Changeset a35b458 in mainline for uspace/drv/char


Ignore:
Timestamp:
2018-03-02T20:10:49Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/drv/char
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 ra35b458  
    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 ra35b458  
    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 ra35b458  
    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 ra35b458  
    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.