Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 5a2c42b in mainline for uspace/drv/ohci/hc.c


Ignore:
Timestamp:
2011-04-13T12:37:20Z (11 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
592369ae
Parents:
2759c52
Message:

Use endpoint lists instead of transfer lists.

Create and enqueue static endpoint descriptor when endpoint is registered.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/ohci/hc.c

    r2759c52 r5a2c42b  
    155155                return ENOMEM;
    156156        }
    157         // TODO: enqueue hcd_ep here!
    158157
    159158        ret = usb_endpoint_manager_register_ep(&instance->ep_manager, ep, size);
    160159        if (ret != EOK) {
    161160                endpoint_destroy(ep);
    162         }
     161                return ret;
     162        }
     163
     164        /* Enqueue hcd_ep */
     165        switch (ep->transfer_type) {
     166        case USB_TRANSFER_CONTROL:
     167                instance->registers->control &= ~C_CLE;
     168                endpoint_list_add_ep(
     169                    &instance->lists[ep->transfer_type], hcd_ep);
     170                instance->registers->control_current = 0;
     171                instance->registers->control |= C_CLE;
     172                break;
     173        case USB_TRANSFER_BULK:
     174                instance->registers->control &= ~C_BLE;
     175                endpoint_list_add_ep(
     176                    &instance->lists[ep->transfer_type], hcd_ep);
     177                instance->registers->control |= C_BLE;
     178                break;
     179        case USB_TRANSFER_ISOCHRONOUS:
     180        case USB_TRANSFER_INTERRUPT:
     181                instance->registers->control &= (~C_PLE & ~C_IE);
     182                endpoint_list_add_ep(
     183                    &instance->lists[ep->transfer_type], hcd_ep);
     184                instance->registers->control |= C_PLE | C_IE;
     185                break;
     186        default:
     187                break;
     188        }
     189
    163190        return ret;
    164191}
     
    176203        hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
    177204        if (hcd_ep) {
    178                 // TODO: dequeue hcd_ep here!
     205                /* Dequeue hcd_ep */
     206                switch (ep->transfer_type) {
     207                case USB_TRANSFER_CONTROL:
     208                        instance->registers->control &= ~C_CLE;
     209                        endpoint_list_remove_ep(
     210                            &instance->lists[ep->transfer_type], hcd_ep);
     211                        instance->registers->control_current = 0;
     212                        instance->registers->control |= C_CLE;
     213                        break;
     214                case USB_TRANSFER_BULK:
     215                        instance->registers->control &= ~C_BLE;
     216                        endpoint_list_remove_ep(
     217                            &instance->lists[ep->transfer_type], hcd_ep);
     218                        instance->registers->control |= C_BLE;
     219                        break;
     220                case USB_TRANSFER_ISOCHRONOUS:
     221                case USB_TRANSFER_INTERRUPT:
     222                        instance->registers->control &= (~C_PLE & ~C_IE);
     223                        endpoint_list_remove_ep(
     224                            &instance->lists[ep->transfer_type], hcd_ep);
     225                        instance->registers->control |= C_PLE | C_IE;
     226                        break;
     227                default:
     228                        break;
     229                }
    179230                hcd_endpoint_clear(ep);
    180231        } else {
     
    195246                return rh_request(&instance->rh, batch);
    196247        }
    197 
     248#if 0
    198249        fibril_mutex_lock(&instance->guard);
    199250        switch (batch->ep->transfer_type) {
     
    230281        }
    231282        fibril_mutex_unlock(&instance->guard);
     283#endif
    232284        return EOK;
    233285}
     
    249301                usb_log_debug2("Periodic current: %p.\n",
    250302                    instance->registers->periodic_current);
     303#if 0
    251304                LIST_INITIALIZE(done);
    252305                transfer_list_remove_finished(
     
    267320                }
    268321                fibril_mutex_unlock(&instance->guard);
     322#endif
    269323        }
    270324}
     
    358412
    359413        /* Use queues */
    360         instance->registers->bulk_head = instance->transfers_bulk.list_head_pa;
     414        instance->registers->bulk_head =
     415            instance->lists[USB_TRANSFER_BULK].list_head_pa;
    361416        usb_log_debug2("Bulk HEAD set to: %p(%p).\n",
    362             instance->transfers_bulk.list_head,
    363             instance->transfers_bulk.list_head_pa);
     417            instance->lists[USB_TRANSFER_BULK].list_head,
     418            instance->lists[USB_TRANSFER_BULK].list_head_pa);
    364419
    365420        instance->registers->control_head =
    366             instance->transfers_control.list_head_pa;
     421            instance->lists[USB_TRANSFER_CONTROL].list_head_pa;
    367422        usb_log_debug2("Control HEAD set to: %p(%p).\n",
    368             instance->transfers_control.list_head,
    369             instance->transfers_control.list_head_pa);
     423            instance->lists[USB_TRANSFER_CONTROL].list_head,
     424            instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
    370425
    371426        /* Enable queues */
     
    398453        assert(instance);
    399454
    400 #define SETUP_TRANSFER_LIST(type, name) \
     455#define SETUP_ENDPOINT_LIST(type) \
    401456do { \
    402         int ret = transfer_list_init(&instance->type, name); \
     457        const char *name = usb_str_transfer_type(type); \
     458        int ret = endpoint_list_init(&instance->lists[type], name); \
    403459        if (ret != EOK) { \
    404                 usb_log_error("Failed(%d) to setup %s transfer list.\n", \
     460                usb_log_error("Failed(%d) to setup %s endpoint list.\n", \
    405461                    ret, name); \
    406                 transfer_list_fini(&instance->transfers_isochronous); \
    407                 transfer_list_fini(&instance->transfers_interrupt); \
    408                 transfer_list_fini(&instance->transfers_control); \
    409                 transfer_list_fini(&instance->transfers_bulk); \
     462                endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]); \
     463                endpoint_list_fini(&instance->lists[USB_TRANSFER_INTERRUPT]); \
     464                endpoint_list_fini(&instance->lists[USB_TRANSFER_CONTROL]); \
     465                endpoint_list_fini(&instance->lists[USB_TRANSFER_BULK]); \
    410466        } \
    411467} while (0)
    412468
    413         SETUP_TRANSFER_LIST(transfers_isochronous, "ISOCHRONOUS");
    414         SETUP_TRANSFER_LIST(transfers_interrupt, "INTERRUPT");
    415         SETUP_TRANSFER_LIST(transfers_control, "CONTROL");
    416         SETUP_TRANSFER_LIST(transfers_bulk, "BULK");
    417 #undef SETUP_TRANSFER_LIST
    418         transfer_list_set_next(&instance->transfers_interrupt,
    419             &instance->transfers_isochronous);
    420 
    421         /* Assign pointers to be used during scheduling */
    422         instance->transfers[USB_TRANSFER_INTERRUPT] =
    423           &instance->transfers_interrupt;
    424         instance->transfers[USB_TRANSFER_ISOCHRONOUS] =
    425           &instance->transfers_interrupt;
    426         instance->transfers[USB_TRANSFER_CONTROL] =
    427           &instance->transfers_control;
    428         instance->transfers[USB_TRANSFER_BULK] =
    429           &instance->transfers_bulk;
     469        SETUP_ENDPOINT_LIST(USB_TRANSFER_ISOCHRONOUS);
     470        SETUP_ENDPOINT_LIST(USB_TRANSFER_INTERRUPT);
     471        SETUP_ENDPOINT_LIST(USB_TRANSFER_CONTROL);
     472        SETUP_ENDPOINT_LIST(USB_TRANSFER_BULK);
     473#undef SETUP_ENDPOINT_LIST
     474        endpoint_list_set_next(&instance->lists[USB_TRANSFER_INTERRUPT],
     475            &instance->lists[USB_TRANSFER_ISOCHRONOUS]);
    430476
    431477        return EOK;
     
    448494        for (; i < 32; ++i) {
    449495                instance->hcca->int_ep[i] =
    450                     instance->transfers_interrupt.list_head_pa;
     496                    instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa;
    451497        }
    452498        usb_log_debug2("Interrupt HEADs set to: %p(%p).\n",
    453             instance->transfers_interrupt.list_head,
    454             instance->transfers_interrupt.list_head_pa);
     499            instance->lists[USB_TRANSFER_INTERRUPT].list_head,
     500            instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
    455501
    456502        return EOK;
Note: See TracChangeset for help on using the changeset viewer.