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

Changeset e20eaed in mainline


Ignore:
Timestamp:
2011-08-25T13:53:38Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
620c710
Parents:
23b0fe8
Message:

ohci: Rename hcd_endpoint ⇒ ohci_endpoint to avoid hcd confusion

Location:
uspace/drv/bus/usb/ohci
Files:
5 edited
2 moved

Legend:

Unmodified
Added
Removed
  • uspace/drv/bus/usb/ohci/Makefile

    r23b0fe8 re20eaed  
    4747        endpoint_list.c \
    4848        hc.c \
    49         hcd_endpoint.c \
    5049        iface.c \
    5150        main.c \
    5251        ohci.c \
     52        ohci_endpoint.c \
    5353        pci.c \
    5454        root_hub.c \
  • uspace/drv/bus/usb/ohci/batch.c

    r23b0fe8 re20eaed  
    3939
    4040#include "batch.h"
    41 #include "hcd_endpoint.h"
     41#include "ohci_endpoint.h"
    4242#include "utils/malloc32.h"
    4343#include "hw_struct/endpoint_descriptor.h"
     
    122122        } else (void)0
    123123
    124         const hcd_endpoint_t *hcd_ep = hcd_endpoint_get(batch->ep);
    125         assert(hcd_ep);
     124        const ohci_endpoint_t *ohci_ep = ohci_endpoint_get(batch->ep);
     125        assert(ohci_ep);
    126126
    127127        ohci_transfer_batch_t *data = calloc(sizeof(ohci_transfer_batch_t), 1);
     
    135135        }
    136136
    137         /* We need an extra place for TD that is currently assigned to hcd_ep*/
     137        /* We need an extra place for TD that is assigned to ohci_ep */
    138138        data->tds = calloc(sizeof(td_t*), data->td_count + 1);
    139139        CHECK_NULL_DISPOSE_RETURN(data->tds,
     
    141141
    142142        /* Add TD left over by the previous transfer */
    143         data->tds[0] = hcd_ep->td;
     143        data->tds[0] = ohci_ep->td;
    144144        data->leave_td = 0;
    145145        unsigned i = 1;
     
    150150        }
    151151
    152         data->ed = hcd_ep->ed;
     152        data->ed = ohci_ep->ed;
    153153        batch->private_data = data;
    154154        batch->private_data_dtor = ohci_batch_dispose;
     
    213213            ohci_batch_dispose);
    214214
    215         const hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
    216         assert(hcd_ep);
     215        const ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
     216        assert(ohci_ep);
    217217
    218218        ohci_transfer_batch_t *data = calloc(sizeof(ohci_transfer_batch_t), 1);
     
    233233
    234234        /* Add TD left over by the previous transfer */
    235         data->tds[0] = hcd_ep->td;
     235        data->tds[0] = ohci_ep->td;
    236236        data->leave_td = 0;
    237237        unsigned i = 1;
     
    242242        }
    243243
    244         data->ed = hcd_ep->ed;
     244        data->ed = ohci_ep->ed;
    245245
    246246        /* NOTE: OHCI is capable of handling buffer that crosses page boundaries
     
    303303        data->leave_td = i;
    304304        assert(data->leave_td <= data->td_count);
    305         hcd_endpoint_t *hcd_ep = hcd_endpoint_get(instance->ep);
    306         assert(hcd_ep);
    307         hcd_ep->td = data->tds[i];
     305
     306        ohci_endpoint_t *ohci_ep = ohci_endpoint_get(instance->ep);
     307        assert(ohci_ep);
     308        ohci_ep->td = data->tds[i];
    308309        assert(i > 0);
    309310        for (--i;i < data->td_count; ++i)
     
    312313        /* Clear possible ED HALT */
    313314        data->ed->td_head &= ~ED_TDHEAD_HALTED_FLAG;
    314         const uint32_t pa = addr_to_phys(hcd_ep->td);
     315        const uint32_t pa = addr_to_phys(ohci_ep->td);
    315316        assert(pa == (data->ed->td_head & ED_TDHEAD_PTR_MASK));
    316317        assert(pa == (data->ed->td_tail & ED_TDTAIL_PTR_MASK));
  • uspace/drv/bus/usb/ohci/endpoint_list.c

    r23b0fe8 re20eaed  
    8787 * The endpoint is added to the end of the list and queue.
    8888 */
    89 void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep)
     89void endpoint_list_add_ep(endpoint_list_t *instance, ohci_endpoint_t *ep)
    9090{
    9191        assert(instance);
    92         assert(hcd_ep);
    93         usb_log_debug2("Queue %s: Adding endpoint(%p).\n",
    94             instance->name, hcd_ep);
     92        assert(ep);
     93        usb_log_debug2("Queue %s: Adding endpoint(%p).\n", instance->name, ep);
    9594
    9695        fibril_mutex_lock(&instance->guard);
     
    103102        } else {
    104103                /* There are active EDs, get the last one */
    105                 hcd_endpoint_t *last = list_get_instance(
    106                     list_last(&instance->endpoint_list), hcd_endpoint_t, link);
     104                ohci_endpoint_t *last = list_get_instance(
     105                    list_last(&instance->endpoint_list), ohci_endpoint_t, link);
    107106                last_ed = last->ed;
    108107        }
    109108        /* Keep link */
    110         hcd_ep->ed->next = last_ed->next;
     109        ep->ed->next = last_ed->next;
    111110        /* Make sure ED is written to the memory */
    112111        write_barrier();
    113112
    114113        /* Add ed to the hw queue */
    115         ed_append_ed(last_ed, hcd_ep->ed);
     114        ed_append_ed(last_ed, ep->ed);
    116115        /* Make sure ED is updated */
    117116        write_barrier();
    118117
    119118        /* Add to the sw list */
    120         list_append(&hcd_ep->link, &instance->endpoint_list);
     119        list_append(&ep->link, &instance->endpoint_list);
    121120
    122         hcd_endpoint_t *first = list_get_instance(
    123             list_first(&instance->endpoint_list), hcd_endpoint_t, link);
     121        ohci_endpoint_t *first = list_get_instance(
     122            list_first(&instance->endpoint_list), ohci_endpoint_t, link);
    124123        usb_log_debug("HCD EP(%p) added to list %s, first is %p(%p).\n",
    125                 hcd_ep, instance->name, first, first->ed);
     124                ep, instance->name, first, first->ed);
    126125        if (last_ed == instance->list_head) {
    127126                usb_log_debug2("%s head ED(%p-0x%0" PRIx32 "): %x:%x:%x:%x.\n",
     
    138137 * @param[in] endpoint Endpoint to remove.
    139138 */
    140 void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep)
     139void endpoint_list_remove_ep(endpoint_list_t *instance, ohci_endpoint_t *ep)
    141140{
    142141        assert(instance);
    143142        assert(instance->list_head);
    144         assert(hcd_ep);
    145         assert(hcd_ep->ed);
     143        assert(ep);
     144        assert(ep->ed);
    146145
    147146        fibril_mutex_lock(&instance->guard);
    148147
    149         usb_log_debug2(
    150             "Queue %s: removing endpoint(%p).\n", instance->name, hcd_ep);
     148        usb_log_debug2("Queue %s: removing endpoint(%p).\n", instance->name, ep);
    151149
    152150        const char *qpos = NULL;
    153151        ed_t *prev_ed;
    154152        /* Remove from the hardware queue */
    155         if (list_first(&instance->endpoint_list) == &hcd_ep->link) {
     153        if (list_first(&instance->endpoint_list) == &ep->link) {
    156154                /* I'm the first one here */
    157155                prev_ed = instance->list_head;
    158156                qpos = "FIRST";
    159157        } else {
    160                 hcd_endpoint_t *prev =
    161                     list_get_instance(hcd_ep->link.prev, hcd_endpoint_t, link);
     158                ohci_endpoint_t *prev =
     159                    list_get_instance(ep->link.prev, ohci_endpoint_t, link);
    162160                prev_ed = prev->ed;
    163161                qpos = "NOT FIRST";
    164162        }
    165         assert((prev_ed->next & ED_NEXT_PTR_MASK) == addr_to_phys(hcd_ep->ed));
    166         prev_ed->next = hcd_ep->ed->next;
     163        assert((prev_ed->next & ED_NEXT_PTR_MASK) == addr_to_phys(ep->ed));
     164        prev_ed->next = ep->ed->next;
    167165        /* Make sure ED is updated */
    168166        write_barrier();
    169167
    170168        usb_log_debug("HCD EP(%p) removed (%s) from %s, next %x.\n",
    171             hcd_ep, qpos, instance->name, hcd_ep->ed->next);
     169            ep, qpos, instance->name, ep->ed->next);
    172170
    173171        /* Remove from the endpoint list */
    174         list_remove(&hcd_ep->link);
     172        list_remove(&ep->link);
    175173        fibril_mutex_unlock(&instance->guard);
    176174}
  • uspace/drv/bus/usb/ohci/endpoint_list.h

    r23b0fe8 re20eaed  
    3737#include <fibril_synch.h>
    3838
    39 #include "hcd_endpoint.h"
     39#include "ohci_endpoint.h"
    4040#include "hw_struct/endpoint_descriptor.h"
    4141#include "utils/malloc32.h"
     
    6969int endpoint_list_init(endpoint_list_t *instance, const char *name);
    7070void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next);
    71 void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
    72 void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
     71void endpoint_list_add_ep(endpoint_list_t *instance, ohci_endpoint_t *ep);
     72void endpoint_list_remove_ep(endpoint_list_t *instance, ohci_endpoint_t *ep);
    7373#endif
    7474/**
  • uspace/drv/bus/usb/ohci/hc.c

    r23b0fe8 re20eaed  
    4242
    4343#include "hc.h"
    44 #include "hcd_endpoint.h"
     44#include "ohci_endpoint.h"
    4545
    4646#define OHCI_USED_INTERRUPTS \
     
    203203        instance->generic.private_data = instance;
    204204        instance->generic.schedule = schedule;
    205         instance->generic.ep_add_hook = NULL;
     205        instance->generic.ep_add_hook = ohci_endpoint_assign;
    206206
    207207        ret = hc_init_memory(instance);
     
    249249                return ENOMEM;
    250250
    251         int ret = hcd_endpoint_assign(ep);
     251        int ret = ohci_endpoint_assign(&instance->generic, ep);
    252252        if (ret != EOK) {
    253253                endpoint_destroy(ep);
     
    261261        }
    262262
    263         /* Enqueue hcd_ep */
     263        /* Enqueue ep */
    264264        switch (ep->transfer_type) {
    265265        case USB_TRANSFER_CONTROL:
    266266                instance->registers->control &= ~C_CLE;
    267267                endpoint_list_add_ep(
    268                     &instance->lists[ep->transfer_type], hcd_endpoint_get(ep));
     268                    &instance->lists[ep->transfer_type], ohci_endpoint_get(ep));
    269269                instance->registers->control_current = 0;
    270270                instance->registers->control |= C_CLE;
     
    273273                instance->registers->control &= ~C_BLE;
    274274                endpoint_list_add_ep(
    275                     &instance->lists[ep->transfer_type], hcd_endpoint_get(ep));
     275                    &instance->lists[ep->transfer_type], ohci_endpoint_get(ep));
    276276                instance->registers->control |= C_BLE;
    277277                break;
     
    280280                instance->registers->control &= (~C_PLE & ~C_IE);
    281281                endpoint_list_add_ep(
    282                     &instance->lists[ep->transfer_type], hcd_endpoint_get(ep));
     282                    &instance->lists[ep->transfer_type], ohci_endpoint_get(ep));
    283283                instance->registers->control |= C_PLE | C_IE;
    284284                break;
     
    309309        }
    310310
    311         hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
    312         if (hcd_ep) {
    313                 /* Dequeue hcd_ep */
     311        ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ep);
     312        if (ohci_ep) {
     313                /* Dequeue ep */
    314314                switch (ep->transfer_type) {
    315315                case USB_TRANSFER_CONTROL:
    316316                        instance->registers->control &= ~C_CLE;
    317317                        endpoint_list_remove_ep(
    318                             &instance->lists[ep->transfer_type], hcd_ep);
     318                            &instance->lists[ep->transfer_type], ohci_ep);
    319319                        instance->registers->control_current = 0;
    320320                        instance->registers->control |= C_CLE;
     
    323323                        instance->registers->control &= ~C_BLE;
    324324                        endpoint_list_remove_ep(
    325                             &instance->lists[ep->transfer_type], hcd_ep);
     325                            &instance->lists[ep->transfer_type], ohci_ep);
    326326                        instance->registers->control |= C_BLE;
    327327                        break;
     
    330330                        instance->registers->control &= (~C_PLE & ~C_IE);
    331331                        endpoint_list_remove_ep(
    332                             &instance->lists[ep->transfer_type], hcd_ep);
     332                            &instance->lists[ep->transfer_type], ohci_ep);
    333333                        instance->registers->control |= C_PLE | C_IE;
    334334                        break;
  • uspace/drv/bus/usb/ohci/ohci_endpoint.c

    r23b0fe8 re20eaed  
    3333 */
    3434#include "utils/malloc32.h"
    35 #include "hcd_endpoint.h"
     35#include "ohci_endpoint.h"
    3636
    3737/** Callback to set toggle on ED.
     
    4040 * @param[in] toggle new value of toggle bit
    4141 */
    42 static void hcd_ep_toggle_set(void *hcd_ep, int toggle)
     42static void ohci_ep_toggle_set(void *ohci_ep, int toggle)
    4343{
    44         hcd_endpoint_t *instance = hcd_ep;
     44        ohci_endpoint_t *instance = ohci_ep;
    4545        assert(instance);
    4646        assert(instance->ed);
     
    5353 * @return Current value of toggle bit.
    5454 */
    55 static int hcd_ep_toggle_get(void *hcd_ep)
     55static int ohci_ep_toggle_get(void *ohci_ep)
    5656{
    57         hcd_endpoint_t *instance = hcd_ep;
     57        ohci_endpoint_t *instance = ohci_ep;
    5858        assert(instance);
    5959        assert(instance->ed);
     
    6565 * @param[in] hcd_ep endpoint structure
    6666 */
    67 static void hcd_ep_destroy(void *hcd_ep)
     67static void ohci_ep_destroy(void *ohci_ep)
    6868{
    69         if (hcd_ep) {
    70                 hcd_endpoint_t *instance = hcd_ep;
     69        if (ohci_ep) {
     70                ohci_endpoint_t *instance = ohci_ep;
    7171                free32(instance->ed);
    7272                free32(instance->td);
     
    8080 * @return pointer to a new hcd endpoint structure, NULL on failure.
    8181 */
    82 int hcd_endpoint_assign(endpoint_t *ep)
     82int ohci_endpoint_assign(hcd_t *hcd, endpoint_t *ep)
    8383{
    8484        assert(ep);
    85         hcd_endpoint_t *hcd_ep = malloc(sizeof(hcd_endpoint_t));
    86         if (hcd_ep == NULL)
     85        ohci_endpoint_t *ohci_ep = malloc(sizeof(ohci_endpoint_t));
     86        if (ohci_ep == NULL)
    8787                return ENOMEM;
    8888
    89         hcd_ep->ed = malloc32(sizeof(ed_t));
    90         if (hcd_ep->ed == NULL) {
    91                 free(hcd_ep);
     89        ohci_ep->ed = malloc32(sizeof(ed_t));
     90        if (ohci_ep->ed == NULL) {
     91                free(ohci_ep);
    9292                return ENOMEM;
    9393        }
    9494
    95         hcd_ep->td = malloc32(sizeof(td_t));
    96         if (hcd_ep->td == NULL) {
    97                 free32(hcd_ep->ed);
    98                 free(hcd_ep);
     95        ohci_ep->td = malloc32(sizeof(td_t));
     96        if (ohci_ep->td == NULL) {
     97                free32(ohci_ep->ed);
     98                free(ohci_ep);
    9999                return ENOMEM;
    100100        }
    101101
    102         ed_init(hcd_ep->ed, ep);
    103         ed_set_td(hcd_ep->ed, hcd_ep->td);
     102        ed_init(ohci_ep->ed, ep);
     103        ed_set_td(ohci_ep->ed, ohci_ep->td);
    104104        endpoint_set_hc_data(
    105             ep, hcd_ep, hcd_ep_destroy, hcd_ep_toggle_get, hcd_ep_toggle_set);
     105            ep, ohci_ep, ohci_ep_destroy, ohci_ep_toggle_get, ohci_ep_toggle_set);
    106106
    107107        return EOK;
  • uspace/drv/bus/usb/ohci/ohci_endpoint.h

    r23b0fe8 re20eaed  
    3838#include <adt/list.h>
    3939#include <usb/host/endpoint.h>
     40#include <usb/host/hcd.h>
    4041
    4142#include "hw_struct/endpoint_descriptor.h"
     
    4344
    4445/** Connector structure linking ED to to prepared TD. */
    45 typedef struct hcd_endpoint {
     46typedef struct ohci_endpoint {
    4647        /** OHCI endpoint descriptor */
    4748        ed_t *ed;
     
    5051        /** Linked list used by driver software */
    5152        link_t link;
    52 } hcd_endpoint_t;
     53        /** Device using this ep */
     54        hcd_t *hcd;
     55} ohci_endpoint_t;
    5356
    54 int hcd_endpoint_assign(endpoint_t *ep);
     57int ohci_endpoint_assign(hcd_t *hcd, endpoint_t *ep);
    5558
    56 /** Get and convert assigned hcd_endpoint_t structure
     59/** Get and convert assigned ohci_endpoint_t structure
    5760 * @param[in] ep USBD endpoint structure.
    5861 * @return Pointer to assigned hcd endpoint structure
    5962 */
    60 static inline hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
     63static inline ohci_endpoint_t * ohci_endpoint_get(endpoint_t *ep)
    6164{
    6265        assert(ep);
Note: See TracChangeset for help on using the changeset viewer.