Changeset 9480


Ignore:
Timestamp:
2007-11-01T20:25:05+01:00 (9 years ago)
Author:
juhosg
Message:

[adm5120] cleanup USB driver, it's still experimental

Location:
trunk/target/linux/adm5120/files/drivers/usb/host
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120-dbg.c

    r8905 r9480  
    1212#ifdef DEBUG 
    1313 
    14 #define edstring(ed_type) ({ char *temp; \ 
    15         switch (ed_type) { \ 
    16         case PIPE_CONTROL:      temp = "ctrl"; break; \ 
    17         case PIPE_BULK:         temp = "bulk"; break; \ 
    18         case PIPE_INTERRUPT:    temp = "intr"; break; \ 
    19         default:                temp = "isoc"; break; \ 
    20         }; temp;}) 
    21 #define pipestring(pipe) edstring(usb_pipetype(pipe)) 
     14static inline char *ed_typestring(int ed_type) 
     15{ 
     16        switch (ed_type) { 
     17        case PIPE_CONTROL: 
     18                return "ctrl"; 
     19        case PIPE_BULK: 
     20                return "bulk"; 
     21        case PIPE_INTERRUPT: 
     22                return "intr"; 
     23        case PIPE_ISOCHRONOUS: 
     24                return "isoc"; 
     25        } 
     26        return "(bad ed_type)"; 
     27} 
     28 
     29static inline char *ed_statestring(int state) 
     30{ 
     31        switch (state) { 
     32        case ED_IDLE: 
     33                return "IDLE"; 
     34        case ED_UNLINK: 
     35                return "UNLINK"; 
     36        case ED_OPER: 
     37                return "OPER"; 
     38        case ED_NEW: 
     39                return "NEW"; 
     40        } 
     41        return "?STATE"; 
     42} 
     43 
     44static inline char *pipestring(int pipe) 
     45{ 
     46        return ed_typestring(usb_pipetype(pipe)); 
     47} 
     48 
     49static inline char *td_pidstring(u32 info) 
     50{ 
     51        switch (info & TD_DP) { 
     52        case TD_DP_SETUP: 
     53                return "SETUP"; 
     54        case TD_DP_IN: 
     55                return "IN"; 
     56        case TD_DP_OUT: 
     57                return "OUT"; 
     58        } 
     59        return "?PID"; 
     60} 
     61 
     62static inline char *td_togglestring(u32 info) 
     63{ 
     64        switch (info & TD_T) { 
     65        case TD_T_DATA0: 
     66                return "DATA0"; 
     67        case TD_T_DATA1: 
     68                return "DATA1"; 
     69        case TD_T_CARRY: 
     70                return "CARRY"; 
     71        } 
     72        return "?TOGGLE"; 
     73} 
    2274 
    2375/* debug| print the main components of an URB 
     
    2577 */ 
    2678static void __attribute__((unused)) 
    27 urb_print(struct urb * urb, char * str, int small) 
    28 { 
    29         unsigned int pipe= urb->pipe; 
     79urb_print(struct admhcd *ahcd, struct urb * urb, char * str, int small) 
     80{ 
     81        unsigned int pipe = urb->pipe; 
    3082 
    3183        if (!urb->dev || !urb->dev->bus) { 
    32                 dbg("%s URB: no dev", str); 
     84                admhc_dbg(ahcd, "%s URB: no dev", str); 
    3385                return; 
    3486        } 
     
    3789        if (urb->status != 0) 
    3890#endif 
    39         dbg("%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d stat=%d", 
    40                     str, 
    41                     urb, 
    42                     usb_pipedevice (pipe), 
    43                     usb_pipeendpoint (pipe), 
    44                     usb_pipeout(pipe)? "out" : "in", 
    45                     pipestring(pipe), 
    46                     urb->transfer_flags, 
    47                     urb->actual_length, 
    48                     urb->transfer_buffer_length, 
    49                     urb->status); 
     91        admhc_dbg(ahcd, "URB-%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d " 
     92                        "stat=%d\n", 
     93                        str, 
     94                        urb, 
     95                        usb_pipedevice(pipe), 
     96                        usb_pipeendpoint(pipe), 
     97                        usb_pipeout(pipe)? "out" : "in", 
     98                        pipestring(pipe), 
     99                        urb->transfer_flags, 
     100                        urb->actual_length, 
     101                        urb->transfer_buffer_length, 
     102                        urb->status); 
    50103 
    51104#ifdef  ADMHC_VERBOSE_DEBUG 
     
    54107 
    55108                if (usb_pipecontrol(pipe)) { 
    56                         printk(KERN_DEBUG __FILE__ ": setup(8):"); 
     109                        admhc_dbg(admhc, "setup(8): "); 
    57110                        for (i = 0; i < 8 ; i++) 
    58111                                printk (" %02x", ((__u8 *) urb->setup_packet) [i]); 
     
    60113                } 
    61114                if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) { 
    62                         printk(KERN_DEBUG __FILE__ ": data(%d/%d):", 
     115                        admhc_dbg(admhc, "data(%d/%d): ", 
    63116                                urb->actual_length, 
    64117                                urb->transfer_buffer_length); 
     
    84137 
    85138 
    86 static void admhc_dump_intr_mask ( 
    87         struct admhcd *ahcd, 
    88         char *label, 
    89         u32 mask, 
    90         char **next, 
    91         unsigned *size) 
     139static void admhc_dump_intr_mask(struct admhcd *ahcd, char *label, u32 mask, 
     140                char **next, unsigned *size) 
    92141{ 
    93142        admhc_dbg_sw(ahcd, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s%s\n", 
     
    107156} 
    108157 
    109 static void maybe_print_eds ( 
    110         struct admhcd *ahcd, 
    111         char *label, 
    112         u32 value, 
    113         char **next, 
    114         unsigned *size) 
     158static void maybe_print_eds(struct admhcd *ahcd, char *label, u32 value, 
     159                char **next, unsigned *size) 
    115160{ 
    116161        if (value) 
     
    130175                return "suspend"; 
    131176        } 
    132         return "(bad state)"; 
     177        return "?state"; 
    133178} 
    134179 
     
    153198                "host_control 0x%08x BUSS=%s%s\n", 
    154199                temp, 
    155                 buss2string (temp & ADMHC_HC_BUSS), 
     200                buss2string(temp & ADMHC_HC_BUSS), 
    156201                (temp & ADMHC_HC_DMAE) ? " DMAE" : "" 
    157202                ); 
     
    246291                const struct td *td) 
    247292{ 
    248         u32     tmp = hc32_to_cpup(ahcd, &td->hwINFO); 
     293        u32     tmp; 
    249294 
    250295        admhc_dbg(ahcd, "%s td %p; urb %p index %d; hwNextTD %08x\n", 
     
    253298                hc32_to_cpup(ahcd, &td->hwNextTD)); 
    254299 
    255         if ((td->flags & TD_FLAG_ISO) == 0) { 
    256                 const char      *toggle, *pid; 
    257  
    258                 switch (tmp & TD_T) { 
    259                 case TD_T_DATA0: toggle = data0; break; 
    260                 case TD_T_DATA1: toggle = data1; break; 
    261                 case TD_T_CARRY: toggle = "CARRY"; break; 
    262                 default: toggle = "(bad toggle)"; break; 
    263                 } 
    264                 switch (tmp & TD_DP) { 
    265                 case TD_DP_SETUP: pid = "SETUP"; break; 
    266                 case TD_DP_IN: pid = "IN"; break; 
    267                 case TD_DP_OUT: pid = "OUT"; break; 
    268                 default: pid = "(bad pid)"; break; 
    269                 } 
    270                 admhc_dbg(ahcd, 
    271                         "     status %08x%s CC=%x EC=%d %s %s ISI=%x FN=%x\n", 
    272                         tmp, 
    273                         (tmp & TD_OWN) ? " OWN" : "", 
    274                         TD_CC_GET(tmp), 
    275                         TD_EC_GET(tmp), 
    276                         toggle, 
    277                         pid, 
    278                         TD_ISI_GET(tmp), 
    279                         TD_FN_GET(tmp)); 
    280         } else { 
    281 #if 0           /* TODO: remove */ 
    282                 unsigned        i; 
    283                 admhc_dbg(ahcd, "  info %08x CC=%x FC=%d DI=%d SF=%04x\n", tmp, 
    284                         TD_CC_GET(tmp), 
    285                         (tmp >> 24) & 0x07, 
    286                         (tmp & TD_DI) >> 21, 
    287                         tmp & 0x0000ffff); 
    288                 admhc_dbg(ahcd, "  bp0 %08x be %08x\n", 
    289                         hc32_to_cpup (ahcd, &td->hwCBP) & ~0x0fff, 
    290                         hc32_to_cpup (ahcd, &td->hwBE)); 
    291 #endif 
    292         } 
     300        tmp = hc32_to_cpup(ahcd, &td->hwINFO); 
     301        admhc_dbg(ahcd, "     status %08x%s CC=%x EC=%d %s %s ISI=%x FN=%x\n", 
     302                tmp, 
     303                (tmp & TD_OWN) ? " OWN" : "", 
     304                TD_CC_GET(tmp), 
     305                TD_EC_GET(tmp), 
     306                td_togglestring(tmp), 
     307                td_pidstring(tmp), 
     308                TD_ISI_GET(tmp), 
     309                TD_FN_GET(tmp)); 
    293310 
    294311        tmp = hc32_to_cpup(ahcd, &td->hwCBL); 
    295312        admhc_dbg(ahcd, "     dbp %08x; cbl %08x; LEN=%d%s\n", 
    296                 hc32_to_cpup (ahcd, &td->hwDBP), 
     313                hc32_to_cpup(ahcd, &td->hwDBP), 
    297314                tmp, 
    298315                TD_BL_GET(tmp), 
    299                 (tmp & TD_IE) ? " IE" : "" 
    300         ); 
     316                (tmp & TD_IE) ? " IE" : ""); 
     317} 
     318 
     319static void admhc_dump_up(const struct admhcd *ahcd, const char *label, 
     320                const struct urb_priv *up) 
     321{ 
     322        int i; 
     323 
     324        admhc_dbg(ahcd, "%s urb/%p:\n", label, up->urb); 
     325        for (i = 0; i < up->td_cnt; i++) { 
     326                struct td *td = up->td[i]; 
     327                admhc_dump_td(ahcd, "    ->", td); 
     328        } 
    301329} 
    302330 
     
    308336        u32 tmp = hc32_to_cpu(ahcd, ed->hwINFO); 
    309337 
    310         admhc_dbg(ahcd, "%s ed %p state 0x%x type %s; next ed %08x\n", 
     338        admhc_dbg(ahcd, "%s ed %p %s type %s; next ed %08x\n", 
    311339                label, 
    312                 ed, ed->state, edstring (ed->type), 
    313                 hc32_to_cpup (ahcd, &ed->hwNextED)); 
     340                ed, ed_statestring(ed->state), ed_typestring(ed->type), 
     341                hc32_to_cpup(ahcd, &ed->hwNextED)); 
    314342 
    315343        admhc_dbg(ahcd, "  info %08x MAX=%d%s%s%s%s EP=%d DEV=%d\n", tmp, 
     
    323351 
    324352        tmp = hc32_to_cpup(ahcd, &ed->hwHeadP); 
    325         admhc_dbg(ahcd, "  tds: head %08x tail %08x %s%s%s\n", 
     353        admhc_dbg(ahcd, "  tds: head %08x tail %08x %s%s\n", 
    326354                tmp & TD_MASK, 
    327                 hc32_to_cpup (ahcd, &ed->hwTailP), 
     355                hc32_to_cpup(ahcd, &ed->hwTailP), 
    328356                (tmp & ED_C) ? data1 : data0, 
    329                 (tmp & ED_H) ? " HALT" : "", 
    330                 verbose ? " td list follows" : " (not listing)"); 
    331  
    332         if (verbose) { 
    333                 struct list_head        *tmp; 
    334  
    335                 /* use ed->td_list because HC concurrently modifies 
    336                  * hwNextTD as it accumulates ed_donelist. 
    337                  */ 
    338                 list_for_each(tmp, &ed->td_list) { 
    339                         struct td               *td; 
    340                         td = list_entry(tmp, struct td, td_list); 
    341                         admhc_dump_td (ahcd, "  ->", td); 
     357                (tmp & ED_H) ? " HALT" : ""); 
     358 
     359        if (ed->urb_active) 
     360                admhc_dump_up(ahcd, "  active ", ed->urb_active); 
     361 
     362        if ((verbose) && (!list_empty(&ed->urb_pending))) { 
     363                struct list_head *entry; 
     364                /* dump pending URBs */ 
     365                list_for_each(entry, &ed->urb_pending) { 
     366                        struct urb_priv *up; 
     367                        up = list_entry(entry, struct urb_priv, pending); 
     368                        admhc_dump_up(ahcd, "  pending ", up); 
    342369                } 
    343370        } 
     
    347374 
    348375static inline void urb_print(struct urb * urb, char * str, int small) {} 
     376static inline void admhc_dump_up(const struct admhcd *ahcd, const char *label, 
     377        const struct urb_priv *up) {} 
    349378static inline void admhc_dump_ed(const struct admhcd *ahcd, const char *label, 
    350379        const struct ed *ed, int verbose) {} 
     
    365394 
    366395static ssize_t 
     396show_urb_priv(struct admhcd *ahcd, char *buf, size_t count, 
     397                struct urb_priv *up) 
     398{ 
     399        unsigned temp, size = count; 
     400        int i; 
     401 
     402        if (!up) 
     403                return 0; 
     404 
     405        temp = scnprintf(buf, size,"\n\turb %p ", up->urb); 
     406        size -= temp; 
     407        buf += temp; 
     408 
     409        for (i = 0; i< up->td_cnt; i++) { 
     410                struct td *td; 
     411                u32 dbp, cbl, info; 
     412 
     413                td = up->td[i]; 
     414                info = hc32_to_cpup(ahcd, &td->hwINFO); 
     415                dbp = hc32_to_cpup(ahcd, &td->hwDBP); 
     416                cbl = hc32_to_cpup(ahcd, &td->hwCBL); 
     417 
     418                temp = scnprintf(buf, size, 
     419                        "\n\t\ttd %p %s %d %s%scc=%x (%08x,%08x)", 
     420                        td, 
     421                        td_pidstring(info), 
     422                        TD_BL_GET(cbl), 
     423                        (info & TD_OWN) ? "WORK " : "DONE ", 
     424                        (cbl & TD_IE) ? "IE " : "", 
     425                        TD_CC_GET(info), info, cbl); 
     426                size -= temp; 
     427                buf += temp; 
     428        } 
     429 
     430        return count - size; 
     431} 
     432 
     433static ssize_t 
    367434show_list(struct admhcd *ahcd, char *buf, size_t count, struct ed *ed) 
    368435{ 
     
    371438        if (!ed) 
    372439                return 0; 
    373  
    374 #if 0 
    375         /* print first --> last */ 
    376         while (ed->ed_prev) 
    377                 ed = ed->ed_prev; 
    378 #endif 
    379440 
    380441        /* dump a snapshot of the bulk or control schedule */ 
     
    382443                u32 info = hc32_to_cpu(ahcd, ed->hwINFO); 
    383444                u32 headp = hc32_to_cpu(ahcd, ed->hwHeadP); 
    384                 struct list_head *entry; 
    385                 struct td       *td; 
    386445 
    387446                temp = scnprintf(buf, size, 
    388447                        "ed/%p %s %cs dev%d ep%d %s%smax %d %08x%s%s %s", 
    389448                        ed, 
    390                         edstring (ed->type), 
     449                        ed_typestring (ed->type), 
    391450                        (info & ED_SPEED_FULL) ? 'f' : 'l', 
    392451                        info & ED_FA_MASK, 
     
    398457                        (info & ED_SKIP) ? " S" : "", 
    399458                        (headp & ED_H) ? " H" : "", 
    400                         (headp & ED_C) ? data1 : data0); 
     459                        (headp & ED_C) ? "DATA1" : "DATA0"); 
    401460                size -= temp; 
    402461                buf += temp; 
    403462 
    404                 list_for_each(entry, &ed->td_list) { 
    405                         u32             dbp, cbl; 
    406  
    407                         td = list_entry(entry, struct td, td_list); 
    408                         info = hc32_to_cpup (ahcd, &td->hwINFO); 
    409                         dbp = hc32_to_cpup (ahcd, &td->hwDBP); 
    410                         cbl = hc32_to_cpup (ahcd, &td->hwCBL); 
    411  
    412                         temp = scnprintf(buf, size, 
    413                                 "\n\ttd %p %s %d %s%scc=%x urb %p (%08x,%08x)", 
    414                                 td, 
    415                                 ({ char *pid; 
    416                                 switch (info & TD_DP) { 
    417                                 case TD_DP_SETUP: pid = "setup"; break; 
    418                                 case TD_DP_IN: pid = "in"; break; 
    419                                 case TD_DP_OUT: pid = "out"; break; 
    420                                 default: pid = "(bad pid)"; break; 
    421                                  } pid;}), 
    422                                 TD_BL_GET(cbl), 
    423                                 (info & TD_OWN) ? "" : "DONE ", 
    424                                 (cbl & TD_IE) ? "IE " : "", 
    425                                 TD_CC_GET (info), td->urb, info, cbl); 
     463                if (ed->urb_active) { 
     464                        temp = scnprintf(buf, size, "\nactive urb:"); 
     465                        size -= temp; 
     466                        buf += temp; 
     467 
     468                        temp = show_urb_priv(ahcd, buf, size, ed->urb_active); 
    426469                        size -= temp; 
    427470                        buf += temp; 
    428471                } 
    429472 
     473                if (!list_empty(&ed->urb_pending)) { 
     474                        struct list_head *entry; 
     475 
     476                        temp = scnprintf(buf, size, "\npending urbs:"); 
     477                        size -= temp; 
     478                        buf += temp; 
     479 
     480                        list_for_each(entry, &ed->urb_pending) { 
     481                                struct urb_priv *up; 
     482                                up = list_entry(entry, struct urb_priv, 
     483                                        pending); 
     484 
     485                                temp = show_urb_priv(ahcd, buf, size, up); 
     486                                size -= temp; 
     487                                buf += temp; 
     488                        } 
     489                } 
     490 
    430491                temp = scnprintf(buf, size, "\n"); 
    431492                size -= temp; 
     
    434495                ed = ed->ed_next; 
    435496        } 
     497 
    436498        return count - size; 
    437499} 
     
    452514        /* display control and bulk lists together, for simplicity */ 
    453515        spin_lock_irqsave(&ahcd->lock, flags); 
    454 #if 0 
    455         temp = show_list (ahcd, buf, PAGE_SIZE, ahcd->ed_tails[ED_TAIL_CONTROL]); 
    456         temp += show_list (ahcd, buf + temp, PAGE_SIZE - temp, 
    457                 ahcd->ed_tails[ED_TAIL_BULK]); 
    458 #else 
    459 #ifdef ED_TAIL_ARRAY 
    460516        temp = show_list(ahcd, buf, PAGE_SIZE, ahcd->ed_head); 
    461 #else 
    462         temp = show_list(ahcd, buf, PAGE_SIZE, ahcd->ed_head); 
    463 #endif 
    464 #endif 
    465517        spin_unlock_irqrestore(&ahcd->lock, flags); 
    466518 
     
    475527show_periodic(struct class_device *class_dev, char *buf) 
    476528{ 
     529#if 0 
    477530        struct usb_bus          *bus; 
    478531        struct usb_hcd          *hcd; 
     
    565618 
    566619        return PAGE_SIZE - size; 
     620#else 
     621        return 0; 
     622#endif 
    567623} 
    568624static CLASS_DEVICE_ATTR(periodic, S_IRUGO, show_periodic, NULL); 
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120-hcd.c

    r8905 r9480  
    4646#include "../core/hub.h" 
    4747 
    48 #define DRIVER_VERSION  "v0.01" 
     48#define DRIVER_VERSION  "v0.02" 
    4949#define DRIVER_AUTHOR   "Gabor Juhos <juhosg at openwrt.org>" 
    5050#define DRIVER_DESC     "ADMtek USB 1.1 Host Controller Driver" 
     
    9191        struct urb_priv *urb_priv; 
    9292        unsigned int    pipe = urb->pipe; 
    93         int             i, td_cnt = 0; 
     93        int             td_cnt = 0; 
    9494        unsigned long   flags; 
    9595        int             retval = 0; 
    9696 
    9797#ifdef ADMHC_VERBOSE_DEBUG 
    98         urb_print(urb, "ENQ", usb_pipein(pipe)); 
     98        spin_lock_irqsave(&ahcd->lock, flags); 
     99        urb_print(ahcd, urb, "ENQEUE", usb_pipein(pipe)); 
     100        spin_unlock_irqrestore(&ahcd->lock, flags); 
    99101#endif 
    100102 
     
    113115                /* 1 TD for setup, 1 for ACK, plus ... */ 
    114116                td_cnt = 2; 
    115                 /* FALLTHROUGH */ 
     117                if (urb->transfer_buffer_length) 
     118                        td_cnt++; 
     119                break; 
    116120        case PIPE_BULK: 
    117121                /* one TD for every 4096 Bytes (can be upto 8K) */ 
    118                 td_cnt += urb->transfer_buffer_length / TD_DATALEN_MAX; 
     122                td_cnt = urb->transfer_buffer_length / TD_DATALEN_MAX; 
    119123                /* ... and for any remaining bytes ... */ 
    120124                if ((urb->transfer_buffer_length % TD_DATALEN_MAX) != 0) 
     
    152156 
    153157        urb_priv->ed = ed; 
     158        urb_priv->urb = urb; 
    154159 
    155160        spin_lock_irqsave(&ahcd->lock, flags); 
     
    174179        } 
    175180 
    176         /* schedule the ed if needed */ 
    177         if (ed->state == ED_IDLE) { 
    178 #ifndef LATE_ED_SCHEDULE 
    179                 retval = ed_schedule(ahcd, ed); 
    180                 if (retval < 0) 
    181                         goto fail0; 
    182 #endif 
    183                 if (ed->type == PIPE_ISOCHRONOUS) { 
     181        if (ed->type == PIPE_ISOCHRONOUS) { 
     182                if (ed->state == ED_NEW) { 
    184183                        u16     frame = admhc_frame_no(ahcd); 
    185184 
     
    193192                         * urb->start_frame is never used as input. 
    194193                         */ 
    195                 } 
    196         } else if (ed->type == PIPE_ISOCHRONOUS) 
    197                 urb->start_frame = ed->last_iso + ed->interval; 
    198  
    199         /* fill the TDs and link them to the ed; and 
    200          * enable that part of the schedule, if needed 
    201          * and update count of queued periodic urbs 
    202          */ 
     194                } else 
     195                        urb->start_frame = ed->last_iso + ed->interval; 
     196        } 
     197 
    203198        urb->hcpriv = urb_priv; 
    204         td_submit_urb(ahcd, urb); 
    205  
    206 #ifdef LATE_ED_SCHEDULE 
    207         if (ed->state == ED_IDLE) 
    208                 retval = ed_schedule(ahcd, ed); 
    209 #endif 
    210  
    211         admhc_dump_ed(ahcd, "admhc_urb_enqueue", urb_priv->ed, 1); 
     199        td_submit_urb(ahcd, urb_priv->urb); 
     200 
     201        /* append it to the ED's queue */ 
     202        list_add_tail(&urb_priv->pending, &ed->urb_pending); 
     203 
     204        /* schedule the ED */ 
     205        retval = ed_schedule(ahcd, ed); 
    212206 
    213207fail0: 
    214208        spin_unlock(&urb->lock); 
    215209fail: 
    216         if (retval) 
     210        if (retval) { 
     211                urb_priv = urb->hcpriv; 
    217212                urb_priv_free(ahcd, urb_priv); 
     213        } 
    218214 
    219215        spin_unlock_irqrestore(&ahcd->lock, flags); 
     
    229225static int admhc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb) 
    230226{ 
    231         struct admhcd           *ahcd = hcd_to_admhcd(hcd); 
    232         unsigned long           flags; 
     227        struct admhcd *ahcd = hcd_to_admhcd(hcd); 
     228        struct urb_priv *up; 
     229        unsigned long flags; 
     230 
     231        up = urb->hcpriv; 
     232        if (!up) 
     233                return 0; 
     234 
     235        spin_lock_irqsave(&ahcd->lock, flags); 
    233236 
    234237#ifdef ADMHC_VERBOSE_DEBUG 
    235         urb_print(urb, "DEQ", 1); 
    236 #endif 
    237  
    238         spin_lock_irqsave(&ahcd->lock, flags); 
     238        urb_print(ahcd, urb, "DEQEUE", 1); 
     239#endif 
     240 
    239241        if (HC_IS_RUNNING(hcd->state)) { 
    240                 struct urb_priv *urb_priv; 
    241  
    242242                /* Unless an IRQ completed the unlink while it was being 
    243243                 * handed to us, flag it for unlink and giveback, and force 
    244244                 * some upcoming INTR_SF to call finish_unlinks() 
    245245                 */ 
    246                 urb_priv = urb->hcpriv; 
    247                 if (urb_priv) { 
    248                         if (urb_priv->ed->state == ED_OPER) 
    249                                 start_ed_unlink(ahcd, urb_priv->ed); 
     246                if (up->ed->urb_active != up) { 
     247                        list_del(&up->pending); 
     248                        finish_urb(ahcd, urb); 
     249                } else { 
     250                        ed_start_deschedule(ahcd, up->ed); 
    250251                } 
    251252        } else { 
     
    254255                 * any more ... just clean up every urb's memory. 
    255256                 */ 
    256                 if (urb->hcpriv) 
     257                if (up->ed->urb_active != up) { 
     258                        list_del(&up->pending); 
    257259                        finish_urb(ahcd, urb); 
     260                } else { 
     261                        finish_urb(ahcd, urb); 
     262                        up->ed->urb_active = NULL; 
     263                        up->ed->state = ED_IDLE; 
     264                } 
    258265        } 
    259266        spin_unlock_irqrestore(&ahcd->lock, flags); 
     
    267274 * including ED memory, dummy TD, and bulk/intr data toggle 
    268275 */ 
    269  
    270 static void 
    271 admhc_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep) 
     276static void admhc_endpoint_disable(struct usb_hcd *hcd, 
     277                struct usb_host_endpoint *ep) 
    272278{ 
    273279        struct admhcd           *ahcd = hcd_to_admhcd(hcd); 
     
    284290#ifdef ADMHC_VERBOSE_DEBUG 
    285291        spin_lock_irqsave(&ahcd->lock, flags); 
    286         admhc_dump_ed(ahcd, "ep_disable", ed, 1); 
     292        admhc_dump_ed(ahcd, "EP-DISABLE", ed, 1); 
    287293        spin_unlock_irqrestore(&ahcd->lock, flags); 
    288294#endif 
     
    293299        if (!HC_IS_RUNNING(hcd->state)) { 
    294300sanitize: 
    295                 ed->state = ED_IDLE; 
    296                 finish_unlinks(ahcd, 0); 
     301                ed->state = ED_UNLINK; 
     302                admhc_finish_unlinks(ahcd, 0); 
    297303        } 
    298304 
     
    307313                schedule_timeout_uninterruptible(1); 
    308314                goto rescan; 
    309         case ED_IDLE:           /* fully unlinked */ 
    310                 if (list_empty(&ed->td_list)) { 
    311                         td_free (ahcd, ed->dummy); 
    312                         ed_free (ahcd, ed); 
     315        case ED_IDLE: 
     316        case ED_NEW:            /* fully unlinked */ 
     317                if (list_empty(&ed->urb_pending)) { 
     318                        td_free(ahcd, ed->dummy); 
     319                        ed_free(ahcd, ed); 
    313320                        break; 
    314321                } 
     
    318325                 * that's not our job.  can't recover; must leak ed. 
    319326                 */ 
    320                 admhc_err(ahcd, "leak ed %p (#%02x) state %d%s\n", 
    321                         ed, ep->desc.bEndpointAddress, ed->state, 
    322                         list_empty(&ed->td_list) ? "" : " (has tds)"); 
    323                 td_free(ahcd, ed->dummy); 
     327                admhc_err(ahcd, "leak ed %p (#%02x) %s act %p%s\n", 
     328                        ed, ep->desc.bEndpointAddress, 
     329                        ed_statestring(ed->state), 
     330                        ed->urb_active, 
     331                        list_empty(&ed->urb_pending) ? "" : " (has urbs)"); 
    324332                break; 
    325333        } 
     334 
    326335        ep->hcpriv = NULL; 
     336 
    327337        spin_unlock_irqrestore(&ahcd->lock, flags); 
    328338        return; 
     
    338348static void admhc_usb_reset(struct admhcd *ahcd) 
    339349{ 
    340 #if 0 
    341         ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control); 
    342         ahcd->hc_control &= OHCI_CTRL_RWC; 
    343         admhc_writel(ahcd, ahcd->hc_control, &ahcd->regs->control); 
    344 #else 
    345         /* FIXME */ 
    346350        ahcd->host_control = ADMHC_BUSS_RESET; 
    347351        admhc_writel(ahcd, ahcd->host_control ,&ahcd->regs->host_control); 
    348 #endif 
    349352} 
    350353 
     
    510513                /* also: power/overcurrent flags in rhdesc */ 
    511514        } 
    512  
    513 #if 0   /* TODO: not applicable */ 
    514         /* Reset USB nearly "by the book".  RemoteWakeupConnected was 
    515          * saved if boot firmware (BIOS/SMM/...) told us it's connected, 
    516          * or if bus glue did the same (e.g. for PCI add-in cards with 
    517          * PCI PM support). 
    518          */ 
    519         if ((ahcd->hc_control & OHCI_CTRL_RWC) != 0 
    520                         && !device_may_wakeup(hcd->self.controller)) 
    521                 device_init_wakeup(hcd->self.controller, 1); 
    522 #endif 
    523515 
    524516        switch (ahcd->host_control & ADMHC_HC_BUSS) { 
     
    659651        ints &= admhc_readl(ahcd, &regs->int_enable); 
    660652 
     653        spin_lock(&ahcd->lock); 
    661654        if (ints & ADMHC_INTR_FATI) { 
    662655                /* e.g. due to PCI Master/Target Abort */ 
     
    664657                admhc_err(ahcd, "Fatal Error, controller disabled\n"); 
    665658                admhc_dump(ahcd, 1); 
     659                admhc_usb_reset(ahcd); 
     660        } 
     661 
     662        if (ints & ADMHC_INTR_BABI) { 
     663                admhc_intr_disable(ahcd, ADMHC_INTR_MIE); 
     664                admhc_err(ahcd, "Babble Detected\n"); 
     665                admhc_disable(ahcd); 
    666666                admhc_usb_reset(ahcd); 
    667667        } 
     
    691691                hcd->poll_rh = 1; 
    692692                if (ahcd->autostop) { 
    693                         spin_lock(&ahcd->lock); 
    694693                        admhc_rh_resume(ahcd); 
    695                         spin_unlock(&ahcd->lock); 
    696694                } else 
    697695                        usb_hcd_resume_root_hub(hcd); 
     
    699697 
    700698        if (ints & ADMHC_INTR_TDC) { 
    701                 admhc_vdbg(ahcd, "Transfer Descriptor Complete\n"); 
    702699                admhc_intr_ack(ahcd, ADMHC_INTR_TDC); 
    703700                if (HC_IS_RUNNING(hcd->state)) 
    704701                        admhc_intr_disable(ahcd, ADMHC_INTR_TDC); 
    705                 spin_lock(&ahcd->lock); 
     702                admhc_vdbg(ahcd, "Transfer Descriptor Complete\n"); 
    706703                admhc_td_complete(ahcd); 
    707                 spin_unlock(&ahcd->lock); 
    708704                if (HC_IS_RUNNING(hcd->state)) 
    709705                        admhc_intr_enable(ahcd, ADMHC_INTR_TDC); 
     
    715711        } 
    716712 
    717         if (ints & ADMHC_INTR_BABI) { 
    718                 admhc_intr_disable(ahcd, ADMHC_INTR_BABI); 
    719                 admhc_intr_ack(ahcd, ADMHC_INTR_BABI); 
    720                 admhc_err(ahcd, "Babble Detected\n"); 
    721         } 
    722  
    723 #if 1 
    724         spin_lock(&ahcd->lock); 
    725         if (ahcd->ed_rm_list) 
    726                 finish_unlinks(ahcd, admhc_frame_no(ahcd)); 
    727  
    728         if ((ints & ADMHC_INTR_SOFI) != 0 && !ahcd->ed_rm_list 
    729                         && HC_IS_RUNNING(hcd->state)) 
    730                 admhc_intr_disable(ahcd, ADMHC_INTR_SOFI); 
    731         spin_unlock(&ahcd->lock); 
    732 #else 
    733713        if (ints & ADMHC_INTR_SOFI) { 
    734                 admhc_vdbg(ahcd, "Start Of Frame\n"); 
    735                 spin_lock(&ahcd->lock); 
    736  
     714                admhc_intr_ack(ahcd, ADMHC_INTR_SOFI); 
    737715                /* handle any pending ED removes */ 
    738                 finish_unlinks(ahcd, admhc_frameno(ahcd)); 
    739  
    740                 /* leaving INTR_SOFI enabled when there's still unlinking 
    741                  * to be done in the (next frame). 
    742                  */ 
    743                 if ((ahcd->ed_rm_list == NULL) || 
    744                         HC_IS_RUNNING(hcd->state) == 0) 
    745                         /* 
    746                          * disable INTR_SOFI if there are no unlinking to be 
    747                          * done (in the next frame) 
    748                          */ 
    749                         admhc_intr_disable(ahcd, ADMHC_INTR_SOFI); 
    750  
    751                 spin_unlock(&ahcd->lock); 
    752         } 
    753 #endif 
     716                admhc_finish_unlinks(ahcd, admhc_frame_no(ahcd)); 
     717                admhc_sof_refill(ahcd); 
     718        } 
    754719 
    755720        if (HC_IS_RUNNING(hcd->state)) { 
     
    758723                admhc_writel_flush(ahcd); 
    759724        } 
     725        spin_unlock(&ahcd->lock); 
    760726 
    761727        return IRQ_HANDLED; 
     
    805771        if (!list_empty(&ahcd->pending)) 
    806772                admhc_dbg(ahcd, "abort schedule...\n"); 
    807                 list_for_each_entry (priv, &ahcd->pending, pending) { 
     773                list_for_each_entry(priv, &ahcd->pending, pending) { 
    808774                struct urb      *urb = priv->td[0]->urb; 
    809775                struct ed       *ed = priv->ed; 
     
    830796                spin_unlock(&urb->lock); 
    831797        } 
    832         finish_unlinks (ahcd, 0); 
     798        finish_unlinks(ahcd, 0); 
    833799        spin_unlock_irq(&ahcd->lock); 
    834800 
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120-mem.c

    r8905 r9480  
    2828        ahcd->next_statechange = jiffies; 
    2929        spin_lock_init(&ahcd->lock); 
    30         INIT_LIST_HEAD(&ahcd->pending); 
     30        spin_lock_init(&ahcd->dma_lock); 
    3131} 
    3232 
     
    7777/*-------------------------------------------------------------------------*/ 
    7878 
    79 /* ahcd "done list" processing needs this mapping */ 
    80 static inline struct td *dma_to_td(struct admhcd *ahcd, dma_addr_t td_dma) 
    81 { 
    82         struct td *td; 
    83  
    84         td_dma &= TD_MASK; 
    85         td = ahcd->td_hash[TD_HASH_FUNC(td_dma)]; 
    86         while (td && td->td_dma != td_dma) 
    87                 td = td->td_hash; 
    88  
    89         return td; 
    90 } 
    91  
    9279/* TDs ... */ 
    9380static struct td *td_alloc(struct admhcd *ahcd, gfp_t mem_flags) 
     
    10289        /* in case ahcd fetches it, make it look dead */ 
    10390        memset(td, 0, sizeof *td); 
    104         td->hwNextTD = cpu_to_hc32(ahcd, dma); 
    10591        td->td_dma = dma; 
    106         /* hashed in td_fill */ 
    10792 
    10893        return td; 
     
    11196static void td_free(struct admhcd *ahcd, struct td *td) 
    11297{ 
    113         struct td **prev = &ahcd->td_hash[TD_HASH_FUNC(td->td_dma)]; 
    114  
    115         while (*prev && *prev != td) 
    116                 prev = &(*prev)->td_hash; 
    117         if (*prev) 
    118                 *prev = td->td_hash; 
    119 #if 0 
    120         /* TODO: remove */ 
    121         else if ((td->hwINFO & cpu_to_hc32(ahcd, TD_DONE)) != 0) 
    122                 admhc_dbg (ahcd, "no hash for td %p\n", td); 
    123 #else 
    124         else if ((td->flags & TD_FLAG_DONE) != 0) 
    125                 admhc_dbg (ahcd, "no hash for td %p\n", td); 
    126 #endif 
    12798        dma_pool_free(ahcd->td_cache, td, td->td_dma); 
    12899} 
     
    143114        ed->dma = dma; 
    144115 
    145         INIT_LIST_HEAD(&ed->td_list); 
    146         INIT_LIST_HEAD(&ed->urb_list); 
     116        INIT_LIST_HEAD(&ed->urb_pending); 
    147117 
    148118        return ed; 
     
    165135                        td_free(ahcd, urb_priv->td[i]); 
    166136 
    167         list_del(&urb_priv->pending); 
    168137        kfree(urb_priv); 
    169138} 
     
    173142{ 
    174143        struct urb_priv *priv; 
     144        int i; 
    175145 
    176146        /* allocate the private part of the URB */ 
     
    180150 
    181151        /* allocate the TDs (deferring hash chain updates) */ 
    182         for (priv->td_cnt = 0; priv->td_cnt < num_tds; priv->td_cnt++) { 
    183                 priv->td[priv->td_cnt] = td_alloc(ahcd, mem_flags); 
    184                 if (priv->td[priv->td_cnt] == NULL) 
     152        for (i = 0; i < num_tds; i++) { 
     153                priv->td[i] = td_alloc(ahcd, mem_flags); 
     154                if (priv->td[i] == NULL) 
    185155                        goto err_free; 
     156                priv->td[i]->index = i; 
    186157        } 
    187158 
    188159        INIT_LIST_HEAD(&priv->pending); 
     160        priv->td_cnt = num_tds; 
    189161 
    190162        return priv; 
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120-q.c

    r8905 r9480  
    3939                urb->status = -EREMOTEIO; 
    4040#ifdef ADMHC_VERBOSE_DEBUG 
    41                 urb_print(urb, "SHORT", usb_pipeout (urb->pipe)); 
     41                urb_print(ahcd, urb, "SHORT", usb_pipeout (urb->pipe)); 
    4242#endif 
    4343        } 
     
    5454 
    5555#ifdef ADMHC_VERBOSE_DEBUG 
    56         urb_print(urb, "RET", usb_pipeout (urb->pipe)); 
     56        urb_print(ahcd, urb, "FINISH", 0); 
    5757#endif 
    5858 
     
    6767 * ED handling functions 
    6868 *-------------------------------------------------------------------------*/ 
    69  
    70 #if 0   /* FIXME */ 
    71 /* search for the right schedule branch to use for a periodic ed. 
    72  * does some load balancing; returns the branch, or negative errno. 
    73  */ 
    74 static int balance(struct admhcd *ahcd, int interval, int load) 
    75 { 
    76         int     i, branch = -ENOSPC; 
    77  
    78         /* iso periods can be huge; iso tds specify frame numbers */ 
    79         if (interval > NUM_INTS) 
    80                 interval = NUM_INTS; 
    81  
    82         /* search for the least loaded schedule branch of that period 
    83          * that has enough bandwidth left unreserved. 
    84          */ 
    85         for (i = 0; i < interval ; i++) { 
    86                 if (branch < 0 || ahcd->load [branch] > ahcd->load [i]) { 
    87                         int     j; 
    88  
    89                         /* usb 1.1 says 90% of one frame */ 
    90                         for (j = i; j < NUM_INTS; j += interval) { 
    91                                 if ((ahcd->load [j] + load) > 900) 
    92                                         break; 
    93                         } 
    94                         if (j < NUM_INTS) 
    95                                 continue; 
    96                         branch = i; 
    97                 } 
    98         } 
    99         return branch; 
    100 } 
    101 #endif 
    102  
    103 /*-------------------------------------------------------------------------*/ 
    104  
    105 #if 0   /* FIXME */ 
    106 /* both iso and interrupt requests have periods; this routine puts them 
    107  * into the schedule tree in the apppropriate place.  most iso devices use 
    108  * 1msec periods, but that's not required. 
    109  */ 
    110 static void periodic_link (struct admhcd *ahcd, struct ed *ed) 
    111 { 
    112         unsigned        i; 
    113  
    114         admhc_vdbg (ahcd, "link %sed %p branch %d [%dus.], interval %d\n", 
    115                 (ed->hwINFO & cpu_to_hc32 (ahcd, ED_ISO)) ? "iso " : "", 
    116                 ed, ed->branch, ed->load, ed->interval); 
    117  
    118         for (i = ed->branch; i < NUM_INTS; i += ed->interval) { 
    119                 struct ed       **prev = &ahcd->periodic [i]; 
    120                 __hc32          *prev_p = &ahcd->hcca->int_table [i]; 
    121                 struct ed       *here = *prev; 
    122  
    123                 /* sorting each branch by period (slow before fast) 
    124                  * lets us share the faster parts of the tree. 
    125                  * (plus maybe: put interrupt eds before iso) 
    126                  */ 
    127                 while (here && ed != here) { 
    128                         if (ed->interval > here->interval) 
    129                                 break; 
    130                         prev = &here->ed_next; 
    131                         prev_p = &here->hwNextED; 
    132                         here = *prev; 
    133                 } 
    134                 if (ed != here) { 
    135                         ed->ed_next = here; 
    136                         if (here) 
    137                                 ed->hwNextED = *prev_p; 
    138                         wmb (); 
    139                         *prev = ed; 
    140                         *prev_p = cpu_to_hc32(ahcd, ed->dma); 
    141                         wmb(); 
    142                 } 
    143                 ahcd->load [i] += ed->load; 
    144         } 
    145         admhcd_to_hcd(ahcd)->self.bandwidth_allocated += ed->load / ed->interval; 
    146 } 
    147 #endif 
    148  
    149 /* link an ed into the HC chain */ 
    150  
    151 static int ed_schedule(struct admhcd *ahcd, struct ed *ed) 
    152 { 
    153         struct ed *old_tail; 
    154  
    155         if (admhcd_to_hcd(ahcd)->state == HC_STATE_QUIESCING) 
    156                 return -EAGAIN; 
    157  
    158         ed->state = ED_OPER; 
    159  
    160         old_tail = ahcd->ed_tails[ed->type]; 
    161  
    162         ed->ed_next = old_tail->ed_next; 
    163         if (ed->ed_next) { 
    164                 ed->ed_next->ed_prev = ed; 
    165                 ed->hwNextED = cpu_to_hc32(ahcd, ed->ed_next->dma); 
    166         } 
    167         ed->ed_prev = old_tail; 
    168  
    169         old_tail->ed_next = ed; 
    170         old_tail->hwNextED = cpu_to_hc32(ahcd, ed->dma); 
    171  
    172         ahcd->ed_tails[ed->type] = ed; 
    173  
    174         admhc_dma_enable(ahcd); 
    175  
    176         return 0; 
    177 } 
    178  
    179 /*-------------------------------------------------------------------------*/ 
    180  
    181 #if 0   /* FIXME */ 
    182 /* scan the periodic table to find and unlink this ED */ 
    183 static void periodic_unlink (struct admhcd *ahcd, struct ed *ed) 
    184 { 
    185         int     i; 
    186  
    187         for (i = ed->branch; i < NUM_INTS; i += ed->interval) { 
    188                 struct ed       *temp; 
    189                 struct ed       **prev = &ahcd->periodic [i]; 
    190                 __hc32          *prev_p = &ahcd->hcca->int_table [i]; 
    191  
    192                 while (*prev && (temp = *prev) != ed) { 
    193                         prev_p = &temp->hwNextED; 
    194                         prev = &temp->ed_next; 
    195                 } 
    196                 if (*prev) { 
    197                         *prev_p = ed->hwNextED; 
    198                         *prev = ed->ed_next; 
    199                 } 
    200                 ahcd->load [i] -= ed->load; 
    201         } 
    202  
    203         admhcd_to_hcd(ahcd)->self.bandwidth_allocated -= ed->load / ed->interval; 
    204         admhc_vdbg (ahcd, "unlink %sed %p branch %d [%dus.], interval %d\n", 
    205                 (ed->hwINFO & cpu_to_hc32 (ahcd, ED_ISO)) ? "iso " : "", 
    206                 ed, ed->branch, ed->load, ed->interval); 
    207 } 
    208 #endif 
    209  
    210 /* unlink an ed from the HC chain. 
    211  * just the link to the ed is unlinked. 
    212  * the link from the ed still points to another operational ed or 0 
    213  * so the HC can eventually finish the processing of the unlinked ed 
    214  * (assuming it already started that, which needn't be true). 
    215  * 
    216  * ED_UNLINK is a transient state: the HC may still see this ED, but soon 
    217  * it won't.  ED_SKIP means the HC will finish its current transaction, 
    218  * but won't start anything new.  The TD queue may still grow; device 
    219  * drivers don't know about this HCD-internal state. 
    220  * 
    221  * When the HC can't see the ED, something changes ED_UNLINK to one of: 
    222  * 
    223  *  - ED_OPER: when there's any request queued, the ED gets rescheduled 
    224  *    immediately.  HC should be working on them. 
    225  * 
    226  *  - ED_IDLE:  when there's no TD queue. there's no reason for the HC 
    227  *    to care about this ED; safe to disable the endpoint. 
    228  * 
    229  * When finish_unlinks() runs later, after SOF interrupt, it will often 
    230  * complete one or more URB unlinks before making that state change. 
    231  */ 
    232 static void ed_deschedule(struct admhcd *ahcd, struct ed *ed) 
    233 { 
    234         ed->hwINFO |= cpu_to_hc32(ahcd, ED_SKIP); 
    235         wmb(); 
    236         ed->state = ED_UNLINK; 
    237  
    238         /* remove this ED from the HC list */ 
    239         ed->ed_prev->hwNextED = ed->hwNextED; 
    240  
    241         /* and remove it from our list also */ 
    242         ed->ed_prev->ed_next = ed->ed_next; 
    243  
    244         if (ed->ed_next) 
    245                 ed->ed_next->ed_prev = ed->ed_prev; 
    246  
    247         if (ahcd->ed_tails[ed->type] == ed) 
    248                 ahcd->ed_tails[ed->type] = ed->ed_prev; 
    249 } 
    250  
    251 /*-------------------------------------------------------------------------*/ 
    25269 
    25370static struct ed *ed_create(struct admhcd *ahcd, unsigned int type, u32 info) 
     
    27592 
    27693        ed->dummy = td; 
    277         ed->state = ED_IDLE; 
     94        ed->state = ED_NEW; 
    27895        ed->type = type; 
    27996 
    28097        ed->hwINFO = cpu_to_hc32(ahcd, info); 
    28198        ed->hwTailP = cpu_to_hc32(ahcd, td->td_dma); 
    282         ed->hwHeadP = ed->hwTailP;      /* ED_C, ED_H zeroed */ 
     99        ed->hwHeadP = cpu_to_hc32(ahcd, td->td_dma); 
    283100 
    284101        return ed; 
     
    322139} 
    323140 
    324 /*-------------------------------------------------------------------------*/ 
    325  
    326 /* request unlinking of an endpoint from an operational HC. 
    327  * put the ep on the rm_list 
    328  * real work is done at the next start frame (SOFI) hardware interrupt 
    329  * caller guarantees HCD is running, so hardware access is safe, 
    330  * and that ed->state is ED_OPER 
    331  */ 
    332 static void start_ed_unlink(struct admhcd *ahcd, struct ed *ed) 
    333 { 
    334         ed->hwINFO |= cpu_to_hc32 (ahcd, ED_DEQUEUE); 
    335         ed_deschedule(ahcd, ed); 
     141/* link an ed into the HC chain */ 
     142static int ed_schedule(struct admhcd *ahcd, struct ed *ed) 
     143{ 
     144        struct ed *old_tail; 
     145 
     146        if (admhcd_to_hcd(ahcd)->state == HC_STATE_QUIESCING) 
     147                return -EAGAIN; 
     148 
     149        if (ed->state != ED_NEW) 
     150                return 0; 
     151 
     152        admhc_dump_ed(ahcd, "ED-SCHED", ed, 0); 
     153 
     154        ed->state = ED_IDLE; 
     155 
     156        admhc_dma_lock(ahcd); 
     157        ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); 
     158 
     159        old_tail = ahcd->ed_tails[ed->type]; 
     160 
     161        ed->ed_next = old_tail->ed_next; 
     162        if (ed->ed_next) { 
     163                ed->ed_next->ed_prev = ed; 
     164                ed->hwNextED = cpu_to_hc32(ahcd, ed->ed_next->dma); 
     165        } 
     166        ed->ed_prev = old_tail; 
     167 
     168        old_tail->ed_next = ed; 
     169        old_tail->hwNextED = cpu_to_hc32(ahcd, ed->dma); 
     170 
     171        ahcd->ed_tails[ed->type] = ed; 
     172        admhc_dma_unlock(ahcd); 
     173 
     174        admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); 
     175 
     176        return 0; 
     177} 
     178 
     179static void ed_deschedule(struct admhcd *ahcd, struct ed *ed) 
     180{ 
     181        admhc_dump_ed(ahcd, "ED-DESCHED", ed, 0); 
     182 
     183        /* remove this ED from the HC list */ 
     184        admhc_dma_lock(ahcd); 
     185        ed->ed_prev->hwNextED = ed->hwNextED; 
     186        admhc_dma_unlock(ahcd); 
     187 
     188        /* and remove it from our list */ 
     189        ed->ed_prev->ed_next = ed->ed_next; 
     190 
     191        if (ed->ed_next) { 
     192                ed->ed_next->ed_prev = ed->ed_prev; 
     193                ed->ed_next = NULL; 
     194        } 
     195 
     196        if (ahcd->ed_tails[ed->type] == ed) 
     197                ahcd->ed_tails[ed->type] = ed->ed_prev; 
     198 
     199        ed->state = ED_NEW; 
     200} 
     201 
     202static void ed_start_deschedule(struct admhcd *ahcd, struct ed *ed) 
     203{ 
     204        admhc_dump_ed(ahcd, "ED-UNLINK", ed, 0); 
     205 
     206        admhc_dma_lock(ahcd); 
     207        ed->hwINFO |= cpu_to_hc32(ahcd, ED_SKIP); 
     208        admhc_dma_unlock(ahcd); 
     209 
     210        ed->state = ED_UNLINK; 
    336211 
    337212        /* add this ED into the remove list */ 
    338213        ed->ed_rm_next = ahcd->ed_rm_list; 
    339214        ahcd->ed_rm_list = ed; 
    340  
    341         /* enable SOF interrupt */ 
    342         admhc_intr_ack(ahcd, ADMHC_INTR_SOFI); 
    343         admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); 
    344         /* flush those writes */ 
    345         admhc_writel_flush(ahcd); 
    346215 
    347216        /* SOF interrupt might get delayed; record the frame counter value that 
     
    351220         */ 
    352221        ed->tick = admhc_frame_no(ahcd) + 1; 
     222 
     223        /* enable SOF interrupt */ 
     224        admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); 
    353225} 
    354226 
     
    357229 *-------------------------------------------------------------------------*/ 
    358230 
    359 /* enqueue next TD for this URB (OHCI spec 5.2.8.2) */ 
    360  
    361 static void 
    362 td_fill(struct admhcd *ahcd, u32 info, dma_addr_t data, int len, 
    363         struct urb *urb, int index) 
    364 { 
    365         struct td               *td, *td_pt; 
    366         struct urb_priv         *urb_priv = urb->hcpriv; 
    367         int                     hash; 
    368         u32                     cbl = 0; 
    369  
    370 #if 1 
    371         if (index == (urb_priv->td_cnt - 1) && 
    372                         ((urb->transfer_flags & URB_NO_INTERRUPT) == 0)) 
    373                 cbl |= TD_IE; 
    374 #else 
    375         if (index == (urb_priv->td_cnt - 1)) 
    376                 cbl |= TD_IE; 
    377 #endif 
    378  
    379         /* use this td as the next dummy */ 
    380         td_pt = urb_priv->td[index]; 
    381  
    382         /* fill the old dummy TD */ 
    383         td = urb_priv->td[index] = urb_priv->ed->dummy; 
    384         urb_priv->ed->dummy = td_pt; 
    385  
    386         td->ed = urb_priv->ed; 
    387         td->next_dl_td = NULL; 
    388         td->index = index; 
    389         td->urb = urb; 
     231static void td_fill(struct admhcd *ahcd, u32 info, dma_addr_t data, int len, 
     232                struct urb_priv *up) 
     233{ 
     234        struct td *td; 
     235        u32 cbl = 0; 
     236 
     237        if (up->td_idx >= up->td_cnt) { 
     238                admhc_dbg(ahcd, "td_fill error, idx=%d, cnt=%d\n", up->td_idx, 
     239                                up->td_cnt); 
     240                return; 
     241        } 
     242 
     243        td = up->td[up->td_idx]; 
    390244        td->data_dma = data; 
    391245        if (!len) 
    392246                data = 0; 
     247 
     248#if 1 
     249        if (up->td_idx == up->td_cnt-1) 
     250#endif 
     251                cbl |= TD_IE; 
    393252 
    394253        if (data) 
     
    401260        td->hwDBP = cpu_to_hc32(ahcd, data); 
    402261        td->hwCBL = cpu_to_hc32(ahcd, cbl); 
    403         td->hwNextTD = cpu_to_hc32(ahcd, td_pt->td_dma); 
    404  
    405         /* append to queue */ 
    406         list_add_tail(&td->td_list, &td->ed->td_list); 
    407  
    408         /* hash it for later reverse mapping */ 
    409         hash = TD_HASH_FUNC(td->td_dma); 
    410         td->td_hash = ahcd->td_hash[hash]; 
    411         ahcd->td_hash[hash] = td; 
    412  
    413         /* HC might read the TD (or cachelines) right away ... */ 
    414         wmb(); 
    415         td->ed->hwTailP = td->hwNextTD; 
     262 
     263        if (up->td_idx > 0) 
     264                up->td[up->td_idx-1]->hwNextTD = cpu_to_hc32(ahcd, td->td_dma); 
     265 
     266        up->td_idx++; 
    416267} 
    417268 
     
    431282        u32             info = 0; 
    432283        int             is_out = usb_pipeout(urb->pipe); 
    433         int             periodic = 0; 
    434284        u32             toggle = 0; 
    435         struct td       *td; 
    436285 
    437286        /* OHCI handles the bulk/interrupt data toggles itself.  We just 
     
    449298 
    450299        urb_priv->td_idx = 0; 
    451         list_add(&urb_priv->pending, &ahcd->pending); 
    452300 
    453301        if (data_len) 
     
    470318                info |= (urb->interval & TD_ISI_MASK) << TD_ISI_SHIFT; 
    471319 
    472                 td_fill(ahcd, info, data, data_len, urb, cnt); 
     320                td_fill(ahcd, info, data, data_len, urb_priv); 
    473321                cnt++; 
    474322 
     
    484332                while (data_len > TD_DATALEN_MAX) { 
    485333                        td_fill(ahcd, info | ((cnt) ? TD_T_CARRY : toggle), 
    486                                 data, TD_DATALEN_MAX, urb, cnt); 
     334                                data, TD_DATALEN_MAX, urb_priv); 
    487335                        data += TD_DATALEN_MAX; 
    488336                        data_len -= TD_DATALEN_MAX; 
     
    491339 
    492340                td_fill(ahcd, info | ((cnt) ? TD_T_CARRY : toggle), data, 
    493                         data_len, urb, cnt); 
     341                        data_len, urb_priv); 
    494342                cnt++; 
    495343 
     
    497345                                && (cnt < urb_priv->td_cnt)) { 
    498346                        td_fill(ahcd, info | ((cnt) ? TD_T_CARRY : toggle), 
    499                                 0, 0, urb, cnt); 
     347                                0, 0, urb_priv); 
    500348                        cnt++; 
    501349                } 
     
    508356                /* fill a TD for the setup */ 
    509357                info = TD_SCC_NOTACCESSED | TD_DP_SETUP | TD_T_DATA0; 
    510                 td_fill(ahcd, info, urb->setup_dma, 8, urb, cnt++); 
     358                td_fill(ahcd, info, urb->setup_dma, 8, urb_priv); 
     359                cnt++; 
    511360 
    512361                if (data_len > 0) { 
     
    515364                        info |= is_out ? TD_DP_OUT : TD_DP_IN; 
    516365                        /* NOTE:  mishandles transfers >8K, some >4K */ 
    517                         td_fill(ahcd, info, data, data_len, urb, cnt++); 
     366                        td_fill(ahcd, info, data, data_len, urb_priv); 
     367                        cnt++; 
    518368                } 
    519369 
     
    522372                        ? TD_SCC_NOTACCESSED | TD_DP_IN | TD_T_DATA1 
    523373                        : TD_SCC_NOTACCESSED | TD_DP_OUT | TD_T_DATA1; 
    524                 td_fill(ahcd, info, data, 0, urb, cnt++); 
     374                td_fill(ahcd, info, data, 0, urb_priv); 
     375                cnt++; 
    525376 
    526377                break; 
     
    539390                        td_fill(ahcd, info | frame, 
    540391                                data + urb->iso_frame_desc[cnt].offset, 
    541                                 urb->iso_frame_desc[cnt].length, urb, cnt); 
     392                                urb->iso_frame_desc[cnt].length, 
     393                                urb_priv); 
    542394                } 
    543395                admhcd_to_hcd(ahcd)->self.bandwidth_isoc_reqs++; 
     
    547399        if (urb_priv->td_cnt != cnt) 
    548400                admhc_err(ahcd, "bad number of tds created for urb %p\n", urb); 
    549 } 
    550  
    551 /*-------------------------------------------------------------------------* 
    552  * Done List handling functions 
    553  *-------------------------------------------------------------------------*/ 
     401 
     402        urb_priv->td_idx = 0; 
     403} 
    554404 
    555405/* calculate transfer length/status and update the urb 
    556406 * PRECONDITION:  irqsafe (only for urb->status locking) 
    557407 */ 
    558 static void td_done(struct admhcd *ahcd, struct urb *urb, struct td *td) 
     408static int td_done(struct admhcd *ahcd, struct urb *urb, struct td *td) 
    559409{ 
    560410        u32     info = hc32_to_cpup(ahcd, &td->hwINFO); 
     411        u32     dbp = hc32_to_cpup(ahcd, &td->hwDBP); 
     412        u32     cbl = TD_BL_GET(hc32_to_cpup(ahcd, &td->hwCBL)); 
    561413        int     type = usb_pipetype(urb->pipe); 
    562         int     cc = TD_CC_NOERROR; 
     414        int     cc; 
     415 
     416        cc = TD_CC_GET(info); 
    563417 
    564418        /* ISO ... drivers see per-TD length/status */ 
     
    577431 
    578432                if (usb_pipeout (urb->pipe)) 
    579                         dlen = urb->iso_frame_desc [td->index].length; 
     433                        dlen = urb->iso_frame_desc[td->index].length; 
    580434                else { 
    581435                        /* short reads are always OK for ISO */ 
     
    584438                        dlen = tdPSW & 0x3ff; 
    585439                } 
     440 
    586441                urb->actual_length += dlen; 
    587                 urb->iso_frame_desc [td->index].actual_length = dlen; 
    588                 urb->iso_frame_desc [td->index].status = cc_to_error [cc]; 
     442                urb->iso_frame_desc[td->index].actual_length = dlen; 
     443                urb->iso_frame_desc[td->index].status = cc_to_error[cc]; 
    589444 
    590445                if (cc != TD_CC_NOERROR) 
     
    598453         */ 
    599454        } else { 
    600                 u32     bl = TD_BL_GET(hc32_to_cpup(ahcd, &td->hwCBL)); 
    601                 u32     tdDBP = hc32_to_cpup(ahcd, &td->hwDBP); 
    602  
    603                 cc = TD_CC_GET(info); 
    604  
    605                 /* update packet status if needed (short is normally ok) */ 
    606                 if (cc == TD_CC_DATAUNDERRUN 
    607                                 && !(urb->transfer_flags & URB_SHORT_NOT_OK)) 
    608                         cc = TD_CC_NOERROR; 
    609  
    610                 if (cc != TD_CC_NOERROR && cc < TD_CC_HCD0) { 
    611                         admhc_dump_ed(ahcd, "CC ERROR", td->ed, 1); 
    612                         spin_lock(&urb->lock); 
    613                         if (urb->status == -EINPROGRESS) 
    614                                 urb->status = cc_to_error[cc]; 
    615                         spin_unlock(&urb->lock); 
    616                 } 
     455                admhc_dump_td(ahcd, "td_done", td); 
    617456 
    618457                /* count all non-empty packets except control SETUP packet */ 
    619                 if ((type != PIPE_CONTROL || td->index != 0) && tdDBP != 0) { 
    620                         urb->actual_length += tdDBP - td->data_dma + bl; 
    621                 } 
    622  
    623                 if (cc != TD_CC_NOERROR && cc < TD_CC_HCD0) 
    624                         admhc_vdbg(ahcd, 
    625                                 "urb %p td %p (%d) cc %d, len=%d/%d\n", 
    626                                 urb, td, td->index, cc, 
    627                                 urb->actual_length, 
    628                                 urb->transfer_buffer_length); 
    629         } 
    630  
    631         list_del(&td->td_list); 
    632  
     458                if ((type != PIPE_CONTROL || td->index != 0) && dbp != 0) { 
     459                        urb->actual_length += dbp - td->data_dma + cbl; 
     460                } 
     461        } 
     462 
     463        return cc; 
    633464} 
    634465 
     
    638469ed_halted(struct admhcd *ahcd, struct td *td, int cc, struct td *rev) 
    639470{ 
     471#if 0 
    640472        struct urb              *urb = td->urb; 
    641473        struct ed               *ed = td->ed; 
     
    709541 
    710542        return rev; 
     543#else 
     544        return NULL; 
     545#endif 
    711546} 
    712547 
    713548/*-------------------------------------------------------------------------*/ 
    714549 
    715 /* there are some urbs/eds to unlink; called in_irq(), with HCD locked */ 
    716 static void 
    717 finish_unlinks(struct admhcd *ahcd, u16 tick) 
    718 { 
    719         struct ed       *ed, **last; 
    720  
    721 rescan_all: 
    722         for (last = &ahcd->ed_rm_list, ed = *last; ed != NULL; ed = *last) { 
    723                 struct list_head        *entry, *tmp; 
    724                 int                     completed, modified; 
    725                 __hc32                  *prev; 
    726  
    727                 /* only take off EDs that the HC isn't using, accounting for 
    728                  * frame counter wraps and EDs with partially retired TDs 
    729                  */ 
    730                 if (likely(HC_IS_RUNNING(admhcd_to_hcd(ahcd)->state))) { 
    731                         if (tick_before (tick, ed->tick)) { 
    732 skip_ed: 
    733                                 last = &ed->ed_rm_next; 
    734                                 continue; 
    735                         } 
    736  
    737                         if (!list_empty (&ed->td_list)) { 
    738                                 struct td       *td; 
    739                                 u32             head; 
    740  
    741                                 td = list_entry(ed->td_list.next, struct td, 
    742                                                         td_list); 
    743                                 head = hc32_to_cpu(ahcd, ed->hwHeadP) & 
    744                                                                 TD_MASK; 
    745  
    746                                 /* INTR_WDH may need to clean up first */ 
    747                                 if (td->td_dma != head) 
    748                                         goto skip_ed; 
    749                         } 
    750                 } 
    751  
    752                 /* reentrancy:  if we drop the schedule lock, someone might 
    753                  * have modified this list.  normally it's just prepending 
    754                  * entries (which we'd ignore), but paranoia won't hurt. 
    755                  */ 
    756                 *last = ed->ed_rm_next; 
    757                 ed->ed_rm_next = NULL; 
    758                 modified = 0; 
    759  
    760                 /* unlink urbs as requested, but rescan the list after 
    761                  * we call a completion since it might have unlinked 
    762                  * another (earlier) urb 
    763                  * 
    764                  * When we get here, the HC doesn't see this ed.  But it 
    765                  * must not be rescheduled until all completed URBs have 
    766                  * been given back to the driver. 
    767                  */ 
    768 rescan_this: 
    769                 completed = 0; 
    770                 prev = &ed->hwHeadP; 
    771                 list_for_each_safe (entry, tmp, &ed->td_list) { 
    772                         struct td       *td; 
    773                         struct urb      *urb; 
    774                         struct urb_priv *urb_priv; 
    775                         __hc32          savebits; 
    776  
    777                         td = list_entry(entry, struct td, td_list); 
    778                         urb = td->urb; 
    779                         urb_priv = td->urb->hcpriv; 
    780  
    781                         if (urb->status == -EINPROGRESS) { 
    782                                 prev = &td->hwNextTD; 
    783                                 continue; 
    784                         } 
    785  
    786                         if ((urb_priv) == NULL) 
    787                                 continue; 
    788  
    789                         /* patch pointer hc uses */ 
    790                         savebits = *prev & ~cpu_to_hc32(ahcd, TD_MASK); 
    791                         *prev = td->hwNextTD | savebits; 
    792  
    793                         /* HC may have partly processed this TD */ 
    794                         urb_print(urb, "PARTIAL",1); 
    795                         td_done(ahcd, urb, td); 
    796                         urb_priv->td_idx++; 
    797  
    798                         /* if URB is done, clean up */ 
    799                         if (urb_priv->td_idx == urb_priv->td_cnt) { 
    800                                 modified = completed = 1; 
    801                                 finish_urb(ahcd, urb); 
    802                         } 
    803                 } 
    804                 if (completed && !list_empty (&ed->td_list)) 
    805                         goto rescan_this; 
    806  
    807                 /* ED's now officially unlinked, hc doesn't see */ 
    808                 ed->state = ED_IDLE; 
    809                 ed->hwHeadP &= ~cpu_to_hc32(ahcd, ED_H); 
    810                 ed->hwNextED = 0; 
    811                 wmb (); 
    812                 ed->hwINFO &= ~cpu_to_hc32 (ahcd, ED_SKIP | ED_DEQUEUE); 
    813  
    814                 /* but if there's work queued, reschedule */ 
    815                 if (!list_empty (&ed->td_list)) { 
    816                         if (HC_IS_RUNNING(admhcd_to_hcd(ahcd)->state)) 
    817                                 ed_schedule(ahcd, ed); 
    818                 } 
    819  
    820                 if (modified) 
    821                         goto rescan_all; 
    822         } 
    823 } 
    824  
    825 /*-------------------------------------------------------------------------*/ 
    826  
    827 /* 
    828  * Process normal completions (error or success) and clean the schedules. 
    829  * 
    830  * This is the main path for handing urbs back to drivers.  The only other 
    831  * path is finish_unlinks(), which unlinks URBs using ed_rm_list, instead of 
    832  * scanning the (re-reversed) donelist as this does. 
    833  */ 
    834  
    835 static void ed_update(struct admhcd *ahcd, struct ed *ed) 
    836 { 
    837         struct list_head *entry,*tmp; 
    838  
    839         admhc_dump_ed(ahcd, "ed update", ed, 1); 
    840  
    841         list_for_each_safe(entry, tmp, &ed->td_list) { 
    842                 struct td *td = list_entry(entry, struct td, td_list); 
    843                 struct urb *urb = td->urb; 
    844                 struct urb_priv *urb_priv = urb->hcpriv; 
     550static int ed_next_urb(struct admhcd *ahcd, struct ed *ed) 
     551{ 
     552        struct urb_priv *up; 
     553        u32 carry; 
     554 
     555        if (ed->state != ED_IDLE) 
     556                return 1; 
     557 
     558        if (ed->urb_active) 
     559                return 1; 
     560 
     561        if (list_empty(&ed->urb_pending)) 
     562                return 0; 
     563 
     564        up = list_entry(ed->urb_pending.next, struct urb_priv, pending); 
     565        list_del(&up->pending); 
     566        ed->urb_active = up; 
     567        ed->state = ED_OPER; 
     568 
     569#ifdef ADMHC_VERBOSE_DEBUG 
     570        urb_print(ahcd, up->urb, "NEXT", 0); 
     571        admhc_dump_ed(ahcd, " ", ed, 0); 
     572#endif 
     573 
     574        up->td[up->td_cnt-1]->hwNextTD = cpu_to_hc32(ahcd, ed->dummy->td_dma); 
     575 
     576        admhc_dma_lock(ahcd); 
     577        carry = hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_C; 
     578        ed->hwHeadP = cpu_to_hc32(ahcd, up->td[0]->td_dma | carry); 
     579        ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); 
     580        admhc_dma_unlock(ahcd); 
     581 
     582        return 1; 
     583} 
     584 
     585static void ed_update(struct admhcd *ahcd, struct ed *ed, int partial) 
     586{ 
     587        struct urb_priv *up; 
     588        struct urb *urb; 
     589        int cc; 
     590 
     591        up = ed->urb_active; 
     592        if (!up) 
     593                return; 
     594 
     595        urb = up->urb; 
     596 
     597#ifdef ADMHC_VERBOSE_DEBUG 
     598        urb_print(ahcd, urb, "UPDATE", 0); 
     599#endif 
     600        admhc_dump_ed(ahcd, "ED-UPDATE", ed, 1); 
     601 
     602        cc = TD_CC_NOERROR; 
     603        for (; up->td_idx < up->td_cnt; up->td_idx++) { 
     604                struct td *td = up->td[up->td_idx]; 
    845605 
    846606                if (hc32_to_cpup(ahcd, &td->hwINFO) & TD_OWN) 
    847607                        break; 
    848608 
    849                 /* update URB's length and status from TD */ 
    850                 td_done(ahcd, urb, td); 
    851                 urb_priv->td_idx++; 
    852  
    853                 /* If all this urb's TDs are done, call complete() */ 
    854                 if (urb_priv->td_idx == urb_priv->td_cnt) 
    855                         finish_urb(ahcd, urb); 
    856  
    857                 /* clean schedule:  unlink EDs that are no longer busy */ 
    858                 if (list_empty(&ed->td_list)) { 
    859                         if (ed->state == ED_OPER) 
    860                                 start_ed_unlink(ahcd, ed); 
    861  
    862                 /* ... reenabling halted EDs only after fault cleanup */ 
    863                 } else if ((ed->hwINFO & cpu_to_hc32 (ahcd, 
    864                                                 ED_SKIP | ED_DEQUEUE)) 
    865                                         == cpu_to_hc32 (ahcd, ED_SKIP)) { 
    866                         td = list_entry(ed->td_list.next, struct td, td_list); 
    867 #if 0 
    868                         if (!(td->hwINFO & cpu_to_hc32 (ahcd, TD_DONE))) { 
    869                                 ed->hwINFO &= ~cpu_to_hc32 (ahcd, ED_SKIP); 
    870                                 /* ... hc may need waking-up */ 
    871                                 switch (ed->type) { 
    872                                 case PIPE_CONTROL: 
    873                                         admhc_writel (ahcd, OHCI_CLF, 
    874                                                 &ahcd->regs->cmdstatus); 
    875                                         break; 
    876                                 case PIPE_BULK: 
    877                                         admhc_writel (ahcd, OHCI_BLF, 
    878                                                 &ahcd->regs->cmdstatus); 
    879                                         break; 
    880                                 } 
    881                         } 
    882 #else 
    883                         if ((td->hwINFO & cpu_to_hc32(ahcd, TD_OWN))) 
    884                                 ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); 
    885 #endif 
    886                 } 
    887  
    888         } 
    889 } 
    890  
    891 static void ed_halt(struct admhcd *ahcd, struct ed *ed) 
    892 { 
    893         admhc_dump_ed(ahcd, "ed_halt", ed, 1); 
     609                cc = td_done(ahcd, urb, td); 
     610                if (cc != TD_CC_NOERROR) { 
     611                        admhc_vdbg(ahcd, 
     612                                "urb %p td %p (%d) cc %d, len=%d/%d\n", 
     613                                urb, td, td->index, cc, 
     614                                urb->actual_length, 
     615                                urb->transfer_buffer_length); 
     616 
     617                        up->td_idx = up->td_cnt; 
     618                        break; 
     619                } 
     620        } 
     621 
     622        if ((up->td_idx != up->td_cnt) && (!partial)) 
     623                /* the URB is not completed yet */ 
     624                return; 
     625 
     626        /* update packet status if needed (short is normally ok) */ 
     627        if (cc == TD_CC_DATAUNDERRUN 
     628                        && !(urb->transfer_flags & URB_SHORT_NOT_OK)) 
     629                cc = TD_CC_NOERROR; 
     630 
     631        if (cc != TD_CC_NOERROR && cc < TD_CC_HCD0) { 
     632                spin_lock(&urb->lock); 
     633                if (urb->status == -EINPROGRESS) 
     634                        urb->status = cc_to_error[cc]; 
     635                spin_unlock(&urb->lock); 
     636        } 
     637 
     638        finish_urb(ahcd, urb); 
     639 
     640        ed->urb_active = NULL; 
     641        ed->state = ED_IDLE; 
    894642} 
    895643 
     
    897645static void admhc_td_complete(struct admhcd *ahcd) 
    898646{ 
    899         struct ed       *ed; 
     647        struct ed *ed; 
    900648 
    901649        for (ed = ahcd->ed_head; ed; ed = ed->ed_next) { 
     
    907655 
    908656                if (hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_H) { 
    909                         ed_halt(ahcd, ed); 
     657                        /* TODO */ 
    910658                        continue; 
    911659                } 
    912660 
    913                 ed_update(ahcd, ed); 
    914         } 
    915 } 
     661                ed_update(ahcd, ed, 0); 
     662        } 
     663} 
     664 
     665/* there are some urbs/eds to unlink; called in_irq(), with HCD locked */ 
     666static void admhc_finish_unlinks(struct admhcd *ahcd, u16 tick) 
     667{ 
     668        struct ed *ed; 
     669 
     670        for (ed = ahcd->ed_head; ed; ed = ed->ed_next) { 
     671                if (ed->state != ED_UNLINK) 
     672                        continue; 
     673 
     674                if (likely(HC_IS_RUNNING(admhcd_to_hcd(ahcd)->state))) 
     675                        if (tick_before(tick, ed->tick)) 
     676                                continue; 
     677 
     678                /* process partial status */ 
     679                ed_update(ahcd, ed, 1); 
     680        } 
     681} 
     682 
     683static void admhc_sof_refill(struct admhcd *ahcd) 
     684{ 
     685        struct ed *ed; 
     686        int disable_dma = 1; 
     687 
     688        for (ed = ahcd->ed_head; ed; ed = ed->ed_next) { 
     689 
     690                if (hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_H) { 
     691                        ed_update(ahcd, ed, 1); 
     692                        ed->hwHeadP &= ~cpu_to_hc32 (ahcd, ED_H); 
     693                } 
     694 
     695                if (ed_next_urb(ahcd, ed)) { 
     696                        disable_dma = 0; 
     697                } else { 
     698                        struct ed *tmp; 
     699                        tmp = ed->ed_prev; 
     700                        ed_deschedule(ahcd, ed); 
     701                        ed = tmp; 
     702                } 
     703        } 
     704 
     705        if (disable_dma) { 
     706                admhc_intr_disable(ahcd, ADMHC_INTR_SOFI); 
     707                admhc_dma_disable(ahcd); 
     708        } else { 
     709                admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); 
     710                admhc_dma_enable(ahcd); 
     711        } 
     712} 
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120.h

    r8905 r9480  
    5757        struct td               *dummy;         /* next TD to activate */ 
    5858 
    59         struct list_head        urb_list;       /* list of our URBs */ 
     59        struct urb_priv         *urb_active;    /* active URB */ 
     60        struct list_head        urb_pending;    /* pending URBs */ 
    6061 
    6162        struct list_head        ed_list;        /* list of all EDs*/ 
     
    6667        struct ed               *ed_prev;       /* for non-interrupt EDs */ 
    6768        struct ed               *ed_rm_next;    /* on rm list */ 
    68         struct ed               *ed_soft_list;  /* on software int list */ 
    69         struct list_head        td_list;        /* "shadow list" of our TDs */ 
    7069 
    7170        /* create --> IDLE --> OPER --> ... --> IDLE --> destroy 
    7271         * usually:  OPER --> UNLINK --> (IDLE | OPER) --> ... 
    7372         */ 
    74         u8                      state;          /* ED_{IDLE,UNLINK,OPER} */ 
    75 #define ED_IDLE         0x00            /* NOT linked to HC */ 
    76 #define ED_UNLINK       0x01            /* being unlinked from hc */ 
    77 #define ED_OPER         0x02            /* IS linked to hc */ 
     73        u8                      state; 
     74#define ED_NEW          0x00            /* just allocated */ 
     75#define ED_IDLE         0x01            /* linked into HC, but not running */ 
     76#define ED_OPER         0x02            /* linked into HC and running */ 
     77#define ED_UNLINK       0x03            /* being unlinked from HC */ 
    7878 
    7979        u8                      type;           /* PIPE_{BULK,...} */ 
     
    116116#define TD_T_MASK       0x3 
    117117#define TD_T            (TD_T_MASK << TD_T_SHIFT) 
    118 #define TD_T_DATA0      (0x2 << TD_T_SHIFT)             /* DATA0 */ 
    119 #define TD_T_DATA1      (0x3 << TD_T_SHIFT)             /* DATA1 */ 
    120 #define TD_T_CARRY      (0x0 << TD_T_SHIFT)             /* uses ED_C */ 
     118#define TD_T_DATA0      (0x2 << TD_T_SHIFT)     /* DATA0 */ 
     119#define TD_T_DATA1      (0x3 << TD_T_SHIFT)     /* DATA1 */ 
     120#define TD_T_CARRY      (0x0 << TD_T_SHIFT)     /* uses ED_C */ 
    121121#define TD_T_GET(x)     (((x) >> TD_T_SHIFT) & TD_T_MASK) 
    122122#define TD_DP_SHIFT     21                      /* direction/pid */ 
    123123#define TD_DP_MASK      0x3 
    124124#define TD_DP           (TD_DP_MASK << TD_DP_SHIFT) 
    125 #define TD_DP_SETUP     (0x0 << TD_DP_SHIFT)            /* SETUP pid */ 
    126 #define TD_DP_OUT       (0x1 << TD_DP_SHIFT)            /* OUT pid */ 
    127 #define TD_DP_IN        (0x2 << TD_DP_SHIFT)            /* IN pid */ 
     125#define TD_DP_SETUP     (0x0 << TD_DP_SHIFT)    /* SETUP pid */ 
     126#define TD_DP_OUT       (0x1 << TD_DP_SHIFT)    /* OUT pid */ 
     127#define TD_DP_IN        (0x2 << TD_DP_SHIFT)    /* IN pid */ 
     128#define TD_DP_GET(x)    (((x) >> TD_DP_SHIFT) & TD_DP_MASK) 
    128129#define TD_ISI_SHIFT    8                       /* Interrupt Service Interval */ 
    129130#define TD_ISI_MASK     0x3f 
     
    143144        /* rest are purely for the driver's use */ 
    144145        __u8            index; 
    145         struct ed       *ed; 
    146         struct td       *td_hash;       /* dma-->td hashtable */ 
    147         struct td       *next_dl_td; 
     146/*      struct ed       *ed;*/ 
    148147        struct urb      *urb; 
    149148 
     
    151150        dma_addr_t      data_dma;       /* addr of data it points to */ 
    152151 
    153         struct list_head td_list;       /* "shadow list", TDs on same ED */ 
    154  
    155         u32             flags; 
    156 #define TD_FLAG_DONE    (1 << 17)       /* retired to done list */ 
    157 #define TD_FLAG_ISO     (1 << 16)       /* copy of ED_ISO */ 
    158152} __attribute__ ((aligned(TD_ALIGN)));  /* c/b/i need 16; only iso needs 32 */ 
    159153 
     
    355349struct urb_priv { 
    356350        struct ed               *ed; 
     351        struct urb              *urb; 
    357352        struct list_head        pending;        /* URBs on the same ED */ 
    358353 
     
    375370struct admhcd { 
    376371        spinlock_t              lock; 
     372        spinlock_t              dma_lock; 
     373        u32                     dma_state; 
    377374 
    378375        /* 
     
    385382         * only at the start of the next frame. 
    386383         */ 
    387  
    388384        struct ed               *ed_head; 
    389385        struct ed               *ed_tails[4]; 
    390386 
    391387        struct ed               *ed_rm_list;    /* to be removed */ 
    392         struct ed               *ed_halt_list;  /* halted due to an error */ 
    393         struct ed               *ed_soft_list;  /* for software interrupt processing */ 
    394  
    395388        struct ed               *periodic[NUM_INTS];    /* shadow int_table */ 
    396389 
     
    409402        struct dma_pool         *ed_cache; 
    410403        struct td               *td_hash[TD_HASH_SIZE]; 
    411         struct list_head        pending; 
    412404 
    413405        /* 
     
    447439#endif  /* DEBUG */ 
    448440 
     441#if 0 
    449442#define admhc_dbg(ahcd, fmt, args...) \ 
    450443        dev_dbg(admhcd_to_hcd(ahcd)->self.controller , fmt , ## args ) 
     
    461454#       define admhc_vdbg(ahcd, fmt, args...) do { } while (0) 
    462455#endif 
     456#else 
     457#define admhc_dbg(ahcd, fmt, args...) \ 
     458        printk(KERN_DEBUG "adm5120-hcd: " fmt , ## args ) 
     459#define admhc_err(ahcd, fmt, args...) \ 
     460        printk(KERN_ERR "adm5120-hcd: " fmt , ## args ) 
     461#define ahcd_info(ahcd, fmt, args...) \ 
     462        printk(KERN_INFO "adm5120-hcd: " fmt , ## args ) 
     463#define admhc_warn(ahcd, fmt, args...) \ 
     464        printk(KERN_WARNING "adm5120-hcd: " fmt , ## args ) 
     465 
     466#ifdef ADMHC_VERBOSE_DEBUG 
     467#       define admhc_vdbg admhc_dbg 
     468#else 
     469#       define admhc_vdbg(ahcd, fmt, args...) do { } while (0) 
     470#endif 
     471#endif 
    463472 
    464473/*-------------------------------------------------------------------------*/ 
     
    634643} 
    635644 
     645static inline u16 admhc_frame_remain(const struct admhcd *ahcd) 
     646{ 
     647        u32     t; 
     648 
     649        t = admhc_readl(ahcd, &ahcd->regs->fmnumber) >> ADMHC_SFN_FR_SHIFT; 
     650        t &= ADMHC_SFN_FR_MASK; 
     651        return (u16)t; 
     652} 
     653 
    636654/*-------------------------------------------------------------------------*/ 
    637655 
     
    653671        /* TODO: adjust FSLargestDataPacket value too? */ 
    654672        admhc_writel(ahcd, (fit ^ FIT) | ahcd->fminterval, 
    655                                                 &ahcd->regs->fminterval); 
     673                                        &ahcd->regs->fminterval); 
    656674} 
    657675 
     
    699717static inline void admhc_dma_enable(struct admhcd *ahcd) 
    700718{ 
    701         ahcd->host_control = admhc_readl(ahcd, &ahcd->regs->host_control); 
    702         if (ahcd->host_control & ADMHC_HC_DMAE) 
     719        u32 t; 
     720 
     721        t = admhc_readl(ahcd, &ahcd->regs->host_control); 
     722        if (t & ADMHC_HC_DMAE) 
    703723                return; 
    704724 
    705         ahcd->host_control |= ADMHC_HC_DMAE; 
    706         admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control); 
     725        t |= ADMHC_HC_DMAE; 
     726        admhc_writel(ahcd, t, &ahcd->regs->host_control); 
     727        admhc_dbg(ahcd,"DMA enabled\n"); 
    707728} 
    708729 
    709730static inline void admhc_dma_disable(struct admhcd *ahcd) 
    710731{ 
    711         ahcd->host_control = admhc_readl(ahcd, &ahcd->regs->host_control); 
    712         ahcd->host_control &= ~ADMHC_HC_DMAE; 
    713         admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control); 
    714 } 
     732        u32 t; 
     733 
     734        t = admhc_readl(ahcd, &ahcd->regs->host_control); 
     735        if (!(t & ADMHC_HC_DMAE)) 
     736                return; 
     737 
     738        t &= ~ADMHC_HC_DMAE; 
     739        admhc_writel(ahcd, t, &ahcd->regs->host_control); 
     740        admhc_dbg(ahcd,"DMA disabled\n"); 
     741} 
     742 
     743static inline void admhc_dma_lock(struct admhcd *ahcd) 
     744{ 
     745        spin_lock(ahcd->dma_lock); 
     746 
     747        ahcd->dma_state = admhc_readl(ahcd, &ahcd->regs->host_control); 
     748        admhc_writel(ahcd, 0, &ahcd->regs->hosthead); 
     749        admhc_writel(ahcd, ahcd->dma_state & ~ADMHC_HC_DMAE, 
     750                                &ahcd->regs->host_control); 
     751        admhc_dbg(ahcd,"DMA locked\n"); 
     752} 
     753 
     754static inline void admhc_dma_unlock(struct admhcd *ahcd) 
     755{ 
     756        admhc_writel(ahcd, (u32)ahcd->ed_head->dma, &ahcd->regs->hosthead); 
     757        admhc_writel(ahcd, ahcd->dma_state, &ahcd->regs->host_control); 
     758        admhc_dbg(ahcd,"DMA unlocked\n"); 
     759        spin_unlock(ahcd->dma_lock); 
     760} 
Note: See TracChangeset for help on using the changeset viewer.