Changes in / [81c508c:cc44f7e] in mainline


Ignore:
Location:
uspace/drv
Files:
2 added
21 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/pciintel/pci.c

    r81c508c rcc44f7e  
    320320        /* Get the value of the BAR. */
    321321        val = pci_conf_read_32(fun, addr);
     322
     323#define IO_MASK  (~0x3)
     324#define MEM_MASK (~0xf)
    322325       
    323326        io = (bool) (val & 1);
    324327        if (io) {
    325328                addrw64 = false;
     329                mask = IO_MASK;
    326330        } else {
     331                mask = MEM_MASK;
    327332                switch ((val >> 1) & 3) {
    328333                case 0:
    … …  
    340345        /* Get the address mask. */
    341346        pci_conf_write_32(fun, addr, 0xffffffff);
    342         mask = pci_conf_read_32(fun, addr);
     347        mask &= pci_conf_read_32(fun, addr);
    343348       
    344349        /* Restore the original value. */
    … …  
    659664size_t pci_bar_mask_to_size(uint32_t mask)
    660665{
    661         return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
     666        size_t size = mask & ~(mask - 1);
     667        return size;
    662668}
    663669

  • uspace/drv/uhci-hcd/Makefile

    r81c508c rcc44f7e  
    3939        uhci.c \
    4040        uhci_struct/transfer_descriptor.c \
     41        utils/device_keeper.c \
    4142        pci.c \
    4243        batch.c

  • uspace/drv/uhci-hcd/batch.c

    r81c508c rcc44f7e  
    3333 */
    3434#include <errno.h>
     35#include <str_error.h>
    3536
    3637#include <usb/debug.h>
    … …  
    5354batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
    5455    usb_transfer_type_t transfer_type, size_t max_packet_size,
    55     dev_speed_t speed, char *buffer, size_t size,
     56    usb_speed_t speed, char *buffer, size_t size,
    5657    char* setup_buffer, size_t setup_size,
    5758    usbhc_iface_transfer_in_callback_t func_in,
    … …  
    133134
    134135        queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
     136        usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
     137            instance, target.address, target.endpoint);
    135138        return instance;
    136139}
    … …  
    139142{
    140143        assert(instance);
    141         usb_log_debug("Checking(%p) %d packet for completion.\n",
     144        usb_log_debug2("Batch(%p) checking %d packet(s) for completion.\n",
    142145            instance, instance->packets);
    143146        instance->transfered_size = 0;
    … …  
    151154                        if (i > 0)
    152155                                instance->transfered_size -= instance->setup_size;
     156                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
     157                          instance, i, instance->tds[i].status);
    153158                        return true;
    154159                }
    … …  
    156161                    transfer_descriptor_actual_size(&instance->tds[i]);
    157162        }
    158         /* This is just an ugly trick to support the old API */
    159163        instance->transfered_size -= instance->setup_size;
    160164        return true;
    … …  
    168172        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
    169173
     174        const bool low_speed = instance->speed == USB_SPEED_LOW;
    170175        int toggle = 0;
    171176        /* setup stage */
    172177        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
    173             instance->setup_size, toggle, false, instance->target,
    174             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
     178            instance->setup_size, toggle, false, low_speed,
     179            instance->target, USB_PID_SETUP, instance->setup_buffer,
     180            &instance->tds[1]);
    175181
    176182        /* data stage */
    … …  
    182188
    183189                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
    184                     instance->max_packet_size, toggle++, false, instance->target,
    185                     USB_PID_OUT, data, &instance->tds[i + 1]);
     190                    instance->max_packet_size, toggle++, false, low_speed,
     191                    instance->target, USB_PID_OUT, data, &instance->tds[i + 1]);
    186192        }
    187193
    … …  
    189195        i = instance->packets - 1;
    190196        transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
    191             0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
     197            0, 1, false, low_speed, instance->target, USB_PID_IN, NULL, NULL);
    192198
    193199        instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
     200        usb_log_debug2("Control write last TD status: %x.\n",
     201                instance->tds[i].status);
    194202
    195203        instance->next_step = batch_call_out_and_dispose;
     204        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
    196205        batch_schedule(instance);
    197206}
    … …  
    201210        assert(instance);
    202211
     212        const bool low_speed = instance->speed == USB_SPEED_LOW;
    203213        int toggle = 0;
    204214        /* setup stage */
    205215        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
    206             instance->setup_size, toggle, false, instance->target,
     216            instance->setup_size, toggle, false, low_speed, instance->target,
    207217            USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
    208218
    … …  
    215225
    216226                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
    217                     instance->max_packet_size, toggle, false, instance->target,
    218                     USB_PID_IN, data, &instance->tds[i + 1]);
     227                    instance->max_packet_size, toggle, false, low_speed,
     228                                instance->target, USB_PID_IN, data, &instance->tds[i + 1]);
    219229        }
    220230
    … …  
    222232        i = instance->packets - 1;
    223233        transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
    224             0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
     234            0, 1, false, low_speed, instance->target, USB_PID_OUT, NULL, NULL);
    225235
    226236        instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
     237        usb_log_debug2("Control read last TD status: %x.\n",
     238                instance->tds[i].status);
    227239
    228240        instance->next_step = batch_call_in_and_dispose;
     241        usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
    229242        batch_schedule(instance);
    230243}
    … …  
    234247        assert(instance);
    235248
     249        const bool low_speed = instance->speed == USB_SPEED_LOW;
    236250        int toggle = 1;
    237251        size_t i = 0;
    … …  
    244258
    245259                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
    246                     instance->max_packet_size, toggle, false, instance->target,
    247                     USB_PID_IN, data, next);
     260                    instance->max_packet_size, toggle, false, low_speed,
     261                    instance->target, USB_PID_IN, data, next);
    248262        }
    249263
    … …  
    251265
    252266        instance->next_step = batch_call_in_and_dispose;
     267        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
    253268        batch_schedule(instance);
    254269}
    … …  
    260275        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
    261276
     277        const bool low_speed = instance->speed == USB_SPEED_LOW;
    262278        int toggle = 1;
    263279        size_t i = 0;
    … …  
    270286
    271287                transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
    272                     instance->max_packet_size, toggle++, false, instance->target,
    273                     USB_PID_OUT, data, next);
     288                    instance->max_packet_size, toggle++, false, low_speed,
     289                    instance->target, USB_PID_OUT, data, next);
    274290        }
    275291
    … …  
    277293
    278294        instance->next_step = batch_call_out_and_dispose;
     295        usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
    279296        batch_schedule(instance);
    280297}
    … …  
    288305
    289306        int err = instance->error;
    290         usb_log_info("Callback IN(%d): %d, %zu.\n", instance->transfer_type,
    291             err, instance->transfered_size);
     307        usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
     308            instance, instance->transfer_type, str_error(err), err,
     309            instance->transfered_size);
    292310
    293311        instance->callback_in(instance->fun,
    … …  
    302320
    303321        int err = instance->error;
    304         usb_log_info("Callback OUT(%d): %d.\n", instance->transfer_type, err);
     322        usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
     323            instance, instance->transfer_type, str_error(err), err);
    305324        instance->callback_out(instance->fun,
    306325            err, instance->arg);
    … …  
    311330        assert(instance);
    312331        batch_call_in(instance);
    313         usb_log_debug("Disposing batch: %p.\n", instance);
     332        usb_log_debug("Batch(%p) disposing.\n", instance);
    314333        free32(instance->tds);
    315334        free32(instance->qh);
    … …  
    323342        assert(instance);
    324343        batch_call_out(instance);
    325         usb_log_debug("Disposing batch: %p.\n", instance);
     344        usb_log_debug("Batch(%p) disposing.\n", instance);
    326345        free32(instance->tds);
    327346        free32(instance->qh);
    … …  
    338357        return uhci_schedule(hc, instance);
    339358}
    340 /*----------------------------------------------------------------------------*/
    341 /* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
    342 void batch_control_setup_old(batch_t *instance)
    343 {
    344         assert(instance);
    345         instance->packets = 1;
    346 
    347         /* setup stage */
    348         transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
    349             instance->setup_size, 0, false, instance->target,
    350             USB_PID_SETUP, instance->setup_buffer, NULL);
    351 
    352         instance->next_step = batch_call_out_and_dispose;
    353         batch_schedule(instance);
    354 }
    355 /*----------------------------------------------------------------------------*/
    356 void batch_control_write_data_old(batch_t *instance)
    357 {
    358         assert(instance);
    359         instance->packets -= 2;
    360         batch_interrupt_out(instance);
    361 }
    362 /*----------------------------------------------------------------------------*/
    363 void batch_control_read_data_old(batch_t *instance)
    364 {
    365         assert(instance);
    366         instance->packets -= 2;
    367         batch_interrupt_in(instance);
    368 }
    369 /*----------------------------------------------------------------------------*/
    370 void batch_control_write_status_old(batch_t *instance)
    371 {
    372         assert(instance);
    373         instance->packets = 1;
    374         transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
    375             0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
    376         instance->next_step = batch_call_in_and_dispose;
    377         batch_schedule(instance);
    378 }
    379 /*----------------------------------------------------------------------------*/
    380 void batch_control_read_status_old(batch_t *instance)
    381 {
    382         assert(instance);
    383         instance->packets = 1;
    384         transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
    385             0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
    386         instance->next_step = batch_call_out_and_dispose;
    387         batch_schedule(instance);
    388 }
    389359/**
    390360 * @}

  • uspace/drv/uhci-hcd/batch.h

    r81c508c rcc44f7e  
    4343#include "uhci_struct/queue_head.h"
    4444
    45 typedef enum {
    46         LOW_SPEED,
    47         FULL_SPEED,
    48 } dev_speed_t;
    49 
    5045typedef struct batch
    5146{
    5247        link_t link;
    53         dev_speed_t speed;
     48        usb_speed_t speed;
    5449        usb_target_t target;
    5550        usb_transfer_type_t transfer_type;
    … …  
    7671batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
    7772    usb_transfer_type_t transfer_type, size_t max_packet_size,
    78     dev_speed_t speed, char *buffer, size_t size,
     73    usb_speed_t speed, char *buffer, size_t size,
    7974                char *setup_buffer, size_t setup_size,
    8075    usbhc_iface_transfer_in_callback_t func_in,

  • uspace/drv/uhci-hcd/iface.c

    r81c508c rcc44f7e  
    4141#include "iface.h"
    4242#include "uhci.h"
     43#include "utils/device_keeper.h"
    4344
    4445/*----------------------------------------------------------------------------*/
    … …  
    4849        uhci_t *hc = fun_to_uhci(fun);
    4950        assert(hc);
    50         usb_address_keeping_reserve_default(&hc->address_manager);
     51        usb_log_debug("Default address request with speed %d.\n", speed);
     52        device_keeper_reserve_default(&hc->device_manager, speed);
    5153        return EOK;
    5254}
    … …  
    5759        uhci_t *hc = fun_to_uhci(fun);
    5860        assert(hc);
    59         usb_address_keeping_release_default(&hc->address_manager);
     61        usb_log_debug("Default address release.\n");
     62        device_keeper_release_default(&hc->device_manager);
    6063        return EOK;
    6164}
    … …  
    6770        uhci_t *hc = fun_to_uhci(fun);
    6871        assert(hc);
    69         *address = usb_address_keeping_request(&hc->address_manager);
     72        assert(address);
     73
     74        usb_log_debug("Address request with speed %d.\n", speed);
     75        *address = device_keeper_request(&hc->device_manager, speed);
     76        usb_log_debug("Address request with result: %d.\n", *address);
    7077        if (*address <= 0)
    7178          return *address;
    … …  
    7986        uhci_t *hc = fun_to_uhci(fun);
    8087        assert(hc);
    81         usb_address_keeping_devman_bind(&hc->address_manager, address, handle);
     88        usb_log_debug("Address bind %d-%d.\n", address, handle);
     89        device_keeper_bind(&hc->device_manager, address, handle);
    8290        return EOK;
    8391}
    … …  
    8896        uhci_t *hc = fun_to_uhci(fun);
    8997        assert(hc);
    90         usb_address_keeping_release_default(&hc->address_manager);
     98        usb_log_debug("Address release %d.\n", address);
     99        device_keeper_release(&hc->device_manager, address);
    91100        return EOK;
    92101}
    93102/*----------------------------------------------------------------------------*/
    94103static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
    95     size_t max_packet_size,
    96     void *data, size_t size,
     104    size_t max_packet_size, void *data, size_t size,
    97105    usbhc_iface_transfer_out_callback_t callback, void *arg)
    98106{
    99         dev_speed_t speed = FULL_SPEED;
     107        assert(fun);
     108        uhci_t *hc = fun_to_uhci(fun);
     109        assert(hc);
     110        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     111
     112        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
     113            target.address, target.endpoint, size, max_packet_size);
    100114
    101115        batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    … …  
    108122/*----------------------------------------------------------------------------*/
    109123static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
    110     size_t max_packet_size,
    111     void *data, size_t size,
     124    size_t max_packet_size, void *data, size_t size,
    112125    usbhc_iface_transfer_in_callback_t callback, void *arg)
    113126{
    114         dev_speed_t speed = FULL_SPEED;
     127        assert(fun);
     128        uhci_t *hc = fun_to_uhci(fun);
     129        assert(hc);
     130        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     131        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
     132            target.address, target.endpoint, size, max_packet_size);
    115133
    116134        batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    … …  
    127145    usbhc_iface_transfer_out_callback_t callback, void *arg)
    128146{
    129         dev_speed_t speed = FULL_SPEED;
     147        assert(fun);
     148        uhci_t *hc = fun_to_uhci(fun);
     149        assert(hc);
     150        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     151        usb_log_debug("Control WRITE %d:%d %zu(%zu).\n",
     152            target.address, target.endpoint, size, max_packet_size);
    130153
    131154        batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    … …  
    143166    usbhc_iface_transfer_in_callback_t callback, void *arg)
    144167{
    145         dev_speed_t speed = FULL_SPEED;
    146 
     168        assert(fun);
     169        uhci_t *hc = fun_to_uhci(fun);
     170        assert(hc);
     171        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     172
     173        usb_log_debug("Control READ %d:%d %zu(%zu).\n",
     174            target.address, target.endpoint, size, max_packet_size);
    147175        batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    148176            max_packet_size, speed, data, size, setup_data, setup_size, callback,

  • uspace/drv/uhci-hcd/main.c

    r81c508c rcc44f7e  
    8282        usb_log_info("uhci_add_device() called\n");
    8383
    84 
    85         uintptr_t io_reg_base;
    86         size_t io_reg_size;
    87         int irq;
     84        uintptr_t io_reg_base = 0;
     85        size_t io_reg_size = 0;
     86        int irq = 0;
    8887
    8988        int ret =
    … …  
    9594            io_reg_base, io_reg_size, irq);
    9695
    97         ret = pci_enable_interrupts(device);
    98         CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
     96//      ret = pci_enable_interrupts(device);
     97//      CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
    9998
    10099        uhci_t *uhci_hc = malloc(sizeof(uhci_t));
    … …  
    114113         */
    115114        device->driver_data = uhci_hc;
    116 
    117115        ret = register_interrupt_handler(device, irq, irq_handler,
    118116            &uhci_hc->interrupt_code);
    … …  
    149147{
    150148        sleep(3);
    151         usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
     149        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
    152150
    153151        return ddf_driver_main(&uhci_driver);

  • uspace/drv/uhci-hcd/pci.c

    r81c508c rcc44f7e  
    3838#include <devman.h>
    3939#include <device/hw_res.h>
     40
     41#include <usb/debug.h>
    4042
    4143#include "pci.h"
    … …  
    8385                                irq = res->res.interrupt.irq;
    8486                                irq_found = true;
     87                                usb_log_debug2("Found interrupt: %d.\n", irq);
    8588                                break;
    8689                        case IO_RANGE:
    87                                 io_address = (uintptr_t)
    88                                     res->res.io_range.address;
     90                                io_address = res->res.io_range.address;
    8991                                io_size = res->res.io_range.size;
     92                                usb_log_debug2("Found io: %llx %zu.\n",
     93                                    res->res.io_range.address, res->res.io_range.size);
    9094                                io_found = true;
    9195                                break;
    … …  
    105109        }
    106110
    107         if (io_reg_address != NULL) {
    108                 *io_reg_address = io_address;
    109         }
    110         if (io_reg_size != NULL) {
    111                 *io_reg_size = io_size;
    112         }
    113         if (irq_no != NULL) {
    114                 *irq_no = irq;
    115         }
     111        *io_reg_address = io_address;
     112        *io_reg_size = io_size;
     113        *irq_no = irq;
    116114
    117115        rc = EOK;
    … …  
    127125            IPC_FLAG_BLOCKING);
    128126        bool enabled = hw_res_enable_interrupt(parent_phone);
     127        async_hangup(parent_phone);
    129128        return enabled ? EOK : EIO;
    130129}

  • uspace/drv/uhci-hcd/root_hub.c

    r81c508c rcc44f7e  
    3434#include <assert.h>
    3535#include <errno.h>
     36#include <str_error.h>
    3637#include <stdio.h>
     38#include <ops/hw_res.h>
     39
    3740#include <usb_iface.h>
    3841#include <usb/debug.h>
    … …  
    4144#include "uhci.h"
    4245
     46/*----------------------------------------------------------------------------*/
    4347static int usb_iface_get_hc_handle_rh_impl(ddf_fun_t *root_hub_fun,
    4448    devman_handle_t *handle)
    … …  
    5155        return EOK;
    5256}
    53 
     57/*----------------------------------------------------------------------------*/
    5458static int usb_iface_get_address_rh_impl(ddf_fun_t *fun, devman_handle_t handle,
    5559    usb_address_t *address)
    … …  
    6165        assert(hc);
    6266
    63         usb_address_t addr = usb_address_keeping_find(&hc->address_manager,
     67        usb_address_t addr = device_keeper_find(&hc->device_manager,
    6468            handle);
    6569        if (addr < 0) {
    … …  
    7377        return EOK;
    7478}
    75 
     79/*----------------------------------------------------------------------------*/
    7680usb_iface_t usb_iface_root_hub_fun_impl = {
    7781        .get_hc_handle = usb_iface_get_hc_handle_rh_impl,
    7882        .get_address = usb_iface_get_address_rh_impl
    7983};
     84/*----------------------------------------------------------------------------*/
     85static hw_resource_list_t *get_resource_list(ddf_fun_t *dev)
     86{
     87        assert(dev);
     88        ddf_fun_t *hc_ddf_instance = dev->driver_data;
     89        assert(hc_ddf_instance);
     90        uhci_t *hc = hc_ddf_instance->driver_data;
     91        assert(hc);
    8092
     93        //TODO: fix memory leak
     94        hw_resource_list_t *resource_list = malloc(sizeof(hw_resource_list_t));
     95        assert(resource_list);
     96        resource_list->count = 1;
     97        resource_list->resources = malloc(sizeof(hw_resource_t));
     98        assert(resource_list->resources);
     99        resource_list->resources[0].type = IO_RANGE;
     100        resource_list->resources[0].res.io_range.address =
     101            ((uintptr_t)hc->registers) + 0x10; // see UHCI design guide
     102        resource_list->resources[0].res.io_range.size = 4;
     103        resource_list->resources[0].res.io_range.endianness = LITTLE_ENDIAN;
     104
     105        return resource_list;
     106}
     107/*----------------------------------------------------------------------------*/
     108static hw_res_ops_t hw_res_iface = {
     109        .get_resource_list = get_resource_list,
     110        .enable_interrupt = NULL
     111};
     112/*----------------------------------------------------------------------------*/
    81113static ddf_dev_ops_t root_hub_ops = {
    82         .interfaces[USB_DEV_IFACE] = &usb_iface_root_hub_fun_impl
     114        .interfaces[USB_DEV_IFACE] = &usb_iface_root_hub_fun_impl,
     115        .interfaces[HW_RES_DEV_IFACE] = &hw_res_iface
    83116};
    84 
    85117/*----------------------------------------------------------------------------*/
    86118int setup_root_hub(ddf_fun_t **fun, ddf_dev_t *hc)
    87119{
    88120        assert(fun);
     121        assert(hc);
    89122        int ret;
    90123
    … …  
    105138        ret = ddf_fun_add_match_id(hub, match_str, 100);
    106139        if (ret != EOK) {
    107                 usb_log_error("Failed to add root hub match id.\n");
     140                usb_log_error("Failed(%d) to add root hub match id: %s\n",
     141                    ret, str_error(ret));
    108142                ddf_fun_destroy(hub);
    109                 return ENOMEM;
     143                return ret;
    110144        }
    111145

  • uspace/drv/uhci-hcd/transfer_list.c

    r81c508c rcc44f7e  
    7070        assert(instance);
    7171        assert(batch);
     72        usb_log_debug2("Adding batch(%p) to queue %s.\n", batch, instance->name);
    7273
    7374        uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
    … …  
    8384                list_append(&batch->link, &instance->batch_list);
    8485                instance->queue_head->element = pa;
    85                 usb_log_debug2("Added batch(%p) to queue %s first.\n",
     86                usb_log_debug("Batch(%p) added to queue %s first.\n",
    8687                        batch, instance->name);
    8788                fibril_mutex_unlock(&instance->guard);
    … …  
    9697        queue_head_append_qh(last->qh, pa);
    9798        list_append(&batch->link, &instance->batch_list);
    98         usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n",
     99        usb_log_debug("Batch(%p) added to queue %s last, first is %p.\n",
    99100                batch, instance->name, first );
    100101        fibril_mutex_unlock(&instance->guard);
    … …  
    108109        assert(instance->queue_head);
    109110        assert(batch->qh);
     111        usb_log_debug2("Removing batch(%p) from queue %s.\n", batch, instance->name);
    110112
    111113        /* I'm the first one here */
    112114        if (batch->link.prev == &instance->batch_list) {
    113                 usb_log_debug("Removing batch %p was first, next element %x.\n",
    114                         batch, batch->qh->next_queue);
     115                usb_log_debug("Batch(%p) removed (FIRST) from queue %s, next element %x.\n",
     116                        batch, instance->name, batch->qh->next_queue);
    115117                instance->queue_head->element = batch->qh->next_queue;
    116118        } else {
    117                 usb_log_debug("Removing batch %p was NOT first, next element %x.\n",
    118                         batch, batch->qh->next_queue);
     119                usb_log_debug("Batch(%p) removed (NOT FIRST) from queue, next element %x.\n",
     120                        batch, instance->name, batch->qh->next_queue);
    119121                batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
    120122                prev->qh->next_queue = batch->qh->next_queue;
    … …  
    123125}
    124126/*----------------------------------------------------------------------------*/
    125 void transfer_list_check(transfer_list_t *instance)
     127void transfer_list_remove_finished(transfer_list_t *instance)
    126128{
    127129        assert(instance);
     130
     131        LIST_INITIALIZE(done);
     132
    128133        fibril_mutex_lock(&instance->guard);
    129134        link_t *current = instance->batch_list.next;
    … …  
    134139                if (batch_is_complete(batch)) {
    135140                        transfer_list_remove_batch(instance, batch);
    136                         batch->next_step(batch);
     141                        list_append(current, &done);
    137142                }
    138143                current = next;
    139144        }
    140145        fibril_mutex_unlock(&instance->guard);
     146
     147        while (!list_empty(&done)) {
     148                link_t *item = done.next;
     149                list_remove(item);
     150                batch_t *batch = list_get_instance(item, batch_t, link);
     151                batch->next_step(batch);
     152        }
    141153}
    142154/**

  • uspace/drv/uhci-hcd/transfer_list.h

    r81c508c rcc44f7e  
    6060        queue_head_dispose(instance->queue_head);
    6161}
    62 void transfer_list_check(transfer_list_t *instance);
     62void transfer_list_remove_finished(transfer_list_t *instance);
    6363
    6464void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);

  • uspace/drv/uhci-hcd/uhci.c

    r81c508c rcc44f7e  
    4848        {
    4949                .cmd = CMD_PIO_READ_16,
    50                 .addr = (void*)0xc022,
     50                .addr = NULL, /* patched for every instance */
    5151                .dstarg = 1
    5252        },
    5353        {
    5454                .cmd = CMD_PIO_WRITE_16,
    55                 .addr = (void*)0xc022,
     55                .addr = NULL, /* pathed for every instance */
    5656                .value = 0x1f
    5757        },
    … …  
    6868        assert(hc);
    6969
    70         usb_address_t addr = usb_address_keeping_find(&hc->address_manager,
     70        usb_address_t addr = device_keeper_find(&hc->device_manager,
    7171            handle);
    7272        if (addr < 0) {
    … …  
    8080        return EOK;
    8181}
    82 
    83 
     82/*----------------------------------------------------------------------------*/
    8483static usb_iface_t hc_usb_iface = {
    8584        .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
    … …  
    8988static ddf_dev_ops_t uhci_ops = {
    9089        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
    91         .interfaces[USBHC_DEV_IFACE] = &uhci_iface
     90        .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
    9291};
    9392
    … …  
    102101        bool low_speed, usb_transfer_type_t, size_t size);
    103102
    104 #define CHECK_RET_RETURN(ret, message...) \
     103
     104int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
     105{
     106        assert(reg_size >= sizeof(regs_t));
     107        int ret;
     108
     109#define CHECK_RET_DEST_FUN_RETURN(ret, message...) \
    105110        if (ret != EOK) { \
    106111                usb_log_error(message); \
     112                if (instance->ddf_instance) \
     113                        ddf_fun_destroy(instance->ddf_instance); \
    107114                return ret; \
    108115        } else (void) 0
    109 
    110 int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
    111 {
    112         assert(reg_size >= sizeof(regs_t));
    113         int ret;
    114116
    115117        /*
    … …  
    117119         */
    118120        instance->ddf_instance = ddf_fun_create(dev, fun_exposed, "uhci");
    119         if (instance->ddf_instance == NULL) {
    120                 usb_log_error("Failed to create UHCI device function.\n");
    121                 return ENOMEM;
    122         }
     121        ret = (instance->ddf_instance == NULL) ? ENOMEM : EOK;
     122        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to create UHCI device function.\n");
     123
    123124        instance->ddf_instance->ops = &uhci_ops;
    124125        instance->ddf_instance->driver_data = instance;
    125126
    126127        ret = ddf_fun_bind(instance->ddf_instance);
    127         CHECK_RET_RETURN(ret, "Failed to bind UHCI device function: %s.\n",
    128             str_error(ret));
     128        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to bind UHCI device function: %s.\n",
     129            ret, str_error(ret));
    129130
    130131        /* allow access to hc control registers */
    131132        regs_t *io;
    132133        ret = pio_enable(regs, reg_size, (void**)&io);
    133         CHECK_RET_RETURN(ret, "Failed to gain access to registers at %p.\n", io);
     134        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to gain access to registers at %p: %s.\n",
     135            ret, str_error(ret), io);
    134136        instance->registers = io;
    135         usb_log_debug("Device registers accessible.\n");
     137        usb_log_debug("Device registers at %p(%u) accessible.\n", io, reg_size);
    136138
    137139        ret = uhci_init_mem_structures(instance);
    138         CHECK_RET_RETURN(ret, "Failed to initialize memory structures.\n");
     140        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to initialize UHCI memory structures.\n");
    139141
    140142        uhci_init_hw(instance);
    141143
    142144        instance->cleaner = fibril_create(uhci_interrupt_emulator, instance);
    143 //      fibril_add_ready(instance->cleaner);
     145        fibril_add_ready(instance->cleaner);
    144146
    145147        instance->debug_checker = fibril_create(uhci_debug_checker, instance);
    146148        fibril_add_ready(instance->debug_checker);
    147149
    148         return EOK;
     150        usb_log_info("Started UHCI driver.\n");
     151        return EOK;
     152#undef CHECK_RET_DEST_FUN_RETURN
    149153}
    150154/*----------------------------------------------------------------------------*/
    151155void uhci_init_hw(uhci_t *instance)
    152156{
     157        /* reset everything, who knows what touched it before us */
     158        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
     159        async_usleep(10000); /* 10ms according to USB spec */
     160        pio_write_16(&instance->registers->usbcmd, 0);
     161
     162        /* reset hc, all states and counters */
     163        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_HCRESET);
     164        while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0)
     165                { async_usleep(10); }
    153166
    154167        /* set framelist pointer */
    … …  
    163176        pio_write_16(&instance->registers->usbcmd,
    164177            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
    165         usb_log_debug("Started UHCI HC.\n");
    166178}
    167179/*----------------------------------------------------------------------------*/
    … …  
    169181{
    170182        assert(instance);
     183#define CHECK_RET_DEST_CMDS_RETURN(ret, message...) \
     184        if (ret != EOK) { \
     185                usb_log_error(message); \
     186                if (instance->interrupt_code.cmds != NULL) \
     187                        free(instance->interrupt_code.cmds); \
     188                return ret; \
     189        } else (void) 0
    171190
    172191        /* init interrupt code */
    173         irq_cmd_t *interrupt_commands = malloc(sizeof(uhci_cmds));
    174         if (interrupt_commands == NULL) {
    175                 return ENOMEM;
    176         }
    177         memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
    178         interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
    179         interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
    180         instance->interrupt_code.cmds = interrupt_commands;
    181         instance->interrupt_code.cmdcount =
    182             sizeof(uhci_cmds) / sizeof(irq_cmd_t);
     192        instance->interrupt_code.cmds = malloc(sizeof(uhci_cmds));
     193        int ret = (instance->interrupt_code.cmds == NULL) ? ENOMEM : EOK;
     194        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to allocate interrupt cmds space.\n");
     195
     196        {
     197                irq_cmd_t *interrupt_commands = instance->interrupt_code.cmds;
     198                memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
     199                interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
     200                interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
     201                instance->interrupt_code.cmdcount =
     202                                sizeof(uhci_cmds) / sizeof(irq_cmd_t);
     203        }
    183204
    184205        /* init transfer lists */
    185         int ret = uhci_init_transfer_lists(instance);
    186         CHECK_RET_RETURN(ret, "Failed to initialize transfer lists.\n");
     206        ret = uhci_init_transfer_lists(instance);
     207        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to initialize transfer lists.\n");
    187208        usb_log_debug("Initialized transfer lists.\n");
    188209
    … …  
    190211        instance->frame_list = get_page();
    191212        ret = instance ? EOK : ENOMEM;
    192         CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
     213        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
    193214        usb_log_debug("Initialized frame list.\n");
    194215
    … …  
    197218          instance->transfers_interrupt.queue_head_pa
    198219          | LINK_POINTER_QUEUE_HEAD_FLAG;
     220
    199221        unsigned i = 0;
    200222        for(; i < UHCI_FRAME_LIST_COUNT; ++i) {
    … …  
    203225
    204226        /* init address keeper(libusb) */
    205         usb_address_keeping_init(&instance->address_manager, USB11_ADDRESS_MAX);
    206         usb_log_debug("Initialized address manager.\n");
    207 
    208         return EOK;
     227        device_keeper_init(&instance->device_manager);
     228        usb_log_debug("Initialized device manager.\n");
     229
     230        return EOK;
     231#undef CHECK_RET_DEST_CMDS_RETURN
    209232}
    210233/*----------------------------------------------------------------------------*/
    … …  
    212235{
    213236        assert(instance);
     237#define CHECK_RET_CLEAR_RETURN(ret, message...) \
     238        if (ret != EOK) { \
     239                usb_log_error(message); \
     240                transfer_list_fini(&instance->transfers_bulk_full); \
     241                transfer_list_fini(&instance->transfers_control_full); \
     242                transfer_list_fini(&instance->transfers_control_slow); \
     243                transfer_list_fini(&instance->transfers_interrupt); \
     244                return ret; \
     245        } else (void) 0
    214246
    215247        /* initialize TODO: check errors */
    216248        int ret;
    217249        ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
    218         assert(ret == EOK);
     250        CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
    219251        ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
    220         assert(ret == EOK);
     252        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL FULL list.");
    221253        ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
    222         assert(ret == EOK);
     254        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
    223255        ret = transfer_list_init(&instance->transfers_interrupt, "INTERRUPT");
    224         assert(ret == EOK);
     256        CHECK_RET_CLEAR_RETURN(ret, "Failed to init INTERRUPT list.");
    225257
    226258        transfer_list_set_next(&instance->transfers_control_full,
    … …  
    249281
    250282        return EOK;
     283#undef CHECK_RET_CLEAR_RETURN
    251284}
    252285/*----------------------------------------------------------------------------*/
    … …  
    255288        assert(instance);
    256289        assert(batch);
    257         const int low_speed = (batch->speed == LOW_SPEED);
     290        const int low_speed = (batch->speed == USB_SPEED_LOW);
    258291        if (!allowed_usb_packet(
    259292            low_speed, batch->transfer_type, batch->max_packet_size)) {
    … …  
    276309{
    277310        assert(instance);
    278         if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
    279                 return;
    280         usb_log_debug("UHCI interrupt: %X.\n", status);
    281         transfer_list_check(&instance->transfers_interrupt);
    282         transfer_list_check(&instance->transfers_control_slow);
    283         transfer_list_check(&instance->transfers_control_full);
    284         transfer_list_check(&instance->transfers_bulk_full);
     311//      if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
     312//              return;
     313//      usb_log_debug2("UHCI interrupt: %X.\n", status);
     314        transfer_list_remove_finished(&instance->transfers_interrupt);
     315        transfer_list_remove_finished(&instance->transfers_control_slow);
     316        transfer_list_remove_finished(&instance->transfers_control_full);
     317        transfer_list_remove_finished(&instance->transfers_bulk_full);
    285318}
    286319/*----------------------------------------------------------------------------*/
    … …  
    291324        assert(instance);
    292325
    293         while(1) {
     326        while (1) {
    294327                uint16_t status = pio_read_16(&instance->registers->usbsts);
     328                if (status != 0)
     329                        usb_log_debug2("UHCI status: %x.\n", status);
     330                status |= 1;
    295331                uhci_interrupt(instance, status);
    296                 async_usleep(UHCI_CLEANER_TIMEOUT);
     332                pio_write_16(&instance->registers->usbsts, 0x1f);
     333                async_usleep(UHCI_CLEANER_TIMEOUT * 5);
    297334        }
    298335        return EOK;
    … …  
    307344                const uint16_t sts = pio_read_16(&instance->registers->usbsts);
    308345                const uint16_t intr = pio_read_16(&instance->registers->usbintr);
    309                 usb_log_debug("Command: %X Status: %X Interrupts: %x\n",
    310                     cmd, sts, intr);
    311 
    312                 uintptr_t frame_list = pio_read_32(&instance->registers->flbaseadd);
     346                if (((cmd & UHCI_CMD_RUN_STOP) != 1) || (sts != 0)) {
     347                        usb_log_debug2("Command: %X Status: %X Intr: %x\n",
     348                            cmd, sts, intr);
     349                }
     350
     351                uintptr_t frame_list =
     352                    pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
    313353                if (frame_list != addr_to_phys(instance->frame_list)) {
    314354                        usb_log_debug("Framelist address: %p vs. %p.\n",

  • uspace/drv/uhci-hcd/uhci.h

    r81c508c rcc44f7e  
    4141#include <ddi.h>
    4242
    43 #include <usb/addrkeep.h>
    4443#include <usbhc_iface.h>
    4544
     45#include "batch.h"
    4646#include "transfer_list.h"
    47 #include "batch.h"
     47#include "utils/device_keeper.h"
    4848
    4949typedef struct uhci_regs {
    … …  
    8282
    8383typedef struct uhci {
    84         usb_address_keeping_t address_manager;
     84        device_keeper_t device_manager;
     85
    8586        volatile regs_t *registers;
    8687

  • uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c

    r81c508c rcc44f7e  
    3939
    4040void transfer_descriptor_init(transfer_descriptor_t *instance,
    41     int error_count, size_t size, bool toggle, bool isochronous,
     41    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
    4242    usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
    4343{
    … …  
    5050        instance->status = 0
    5151          | ((error_count & TD_STATUS_ERROR_COUNT_MASK) << TD_STATUS_ERROR_COUNT_POS)
     52                | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
    5253          | TD_STATUS_ERROR_ACTIVE;
    5354
    … …  
    6667        }
    6768
    68         usb_log_info("Created TD: %X:%X:%X:%X(%p).\n",
     69        usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
    6970                instance->next, instance->status, instance->device,
    7071          instance->buffer_ptr, buffer);
    71 #if 0
    72         if (size) {
    73                 unsigned char * buff = buffer;
    74                 uhci_print_verbose("TD Buffer dump(%p-%dB): ", buffer, size);
    75                 unsigned i = 0;
    76                 /* TODO: Verbose? */
    77                 for (; i < size; ++i) {
    78                         printf((i & 1) ? "%x " : "%x", buff[i]);
    79                 }
    80                 printf("\n");
    81         }
    82 #endif
    8372}
    8473/*----------------------------------------------------------------------------*/
    … …  
    8877
    8978        if ((instance->status & TD_STATUS_ERROR_STALLED) != 0)
    90                 return EIO;
     79                return ESTALL;
    9180
    9281        if ((instance->status & TD_STATUS_ERROR_CRC) != 0)
    93                 return EAGAIN;
     82                return EBADCHECKSUM;
    9483
    9584        if ((instance->status & TD_STATUS_ERROR_BUFFER) != 0)

  • uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h

    r81c508c rcc44f7e  
    9292
    9393void transfer_descriptor_init(transfer_descriptor_t *instance,
    94     int error_count, size_t size, bool toggle, bool isochronous,
     94    int error_count, size_t size, bool toggle, bool isochronous, bool low_speed,
    9595    usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
    9696

  • uspace/drv/uhci-rhd/main.c

    r81c508c rcc44f7e  
    3333 */
    3434#include <ddf/driver.h>
     35#include <devman.h>
     36#include <device/hw_res.h>
    3537#include <usb_iface.h>
    3638#include <usb/ddfiface.h>
    … …  
    4345
    4446#define NAME "uhci-rhd"
     47static int hc_get_my_registers(ddf_dev_t *dev,
     48    uintptr_t *io_reg_address, size_t *io_reg_size);
    4549
    4650static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
    … …  
    8084        }
    8185
    82         /* TODO: get register values from hc */
    83         int ret = uhci_root_hub_init(rh, (void*)0xc030, 4, device);
     86        uintptr_t io_regs = 0;
     87        size_t io_size = 0;
     88
     89        int ret = hc_get_my_registers(device, &io_regs, &io_size);
     90        assert(ret == EOK);
     91
     92        /* TODO: verify values from hc */
     93        usb_log_info("I/O regs at 0x%X (size %zu).\n", io_regs, io_size);
     94        ret = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
    8495        if (ret != EOK) {
    8596                usb_log_error("Failed(%d) to initialize driver instance.\n", ret);
    … …  
    102113        .driver_ops = &uhci_rh_driver_ops
    103114};
    104 
     115/*----------------------------------------------------------------------------*/
    105116int main(int argc, char *argv[])
    106117{
    107         usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
     118        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
    108119        return ddf_driver_main(&uhci_rh_driver);
     120}
     121/*----------------------------------------------------------------------------*/
     122int hc_get_my_registers(ddf_dev_t *dev,
     123    uintptr_t *io_reg_address, size_t *io_reg_size)
     124{
     125        assert(dev != NULL);
     126
     127        int parent_phone = devman_parent_device_connect(dev->handle,
     128            IPC_FLAG_BLOCKING);
     129        if (parent_phone < 0) {
     130                return parent_phone;
     131        }
     132
     133        int rc;
     134
     135        hw_resource_list_t hw_resources;
     136        rc = hw_res_get_resource_list(parent_phone, &hw_resources);
     137        if (rc != EOK) {
     138                goto leave;
     139        }
     140
     141        uintptr_t io_address = 0;
     142        size_t io_size = 0;
     143        bool io_found = false;
     144
     145        size_t i;
     146        for (i = 0; i < hw_resources.count; i++) {
     147                hw_resource_t *res = &hw_resources.resources[i];
     148                switch (res->type) {
     149                        case IO_RANGE:
     150                                io_address = (uintptr_t)
     151                                    res->res.io_range.address;
     152                                io_size = res->res.io_range.size;
     153                                io_found = true;
     154                                break;
     155                        default:
     156                                break;
     157                }
     158        }
     159
     160        if (!io_found) {
     161                rc = ENOENT;
     162                goto leave;
     163        }
     164
     165        if (io_reg_address != NULL) {
     166                *io_reg_address = io_address;
     167        }
     168        if (io_reg_size != NULL) {
     169                *io_reg_size = io_size;
     170        }
     171        rc = EOK;
     172leave:
     173        async_hangup(parent_phone);
     174
     175        return rc;
    109176}
    110177/**

  • uspace/drv/uhci-rhd/port.c

    r81c508c rcc44f7e  
    3434#include <errno.h>
    3535#include <str_error.h>
     36#include <fibril_synch.h>
    3637
    3738#include <usb/usb.h>    /* usb_address_t */
    … …  
    4546#include "port_status.h"
    4647
    47 static int uhci_port_new_device(uhci_port_t *port);
     48static int uhci_port_new_device(uhci_port_t *port, uint16_t status);
    4849static int uhci_port_remove_device(uhci_port_t *port);
    4950static int uhci_port_set_enabled(uhci_port_t *port, bool enabled);
    5051static int uhci_port_check(void *port);
     52static int new_device_enable_port(int portno, void *arg);
    5153
    5254int uhci_port_init(
    5355  uhci_port_t *port, port_status_t *address, unsigned number,
    54   unsigned usec, ddf_dev_t *rh, int parent_phone)
     56  unsigned usec, ddf_dev_t *rh)
    5557{
    5658        assert(port);
    … …  
    6971        port->checker = fibril_create(uhci_port_check, port);
    7072        if (port->checker == 0) {
    71                 usb_log_error(": failed to launch root hub fibril.");
     73                usb_log_error("Port(%p - %d): failed to launch root hub fibril.",
     74                    port->address, port->number);
    7275                return ENOMEM;
    7376        }
    7477        fibril_add_ready(port->checker);
    75         usb_log_debug(
    76           "Added fibril for port %d: %p.\n", number, port->checker);
     78        usb_log_debug("Port(%p - %d): Added fibril. %x\n",
     79            port->address, port->number, port->checker);
    7780        return EOK;
    7881}
    … …  
    9093        uhci_port_t *port_instance = port;
    9194        assert(port_instance);
     95//      port_status_write(port_instance->address, 0);
     96
     97        unsigned count = 0;
    9298
    9399        while (1) {
     100                async_usleep(port_instance->wait_period_usec);
     101
    94102                /* read register value */
    95103                port_status_t port_status =
    … …  
    97105
    98106                /* debug print */
    99                 usb_log_debug("Port %d status at %p: 0x%04x.\n",
    100                   port_instance->number, port_instance->address, port_status);
    101                 print_port_status(port_status);
    102 
    103                 if (port_status & STATUS_CONNECTED_CHANGED) {
     107                static fibril_mutex_t dbg_mtx = FIBRIL_MUTEX_INITIALIZER(dbg_mtx);
     108                fibril_mutex_lock(&dbg_mtx);
     109                usb_log_debug2("Port(%p - %d): Status: %#04x. === %u\n",
     110                  port_instance->address, port_instance->number, port_status, count++);
     111//              print_port_status(port_status);
     112                fibril_mutex_unlock(&dbg_mtx);
     113
     114                if ((port_status & STATUS_CONNECTED_CHANGED) != 0) {
     115                        usb_log_debug("Port(%p - %d): Connected change detected: %x.\n",
     116                            port_instance->address, port_instance->number, port_status);
     117
     118
    104119                        int rc = usb_hc_connection_open(
    105120                            &port_instance->hc_connection);
    106121                        if (rc != EOK) {
    107                                 usb_log_error("Failed to connect to HC.");
    108                                 goto next;
    109                         }
    110 
    111                         if (port_status & STATUS_CONNECTED) {
     122                                usb_log_error("Port(%p - %d): Failed to connect to HC.",
     123                                    port_instance->address, port_instance->number);
     124                                continue;
     125                        }
     126
     127                        /* remove any old device */
     128                        if (port_instance->attached_device) {
     129                                usb_log_debug("Port(%p - %d): Removing device.\n",
     130                                    port_instance->address, port_instance->number);
     131                                uhci_port_remove_device(port_instance);
     132                        }
     133
     134                        if ((port_status & STATUS_CONNECTED) != 0) {
    112135                                /* new device */
    113                                 uhci_port_new_device(port_instance);
     136                                uhci_port_new_device(port_instance, port_status);
    114137                        } else {
    115                                 uhci_port_remove_device(port_instance);
     138                                /* ack changes by writing one to WC bits */
     139                                port_status_write(port_instance->address, port_status);
     140                                usb_log_debug("Port(%p - %d): Change status ACK.\n",
     141                                                port_instance->address, port_instance->number);
    116142                        }
    117143
    … …  
    119145                            &port_instance->hc_connection);
    120146                        if (rc != EOK) {
    121                                 usb_log_error("Failed to disconnect from HC.");
    122                                 goto next;
     147                                usb_log_error("Port(%p - %d): Failed to disconnect from HC.",
     148                                    port_instance->address, port_instance->number);
    123149                        }
    124150                }
    125         next:
    126                 async_usleep(port_instance->wait_period_usec);
    127151        }
    128152        return EOK;
    … …  
    139163        uhci_port_t *port = (uhci_port_t *) arg;
    140164
    141         usb_log_debug("new_device_enable_port(%d)\n", port->number);
     165        usb_log_debug2("Port(%p - %d): new_device_enable_port.\n",
     166            port->address, port->number);
    142167
    143168        /*
    … …  
    147172        async_usleep(100000);
    148173
    149         /* Enable the port. */
    150         uhci_port_set_enabled(port, true);
    151174
    152175        /* The hub maintains the reset signal to that port for 10 ms
    … …  
    154177         */
    155178        {
    156                 usb_log_debug("Reset Signal start on port %d.\n",
    157                     port->number);
     179                usb_log_debug("Port(%p - %d): Reset Signal start.\n",
     180                    port->address, port->number);
    158181                port_status_t port_status =
    159182                        port_status_read(port->address);
    … …  
    165188                port_status &= ~STATUS_IN_RESET;
    166189                port_status_write(port->address, port_status);
    167                 usb_log_debug("Reset Signal stop on port %d.\n",
    168                     port->number);
    169         }
    170 
    171         return EOK;
    172 }
    173 
    174 /*----------------------------------------------------------------------------*/
    175 static int uhci_port_new_device(uhci_port_t *port)
     190                usb_log_debug("Port(%p - %d): Reset Signal stop.\n",
     191                    port->address, port->number);
     192        }
     193
     194        /* Enable the port. */
     195        uhci_port_set_enabled(port, true);
     196
     197        return EOK;
     198}
     199
     200/*----------------------------------------------------------------------------*/
     201static int uhci_port_new_device(uhci_port_t *port, uint16_t status)
    176202{
    177203        assert(port);
    178204        assert(usb_hc_connection_is_opened(&port->hc_connection));
    179205
    180         usb_log_info("Detected new device on port %u.\n", port->number);
     206        usb_log_info("Port(%p-%d): Detected new device.\n",
     207            port->address, port->number);
    181208
    182209        usb_address_t dev_addr;
    183210        int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
    184             USB_SPEED_FULL,
     211            ((status & STATUS_LOW_SPEED) != 0) ? USB_SPEED_LOW : USB_SPEED_FULL,
    185212            new_device_enable_port, port->number, port,
    186213            &dev_addr, &port->attached_device, NULL, NULL, NULL);
     214
    187215        if (rc != EOK) {
    188                 usb_log_error("Failed adding new device on port %u: %s.\n",
    189                     port->number, str_error(rc));
     216                usb_log_error("Port(%p-%d): Failed(%d) adding new device: %s.\n",
     217                    port->address, port->number, rc, str_error(rc));
    190218                uhci_port_set_enabled(port, false);
    191219                return rc;
    192220        }
    193221
    194         usb_log_info("New device on port %u has address %d (handle %zu).\n",
    195             port->number, dev_addr, port->attached_device);
     222        usb_log_info("Port(%p-%d): New device has address %d (handle %zu).\n",
     223            port->address, port->number, dev_addr, port->attached_device);
    196224
    197225        return EOK;
    … …  
    201229static int uhci_port_remove_device(uhci_port_t *port)
    202230{
    203         usb_log_error("Don't know how to remove device %#x.\n",
    204                 (unsigned int)port->attached_device);
     231        usb_log_error("Port(%p-%d): Don't know how to remove device %#x.\n",
     232                port->address, port->number, (unsigned int)port->attached_device);
    205233//      uhci_port_set_enabled(port, false);
    206234        return EOK;
    … …  
    223251        port_status_write(port->address, port_status);
    224252
    225         usb_log_info("%s port %d.\n",
    226           enabled ? "Enabled" : "Disabled", port->number);
     253        usb_log_info("Port(%p-%d): %sabled port.\n",
     254                port->address, port->number, enabled ? "En" : "Dis");
    227255        return EOK;
    228256}

  • uspace/drv/uhci-rhd/port.h

    r81c508c rcc44f7e  
    5555int uhci_port_init(
    5656  uhci_port_t *port, port_status_t *address, unsigned number,
    57   unsigned usec, ddf_dev_t *rh, int parent_phone);
     57  unsigned usec, ddf_dev_t *rh);
    5858
    5959void uhci_port_fini(uhci_port_t *port);

  • uspace/drv/uhci-rhd/port_status.c

    r81c508c rcc44f7e  
    4141struct flag_name
    4242{
    43         unsigned flag;
     43        uint16_t flag;
    4444        const char *name;
    4545};
    … …  
    6565        for (;i < sizeof(flags)/sizeof(struct flag_name); ++i) {
    6666                usb_log_debug2("\t%s status: %s.\n", flags[i].name,
    67                   value & flags[i].flag ? "YES" : "NO");
     67                  ((value & flags[i].flag) != 0) ? "YES" : "NO");
    6868        }
    6969}

  • uspace/drv/uhci-rhd/port_status.h

    r81c508c rcc44f7e  
    4141typedef uint16_t port_status_t;
    4242
    43 enum {
    44         STATUS_CONNECTED         = 1 << 0,
    45         STATUS_CONNECTED_CHANGED = 1 << 1,
    46         STATUS_ENABLED           = 1 << 2,
    47         STATUS_ENABLED_CHANGED   = 1 << 3,
    48         STATUS_LINE_D_PLUS       = 1 << 4,
    49         STATUS_LINE_D_MINUS      = 1 << 5,
    50         STATUS_RESUME            = 1 << 6,
    51         STATUS_ALWAYS_ONE        = 1 << 7,
     43#define STATUS_CONNECTED         (1 << 0)
     44#define STATUS_CONNECTED_CHANGED (1 << 1)
     45#define STATUS_ENABLED           (1 << 2)
     46#define STATUS_ENABLED_CHANGED   (1 << 3)
     47#define STATUS_LINE_D_PLUS       (1 << 4)
     48#define STATUS_LINE_D_MINUS      (1 << 5)
     49#define STATUS_RESUME            (1 << 6)
     50#define STATUS_ALWAYS_ONE        (1 << 7)
    5251
    53         STATUS_LOW_SPEED = 1 <<  8,
    54         STATUS_IN_RESET  = 1 <<  9,
    55         STATUS_SUSPEND   = 1 << 12,
    56 };
     52#define STATUS_LOW_SPEED (1 <<  8)
     53#define STATUS_IN_RESET  (1 <<  9)
     54#define STATUS_SUSPEND   (1 << 12)
    5755
    5856static inline port_status_t port_status_read(port_status_t * address)

  • uspace/drv/uhci-rhd/root_hub.c

    r81c508c rcc44f7e  
    4040#include "root_hub.h"
    4141
    42 
    4342int uhci_root_hub_init(
    4443  uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh)
    … …  
    4746        assert(rh);
    4847        int ret;
    49         ret = usb_hc_find(rh->handle, &instance->hc_handle);
    50         usb_log_info("rh found(%d) hc handle: %d.\n", ret, instance->hc_handle);
    51         if (ret != EOK) {
    52                 return ret;
    53         }
    5448
    5549        /* allow access to root hub registers */
    5650        assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT == size);
    5751        port_status_t *regs;
    58         ret = pio_enable(
    59           addr, sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT, (void**)&regs);
     52        ret = pio_enable(addr, size, (void**)&regs);
    6053
    6154        if (ret < 0) {
    … …  
    6760        unsigned i = 0;
    6861        for (; i < UHCI_ROOT_HUB_PORT_COUNT; ++i) {
    69                 /* connect to the parent device (HC) */
    70                 int parent_phone = devman_device_connect(instance->hc_handle, 0);
    71                 //usb_drv_hc_connect(rh, instance->hc_handle, 0);
    72                 if (parent_phone < 0) {
    73                         usb_log_error("Failed to connect to the HC device port %d.\n", i);
    74                         return parent_phone;
    75                 }
    7662                /* mind pointer arithmetics */
    77                 int ret = uhci_port_init(
    78                   &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh, parent_phone);
     63                ret = uhci_port_init(
     64                  &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh);
    7965                if (ret != EOK) {
    8066                        unsigned j = 0;

  • uspace/drv/uhci-rhd/root_hub.h

    r81c508c rcc44f7e  
    4141
    4242#define UHCI_ROOT_HUB_PORT_COUNT 2
    43 #define UHCI_ROOT_HUB_PORT_REGISTERS_OFFSET 0x10
    44 #define ROOT_HUB_WAIT_USEC 10000000 /* 10 seconds */
     43#define ROOT_HUB_WAIT_USEC 5000000 /* 5 seconds */
    4544
    4645typedef struct root_hub {
Note: See TracChangeset for help on using the changeset viewer.