Changeset a35b458 in mainline for uspace/drv/bus


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/bus
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/isa/i8237.c

    r3061bc1 ra35b458  
    9999        uint8_t channel_start3;
    100100        uint8_t channel_count3;
    101        
     101
    102102        uint8_t command_status;
    103        
     103
    104104        /** Memory to memory transfers, NOT implemented on PCs */
    105105        uint8_t request;
    … …  
    107107        uint8_t mode;
    108108        uint8_t flip_flop;
    109        
     109
    110110        /*
    111111         * Master reset sets Flip-Flop low, clears status,
    … …  
    136136        uint8_t reserved6;
    137137        uint8_t channel_count7;
    138        
     138
    139139        uint8_t command_status;
    140140        uint8_t reserved8;
    … …  
    230230                        .flip_flop_address = (uint8_t *) 0x0c,
    231231                },
    232                
     232
    233233                /* The second chip 16-bit */
    234234                { /* Channel 4 - Unusable */
    … …  
    265265                },
    266266        },
    267        
     267
    268268        .page_table = NULL,
    269269        .first = NULL,
    … …  
    286286        if (ret != EOK)
    287287                return EIO;
    288        
     288
    289289        ret = pio_enable(DMA_CONTROLLER_FIRST_BASE,
    290290            sizeof(dma_controller_regs_first_t), (void **) &controller->first);
    291291        if (ret != EOK)
    292292                return EIO;
    293        
     293
    294294        ret = pio_enable(DMA_CONTROLLER_SECOND_BASE,
    295295                sizeof(dma_controller_regs_second_t), (void **) &controller->second);
    296296        if (ret != EOK)
    297297                return EIO;
    298        
     298
    299299        controller->initialized = true;
    300        
     300
    301301        /* Reset the controller */
    302302        pio_write_8(&controller->second->master_reset, 0xff);
    303303        pio_write_8(&controller->first->master_reset, 0xff);
    304        
     304
    305305        return EOK;
    306306}
    … …  
    347347        if ((channel == 0) || (channel == 4))
    348348                return ENOTSUP;
    349        
     349
    350350        /* DMA is limited to 24bit addresses. */
    351351        if (pa >= (1 << 24))
    352352                return EINVAL;
    353        
     353
    354354        /* 8 bit channels use only 4 bits from the page register. */
    355355        if (is_dma8(channel) && (pa >= (1 << 20)))
    … …  
    359359        if ((pa & 0xffff0000) != ((pa + size - 1) & 0xffff0000))
    360360                return EINVAL;
    361        
     361
    362362        fibril_mutex_lock(&guard);
    363        
     363
    364364        if (!controller_8237.initialized)
    365365                dma_controller_init(&controller_8237);
    366        
     366
    367367        if (!controller_8237.initialized) {
    368368                fibril_mutex_unlock(&guard);
    369369                return EIO;
    370370        }
    371        
     371
    372372        /* 16 bit transfers are a bit special */
    373373        ddf_msg(LVL_DEBUG, "Unspoiled address %#" PRIx32 " (size %" PRIu32 ")",
    … …  
    384384                pa = ((pa & 0xffff) >> 1) | (pa & 0xff0000);
    385385        }
    386        
     386
    387387        const dma_channel_t dma_channel = controller_8237.channels[channel];
    388        
     388
    389389        ddf_msg(LVL_DEBUG, "Setting channel %u to address %#" PRIx32 " "
    390390            "(size %" PRIu32 "), mode %hhx.", channel, pa, size, mode);
    391        
     391
    392392        /* Mask DMA request */
    393393        uint8_t value = DMA_SINGLE_MASK_CHAN_TO_REG(channel) |
    394394            DMA_SINGLE_MASK_MASKED_FLAG;
    395395        pio_write_8(dma_channel.single_mask_address, value);
    396        
     396
    397397        /* Set mode */
    398398        value = DMA_MODE_CHAN_TO_REG(channel) | mode;
    … …  
    400400            dma_channel.mode_address, value);
    401401        pio_write_8(dma_channel.mode_address, value);
    402        
     402
    403403        /* Set address - reset flip-flop */
    404404        pio_write_8(dma_channel.flip_flop_address, 0);
    405        
     405
    406406        /* Low byte */
    407407        value = pa & 0xff;
    … …  
    409409            dma_channel.offset_reg_address, value);
    410410        pio_write_8(dma_channel.offset_reg_address, value);
    411        
     411
    412412        /* High byte */
    413413        value = (pa >> 8) & 0xff;
    … …  
    415415            dma_channel.offset_reg_address, value);
    416416        pio_write_8(dma_channel.offset_reg_address, value);
    417        
     417
    418418        /* Page address - third byte */
    419419        value = (pa >> 16) & 0xff;
    … …  
    421421            dma_channel.page_reg_address, value);
    422422        pio_write_8(dma_channel.page_reg_address, value);
    423        
     423
    424424        /* Set size - reset flip-flop */
    425425        pio_write_8(dma_channel.flip_flop_address, 0);
    426        
     426
    427427        /* Low byte */
    428428        value = (size - 1) & 0xff;
    … …  
    430430            dma_channel.size_reg_address, value);
    431431        pio_write_8(dma_channel.size_reg_address, value);
    432        
     432
    433433        /* High byte */
    434434        value = ((size - 1) >> 8) & 0xff;
    … …  
    436436            dma_channel.size_reg_address, value);
    437437        pio_write_8(dma_channel.size_reg_address, value);
    438        
     438
    439439        /* Unmask DMA request */
    440440        value = DMA_SINGLE_MASK_CHAN_TO_REG(channel);
    441441        pio_write_8(dma_channel.single_mask_address, value);
    442        
     442
    443443        fibril_mutex_unlock(&guard);
    444        
     444
    445445        return EOK;
    446446}
    … …  
    459459        if (!is_dma8(channel) && !is_dma16(channel))
    460460                return ENOENT;
    461        
     461
    462462        if ((channel == 0) || (channel == 4))
    463463                return ENOTSUP;
    464        
     464
    465465        fibril_mutex_lock(&guard);
    466466        if (!controller_8237.initialized) {
    … …  
    472472        /* Get size - reset flip-flop */
    473473        pio_write_8(dma_channel.flip_flop_address, 0);
    474        
     474
    475475        /* Low byte */
    476476        const uint8_t value_low = pio_read_8(dma_channel.size_reg_address);
    477477        ddf_msg(LVL_DEBUG2, "Read size low byte: %p:%x.",
    478478            dma_channel.size_reg_address, value_low);
    479        
     479
    480480        /* High byte */
    481481        const uint8_t value_high = pio_read_8(dma_channel.size_reg_address);

  • uspace/drv/bus/isa/isa.c

    r3061bc1 ra35b458  
    402402        size_t count = fun->hw_resources.count;
    403403        hw_resource_t *resources = fun->hw_resources.resources;
    404        
     404
    405405        if (count < ISA_MAX_HW_RES) {
    406406                if ((dma > 0) && (dma < 4)) {
    407407                        resources[count].type = DMA_CHANNEL_8;
    408408                        resources[count].res.dma_channel.dma8 = dma;
    409                        
     409
    410410                        fun->hw_resources.count++;
    411411                        ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
    412412                            ddf_fun_get_name(fun->fnode));
    413                        
     413
    414414                        return;
    415415                }
    … …  
    418418                        resources[count].type = DMA_CHANNEL_16;
    419419                        resources[count].res.dma_channel.dma16 = dma;
    420                        
     420
    421421                        fun->hw_resources.count++;
    422422                        ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
    423423                            ddf_fun_get_name(fun->fnode));
    424                        
     424
    425425                        return;
    426426                }
    427                
     427
    428428                ddf_msg(LVL_WARN, "Skipped dma 0x%x for function %s", dma,
    429429                    ddf_fun_get_name(fun->fnode));
    … …  
    492492{
    493493        char *end = NULL;
    494        
     494
    495495        val = skip_spaces(val);
    496496        const int dma = strtol(val, &end, 10);
    497        
     497
    498498        if (val != end)
    499499                isa_fun_add_dma(fun, dma);
    … …  
    733733        if (rc != EOK)
    734734                return rc;
    735        
     735
    736736        rc = pio_window_get(sess, &isa->pio_win);
    737737        if (rc != EOK) {

  • uspace/drv/bus/pci/pciintel/pci.c

    r3061bc1 ra35b458  
    9393{
    9494        pci_fun_t *fun = pci_fun(fnode);
    95        
     95
    9696        if (fun == NULL)
    9797                return NULL;
    … …  
    103103        size_t i;
    104104        hw_resource_list_t *res = &fun->hw_resources;
    105        
     105
    106106        for (i = 0; i < res->count; i++) {
    107107                if (res->resources[i].type == INTERRUPT &&
    … …  
    110110                }
    111111        }
    112        
     112
    113113        return false;
    114114}
    … …  
    117117{
    118118        pci_fun_t *fun = pci_fun(fnode);
    119        
     119
    120120        if (!pciintel_fun_owns_interrupt(fun, irq))
    121121                return EINVAL;
    … …  
    127127{
    128128        pci_fun_t *fun = pci_fun(fnode);
    129        
     129
    130130        if (!pciintel_fun_owns_interrupt(fun, irq))
    131131                return EINVAL;
    … …  
    137137{
    138138        pci_fun_t *fun = pci_fun(fnode);
    139        
     139
    140140        if (!pciintel_fun_owns_interrupt(fun, irq))
    141141                return EINVAL;
    … …  
    147147{
    148148        pci_fun_t *fun = pci_fun(fnode);
    149        
     149
    150150        if (fun == NULL)
    151151                return NULL;
    … …  
    256256        pci_bus_t *bus = pci_bus_from_fun(fun);
    257257        uint32_t val;
    258        
     258
    259259        fibril_mutex_lock(&bus->conf_mutex);
    260260
    … …  
    285285                break;
    286286        }
    287        
     287
    288288        fibril_mutex_unlock(&bus->conf_mutex);
    289289}
    … …  
    294294        pci_bus_t *bus = pci_bus_from_fun(fun);
    295295        uint32_t val = 0;
    296        
     296
    297297        fibril_mutex_lock(&bus->conf_mutex);
    298298
    … …  
    317317                }
    318318        }
    319        
     319
    320320        switch (len) {
    321321        case 1:
    … …  
    340340                    host2uint32_t_le(val));
    341341        }
    342        
     342
    343343        fibril_mutex_unlock(&bus->conf_mutex);
    344344}
    … …  
    458458        hw_resource_t *hw_resources =  hw_res_list->resources;
    459459        size_t count = hw_res_list->count;
    460        
     460
    461461        assert(hw_resources != NULL);
    462462        assert(count < PCI_MAX_HW_RES);
    463        
     463
    464464        if (io) {
    465465                hw_resources[count].type = IO_RANGE;
    … …  
    475475                hw_resources[count].res.mem_range.endianness = LITTLE_ENDIAN;
    476476        }
    477        
     477
    478478        hw_res_list->count++;
    479479}
    … …  
    498498        /* 64-bit wide address */
    499499        bool addrw64;
    500        
     500
    501501        /* Size of the io or memory range specified by the BAR */
    502502        size_t range_size;
    503503        /* Beginning of the io or memory range specified by the BAR */
    504504        uint64_t range_addr;
    505        
     505
    506506        /* Get the value of the BAR. */
    507507        val = pci_conf_read_32(fun, addr);
    … …  
    509509#define IO_MASK  (~0x3)
    510510#define MEM_MASK (~0xf)
    511        
     511
    512512        io = (val & 1) != 0;
    513513        if (io) {
    … …  
    528528                }
    529529        }
    530        
     530
    531531        /* Get the address mask. */
    532532        pci_conf_write_32(fun, addr, 0xffffffff);
    … …  
    544544        pci_conf_write_32(fun, addr, val);
    545545        val = pci_conf_read_32(fun, addr);
    546        
     546
    547547        range_size = pci_bar_mask_to_size(mask);
    548        
     548
    549549        if (addrw64) {
    550550                range_addr = ((uint64_t)pci_conf_read_32(fun, addr + 4) << 32) |
    … …  
    553553                range_addr = (val & 0xfffffff0);
    554554        }
    555        
     555
    556556        if (range_addr != 0) {
    557557                ddf_msg(LVL_DEBUG, "Function %s : address = %" PRIx64
    … …  
    559559                    (unsigned int) range_size);
    560560        }
    561        
     561
    562562        pci_add_range(fun, range_addr, range_size, io);
    563        
     563
    564564        if (addrw64)
    565565                return addr + 8;
    566        
     566
    567567        return addr + 4;
    568568}
    … …  
    573573        hw_resource_t *hw_resources = hw_res_list->resources;
    574574        size_t count = hw_res_list->count;
    575        
     575
    576576        assert(NULL != hw_resources);
    577577        assert(count < PCI_MAX_HW_RES);
    578        
     578
    579579        hw_resources[count].type = INTERRUPT;
    580580        hw_resources[count].res.interrupt.irq = irq;
    581        
     581
    582582        hw_res_list->count++;
    583        
     583
    584584        ddf_msg(LVL_NOTE, "Function %s uses irq %x.", ddf_fun_get_name(fun->fnode), irq);
    585585}
    … …  
    603603        pci_fun_t *fun;
    604604        errno_t rc;
    605        
     605
    606606        int child_bus = 0;
    607607        int dnum, fnum;
    608608        bool multi;
    609609        uint8_t header_type;
    610        
     610
    611611        for (dnum = 0; dnum < 32; dnum++) {
    612612                multi = true;
    613613                for (fnum = 0; multi && fnum < 8; fnum++) {
    614614                        fun = pci_fun_new(bus);
    615                        
     615
    616616                        pci_fun_init(fun, bus_num, dnum, fnum);
    617617                        if (fun->vendor_id == 0xffff) {
    … …  
    626626                                        continue;
    627627                        }
    628                        
     628
    629629                        header_type = pci_conf_read_8(fun, PCI_HEADER_TYPE);
    630630                        if (fnum == 0) {
    … …  
    634634                        /* Clear the multifunction bit. */
    635635                        header_type = header_type & 0x7F;
    636                        
     636
    637637                        char *fun_name = pci_fun_create_name(fun);
    638638                        if (fun_name == NULL) {
    … …  
    641641                                return;
    642642                        }
    643                        
     643
    644644                        rc = ddf_fun_set_name(fun->fnode, fun_name);
    645645                        free(fun_name);
    … …  
    649649                                return;
    650650                        }
    651                        
     651
    652652                        pci_alloc_resource_list(fun);
    653653                        pci_read_bars(fun);
    … …  
    656656                        /* Propagate the PIO window to the function. */
    657657                        fun->pio_window = bus->pio_win;
    658                        
     658
    659659                        ddf_fun_set_ops(fun->fnode, &pci_fun_ops);
    660                        
     660
    661661                        ddf_msg(LVL_DEBUG, "Adding new function %s.",
    662662                            ddf_fun_get_name(fun->fnode));
    663663
    664664                        pci_fun_create_match_ids(fun);
    665                        
     665
    666666                        if (ddf_fun_bind(fun->fnode) != EOK) {
    667667                                pci_clean_resource_list(fun);
    … …  
    669669                                continue;
    670670                        }
    671                        
     671
    672672                        if (header_type == PCI_HEADER_TYPE_BRIDGE ||
    673673                            header_type == PCI_HEADER_TYPE_CARDBUS) {
    … …  
    692692        async_sess_t *sess;
    693693        errno_t rc;
    694        
     694
    695695        ddf_msg(LVL_DEBUG, "pci_dev_add");
    696        
     696
    697697        bus = ddf_dev_data_alloc(dnode, sizeof(pci_bus_t));
    698698        if (bus == NULL) {
    … …  
    704704
    705705        bus->dnode = dnode;
    706        
     706
    707707        sess = ddf_dev_parent_sess_get(dnode);
    708708        if (sess == NULL) {
    … …  
    719719                goto fail;
    720720        }
    721        
     721
    722722        rc = hw_res_get_resource_list(sess, &hw_resources);
    723723        if (rc != EOK) {
    … …  
    727727        }
    728728        got_res = true;
    729        
    730        
     729
     730
    731731        assert(hw_resources.count >= 1);
    732732
    … …  
    745745                        goto fail;
    746746                }
    747                
     747
    748748        } else {
    749749                assert(hw_resources.resources[0].type == IO_RANGE);
    750750                assert(hw_resources.resources[0].res.io_range.size >= 4);
    751        
     751
    752752                assert(hw_resources.resources[1].type == IO_RANGE);
    753753                assert(hw_resources.resources[1].res.io_range.size >= 4);
    754        
     754
    755755                ddf_msg(LVL_DEBUG, "conf_addr = %" PRIx64 ".",
    756756                    hw_resources.resources[0].res.io_range.address);
    757757                ddf_msg(LVL_DEBUG, "data_addr = %" PRIx64 ".",
    758758                    hw_resources.resources[1].res.io_range.address);
    759        
     759
    760760                if (pio_enable_resource(&bus->pio_win,
    761761                    &hw_resources.resources[0],
    … …  
    775775                }
    776776        }
    777        
     777
    778778        /* Make the bus device more visible. It has no use yet. */
    779779        ddf_msg(LVL_DEBUG, "Adding a 'ctl' function");
    780        
     780
    781781        ctl = ddf_fun_create(bus->dnode, fun_exposed, "ctl");
    782782        if (ctl == NULL) {
    … …  
    785785                goto fail;
    786786        }
    787        
     787
    788788        rc = ddf_fun_bind(ctl);
    789789        if (rc != EOK) {
    … …  
    791791                goto fail;
    792792        }
    793        
     793
    794794        /* Enumerate functions. */
    795795        ddf_msg(LVL_DEBUG, "Scanning the bus");
    796796        pci_bus_scan(bus, 0);
    797        
     797
    798798        hw_res_clean_resource_list(&hw_resources);
    799        
     799
    800800        return EOK;
    801        
     801
    802802fail:
    803803        if (got_res)
    804804                hw_res_clean_resource_list(&hw_resources);
    805        
     805
    806806        if (ctl != NULL)
    807807                ddf_fun_destroy(ctl);
    808        
     808
    809809        return rc;
    810810}
    … …  
    831831        pci_fun_t *fun;
    832832        ddf_fun_t *fnode;
    833        
     833
    834834        fnode = ddf_fun_create(bus->dnode, fun_inner, NULL);
    835835        if (fnode == NULL)
    … …  
    852852        fun->vendor_id = pci_conf_read_16(fun, PCI_VENDOR_ID);
    853853        fun->device_id = pci_conf_read_16(fun, PCI_DEVICE_ID);
    854        
     854
    855855        /* Explicitly enable PCI bus mastering */
    856856        fun->command = pci_conf_read_16(fun, PCI_COMMAND) |
    857857            PCI_COMMAND_MASTER;
    858858        pci_conf_write_16(fun, PCI_COMMAND, fun->command);
    859        
     859
    860860        fun->class_code = pci_conf_read_8(fun, PCI_BASE_CLASS);
    861861        fun->subclass_code = pci_conf_read_8(fun, PCI_SUB_CLASS);
    … …  
    874874{
    875875        char *name = NULL;
    876        
     876
    877877        asprintf(&name, "%02x:%02x.%01x", fun->bus, fun->dev,
    878878            fun->fn);
    … …  
    903903         */
    904904        int addr = PCI_BASE_ADDR_0;
    905        
     905
    906906        while (addr <= PCI_BASE_ADDR_5)
    907907                addr = pci_read_bar(fun, addr);

  • uspace/drv/bus/usb/ehci/ehci_bus.h

    r3061bc1 ra35b458  
    5151        /** EHCI endpoint descriptor, backed by dma_buffer */
    5252        qh_t *qh;
    53        
     53
    5454        dma_buffer_t dma_buffer;
    5555

  • uspace/drv/bus/usb/ohci/hc.h

    r3061bc1 ra35b458  
    6464        /** Memory mapped I/O registers area */
    6565        ohci_regs_t *registers;
    66        
     66
    6767        /** Host controller communication area structure */
    6868        hcca_t *hcca;

  • uspace/drv/bus/usb/ohci/ohci_rh.c

    r3061bc1 ra35b458  
    409409        TEST_SIZE_INIT(0, port, hub);
    410410        const unsigned feature = uint16_usb2host(setup_packet->value);
    411        
     411
    412412        switch (feature) {
    413413        case USB_HUB_FEATURE_PORT_POWER:   /*8*/
    414414                {
    415415                        const uint32_t rhda = OHCI_RD(hub->registers->rh_desc_a);
    416                        
     416
    417417                        /* No power switching */
    418418                        if (rhda & RHDA_NPS_FLAG)
    419419                                return EOK;
    420                        
     420
    421421                        /* Ganged power switching, one port powers all */
    422422                        if (!(rhda & RHDA_PSM_FLAG)) {

  • uspace/drv/bus/usb/usbhub/port.c

    r3061bc1 ra35b458  
    8787                return;
    8888        }
    89        
     89
    9090        const errno_t err = usbhc_device_remove(exch, port->port_number);
    9191        if (err)

  • uspace/drv/bus/usb/usbmid/explore.c

    r3061bc1 ra35b458  
    164164                return rc;
    165165        }
    166        
     166
    167167        /* Create driver soft-state. */
    168168        usb_mid_t *usb_mid = usb_device_data_alloc(dev, sizeof(usb_mid_t));

  • uspace/drv/bus/usb/vhc/conndev.c

    r3061bc1 ra35b458  
    5757{
    5858        async_exch_t *exch = async_exchange_begin(sess);
    59        
     59
    6060        aid_t opening_request = async_send_0(exch, IPC_M_USBVIRT_GET_NAME, NULL);
    6161        if (opening_request == 0) {
    … …  
    6363                return;
    6464        }
    65        
     65
    6666        ipc_call_t data_request_call;
    6767        aid_t data_request = async_data_read(exch, plugged_device_name,
    6868             PLUGGED_DEVICE_NAME_MAXLEN, &data_request_call);
    69        
     69
    7070        async_exchange_end(exch);
    71        
     71
    7272        if (data_request == 0) {
    7373                async_forget(opening_request);
    7474                return;
    7575        }
    76        
     76
    7777        errno_t data_request_rc;
    7878        errno_t opening_request_rc;
    7979        async_wait_for(data_request, &data_request_rc);
    8080        async_wait_for(opening_request, &opening_request_rc);
    81        
     81
    8282        if ((data_request_rc != EOK) || (opening_request_rc != EOK))
    8383                return;
    84        
     84
    8585        size_t len = IPC_GET_ARG2(data_request_call);
    8686        plugged_device_name[len] = 0;
    … …  
    9797{
    9898        vhc_data_t *vhc = ddf_fun_data_get(fun);
    99        
     99
    100100        async_sess_t *callback =
    101101            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
    102        
     102
    103103        if (callback) {
    104104                errno_t rc = vhc_virtdev_plug(vhc, callback, &plugged_device_handle);
    … …  
    108108                        return;
    109109                }
    110                
     110
    111111                async_answer_0(icallid, EOK);
    112                
     112
    113113                receive_device_name(callback);
    114                
     114
    115115                usb_log_info("New virtual device `%s' (id: %" PRIxn ").",
    116116                    plugged_device_name, plugged_device_handle);

  • uspace/drv/bus/usb/vhc/hub/virthubops.c

    r3061bc1 ra35b458  
    7373                return ESTALL;
    7474        }
    75        
     75
    7676        hub_t *hub = dev->device_data;
    7777
    … …  
    9494                *actual_size = 0;
    9595        }
    96        
     96
    9797        hub->signal_changes = false;
    9898

  • uspace/drv/bus/usb/vhc/transfer.c

    r3061bc1 ra35b458  
    228228
    229229        fibril_mutex_unlock(&vhc->guard);
    230        
     230
    231231        if (targets > 1)
    232232                usb_log_warning("Transfer would be accepted by more devices!");

  • uspace/drv/bus/usb/xhci/debug.c

    r3061bc1 ra35b458  
    301301        static const char speed_exp [] = " KMG";
    302302        static const char *psi_types [] = { "", " rsvd", " RX", " TX" };
    303        
     303
    304304        usb_log_debug("Speed %u%s: %5u %cb/s, %s",
    305305            XHCI_REG_RD(psi, XHCI_PSI_PSIV),

  • uspace/drv/bus/usb/xhci/rh.c

    r3061bc1 ra35b458  
    273273                if (status != 0)
    274274                        usb_log_debug("RH port %u change not handled: 0x%x", port_id, status);
    275                
     275
    276276                /* Make sure that PSCEG is 0 before exiting the loop. */
    277277                status = XHCI_REG_RD_FIELD(&port->regs->portsc, 32);
Note: See TracChangeset for help on using the changeset viewer.