Changes in / [8a20380:24d5432] in mainline


Ignore:
Location:
uspace/drv/uhci-hcd
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed

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

    r8a20380 r24d5432  
    5454static void batch_call_in_and_dispose(batch_t *instance);
    5555static void batch_call_out_and_dispose(batch_t *instance);
    56 static void batch_dispose(batch_t *instance);
    5756
    5857
    … …  
    6261    char* setup_buffer, size_t setup_size,
    6362    usbhc_iface_transfer_in_callback_t func_in,
    64     usbhc_iface_transfer_out_callback_t func_out, void *arg,
    65     device_keeper_t *manager
    66     )
     63    usbhc_iface_transfer_out_callback_t func_out, void *arg)
    6764{
    6865        assert(func_in == NULL || func_out == NULL);
    … …  
    140137        instance->arg = arg;
    141138        instance->speed = speed;
    142         instance->manager = manager;
    143139
    144140        queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
    … …  
    164160                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
    165161                            instance, i, instance->tds[i].status);
    166 
    167                         device_keeper_set_toggle(instance->manager, instance->target,
    168                             td_toggle(&instance->tds[i]));
    169162                        if (i > 0)
    170163                                goto substract_ret;
    … …  
    239232}
    240233/*----------------------------------------------------------------------------*/
    241 void batch_data(batch_t *instance, usb_packet_id pid)
     234static void batch_data(batch_t *instance, usb_packet_id pid)
    242235{
    243236        assert(instance);
    244237        const bool low_speed = instance->speed == USB_SPEED_LOW;
    245         int toggle = device_keeper_get_toggle(instance->manager, instance->target);
    246         assert(toggle == 0 || toggle == 1);
     238        int toggle = 1;
    247239
    248240        size_t packet = 0;
    … …  
    253245                    - remain_size;
    254246
     247                toggle = 1 - toggle;
    255248
    256249                const size_t packet_size =
    … …  
    263256                    &instance->tds[packet + 1]);
    264257
    265                 toggle = 1 - toggle;
    266258                ++packet;
    267259                assert(packet <= instance->packets);
    … …  
    269261                remain_size -= packet_size;
    270262        }
    271         device_keeper_set_toggle(instance->manager, instance->target, toggle);
    272263
    273264        instance->tds[packet - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
    … …  
    275266}
    276267/*----------------------------------------------------------------------------*/
    277 void batch_control(batch_t *instance,
     268static void batch_control(batch_t *instance,
    278269   usb_packet_id data_stage, usb_packet_id status_stage)
    279270{
    … …  
    356347        assert(instance);
    357348        batch_call_in(instance);
    358         batch_dispose(instance);
    359 }
    360 /*----------------------------------------------------------------------------*/
    361 void batch_call_out_and_dispose(batch_t *instance)
    362 {
    363         assert(instance);
    364         batch_call_out(instance);
    365         batch_dispose(instance);
    366 }
    367 /*----------------------------------------------------------------------------*/
    368 void batch_dispose(batch_t *instance)
    369 {
    370         assert(instance);
    371349        usb_log_debug("Batch(%p) disposing.\n", instance);
    372350        free32(instance->tds);
    … …  
    377355}
    378356/*----------------------------------------------------------------------------*/
     357void batch_call_out_and_dispose(batch_t *instance)
     358{
     359        assert(instance);
     360        batch_call_out(instance);
     361        usb_log_debug("Batch(%p) disposing.\n", instance);
     362        free32(instance->tds);
     363        free32(instance->qh);
     364        free32(instance->setup_buffer);
     365        free32(instance->transport_buffer);
     366        free(instance);
     367}
     368/*----------------------------------------------------------------------------*/
    379369int batch_schedule(batch_t *instance)
    380370{

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

    r8a20380 r24d5432  
    4242#include "uhci_struct/transfer_descriptor.h"
    4343#include "uhci_struct/queue_head.h"
    44 #include "utils/device_keeper.h"
    4544
    4645typedef struct batch
    … …  
    6867        td_t *tds;
    6968        void (*next_step)(struct batch*);
    70         device_keeper_t *manager;
    7169} batch_t;
    7270
    … …  
    7674                char *setup_buffer, size_t setup_size,
    7775    usbhc_iface_transfer_in_callback_t func_in,
    78     usbhc_iface_transfer_out_callback_t func_out, void *arg,
    79                 device_keeper_t *manager
    80                 );
     76    usbhc_iface_transfer_out_callback_t func_out, void *arg);
    8177
    8278bool batch_is_complete(batch_t *instance);

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

    r8a20380 r24d5432  
    114114
    115115        batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    116             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    117             &hc->device_manager);
     116            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
    118117        if (!batch)
    119118                return ENOMEM;
    … …  
    134133
    135134        batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    136             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    137                         &hc->device_manager);
     135            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
    138136        if (!batch)
    139137                return ENOMEM;
    … …  
    155153
    156154        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    157             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    158             &hc->device_manager);
     155            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
    159156        if (!batch)
    160157                return ENOMEM;
    … …  
    175172
    176173        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    177             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    178             &hc->device_manager);
     174            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
    179175        if (!batch)
    180176                return ENOMEM;
    … …  
    195191            target.address, target.endpoint, size, max_packet_size);
    196192
    197         if (setup_size != 8)
    198                 return EINVAL;
    199 
    200193        batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    201194            max_packet_size, speed, data, size, setup_data, setup_size,
    202             NULL, callback, arg, &hc->device_manager);
    203         if (!batch)
    204                 return ENOMEM;
    205         device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
     195            NULL, callback, arg);
     196        if (!batch)
     197                return ENOMEM;
    206198        batch_control_write(batch);
    207199        return EOK;
    … …  
    222214        batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    223215            max_packet_size, speed, data, size, setup_data, setup_size, callback,
    224             NULL, arg, &hc->device_manager);
     216            NULL, arg);
    225217        if (!batch)
    226218                return ENOMEM;

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

    r8a20380 r24d5432  
    167167        /* reset hc, all states and counters */
    168168        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_HCRESET);
    169         do { async_usleep(10); }
    170         while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
     169        while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0)
     170                { async_usleep(10); }
    171171
    172172        /* set framelist pointer */
    … …  
    175175
    176176        /* enable all interrupts, but resume interrupt */
    177 //      pio_write_16(&instance->registers->usbintr,
    178 //          UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
    179 
    180         uint16_t status = pio_read_16(&instance->registers->usbcmd);
    181         usb_log_warning("Previous command value: %x.\n", status);
     177        pio_write_16(&instance->registers->usbintr,
     178            UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
     179
    182180        /* Start the hc with large(64B) packet FSBR */
    183181        pio_write_16(&instance->registers->usbcmd,

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

    r8a20380 r24d5432  
    7575            instance->next, instance->status, instance->device,
    7676            instance->buffer_ptr, buffer);
    77         if (pid == USB_PID_SETUP) {
    78                 usb_log_debug("SETUP BUFFER: %s\n",
    79                         usb_debug_str_buffer(buffer, 8, 8));
    80         }
    8177}
    8278/*----------------------------------------------------------------------------*/

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

    r8a20380 r24d5432  
    115115}
    116116
    117 static inline int td_toggle(td_t *instance)
    118 {
    119         assert(instance);
    120         return ((instance->device & TD_DEVICE_DATA_TOGGLE_ONE_FLAG) != 0)
    121             ? 1 : 0;
    122 }
    123 
    124117static inline bool td_is_active(td_t *instance)
    125118{

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

    r8a20380 r24d5432  
    4949                instance->devices[i].occupied = false;
    5050                instance->devices[i].handle = 0;
    51                 instance->devices[i].toggle_status = 0;
    5251        }
    5352}
    … …  
    7675}
    7776/*----------------------------------------------------------------------------*/
    78 void device_keeper_reset_if_need(
    79     device_keeper_t *instance, usb_target_t target, const unsigned char *data)
    80 {
    81         assert(instance);
    82         fibril_mutex_lock(&instance->guard);
    83         if (target.endpoint > 15 || target.endpoint < 0
    84             || target.address >= USB_ADDRESS_COUNT || target.address < 0
    85             || !instance->devices[target.address].occupied) {
    86                 goto the_end;
    87         }
    88 
    89         switch (data[1])
    90         {
    91         case 0x01: /*clear feature*/
    92                 /* recipient is enpoint, value is zero (ENDPOINT_STALL) */
    93                 if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
    94                         /* enpoint number is < 16, thus first byte is enough */
    95                         instance->devices[target.address].toggle_status &= ~(1 << data[4]);
    96                 }
    97         break;
    98 
    99         case 0x9: /* set configuration */
    100         case 0x11: /* set interface */
    101                 instance->devices[target.address].toggle_status = 0;
    102         break;
    103         }
    104 the_end:
    105         fibril_mutex_unlock(&instance->guard);
    106 }
    107 /*----------------------------------------------------------------------------*/
    108 int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target)
    109 {
    110         assert(instance);
    111         int ret;
    112         fibril_mutex_lock(&instance->guard);
    113         if (target.endpoint > 15 || target.endpoint < 0
    114             || target.address >= USB_ADDRESS_COUNT || target.address < 0
    115             || !instance->devices[target.address].occupied) {
    116                 ret = EINVAL;
    117         } else {
    118                 ret = (instance->devices[target.address].toggle_status >> target.endpoint) & 1;
    119         }
    120         fibril_mutex_unlock(&instance->guard);
    121         return ret;
    122 }
    123 /*----------------------------------------------------------------------------*/
    124 int device_keeper_set_toggle(
    125     device_keeper_t *instance, usb_target_t target, bool toggle)
    126 {
    127         assert(instance);
    128         int ret;
    129         fibril_mutex_lock(&instance->guard);
    130         if (target.endpoint > 15 || target.endpoint < 0
    131             || target.address >= USB_ADDRESS_COUNT || target.address < 0
    132             || !instance->devices[target.address].occupied) {
    133                 ret = EINVAL;
    134         } else {
    135                 if (toggle) {
    136                         instance->devices[target.address].toggle_status |= (1 << target.endpoint);
    137                 } else {
    138                         instance->devices[target.address].toggle_status &= ~(1 << target.endpoint);
    139                 }
    140                 ret = EOK;
    141         }
    142         fibril_mutex_unlock(&instance->guard);
    143         return ret;
    144 }
    145 /*----------------------------------------------------------------------------*/
    14677usb_address_t device_keeper_request(
    14778    device_keeper_t *instance, usb_speed_t speed)
    … …  
    16596        instance->devices[new_address].occupied = true;
    16697        instance->devices[new_address].speed = speed;
    167         instance->devices[new_address].toggle_status = 0;
    16898        instance->last_address = new_address;
    16999        fibril_mutex_unlock(&instance->guard);

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

    r8a20380 r24d5432  
    4444        usb_speed_t speed;
    4545        bool occupied;
    46         uint16_t toggle_status;
    4746        devman_handle_t handle;
    4847};
    … …  
    5655
    5756void device_keeper_init(device_keeper_t *instance);
    58 
    5957void device_keeper_reserve_default(
    6058    device_keeper_t *instance, usb_speed_t speed);
    61 
    6259void device_keeper_release_default(device_keeper_t *instance);
    63 
    64 void device_keeper_reset_if_need(
    65     device_keeper_t *instance, usb_target_t target, const unsigned char *setup_data);
    66 
    67 int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target);
    68 
    69 int device_keeper_set_toggle(
    70     device_keeper_t *instance, usb_target_t target, bool toggle);
    7160
    7261usb_address_t device_keeper_request(
    7362    device_keeper_t *instance, usb_speed_t speed);
    74 
    7563void device_keeper_bind(
    7664    device_keeper_t *instance, usb_address_t address, devman_handle_t handle);
    77 
    7865void device_keeper_release(device_keeper_t *instance, usb_address_t address);
    79 
    8066usb_address_t device_keeper_find(
    8167    device_keeper_t *instance, devman_handle_t handle);
Note: See TracChangeset for help on using the changeset viewer.