Changeset 4deca9b in mainline for uspace/drv/ohci


Ignore:
Timestamp:
2011-04-12T11:43:35Z (15 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
651b352
Parents:
1324ff3 (diff), 910ca3f (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:

Extensive cleanup, preparation for OHCI rework

Location:
uspace/drv/ohci
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/batch.c

    r1324ff3 r4deca9b  
    7373        CHECK_NULL_DISPOSE_RETURN(instance,
    7474            "Failed to allocate batch instance.\n");
    75         usb_target_t target =
    76             { .address = ep->address, .endpoint = ep->endpoint };
    77         usb_transfer_batch_init(instance, target, ep->transfer_type, ep->speed,
    78             ep->max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
    79             func_in, func_out, arg, fun, ep, NULL);
     75        usb_transfer_batch_init(instance, ep, buffer, NULL, buffer_size,
     76            NULL, setup_size, func_in, func_out, arg, fun, NULL);
    8077
    8178        ohci_batch_t *data = malloc(sizeof(ohci_batch_t));
    … …  
    10198
    10299        if (buffer_size > 0) {
    103                 instance->transport_buffer = malloc32(buffer_size);
    104                 CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
     100                instance->data_buffer = malloc32(buffer_size);
     101                CHECK_NULL_DISPOSE_RETURN(instance->data_buffer,
    105102                    "Failed to allocate device accessible buffer.\n");
    106103        }
    … …  
    124121        free32(data->tds);
    125122        free32(instance->setup_buffer);
    126         free32(instance->transport_buffer);
     123        free32(instance->data_buffer);
    127124        free(data);
    128125        free(instance);
    … …  
    165162        assert(instance);
    166163        /* We are data out, we are supposed to provide data */
    167         memcpy(instance->transport_buffer, instance->buffer,
    168             instance->buffer_size);
     164        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
    169165        instance->next_step = batch_call_out_and_dispose;
    170166        batch_control(instance, USB_DIRECTION_OUT, USB_DIRECTION_IN);
    … …  
    183179{
    184180        assert(instance);
    185         assert(instance->direction == USB_DIRECTION_IN);
    186181        instance->next_step = batch_call_in_and_dispose;
    187182        batch_data(instance);
    … …  
    192187{
    193188        assert(instance);
    194         assert(instance->direction == USB_DIRECTION_OUT);
    195189        /* We are data out, we are supposed to provide data */
    196         memcpy(instance->transport_buffer, instance->buffer,
    197             instance->buffer_size);
     190        memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
    198191        instance->next_step = batch_call_out_and_dispose;
    199192        batch_data(instance);
    … …  
    204197{
    205198        assert(instance);
    206         instance->direction = USB_DIRECTION_IN;
    207199        instance->next_step = batch_call_in_and_dispose;
    208200        batch_data(instance);
    … …  
    213205{
    214206        assert(instance);
    215         instance->direction = USB_DIRECTION_IN;
    216207        instance->next_step = batch_call_in_and_dispose;
    217208        batch_data(instance);
    … …  
    249240        size_t td_current = 1;
    250241        size_t remain_size = instance->buffer_size;
    251         char *transfer_buffer = instance->transport_buffer;
     242        char *buffer = instance->data_buffer;
    252243        while (remain_size > 0) {
    253244                size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
    … …  
    255246                toggle = 1 - toggle;
    256247
    257                 td_init(&data->tds[td_current], data_dir, transfer_buffer,
     248                td_init(&data->tds[td_current], data_dir, buffer,
    258249                    transfer_size, toggle);
    259250                td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
    … …  
    262253                    data->tds[td_current].next, data->tds[td_current].be);
    263254
    264                 transfer_buffer += transfer_size;
     255                buffer += transfer_size;
    265256                remain_size -= transfer_size;
    266257                assert(td_current < data->td_count - 2);
    … …  
    290281        size_t td_current = 0;
    291282        size_t remain_size = instance->buffer_size;
    292         char *transfer_buffer = instance->transport_buffer;
     283        char *buffer = instance->data_buffer;
    293284        while (remain_size > 0) {
    294285                size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
    … …  
    296287
    297288                td_init(&data->tds[td_current], instance->ep->direction,
    298                     transfer_buffer, transfer_size, -1);
     289                    buffer, transfer_size, -1);
    299290                td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
    300291                usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
    … …  
    302293                    data->tds[td_current].next, data->tds[td_current].be);
    303294
    304                 transfer_buffer += transfer_size;
     295                buffer += transfer_size;
    305296                remain_size -= transfer_size;
    306297                assert(td_current < data->td_count);

  • uspace/drv/ohci/hc.c

    r1324ff3 r4deca9b  
    5555        assert(hub_fun);
    5656
     57        int ret;
     58
    5759        usb_address_t hub_address =
    5860            device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
     61        if (hub_address <= 0) {
     62                usb_log_error("Failed to get OHCI root hub address.\n");
     63                return hub_address;
     64        }
    5965        instance->rh.address = hub_address;
    6066        usb_device_keeper_bind(
    6167            &instance->manager, hub_address, hub_fun->handle);
    6268
    63         endpoint_t *ep = malloc(sizeof(endpoint_t));
    64         assert(ep);
    65         int ret = endpoint_init(ep, hub_address, 0, USB_DIRECTION_BOTH,
    66             USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64);
    67         assert(ret == EOK);
    68         ret = usb_endpoint_manager_register_ep(&instance->ep_manager, ep, 0);
    69         assert(ret == EOK);
     69        ret = usb_endpoint_manager_add_ep(&instance->ep_manager,
     70            hub_address, 0, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
     71            USB_SPEED_FULL, 64, 0);
     72        if (ret != EOK) {
     73                usb_log_error("Failed to add OHCI rh endpoint 0.\n");
     74                usb_device_keeper_release(&instance->manager, hub_address);
     75                return ret;
     76        }
    7077
    7178        char *match_str = NULL;
     79        /* DDF needs heap allocated string */
    7280        ret = asprintf(&match_str, "usb&class=hub");
    73 //      ret = (match_str == NULL) ? ret : EOK;
    7481        if (ret < 0) {
    7582                usb_log_error(
    7683                    "Failed(%d) to create root hub match-id string.\n", ret);
     84                usb_device_keeper_release(&instance->manager, hub_address);
    7785                return ret;
    7886        }
    … …  
    8088        ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
    8189        if (ret != EOK) {
    82                 usb_log_error("Failed add create root hub match-id.\n");
     90                usb_log_error("Failed add root hub match-id.\n");
    8391        }
    8492        return ret;
    … …  
    115123        fibril_mutex_initialize(&instance->guard);
    116124
    117         rh_init(&instance->rh, dev, instance->registers);
     125        rh_init(&instance->rh, instance->registers);
    118126
    119127        if (!interrupts) {
    … …  
    130138        assert(instance);
    131139        assert(batch);
     140        assert(batch->ep);
    132141
    133142        /* check for root hub communication */
    134         if (batch->target.address == instance->rh.address) {
     143        if (batch->ep->address == instance->rh.address) {
    135144                return rh_request(&instance->rh, batch);
    136145        }
    137146
    138147        fibril_mutex_lock(&instance->guard);
    139         switch (batch->transfer_type) {
     148        switch (batch->ep->transfer_type) {
    140149        case USB_TRANSFER_CONTROL:
    141150                instance->registers->control &= ~C_CLE;
    142151                transfer_list_add_batch(
    143                     instance->transfers[batch->transfer_type], batch);
     152                    instance->transfers[batch->ep->transfer_type], batch);
    144153                instance->registers->command_status |= CS_CLF;
    145154                usb_log_debug2("Set CS control transfer filled: %x.\n",
    … …  
    151160                instance->registers->control &= ~C_BLE;
    152161                transfer_list_add_batch(
    153                     instance->transfers[batch->transfer_type], batch);
     162                    instance->transfers[batch->ep->transfer_type], batch);
    154163                instance->registers->command_status |= CS_BLF;
    155164                usb_log_debug2("Set bulk transfer filled: %x.\n",
    … …  
    161170                instance->registers->control &= (~C_PLE & ~C_IE);
    162171                transfer_list_add_batch(
    163                     instance->transfers[batch->transfer_type], batch);
     172                    instance->transfers[batch->ep->transfer_type], batch);
    164173                instance->registers->control |= C_PLE | C_IE;
    165174                usb_log_debug2("Added periodic transfer: %x.\n",

  • uspace/drv/ohci/root_hub.c

    r1324ff3 r4deca9b  
    205205 * @return Error code.
    206206 */
    207 int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) {
     207int rh_init(rh_t *instance, ohci_regs_t *regs) {
    208208        assert(instance);
    209         //instance->address = -1;
    210209        instance->registers = regs;
    211         instance->device = dev;
    212210        instance->port_count =
    213211            (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
    214212        rh_init_descriptors(instance);
    215213        // set port power mode to no-power-switching
    216         instance->registers->rh_desc_a =
    217                 instance->registers->rh_desc_a | (1<<9);
     214        instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
    218215
    219216        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
    220 
    221         //start generic usb hub driver
    222 
    223         /* TODO: implement */
    224217        return EOK;
    225218}
    … …  
    237230        assert(request);
    238231        int opResult;
    239         if (request->transfer_type == USB_TRANSFER_CONTROL) {
     232        if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
    240233                usb_log_info("Root hub got CONTROL packet\n");
    241234                opResult = process_ctrl_request(instance, request);
    242         } else if (request->transfer_type == USB_TRANSFER_INTERRUPT) {
     235        } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
    243236                usb_log_info("Root hub got INTERRUPT packet\n");
    244237                void * buffer;
    245238                create_interrupt_mask(instance, &buffer,
    246239                        &(request->transfered_size));
    247                 memcpy(request->transport_buffer, buffer,
     240                memcpy(request->data_buffer, buffer,
    248241                        request->transfered_size);
    249242                opResult = EOK;
    … …  
    374367        if (port < 1 || port > instance->port_count)
    375368                return EINVAL;
    376         uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
     369        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
    377370        request->transfered_size = 4;
    378371        uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
    … …  
    400393static int process_get_hub_status_request(rh_t *instance,
    401394        usb_transfer_batch_t * request) {
    402         uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
     395        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
    403396        request->transfered_size = 4;
    404397        //bits, 0,1,16,17
    … …  
    550543        }
    551544        request->transfered_size = size;
    552         memcpy(request->transport_buffer, result_descriptor, size);
     545        memcpy(request->data_buffer, result_descriptor, size);
    553546        if (del)
    554547                free(result_descriptor);
    … …  
    571564        if (request->buffer_size != 1)
    572565                return EINVAL;
    573         request->transport_buffer[0] = 1;
     566        request->data_buffer[0] = 1;
    574567        request->transfered_size = 1;
    575568        return EOK;

  • uspace/drv/ohci/root_hub.h

    r1324ff3 r4deca9b  
    5050        /** usb address of the root hub */
    5151        usb_address_t address;
    52         /** ddf device information */
    53         ddf_dev_t *device;
    5452        /** hub port count */
    5553        int port_count;
    … …  
    5856} rh_t;
    5957
    60 int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs);
     58int rh_init(rh_t *instance, ohci_regs_t *regs);
    6159
    6260int rh_request(rh_t *instance, usb_transfer_batch_t *request);
Note: See TracChangeset for help on using the changeset viewer.