Changeset 8565a42 in mainline for uspace/drv/char


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
uspace/drv/char
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/char/i8042/i8042.c

    r3061bc1 r8565a42  
    130130        i8042_t *controller = ddf_dev_data_get(dev);
    131131        errno_t rc;
    132        
     132
    133133        const uint8_t status = IPC_GET_ARG1(*call);
    134134        const uint8_t data = IPC_GET_ARG2(*call);
    135        
     135
    136136        i8042_port_t *port = (status & i8042_AUX_DATA) ?
    137137            controller->aux : controller->kbd;
    138        
     138
    139139        fibril_mutex_lock(&port->buf_lock);
    140        
     140
    141141        rc = circ_buf_push(&port->cbuf, &data);
    142142        if (rc != EOK)
    … …  
    169169        ddf_fun_t *aux_fun;
    170170        i8042_regs_t *ar;
    171        
     171
    172172        errno_t rc;
    173173        bool kbd_bound = false;
    174174        bool aux_bound = false;
    175        
     175
    176176        if (regs->size < sizeof(i8042_regs_t)) {
    177177                rc = EINVAL;
    178178                goto error;
    179179        }
    180        
     180
    181181        if (pio_enable_range(regs, (void **) &dev->regs) != 0) {
    182182                rc = EIO;
    183183                goto error;
    184184        }
    185        
     185
    186186        kbd_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2a");
    187187        if (kbd_fun == NULL) {
    … …  
    189189                goto error;
    190190        };
    191        
     191
    192192        dev->kbd = ddf_fun_data_alloc(kbd_fun, sizeof(i8042_port_t));
    193193        if (dev->kbd == NULL) {
    … …  
    195195                goto error;
    196196        }
    197        
     197
    198198        dev->kbd->fun = kbd_fun;
    199199        dev->kbd->ctl = dev;
    … …  
    203203        fibril_mutex_initialize(&dev->kbd->buf_lock);
    204204        fibril_condvar_initialize(&dev->kbd->buf_cv);
    205        
     205
    206206        rc = ddf_fun_add_match_id(dev->kbd->fun, "char/xtkbd", 90);
    207207        if (rc != EOK)
    208208                goto error;
    209        
     209
    210210        aux_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2b");
    211211        if (aux_fun == NULL) {
    … …  
    213213                goto error;
    214214        }
    215        
     215
    216216        dev->aux = ddf_fun_data_alloc(aux_fun, sizeof(i8042_port_t));
    217217        if (dev->aux == NULL) {
    … …  
    219219                goto error;
    220220        }
    221        
     221
    222222        dev->aux->fun = aux_fun;
    223223        dev->aux->ctl = dev;
    … …  
    227227        fibril_mutex_initialize(&dev->aux->buf_lock);
    228228        fibril_condvar_initialize(&dev->aux->buf_cv);
    229        
     229
    230230        rc = ddf_fun_add_match_id(dev->aux->fun, "char/ps2mouse", 90);
    231231        if (rc != EOK)
    232232                goto error;
    233        
     233
    234234        ddf_fun_set_conn_handler(dev->kbd->fun, i8042_char_conn);
    235235        ddf_fun_set_conn_handler(dev->aux->fun, i8042_char_conn);
    236        
     236
    237237        circ_buf_init(&dev->kbd->cbuf, dev->kbd->buf_data, BUFFER_SIZE, 1);
    238238        circ_buf_init(&dev->aux->cbuf, dev->aux->buf_data, BUFFER_SIZE, 1);
    239239        fibril_mutex_initialize(&dev->write_guard);
    240        
     240
    241241        rc = ddf_fun_bind(dev->kbd->fun);
    242242        if (rc != EOK) {
    … …  
    246246        }
    247247        kbd_bound = true;
    248        
     248
    249249        rc = ddf_fun_bind(dev->aux->fun);
    250250        if (rc != EOK) {
    … …  
    254254        }
    255255        aux_bound = true;
    256        
     256
    257257        /* Disable kbd and aux */
    258258        wait_ready(dev);
    … …  
    260260        wait_ready(dev);
    261261        pio_write_8(&dev->regs->data, i8042_KBD_DISABLE | i8042_AUX_DISABLE);
    262        
     262
    263263        /* Flush all current IO */
    264264        while (pio_read_8(&dev->regs->status) & i8042_OUTPUT_FULL)
    … …  
    280280                .cmds = cmds
    281281        };
    282        
     282
    283283        int irq_kbd_cap;
    284284        rc = register_interrupt_handler(ddf_dev, irq_kbd,
    … …  
    289289                goto error;
    290290        }
    291        
     291
    292292        int irq_mouse_cap;
    293293        rc = register_interrupt_handler(ddf_dev, irq_mouse,
    … …  
    298298                goto error;
    299299        }
    300        
     300
    301301        /* Enable interrupts */
    302302        async_sess_t *parent_sess = ddf_dev_parent_sess_get(ddf_dev);
    303303        assert(parent_sess != NULL);
    304        
     304
    305305        rc = hw_res_enable_interrupt(parent_sess, irq_kbd);
    306306        if (rc != EOK) {
    … …  
    318318                goto error;
    319319        }
    320        
     320
    321321        /* Enable port interrupts. */
    322322        wait_ready(dev);
    … …  
    325325        pio_write_8(&dev->regs->data, i8042_KBD_IE | i8042_KBD_TRANSLATE |
    326326            i8042_AUX_IE);
    327        
     327
    328328        return EOK;
    329329error:
    … …  
    356356        i8042_t *i8042 = port->ctl;
    357357        const char *dp = (const char *)data;
    358        
     358
    359359        fibril_mutex_lock(&i8042->write_guard);
    360        
     360
    361361        for (size_t i = 0; i < size; ++i) {
    362362                if (port == i8042->aux) {
    … …  
    365365                            i8042_CMD_WRITE_AUX);
    366366                }
    367                
     367
    368368                wait_ready(i8042);
    369369                pio_write_8(&i8042->regs->data, dp[i]);
    370370        }
    371        
     371
    372372        fibril_mutex_unlock(&i8042->write_guard);
    373373        *nwr = size;
    … …  
    392392        uint8_t *destp = (uint8_t *)dest;
    393393        errno_t rc;
    394        
     394
    395395        fibril_mutex_lock(&port->buf_lock);
    396        
     396
    397397        while (circ_buf_nused(&port->cbuf) == 0)
    398398                fibril_condvar_wait(&port->buf_cv, &port->buf_lock);

  • uspace/drv/char/i8042/main.c

    r3061bc1 r8565a42  
    5959{
    6060        assert(dev);
    61        
     61
    6262        async_sess_t *parent_sess = ddf_dev_parent_sess_get(dev);
    6363        if (parent_sess == NULL)
    6464                return ENOMEM;
    65        
     65
    6666        hw_res_list_parsed_t hw_resources;
    6767        hw_res_list_parsed_init(&hw_resources);
    … …  
    6969        if (ret != EOK)
    7070                return ret;
    71        
     71
    7272        if ((hw_resources.irqs.count != 2) ||
    7373            (hw_resources.io_ranges.count != 1)) {
    … …  
    7575                return EINVAL;
    7676        }
    77        
     77
    7878        if (p_io_reg)
    7979                *p_io_reg = hw_resources.io_ranges.ranges[0];
    80        
     80
    8181        if (kbd_irq)
    8282                *kbd_irq = hw_resources.irqs.irqs[0];
    83        
     83
    8484        if (mouse_irq)
    8585                *mouse_irq = hw_resources.irqs.irqs[1];
    86        
     86
    8787        hw_res_list_parsed_clean(&hw_resources);
    8888        return EOK;
    … …  
    102102        int mouse = 0;
    103103        errno_t rc;
    104        
     104
    105105        if (!device)
    106106                return EINVAL;
    107        
     107
    108108        rc = get_my_registers(device, &io_regs, &kbd, &mouse);
    109109        if (rc != EOK) {
    … …  
    112112                return rc;
    113113        }
    114        
     114
    115115        ddf_msg(LVL_DEBUG,
    116116            "I/O regs at %p (size %zuB), IRQ kbd %d, IRQ mouse %d.",
    117117            RNGABSPTR(io_regs), RNGSZ(io_regs), kbd, mouse);
    118        
     118
    119119        i8042_t *i8042 = ddf_dev_data_alloc(device, sizeof(i8042_t));
    120120        if (i8042 == NULL) {
    … …  
    122122                return ENOMEM;
    123123        }
    124        
     124
    125125        rc = i8042_init(i8042, &io_regs, kbd, mouse, device);
    126126        if (rc != EOK) {
    … …  
    129129                return rc;
    130130        }
    131        
     131
    132132        ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
    133133            ddf_dev_get_name(device), ddf_dev_get_handle(device));
    … …  
    150150        printf("%s: HelenOS PS/2 driver.\n", NAME);
    151151        ddf_log_init(NAME);
    152        
     152
    153153        return ddf_driver_main(&i8042_driver);
    154154}

  • uspace/drv/char/ns8250/cyclic_buffer.h

    r3061bc1 r8565a42  
    6565{
    6666        assert(!buf_is_empty(buf));
    67        
     67
    6868        uint8_t res = buf->buf[buf->start];
    6969        buf->start = (buf->start + 1) % BUF_LEN;

  • uspace/drv/char/ns8250/ns8250.c

    r3061bc1 r8565a42  
    238238        while (!is_transmit_empty(regs))
    239239                ;
    240        
     240
    241241        pio_write_8(&regs->data, c);
    242242}
    … …  
    256256        char *bp = (char *) buf;
    257257        size_t pos = 0;
    258        
     258
    259259        if (count == 0) {
    260260                *nread = 0;
    261261                return EOK;
    262262        }
    263        
     263
    264264        fibril_mutex_lock(&ns->mutex);
    265265        while (buf_is_empty(&ns->input_buffer))
    … …  
    270270        }
    271271        fibril_mutex_unlock(&ns->mutex);
    272        
     272
    273273        *nread = pos;
    274274        return EOK;
    … …  
    301301        size_t idx;
    302302        uint8_t *bp = (uint8_t *) buf;
    303        
     303
    304304        for (idx = 0; idx < count; idx++)
    305305                ns8250_putchar(ns, bp[idx]);
    306        
     306
    307307        *nwritten = count;
    308308        return EOK;
    … …  
    355355{
    356356        ddf_msg(LVL_DEBUG, "ns8250_pio_enable %s", ddf_dev_get_name(ns->dev));
    357        
     357
    358358        /* Gain control over port's registers. */
    359359        if (pio_enable((void *) ns->io_addr, REG_COUNT,
    … …  
    365365
    366366        ns->regs = (ns8250_regs_t *)ns->port;
    367        
     367
    368368        return true;
    369369}
    … …  
    377377{
    378378        ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ddf_dev_get_name(ns->dev));
    379        
     379
    380380        bool res = true;
    381381        uint8_t olddata;
    382        
     382
    383383        olddata = pio_read_8(&ns->regs->mcr);
    384        
     384
    385385        pio_write_8(&ns->regs->mcr, NS8250_MCR_LOOPBACK);
    386386        if (pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS)
    387387                res = false;
    388        
     388
    389389        pio_write_8(&ns->regs->mcr, NS8250_MCR_ALL);
    390390        if ((pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS)
    391391            != NS8250_MSR_SIGNALS)
    392392                res = false;
    393        
     393
    394394        pio_write_8(&ns->regs->mcr, olddata);
    395        
     395
    396396        if (!res) {
    397397                ddf_msg(LVL_DEBUG, "Device %s is not present.",
    398398                    ddf_dev_get_name(ns->dev));
    399399        }
    400        
     400
    401401        return res;
    402402}
    … …  
    410410{
    411411        errno_t ret = EOK;
    412        
     412
    413413        ddf_msg(LVL_DEBUG, "ns8250_dev_initialize %s", ddf_dev_get_name(ns->dev));
    414        
     414
    415415        hw_resource_list_t hw_resources;
    416416        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
    417        
     417
    418418        /* Get hw resources. */
    419419        ret = hw_res_get_resource_list(ns->parent_sess, &hw_resources);
    … …  
    423423                goto failed;
    424424        }
    425        
     425
    426426        size_t i;
    427427        hw_resource_t *res;
    428428        bool irq = false;
    429429        bool ioport = false;
    430        
     430
    431431        for (i = 0; i < hw_resources.count; i++) {
    432432                res = &hw_resources.resources[i];
    … …  
    438438                            ddf_dev_get_name(ns->dev), ns->irq);
    439439                        break;
    440                        
     440
    441441                case IO_RANGE:
    442442                        ns->io_addr = res->res.io_range.address;
    … …  
    451451                            "0x%#" PRIxn ".", ddf_dev_get_name(ns->dev), ns->io_addr);
    452452                        break;
    453                        
     453
    454454                default:
    455455                        break;
    456456                }
    457457        }
    458        
     458
    459459        if (!irq || !ioport) {
    460460                ddf_msg(LVL_ERROR, "Missing HW resource(s) for device %s.",
    … …  
    463463                goto failed;
    464464        }
    465        
     465
    466466        hw_res_clean_resource_list(&hw_resources);
    467467        return ret;
    468        
     468
    469469failed:
    470470        ns8250_dev_cleanup(ns);
    … …  
    507507        if (rc != EOK)
    508508                return EIO;
    509        
     509
    510510        /* Read LSR to clear possible previous LSR interrupt */
    511511        pio_read_8(&ns->regs->lsr);
    512        
     512
    513513        /* Enable interrupt on the serial port. */
    514514        ns8250_port_interrupts_enable(ns->regs);
    515        
     515
    516516        return EOK;
    517517}
    … …  
    551551        uint16_t divisor;
    552552        uint8_t div_low, div_high;
    553        
     553
    554554        if (baud_rate < 50 || MAX_BAUD_RATE % baud_rate != 0) {
    555555                ddf_msg(LVL_ERROR, "Invalid baud rate %d requested.",
    … …  
    557557                return EINVAL;
    558558        }
    559        
     559
    560560        divisor = MAX_BAUD_RATE / baud_rate;
    561561        div_low = (uint8_t)divisor;
    562562        div_high = (uint8_t)(divisor >> 8);
    563        
     563
    564564        /* Enable DLAB to be able to access baud rate divisor. */
    565565        enable_dlab(regs);
    566        
     566
    567567        /* Set divisor low byte. */
    568568        pio_write_8(&regs->data, div_low);
    569569        /* Set divisor high byte. */
    570570        pio_write_8(&regs->ier, div_high);
    571        
     571
    572572        clear_dlab(regs);
    573        
     573
    574574        return EOK;
    575575}
    … …  
    584584        uint16_t divisor;
    585585        uint8_t div_low, div_high;
    586        
     586
    587587        /* Enable DLAB to be able to access baud rate divisor. */
    588588        enable_dlab(regs);
    589        
     589
    590590        /* Get divisor low byte. */
    591591        div_low = pio_read_8(&regs->data);
    592592        /* Get divisor high byte. */
    593593        div_high = pio_read_8(&regs->ier);
    594        
     594
    595595        clear_dlab(regs);
    596        
     596
    597597        divisor = (div_high << 8) | div_low;
    598598        return MAX_BAUD_RATE / divisor;
    … …  
    610610{
    611611        uint8_t val;
    612        
     612
    613613        val = pio_read_8(&regs->lcr);
    614614        *parity = ((val >> NS8250_LCR_PARITY) & 7);
    615        
     615
    616616        /* Silence warnings */
    617617        *word_length = 0;
    … …  
    631631                break;
    632632        }
    633        
     633
    634634        if ((val >> NS8250_LCR_STOPBITS) & 1)
    635635                *stop_bits = 2;
    … …  
    650650{
    651651        uint8_t val;
    652        
     652
    653653        switch (word_length) {
    654654        case 5:
    … …  
    667667                return EINVAL;
    668668        }
    669        
     669
    670670        switch (stop_bits) {
    671671        case 1:
    … …  
    678678                return EINVAL;
    679679        }
    680        
     680
    681681        switch (parity) {
    682682        case SERIAL_NO_PARITY:
    … …  
    690690                return EINVAL;
    691691        }
    692        
     692
    693693        pio_write_8(&regs->lcr, val);
    694        
     694
    695695        return EOK;
    696696}
    … …  
    748748        ns8250_regs_t *regs = ns->regs;
    749749        bool cont = true;
    750        
     750
    751751        fibril_mutex_lock(&ns->mutex);
    752752        while (cont) {
    … …  
    754754                if (cont) {
    755755                        uint8_t val = ns8250_read_8(regs);
    756                        
     756
    757757                        if (ns->client_connections > 0) {
    758758                                bool buf_was_empty = buf_is_empty(&ns->input_buffer);
    … …  
    794794                }
    795795        }
    796        
     796
    797797        ns8250_read_from_device(ns);
    798798        hw_res_clear_interrupt(ns->parent_sess, ns->irq);
    … …  
    832832        bool need_unreg_intr_handler = false;
    833833        errno_t rc;
    834        
     834
    835835        ddf_msg(LVL_DEBUG, "ns8250_dev_add %s (handle = %d)",
    836836            ddf_dev_get_name(dev), (int) ddf_dev_get_handle(dev));
    837        
     837
    838838        /* Allocate soft-state for the device */
    839839        ns = ddf_dev_data_alloc(dev, sizeof(ns8250_t));
    … …  
    842842                goto fail;
    843843        }
    844        
     844
    845845        fibril_mutex_initialize(&ns->mutex);
    846846        fibril_condvar_initialize(&ns->input_buffer_available);
    847847        ns->dev = dev;
    848        
     848
    849849        ns->parent_sess = ddf_dev_parent_sess_get(ns->dev);
    850850        if (ns->parent_sess == NULL) {
    … …  
    854854                goto fail;
    855855        }
    856        
     856
    857857        rc = ns8250_dev_initialize(ns);
    858858        if (rc != EOK)
    859859                goto fail;
    860        
     860
    861861        need_cleanup = true;
    862        
     862
    863863        if (!ns8250_pio_enable(ns)) {
    864864                rc = EADDRNOTAVAIL;
    865865                goto fail;
    866866        }
    867        
     867
    868868        /* Find out whether the device is present. */
    869869        if (!ns8250_dev_probe(ns)) {
    … …  
    871871                goto fail;
    872872        }
    873        
     873
    874874        /* Serial port initialization (baud rate etc.). */
    875875        ns8250_initialize_port(ns);
    876        
     876
    877877        /* Register interrupt handler. */
    878878        rc = ns8250_register_interrupt_handler(ns, &ns->irq_cap);
    … …  
    891891                goto fail;
    892892        }
    893        
     893
    894894        fun = ddf_fun_create(dev, fun_exposed, "a");
    895895        if (fun == NULL) {
    … …  
    897897                goto fail;
    898898        }
    899        
     899
    900900        ddf_fun_set_conn_handler(fun, ns8250_char_conn);
    901        
     901
    902902        chardev_srvs_init(&ns->cds);
    903903        ns->cds.ops = &ns8250_chardev_ops;
    904904        ns->cds.sarg = ns;
    905        
     905
    906906        rc = ddf_fun_bind(fun);
    907907        if (rc != EOK) {
    … …  
    911911
    912912        ns->fun = fun;
    913        
     913
    914914        ddf_fun_add_to_category(fun, "serial");
    915        
     915
    916916        ddf_msg(LVL_NOTE, "Device %s successfully initialized.",
    917917            ddf_dev_get_name(dev));
    918        
     918
    919919        return EOK;
    920920fail:
    … …  
    932932        ns8250_t *ns = dev_ns8250(dev);
    933933        errno_t rc;
    934        
     934
    935935        fibril_mutex_lock(&ns->mutex);
    936936        if (ns->client_connections > 0) {
    … …  
    940940        ns->removed = true;
    941941        fibril_mutex_unlock(&ns->mutex);
    942        
     942
    943943        rc = ddf_fun_unbind(ns->fun);
    944944        if (rc != EOK) {
    … …  
    946946                return rc;
    947947        }
    948        
     948
    949949        ddf_fun_destroy(ns->fun);
    950        
     950
    951951        ns8250_port_cleanup(ns);
    952952        ns8250_unregister_interrupt_handler(ns);
    … …  
    967967        ns8250_t *ns = srv_ns8250(srv);
    968968        errno_t res;
    969        
     969
    970970        fibril_mutex_lock(&ns->mutex);
    971971        if (ns->removed) {
    … …  
    976976        }
    977977        fibril_mutex_unlock(&ns->mutex);
    978        
     978
    979979        return res;
    980980}
    … …  
    990990{
    991991        ns8250_t *data = srv_ns8250(srv);
    992        
     992
    993993        fibril_mutex_lock(&data->mutex);
    994        
     994
    995995        assert(data->client_connections > 0);
    996        
     996
    997997        if (!(--data->client_connections))
    998998                buf_clear(&data->input_buffer);
    999        
     999
    10001000        fibril_mutex_unlock(&data->mutex);
    1001        
     1001
    10021002        return EOK;
    10031003}
    … …  
    10181018        ns8250_t *data = dev_ns8250(dev);
    10191019        ns8250_regs_t *regs = data->regs;
    1020        
     1020
    10211021        fibril_mutex_lock(&data->mutex);
    10221022        ns8250_port_interrupts_disable(regs);
    … …  
    10251025        ns8250_port_interrupts_enable(regs);
    10261026        fibril_mutex_unlock(&data->mutex);
    1027        
     1027
    10281028        ddf_msg(LVL_DEBUG, "ns8250_get_props: baud rate %d, parity 0x%x, word "
    10291029            "length %d, stop bits %d", *baud_rate, *parity, *word_length,
    … …  
    10461046            "length %d, stop bits %d", baud_rate, parity, word_length,
    10471047            stop_bits);
    1048        
     1048
    10491049        ns8250_t *data = dev_ns8250(dev);
    10501050        ns8250_regs_t *regs = data->regs;
    10511051        errno_t ret;
    1052        
     1052
    10531053        fibril_mutex_lock(&data->mutex);
    10541054        ns8250_port_interrupts_disable(regs);
    … …  
    10581058        ns8250_port_interrupts_enable(regs);
    10591059        fibril_mutex_unlock(&data->mutex);
    1060        
     1060
    10611061        return ret;
    10621062}
    … …  
    10741074        errno_t ret;
    10751075        unsigned int baud_rate, parity, word_length, stop_bits;
    1076        
     1076
    10771077        switch (method) {
    10781078        case SERIAL_GET_COM_PROPS:
    … …  
    10821082                    stop_bits);
    10831083                break;
    1084                
     1084
    10851085        case SERIAL_SET_COM_PROPS:
    10861086                baud_rate = IPC_GET_ARG1(*call);
    … …  
    10921092                async_answer_0(callid, ret);
    10931093                break;
    1094                
     1094
    10951095        default:
    10961096                async_answer_0(callid, ENOTSUP);
Note: See TracChangeset for help on using the changeset viewer.