Changeset 9550


Ignore:
Timestamp:
2007-11-15T10:16:47+01:00 (8 years ago)
Author:
juhosg
Message:

[adm5120] more USB driver changes

Location:
trunk/target/linux/adm5120
Files:
5 edited

Legend:

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

    r9543 r9550  
    140140                char **next, unsigned *size) 
    141141{ 
    142         admhc_dbg_sw(ahcd, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s%s\n", 
     142        admhc_dbg_sw(ahcd, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", 
    143143                label, 
    144144                mask, 
     
    151151                (mask & ADMHC_INTR_INSM) ? " INSM" : "", 
    152152                (mask & ADMHC_INTR_BABI) ? " BABI" : "", 
     153                (mask & ADMHC_INTR_7) ? " !7!" : "", 
     154                (mask & ADMHC_INTR_6) ? " !6!" : "", 
    153155                (mask & ADMHC_INTR_RESI) ? " RESI" : "", 
    154156                (mask & ADMHC_INTR_SOFI) ? " SOFI" : "" 
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120-hcd.c

    r9543 r9550  
    4646#include "../core/hub.h" 
    4747 
    48 #define DRIVER_VERSION  "v0.05" 
     48#define DRIVER_VERSION  "v0.06" 
    4949#define DRIVER_AUTHOR   "Gabor Juhos <juhosg at openwrt.org>" 
    5050#define DRIVER_DESC     "ADMtek USB 1.1 Host Controller Driver" 
     
    5252/*-------------------------------------------------------------------------*/ 
    5353 
    54 #define ADMHC_VERBOSE_DEBUG     /* not always helpful */ 
     54#undef ADMHC_VERBOSE_DEBUG      /* not always helpful */ 
    5555 
    5656/* For initializing controller (mask in an HCFS mode too) */ 
     
    5959#define ADMHC_INTR_INIT \ 
    6060                ( ADMHC_INTR_MIE | ADMHC_INTR_INSM | ADMHC_INTR_FATI \ 
    61                 | ADMHC_INTR_RESI | ADMHC_INTR_TDC | ADMHC_INTR_BABI ) 
     61                | ADMHC_INTR_RESI | ADMHC_INTR_TDC | ADMHC_INTR_BABI \ 
     62                | ADMHC_INTR_7 | ADMHC_INTR_6 ) 
    6263 
    6364/*-------------------------------------------------------------------------*/ 
     
    347348static void admhc_usb_reset(struct admhcd *ahcd) 
    348349{ 
     350        admhc_dbg(ahcd, "usb reset\n"); 
    349351        ahcd->host_control = ADMHC_BUSS_RESET; 
    350352        admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control); 
     
    360362        struct admhcd *ahcd; 
    361363 
     364        admhc_dbg(ahcd, "shutdown\n"); 
     365 
    362366        ahcd = hcd_to_admhcd(hcd); 
    363367        admhc_intr_disable(ahcd, ADMHC_INTR_MIE); 
     
    395399} 
    396400 
    397 #define ED_DUMMY_INFO   (ED_SPEED_FULL | ED_SKIP) 
     401#define ED_DUMMY_INFO   0 
    398402 
    399403static int admhc_eds_init(struct admhcd *ahcd) 
     
    528532        } 
    529533        admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control); 
    530  
    531534        msleep(temp); 
     535 
    532536        temp = admhc_read_rhdesc(ahcd); 
    533537        if (!(temp & ADMHC_RH_NPS)) { 
     
    548552                        return -1; 
    549553                } 
    550                 udelay (1); 
     554                udelay(1); 
    551555        } 
    552556 
     
    563567        hcd->uses_new_polling = 1; 
    564568 
    565 #if 0 
    566         /* wake on ConnectStatusChange, matching external hubs */ 
    567         admhc_writel(ahcd, RH_HS_DRWE, &ahcd->regs->roothub.status); 
    568 #else 
    569         /* FIXME roothub_write_status (ahcd, ADMHC_RH_DRWE); */ 
    570 #endif 
    571  
    572         /* Choose the interrupts we care about now, others later on demand */ 
    573         admhc_intr_ack(ahcd, ~0); 
    574         admhc_intr_enable(ahcd, ADMHC_INTR_INIT); 
    575  
    576         admhc_writel(ahcd, ADMHC_RH_NPS | ADMHC_RH_LPSC, &ahcd->regs->rhdesc); 
    577  
    578569        /* start controller operations */ 
    579570        ahcd->host_control = ADMHC_BUSS_OPER; 
    580571        admhc_writel(ahcd, ahcd->host_control, &ahcd->regs->host_control); 
     572        hcd->state = HC_STATE_RUNNING; 
    581573 
    582574        temp = 20; 
     
    591583        } 
    592584 
     585#if 0 
     586        /* FIXME */ 
     587        /* wake on ConnectStatusChange, matching external hubs */ 
     588        admhc_writel(ahcd, ADMHC_RH_DRWE, &ahcd->regs->rhdesc); 
     589#endif 
     590 
     591        /* Choose the interrupts we care about now, others later on demand */ 
     592        temp = ADMHC_INTR_INIT; 
     593        admhc_intr_ack(ahcd, ~0); 
     594        admhc_intr_enable(ahcd, temp); 
     595 
     596        admhc_writel(ahcd, ADMHC_RH_NPS | ADMHC_RH_LPSC, &ahcd->regs->rhdesc); 
     597 
     598        ahcd->next_statechange = jiffies + STATECHANGE_DELAY; 
     599        spin_unlock_irq(&ahcd->lock); 
     600 
     601        mdelay(ADMHC_POTPGT); 
    593602        hcd->state = HC_STATE_RUNNING; 
    594         ahcd->next_statechange = jiffies + STATECHANGE_DELAY; 
    595  
    596         spin_unlock_irq(&ahcd->lock); 
    597  
    598         mdelay(ADMHC_POTPGT); 
    599603 
    600604        return 0; 
     
    612616 
    613617        ints = admhc_readl(ahcd, &regs->int_status); 
    614         if (!(ints & ADMHC_INTR_INTA)) 
     618        if (!(ints & ADMHC_INTR_INTA)) { 
    615619                /* no unmasked interrupt status is set */ 
     620                admhc_err(ahcd, "spurious interrupt %08x\n", ints); 
    616621                return IRQ_NONE; 
     622        } 
    617623 
    618624        ints &= admhc_readl(ahcd, &regs->int_enable); 
    619         if (!ints) 
     625        if (!ints) { 
     626                admhc_err(ahcd, "hardware irq problems?\n"); 
    620627                return IRQ_NONE; 
     628        } 
     629 
     630        if (ints & ADMHC_INTR_6) { 
     631                admhc_err(ahcd, "unknown interrupt 6\n"); 
     632                admhc_dump(ahcd, 0); 
     633        } 
     634 
     635        if (ints & ADMHC_INTR_7) { 
     636                admhc_err(ahcd, "unknown interrupt 7\n"); 
     637                admhc_dump(ahcd, 0); 
     638        } 
    621639 
    622640        if (ints & ADMHC_INTR_FATI) { 
     
    656674                hcd->poll_rh = 1; 
    657675                if (ahcd->autostop) { 
     676                        spin_lock(&ahcd->lock); 
    658677                        admhc_rh_resume(ahcd); 
     678                        spin_unlock(&ahcd->lock); 
    659679                } else 
    660680                        usb_hcd_resume_root_hub(hcd); 
     
    662682 
    663683        if (ints & ADMHC_INTR_TDC) { 
    664                 admhc_intr_ack(ahcd, ADMHC_INTR_TDC); 
     684                admhc_vdbg(ahcd, "Transfer Descriptor Complete\n"); 
    665685                if (HC_IS_RUNNING(hcd->state)) 
    666686                        admhc_intr_disable(ahcd, ADMHC_INTR_TDC); 
    667                 admhc_vdbg(ahcd, "Transfer Descriptor Complete\n"); 
    668687                spin_lock(&ahcd->lock); 
    669688                admhc_td_complete(ahcd); 
     
    675694        if (ints & ADMHC_INTR_SO) { 
    676695                /* could track INTR_SO to reduce available PCI/... bandwidth */ 
    677                 admhc_vdbg(ahcd, "Schedule Overrun\n"); 
     696                admhc_err(ahcd, "Schedule Overrun\n"); 
    678697        } 
    679698 
    680699        if (ints & ADMHC_INTR_SOFI) { 
    681                 admhc_intr_ack(ahcd, ADMHC_INTR_SOFI); 
    682700                spin_lock(&ahcd->lock); 
    683701                /* handle any pending ED removes */ 
    684702                admhc_finish_unlinks(ahcd, admhc_frame_no(ahcd)); 
    685                 admhc_sof_refill(ahcd); 
    686703                spin_unlock(&ahcd->lock); 
    687704        } 
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120-q.c

    r9513 r9550  
    9191        } 
    9292 
     93        info |= ED_SKIP; 
     94 
    9395        ed->dummy = td; 
    9496        ed->state = ED_NEW; 
     
    113115        struct usb_device *udev, unsigned int pipe, int interval) 
    114116{ 
    115         struct ed               *ed; 
    116         unsigned long           flags; 
    117  
    118         spin_lock_irqsave(&ahcd->lock, flags); 
     117        struct ed *ed; 
     118 
    119119        ed = ep->hcpriv; 
    120120        if (!ed) { 
     
    134134                        ep->hcpriv = ed; 
    135135        } 
    136         spin_unlock_irqrestore(&ahcd->lock, flags); 
    137136 
    138137        return ed; 
     138} 
     139 
     140static void ed_next_urb(struct admhcd *ahcd, struct ed *ed) 
     141{ 
     142        struct urb_priv *up; 
     143        u32 carry; 
     144 
     145        up = list_entry(ed->urb_pending.next, struct urb_priv, pending); 
     146        list_del(&up->pending); 
     147 
     148        ed->urb_active = up; 
     149        ed->state = ED_OPER; 
     150 
     151#ifdef ADMHC_VERBOSE_DEBUG 
     152        urb_print(ahcd, up->urb, "NEXT", 0); 
     153        admhc_dump_ed(ahcd, " ", ed, 0); 
     154#endif 
     155 
     156        up->td[up->td_cnt-1]->hwNextTD = cpu_to_hc32(ahcd, ed->dummy->td_dma); 
     157 
     158        carry = hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_C; 
     159        ed->hwHeadP = cpu_to_hc32(ahcd, up->td[0]->td_dma | carry); 
     160        ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); 
    139161} 
    140162 
     
    147169                return -EAGAIN; 
    148170 
    149         if (ed->state != ED_NEW) 
    150                 return 0; 
    151  
     171        if (ed->state == ED_NEW) { 
     172                ed->state = ED_IDLE; 
     173 
     174                old_tail = ahcd->ed_tails[ed->type]; 
     175 
     176                ed->ed_next = old_tail->ed_next; 
     177                if (ed->ed_next) { 
     178                        ed->ed_next->ed_prev = ed; 
     179                        ed->hwNextED = cpu_to_hc32(ahcd, ed->ed_next->dma); 
     180                } 
     181                ed->ed_prev = old_tail; 
     182 
     183                old_tail->ed_next = ed; 
     184                old_tail->hwNextED = cpu_to_hc32(ahcd, ed->dma); 
     185 
     186                ahcd->ed_tails[ed->type] = ed; 
     187                ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); 
     188        } 
     189 
     190#ifdef ADMHC_VERBOSE_DEBUG 
    152191        admhc_dump_ed(ahcd, "ED-SCHED", ed, 0); 
    153  
    154         ed->state = ED_IDLE; 
    155  
    156         ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); 
    157  
    158         old_tail = ahcd->ed_tails[ed->type]; 
    159  
    160         ed->ed_next = old_tail->ed_next; 
    161         if (ed->ed_next) { 
    162                 ed->ed_next->ed_prev = ed; 
    163                 ed->hwNextED = cpu_to_hc32(ahcd, ed->ed_next->dma); 
    164         } 
    165         ed->ed_prev = old_tail; 
    166  
    167         old_tail->ed_next = ed; 
    168         old_tail->hwNextED = cpu_to_hc32(ahcd, ed->dma); 
    169  
    170         ahcd->ed_tails[ed->type] = ed; 
    171  
    172         admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); 
     192#endif 
     193 
     194        if (!ed->urb_active) { 
     195                ed_next_urb(ahcd, ed); 
     196                admhc_dma_enable(ahcd); 
     197        } 
    173198 
    174199        return 0; 
     
    177202static void ed_deschedule(struct admhcd *ahcd, struct ed *ed) 
    178203{ 
     204 
     205#ifdef ADMHC_VERBOSE_DEBUG 
    179206        admhc_dump_ed(ahcd, "ED-DESCHED", ed, 0); 
     207#endif 
    180208 
    181209        /* remove this ED from the HC list */ 
     
    198226static void ed_start_deschedule(struct admhcd *ahcd, struct ed *ed) 
    199227{ 
     228 
     229#ifdef ADMHC_VERBOSE_DEBUG 
    200230        admhc_dump_ed(ahcd, "ED-UNLINK", ed, 0); 
     231#endif 
    201232 
    202233        ed->hwINFO |= cpu_to_hc32(ahcd, ED_SKIP); 
    203  
    204234        ed->state = ED_UNLINK; 
    205  
    206         /* add this ED into the remove list */ 
    207         ed->ed_rm_next = ahcd->ed_rm_list; 
    208         ahcd->ed_rm_list = ed; 
    209235 
    210236        /* SOF interrupt might get delayed; record the frame counter value that 
     
    215241        ed->tick = admhc_frame_no(ahcd) + 1; 
    216242 
    217         /* enable SOF interrupt */ 
    218243        admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); 
    219244} 
     
    230255 
    231256        if (up->td_idx >= up->td_cnt) { 
    232                 admhc_dbg(ahcd, "td_fill error, idx=%d, cnt=%d\n", up->td_idx, 
     257                admhc_err(ahcd, "td_fill error, idx=%d, cnt=%d\n", up->td_idx, 
    233258                                up->td_cnt); 
    234                 return; 
     259                BUG(); 
    235260        } 
    236261 
     
    240265                data = 0; 
    241266 
    242 #if 1 
    243267        if (up->td_idx == up->td_cnt-1) 
    244 #endif 
    245268                cbl |= TD_IE; 
    246269 
     
    447470         */ 
    448471        } else { 
     472 
     473#ifdef ADMHC_VERBOSE_DEBUG 
    449474                admhc_dump_td(ahcd, "td_done", td); 
     475#endif 
    450476 
    451477                /* count all non-empty packets except control SETUP packet */ 
     
    460486/*-------------------------------------------------------------------------*/ 
    461487 
    462 static inline struct td * 
    463 ed_halted(struct admhcd *ahcd, struct td *td, int cc, struct td *rev) 
    464 { 
    465 #if 0 
    466         struct urb              *urb = td->urb; 
    467         struct ed               *ed = td->ed; 
    468         struct list_head        *tmp = td->td_list.next; 
    469         __hc32                  toggle = ed->hwHeadP & cpu_to_hc32 (ahcd, ED_C); 
    470  
    471         admhc_dump_ed(ahcd, "ed halted", td->ed, 1); 
    472         /* clear ed halt; this is the td that caused it, but keep it inactive 
    473          * until its urb->complete() has a chance to clean up. 
    474          */ 
    475         ed->hwINFO |= cpu_to_hc32 (ahcd, ED_SKIP); 
    476         wmb (); 
    477         ed->hwHeadP &= ~cpu_to_hc32 (ahcd, ED_H); 
    478  
    479         /* put any later tds from this urb onto the donelist, after 'td', 
    480          * order won't matter here: no errors, and nothing was transferred. 
    481          * also patch the ed so it looks as if those tds completed normally. 
    482          */ 
    483         while (tmp != &ed->td_list) { 
    484                 struct td       *next; 
    485                 __hc32          info; 
    486  
    487                 next = list_entry(tmp, struct td, td_list); 
    488                 tmp = next->td_list.next; 
    489  
    490                 if (next->urb != urb) 
    491                         break; 
    492  
    493                 /* NOTE: if multi-td control DATA segments get supported, 
    494                  * this urb had one of them, this td wasn't the last td 
    495                  * in that segment (TD_R clear), this ed halted because 
    496                  * of a short read, _and_ URB_SHORT_NOT_OK is clear ... 
    497                  * then we need to leave the control STATUS packet queued 
    498                  * and clear ED_SKIP. 
    499                  */ 
    500                 info = next->hwINFO; 
    501 #if 0           /* FIXME */ 
    502                 info |= cpu_to_hc32 (ahcd, TD_DONE); 
    503                 info &= ~cpu_to_hc32 (ahcd, TD_CC); 
    504 #endif 
    505                 next->hwINFO = info; 
    506  
    507                 next->next_dl_td = rev; 
    508                 rev = next; 
    509  
    510                 ed->hwHeadP = next->hwNextTD | toggle; 
    511         } 
    512  
    513         /* help for troubleshooting:  report anything that 
    514          * looks odd ... that doesn't include protocol stalls 
    515          * (or maybe some other things) 
    516          */ 
    517         switch (cc) { 
    518         case TD_CC_DATAUNDERRUN: 
    519                 if ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0) 
    520                         break; 
    521                 /* fallthrough */ 
    522         case TD_CC_STALL: 
    523                 if (usb_pipecontrol (urb->pipe)) 
    524                         break; 
    525                 /* fallthrough */ 
    526         default: 
    527                 admhc_dbg (ahcd, 
    528                         "urb %p path %s ep%d%s %08x cc %d --> status %d\n", 
    529                         urb, urb->dev->devpath, 
    530                         usb_pipeendpoint (urb->pipe), 
    531                         usb_pipein (urb->pipe) ? "in" : "out", 
    532                         hc32_to_cpu(ahcd, td->hwINFO), 
    533                         cc, cc_to_error [cc]); 
    534         } 
    535  
    536         return rev; 
    537 #else 
    538         return NULL; 
    539 #endif 
    540 } 
    541  
    542 /*-------------------------------------------------------------------------*/ 
    543  
    544 static int ed_next_urb(struct admhcd *ahcd, struct ed *ed) 
    545 { 
    546         struct urb_priv *up; 
    547         u32 carry; 
    548  
    549         if (ed->state != ED_IDLE) 
    550                 return 1; 
    551  
    552         if (ed->urb_active) 
    553                 return 1; 
    554  
    555         if (list_empty(&ed->urb_pending)) 
    556                 return 0; 
    557  
    558         up = list_entry(ed->urb_pending.next, struct urb_priv, pending); 
    559         list_del(&up->pending); 
    560         ed->urb_active = up; 
    561         ed->state = ED_OPER; 
    562  
    563 #ifdef ADMHC_VERBOSE_DEBUG 
    564         urb_print(ahcd, up->urb, "NEXT", 0); 
    565         admhc_dump_ed(ahcd, " ", ed, 0); 
    566 #endif 
    567  
    568         up->td[up->td_cnt-1]->hwNextTD = cpu_to_hc32(ahcd, ed->dummy->td_dma); 
    569  
    570         carry = hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_C; 
    571         ed->hwHeadP = cpu_to_hc32(ahcd, up->td[0]->td_dma | carry); 
    572         ed->hwINFO &= ~cpu_to_hc32(ahcd, ED_SKIP); 
    573  
    574         return 1; 
    575 } 
    576  
    577 static void ed_update(struct admhcd *ahcd, struct ed *ed, int partial) 
     488static void ed_update(struct admhcd *ahcd, struct ed *ed, int force) 
    578489{ 
    579490        struct urb_priv *up; 
     
    589500#ifdef ADMHC_VERBOSE_DEBUG 
    590501        urb_print(ahcd, urb, "UPDATE", 0); 
    591 #endif 
    592502        admhc_dump_ed(ahcd, "ED-UPDATE", ed, 1); 
     503#endif 
    593504 
    594505        cc = TD_CC_NOERROR; 
     
    612523        } 
    613524 
    614         if ((up->td_idx != up->td_cnt) && (!partial)) 
     525        if ((up->td_idx != up->td_cnt) && (!force)) 
    615526                /* the URB is not completed yet */ 
    616527                return; 
     
    638549{ 
    639550        struct ed *ed; 
     551        int more = 0; 
    640552 
    641553        for (ed = ahcd->ed_head; ed; ed = ed->ed_next) { 
     
    643555                        continue; 
    644556 
    645                 if (hc32_to_cpup(ahcd, &ed->hwINFO) & ED_SKIP) 
     557                if (hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_H) { 
     558                        admhc_dump_ed(ahcd, "ed halted", ed, 1); 
     559                        ed_update(ahcd, ed, 1); 
     560                        ed->hwHeadP &= ~cpu_to_hc32(ahcd, ED_H); 
     561                } else 
     562                        ed_update(ahcd, ed, 0); 
     563 
     564                if (ed->urb_active) { 
     565                        more = 1; 
    646566                        continue; 
    647  
    648                 if (hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_H) { 
    649                         /* TODO */ 
     567                } 
     568 
     569                if (!(list_empty(&ed->urb_pending))) { 
     570                        more = 1; 
     571                        ed_next_urb(ahcd, ed); 
    650572                        continue; 
    651573                } 
    652574 
    653                 ed_update(ahcd, ed, 0); 
    654         } 
     575                ed_start_deschedule(ahcd, ed); 
     576        } 
     577 
     578        if (!more) 
     579                admhc_dma_disable(ahcd); 
     580 
    655581} 
    656582 
     
    659585{ 
    660586        struct ed *ed; 
     587        int more = 0; 
    661588 
    662589        for (ed = ahcd->ed_head; ed; ed = ed->ed_next) { 
     
    665592 
    666593                if (likely(HC_IS_RUNNING(admhcd_to_hcd(ahcd)->state))) 
    667                         if (tick_before(tick, ed->tick)) 
     594                        if (tick_before(tick, ed->tick)) { 
     595                                more = 1; 
    668596                                continue; 
     597                        } 
    669598 
    670599                /* process partial status */ 
    671                 ed_update(ahcd, ed, 1); 
    672         } 
    673 } 
    674  
    675 static void admhc_sof_refill(struct admhcd *ahcd) 
    676 { 
    677         struct ed *ed; 
    678         int disable_dma = 1; 
    679  
    680         for (ed = ahcd->ed_head; ed; ed = ed->ed_next) { 
    681  
    682                 if (hc32_to_cpup(ahcd, &ed->hwHeadP) & ED_H) { 
     600                if (ed->urb_active) 
    683601                        ed_update(ahcd, ed, 1); 
    684                         ed->hwHeadP &= ~cpu_to_hc32 (ahcd, ED_H); 
    685                 } 
    686  
    687                 if (ed_next_urb(ahcd, ed)) { 
    688                         disable_dma = 0; 
    689                 } else { 
    690                         struct ed *tmp; 
    691                         tmp = ed->ed_prev; 
     602 
     603                if (list_empty(&ed->urb_pending)) 
    692604                        ed_deschedule(ahcd, ed); 
    693                         ed = tmp; 
    694                 } 
    695         } 
    696  
    697         if (disable_dma) { 
    698                 admhc_intr_disable(ahcd, ADMHC_INTR_SOFI); 
    699                 admhc_dma_disable(ahcd); 
    700         } else { 
    701                 admhc_intr_enable(ahcd, ADMHC_INTR_SOFI); 
    702                 admhc_dma_enable(ahcd); 
    703         } 
    704 } 
     605                else 
     606                        ed_schedule(ahcd, ed); 
     607        } 
     608 
     609        if (!more) 
     610                if (likely(HC_IS_RUNNING(admhcd_to_hcd(ahcd)->state))) 
     611                        admhc_intr_disable(ahcd, ADMHC_INTR_SOFI); 
     612} 
  • trunk/target/linux/adm5120/files/drivers/usb/host/adm5120.h

    r9543 r9550  
    6666        struct ed               *ed_next;       /* on schedule list */ 
    6767        struct ed               *ed_prev;       /* for non-interrupt EDs */ 
    68         struct ed               *ed_rm_next;    /* on rm list */ 
    6968 
    7069        /* create --> IDLE --> OPER --> ... --> IDLE --> destroy 
     
    263262#define ADMHC_INTR_SOFI (1 << 4)        /* start of frame */ 
    264263#define ADMHC_INTR_RESI (1 << 5)        /* resume detected */ 
     264#define ADMHC_INTR_6    (1 << 6)        /* unknown */ 
     265#define ADMHC_INTR_7    (1 << 7)        /* unknown */ 
    265266#define ADMHC_INTR_BABI (1 << 8)        /* babble detected */ 
    266267#define ADMHC_INTR_INSM (1 << 9)        /* root hub status change */ 
     
    382383        struct ed               *ed_tails[4]; 
    383384 
    384         struct ed               *ed_rm_list;    /* to be removed */ 
    385         struct ed               *periodic[NUM_INTS];    /* shadow int_table */ 
     385//      struct ed               *periodic[NUM_INTS];    /* shadow int_table */ 
    386386 
    387387#if 0   /* TODO: remove? */ 
  • trunk/target/linux/adm5120/router_le/config-2.6.23

    r9500 r9550  
    238238CONFIG_TRAD_SIGNALS=y 
    239239# CONFIG_USBPCWATCHDOG is not set 
    240 # CONFIG_USB_ACM is not set 
    241240CONFIG_USB_ADM5120_HCD=m 
    242241# CONFIG_USB_ALI_M5632 is not set 
    243242# CONFIG_USB_AN2720 is not set 
    244243# CONFIG_USB_CATC is not set 
     244CONFIG_USB_DEBUG=y 
    245245CONFIG_USB_EHCI_HCD=m 
    246246# CONFIG_USB_KAWETH is not set 
Note: See TracChangeset for help on using the changeset viewer.