Changeset 90478727 in mainline for uspace/drv


Ignore:
Timestamp:
2012-08-12T11:46:44Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
41b764b7
Parents:
e1e4192 (diff), 371cb6c (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.
Message:

merge mainline changes

Location:
uspace/drv
Files:
6 added
55 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/block/ahci/Makefile

    re1e4192 r90478727  
    11#
    2 # Copyright (c) 2011 Vojtech Horky
     2# Copyright (c) 2012 Petr Jerman
    33# All rights reserved.
    44#
    … …  
    2727#
    2828
    29 USPACE_PREFIX = ../..
    30 BINARY = lsusb
    31 
    32 LIBS = \
    33         $(LIBUSBDEV_PREFIX)/libusbdev.a \
    34         $(LIBUSB_PREFIX)/libusb.a \
    35         $(LIBDRV_PREFIX)/libdrv.a
    36 EXTRA_CFLAGS = \
    37         -I$(LIBUSB_PREFIX)/include \
    38         -I$(LIBUSBDEV_PREFIX)/include \
    39         -I$(LIBDRV_PREFIX)/include
     29USPACE_PREFIX = ../../..
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include
     32BINARY = ahci
    4033
    4134SOURCES = \
    42         main.c
     35        ahci.c
    4336
    4437include $(USPACE_PREFIX)/Makefile.common

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

    re1e4192 r90478727  
    201201
    202202        isa_fun_t *fun = ddf_fun_data_alloc(fnode, sizeof(isa_fun_t));
    203         if (fun == NULL)
     203        if (fun == NULL) {
     204                ddf_fun_destroy(fnode);
    204205                return NULL;
     206        }
    205207
    206208        fibril_mutex_initialize(&fun->mutex);
    … …  
    552554
    553555        isa_fun_t *fun = isa_fun_create(isa, fun_name);
     556        free(fun_name);
    554557        if (fun == NULL) {
    555                 free(fun_name);
    556558                return NULL;
    557559        }

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

    re1e4192 r90478727  
    3838
    3939#include <assert.h>
     40#include <byteorder.h>
    4041#include <stdio.h>
    4142#include <errno.h>
    … …  
    231232        void *addr = bus->conf_data_port + (reg & 3);
    232233       
    233         pio_write_32(bus->conf_addr_port, conf_addr);
     234        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
    234235       
    235236        switch (len) {
    236237        case 1:
     238                /* No endianness change for 1 byte */
    237239                buf[0] = pio_read_8(addr);
    238240                break;
    239241        case 2:
    240                 ((uint16_t *) buf)[0] = pio_read_16(addr);
     242                ((uint16_t *) buf)[0] = uint16_t_le2host(pio_read_16(addr));
    241243                break;
    242244        case 4:
    243                 ((uint32_t *) buf)[0] = pio_read_32(addr);
     245                ((uint32_t *) buf)[0] = uint32_t_le2host(pio_read_32(addr));
    244246                break;
    245247        }
    … …  
    254256        fibril_mutex_lock(&bus->conf_mutex);
    255257       
    256         uint32_t conf_addr;
    257         conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
     258        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
    258259        void *addr = bus->conf_data_port + (reg & 3);
    259260       
    260         pio_write_32(bus->conf_addr_port, conf_addr);
     261        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
    261262       
    262263        switch (len) {
    263264        case 1:
     265                /* No endianness change for 1 byte */
    264266                pio_write_8(addr, buf[0]);
    265267                break;
    266268        case 2:
    267                 pio_write_16(addr, ((uint16_t *) buf)[0]);
     269                pio_write_16(addr, host2uint16_t_le(((uint16_t *) buf)[0]));
    268270                break;
    269271        case 4:
    270                 pio_write_32(addr, ((uint32_t *) buf)[0]);
     272                pio_write_32(addr, host2uint32_t_le(((uint32_t *) buf)[0]));
    271273                break;
    272274        }
    … …  
    650652        got_res = true;
    651653       
     654       
     655        assert(hw_resources.count > 1);
     656        assert(hw_resources.resources[0].type == IO_RANGE);
     657        assert(hw_resources.resources[0].res.io_range.size >= 4);
     658       
     659        assert(hw_resources.resources[1].type == IO_RANGE);
     660        assert(hw_resources.resources[1].res.io_range.size >= 4);
     661       
    652662        ddf_msg(LVL_DEBUG, "conf_addr = %" PRIx64 ".",
    653663            hw_resources.resources[0].res.io_range.address);
    654        
    655         assert(hw_resources.count > 0);
    656         assert(hw_resources.resources[0].type == IO_RANGE);
    657         assert(hw_resources.resources[0].res.io_range.size == 8);
     664        ddf_msg(LVL_DEBUG, "data_addr = %" PRIx64 ".",
     665            hw_resources.resources[1].res.io_range.address);
    658666       
    659667        bus->conf_io_addr =
    660668            (uint32_t) hw_resources.resources[0].res.io_range.address;
    661        
    662         if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8,
     669        bus->conf_io_data =
     670            (uint32_t) hw_resources.resources[1].res.io_range.address;
     671       
     672        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 4,
    663673            &bus->conf_addr_port)) {
    664674                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
    … …  
    666676                goto fail;
    667677        }
    668         bus->conf_data_port = (char *) bus->conf_addr_port + 4;
     678        if (pio_enable((void *)(uintptr_t)bus->conf_io_data, 4,
     679            &bus->conf_data_port)) {
     680                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
     681                rc = EADDRNOTAVAIL;
     682                goto fail;
     683        }
    669684       
    670685        /* Make the bus device more visible. It has no use yet. */

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

    re1e4192 r90478727  
    4646        ddf_dev_t *dnode;
    4747        uint32_t conf_io_addr;
     48        uint32_t conf_io_data;
    4849        void *conf_data_port;
    4950        void *conf_addr_port;

  • uspace/drv/bus/usb/ehci/main.c

    re1e4192 r90478727  
    4949
    5050static int ehci_dev_add(ddf_dev_t *device);
    51 /*----------------------------------------------------------------------------*/
     51
    5252static driver_ops_t ehci_driver_ops = {
    5353        .dev_add = ehci_dev_add,
    5454};
    55 /*----------------------------------------------------------------------------*/
     55
    5656static driver_t ehci_driver = {
    5757        .name = NAME,
    … …  
    6262};
    6363
    64 /*----------------------------------------------------------------------------*/
     64
    6565/** Initializes a new ddf driver instance of EHCI hcd.
    6666 *
    … …  
    121121#undef CHECK_RET_RETURN
    122122}
    123 /*----------------------------------------------------------------------------*/
     123
    124124/** Initializes global driver structures (NONE).
    125125 *

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

    re1e4192 r90478727  
    6565        return EOK;
    6666}
    67 /*----------------------------------------------------------------------------*/
     67
    6868/** Set the next list in transfer list chain.
    6969 *
    … …  
    8080        ed_append_ed(instance->list_head, next->list_head);
    8181}
    82 /*----------------------------------------------------------------------------*/
     82
    8383/** Add endpoint to the list and queue.
    8484 *
    … …  
    132132        fibril_mutex_unlock(&instance->guard);
    133133}
    134 /*----------------------------------------------------------------------------*/
     134
    135135/** Remove endpoint from the list and queue.
    136136 *
    … …  
    162162                qpos = "NOT FIRST";
    163163        }
    164         assert((prev_ed->next & ED_NEXT_PTR_MASK) == addr_to_phys(ep->ed));
     164        assert(ed_next(prev_ed) == addr_to_phys(ep->ed));
    165165        prev_ed->next = ep->ed->next;
    166166        /* Make sure ED is updated */

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

    re1e4192 r90478727  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
    2829/** @addtogroup drvusbohcihc
    2930 * @{
    … …  
    3233 * @brief OHCI Host controller driver routines
    3334 */
     35
    3436#include <errno.h>
    3537#include <str_error.h>
    … …  
    4951static const irq_pio_range_t ohci_pio_ranges[] = {
    5052        {
    51                 .base = 0,      /* filled later */
     53                .base = 0,
    5254                .size = sizeof(ohci_regs_t)
    5355        }
    … …  
    5557
    5658static const irq_cmd_t ohci_irq_commands[] = {
    57         { .cmd = CMD_PIO_READ_32, .dstarg = 1, .addr = NULL /* filled later */ },
    58         { .cmd = CMD_BTEST, .srcarg = 1, .dstarg = 2, .value = OHCI_USED_INTERRUPTS },
    59         { .cmd = CMD_PREDICATE, .srcarg = 2, .value = 2 },
    60         { .cmd = CMD_PIO_WRITE_A_32, .srcarg = 1, .addr = NULL /* filled later */ },
    61         { .cmd = CMD_ACCEPT },
     59        {
     60                .cmd = CMD_PIO_READ_32,
     61                .dstarg = 1,
     62                .addr = NULL
     63        },
     64        {
     65                .cmd = CMD_AND,
     66                .srcarg = 1,
     67                .dstarg = 2,
     68                .value = 0
     69        },
     70        {
     71                .cmd = CMD_PREDICATE,
     72                .srcarg = 2,
     73                .value = 2
     74        },
     75        {
     76                .cmd = CMD_PIO_WRITE_A_32,
     77                .srcarg = 1,
     78                .addr = NULL
     79        },
     80        {
     81                .cmd = CMD_ACCEPT
     82        }
    6283};
    6384
    … …  
    6889static int interrupt_emulator(hc_t *instance);
    6990static int hc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch);
    70 /*----------------------------------------------------------------------------*/
     91
    7192/** Get number of PIO ranges used in IRQ code.
    7293 * @return Number of ranges.
    … …  
    7697        return sizeof(ohci_pio_ranges) / sizeof(irq_pio_range_t);
    7798}
    78 /*----------------------------------------------------------------------------*/
    79 /*----------------------------------------------------------------------------*/
     99
    80100/** Get number of commands used in IRQ code.
    81101 * @return Number of commands.
    … …  
    85105        return sizeof(ohci_irq_commands) / sizeof(irq_cmd_t);
    86106}
    87 /*----------------------------------------------------------------------------*/
     107
    88108/** Generate IRQ code.
    89109 * @param[out] ranges PIO ranges buffer.
    … …  
    112132        cmds[0].addr = (void *) &registers->interrupt_status;
    113133        cmds[3].addr = (void *) &registers->interrupt_status;
     134        OHCI_WR(cmds[1].value, OHCI_USED_INTERRUPTS);
    114135
    115136        return EOK;
    116137}
    117 /*----------------------------------------------------------------------------*/
     138
    118139/** Announce OHCI root hub to the DDF
    119140 *
    … …  
    174195#undef CHECK_RET_RELEASE
    175196}
    176 /*----------------------------------------------------------------------------*/
     197
    177198/** Initialize OHCI hc driver structure
    178199 *
    … …  
    227248        return EOK;
    228249}
    229 /*----------------------------------------------------------------------------*/
     250
    230251void hc_enqueue_endpoint(hc_t *instance, const endpoint_t *ep)
    231252{
    … …  
    241262        switch (ep->transfer_type) {
    242263        case USB_TRANSFER_CONTROL:
    243                 instance->registers->control &= ~C_CLE;
     264                OHCI_CLR(instance->registers->control, C_CLE);
    244265                endpoint_list_add_ep(list, ohci_ep);
    245                 instance->registers->control_current = 0;
    246                 instance->registers->control |= C_CLE;
     266                OHCI_WR(instance->registers->control_current, 0);
     267                OHCI_SET(instance->registers->control, C_CLE);
    247268                break;
    248269        case USB_TRANSFER_BULK:
    249                 instance->registers->control &= ~C_BLE;
     270                OHCI_CLR(instance->registers->control, C_BLE);
    250271                endpoint_list_add_ep(list, ohci_ep);
    251                 instance->registers->control |= C_BLE;
     272                OHCI_WR(instance->registers->bulk_current, 0);
     273                OHCI_SET(instance->registers->control, C_BLE);
    252274                break;
    253275        case USB_TRANSFER_ISOCHRONOUS:
    254276        case USB_TRANSFER_INTERRUPT:
    255                 instance->registers->control &= (~C_PLE & ~C_IE);
     277                OHCI_CLR(instance->registers->control, C_PLE | C_IE);
    256278                endpoint_list_add_ep(list, ohci_ep);
    257                 instance->registers->control |= C_PLE | C_IE;
    258                 break;
    259         }
    260 }
    261 /*----------------------------------------------------------------------------*/
     279                OHCI_SET(instance->registers->control, C_PLE | C_IE);
     280                break;
     281        }
     282}
     283
    262284void hc_dequeue_endpoint(hc_t *instance, const endpoint_t *ep)
    263285{
    … …  
    273295        switch (ep->transfer_type) {
    274296        case USB_TRANSFER_CONTROL:
    275                 instance->registers->control &= ~C_CLE;
     297                OHCI_CLR(instance->registers->control, C_CLE);
    276298                endpoint_list_remove_ep(list, ohci_ep);
    277                 instance->registers->control_current = 0;
    278                 instance->registers->control |= C_CLE;
     299                OHCI_WR(instance->registers->control_current, 0);
     300                OHCI_SET(instance->registers->control, C_CLE);
    279301                break;
    280302        case USB_TRANSFER_BULK:
    281                 instance->registers->control &= ~C_BLE;
     303                OHCI_CLR(instance->registers->control, C_BLE);
    282304                endpoint_list_remove_ep(list, ohci_ep);
    283                 instance->registers->control |= C_BLE;
     305                OHCI_WR(instance->registers->bulk_current, 0);
     306                OHCI_SET(instance->registers->control, C_BLE);
    284307                break;
    285308        case USB_TRANSFER_ISOCHRONOUS:
    286309        case USB_TRANSFER_INTERRUPT:
    287                 instance->registers->control &= (~C_PLE & ~C_IE);
     310                OHCI_CLR(instance->registers->control, C_PLE | C_IE);
    288311                endpoint_list_remove_ep(list, ohci_ep);
    289                 instance->registers->control |= C_PLE | C_IE;
     312                OHCI_SET(instance->registers->control, C_PLE | C_IE);
    290313                break;
    291314        default:
    … …  
    293316        }
    294317}
    295 /*----------------------------------------------------------------------------*/
     318
    296319/** Add USB transfer to the schedule.
    297320 *
    … …  
    308331        /* Check for root hub communication */
    309332        if (batch->ep->address == instance->rh.address) {
     333                usb_log_debug("OHCI root hub request.\n");
    310334                rh_request(&instance->rh, batch);
    311335                return EOK;
    … …  
    323347        {
    324348        case USB_TRANSFER_CONTROL:
    325                 instance->registers->command_status |= CS_CLF;
     349                OHCI_SET(instance->registers->command_status, CS_CLF);
    326350                break;
    327351        case USB_TRANSFER_BULK:
    328                 instance->registers->command_status |= CS_BLF;
     352                OHCI_SET(instance->registers->command_status, CS_BLF);
    329353                break;
    330354        default:
    … …  
    334358        return EOK;
    335359}
    336 /*----------------------------------------------------------------------------*/
     360
    337361/** Interrupt handling routine
    338362 *
    … …  
    342366void hc_interrupt(hc_t *instance, uint32_t status)
    343367{
     368        status = OHCI_RD(status);
    344369        assert(instance);
    345370        if ((status & ~I_SF) == 0) /* ignore sof status */
    … …  
    352377                fibril_mutex_lock(&instance->guard);
    353378                usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).\n", instance->hcca,
    354                     instance->registers->hcca,
     379                    OHCI_RD(instance->registers->hcca),
    355380                    (void *) addr_to_phys(instance->hcca));
    356381                usb_log_debug2("Periodic current: %#" PRIx32 ".\n",
    357                     instance->registers->periodic_current);
     382                    OHCI_RD(instance->registers->periodic_current));
    358383
    359384                link_t *current = list_first(&instance->pending_batches);
    … …  
    379404
    380405}
    381 /*----------------------------------------------------------------------------*/
     406
    382407/** Check status register regularly
    383408 *
    … …  
    397422        return EOK;
    398423}
    399 /*----------------------------------------------------------------------------*/
     424
    400425/** Turn off any (BIOS)driver that might be in control of the device.
    401426 *
    … …  
    410435
    411436        usb_log_debug("Requesting OHCI control.\n");
    412         if (instance->registers->revision & R_LEGACY_FLAG) {
     437        if (OHCI_RD(instance->registers->revision) & R_LEGACY_FLAG) {
    413438                /* Turn off legacy emulation, it should be enough to zero
    414439                 * the lowest bit, but it caused problems. Thus clear all
    … …  
    419444                (uint32_t*)((char*)instance->registers + LEGACY_REGS_OFFSET);
    420445                usb_log_debug("OHCI legacy register %p: %x.\n",
    421                     ohci_emulation_reg, *ohci_emulation_reg);
     446                    ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
    422447                /* Zero everything but A20State */
    423                 *ohci_emulation_reg &= 0x100;
     448                OHCI_CLR(*ohci_emulation_reg, ~0x100);
    424449                usb_log_debug(
    425450                    "OHCI legacy register (should be 0 or 0x100) %p: %x.\n",
    426                     ohci_emulation_reg, *ohci_emulation_reg);
     451                    ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
    427452        }
    428453
    429454        /* Interrupt routing enabled => smm driver is active */
    430         if (instance->registers->control & C_IR) {
     455        if (OHCI_RD(instance->registers->control) & C_IR) {
    431456                usb_log_debug("SMM driver: request ownership change.\n");
    432                 instance->registers->command_status |= CS_OCR;
     457                OHCI_SET(instance->registers->command_status, CS_OCR);
    433458                /* Hope that SMM actually knows its stuff or we can hang here */
    434                 while (instance->registers->control & C_IR) {
     459                while (OHCI_RD(instance->registers->control & C_IR)) {
    435460                        async_usleep(1000);
    436461                }
    … …  
    449474                        return;
    450475                }
    451                 /* HC is suspended assert resume for 20ms, */
     476                /* HC is suspended assert resume for 20ms */
    452477                C_HCFS_SET(instance->registers->control, C_HCFS_RESUME);
    453478                async_usleep(20000);
    … …  
    461486        async_usleep(50000);
    462487}
    463 /*----------------------------------------------------------------------------*/
     488
    464489/** OHCI hw initialization routine.
    465490 *
    … …  
    473498
    474499        /* Save contents of fm_interval register */
    475         const uint32_t fm_interval = instance->registers->fm_interval;
     500        const uint32_t fm_interval = OHCI_RD(instance->registers->fm_interval);
    476501        usb_log_debug2("Old value of HcFmInterval: %x.\n", fm_interval);
    477502
    … …  
    479504        usb_log_debug2("HC reset.\n");
    480505        size_t time = 0;
    481         instance->registers->command_status = CS_HCR;
    482         while (instance->registers->command_status & CS_HCR) {
     506        OHCI_WR(instance->registers->command_status, CS_HCR);
     507        while (OHCI_RD(instance->registers->command_status) & CS_HCR) {
    483508                async_usleep(10);
    484509                time += 10;
    … …  
    487512
    488513        /* Restore fm_interval */
    489         instance->registers->fm_interval = fm_interval;
    490         assert((instance->registers->command_status & CS_HCR) == 0);
     514        OHCI_WR(instance->registers->fm_interval, fm_interval);
     515        assert((OHCI_RD(instance->registers->command_status) & CS_HCR) == 0);
    491516
    492517        /* hc is now in suspend state */
    493518        usb_log_debug2("HC should be in suspend state(%x).\n",
    494             instance->registers->control);
     519            OHCI_RD(instance->registers->control));
    495520
    496521        /* Use HCCA */
    497         instance->registers->hcca = addr_to_phys(instance->hcca);
     522        OHCI_WR(instance->registers->hcca, addr_to_phys(instance->hcca));
    498523
    499524        /* Use queues */
    500         instance->registers->bulk_head =
    501             instance->lists[USB_TRANSFER_BULK].list_head_pa;
     525        OHCI_WR(instance->registers->bulk_head,
     526            instance->lists[USB_TRANSFER_BULK].list_head_pa);
    502527        usb_log_debug2("Bulk HEAD set to: %p (%#" PRIx32 ").\n",
    503528            instance->lists[USB_TRANSFER_BULK].list_head,
    504529            instance->lists[USB_TRANSFER_BULK].list_head_pa);
    505530
    506         instance->registers->control_head =
    507             instance->lists[USB_TRANSFER_CONTROL].list_head_pa;
     531        OHCI_WR(instance->registers->control_head,
     532            instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
    508533        usb_log_debug2("Control HEAD set to: %p (%#" PRIx32 ").\n",
    509534            instance->lists[USB_TRANSFER_CONTROL].list_head,
    … …  
    511536
    512537        /* Enable queues */
    513         instance->registers->control |= (C_PLE | C_IE | C_CLE | C_BLE);
    514         usb_log_debug2("All queues enabled(%x).\n",
    515             instance->registers->control);
     538        OHCI_SET(instance->registers->control, (C_PLE | C_IE | C_CLE | C_BLE));
     539        usb_log_debug("Queues enabled(%x).\n",
     540            OHCI_RD(instance->registers->control));
    516541
    517542        /* Enable interrupts */
    518         instance->registers->interrupt_enable = OHCI_USED_INTERRUPTS;
    519         usb_log_debug2("Enabled interrupts: %x.\n",
    520             instance->registers->interrupt_enable);
    521         instance->registers->interrupt_enable = I_MI;
     543        OHCI_WR(instance->registers->interrupt_enable, OHCI_USED_INTERRUPTS);
     544        usb_log_debug("Enabled interrupts: %x.\n",
     545            OHCI_RD(instance->registers->interrupt_enable));
     546        OHCI_WR(instance->registers->interrupt_enable, I_MI);
    522547
    523548        /* Set periodic start to 90% */
    524         uint32_t frame_length = ((fm_interval >> FMI_FI_SHIFT) & FMI_FI_MASK);
    525         instance->registers->periodic_start = (frame_length / 10) * 9;
     549        const uint32_t frame_length =
     550            (fm_interval >> FMI_FI_SHIFT) & FMI_FI_MASK;
     551        OHCI_WR(instance->registers->periodic_start,
     552            ((frame_length / 10) * 9) & PS_MASK << PS_SHIFT);
    526553        usb_log_debug2("All periodic start set to: %x(%u - 90%% of %d).\n",
    527             instance->registers->periodic_start,
    528             instance->registers->periodic_start, frame_length);
    529 
     554            OHCI_RD(instance->registers->periodic_start),
     555            OHCI_RD(instance->registers->periodic_start), frame_length);
    530556        C_HCFS_SET(instance->registers->control, C_HCFS_OPERATIONAL);
    531557        usb_log_debug("OHCI HC up and running (ctl_reg=0x%x).\n",
    532             instance->registers->control);
    533 }
    534 /*----------------------------------------------------------------------------*/
     558            OHCI_RD(instance->registers->control));
     559}
     560
    535561/** Initialize schedule queues
    536562 *
    … …  
    566592        return EOK;
    567593}
    568 /*----------------------------------------------------------------------------*/
     594
    569595/** Initialize memory structures used by the OHCI hcd.
    570596 *
    … …  
    587613        if (instance->hcca == NULL)
    588614                return ENOMEM;
    589         bzero(instance->hcca, sizeof(hcca_t));
    590615        usb_log_debug2("OHCI HCCA initialized at %p.\n", instance->hcca);
    591616
    592         for (unsigned i = 0; i < 32; ++i) {
    593                 instance->hcca->int_ep[i] =
    594                     instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa;
     617        for (unsigned i = 0; i < HCCA_INT_EP_COUNT; ++i) {
     618                hcca_set_int_ep(instance->hcca, i,
     619                    instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
    595620        }
    596621        usb_log_debug2("Interrupt HEADs set to: %p (%#" PRIx32 ").\n",

  • uspace/drv/bus/usb/ohci/hw_struct/endpoint_descriptor.c

    re1e4192 r90478727  
    5858                /* Mark as dead, used for dummy EDs at the beginning of
    5959                 * endpoint lists. */
    60                 instance->status = ED_STATUS_K_FLAG;
     60                OHCI_MEM32_WR(instance->status, ED_STATUS_K_FLAG);
    6161                return;
    6262        }
    … …  
    6565
    6666        /* Status: address, endpoint nr, direction mask and max packet size. */
    67         instance->status = 0
    68             | ((ep->address & ED_STATUS_FA_MASK) << ED_STATUS_FA_SHIFT)
     67        OHCI_MEM32_WR(instance->status,
     68            ((ep->address & ED_STATUS_FA_MASK) << ED_STATUS_FA_SHIFT)
    6969            | ((ep->endpoint & ED_STATUS_EN_MASK) << ED_STATUS_EN_SHIFT)
    7070            | ((dir[ep->direction] & ED_STATUS_D_MASK) << ED_STATUS_D_SHIFT)
    7171            | ((ep->max_packet_size & ED_STATUS_MPS_MASK)
    72                 << ED_STATUS_MPS_SHIFT);
     72                << ED_STATUS_MPS_SHIFT));
    7373
    7474        /* Low speed flag */
    7575        if (ep->speed == USB_SPEED_LOW)
    76                 instance->status |= ED_STATUS_S_FLAG;
     76                OHCI_MEM32_SET(instance->status, ED_STATUS_S_FLAG);
    7777
    7878        /* Isochronous format flag */
    7979        if (ep->transfer_type == USB_TRANSFER_ISOCHRONOUS)
    80                 instance->status |= ED_STATUS_F_FLAG;
     80                OHCI_MEM32_SET(instance->status, ED_STATUS_F_FLAG);
    8181
    8282        /* Set TD to the list */
    8383        const uintptr_t pa = addr_to_phys(td);
    84         instance->td_head = pa & ED_TDHEAD_PTR_MASK;
    85         instance->td_tail = pa & ED_TDTAIL_PTR_MASK;
     84        OHCI_MEM32_WR(instance->td_head, pa & ED_TDHEAD_PTR_MASK);
     85        OHCI_MEM32_WR(instance->td_tail, pa & ED_TDTAIL_PTR_MASK);
    8686
    8787        /* Set toggle bit */
    8888        if (ep->toggle)
    89                 instance->td_head |= ED_TDHEAD_TOGGLE_CARRY;
     89                OHCI_MEM32_SET(instance->td_head, ED_TDHEAD_TOGGLE_CARRY);
    9090
    9191}

  • uspace/drv/bus/usb/ohci/hw_struct/endpoint_descriptor.h

    re1e4192 r90478727  
    4444
    4545#include "completion_codes.h"
     46#include "mem_access.h"
    4647
    4748/**
    … …  
    116117{
    117118        assert(instance);
    118         return (instance->td_head & ED_TDHEAD_HALTED_FLAG)
    119             || (instance->status & ED_STATUS_K_FLAG);
     119        return (OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_HALTED_FLAG)
     120            || (OHCI_MEM32_RD(instance->status) & ED_STATUS_K_FLAG);
     121}
     122
     123static inline void ed_clear_halt(ed_t *instance)
     124{
     125        assert(instance);
     126        OHCI_MEM32_CLR(instance->td_head, ED_TDHEAD_HALTED_FLAG);
    120127}
    121128
    … …  
    128135{
    129136        assert(instance);
    130         return (instance->td_head & ED_TDHEAD_PTR_MASK)
    131             != (instance->td_tail & ED_TDTAIL_PTR_MASK);
     137        return (OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_PTR_MASK)
     138            != (OHCI_MEM32_RD(instance->td_tail) & ED_TDTAIL_PTR_MASK);
    132139}
    133140
    … …  
    141148        assert(instance);
    142149        const uintptr_t pa = addr_to_phys(td);
    143         instance->td_tail = pa & ED_TDTAIL_PTR_MASK;
     150        OHCI_MEM32_WR(instance->td_tail, pa & ED_TDTAIL_PTR_MASK);
     151}
     152
     153static inline uint32_t ed_tail_td(const ed_t *instance)
     154{
     155        assert(instance);
     156        return OHCI_MEM32_RD(instance->td_tail) & ED_TDTAIL_PTR_MASK;
     157}
     158
     159static inline uint32_t ed_head_td(const ed_t *instance)
     160{
     161        assert(instance);
     162        return OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_PTR_MASK;
    144163}
    145164
    … …  
    155174        const uint32_t pa = addr_to_phys(next);
    156175        assert((pa & ED_NEXT_PTR_MASK) << ED_NEXT_PTR_SHIFT == pa);
    157         instance->next = pa;
     176        OHCI_MEM32_WR(instance->next, pa);
     177}
     178
     179static inline uint32_t ed_next(const ed_t *instance)
     180{
     181        assert(instance);
     182        return OHCI_MEM32_RD(instance->next) & ED_NEXT_PTR_MASK;
    158183}
    159184
    … …  
    166191{
    167192        assert(instance);
    168         return (instance->td_head & ED_TDHEAD_TOGGLE_CARRY) ? 1 : 0;
     193        return (OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_TOGGLE_CARRY) ? 1 : 0;
    169194}
    170195
    … …  
    178203        assert(instance);
    179204        if (toggle) {
    180                 instance->td_head |= ED_TDHEAD_TOGGLE_CARRY;
     205                OHCI_MEM32_SET(instance->td_head, ED_TDHEAD_TOGGLE_CARRY);
    181206        } else {
    182207                /* Clear halted flag when reseting toggle TODO: Why? */
    183                 instance->td_head &= ~ED_TDHEAD_TOGGLE_CARRY;
    184                 instance->td_head &= ~ED_TDHEAD_HALTED_FLAG;
     208                OHCI_MEM32_CLR(instance->td_head, ED_TDHEAD_TOGGLE_CARRY);
     209                OHCI_MEM32_CLR(instance->td_head, ED_TDHEAD_HALTED_FLAG);
    185210        }
    186211}

  • uspace/drv/bus/usb/ohci/hw_struct/hcca.h

    re1e4192 r90478727  
    3838#include <malloc.h>
    3939
     40#include "mem_access.h"
     41
     42#define HCCA_INT_EP_COUNT  32
     43
    4044/** Host controller communication area.
    4145 * Shared memory used for communication between the controller and the driver.
    4246 */
    4347typedef struct hcca {
    44         uint32_t int_ep[32];
     48        /** Interrupt endpoints */
     49        uint32_t int_ep[HCCA_INT_EP_COUNT];
     50        /** Frame number. */
    4551        uint16_t frame_number;
    4652        uint16_t pad1;
     53        /** Pointer to the last completed TD. (useless) */
    4754        uint32_t done_head;
     55        /** Padding to make the size 256B */
    4856        uint32_t reserved[30];
    4957} hcca_t;
    5058
    51 static inline void * hcca_get(void)
     59/** Allocate properly aligned structure.
     60 *
     61 * The returned structure is zeroed upon allocation.
     62 *
     63 * @return Usable HCCA memory structure.
     64 */
     65static inline hcca_t * hcca_get(void)
    5266{
    5367        assert(sizeof(hcca_t) == 256);
    54         return memalign(256, sizeof(hcca_t));
     68        hcca_t *hcca = memalign(256, sizeof(hcca_t));
     69        if (hcca)
     70                bzero(hcca, sizeof(hcca_t));
     71        return hcca;
     72}
     73
     74/** Set HCCA interrupt endpoint pointer table entry.
     75 * @param hcca HCCA memory structure.
     76 * @param index table index.
     77 * @param pa Physical address.
     78 */
     79static inline void hcca_set_int_ep(hcca_t *hcca, unsigned index, uintptr_t pa)
     80{
     81        assert(hcca);
     82        assert(index < HCCA_INT_EP_COUNT);
     83        OHCI_MEM32_WR(hcca->int_ep[index], pa);
     84
    5585}
    5686#endif

  • uspace/drv/bus/usb/ohci/hw_struct/transfer_descriptor.c

    re1e4192 r90478727  
    3333 */
    3434#include <usb/usb.h>
     35#include <mem.h>
     36#include "../utils/malloc32.h"
    3537#include "transfer_descriptor.h"
    3638
    … …  
    5860        bzero(instance, sizeof(td_t));
    5961        /* Set PID and Error code */
    60         instance->status = 0
    61             | ((dir[direction] & TD_STATUS_DP_MASK) << TD_STATUS_DP_SHIFT)
    62             | ((CC_NOACCESS2 & TD_STATUS_CC_MASK) << TD_STATUS_CC_SHIFT);
     62        OHCI_MEM32_WR(instance->status,
     63            ((dir[direction] & TD_STATUS_DP_MASK) << TD_STATUS_DP_SHIFT)
     64            | ((CC_NOACCESS2 & TD_STATUS_CC_MASK) << TD_STATUS_CC_SHIFT));
    6365
    6466        if (toggle == 0 || toggle == 1) {
    6567                /* Set explicit toggle bit */
    66                 instance->status |= TD_STATUS_T_USE_TD_FLAG;
    67                 instance->status |= toggle ? TD_STATUS_T_FLAG : 0;
     68                OHCI_MEM32_SET(instance->status, TD_STATUS_T_USE_TD_FLAG);
     69                OHCI_MEM32_SET(instance->status, toggle ? TD_STATUS_T_FLAG : 0);
    6870        }
    6971
    7072        /* Alow less data on input. */
    7173        if (dir == USB_DIRECTION_IN) {
    72                 instance->status |= TD_STATUS_ROUND_FLAG;
     74                OHCI_MEM32_SET(instance->status, TD_STATUS_ROUND_FLAG);
    7375        }
    7476
    7577        if (buffer != NULL) {
    7678                assert(size != 0);
    77                 instance->cbp = addr_to_phys(buffer);
    78                 instance->be = addr_to_phys(buffer + size - 1);
     79                OHCI_MEM32_WR(instance->cbp, addr_to_phys(buffer));
     80                OHCI_MEM32_WR(instance->be, addr_to_phys(buffer + size - 1));
    7981        }
    8082
    81         instance->next = addr_to_phys(next) & TD_NEXT_PTR_MASK;
     83        OHCI_MEM32_WR(instance->next, addr_to_phys(next) & TD_NEXT_PTR_MASK);
    8284
    8385}

  • uspace/drv/bus/usb/ohci/hw_struct/transfer_descriptor.h

    re1e4192 r90478727  
    3838#include <stdint.h>
    3939
    40 #include "../utils/malloc32.h"
     40#include "mem_access.h"
    4141#include "completion_codes.h"
    4242
    … …  
    100100{
    101101        assert(instance);
    102         const int cc =
    103             (instance->status >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
     102        const int cc =(OHCI_MEM32_RD(instance->status)
     103            >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
    104104        /* This value is changed on transfer completion,
    105105         * either to CC_NOERROR or and error code.
    … …  
    119119{
    120120        assert(instance);
    121         const int cc =
    122             (instance->status >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
     121        const int cc = (OHCI_MEM32_RD(instance->status)
     122            >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
    123123        return cc_to_rc(cc);
    124124}
    … …  
    136136                return 0;
    137137        /* Buffer end points to the last byte of transfer buffer, so add 1 */
    138         return instance->be - instance->cbp + 1;
     138        return OHCI_MEM32_RD(instance->be) - OHCI_MEM32_RD(instance->cbp) + 1;
    139139}
    140140#endif

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

    re1e4192 r90478727  
    6363        return EOK;
    6464}
    65 /*----------------------------------------------------------------------------*/
     65
    6666static driver_ops_t ohci_driver_ops = {
    6767        .dev_add = ohci_dev_add,
    6868};
    69 /*----------------------------------------------------------------------------*/
     69
    7070static driver_t ohci_driver = {
    7171        .name = NAME,
    7272        .driver_ops = &ohci_driver_ops
    7373};
    74 /*----------------------------------------------------------------------------*/
     74
    7575/** Initializes global driver structures (NONE).
    7676 *

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

    re1e4192 r90478727  
    7575        hc_interrupt(&ohci->hc, status);
    7676}
    77 /*----------------------------------------------------------------------------*/
     77
    7878/** Get USB address assigned to root hub.
    7979 *
    … …  
    9292        return EOK;
    9393}
    94 /*----------------------------------------------------------------------------*/
     94
    9595/** Gets handle of the respective hc (this device, hc function).
    9696 *
    … …  
    110110        return EOK;
    111111}
    112 /*----------------------------------------------------------------------------*/
     112
    113113/** Root hub USB interface */
    114114static usb_iface_t usb_iface = {
    … …  
    116116        .get_my_address = rh_get_my_address,
    117117};
    118 /*----------------------------------------------------------------------------*/
     118
    119119/** Standard USB HC options (HC interface) */
    120120static ddf_dev_ops_t hc_ops = {
    121121        .interfaces[USBHC_DEV_IFACE] = &hcd_iface,
    122122};
    123 /*----------------------------------------------------------------------------*/
     123
    124124/** Standard USB RH options (RH interface) */
    125125static ddf_dev_ops_t rh_ops = {
    126126        .interfaces[USB_DEV_IFACE] = &usb_iface,
    127127};
    128 /*----------------------------------------------------------------------------*/
     128
    129129/** Initialize hc and rh ddf structures and their respective drivers.
    130130 *

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

    re1e4192 r90478727  
    4444
    4545static void (*const batch_setup[])(ohci_transfer_batch_t*, usb_direction_t);
    46 /*----------------------------------------------------------------------------*/
     46
    4747/** Safely destructs ohci_transfer_batch_t structure
    4848 *
    … …  
    6767        free(ohci_batch);
    6868}
    69 /*----------------------------------------------------------------------------*/
     69
    7070/** Finishes usb_transfer_batch and destroys the structure.
    7171 *
    … …  
    8080        ohci_transfer_batch_dispose(ohci_batch);
    8181}
    82 /*----------------------------------------------------------------------------*/
     82
    8383/** Allocate memory and initialize internal data structure.
    8484 *
    … …  
    158158#undef CHECK_NULL_DISPOSE_RET
    159159}
    160 /*----------------------------------------------------------------------------*/
     160
    161161/** Check batch TDs' status.
    162162 *
    … …  
    199199                    ohci_batch->tds[i]->next, ohci_batch->tds[i]->be);
    200200
    201                 /* If the TD got all its data through, it will report 0 bytes
    202                  * remain, the sole exception is INPUT with data rounding flag
    203                  * (short), i.e. every INPUT. Nice thing is that short packets
    204                  * will correctly report remaining data, thus making
    205                  * this computation correct (short packets need to be produced
    206                  * by the last TD)
    207                  * NOTE: This also works for CONTROL transfer as
    208                  * the first TD will return 0 remain.
    209                  * NOTE: Short packets don't break the assumption that
    210                  * we leave the very last(unused) TD behind.
    211                  */
    212                 ohci_batch->usb_batch->transfered_size
    213                     -= td_remain_size(ohci_batch->tds[i]);
    214 
    215201                ohci_batch->usb_batch->error = td_error(ohci_batch->tds[i]);
    216                 if (ohci_batch->usb_batch->error != EOK) {
     202                if (ohci_batch->usb_batch->error == EOK) {
     203                        /* If the TD got all its data through, it will report
     204                         * 0 bytes remain, the sole exception is INPUT with
     205                         * data rounding flag (short), i.e. every INPUT.
     206                         * Nice thing is that short packets will correctly
     207                         * report remaining data, thus making this computation
     208                         * correct (short packets need to be produced by the
     209                         * last TD)
     210                         * NOTE: This also works for CONTROL transfer as
     211                         * the first TD will return 0 remain.
     212                         * NOTE: Short packets don't break the assumption that
     213                         * we leave the very last(unused) TD behind.
     214                         */
     215                        ohci_batch->usb_batch->transfered_size
     216                            -= td_remain_size(ohci_batch->tds[i]);
     217                } else {
    217218                        usb_log_debug("Batch %p found error TD(%zu):%08x.\n",
    218219                            ohci_batch->usb_batch, i,
    … …  
    231232
    232233                        /* Check TD assumption */
    233                         const uint32_t pa =
    234                             addr_to_phys(ohci_batch->tds[leave_td]);
    235                         assert((ohci_batch->ed->td_head & ED_TDHEAD_PTR_MASK)
    236                             == pa);
    237 
     234                        assert(ed_head_td(ohci_batch->ed) ==
     235                            addr_to_phys(ohci_batch->tds[leave_td]));
     236
     237                        /* Set tail to the same TD */
    238238                        ed_set_tail_td(ohci_batch->ed,
    239239                            ohci_batch->tds[leave_td]);
    240240
    241241                        /* Clear possible ED HALT */
    242                         ohci_batch->ed->td_head &= ~ED_TDHEAD_HALTED_FLAG;
     242                        ed_clear_halt(ohci_batch->ed);
    243243                        break;
    244244                }
    … …  
    253253
    254254        /* Make sure that we are leaving the right TD behind */
    255         const uint32_t pa = addr_to_phys(ohci_ep->td);
    256         assert(pa == (ohci_batch->ed->td_head & ED_TDHEAD_PTR_MASK));
    257         assert(pa == (ohci_batch->ed->td_tail & ED_TDTAIL_PTR_MASK));
     255        assert(addr_to_phys(ohci_ep->td) == ed_head_td(ohci_batch->ed));
     256        assert(addr_to_phys(ohci_ep->td) == ed_tail_td(ohci_batch->ed));
    258257
    259258        return true;
    260259}
    261 /*----------------------------------------------------------------------------*/
     260
    262261/** Starts execution of the TD list
    263262 *
    … …  
    269268        ed_set_tail_td(ohci_batch->ed, ohci_batch->tds[ohci_batch->td_count]);
    270269}
    271 /*----------------------------------------------------------------------------*/
     270
    272271/** Prepare generic control transfer
    273272 *
    … …  
    345344            USB_TRANSFER_BATCH_ARGS(*ohci_batch->usb_batch));
    346345}
    347 /*----------------------------------------------------------------------------*/
     346
    348347/** Prepare generic data transfer
    349348 *
    … …  
    392391            USB_TRANSFER_BATCH_ARGS(*ohci_batch->usb_batch));
    393392}
    394 /*----------------------------------------------------------------------------*/
     393
    395394/** Transfer setup table. */
    396395static void (*const batch_setup[])(ohci_transfer_batch_t*, usb_direction_t) =

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

    re1e4192 r90478727  
    6363void ohci_transfer_batch_commit(const ohci_transfer_batch_t *batch);
    6464void ohci_transfer_batch_finish_dispose(ohci_transfer_batch_t *batch);
    65 /*----------------------------------------------------------------------------*/
     65
    6666static inline ohci_transfer_batch_t *ohci_transfer_batch_from_link(link_t *l)
    6767{

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

    re1e4192 r90478727  
    4848        ed_toggle_set(instance->ed, toggle);
    4949}
    50 /*----------------------------------------------------------------------------*/
     50
    5151/** Callback to get value of toggle bit.
    5252 *
    … …  
    6161        return ed_toggle_get(instance->ed);
    6262}
    63 /*----------------------------------------------------------------------------*/
     63
    6464/** Creates new hcd endpoint representation.
    6565 *
    … …  
    9393        return EOK;
    9494}
    95 /*----------------------------------------------------------------------------*/
     95
    9696/** Disposes hcd endpoint structure
    9797 *

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

    re1e4192 r90478727  
    3535#define DRV_OHCI_OHCI_REGS_H
    3636#include <sys/types.h>
     37#include <byteorder.h>
     38
     39#define OHCI_WR(reg, val) reg = host2uint32_t_le(val)
     40#define OHCI_RD(reg) uint32_t_le2host(reg)
     41#define OHCI_SET(reg, val) reg |= host2uint32_t_le(val)
     42#define OHCI_CLR(reg, val) reg &= host2uint32_t_le(~val)
     43
    3744
    3845#define LEGACY_REGS_OFFSET 0x100
    … …  
    4249        const ioport32_t revision;
    4350#define R_REVISION_MASK (0x3f)
    44 #define R_REVISION_SHIFT (0)
    4551#define R_LEGACY_FLAG   (0x80)
    4652
    4753        ioport32_t control;
    48 #define C_CBSR_MASK (0x3) /* Control-bulk service ratio */
     54/* Control-bulk service ratio */
    4955#define C_CBSR_1_1  (0x0)
    5056#define C_CBSR_1_2  (0x1)
    5157#define C_CBSR_1_3  (0x2)
    5258#define C_CBSR_1_4  (0x3)
    53 #define C_CBSR_SHIFT (0)
     59#define C_CBSR_MASK (0x3)
     60#define C_CBSR_SHIFT 0
    5461
    5562#define C_PLE (1 << 2)   /* Periodic list enable */
    … …  
    5865#define C_BLE (1 << 5)   /* Bulk list enable */
    5966
    60 #define C_HCFS_MASK        (0x3) /* Host controller functional state */
     67/* Host controller functional state */
    6168#define C_HCFS_RESET       (0x0)
    6269#define C_HCFS_RESUME      (0x1)
    6370#define C_HCFS_OPERATIONAL (0x2)
    6471#define C_HCFS_SUSPEND     (0x3)
    65 #define C_HCFS_SHIFT       (6)
    66 
    67 #define C_HCFS_GET(reg) \
    68         ((reg >> C_HCFS_SHIFT) & C_HCFS_MASK)
    69 #define C_HCFS_SET(reg, hcfs_state) \
     72#define C_HCFS_GET(reg) ((OHCI_RD(reg) >> 6) & 0x3)
     73#define C_HCFS_SET(reg, value) \
    7074do { \
    71         reg = (reg & ~(C_HCFS_MASK << C_HCFS_SHIFT)) \
    72             | ((hcfs_state & C_HCFS_MASK) << C_HCFS_SHIFT); \
     75        uint32_t r = OHCI_RD(reg); \
     76        r &= ~(0x3 << 6); \
     77        r |= (value & 0x3) << 6; \
     78        OHCI_WR(reg, r); \
    7379} while (0)
    7480
    75 
    76 #define C_IR  (1 << 8)   /* Interrupt routing, make sure it's 0 */
    77 #define C_RWC (1 << 9)   /* Remote wakeup connected, host specific */
     81#define C_IR  (1 << 8)  /* Interrupt routing, make sure it's 0 */
     82#define C_RWC (1 << 9)  /* Remote wakeup connected, host specific */
    7883#define C_RWE (1 << 10)  /* Remote wakeup enable */
    7984
    … …  
    8388#define CS_BLF (1 << 2)   /* Bulk list filled */
    8489#define CS_OCR (1 << 3)   /* Ownership change request */
     90#if 0
    8591#define CS_SOC_MASK (0x3) /* Scheduling overrun count */
    8692#define CS_SOC_SHIFT (16)
     93#endif
    8794
    8895        /** Interupt enable/disable/status,
    … …  
    101108#define I_RHSC (1 << 6)   /* Root hub status change */
    102109#define I_OC   (1 << 30)  /* Ownership change */
    103 #define I_MI   (1 << 31)  /* Master interrupt (all/any interrupts) */
     110#define I_MI   (1 << 31)  /* Master interrupt (any/all) */
    104111
    105112        /** HCCA pointer (see hw_struct hcca.h) */
    … …  
    145152        /** Remaining bit time in frame to start periodic transfers */
    146153        ioport32_t periodic_start;
    147 #define PS_PS_MASK (0x3fff) /* bit time when periodic get priority (0x3e67) */
     154#define PS_MASK 0x3fff
     155#define PS_SHIFT 0
    148156
    149157        /** Threshold for starting LS transaction */
    … …  
    153161        /** The first root hub control register */
    154162        ioport32_t rh_desc_a;
    155 #define RHDA_NDS_MASK (0xff) /* Number of downstream ports, max 15 */
    156 #define RHDA_NDS_SHIFT (0)
    157 #define RHDA_PSM_FLAG  (1 << 8)  /* Power switching mode: 0-global, 1-per port*/
    158 #define RHDA_NPS_FLAG  (1 << 9)  /* No power switch: 1-power on, 0-use PSM*/
    159 #define RHDA_DT_FLAG   (1 << 10) /* 1-Compound device, must be 0 */
    160 #define RHDA_OCPM_FLAG (1 << 11) /* Over-current mode: 0-global, 1-per port */
    161 #define RHDA_NOCP_FLAG (1 << 12) /* OC control: 0-use OCPM, 1-OC off */
    162 #define RHDA_POTPGT_MASK (0xff)  /* Power on to power good time */
    163 #define RHDA_POTPGT_SHIFT (24)
     163/** Number of downstream ports, max 15 */
     164#define RHDA_NDS_MASK  (0xff)
     165/** Power switching mode: 0-global, 1-per port*/
     166#define RHDA_PSM_FLAG  (1 << 8)
     167/** No power switch: 1-power on, 0-use PSM*/
     168#define RHDA_NPS_FLAG  (1 << 9)
     169/** 1-Compound device, must be 0 */
     170#define RHDA_DT_FLAG   (1 << 10)
     171/** Over-current mode: 0-global, 1-per port */
     172#define RHDA_OCPM_FLAG (1 << 11)
     173/** OC control: 0-use OCPM, 1-OC off */
     174#define RHDA_NOCP_FLAG (1 << 12)
     175/** Power on to power good time */
     176#define RHDA_POTPGT_SHIFT   24
    164177
    165178        /** The other root hub control register */
    166179        ioport32_t rh_desc_b;
    167 #define RHDB_DR_MASK (0xffff) /* Device removable mask */
    168 #define RHDB_DR_SHIFT (0)
    169 #define RHDB_PCC_MASK (0xffff) /* Power control mask */
    170 #define RHDB_PCC_SHIFT (16)
    171 
    172 /* Port device removable status */
    173 #define RHDB_DR_FLAG(port) (((1 << port) & RHDB_DR_MASK) << RHDB_DR_SHIFT)
    174 /* Port power control status: 1-per port power control, 0-global power switch */
    175 #define RHDB_PPC_FLAG(port) (((1 << port) & RHDB_DR_MASK) << RHDB_DR_SHIFT)
     180/** Device removable mask */
     181#define RHDB_DR_SHIFT   0
     182#define RHDB_DR_MASK    0xffff
     183/** Power control mask */
     184#define RHDB_PCC_MASK (0xffff)
     185#define RHDB_PCC_SHIFT 16
    176186
    177187        /** Root hub status register */
    178188        ioport32_t rh_status;
    179 #define RHS_LPS_FLAG  (1 <<  0)/* read: 0,
    180                                 * write: 0-no effect,
    181                                 *        1-turn off port power for ports
    182                                 *        specified in PPCM(RHDB), or all ports,
    183                                 *        if power is set globally */
     189/* read: 0,
     190 * write: 0-no effect,
     191 *        1-turn off port power for ports
     192 *        specified in PPCM(RHDB), or all ports,
     193 *        if power is set globally */
     194#define RHS_LPS_FLAG  (1 <<  0)
    184195#define RHS_CLEAR_GLOBAL_POWER RHS_LPS_FLAG /* synonym for the above */
    185 #define RHS_OCI_FLAG  (1 <<  1)/* Over-current indicator, if per-port: 0 */
    186 #define RHS_DRWE_FLAG (1 << 15)/* read: 0-connect status change does not wake HC
    187                                 *       1-connect status change wakes HC
    188                                 * write: 1-set DRWE, 0-no effect */
     196/** Over-current indicator, if per-port: 0 */
     197#define RHS_OCI_FLAG  (1 <<  1)
     198
     199/* read: 0-connect status change does not wake HC
     200 *       1-connect status change wakes HC
     201 * write: 1-set DRWE, 0-no effect */
     202#define RHS_DRWE_FLAG (1 << 15)
    189203#define RHS_SET_DRWE RHS_DRWE_FLAG
    190 #define RHS_LPSC_FLAG (1 << 16)/* read: 0,
    191                                 * write: 0-no effect
    192                                 *        1-turn on port power for ports
    193                                 *        specified in PPCM(RHDB), or all ports,
    194                                 *        if power is set globally */
     204/* read: 0,
     205 * write: 0-no effect
     206 *        1-turn on port power for ports
     207 *        specified in PPCM(RHDB), or all ports,
     208 *        if power is set globally */
     209#define RHS_LPSC_FLAG (1 << 16)
    195210#define RHS_SET_GLOBAL_POWER RHS_LPSC_FLAG /* synonym for the above */
    196 #define RHS_OCIC_FLAG (1 << 17)/* Over-current indicator change   */
     211/** Over-current change indicator*/
     212#define RHS_OCIC_FLAG (1 << 17)
    197213#define RHS_CLEAR_DRWE (1 << 31)
    198214
    … …  
    200216        ioport32_t rh_port_status[];
    201217#define RHPS_CCS_FLAG (1 << 0) /* r: current connect status,
    202                                 * w: 1-clear port enable, 0-nothing */
     218                                               * w: 1-clear port enable, 0-N/S*/
    203219#define RHPS_CLEAR_PORT_ENABLE RHPS_CCS_FLAG
    204220#define RHPS_PES_FLAG (1 << 1) /* r: port enable status
    205                                 * w: 1-set port enable, 0-nothing */
     221                                              * w: 1-set port enable, 0-N/S */
    206222#define RHPS_SET_PORT_ENABLE RHPS_PES_FLAG
    207223#define RHPS_PSS_FLAG (1 << 2) /* r: port suspend status
    208                                 * w: 1-set port suspend, 0-nothing */
     224                                               * w: 1-set port suspend, 0-N/S */
    209225#define RHPS_SET_PORT_SUSPEND RHPS_PSS_FLAG
    210 #define RHPS_POCI_FLAG (1 << 3) /* r: port over-current (if reports are per-port
    211                                  * w: 1-clear port suspend (start resume
    212                                  *      if suspened)
    213                                  *    0-nothing */
     226#define RHPS_POCI_FLAG (1 << 3) /* r: port over-current
     227                                                * (if reports are per-port
     228                                                * w: 1-clear port suspend
     229                                                *  (start resume if suspened)
     230                                                *    0-nothing */
    214231#define RHPS_CLEAR_PORT_SUSPEND RHPS_POCI_FLAG
    215232#define RHPS_PRS_FLAG (1 << 4) /* r: port reset status
    216                                 * w: 1-set port reset, 0-nothing */
     233                                               * w: 1-set port reset, 0-N/S */
    217234#define RHPS_SET_PORT_RESET RHPS_PRS_FLAG
    218235#define RHPS_PPS_FLAG (1 << 8) /* r: port power status
    219                                 * w: 1-set port power, 0-nothing */
     236                                              * w: 1-set port power, 0-N/S */
    220237#define RHPS_SET_PORT_POWER RHPS_PPS_FLAG
    221238#define RHPS_LSDA_FLAG (1 << 9) /* r: low speed device attached
    222                                  * w: 1-clear port power, 0-nothing */
     239                                                * w: 1-clear port power, 0-N/S*/
    223240#define RHPS_CLEAR_PORT_POWER RHPS_LSDA_FLAG
    224 #define RHPS_CSC_FLAG  (1 << 16) /* connect status change Write-Clean */
     241#define RHPS_CSC_FLAG  (1 << 16) /* connect status change WC */
    225242#define RHPS_PESC_FLAG (1 << 17) /* port enable status change WC */
    226243#define RHPS_PSSC_FLAG (1 << 18) /* port suspend status change WC */
    227244#define RHPS_OCIC_FLAG (1 << 19) /* port over-current change WC */
    228245#define RHPS_PRSC_FLAG (1 << 20) /* port reset status change WC */
    229 #define RHPS_CHANGE_WC_MASK 0x1f0000
     246#define RHPS_CHANGE_WC_MASK (0x1f0000)
    230247} __attribute__((packed)) ohci_regs_t;
    231248#endif

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

    re1e4192 r90478727  
    3333 */
    3434#include <assert.h>
     35#include <byteorder.h>
    3536#include <errno.h>
    3637#include <str_error.h>
    3738#include <fibril_synch.h>
    3839
     40#include <usb/usb.h>
    3941#include <usb/debug.h>
    4042#include <usb/dev/request.h>
    4143#include <usb/classes/hub.h>
    4244
    43 #include "root_hub.h"
    4445#include <usb/classes/classes.h>
    4546#include <usb/classes/hub.h>
    4647#include <usb/dev/driver.h>
    4748#include "ohci_regs.h"
     49#include "root_hub.h"
    4850
    4951/**
    … …  
    122124{
    123125        assert(request);
     126        usb_log_debug("Sending interrupt vector(%zu) %hhx:%hhx.\n",
     127            size, ((uint8_t*)&mask)[0], ((uint8_t*)&mask)[1]);
    124128        usb_transfer_batch_finish_error(request, &mask, size, EOK);
    125129        usb_transfer_batch_destroy(request);
    … …  
    150154
    151155        instance->registers = regs;
    152         instance->port_count =
    153             (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
     156        instance->port_count = OHCI_RD(regs->rh_desc_a) & RHDA_NDS_MASK;
     157        usb_log_debug2("rh_desc_a: %x.\n", OHCI_RD(regs->rh_desc_a));
    154158        if (instance->port_count > 15) {
    155159                usb_log_warning("OHCI specification does not allow more than 15"
    … …  
    163167
    164168#if defined OHCI_POWER_SWITCH_no
     169        usb_log_debug("OHCI rh: Set power mode to no power switching.\n");
    165170        /* Set port power mode to no power-switching. (always on) */
    166         instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
     171        OHCI_SET(regs->rh_desc_a, RHDA_NPS_FLAG);
    167172
    168173        /* Set to no over-current reporting */
    169         instance->registers->rh_desc_a |= RHDA_NOCP_FLAG;
     174        OHCI_SET(regs->rh_desc_a, RHDA_NOCP_FLAG);
    170175
    171176#elif defined OHCI_POWER_SWITCH_ganged
    172         /* Set port power mode to no ganged power-switching. */
    173         instance->registers->rh_desc_a &= ~RHDA_NPS_FLAG;
    174         instance->registers->rh_desc_a &= ~RHDA_PSM_FLAG;
    175         instance->registers->rh_status = RHS_CLEAR_GLOBAL_POWER;
     177        usb_log_debug("OHCI rh: Set power mode to ganged power switching.\n");
     178        /* Set port power mode to ganged power-switching. */
     179        OHCI_CLR(regs->rh_desc_a, RHDA_NPS_FLAG);
     180        OHCI_CLR(regs->rh_desc_a, RHDA_PSM_FLAG);
     181
     182        /* Turn off power (hub driver will turn this back on)*/
     183        OHCI_WR(regs->rh_status, RHS_CLEAR_GLOBAL_POWER);
    176184
    177185        /* Set to global over-current */
    178         instance->registers->rh_desc_a &= ~RHDA_NOCP_FLAG;
    179         instance->registers->rh_desc_a &= ~RHDA_OCPM_FLAG;
     186        OHCI_CLR(regs->rh_desc_a, RHDA_NOCP_FLAG);
     187        OHCI_CLR(regs->rh_desc_a, RHDA_OCPM_FLAG);
    180188#else
    181         /* Set port power mode to no per port power-switching. */
    182         instance->registers->rh_desc_a &= ~RHDA_NPS_FLAG;
    183         instance->registers->rh_desc_a |= RHDA_PSM_FLAG;
     189        usb_log_debug("OHCI rh: Set power mode to per-port power switching.\n");
     190        /* Set port power mode to per port power-switching. */
     191        OHCI_CLR(regs->rh_desc_a, RHDA_NPS_FLAG);
     192        OHCI_SET(regs->rh_desc_a, RHDA_PSM_FLAG);
    184193
    185194        /* Control all ports by global switch and turn them off */
    186         instance->registers->rh_desc_b &= (RHDB_PCC_MASK << RHDB_PCC_SHIFT);
    187         instance->registers->rh_status = RHS_CLEAR_GLOBAL_POWER;
     195        OHCI_CLR(regs->rh_desc_b, RHDB_PCC_MASK << RHDB_PCC_SHIFT);
     196        OHCI_WR(regs->rh_status, RHS_CLEAR_GLOBAL_POWER);
    188197
    189198        /* Return control to per port state */
    190         instance->registers->rh_desc_b |=
    191                 ((1 << (instance->port_count + 1)) - 1) << RHDB_PCC_SHIFT;
     199        OHCI_SET(regs->rh_desc_b, RHDB_PCC_MASK << RHDB_PCC_SHIFT);
    192200
    193201        /* Set per port over-current */
    194         instance->registers->rh_desc_a &= ~RHDA_NOCP_FLAG;
    195         instance->registers->rh_desc_a |= RHDA_OCPM_FLAG;
     202        OHCI_CLR(regs->rh_desc_a, RHDA_NOCP_FLAG);
     203        OHCI_SET(regs->rh_desc_a, RHDA_OCPM_FLAG);
    196204#endif
    197205
    … …  
    202210            instance->port_count);
    203211}
    204 /*----------------------------------------------------------------------------*/
     212
    205213/**
    206214 * Process root hub request.
    … …  
    226234                fibril_mutex_lock(&instance->guard);
    227235                assert(instance->unfinished_interrupt_transfer == NULL);
    228                 uint16_t mask = create_interrupt_mask(instance);
     236                const uint16_t mask = create_interrupt_mask(instance);
    229237                if (mask == 0) {
    230                         usb_log_debug("No changes...\n");
     238                        usb_log_debug("No changes(%hx)...\n", mask);
    231239                        instance->unfinished_interrupt_transfer = request;
    232240                } else {
    … …  
    243251        }
    244252}
    245 /*----------------------------------------------------------------------------*/
     253
    246254/**
    247255 * Process interrupt on a hub device.
    … …  
    257265        if (instance->unfinished_interrupt_transfer) {
    258266                usb_log_debug("Finalizing interrupt transfer\n");
    259                 uint16_t mask = create_interrupt_mask(instance);
     267                const uint16_t mask = create_interrupt_mask(instance);
    260268                interrupt_request(instance->unfinished_interrupt_transfer,
    261269                    mask, instance->interrupt_mask_size);
    … …  
    264272        fibril_mutex_unlock(&instance->guard);
    265273}
    266 /*----------------------------------------------------------------------------*/
     274
    267275/**
    268276 * Create hub descriptor.
    … …  
    282290        instance->hub_descriptor_size = size;
    283291
    284         uint32_t hub_desc = instance->registers->rh_desc_a;
    285         uint32_t port_desc = instance->registers->rh_desc_b;
     292        const uint32_t hub_desc = OHCI_RD(instance->registers->rh_desc_a);
     293        const uint32_t port_desc = OHCI_RD(instance->registers->rh_desc_b);
    286294
    287295        /* bDescLength */
    … …  
    305313        instance->descriptors.hub[4] = 0;
    306314        /* bPwrOn2PwrGood */
    307         instance->descriptors.hub[5] =
    308             (hub_desc >> RHDA_POTPGT_SHIFT) & RHDA_POTPGT_MASK;
     315        instance->descriptors.hub[5] = hub_desc >> RHDA_POTPGT_SHIFT;
    309316        /* bHubContrCurrent, root hubs don't need no power. */
    310317        instance->descriptors.hub[6] = 0;
    311318
    312319        /* Device Removable and some legacy 1.0 stuff*/
    313         instance->descriptors.hub[7] =
    314             (port_desc >> RHDB_DR_SHIFT) & RHDB_DR_MASK & 0xff;
     320        instance->descriptors.hub[7] = (port_desc >> RHDB_DR_SHIFT) & 0xff;
    315321        instance->descriptors.hub[8] = 0xff;
    316322        if (instance->interrupt_mask_size == 2) {
    317323                instance->descriptors.hub[8] =
    318                     (port_desc >> RHDB_DR_SHIFT) & RHDB_DR_MASK >> 8;
     324                    (port_desc >> RHDB_DR_SHIFT) >> 8;
    319325                instance->descriptors.hub[9]  = 0xff;
    320326                instance->descriptors.hub[10] = 0xff;
    321327        }
    322328}
    323 /*----------------------------------------------------------------------------*/
     329
    324330/** Initialize hub descriptors.
    325331 *
    … …  
    341347            instance->interrupt_mask_size;
    342348
    343         instance->descriptors.configuration.total_length =
     349        instance->descriptors.configuration.total_length = uint16_host2usb(
    344350            sizeof(usb_standard_configuration_descriptor_t) +
    345351            sizeof(usb_standard_endpoint_descriptor_t) +
    346352            sizeof(usb_standard_interface_descriptor_t) +
    347             instance->hub_descriptor_size;
    348 }
    349 /*----------------------------------------------------------------------------*/
     353            instance->hub_descriptor_size);
     354}
     355
    350356/**
    351357 * Create bitmap of changes to answer status interrupt.
    … …  
    364370
    365371        /* Only local power source change and over-current change can happen */
    366         if (instance->registers->rh_status & (RHS_LPSC_FLAG | RHS_OCIC_FLAG)) {
     372        if (OHCI_RD(instance->registers->rh_status)
     373            & (RHS_LPSC_FLAG | RHS_OCIC_FLAG)) {
    367374                mask |= 1;
    368375        }
    369376        for (size_t port = 1; port <= instance->port_count; ++port) {
    370377                /* Write-clean bits are those that indicate change */
    371                 if (RHPS_CHANGE_WC_MASK
    372                     & instance->registers->rh_port_status[port - 1]) {
    373 
     378                if (OHCI_RD(instance->registers->rh_port_status[port - 1])
     379                    & RHPS_CHANGE_WC_MASK) {
    374380                        mask |= (1 << port);
    375381                }
    376382        }
    377         /* USB is little endian */
    378         return host2uint32_t_le(mask);
    379 }
    380 /*----------------------------------------------------------------------------*/
     383        usb_log_debug2("OHCI root hub interrupt mask: %hx.\n", mask);
     384        return uint16_host2usb(mask);
     385}
     386
    381387/**
    382388 * Create answer to status request.
    … …  
    396402        usb_device_request_setup_packet_t *request_packet =
    397403            (usb_device_request_setup_packet_t*)request->setup_buffer;
     404
     405        const uint16_t index = uint16_usb2host(request_packet->index);
    398406
    399407        switch (request_packet->request_type)
    … …  
    406414                        TRANSFER_END(request, EOVERFLOW);
    407415                } else {
    408                         uint32_t data = instance->registers->rh_status &
    409                             (RHS_LPS_FLAG | RHS_LPSC_FLAG
    410                                 | RHS_OCI_FLAG | RHS_OCIC_FLAG);
     416                        const uint32_t data =
     417                            OHCI_RD(instance->registers->rh_status) &
     418                                (RHS_LPS_FLAG | RHS_LPSC_FLAG
     419                                    | RHS_OCI_FLAG | RHS_OCIC_FLAG);
    411420                        TRANSFER_END_DATA(request, &data, sizeof(data));
    412421                }
    … …  
    420429                        TRANSFER_END(request, EOVERFLOW);
    421430                } else {
    422                         unsigned port = request_packet->index;
     431                        const unsigned port = index;
    423432                        if (port < 1 || port > instance->port_count)
    424433                                TRANSFER_END(request, EINVAL);
    425 
    426                         uint32_t data =
    427                             instance->registers->rh_port_status[port - 1];
     434                        /* Register format matches the format of port status
     435                         * field */
     436                        const uint32_t data = uint32_host2usb(OHCI_RD(
     437                            instance->registers->rh_port_status[port - 1]));
    428438                        TRANSFER_END_DATA(request, &data, sizeof(data));
    429439                }
    … …  
    434444                        TRANSFER_END(request, EOVERFLOW);
    435445                } else {
    436                         uint16_t data =
     446                        const uint16_t data =
    437447                            uint16_host2usb(USB_DEVICE_STATUS_SELF_POWERED);
    438448                        TRANSFER_END_DATA(request, &data, sizeof(data));
    … …  
    441451        case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE):
    442452                /* Hubs are allowed to have only one interface */
    443                 if (request_packet->index != 0)
     453                if (index != 0)
    444454                        TRANSFER_END(request, EINVAL);
    445455                /* Fall through, as the answer will be the same: 0x0000 */
    446456        case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT):
    447457                /* Endpoint 0 (default control) and 1 (interrupt) */
    448                 if (request_packet->index >= 2)
     458                if (index >= 2)
    449459                        TRANSFER_END(request, EINVAL);
    450460
    … …  
    455465                } else {
    456466                        /* Endpoints are OK. (We don't halt) */
    457                         uint16_t data = 0;
     467                        const uint16_t data = 0;
    458468                        TRANSFER_END_DATA(request, &data, sizeof(data));
    459469                }
    … …  
    465475
    466476}
    467 /*----------------------------------------------------------------------------*/
     477
    468478/**
    469479 * Create answer to a descriptor request.
    … …  
    482492        usb_device_request_setup_packet_t *setup_request =
    483493            (usb_device_request_setup_packet_t *) request->setup_buffer;
    484         uint16_t setup_request_value = setup_request->value_high;
    485         switch (setup_request_value)
     494        /* "The wValue field specifies the descriptor type in the high byte
     495         * and the descriptor index in the low byte (refer to Table 9-5)." */
     496        const int desc_type = uint16_usb2host(setup_request->value) >> 8;
     497        switch (desc_type)
    486498        {
    487499        case USB_DESCTYPE_HUB:
    … …  
    530542                    setup_request->value,
    531543                    setup_request->request_type, setup_request->request,
    532                     setup_request_value, setup_request->index,
     544                    desc_type, setup_request->index,
    533545                    setup_request->length);
    534546                TRANSFER_END(request, EINVAL);
    … …  
    537549        TRANSFER_END(request, ENOTSUP);
    538550}
    539 /*----------------------------------------------------------------------------*/
     551
    540552/**
    541553 * process feature-enabling request on hub
    … …  
    554566                return EINVAL;
    555567
    556         switch (feature)
    557         {
    558         case USB_HUB_FEATURE_PORT_POWER:   //8
    559                 /* No power switching */
    560                 if (instance->registers->rh_desc_a & RHDA_NPS_FLAG)
    561                         return EOK;
    562                 /* Ganged power switching */
    563                 if (!(instance->registers->rh_desc_a & RHDA_PSM_FLAG)) {
    564                         instance->registers->rh_status = RHS_SET_GLOBAL_POWER;
    565                         return EOK;
     568        switch (feature) {
     569        case USB_HUB_FEATURE_PORT_POWER:   /*8*/
     570                {
     571                        const uint32_t rhda =
     572                            OHCI_RD(instance->registers->rh_desc_a);
     573                        /* No power switching */
     574                        if (rhda & RHDA_NPS_FLAG)
     575                                return EOK;
     576                        /* Ganged power switching, one port powers all */
     577                        if (!(rhda & RHDA_PSM_FLAG)) {
     578                                OHCI_WR(instance->registers->rh_status,
     579                                    RHS_SET_GLOBAL_POWER);
     580                                return EOK;
     581                        }
    566582                }
    567         case USB_HUB_FEATURE_PORT_ENABLE:  //1
    568         case USB_HUB_FEATURE_PORT_SUSPEND: //2
    569         case USB_HUB_FEATURE_PORT_RESET:   //4
    570                 /* Nice thing is that these shifts correspond to the position
    571                  * of control bits in register */
    572                 instance->registers->rh_port_status[port - 1] = (1 << feature);
     583                        /* Fall through */
     584        case USB_HUB_FEATURE_PORT_ENABLE:  /*1*/
     585        case USB_HUB_FEATURE_PORT_SUSPEND: /*2*/
     586        case USB_HUB_FEATURE_PORT_RESET:   /*4*/
     587                usb_log_debug2("Setting port POWER, ENABLE, SUSPEND or RESET "
     588                    "on port %"PRIu16".\n", port);
     589                OHCI_WR(instance->registers->rh_port_status[port - 1],
     590                    1 << feature);
    573591                return EOK;
    574592        default:
    … …  
    576594        }
    577595}
    578 /*----------------------------------------------------------------------------*/
     596
    579597/**
    580598 * Process feature clear request.
    … …  
    596614        switch (feature)
    597615        {
    598         case USB_HUB_FEATURE_PORT_POWER:          //8
    599                 /* No power switching */
    600                 if (instance->registers->rh_desc_a & RHDA_NPS_FLAG)
    601                         return ENOTSUP;
    602                 /* Ganged power switching */
    603                 if (!(instance->registers->rh_desc_a & RHDA_PSM_FLAG)) {
    604                         instance->registers->rh_status = RHS_CLEAR_GLOBAL_POWER;
     616        case USB_HUB_FEATURE_PORT_POWER:          /*8*/
     617                {
     618                        const uint32_t rhda =
     619                            OHCI_RD(instance->registers->rh_desc_a);
     620                        /* No power switching */
     621                        if (rhda & RHDA_NPS_FLAG)
     622                                return ENOTSUP;
     623                        /* Ganged power switching, one port powers all */
     624                        if (!(rhda & RHDA_PSM_FLAG)) {
     625                                OHCI_WR(instance->registers->rh_status,
     626                                    RHS_CLEAR_GLOBAL_POWER);
     627                                return EOK;
     628                        }
     629                        OHCI_WR(instance->registers->rh_port_status[port - 1],
     630                            RHPS_CLEAR_PORT_POWER);
    605631                        return EOK;
    606632                }
    607                 instance->registers->rh_port_status[port - 1] =
    608                         RHPS_CLEAR_PORT_POWER;
     633
     634        case USB_HUB_FEATURE_PORT_ENABLE:         /*1*/
     635                OHCI_WR(instance->registers->rh_port_status[port - 1],
     636                    RHPS_CLEAR_PORT_ENABLE);
    609637                return EOK;
    610638
    611         case USB_HUB_FEATURE_PORT_ENABLE:         //1
    612                 instance->registers->rh_port_status[port - 1] =
    613                         RHPS_CLEAR_PORT_ENABLE;
     639        case USB_HUB_FEATURE_PORT_SUSPEND:        /*2*/
     640                OHCI_WR(instance->registers->rh_port_status[port - 1],
     641                    RHPS_CLEAR_PORT_SUSPEND);
    614642                return EOK;
    615643
    616         case USB_HUB_FEATURE_PORT_SUSPEND:        //2
    617                 instance->registers->rh_port_status[port - 1] =
    618                         RHPS_CLEAR_PORT_SUSPEND;
    619                 return EOK;
    620 
    621         case USB_HUB_FEATURE_C_PORT_CONNECTION:   //16
    622         case USB_HUB_FEATURE_C_PORT_ENABLE:       //17
    623         case USB_HUB_FEATURE_C_PORT_SUSPEND:      //18
    624         case USB_HUB_FEATURE_C_PORT_OVER_CURRENT: //19
    625         case USB_HUB_FEATURE_C_PORT_RESET:        //20
    626                 /* Nice thing is that these shifts correspond to the position
    627                  * of control bits in register */
    628                 instance->registers->rh_port_status[port - 1] = (1 << feature);
     644        case USB_HUB_FEATURE_C_PORT_CONNECTION:   /*16*/
     645        case USB_HUB_FEATURE_C_PORT_ENABLE:       /*17*/
     646        case USB_HUB_FEATURE_C_PORT_SUSPEND:      /*18*/
     647        case USB_HUB_FEATURE_C_PORT_OVER_CURRENT: /*19*/
     648        case USB_HUB_FEATURE_C_PORT_RESET:        /*20*/
     649                usb_log_debug2("Clearing port C_CONNECTION, C_ENABLE, "
     650                    "C_SUSPEND, C_OC or C_RESET on port %"PRIu16".\n", port);
     651                /* Bit offsets correspond to the feature number */
     652                OHCI_WR(instance->registers->rh_port_status[port - 1],
     653                    1 << feature);
    629654                return EOK;
    630655
    … …  
    633658        }
    634659}
    635 /*----------------------------------------------------------------------------*/
     660
    636661/**
    637662 * process one of requests that do not request nor carry additional data
    … …  
    654679        case USB_HUB_REQ_TYPE_SET_PORT_FEATURE:
    655680                usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    656                 int ret = set_feature_port(instance,
     681                const int ret = set_feature_port(instance,
    657682                    setup_request->value, setup_request->index);
    658683                TRANSFER_END(request, ret);
    … …  
    671696        }
    672697}
    673 /*----------------------------------------------------------------------------*/
     698
    674699/**
    675700 * process one of requests that do not request nor carry additional data
    … …  
    693718        case USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE:
    694719                usb_log_debug("USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE\n");
    695                 int ret = clear_feature_port(instance,
     720                const int ret = clear_feature_port(instance,
    696721                    setup_request->value, setup_request->index);
    697722                TRANSFER_END(request, ret);
    … …  
    706731                 * as root hubs do not support local power status feature.
    707732                 * (OHCI pg. 127) */
    708                 if (setup_request->value == USB_HUB_FEATURE_C_HUB_OVER_CURRENT) {
    709                         instance->registers->rh_status = RHS_OCIC_FLAG;
     733                if (uint16_usb2host(setup_request->value)
     734                    == USB_HUB_FEATURE_C_HUB_OVER_CURRENT) {
     735                        OHCI_WR(instance->registers->rh_status, RHS_OCIC_FLAG);
    710736                        TRANSFER_END(request, EOK);
    711737                }
    … …  
    717743        }
    718744}
    719 /*----------------------------------------------------------------------------*/
     745
    720746/**
    721747 * Process hub control request.
    … …  
    771797                if (request->buffer_size == 0)
    772798                        TRANSFER_END(request, EOVERFLOW);
    773                 uint8_t config = 1;
     799                const uint8_t config = 1;
    774800                TRANSFER_END_DATA(request, &config, sizeof(config));
    775801
    … …  
    790816                        TRANSFER_END(request, EINVAL);
    791817
    792                 instance->address = setup_request->value;
     818                instance->address = uint16_usb2host(setup_request->value);
    793819                TRANSFER_END(request, EOK);
    794820
    795821        case USB_DEVREQ_SET_CONFIGURATION:
    796822                usb_log_debug("USB_DEVREQ_SET_CONFIGURATION: %u\n",
    797                     setup_request->value);
     823                    uint16_usb2host(setup_request->value));
    798824                /* We have only one configuration, it's number is 1 */
    799825                if (uint16_usb2host(setup_request->value) != 1)

  • uspace/drv/bus/usb/ohci/utils/malloc32.h

    re1e4192 r90478727  
    6363        return result;
    6464}
    65 /*----------------------------------------------------------------------------*/
     65
    6666/** Physical mallocator simulator
    6767 *
    … …  
    7171static inline void * malloc32(size_t size)
    7272        { return memalign(OHCI_ALIGN, size); }
    73 /*----------------------------------------------------------------------------*/
     73
    7474/** Physical mallocator simulator
    7575 *

  • uspace/drv/bus/usb/uhci/hc.c

    re1e4192 r90478727  
    5050static const irq_pio_range_t uhci_irq_pio_ranges[] = {
    5151        {
    52                 .base = 0,      /* filled later */
     52                .base = 0,
    5353                .size = sizeof(uhci_regs_t)
    5454        }
    … …  
    5656
    5757static const irq_cmd_t uhci_irq_commands[] = {
    58         { .cmd = CMD_PIO_READ_16, .dstarg = 1, .addr = NULL/*filled later*/},
    59         { .cmd = CMD_BTEST, .srcarg = 1, .dstarg = 2,
    60           .value = UHCI_STATUS_USED_INTERRUPTS | UHCI_STATUS_NM_INTERRUPTS },
    61         { .cmd = CMD_PREDICATE, .srcarg = 2, .value = 2 },
    62         { .cmd = CMD_PIO_WRITE_A_16, .srcarg = 1, .addr = NULL/*filled later*/},
    63         { .cmd = CMD_ACCEPT },
     58        {
     59                .cmd = CMD_PIO_READ_16,
     60                .dstarg = 1,
     61                .addr = NULL
     62        },
     63        {
     64                .cmd = CMD_AND,
     65                .srcarg = 1,
     66                .dstarg = 2,
     67                .value = UHCI_STATUS_USED_INTERRUPTS | UHCI_STATUS_NM_INTERRUPTS
     68        },
     69        {
     70                .cmd = CMD_PREDICATE,
     71                .srcarg = 2,
     72                .value = 2
     73        },
     74        {
     75                .cmd = CMD_PIO_WRITE_A_16,
     76                .srcarg = 1,
     77                .addr = NULL
     78        },
     79        {
     80                .cmd = CMD_ACCEPT
     81        }
    6482};
    6583
    … …  
    7290static int hc_debug_checker(void *arg);
    7391
    74 /*----------------------------------------------------------------------------*/
     92
    7593/** Get number of PIO ranges used in IRQ code.
    7694 * @return Number of ranges.
    … …  
    8098        return sizeof(uhci_irq_pio_ranges) / sizeof(irq_pio_range_t);
    8199}
    82 /*----------------------------------------------------------------------------*/
     100
    83101/** Get number of commands used in IRQ code.
    84102 * @return Number of commands.
    … …  
    88106        return sizeof(uhci_irq_commands) / sizeof(irq_cmd_t);
    89107}
    90 /*----------------------------------------------------------------------------*/
     108
    91109/** Generate IRQ code.
    92110 * @param[out] ranges PIO ranges buffer.
    … …  
    118136        return EOK;
    119137}
    120 /*----------------------------------------------------------------------------*/
     138
    121139/** Take action based on the interrupt cause.
    122140 *
    … …  
    175193        }
    176194}
    177 /*----------------------------------------------------------------------------*/
     195
    178196/** Initialize UHCI hc driver structure
    179197 *
    … …  
    235253        return EOK;
    236254}
    237 /*----------------------------------------------------------------------------*/
     255
    238256/** Initialize UHCI hc hw resources.
    239257 *
    … …  
    277295            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
    278296}
    279 /*----------------------------------------------------------------------------*/
     297
    280298/** Initialize UHCI hc memory structures.
    281299 *
    … …  
    319337        return EOK;
    320338}
    321 /*----------------------------------------------------------------------------*/
     339
    322340/** Initialize UHCI hc transfer lists.
    323341 *
    … …  
    381399#undef CHECK_RET_CLEAR_RETURN
    382400}
    383 /*----------------------------------------------------------------------------*/
     401
    384402/** Schedule batch for execution.
    385403 *
    … …  
    409427        return EOK;
    410428}
    411 /*----------------------------------------------------------------------------*/
     429
    412430/** Polling function, emulates interrupts.
    413431 *
    … …  
    432450        return EOK;
    433451}
    434 /*----------------------------------------------------------------------------*/
     452
    435453/** Debug function, checks consistency of memory structures.
    436454 *

  • uspace/drv/bus/usb/uhci/hw_struct/queue_head.h

    re1e4192 r90478727  
    4747        volatile link_pointer_t element;
    4848} __attribute__((packed)) qh_t;
    49 /*----------------------------------------------------------------------------*/
     49
    5050/** Initialize queue head structure
    5151 *
    … …  
    6161        instance->next = LINK_POINTER_TERM;
    6262}
    63 /*----------------------------------------------------------------------------*/
     63
    6464/** Set queue head next pointer
    6565 *
    … …  
    8181        }
    8282}
    83 /*----------------------------------------------------------------------------*/
     83
    8484/** Set queue head element pointer
    8585 *

  • uspace/drv/bus/usb/uhci/hw_struct/transfer_descriptor.c

    re1e4192 r90478727  
    107107        }
    108108}
    109 /*----------------------------------------------------------------------------*/
     109
    110110/** Convert TD status into standard error code
    111111 *
    … …  
    145145        return EOK;
    146146}
    147 /*----------------------------------------------------------------------------*/
     147
    148148/** Print values in status field (dw1) in a human readable way.
    149149 *

  • uspace/drv/bus/usb/uhci/hw_struct/transfer_descriptor.h

    re1e4192 r90478727  
    100100
    101101void td_print_status(const td_t *instance);
    102 /*----------------------------------------------------------------------------*/
     102
    103103/** Helper function for parsing actual size out of TD.
    104104 *
    … …  
    113113        return ((s >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK;
    114114}
    115 /*----------------------------------------------------------------------------*/
     115
    116116/** Check whether less than max data were received on SPD marked transfer.
    117117 *
    … …  
    129129            (instance->status | TD_STATUS_SPD_FLAG) && act_size < max_size;
    130130}
    131 /*----------------------------------------------------------------------------*/
     131
    132132/** Helper function for parsing value of toggle bit.
    133133 *
    … …  
    140140        return (instance->device & TD_DEVICE_DATA_TOGGLE_ONE_FLAG) ? 1 : 0;
    141141}
    142 /*----------------------------------------------------------------------------*/
     142
    143143/** Helper function for parsing value of active bit
    144144 *
    … …  
    151151        return (instance->status & TD_STATUS_ERROR_ACTIVE) != 0;
    152152}
    153 /*----------------------------------------------------------------------------*/
     153
    154154/** Helper function for setting IOC bit.
    155155 *
    … …  
    161161        instance->status |= TD_STATUS_IOC_FLAG;
    162162}
    163 /*----------------------------------------------------------------------------*/
     163
    164164#endif
    165165/**

  • uspace/drv/bus/usb/uhci/main.c

    re1e4192 r90478727  
    4444
    4545static int uhci_dev_add(ddf_dev_t *device);
    46 /*----------------------------------------------------------------------------*/
     46
    4747static driver_ops_t uhci_driver_ops = {
    4848        .dev_add = uhci_dev_add,
    4949};
    50 /*----------------------------------------------------------------------------*/
     50
    5151static driver_t uhci_driver = {
    5252        .name = NAME,
    5353        .driver_ops = &uhci_driver_ops
    5454};
    55 /*----------------------------------------------------------------------------*/
     55
    5656/** Initialize a new ddf driver instance for uhci hc and hub.
    5757 *
    … …  
    7575        return ret;
    7676}
    77 /*----------------------------------------------------------------------------*/
     77
    7878/** Initialize global driver structures (NONE).
    7979 *

  • uspace/drv/bus/usb/uhci/transfer_list.c

    re1e4192 r90478727  
    4242static void transfer_list_remove_batch(
    4343    transfer_list_t *instance, uhci_transfer_batch_t *uhci_batch);
    44 /*----------------------------------------------------------------------------*/
     44
    4545/** Initialize transfer list structures.
    4646 *
    … …  
    6969        return EOK;
    7070}
    71 /*----------------------------------------------------------------------------*/
     71
    7272/** Dispose transfer list structures.
    7373 *
    … …  
    9797        qh_set_next_qh(instance->queue_head, next->queue_head);
    9898}
    99 /*----------------------------------------------------------------------------*/
     99
    100100/** Add transfer batch to the list and queue.
    101101 *
    … …  
    144144        fibril_mutex_unlock(&instance->guard);
    145145}
    146 /*----------------------------------------------------------------------------*/
     146
    147147/** Add completed batches to the provided list.
    148148 *
    … …  
    171171        fibril_mutex_unlock(&instance->guard);
    172172}
    173 /*----------------------------------------------------------------------------*/
     173
    174174/** Walk the list and finish all batches with EINTR.
    175175 *
    … …  
    188188        fibril_mutex_unlock(&instance->guard);
    189189}
    190 /*----------------------------------------------------------------------------*/
     190
    191191/** Remove a transfer batch from the list and queue.
    192192 *

  • uspace/drv/bus/usb/uhci/uhci.c

    re1e4192 r90478727  
    6565        return dev->driver_data;
    6666}
    67 /*----------------------------------------------------------------------------*/
     67
    6868/** IRQ handling callback, forward status from call to diver structure.
    6969 *
    … …  
    8383        hc_interrupt(&uhci->hc, status);
    8484}
    85 /*----------------------------------------------------------------------------*/
     85
    8686/** Operations supported by the HC driver */
    8787static ddf_dev_ops_t hc_ops = {
    8888        .interfaces[USBHC_DEV_IFACE] = &hcd_iface, /* see iface.h/c */
    8989};
    90 /*----------------------------------------------------------------------------*/
     90
    9191/** Gets handle of the respective hc.
    9292 *
    … …  
    105105        return EOK;
    106106}
    107 /*----------------------------------------------------------------------------*/
     107
    108108/** USB interface implementation used by RH */
    109109static usb_iface_t usb_iface = {
    110110        .get_hc_handle = usb_iface_get_hc_handle,
    111111};
    112 /*----------------------------------------------------------------------------*/
     112
    113113/** Get root hub hw resources (I/O registers).
    114114 *
    … …  
    123123        return &rh->resource_list;
    124124}
    125 /*----------------------------------------------------------------------------*/
     125
    126126/** Interface to provide the root hub driver with hw info */
    127127static hw_res_ops_t hw_res_iface = {
    … …  
    129129        .enable_interrupt = NULL,
    130130};
    131 /*----------------------------------------------------------------------------*/
     131
    132132/** RH function support for uhci_rhd */
    133133static ddf_dev_ops_t rh_ops = {
    … …  
    135135        .interfaces[HW_RES_DEV_IFACE] = &hw_res_iface
    136136};
    137 /*----------------------------------------------------------------------------*/
     137
    138138/** Initialize hc and rh DDF structures and their respective drivers.
    139139 *

  • uspace/drv/bus/usb/uhci/uhci_batch.c

    re1e4192 r90478727  
    5858        }
    5959}
    60 /*----------------------------------------------------------------------------*/
     60
    6161/** Finishes usb_transfer_batch and destroys the structure.
    6262 *
    … …  
    7171        uhci_transfer_batch_dispose(uhci_batch);
    7272}
    73 /*----------------------------------------------------------------------------*/
     73
    7474/** Transfer batch setup table. */
    7575static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t);
    76 /*----------------------------------------------------------------------------*/
     76
    7777/** Allocate memory and initialize internal data structure.
    7878 *
    … …  
    143143        return uhci_batch;
    144144}
    145 /*----------------------------------------------------------------------------*/
     145
    146146/** Check batch TDs for activity.
    147147 *
    … …  
    196196        return true;
    197197}
    198 /*----------------------------------------------------------------------------*/
     198
    199199/** Direction to pid conversion table */
    200200static const usb_packet_id direction_pids[] = {
    … …  
    202202        [USB_DIRECTION_OUT] = USB_PID_OUT,
    203203};
    204 /*----------------------------------------------------------------------------*/
     204
    205205/** Prepare generic data transfer
    206206 *
    … …  
    259259            USB_TRANSFER_BATCH_ARGS(*uhci_batch->usb_batch));
    260260}
    261 /*----------------------------------------------------------------------------*/
     261
    262262/** Prepare generic control transfer
    263263 *
    … …  
    331331            uhci_batch->tds[td].status);
    332332}
    333 /*----------------------------------------------------------------------------*/
     333
    334334static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t) =
    335335{

  • uspace/drv/bus/usb/uhci/uhci_batch.h

    re1e4192 r90478727  
    7676            uhci_batch->td_count * sizeof(td_t);
    7777}
    78 /*----------------------------------------------------------------------------*/
     78
    7979/** Get offset to data buffer accessible to the HC hw.
    8080 * @param uhci_batch UHCI batch structure.
    … …  
    8989            uhci_batch->usb_batch->setup_size;
    9090}
    91 /*----------------------------------------------------------------------------*/
     91
    9292/** Aborts the batch.
    9393 * Sets error to EINTR and size off transferd data to 0, before finishing the
    … …  
    103103        uhci_transfer_batch_finish_dispose(uhci_batch);
    104104}
    105 /*----------------------------------------------------------------------------*/
     105
    106106/** Linked list conversion wrapper.
    107107 * @param l Linked list link.

  • uspace/drv/bus/usb/uhci/utils/malloc32.h

    re1e4192 r90478727  
    3535#define DRV_UHCI_UTILS_MALLOC32_H
    3636
     37#include <as.h>
    3738#include <assert.h>
    38 #include <unistd.h>
     39#include <ddi.h>
    3940#include <errno.h>
    4041#include <malloc.h>
    4142#include <mem.h>
    42 #include <as.h>
     43#include <unistd.h>
    4344
    4445#define UHCI_STRCUTURES_ALIGNMENT 16
    … …  
    6364        return result;
    6465}
    65 /*----------------------------------------------------------------------------*/
     66
    6667/** DMA malloc simulator
    6768 *
    … …  
    8586        return memalign(alignment, size);
    8687}
    87 /*----------------------------------------------------------------------------*/
     88
    8889/** DMA malloc simulator
    8990 *
    … …  
    9293static inline void free32(void *addr)
    9394        { free(addr); }
    94 /*----------------------------------------------------------------------------*/
     95
    9596/** Create 4KB page mapping
    9697 *
    … …  
    99100static inline void * get_page(void)
    100101{
    101         void *address = as_area_create((void *) -1, UHCI_REQUIRED_PAGE_SIZE,
    102             AS_AREA_READ | AS_AREA_WRITE);
    103         if (address == (void *) -1)
    104                 return NULL;
    105        
    106         return address;
     102        void *address, *phys;
     103        const int ret = dmamem_map_anonymous(UHCI_REQUIRED_PAGE_SIZE,
     104            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &address);
     105        return ret == EOK ? address : NULL;
    107106}
    108 /*----------------------------------------------------------------------------*/
     107
    109108static inline void return_page(void *page)
    110109{
    111         if (page)
    112                 as_area_destroy(page);
     110        dmamem_unmap_anonymous(page);
    113111}
    114112

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

    re1e4192 r90478727  
    6363        return pio_read_16(port->address);
    6464}
    65 /*----------------------------------------------------------------------------*/
     65
    6666/** Register writing helper function.
    6767 *
    … …  
    7575        pio_write_16(port->address, val);
    7676}
    77 /*----------------------------------------------------------------------------*/
     77
    7878/** Initialize UHCI root hub port instance.
    7979 *
    … …  
    127127        return EOK;
    128128}
    129 /*----------------------------------------------------------------------------*/
     129
    130130/** Cleanup UHCI root hub port instance.
    131131 *
    … …  
    141141        return;
    142142}
    143 /*----------------------------------------------------------------------------*/
     143
    144144/** Periodically checks port status and reports new devices.
    145145 *
    … …  
    210210        return EOK;
    211211}
    212 /*----------------------------------------------------------------------------*/
     212
    213213/** Callback for enabling port during adding a new device.
    214214 *
    … …  
    247247        return EOK;
    248248}
    249 /*----------------------------------------------------------------------------*/
     249
    250250/** Initialize and report connected device.
    251251 *
    … …  
    282282        return EOK;
    283283}
    284 /*----------------------------------------------------------------------------*/
     284
    285285/** Remove device.
    286286 *
    … …  
    324324        return EOK;
    325325}
    326 /*----------------------------------------------------------------------------*/
     326
    327327/** Enable or disable root hub port.
    328328 *
    … …  
    358358        return EOK;
    359359}
    360 /*----------------------------------------------------------------------------*/
     360
    361361/** Print the port status value in a human friendly way
    362362 *

  • uspace/drv/bus/usb/uhcirh/root_hub.c

    re1e4192 r90478727  
    7979        return EOK;
    8080}
    81 /*----------------------------------------------------------------------------*/
     81
    8282/** Cleanup UHCI root hub instance.
    8383 *
    … …  
    9292        }
    9393}
    94 /*----------------------------------------------------------------------------*/
     94
    9595/**
    9696 * @}

  • uspace/drv/bus/usb/usbhid/generic/hiddev.c

    re1e4192 r90478727  
    4646#include "usbhid.h"
    4747
    48 /*----------------------------------------------------------------------------*/
     48
    4949
    5050const usb_endpoint_description_t usb_hid_generic_poll_endpoint_description = {
    … …  
    6060const char *HID_GENERIC_CLASS_NAME = "hid";
    6161
    62 /*----------------------------------------------------------------------------*/
     62
    6363static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun);
    6464static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
    … …  
    6868static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
    6969    size_t size, size_t *actual_size);
    70 /*----------------------------------------------------------------------------*/
     70
    7171static usbhid_iface_t usb_generic_iface = {
    7272        .get_event = usb_generic_hid_get_event,
    … …  
    7575        .get_report_descriptor = usb_generic_get_report_descriptor
    7676};
    77 /*----------------------------------------------------------------------------*/
     77
    7878static ddf_dev_ops_t usb_generic_hid_ops = {
    7979        .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface,
    8080        .open = usb_generic_hid_client_connected
    8181};
    82 /*----------------------------------------------------------------------------*/
     82
    8383static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun)
    8484{
    … …  
    9797        return hid_dev->max_input_report_size;
    9898}
    99 /*----------------------------------------------------------------------------*/
     99
    100100static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
    101101    size_t size, size_t *act_size, int *event_nr, unsigned int flags)
    … …  
    127127        return EOK;
    128128}
    129 /*----------------------------------------------------------------------------*/
     129
    130130static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun)
    131131{
    … …  
    144144        return hid_dev->report_desc_size;
    145145}
    146 /*----------------------------------------------------------------------------*/
     146
    147147static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
    148148    size_t size, size_t *actual_size)
    … …  
    166166        return EOK;
    167167}
    168 /*----------------------------------------------------------------------------*/
     168
    169169static int usb_generic_hid_client_connected(ddf_fun_t *fun)
    170170{
    … …  
    172172        return EOK;
    173173}
    174 /*----------------------------------------------------------------------------*/
     174
    175175void usb_generic_hid_deinit(usb_hid_dev_t *hid_dev, void *data)
    176176{
    … …  
    189189        ddf_fun_destroy(fun);
    190190}
    191 /*----------------------------------------------------------------------------*/
     191
    192192int usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
    193193{
    … …  
    224224        return EOK;
    225225}
    226 /*----------------------------------------------------------------------------*/
     226
    227227bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data)
    228228{

  • uspace/drv/bus/usb/usbhid/generic/hiddev.h

    re1e4192 r90478727  
    4747const char *HID_GENERIC_CLASS_NAME;
    4848
    49 /*----------------------------------------------------------------------------*/
     49
    5050
    5151int usb_generic_hid_init(struct usb_hid_dev *hid_dev, void **data);

  • uspace/drv/bus/usb/usbhid/kbd/kbddev.c

    re1e4192 r90478727  
    7171#include "../usbhid.h"
    7272
    73 /*----------------------------------------------------------------------------*/
     73static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
     74static ddf_dev_ops_t kbdops = { .default_handler = default_connection_handler };
     75
    7476
    7577static const unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK;
    … …  
    8688static const unsigned int DEFAULT_REPEAT_DELAY = 50 * 1000;
    8789
    88 /*----------------------------------------------------------------------------*/
     90
    8991/** Keyboard polling endpoint description for boot protocol class. */
    9092const usb_endpoint_description_t usb_hid_kbd_poll_endpoint_description = {
    … …  
    101103
    102104static void usb_kbd_set_led(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev);
    103 /*----------------------------------------------------------------------------*/
     105
    104106static const uint8_t USB_KBD_BOOT_REPORT_DESCRIPTOR[] = {
    105107        0x05, 0x01,  /* Usage Page (Generic Desktop), */
    … …  
    136138        0xC0         /* End Collection */
    137139};
    138 /*----------------------------------------------------------------------------*/
     140
    139141typedef enum usb_kbd_flags {
    140142        USB_KBD_STATUS_UNINITIALIZED = 0,
    … …  
    142144        USB_KBD_STATUS_TO_DESTROY = -1
    143145} usb_kbd_flags;
    144 /*----------------------------------------------------------------------------*/
     146
    145147/* IPC method handler                                                         */
    146 /*----------------------------------------------------------------------------*/
     148
    147149/**
    148150 * Default handler for IPC methods not handled by DDF.
    … …  
    187189                        break;
    188190                }
    189                 if (kbd_dev->console_sess == NULL) {
    190                         kbd_dev->console_sess = sess;
     191                if (kbd_dev->client_sess == NULL) {
     192                        kbd_dev->client_sess = sess;
    191193                        usb_log_debug("%s: OK\n", __FUNCTION__);
    192194                        async_answer_0(icallid, EOK);
    … …  
    206208
    207209}
    208 /*----------------------------------------------------------------------------*/
     210
    209211/* Key processing functions                                                   */
    210 /*----------------------------------------------------------------------------*/
     212
    211213/**
    212214 * Handles turning of LED lights on and off.
    … …  
    281283        }
    282284}
    283 /*----------------------------------------------------------------------------*/
     285
    284286/** Send key event.
    285287 *
    … …  
    292294{
    293295        usb_log_debug2("Sending kbdev event %d/%d to the console\n", type, key);
    294         if (kbd_dev->console_sess == NULL) {
     296        if (kbd_dev->client_sess == NULL) {
    295297                usb_log_warning(
    296298                    "Connection to console not ready, key discarded.\n");
    … …  
    298300        }
    299301
    300         async_exch_t *exch = async_exchange_begin(kbd_dev->console_sess);
     302        async_exch_t *exch = async_exchange_begin(kbd_dev->client_sess);
    301303        if (exch != NULL) {
    302304                async_msg_2(exch, KBDEV_EVENT, type, key);
    … …  
    306308        }
    307309}
    308 /*----------------------------------------------------------------------------*/
     310
    309311static inline int usb_kbd_is_lock(unsigned int key_code)
    310312{
    … …  
    313315            || key_code == KC_CAPS_LOCK);
    314316}
    315 /*----------------------------------------------------------------------------*/
     317
    316318static size_t find_in_array_int32(int32_t val, int32_t *arr, size_t arr_size)
    317319{
    … …  
    324326        return (size_t) -1;
    325327}
    326 /*----------------------------------------------------------------------------*/
     328
    327329/**
    328330 * Checks if some keys were pressed or released and generates key events.
    … …  
    407409        usb_log_debug2("Stored keys %s.\n", key_buffer);
    408410}
    409 /*----------------------------------------------------------------------------*/
     411
    410412/* General kbd functions                                                      */
    411 /*----------------------------------------------------------------------------*/
     413
    412414/**
    413415 * Processes data received from the device in form of report.
    … …  
    479481        usb_kbd_check_key_changes(hid_dev, kbd_dev);
    480482}
    481 /*----------------------------------------------------------------------------*/
     483
    482484/* HID/KBD structure manipulation                                             */
    483 /*----------------------------------------------------------------------------*/
     485
    484486static int usb_kbd_create_function(usb_kbd_t *kbd_dev)
    485487{
    … …  
    499501        /* Store the initialized HID device and HID ops
    500502         * to the DDF function. */
    501         fun->ops = &kbd_dev->ops;
     503        fun->ops = &kbdops;
    502504        fun->driver_data = kbd_dev;
    503505
    … …  
    535537        return EOK;
    536538}
    537 /*----------------------------------------------------------------------------*/
     539
    538540/* API functions                                                              */
    539 /*----------------------------------------------------------------------------*/
     541
    540542/**
    541543 * Initialization of the USB/HID keyboard structure.
    … …  
    576578        fibril_mutex_initialize(&kbd_dev->repeat_mtx);
    577579        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
    578         kbd_dev->ops.default_handler = default_connection_handler;
    579580
    580581        /* Store link to HID device */
    … …  
    700701        return EOK;
    701702}
    702 /*----------------------------------------------------------------------------*/
     703
    703704bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data)
    704705{
    … …  
    714715        return true;
    715716}
    716 /*----------------------------------------------------------------------------*/
     717
    717718int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev)
    718719{
    719720        return (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
    720721}
    721 /*----------------------------------------------------------------------------*/
     722
    722723int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev)
    723724{
    724725        return (kbd_dev->initialized == USB_KBD_STATUS_TO_DESTROY);
    725726}
    726 /*----------------------------------------------------------------------------*/
     727
    727728/**
    728729 * Properly destroys the USB/HID keyboard structure.
    … …  
    737738
    738739        /* Hangup session to the console. */
    739         if (kbd_dev->console_sess)
    740                 async_hangup(kbd_dev->console_sess);
     740        if (kbd_dev->client_sess)
     741                async_hangup(kbd_dev->client_sess);
    741742
    742743        //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
    … …  
    765766        free(kbd_dev);
    766767}
    767 /*----------------------------------------------------------------------------*/
     768
    768769void usb_kbd_deinit(usb_hid_dev_t *hid_dev, void *data)
    769770{
    … …  
    778779        }
    779780}
    780 /*----------------------------------------------------------------------------*/
     781
    781782int usb_kbd_set_boot_protocol(usb_hid_dev_t *hid_dev)
    782783{

  • uspace/drv/bus/usb/usbhid/kbd/kbddev.h

    re1e4192 r90478727  
    5050struct usb_hid_dev;
    5151
    52 /*----------------------------------------------------------------------------*/
     52
    5353/**
    5454 * USB/HID keyboard device type.
    … …  
    8282        unsigned lock_keys;
    8383
    84         /** IPC session to the console device (for sending key events). */
    85         async_sess_t *console_sess;
    86 
    87         /** @todo What is this actually? */
    88         ddf_dev_ops_t ops;
     84        /** IPC session to client (for sending key events). */
     85        async_sess_t *client_sess;
    8986
    9087        /** Information for auto-repeat of keys. */
    … …  
    116113} usb_kbd_t;
    117114
    118 /*----------------------------------------------------------------------------*/
     115
    119116
    120117extern const usb_endpoint_description_t usb_hid_kbd_poll_endpoint_description;
    … …  
    123120const char *HID_KBD_CLASS_NAME;
    124121
    125 /*----------------------------------------------------------------------------*/
     122
    126123
    127124int usb_kbd_init(struct usb_hid_dev *hid_dev, void **data);

  • uspace/drv/bus/usb/usbhid/kbd/kbdrepeat.c

    re1e4192 r90478727  
    105105        }
    106106}
    107 /*----------------------------------------------------------------------------*/
     107
    108108/**
    109109 * Main routine to be executed by a fibril for handling auto-repeat.
    … …  
    132132        return EOK;
    133133}
    134 /*----------------------------------------------------------------------------*/
     134
    135135/**
    136136 * Start repeating particular key.
    … …  
    149149        fibril_mutex_unlock(&kbd->repeat_mtx);
    150150}
    151 /*----------------------------------------------------------------------------*/
     151
    152152/**
    153153 * Stop repeating particular key.

  • uspace/drv/bus/usb/usbhid/kbd/kbdrepeat.h

    re1e4192 r90478727  
    4242struct usb_kbd_t;
    4343
    44 /*----------------------------------------------------------------------------*/
     44
    4545/**
    4646 * Structure for keeping information needed for auto-repeat of keys.
    … …  
    5757} usb_kbd_repeat_t;
    5858
    59 /*----------------------------------------------------------------------------*/
     59
    6060
    6161int usb_kbd_repeat_fibril(void *arg);

  • uspace/drv/bus/usb/usbhid/main.c

    re1e4192 r90478727  
    113113        return EOK;
    114114}
    115 /*----------------------------------------------------------------------------*/
     115
    116116/**
    117117 * Callback for a device about to be removed from the driver.
    … …  
    126126        return ENOTSUP;
    127127}
    128 /*----------------------------------------------------------------------------*/
     128
    129129/**
    130130 * Callback for removing a device from the driver.
    … …  
    152152        return EOK;
    153153}
    154 /*----------------------------------------------------------------------------*/
     154
    155155/** USB generic driver callbacks */
    156156static const usb_driver_ops_t usb_hid_driver_ops = {
    … …  
    159159        .device_gone = usb_hid_device_gone,
    160160};
    161 /*----------------------------------------------------------------------------*/
     161
    162162/** The driver itself. */
    163163static const usb_driver_t usb_hid_driver = {
    … …  
    166166        .endpoints = usb_hid_endpoints
    167167};
    168 /*----------------------------------------------------------------------------*/
     168
    169169int main(int argc, char *argv[])
    170170{

  • uspace/drv/bus/usb/usbhid/mouse/mousedev.c

    re1e4192 r90478727  
    5454#define NAME "mouse"
    5555
    56 /*----------------------------------------------------------------------------*/
     56static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
     57
     58static ddf_dev_ops_t ops = { .default_handler = default_connection_handler };
     59
    5760
    5861const usb_endpoint_description_t usb_hid_mouse_poll_endpoint_description = {
    … …  
    7174static const uint8_t IDLE_RATE = 0;
    7275
    73 /*----------------------------------------------------------------------------*/
     76
    7477static const uint8_t USB_MOUSE_BOOT_REPORT_DESCRIPTOR[] = {
    7578        0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    … …  
    101104};
    102105
    103 /*----------------------------------------------------------------------------*/
     106
    104107
    105108/** Default handler for IPC methods not handled by DDF.
    … …  
    143146        }
    144147}
    145 /*----------------------------------------------------------------------------*/
     148
    146149static int get_mouse_axis_move_value(uint8_t rid, usb_hid_report_t *report,
    147150    int32_t usage)
    … …  
    221224                assert(index < mouse_dev->buttons_count);
    222225
    223                 if (mouse_dev->buttons[index] == 0 && field->value != 0) {
     226                if (mouse_dev->buttons[index] != field->value) {
    224227                        async_exch_t *exch =
    225228                            async_exchange_begin(mouse_dev->mouse_sess);
    226229                        if (exch != NULL) {
    227230                                async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
    228                                     field->usage, 1);
    229                                 async_exchange_end(exch);
    230                                 mouse_dev->buttons[index] = field->value;
    231                         }
    232 
    233                 } else if (mouse_dev->buttons[index] != 0 && field->value == 0) {
    234                         async_exch_t *exch =
    235                             async_exchange_begin(mouse_dev->mouse_sess);
    236                         if (exch != NULL) {
    237                                 async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
    238                                     field->usage, 0);
     231                                    field->usage, (field->value != 0) ? 1 : 0);
    239232                                async_exchange_end(exch);
    240233                                mouse_dev->buttons[index] = field->value;
    … …  
    252245        return true;
    253246}
    254 /*----------------------------------------------------------------------------*/
     247
    255248#define FUN_UNBIND_DESTROY(fun) \
    256249if (fun) { \
    … …  
    263256        } \
    264257} else (void)0
    265 /*----------------------------------------------------------------------------*/
     258
    266259static int usb_mouse_create_function(usb_hid_dev_t *hid_dev, usb_mouse_t *mouse)
    267260{
    … …  
    279272        }
    280273
    281         fun->ops = &mouse->ops;
     274        fun->ops = &ops;
    282275        fun->driver_data = mouse;
    283276
    … …  
    302295        }
    303296        mouse->mouse_fun = fun;
    304 
    305297        return EOK;
    306298}
    … …  
    345337        return highest_button;
    346338}
    347 /*----------------------------------------------------------------------------*/
     339
    348340int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
    349341{
    … …  
    379371        }
    380372
    381         // set handler for incoming calls
    382         mouse_dev->ops.default_handler = default_connection_handler;
    383 
    384373        // TODO: how to know if the device supports the request???
    385374        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,
    … …  
    398387        return EOK;
    399388}
    400 /*----------------------------------------------------------------------------*/
     389
    401390bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data)
    402391{
    … …  
    411400        return usb_mouse_process_report(hid_dev, mouse_dev);
    412401}
    413 /*----------------------------------------------------------------------------*/
     402
    414403void usb_mouse_deinit(usb_hid_dev_t *hid_dev, void *data)
    415404{
    … …  
    432421        free(mouse_dev);
    433422}
    434 /*----------------------------------------------------------------------------*/
     423
    435424int usb_mouse_set_boot_protocol(usb_hid_dev_t *hid_dev)
    436425{

  • uspace/drv/bus/usb/usbhid/mouse/mousedev.h

    re1e4192 r90478727  
    4242struct usb_hid_dev;
    4343
    44 /*----------------------------------------------------------------------------*/
     44
    4545
    4646/** Container for USB mouse device. */
    4747typedef struct {
    48         /** IPC session to console (consumer). */
     48        /** IPC session to consumer. */
    4949        async_sess_t *mouse_sess;
    5050
    … …  
    5353        size_t buttons_count;
    5454
    55         ddf_dev_ops_t ops;
    5655        /* DDF mouse function */
    5756        ddf_fun_t *mouse_fun;
    5857} usb_mouse_t;
    5958
    60 /*----------------------------------------------------------------------------*/
     59
    6160
    6261extern const usb_endpoint_description_t usb_hid_mouse_poll_endpoint_description;
    … …  
    6564const char *HID_MOUSE_CATEGORY;
    6665
    67 /*----------------------------------------------------------------------------*/
     66
    6867
    6968int usb_mouse_init(struct usb_hid_dev *hid_dev, void **data);
    … …  
    7574int usb_mouse_set_boot_protocol(struct usb_hid_dev *hid_dev);
    7675
    77 /*----------------------------------------------------------------------------*/
     76
    7877
    7978#endif // USB_HID_MOUSEDEV_H_

  • uspace/drv/bus/usb/usbhid/multimedia/multimedia.c

    re1e4192 r90478727  
    5454#define NAME  "multimedia-keys"
    5555
    56 /*----------------------------------------------------------------------------*/
     56
    5757/**
    5858 * Logitech UltraX device type.
    … …  
    7070
    7171
    72 /*----------------------------------------------------------------------------*/
     72
    7373/**
    7474 * Default handler for IPC methods not handled by DDF.
    … …  
    106106                async_answer_0(icallid, EINVAL);
    107107}
    108 /*----------------------------------------------------------------------------*/
     108
    109109static ddf_dev_ops_t multimedia_ops = {
    110110        .default_handler = default_connection_handler
    111111};
    112 /*----------------------------------------------------------------------------*/
     112
    113113/**
    114114 * Processes key events.
    … …  
    155155        }
    156156}
    157 /*----------------------------------------------------------------------------*/
     157
    158158int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data)
    159159{
    … …  
    216216        return EOK;
    217217}
    218 /*----------------------------------------------------------------------------*/
     218
    219219void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data)
    220220{
    … …  
    239239        }
    240240}
    241 /*----------------------------------------------------------------------------*/
     241
    242242bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data)
    243243{

  • uspace/drv/bus/usb/usbhid/multimedia/multimedia.h

    re1e4192 r90478727  
    4141struct usb_hid_dev;
    4242
    43 /*----------------------------------------------------------------------------*/
     43
    4444
    4545int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data);
    … …  
    4949bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data);
    5050
    51 /*----------------------------------------------------------------------------*/
     51
    5252
    5353#endif // USB_HID_MULTIMEDIA_H_

  • uspace/drv/bus/usb/usbhid/subdrivers.h

    re1e4192 r90478727  
    4040#include "kbd/kbddev.h"
    4141
    42 /*----------------------------------------------------------------------------*/
     42
    4343
    4444typedef struct usb_hid_subdriver_usage {
    … …  
    4747} usb_hid_subdriver_usage_t;
    4848
    49 /*----------------------------------------------------------------------------*/
     49
    5050
    5151/** Structure representing the mapping between device requirements and the
    … …  
    8181} usb_hid_subdriver_mapping_t;
    8282
    83 /*----------------------------------------------------------------------------*/
     83
    8484
    8585extern const usb_hid_subdriver_mapping_t usb_hid_subdrivers[];
    8686extern const size_t USB_HID_MAX_SUBDRIVERS;
    8787
    88 /*----------------------------------------------------------------------------*/
     88
    8989
    9090#endif /* USB_HID_SUBDRIVERS_H_ */

  • uspace/drv/bus/usb/usbhid/usbhid.c

    re1e4192 r90478727  
    5858        NULL
    5959};
    60 /*----------------------------------------------------------------------------*/
     60
    6161static int usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev)
    6262{
    … …  
    7474        return EOK;
    7575}
    76 /*----------------------------------------------------------------------------*/
     76
    7777static int usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev)
    7878{
    … …  
    9090        return EOK;
    9191}
    92 /*----------------------------------------------------------------------------*/
     92
    9393static int usb_hid_set_generic_hid_subdriver(usb_hid_dev_t *hid_dev)
    9494{
    … …  
    110110        return EOK;
    111111}
    112 /*----------------------------------------------------------------------------*/
     112
    113113static bool usb_hid_ids_match(const usb_hid_dev_t *hid_dev,
    114114    const usb_hid_subdriver_mapping_t *mapping)
    … …  
    122122            == mapping->product_id);
    123123}
    124 /*----------------------------------------------------------------------------*/
     124
    125125static bool usb_hid_path_matches(usb_hid_dev_t *hid_dev,
    126126    const usb_hid_subdriver_mapping_t *mapping)
    … …  
    178178        return matches;
    179179}
    180 /*----------------------------------------------------------------------------*/
     180
    181181static int usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev,
    182182    const usb_hid_subdriver_t **subdrivers, unsigned count)
    … …  
    211211        return EOK;
    212212}
    213 /*----------------------------------------------------------------------------*/
     213
    214214static int usb_hid_find_subdrivers(usb_hid_dev_t *hid_dev)
    215215{
    … …  
    263263        return usb_hid_save_subdrivers(hid_dev, subdrivers, count);
    264264}
    265 /*----------------------------------------------------------------------------*/
     265
    266266static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, const usb_device_t *dev)
    267267{
    … …  
    290290        return ENOTSUP;
    291291}
    292 /*----------------------------------------------------------------------------*/
     292
    293293static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
    294294{
    … …  
    322322        return EOK;
    323323}
    324 /*----------------------------------------------------------------------------*/
     324
    325325/*
    326326 * This functions initializes required structures from the device's descriptors
    … …  
    458458        return rc;
    459459}
    460 /*----------------------------------------------------------------------------*/
     460
    461461bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
    462462    size_t buffer_size, void *arg)
    … …  
    500500        return cont;
    501501}
    502 /*----------------------------------------------------------------------------*/
     502
    503503void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, void *arg)
    504504{
    … …  
    517517        hid_dev->running = false;
    518518}
    519 /*----------------------------------------------------------------------------*/
     519
    520520void usb_hid_new_report(usb_hid_dev_t *hid_dev)
    521521{
    522522        ++hid_dev->report_nr;
    523523}
    524 /*----------------------------------------------------------------------------*/
     524
    525525int usb_hid_report_number(const usb_hid_dev_t *hid_dev)
    526526{
    527527        return hid_dev->report_nr;
    528528}
    529 /*----------------------------------------------------------------------------*/
     529
    530530void usb_hid_deinit(usb_hid_dev_t *hid_dev)
    531531{

  • uspace/drv/bus/usb/usbhid/usbhid.h

    re1e4192 r90478727  
    9595};
    9696
    97 /*----------------------------------------------------------------------------*/
     97
    9898/**
    9999 * Structure for holding general HID device data.
    … …  
    132132};
    133133
    134 /*----------------------------------------------------------------------------*/
     134
    135135
    136136enum {
    … …  
    143143extern const usb_endpoint_description_t *usb_hid_endpoints[];
    144144
    145 /*----------------------------------------------------------------------------*/
     145
    146146
    147147int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev);

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

    re1e4192 r90478727  
    7070        return EOK;
    7171}
    72 /*----------------------------------------------------------------------------*/
     72
    7373/**
    7474 * Clear feature on hub port.
    … …  
    9292            sizeof(clear_request), NULL, 0);
    9393}
    94 /*----------------------------------------------------------------------------*/
     94
    9595/**
    9696 * Set feature on hub port.
    … …  
    114114            sizeof(clear_request), NULL, 0);
    115115}
    116 /*----------------------------------------------------------------------------*/
     116
    117117/**
    118118 * Mark reset process as failed due to external reasons
    … …  
    129129        fibril_mutex_unlock(&port->mutex);
    130130}
    131 /*----------------------------------------------------------------------------*/
     131
    132132/**
    133133 * Process interrupts on given port
    … …  
    245245            port->port_number, status);
    246246}
    247 /*----------------------------------------------------------------------------*/
     247
    248248/**
    249249 * routine called when a device on port has been removed
    … …  
    299299        return EOK;
    300300}
    301 /*----------------------------------------------------------------------------*/
     301
    302302/**
    303303 * Process port reset change
    … …  
    335335        }
    336336}
    337 /*----------------------------------------------------------------------------*/
     337
    338338/** Retrieve port status.
    339339 *
    … …  
    352352                .request = USB_HUB_REQUEST_GET_STATUS,
    353353                .value = 0,
    354                 .index = port->port_number,
     354                .index = uint16_host2usb(port->port_number),
    355355                .length = sizeof(usb_port_status_t),
    356356        };
    … …  
    375375        return EOK;
    376376}
    377 /*----------------------------------------------------------------------------*/
     377
    378378/** Callback for enabling a specific port.
    379379 *
    … …  
    407407        return port->reset_okay ? EOK : ESTALL;
    408408}
    409 /*----------------------------------------------------------------------------*/
     409
    410410/** Fibril for adding a new device.
    411411 *
    … …  
    454454        return rc;
    455455}
    456 /*----------------------------------------------------------------------------*/
     456
    457457/** Start device adding when connection change is detected.
    458458 *

  • uspace/drv/bus/usb/usbhub/status.h

    re1e4192 r90478727  
    4242 * should not be accessed directly, use supplied getter/setter methods.
    4343 *
    44  * For more information refer to table 11-15 in
    45  * "Universal Serial Bus Specification Revision 1.1"
     44 * For more information refer to tables 11-15 and 11-16 in
     45 * "Universal Serial Bus Specification Revision 1.1" pages 274 and 277
     46 * (290 and 293 in pdf)
    4647 *
    4748 */

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

    re1e4192 r90478727  
    165165        return EOK;
    166166}
    167 /*----------------------------------------------------------------------------*/
     167
    168168/**
    169169 * Turn off power to all ports.
    … …  
    176176        return ENOTSUP;
    177177}
    178 /*----------------------------------------------------------------------------*/
     178
    179179/**
    180180 * Remove all attached devices
    … …  
    219219        return EOK;
    220220}
    221 /*----------------------------------------------------------------------------*/
     221
    222222/** Callback for polling hub for changes.
    223223 *
    … …  
    256256        return true;
    257257}
    258 /*----------------------------------------------------------------------------*/
     258
    259259/**
    260260 * Load hub-specific information into hub_dev structure and process if needed
    … …  
    331331        return EOK;
    332332}
    333 /*----------------------------------------------------------------------------*/
     333
    334334/**
    335335 * Set configuration of and USB device
    … …  
    378378        return opResult;
    379379}
    380 /*----------------------------------------------------------------------------*/
     380
    381381/**
    382382 * Process hub over current change
    … …  
    416416
    417417}
    418 /*----------------------------------------------------------------------------*/
     418
    419419/**
    420420 * Process hub interrupts.
    … …  
    485485        }
    486486}
    487 /*----------------------------------------------------------------------------*/
     487
    488488/**
    489489 * callback called from hub polling fibril when the fibril terminates

  • uspace/drv/bus/usb/usbmast/main.c

    re1e4192 r90478727  
    302302       
    303303        (void) async_share_out_finalize(callid, &comm_buf);
    304         if (comm_buf == (void *) -1) {
     304        if (comm_buf == AS_MAP_FAILED) {
    305305                async_answer_0(callid, EHANGUP);
    306306                return;

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

    re1e4192 r90478727  
    6161        return EOK;
    6262}
    63 /*----------------------------------------------------------------------------*/
     63
    6464/** Callback when a MID device is about to be removed from the host.
    6565 *
    … …  
    115115        return ret;
    116116}
    117 /*----------------------------------------------------------------------------*/
     117
    118118/** Callback when a MID device was removed from the host.
    119119 *

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

    re1e4192 r90478727  
    120120        },
    121121        {
    122                 .cmd = CMD_BTEST,
     122                .cmd = CMD_AND,
    123123                .value = i8042_OUTPUT_FULL,
    124124                .srcarg = 1,

  • uspace/drv/infrastructure/rootmac/rootmac.c

    re1e4192 r90478727  
    5252} rootmac_fun_t;
    5353
    54 static hw_resource_t pci_conf_regs = {
    55         .type = IO_RANGE,
    56         .res.io_range = {
    57                 .address = 0xCF8,
    58                 .size = 8,
    59                 .endianness = LITTLE_ENDIAN
     54static hw_resource_t pci_conf_regs[] = {
     55        {
     56                .type = IO_RANGE,
     57                .res.io_range = {
     58                        .address = 0xfec00000,
     59                        .size = 4,
     60                        .endianness = LITTLE_ENDIAN
     61                }
     62        },
     63        {
     64                .type = IO_RANGE,
     65                .res.io_range = {
     66                        .address = 0xfee00000,
     67                        .size = 4,
     68                        .endianness = LITTLE_ENDIAN
     69                }
    6070        }
    6171};
    … …  
    6373static rootmac_fun_t pci_data = {
    6474        .hw_resources = {
    65                 1,
    66                 &pci_conf_regs
     75                2,
     76                pci_conf_regs
    6777        }
    6878};
    … …  
    127137static int rootmac_dev_add(ddf_dev_t *dev)
    128138{
     139#if 0
    129140        /* Register functions */
    130         if (!rootmac_add_fun(dev, "pci0", "pangea_pci", &pci_data))
     141        if (!rootmac_add_fun(dev, "pci0", "intel_pci", &pci_data))
    131142                ddf_msg(LVL_ERROR, "Failed to add functions for Mac platform.");
     143#else
     144        (void)pci_data;
     145        (void)rootmac_add_fun;
     146#endif
    132147       
    133148        return EOK;

  • uspace/drv/infrastructure/rootpc/rootpc.c

    re1e4192 r90478727  
    7575};
    7676
    77 static hw_resource_t pci_conf_regs = {
    78         .type = IO_RANGE,
    79         .res.io_range = {
    80                 .address = 0xCF8,
    81                 .size = 8,
    82                 .endianness = LITTLE_ENDIAN
     77static hw_resource_t pci_conf_regs[] = {
     78        {
     79                .type = IO_RANGE,
     80                .res.io_range = {
     81                        .address = 0xCF8,
     82                        .size = 4,
     83                        .endianness = LITTLE_ENDIAN
     84                }
     85        },
     86        {
     87                .type = IO_RANGE,
     88                .res.io_range = {
     89                        .address = 0xCFC,
     90                        .size = 4,
     91                        .endianness = LITTLE_ENDIAN
     92                }
    8393        }
    8494};
    … …  
    8696static rootpc_fun_t pci_data = {
    8797        .hw_resources = {
    88                 1,
    89                 &pci_conf_regs
     98                sizeof(pci_conf_regs)/sizeof(pci_conf_regs[0]),
     99                pci_conf_regs
    90100        }
    91101};

  • uspace/drv/nic/ne2k/dp8390.c

    re1e4192 r90478727  
    201201        /* Check if the DP8390 is really there */
    202202        uint8_t val = pio_read_8(ne2k->port + DP_CR);
    203         if ((val & (CR_STP | CR_DM_ABORT)) != (CR_STP | CR_DM_ABORT))
     203        if ((val & (CR_STP | CR_TXP | CR_DM_ABORT)) != (CR_STP | CR_DM_ABORT))
    204204                return EXDEV;
    205205       

  • uspace/drv/nic/ne2k/ne2k.c

    re1e4192 r90478727  
    8383        {
    8484                /* Mask supported interrupt causes */
    85                 .cmd = CMD_BTEST,
     85                .cmd = CMD_AND,
    8686                .value = (ISR_PRX | ISR_PTX | ISR_RXE | ISR_TXE | ISR_OVW |
    8787                    ISR_CNT | ISR_RDC),
Note: See TracChangeset for help on using the changeset viewer.