Changeset 8565a42 in mainline for uspace/drv/bus


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/fix-logger-deadlock, 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/bus
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

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