Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * ISP116x HCD (Host Controller Driver) for USB.
0004  *
0005  * Derived from the SL811 HCD, rewritten for ISP116x.
0006  * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
0007  *
0008  * Portions:
0009  * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
0010  * Copyright (C) 2004 David Brownell
0011  *
0012  * Periodic scheduling is based on Roman's OHCI code
0013  * Copyright (C) 1999 Roman Weissgaerber
0014  *
0015  */
0016 
0017 /*
0018  * The driver basically works. A number of people have used it with a range
0019  * of devices.
0020  *
0021  * The driver passes all usbtests 1-14.
0022  *
0023  * Suspending/resuming of root hub via sysfs works. Remote wakeup works too.
0024  * And suspending/resuming of platform device works too. Suspend/resume
0025  * via HCD operations vector is not implemented.
0026  *
0027  * Iso transfer support is not implemented. Adding this would include
0028  * implementing recovery from the failure to service the processed ITL
0029  * fifo ram in time, which will involve chip reset.
0030  *
0031  * TODO:
0032  + More testing of suspend/resume.
0033 */
0034 
0035 /*
0036   ISP116x chips require certain delays between accesses to its
0037   registers. The following timing options exist.
0038 
0039   1. Configure your memory controller (the best)
0040   2. Implement platform-specific delay function possibly
0041   combined with configuring the memory controller; see
0042   include/linux/usb-isp116x.h for more info. Some broken
0043   memory controllers line LH7A400 SMC need this. Also,
0044   uncomment for that to work the following
0045   USE_PLATFORM_DELAY macro.
0046   3. Use ndelay (easiest, poorest). For that, uncomment
0047   the following USE_NDELAY macro.
0048 */
0049 #define USE_PLATFORM_DELAY
0050 //#define USE_NDELAY
0051 
0052 //#define DEBUG
0053 //#define VERBOSE
0054 /* Transfer descriptors. See dump_ptd() for printout format  */
0055 //#define PTD_TRACE
0056 /* enqueuing/finishing log of urbs */
0057 //#define URB_TRACE
0058 
0059 #include <linux/module.h>
0060 #include <linux/delay.h>
0061 #include <linux/debugfs.h>
0062 #include <linux/seq_file.h>
0063 #include <linux/errno.h>
0064 #include <linux/list.h>
0065 #include <linux/slab.h>
0066 #include <linux/usb.h>
0067 #include <linux/usb/isp116x.h>
0068 #include <linux/usb/hcd.h>
0069 #include <linux/platform_device.h>
0070 
0071 #include <asm/io.h>
0072 #include <asm/irq.h>
0073 #include <asm/byteorder.h>
0074 
0075 #include "isp116x.h"
0076 
0077 #define DRIVER_VERSION  "03 Nov 2005"
0078 #define DRIVER_DESC "ISP116x USB Host Controller Driver"
0079 
0080 MODULE_DESCRIPTION(DRIVER_DESC);
0081 MODULE_LICENSE("GPL");
0082 
0083 static const char hcd_name[] = "isp116x-hcd";
0084 
0085 /*-----------------------------------------------------------------*/
0086 
0087 /*
0088   Write len bytes to fifo, pad till 32-bit boundary
0089  */
0090 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
0091 {
0092     u8 *dp = (u8 *) buf;
0093     u16 *dp2 = (u16 *) buf;
0094     u16 w;
0095     int quot = len % 4;
0096 
0097     /* buffer is already in 'usb data order', which is LE. */
0098     /* When reading buffer as u16, we have to take care byte order */
0099     /* doesn't get mixed up */
0100 
0101     if ((unsigned long)dp2 & 1) {
0102         /* not aligned */
0103         for (; len > 1; len -= 2) {
0104             w = *dp++;
0105             w |= *dp++ << 8;
0106             isp116x_raw_write_data16(isp116x, w);
0107         }
0108         if (len)
0109             isp116x_write_data16(isp116x, (u16) * dp);
0110     } else {
0111         /* aligned */
0112         for (; len > 1; len -= 2) {
0113             /* Keep byte order ! */
0114             isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
0115         }
0116 
0117         if (len)
0118             isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
0119     }
0120     if (quot == 1 || quot == 2)
0121         isp116x_raw_write_data16(isp116x, 0);
0122 }
0123 
0124 /*
0125   Read len bytes from fifo and then read till 32-bit boundary.
0126  */
0127 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
0128 {
0129     u8 *dp = (u8 *) buf;
0130     u16 *dp2 = (u16 *) buf;
0131     u16 w;
0132     int quot = len % 4;
0133 
0134     /* buffer is already in 'usb data order', which is LE. */
0135     /* When reading buffer as u16, we have to take care byte order */
0136     /* doesn't get mixed up */
0137 
0138     if ((unsigned long)dp2 & 1) {
0139         /* not aligned */
0140         for (; len > 1; len -= 2) {
0141             w = isp116x_raw_read_data16(isp116x);
0142             *dp++ = w & 0xff;
0143             *dp++ = (w >> 8) & 0xff;
0144         }
0145 
0146         if (len)
0147             *dp = 0xff & isp116x_read_data16(isp116x);
0148     } else {
0149         /* aligned */
0150         for (; len > 1; len -= 2) {
0151             /* Keep byte order! */
0152             *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
0153         }
0154 
0155         if (len)
0156             *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
0157     }
0158     if (quot == 1 || quot == 2)
0159         isp116x_raw_read_data16(isp116x);
0160 }
0161 
0162 /*
0163   Write ptd's and data for scheduled transfers into
0164   the fifo ram. Fifo must be empty and ready.
0165 */
0166 static void pack_fifo(struct isp116x *isp116x)
0167 {
0168     struct isp116x_ep *ep;
0169     struct ptd *ptd;
0170     int buflen = isp116x->atl_last_dir == PTD_DIR_IN
0171         ? isp116x->atl_bufshrt : isp116x->atl_buflen;
0172 
0173     isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
0174     isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
0175     isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
0176     for (ep = isp116x->atl_active; ep; ep = ep->active) {
0177         ptd = &ep->ptd;
0178         dump_ptd(ptd);
0179         dump_ptd_out_data(ptd, ep->data);
0180         isp116x_write_data16(isp116x, ptd->count);
0181         isp116x_write_data16(isp116x, ptd->mps);
0182         isp116x_write_data16(isp116x, ptd->len);
0183         isp116x_write_data16(isp116x, ptd->faddr);
0184         buflen -= sizeof(struct ptd);
0185         /* Skip writing data for last IN PTD */
0186         if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
0187             write_ptddata_to_fifo(isp116x, ep->data, ep->length);
0188             buflen -= ALIGN(ep->length, 4);
0189         }
0190     }
0191     BUG_ON(buflen);
0192 }
0193 
0194 /*
0195   Read the processed ptd's and data from fifo ram back to
0196   URBs' buffers. Fifo must be full and done
0197 */
0198 static void unpack_fifo(struct isp116x *isp116x)
0199 {
0200     struct isp116x_ep *ep;
0201     struct ptd *ptd;
0202     int buflen = isp116x->atl_last_dir == PTD_DIR_IN
0203         ? isp116x->atl_buflen : isp116x->atl_bufshrt;
0204 
0205     isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
0206     isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
0207     isp116x_write_addr(isp116x, HCATLPORT);
0208     for (ep = isp116x->atl_active; ep; ep = ep->active) {
0209         ptd = &ep->ptd;
0210         ptd->count = isp116x_read_data16(isp116x);
0211         ptd->mps = isp116x_read_data16(isp116x);
0212         ptd->len = isp116x_read_data16(isp116x);
0213         ptd->faddr = isp116x_read_data16(isp116x);
0214         buflen -= sizeof(struct ptd);
0215         /* Skip reading data for last Setup or Out PTD */
0216         if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
0217             read_ptddata_from_fifo(isp116x, ep->data, ep->length);
0218             buflen -= ALIGN(ep->length, 4);
0219         }
0220         dump_ptd(ptd);
0221         dump_ptd_in_data(ptd, ep->data);
0222     }
0223     BUG_ON(buflen);
0224 }
0225 
0226 /*---------------------------------------------------------------*/
0227 
0228 /*
0229   Set up PTD's.
0230 */
0231 static void preproc_atl_queue(struct isp116x *isp116x)
0232 {
0233     struct isp116x_ep *ep;
0234     struct urb *urb;
0235     struct ptd *ptd;
0236     u16 len;
0237 
0238     for (ep = isp116x->atl_active; ep; ep = ep->active) {
0239         u16 toggle = 0, dir = PTD_DIR_SETUP;
0240 
0241         BUG_ON(list_empty(&ep->hep->urb_list));
0242         urb = container_of(ep->hep->urb_list.next,
0243                    struct urb, urb_list);
0244         ptd = &ep->ptd;
0245         len = ep->length;
0246         ep->data = (unsigned char *)urb->transfer_buffer
0247             + urb->actual_length;
0248 
0249         switch (ep->nextpid) {
0250         case USB_PID_IN:
0251             toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
0252             dir = PTD_DIR_IN;
0253             break;
0254         case USB_PID_OUT:
0255             toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
0256             dir = PTD_DIR_OUT;
0257             break;
0258         case USB_PID_SETUP:
0259             len = sizeof(struct usb_ctrlrequest);
0260             ep->data = urb->setup_packet;
0261             break;
0262         case USB_PID_ACK:
0263             toggle = 1;
0264             len = 0;
0265             dir = (urb->transfer_buffer_length
0266                    && usb_pipein(urb->pipe))
0267                 ? PTD_DIR_OUT : PTD_DIR_IN;
0268             break;
0269         default:
0270             ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
0271                 ep->nextpid);
0272             BUG();
0273         }
0274 
0275         ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
0276         ptd->mps = PTD_MPS(ep->maxpacket)
0277             | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
0278             | PTD_EP(ep->epnum);
0279         ptd->len = PTD_LEN(len) | PTD_DIR(dir);
0280         ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
0281         if (!ep->active) {
0282             ptd->mps |= PTD_LAST_MSK;
0283             isp116x->atl_last_dir = dir;
0284         }
0285         isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
0286         isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
0287     }
0288 }
0289 
0290 /*
0291   Take done or failed requests out of schedule. Give back
0292   processed urbs.
0293 */
0294 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
0295                struct urb *urb, int status)
0296 __releases(isp116x->lock) __acquires(isp116x->lock)
0297 {
0298     unsigned i;
0299 
0300     ep->error_count = 0;
0301 
0302     if (usb_pipecontrol(urb->pipe))
0303         ep->nextpid = USB_PID_SETUP;
0304 
0305     urb_dbg(urb, "Finish");
0306 
0307     usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
0308     spin_unlock(&isp116x->lock);
0309     usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
0310     spin_lock(&isp116x->lock);
0311 
0312     /* take idle endpoints out of the schedule */
0313     if (!list_empty(&ep->hep->urb_list))
0314         return;
0315 
0316     /* async deschedule */
0317     if (!list_empty(&ep->schedule)) {
0318         list_del_init(&ep->schedule);
0319         return;
0320     }
0321 
0322     /* periodic deschedule */
0323     DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
0324     for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
0325         struct isp116x_ep *temp;
0326         struct isp116x_ep **prev = &isp116x->periodic[i];
0327 
0328         while (*prev && ((temp = *prev) != ep))
0329             prev = &temp->next;
0330         if (*prev)
0331             *prev = ep->next;
0332         isp116x->load[i] -= ep->load;
0333     }
0334     ep->branch = PERIODIC_SIZE;
0335     isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
0336         ep->load / ep->period;
0337 
0338     /* switch irq type? */
0339     if (!--isp116x->periodic_count) {
0340         isp116x->irqenb &= ~HCuPINT_SOF;
0341         isp116x->irqenb |= HCuPINT_ATL;
0342     }
0343 }
0344 
0345 /*
0346   Analyze transfer results, handle partial transfers and errors
0347 */
0348 static void postproc_atl_queue(struct isp116x *isp116x)
0349 {
0350     struct isp116x_ep *ep;
0351     struct urb *urb;
0352     struct usb_device *udev;
0353     struct ptd *ptd;
0354     int short_not_ok;
0355     int status;
0356     u8 cc;
0357 
0358     for (ep = isp116x->atl_active; ep; ep = ep->active) {
0359         BUG_ON(list_empty(&ep->hep->urb_list));
0360         urb =
0361             container_of(ep->hep->urb_list.next, struct urb, urb_list);
0362         udev = urb->dev;
0363         ptd = &ep->ptd;
0364         cc = PTD_GET_CC(ptd);
0365         short_not_ok = 1;
0366         status = -EINPROGRESS;
0367 
0368         /* Data underrun is special. For allowed underrun
0369            we clear the error and continue as normal. For
0370            forbidden underrun we finish the DATA stage
0371            immediately while for control transfer,
0372            we do a STATUS stage. */
0373         if (cc == TD_DATAUNDERRUN) {
0374             if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
0375                     usb_pipecontrol(urb->pipe)) {
0376                 DBG("Allowed or control data underrun\n");
0377                 cc = TD_CC_NOERROR;
0378                 short_not_ok = 0;
0379             } else {
0380                 ep->error_count = 1;
0381                 usb_settoggle(udev, ep->epnum,
0382                           ep->nextpid == USB_PID_OUT,
0383                           PTD_GET_TOGGLE(ptd));
0384                 urb->actual_length += PTD_GET_COUNT(ptd);
0385                 status = cc_to_error[TD_DATAUNDERRUN];
0386                 goto done;
0387             }
0388         }
0389 
0390         if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
0391             && (++ep->error_count >= 3 || cc == TD_CC_STALL
0392             || cc == TD_DATAOVERRUN)) {
0393             status = cc_to_error[cc];
0394             if (ep->nextpid == USB_PID_ACK)
0395                 ep->nextpid = 0;
0396             goto done;
0397         }
0398         /* According to usb spec, zero-length Int transfer signals
0399            finishing of the urb. Hey, does this apply only
0400            for IN endpoints? */
0401         if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
0402             status = 0;
0403             goto done;
0404         }
0405 
0406         /* Relax after previously failed, but later succeeded
0407            or correctly NAK'ed retransmission attempt */
0408         if (ep->error_count
0409             && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
0410             ep->error_count = 0;
0411 
0412         /* Take into account idiosyncracies of the isp116x chip
0413            regarding toggle bit for failed transfers */
0414         if (ep->nextpid == USB_PID_OUT)
0415             usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
0416                       ^ (ep->error_count > 0));
0417         else if (ep->nextpid == USB_PID_IN)
0418             usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
0419                       ^ (ep->error_count > 0));
0420 
0421         switch (ep->nextpid) {
0422         case USB_PID_IN:
0423         case USB_PID_OUT:
0424             urb->actual_length += PTD_GET_COUNT(ptd);
0425             if (PTD_GET_ACTIVE(ptd)
0426                 || (cc != TD_CC_NOERROR && cc < 0x0E))
0427                 break;
0428             if (urb->transfer_buffer_length != urb->actual_length) {
0429                 if (short_not_ok)
0430                     break;
0431             } else {
0432                 if (urb->transfer_flags & URB_ZERO_PACKET
0433                     && ep->nextpid == USB_PID_OUT
0434                     && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
0435                     DBG("Zero packet requested\n");
0436                     break;
0437                 }
0438             }
0439             /* All data for this URB is transferred, let's finish */
0440             if (usb_pipecontrol(urb->pipe))
0441                 ep->nextpid = USB_PID_ACK;
0442             else
0443                 status = 0;
0444             break;
0445         case USB_PID_SETUP:
0446             if (PTD_GET_ACTIVE(ptd)
0447                 || (cc != TD_CC_NOERROR && cc < 0x0E))
0448                 break;
0449             if (urb->transfer_buffer_length == urb->actual_length)
0450                 ep->nextpid = USB_PID_ACK;
0451             else if (usb_pipeout(urb->pipe)) {
0452                 usb_settoggle(udev, 0, 1, 1);
0453                 ep->nextpid = USB_PID_OUT;
0454             } else {
0455                 usb_settoggle(udev, 0, 0, 1);
0456                 ep->nextpid = USB_PID_IN;
0457             }
0458             break;
0459         case USB_PID_ACK:
0460             if (PTD_GET_ACTIVE(ptd)
0461                 || (cc != TD_CC_NOERROR && cc < 0x0E))
0462                 break;
0463             status = 0;
0464             ep->nextpid = 0;
0465             break;
0466         default:
0467             BUG();
0468         }
0469 
0470  done:
0471         if (status != -EINPROGRESS || urb->unlinked)
0472             finish_request(isp116x, ep, urb, status);
0473     }
0474 }
0475 
0476 /*
0477   Scan transfer lists, schedule transfers, send data off
0478   to chip.
0479  */
0480 static void start_atl_transfers(struct isp116x *isp116x)
0481 {
0482     struct isp116x_ep *last_ep = NULL, *ep;
0483     struct urb *urb;
0484     u16 load = 0;
0485     int len, index, speed, byte_time;
0486 
0487     if (atomic_read(&isp116x->atl_finishing))
0488         return;
0489 
0490     if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
0491         return;
0492 
0493     /* FIFO not empty? */
0494     if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
0495         return;
0496 
0497     isp116x->atl_active = NULL;
0498     isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
0499 
0500     /* Schedule int transfers */
0501     if (isp116x->periodic_count) {
0502         isp116x->fmindex = index =
0503             (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
0504         load = isp116x->load[index];
0505         if (load) {
0506             /* Bring all int transfers for this frame
0507                into the active queue */
0508             isp116x->atl_active = last_ep =
0509                 isp116x->periodic[index];
0510             while (last_ep->next)
0511                 last_ep = (last_ep->active = last_ep->next);
0512             last_ep->active = NULL;
0513         }
0514     }
0515 
0516     /* Schedule control/bulk transfers */
0517     list_for_each_entry(ep, &isp116x->async, schedule) {
0518         urb = container_of(ep->hep->urb_list.next,
0519                    struct urb, urb_list);
0520         speed = urb->dev->speed;
0521         byte_time = speed == USB_SPEED_LOW
0522             ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
0523 
0524         if (ep->nextpid == USB_PID_SETUP) {
0525             len = sizeof(struct usb_ctrlrequest);
0526         } else if (ep->nextpid == USB_PID_ACK) {
0527             len = 0;
0528         } else {
0529             /* Find current free length ... */
0530             len = (MAX_LOAD_LIMIT - load) / byte_time;
0531 
0532             /* ... then limit it to configured max size ... */
0533             len = min(len, speed == USB_SPEED_LOW ?
0534                   MAX_TRANSFER_SIZE_LOWSPEED :
0535                   MAX_TRANSFER_SIZE_FULLSPEED);
0536 
0537             /* ... and finally cut to the multiple of MaxPacketSize,
0538                or to the real length if there's enough room. */
0539             if (len <
0540                 (urb->transfer_buffer_length -
0541                  urb->actual_length)) {
0542                 len -= len % ep->maxpacket;
0543                 if (!len)
0544                     continue;
0545             } else
0546                 len = urb->transfer_buffer_length -
0547                     urb->actual_length;
0548             BUG_ON(len < 0);
0549         }
0550 
0551         load += len * byte_time;
0552         if (load > MAX_LOAD_LIMIT)
0553             break;
0554 
0555         ep->active = NULL;
0556         ep->length = len;
0557         if (last_ep)
0558             last_ep->active = ep;
0559         else
0560             isp116x->atl_active = ep;
0561         last_ep = ep;
0562     }
0563 
0564     /* Avoid starving of endpoints */
0565     if ((&isp116x->async)->next != (&isp116x->async)->prev)
0566         list_move(&isp116x->async, (&isp116x->async)->next);
0567 
0568     if (isp116x->atl_active) {
0569         preproc_atl_queue(isp116x);
0570         pack_fifo(isp116x);
0571     }
0572 }
0573 
0574 /*
0575   Finish the processed transfers
0576 */
0577 static void finish_atl_transfers(struct isp116x *isp116x)
0578 {
0579     if (!isp116x->atl_active)
0580         return;
0581     /* Fifo not ready? */
0582     if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
0583         return;
0584 
0585     atomic_inc(&isp116x->atl_finishing);
0586     unpack_fifo(isp116x);
0587     postproc_atl_queue(isp116x);
0588     atomic_dec(&isp116x->atl_finishing);
0589 }
0590 
0591 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
0592 {
0593     struct isp116x *isp116x = hcd_to_isp116x(hcd);
0594     u16 irqstat;
0595     irqreturn_t ret = IRQ_NONE;
0596 
0597     spin_lock(&isp116x->lock);
0598     isp116x_write_reg16(isp116x, HCuPINTENB, 0);
0599     irqstat = isp116x_read_reg16(isp116x, HCuPINT);
0600     isp116x_write_reg16(isp116x, HCuPINT, irqstat);
0601 
0602     if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
0603         ret = IRQ_HANDLED;
0604         finish_atl_transfers(isp116x);
0605     }
0606 
0607     if (irqstat & HCuPINT_OPR) {
0608         u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
0609         isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
0610         if (intstat & HCINT_UE) {
0611             ERR("Unrecoverable error, HC is dead!\n");
0612             /* IRQ's are off, we do no DMA,
0613                perfectly ready to die ... */
0614             hcd->state = HC_STATE_HALT;
0615             usb_hc_died(hcd);
0616             ret = IRQ_HANDLED;
0617             goto done;
0618         }
0619         if (intstat & HCINT_RHSC)
0620             /* When root hub or any of its ports is going
0621                to come out of suspend, it may take more
0622                than 10ms for status bits to stabilize. */
0623             mod_timer(&hcd->rh_timer, jiffies
0624                   + msecs_to_jiffies(20) + 1);
0625         if (intstat & HCINT_RD) {
0626             DBG("---- remote wakeup\n");
0627             usb_hcd_resume_root_hub(hcd);
0628         }
0629         irqstat &= ~HCuPINT_OPR;
0630         ret = IRQ_HANDLED;
0631     }
0632 
0633     if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
0634         start_atl_transfers(isp116x);
0635     }
0636 
0637     isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
0638       done:
0639     spin_unlock(&isp116x->lock);
0640     return ret;
0641 }
0642 
0643 /*-----------------------------------------------------------------*/
0644 
0645 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
0646  * this driver doesn't promise that much since it's got to handle an
0647  * IRQ per packet; irq handling latencies also use up that time.
0648  */
0649 
0650 /* out of 1000 us */
0651 #define MAX_PERIODIC_LOAD   600
0652 static int balance(struct isp116x *isp116x, u16 period, u16 load)
0653 {
0654     int i, branch = -ENOSPC;
0655 
0656     /* search for the least loaded schedule branch of that period
0657        which has enough bandwidth left unreserved. */
0658     for (i = 0; i < period; i++) {
0659         if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
0660             int j;
0661 
0662             for (j = i; j < PERIODIC_SIZE; j += period) {
0663                 if ((isp116x->load[j] + load)
0664                     > MAX_PERIODIC_LOAD)
0665                     break;
0666             }
0667             if (j < PERIODIC_SIZE)
0668                 continue;
0669             branch = i;
0670         }
0671     }
0672     return branch;
0673 }
0674 
0675 /* NB! ALL the code above this point runs with isp116x->lock
0676    held, irqs off
0677 */
0678 
0679 /*-----------------------------------------------------------------*/
0680 
0681 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
0682                    struct urb *urb,
0683                    gfp_t mem_flags)
0684 {
0685     struct isp116x *isp116x = hcd_to_isp116x(hcd);
0686     struct usb_device *udev = urb->dev;
0687     unsigned int pipe = urb->pipe;
0688     int is_out = !usb_pipein(pipe);
0689     int type = usb_pipetype(pipe);
0690     int epnum = usb_pipeendpoint(pipe);
0691     struct usb_host_endpoint *hep = urb->ep;
0692     struct isp116x_ep *ep = NULL;
0693     unsigned long flags;
0694     int i;
0695     int ret = 0;
0696 
0697     urb_dbg(urb, "Enqueue");
0698 
0699     if (type == PIPE_ISOCHRONOUS) {
0700         ERR("Isochronous transfers not supported\n");
0701         urb_dbg(urb, "Refused to enqueue");
0702         return -ENXIO;
0703     }
0704     /* avoid all allocations within spinlocks: request or endpoint */
0705     if (!hep->hcpriv) {
0706         ep = kzalloc(sizeof *ep, mem_flags);
0707         if (!ep)
0708             return -ENOMEM;
0709     }
0710 
0711     spin_lock_irqsave(&isp116x->lock, flags);
0712     if (!HC_IS_RUNNING(hcd->state)) {
0713         kfree(ep);
0714         ret = -ENODEV;
0715         goto fail_not_linked;
0716     }
0717     ret = usb_hcd_link_urb_to_ep(hcd, urb);
0718     if (ret) {
0719         kfree(ep);
0720         goto fail_not_linked;
0721     }
0722 
0723     if (hep->hcpriv)
0724         ep = hep->hcpriv;
0725     else {
0726         INIT_LIST_HEAD(&ep->schedule);
0727         ep->udev = udev;
0728         ep->epnum = epnum;
0729         ep->maxpacket = usb_maxpacket(udev, urb->pipe);
0730         usb_settoggle(udev, epnum, is_out, 0);
0731 
0732         if (type == PIPE_CONTROL) {
0733             ep->nextpid = USB_PID_SETUP;
0734         } else if (is_out) {
0735             ep->nextpid = USB_PID_OUT;
0736         } else {
0737             ep->nextpid = USB_PID_IN;
0738         }
0739 
0740         if (urb->interval) {
0741             /*
0742                With INT URBs submitted, the driver works with SOF
0743                interrupt enabled and ATL interrupt disabled. After
0744                the PTDs are written to fifo ram, the chip starts
0745                fifo processing and usb transfers after the next
0746                SOF and continues until the transfers are finished
0747                (succeeded or failed) or the frame ends. Therefore,
0748                the transfers occur only in every second frame,
0749                while fifo reading/writing and data processing
0750                occur in every other second frame. */
0751             if (urb->interval < 2)
0752                 urb->interval = 2;
0753             if (urb->interval > 2 * PERIODIC_SIZE)
0754                 urb->interval = 2 * PERIODIC_SIZE;
0755             ep->period = urb->interval >> 1;
0756             ep->branch = PERIODIC_SIZE;
0757             ep->load = usb_calc_bus_time(udev->speed,
0758                              !is_out,
0759                              (type == PIPE_ISOCHRONOUS),
0760                              usb_maxpacket(udev, pipe)) /
0761                 1000;
0762         }
0763         hep->hcpriv = ep;
0764         ep->hep = hep;
0765     }
0766 
0767     /* maybe put endpoint into schedule */
0768     switch (type) {
0769     case PIPE_CONTROL:
0770     case PIPE_BULK:
0771         if (list_empty(&ep->schedule))
0772             list_add_tail(&ep->schedule, &isp116x->async);
0773         break;
0774     case PIPE_INTERRUPT:
0775         urb->interval = ep->period;
0776         ep->length = min_t(u32, ep->maxpacket,
0777                  urb->transfer_buffer_length);
0778 
0779         /* urb submitted for already existing endpoint */
0780         if (ep->branch < PERIODIC_SIZE)
0781             break;
0782 
0783         ep->branch = ret = balance(isp116x, ep->period, ep->load);
0784         if (ret < 0)
0785             goto fail;
0786         ret = 0;
0787 
0788         urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
0789             + ep->branch;
0790 
0791         /* sort each schedule branch by period (slow before fast)
0792            to share the faster parts of the tree without needing
0793            dummy/placeholder nodes */
0794         DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
0795         for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
0796             struct isp116x_ep **prev = &isp116x->periodic[i];
0797             struct isp116x_ep *here = *prev;
0798 
0799             while (here && ep != here) {
0800                 if (ep->period > here->period)
0801                     break;
0802                 prev = &here->next;
0803                 here = *prev;
0804             }
0805             if (ep != here) {
0806                 ep->next = here;
0807                 *prev = ep;
0808             }
0809             isp116x->load[i] += ep->load;
0810         }
0811         hcd->self.bandwidth_allocated += ep->load / ep->period;
0812 
0813         /* switch over to SOFint */
0814         if (!isp116x->periodic_count++) {
0815             isp116x->irqenb &= ~HCuPINT_ATL;
0816             isp116x->irqenb |= HCuPINT_SOF;
0817             isp116x_write_reg16(isp116x, HCuPINTENB,
0818                         isp116x->irqenb);
0819         }
0820     }
0821 
0822     urb->hcpriv = hep;
0823     start_atl_transfers(isp116x);
0824 
0825       fail:
0826     if (ret)
0827         usb_hcd_unlink_urb_from_ep(hcd, urb);
0828       fail_not_linked:
0829     spin_unlock_irqrestore(&isp116x->lock, flags);
0830     return ret;
0831 }
0832 
0833 /*
0834    Dequeue URBs.
0835 */
0836 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
0837         int status)
0838 {
0839     struct isp116x *isp116x = hcd_to_isp116x(hcd);
0840     struct usb_host_endpoint *hep;
0841     struct isp116x_ep *ep, *ep_act;
0842     unsigned long flags;
0843     int rc;
0844 
0845     spin_lock_irqsave(&isp116x->lock, flags);
0846     rc = usb_hcd_check_unlink_urb(hcd, urb, status);
0847     if (rc)
0848         goto done;
0849 
0850     hep = urb->hcpriv;
0851     ep = hep->hcpriv;
0852     WARN_ON(hep != ep->hep);
0853 
0854     /* In front of queue? */
0855     if (ep->hep->urb_list.next == &urb->urb_list)
0856         /* active? */
0857         for (ep_act = isp116x->atl_active; ep_act;
0858              ep_act = ep_act->active)
0859             if (ep_act == ep) {
0860                 VDBG("dequeue, urb %p active; wait for irq\n",
0861                      urb);
0862                 urb = NULL;
0863                 break;
0864             }
0865 
0866     if (urb)
0867         finish_request(isp116x, ep, urb, status);
0868  done:
0869     spin_unlock_irqrestore(&isp116x->lock, flags);
0870     return rc;
0871 }
0872 
0873 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
0874                      struct usb_host_endpoint *hep)
0875 {
0876     int i;
0877     struct isp116x_ep *ep = hep->hcpriv;
0878 
0879     if (!ep)
0880         return;
0881 
0882     /* assume we'd just wait for the irq */
0883     for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
0884         msleep(3);
0885     if (!list_empty(&hep->urb_list))
0886         WARNING("ep %p not empty?\n", ep);
0887 
0888     kfree(ep);
0889     hep->hcpriv = NULL;
0890 }
0891 
0892 static int isp116x_get_frame(struct usb_hcd *hcd)
0893 {
0894     struct isp116x *isp116x = hcd_to_isp116x(hcd);
0895     u32 fmnum;
0896     unsigned long flags;
0897 
0898     spin_lock_irqsave(&isp116x->lock, flags);
0899     fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
0900     spin_unlock_irqrestore(&isp116x->lock, flags);
0901     return (int)fmnum;
0902 }
0903 
0904 /*
0905   Adapted from ohci-hub.c. Currently we don't support autosuspend.
0906 */
0907 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
0908 {
0909     struct isp116x *isp116x = hcd_to_isp116x(hcd);
0910     int ports, i, changed = 0;
0911     unsigned long flags;
0912 
0913     if (!HC_IS_RUNNING(hcd->state))
0914         return -ESHUTDOWN;
0915 
0916     /* Report no status change now, if we are scheduled to be
0917        called later */
0918     if (timer_pending(&hcd->rh_timer))
0919         return 0;
0920 
0921     ports = isp116x->rhdesca & RH_A_NDP;
0922     spin_lock_irqsave(&isp116x->lock, flags);
0923     isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
0924     if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
0925         buf[0] = changed = 1;
0926     else
0927         buf[0] = 0;
0928 
0929     for (i = 0; i < ports; i++) {
0930         u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
0931 
0932         if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
0933                   | RH_PS_OCIC | RH_PS_PRSC)) {
0934             changed = 1;
0935             buf[0] |= 1 << (i + 1);
0936         }
0937     }
0938     spin_unlock_irqrestore(&isp116x->lock, flags);
0939     return changed;
0940 }
0941 
0942 static void isp116x_hub_descriptor(struct isp116x *isp116x,
0943                    struct usb_hub_descriptor *desc)
0944 {
0945     u32 reg = isp116x->rhdesca;
0946 
0947     desc->bDescriptorType = USB_DT_HUB;
0948     desc->bDescLength = 9;
0949     desc->bHubContrCurrent = 0;
0950     desc->bNbrPorts = (u8) (reg & 0x3);
0951     /* Power switching, device type, overcurrent. */
0952     desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) &
0953                                (HUB_CHAR_LPSM |
0954                             HUB_CHAR_COMPOUND |
0955                             HUB_CHAR_OCPM)));
0956     desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
0957     /* ports removable, and legacy PortPwrCtrlMask */
0958     desc->u.hs.DeviceRemovable[0] = 0;
0959     desc->u.hs.DeviceRemovable[1] = ~0;
0960 }
0961 
0962 /* Perform reset of a given port.
0963    It would be great to just start the reset and let the
0964    USB core to clear the reset in due time. However,
0965    root hub ports should be reset for at least 50 ms, while
0966    our chip stays in reset for about 10 ms. I.e., we must
0967    repeatedly reset it ourself here.
0968 */
0969 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
0970 {
0971     u32 tmp;
0972     unsigned long flags, t;
0973 
0974     /* Root hub reset should be 50 ms, but some devices
0975        want it even longer. */
0976     t = jiffies + msecs_to_jiffies(100);
0977 
0978     while (time_before(jiffies, t)) {
0979         spin_lock_irqsave(&isp116x->lock, flags);
0980         /* spin until any current reset finishes */
0981         for (;;) {
0982             tmp = isp116x_read_reg32(isp116x, port ?
0983                          HCRHPORT2 : HCRHPORT1);
0984             if (!(tmp & RH_PS_PRS))
0985                 break;
0986             udelay(500);
0987         }
0988         /* Don't reset a disconnected port */
0989         if (!(tmp & RH_PS_CCS)) {
0990             spin_unlock_irqrestore(&isp116x->lock, flags);
0991             break;
0992         }
0993         /* Reset lasts 10ms (claims datasheet) */
0994         isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
0995                     HCRHPORT1, (RH_PS_PRS));
0996         spin_unlock_irqrestore(&isp116x->lock, flags);
0997         msleep(10);
0998     }
0999 }
1000 
1001 /* Adapted from ohci-hub.c */
1002 static int isp116x_hub_control(struct usb_hcd *hcd,
1003                    u16 typeReq,
1004                    u16 wValue, u16 wIndex, char *buf, u16 wLength)
1005 {
1006     struct isp116x *isp116x = hcd_to_isp116x(hcd);
1007     int ret = 0;
1008     unsigned long flags;
1009     int ports = isp116x->rhdesca & RH_A_NDP;
1010     u32 tmp = 0;
1011 
1012     switch (typeReq) {
1013     case ClearHubFeature:
1014         DBG("ClearHubFeature: ");
1015         switch (wValue) {
1016         case C_HUB_OVER_CURRENT:
1017             DBG("C_HUB_OVER_CURRENT\n");
1018             spin_lock_irqsave(&isp116x->lock, flags);
1019             isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1020             spin_unlock_irqrestore(&isp116x->lock, flags);
1021             fallthrough;
1022         case C_HUB_LOCAL_POWER:
1023             DBG("C_HUB_LOCAL_POWER\n");
1024             break;
1025         default:
1026             goto error;
1027         }
1028         break;
1029     case SetHubFeature:
1030         DBG("SetHubFeature: ");
1031         switch (wValue) {
1032         case C_HUB_OVER_CURRENT:
1033         case C_HUB_LOCAL_POWER:
1034             DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1035             break;
1036         default:
1037             goto error;
1038         }
1039         break;
1040     case GetHubDescriptor:
1041         DBG("GetHubDescriptor\n");
1042         isp116x_hub_descriptor(isp116x,
1043                        (struct usb_hub_descriptor *)buf);
1044         break;
1045     case GetHubStatus:
1046         DBG("GetHubStatus\n");
1047         *(__le32 *) buf = 0;
1048         break;
1049     case GetPortStatus:
1050         DBG("GetPortStatus\n");
1051         if (!wIndex || wIndex > ports)
1052             goto error;
1053         spin_lock_irqsave(&isp116x->lock, flags);
1054         tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1055         spin_unlock_irqrestore(&isp116x->lock, flags);
1056         *(__le32 *) buf = cpu_to_le32(tmp);
1057         DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1058         break;
1059     case ClearPortFeature:
1060         DBG("ClearPortFeature: ");
1061         if (!wIndex || wIndex > ports)
1062             goto error;
1063         wIndex--;
1064 
1065         switch (wValue) {
1066         case USB_PORT_FEAT_ENABLE:
1067             DBG("USB_PORT_FEAT_ENABLE\n");
1068             tmp = RH_PS_CCS;
1069             break;
1070         case USB_PORT_FEAT_C_ENABLE:
1071             DBG("USB_PORT_FEAT_C_ENABLE\n");
1072             tmp = RH_PS_PESC;
1073             break;
1074         case USB_PORT_FEAT_SUSPEND:
1075             DBG("USB_PORT_FEAT_SUSPEND\n");
1076             tmp = RH_PS_POCI;
1077             break;
1078         case USB_PORT_FEAT_C_SUSPEND:
1079             DBG("USB_PORT_FEAT_C_SUSPEND\n");
1080             tmp = RH_PS_PSSC;
1081             break;
1082         case USB_PORT_FEAT_POWER:
1083             DBG("USB_PORT_FEAT_POWER\n");
1084             tmp = RH_PS_LSDA;
1085             break;
1086         case USB_PORT_FEAT_C_CONNECTION:
1087             DBG("USB_PORT_FEAT_C_CONNECTION\n");
1088             tmp = RH_PS_CSC;
1089             break;
1090         case USB_PORT_FEAT_C_OVER_CURRENT:
1091             DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1092             tmp = RH_PS_OCIC;
1093             break;
1094         case USB_PORT_FEAT_C_RESET:
1095             DBG("USB_PORT_FEAT_C_RESET\n");
1096             tmp = RH_PS_PRSC;
1097             break;
1098         default:
1099             goto error;
1100         }
1101         spin_lock_irqsave(&isp116x->lock, flags);
1102         isp116x_write_reg32(isp116x, wIndex
1103                     ? HCRHPORT2 : HCRHPORT1, tmp);
1104         spin_unlock_irqrestore(&isp116x->lock, flags);
1105         break;
1106     case SetPortFeature:
1107         DBG("SetPortFeature: ");
1108         if (!wIndex || wIndex > ports)
1109             goto error;
1110         wIndex--;
1111         switch (wValue) {
1112         case USB_PORT_FEAT_SUSPEND:
1113             DBG("USB_PORT_FEAT_SUSPEND\n");
1114             spin_lock_irqsave(&isp116x->lock, flags);
1115             isp116x_write_reg32(isp116x, wIndex
1116                         ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1117             spin_unlock_irqrestore(&isp116x->lock, flags);
1118             break;
1119         case USB_PORT_FEAT_POWER:
1120             DBG("USB_PORT_FEAT_POWER\n");
1121             spin_lock_irqsave(&isp116x->lock, flags);
1122             isp116x_write_reg32(isp116x, wIndex
1123                         ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1124             spin_unlock_irqrestore(&isp116x->lock, flags);
1125             break;
1126         case USB_PORT_FEAT_RESET:
1127             DBG("USB_PORT_FEAT_RESET\n");
1128             root_port_reset(isp116x, wIndex);
1129             break;
1130         default:
1131             goto error;
1132         }
1133         break;
1134 
1135     default:
1136           error:
1137         /* "protocol stall" on error */
1138         DBG("PROTOCOL STALL\n");
1139         ret = -EPIPE;
1140     }
1141     return ret;
1142 }
1143 
1144 /*-----------------------------------------------------------------*/
1145 
1146 #ifdef CONFIG_DEBUG_FS
1147 
1148 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1149 {
1150     seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1151            mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1152            mask & HCuPINT_SUSP ? " susp" : "",
1153            mask & HCuPINT_OPR ? " opr" : "",
1154            mask & HCuPINT_AIIEOT ? " eot" : "",
1155            mask & HCuPINT_ATL ? " atl" : "",
1156            mask & HCuPINT_SOF ? " sof" : "");
1157 }
1158 
1159 static void dump_int(struct seq_file *s, char *label, u32 mask)
1160 {
1161     seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1162            mask & HCINT_MIE ? " MIE" : "",
1163            mask & HCINT_RHSC ? " rhsc" : "",
1164            mask & HCINT_FNO ? " fno" : "",
1165            mask & HCINT_UE ? " ue" : "",
1166            mask & HCINT_RD ? " rd" : "",
1167            mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1168 }
1169 
1170 static int isp116x_debug_show(struct seq_file *s, void *unused)
1171 {
1172     struct isp116x *isp116x = s->private;
1173 
1174     seq_printf(s, "%s\n%s version %s\n",
1175            isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1176            DRIVER_VERSION);
1177 
1178     if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1179         seq_printf(s, "HCD is suspended\n");
1180         return 0;
1181     }
1182     if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1183         seq_printf(s, "HCD not running\n");
1184         return 0;
1185     }
1186 
1187     spin_lock_irq(&isp116x->lock);
1188     dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1189     dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1190     dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1191     dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1192     isp116x_show_regs_seq(isp116x, s);
1193     spin_unlock_irq(&isp116x->lock);
1194     seq_printf(s, "\n");
1195 
1196     return 0;
1197 }
1198 DEFINE_SHOW_ATTRIBUTE(isp116x_debug);
1199 
1200 static void create_debug_file(struct isp116x *isp116x)
1201 {
1202     debugfs_create_file(hcd_name, S_IRUGO, usb_debug_root, isp116x,
1203                 &isp116x_debug_fops);
1204 }
1205 
1206 static void remove_debug_file(struct isp116x *isp116x)
1207 {
1208     debugfs_remove(debugfs_lookup(hcd_name, usb_debug_root));
1209 }
1210 
1211 #else
1212 
1213 static inline void create_debug_file(struct isp116x *isp116x) { }
1214 static inline void remove_debug_file(struct isp116x *isp116x) { }
1215 
1216 #endif              /* CONFIG_DEBUG_FS */
1217 
1218 /*-----------------------------------------------------------------*/
1219 
1220 /*
1221   Software reset - can be called from any contect.
1222 */
1223 static int isp116x_sw_reset(struct isp116x *isp116x)
1224 {
1225     int retries = 15;
1226     unsigned long flags;
1227     int ret = 0;
1228 
1229     spin_lock_irqsave(&isp116x->lock, flags);
1230     isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1231     isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1232     while (--retries) {
1233         /* It usually resets within 1 ms */
1234         mdelay(1);
1235         if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1236             break;
1237     }
1238     if (!retries) {
1239         ERR("Software reset timeout\n");
1240         ret = -ETIME;
1241     }
1242     spin_unlock_irqrestore(&isp116x->lock, flags);
1243     return ret;
1244 }
1245 
1246 static int isp116x_reset(struct usb_hcd *hcd)
1247 {
1248     struct isp116x *isp116x = hcd_to_isp116x(hcd);
1249     unsigned long t;
1250     u16 clkrdy = 0;
1251     int ret, timeout = 15 /* ms */ ;
1252 
1253     ret = isp116x_sw_reset(isp116x);
1254     if (ret)
1255         return ret;
1256 
1257     t = jiffies + msecs_to_jiffies(timeout);
1258     while (time_before_eq(jiffies, t)) {
1259         msleep(4);
1260         spin_lock_irq(&isp116x->lock);
1261         clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1262         spin_unlock_irq(&isp116x->lock);
1263         if (clkrdy)
1264             break;
1265     }
1266     if (!clkrdy) {
1267         ERR("Clock not ready after %dms\n", timeout);
1268         /* After sw_reset the clock won't report to be ready, if
1269            H_WAKEUP pin is high. */
1270         ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1271         ret = -ENODEV;
1272     }
1273     return ret;
1274 }
1275 
1276 static void isp116x_stop(struct usb_hcd *hcd)
1277 {
1278     struct isp116x *isp116x = hcd_to_isp116x(hcd);
1279     unsigned long flags;
1280     u32 val;
1281 
1282     spin_lock_irqsave(&isp116x->lock, flags);
1283     isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1284 
1285     /* Switch off ports' power, some devices don't come up
1286        after next 'insmod' without this */
1287     val = isp116x_read_reg32(isp116x, HCRHDESCA);
1288     val &= ~(RH_A_NPS | RH_A_PSM);
1289     isp116x_write_reg32(isp116x, HCRHDESCA, val);
1290     isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1291     spin_unlock_irqrestore(&isp116x->lock, flags);
1292 
1293     isp116x_sw_reset(isp116x);
1294 }
1295 
1296 /*
1297   Configure the chip. The chip must be successfully reset by now.
1298 */
1299 static int isp116x_start(struct usb_hcd *hcd)
1300 {
1301     struct isp116x *isp116x = hcd_to_isp116x(hcd);
1302     struct isp116x_platform_data *board = isp116x->board;
1303     u32 val;
1304     unsigned long flags;
1305 
1306     spin_lock_irqsave(&isp116x->lock, flags);
1307 
1308     /* clear interrupt status and disable all interrupt sources */
1309     isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1310     isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1311 
1312     val = isp116x_read_reg16(isp116x, HCCHIPID);
1313     if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1314         ERR("Invalid chip ID %04x\n", val);
1315         spin_unlock_irqrestore(&isp116x->lock, flags);
1316         return -ENODEV;
1317     }
1318 
1319     /* To be removed in future */
1320     hcd->uses_new_polling = 1;
1321 
1322     isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1323     isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1324 
1325     /* ----- HW conf */
1326     val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1327     if (board->sel15Kres)
1328         val |= HCHWCFG_15KRSEL;
1329     /* Remote wakeup won't work without working clock */
1330     if (board->remote_wakeup_enable)
1331         val |= HCHWCFG_CLKNOTSTOP;
1332     if (board->oc_enable)
1333         val |= HCHWCFG_ANALOG_OC;
1334     if (board->int_act_high)
1335         val |= HCHWCFG_INT_POL;
1336     if (board->int_edge_triggered)
1337         val |= HCHWCFG_INT_TRIGGER;
1338     isp116x_write_reg16(isp116x, HCHWCFG, val);
1339 
1340     /* ----- Root hub conf */
1341     val = (25 << 24) & RH_A_POTPGT;
1342     /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1343        be always set. Yet, instead, we request individual port
1344        power switching. */
1345     val |= RH_A_PSM;
1346     /* Report overcurrent per port */
1347     val |= RH_A_OCPM;
1348     isp116x_write_reg32(isp116x, HCRHDESCA, val);
1349     isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1350 
1351     val = RH_B_PPCM;
1352     isp116x_write_reg32(isp116x, HCRHDESCB, val);
1353     isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1354 
1355     val = 0;
1356     if (board->remote_wakeup_enable) {
1357         if (!device_can_wakeup(hcd->self.controller))
1358             device_init_wakeup(hcd->self.controller, 1);
1359         val |= RH_HS_DRWE;
1360     }
1361     isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1362     isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1363 
1364     isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1365 
1366     hcd->state = HC_STATE_RUNNING;
1367 
1368     /* Set up interrupts */
1369     isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1370     if (board->remote_wakeup_enable)
1371         isp116x->intenb |= HCINT_RD;
1372     isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;    /* | HCuPINT_SUSP; */
1373     isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1374     isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1375 
1376     /* Go operational */
1377     val = HCCONTROL_USB_OPER;
1378     if (board->remote_wakeup_enable)
1379         val |= HCCONTROL_RWE;
1380     isp116x_write_reg32(isp116x, HCCONTROL, val);
1381 
1382     /* Disable ports to avoid race in device enumeration */
1383     isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1384     isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1385 
1386     isp116x_show_regs_log(isp116x);
1387     spin_unlock_irqrestore(&isp116x->lock, flags);
1388     return 0;
1389 }
1390 
1391 #ifdef  CONFIG_PM
1392 
1393 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1394 {
1395     struct isp116x *isp116x = hcd_to_isp116x(hcd);
1396     unsigned long flags;
1397     u32 val;
1398     int ret = 0;
1399 
1400     spin_lock_irqsave(&isp116x->lock, flags);
1401     val = isp116x_read_reg32(isp116x, HCCONTROL);
1402 
1403     switch (val & HCCONTROL_HCFS) {
1404     case HCCONTROL_USB_OPER:
1405         spin_unlock_irqrestore(&isp116x->lock, flags);
1406         val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1407         val |= HCCONTROL_USB_SUSPEND;
1408         if (hcd->self.root_hub->do_remote_wakeup)
1409             val |= HCCONTROL_RWE;
1410         /* Wait for usb transfers to finish */
1411         msleep(2);
1412         spin_lock_irqsave(&isp116x->lock, flags);
1413         isp116x_write_reg32(isp116x, HCCONTROL, val);
1414         spin_unlock_irqrestore(&isp116x->lock, flags);
1415         /* Wait for devices to suspend */
1416         msleep(5);
1417         break;
1418     case HCCONTROL_USB_RESUME:
1419         isp116x_write_reg32(isp116x, HCCONTROL,
1420                     (val & ~HCCONTROL_HCFS) |
1421                     HCCONTROL_USB_RESET);
1422         fallthrough;
1423     case HCCONTROL_USB_RESET:
1424         ret = -EBUSY;
1425         fallthrough;
1426     default:        /* HCCONTROL_USB_SUSPEND */
1427         spin_unlock_irqrestore(&isp116x->lock, flags);
1428         break;
1429     }
1430 
1431     return ret;
1432 }
1433 
1434 static int isp116x_bus_resume(struct usb_hcd *hcd)
1435 {
1436     struct isp116x *isp116x = hcd_to_isp116x(hcd);
1437     u32 val;
1438 
1439     msleep(5);
1440     spin_lock_irq(&isp116x->lock);
1441 
1442     val = isp116x_read_reg32(isp116x, HCCONTROL);
1443     switch (val & HCCONTROL_HCFS) {
1444     case HCCONTROL_USB_SUSPEND:
1445         val &= ~HCCONTROL_HCFS;
1446         val |= HCCONTROL_USB_RESUME;
1447         isp116x_write_reg32(isp116x, HCCONTROL, val);
1448         break;
1449     case HCCONTROL_USB_RESUME:
1450         break;
1451     case HCCONTROL_USB_OPER:
1452         spin_unlock_irq(&isp116x->lock);
1453         return 0;
1454     default:
1455         /* HCCONTROL_USB_RESET: this may happen, when during
1456            suspension the HC lost power. Reinitialize completely */
1457         spin_unlock_irq(&isp116x->lock);
1458         DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1459         isp116x_reset(hcd);
1460         isp116x_start(hcd);
1461         isp116x_hub_control(hcd, SetPortFeature,
1462                     USB_PORT_FEAT_POWER, 1, NULL, 0);
1463         if ((isp116x->rhdesca & RH_A_NDP) == 2)
1464             isp116x_hub_control(hcd, SetPortFeature,
1465                         USB_PORT_FEAT_POWER, 2, NULL, 0);
1466         return 0;
1467     }
1468 
1469     val = isp116x->rhdesca & RH_A_NDP;
1470     while (val--) {
1471         u32 stat =
1472             isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1473         /* force global, not selective, resume */
1474         if (!(stat & RH_PS_PSS))
1475             continue;
1476         DBG("%s: Resuming port %d\n", __func__, val);
1477         isp116x_write_reg32(isp116x, RH_PS_POCI, val
1478                     ? HCRHPORT2 : HCRHPORT1);
1479     }
1480     spin_unlock_irq(&isp116x->lock);
1481 
1482     hcd->state = HC_STATE_RESUMING;
1483     msleep(USB_RESUME_TIMEOUT);
1484 
1485     /* Go operational */
1486     spin_lock_irq(&isp116x->lock);
1487     val = isp116x_read_reg32(isp116x, HCCONTROL);
1488     isp116x_write_reg32(isp116x, HCCONTROL,
1489                 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1490     spin_unlock_irq(&isp116x->lock);
1491     hcd->state = HC_STATE_RUNNING;
1492 
1493     return 0;
1494 }
1495 
1496 #else
1497 
1498 #define isp116x_bus_suspend NULL
1499 #define isp116x_bus_resume  NULL
1500 
1501 #endif
1502 
1503 static const struct hc_driver isp116x_hc_driver = {
1504     .description = hcd_name,
1505     .product_desc = "ISP116x Host Controller",
1506     .hcd_priv_size = sizeof(struct isp116x),
1507 
1508     .irq = isp116x_irq,
1509     .flags = HCD_USB11,
1510 
1511     .reset = isp116x_reset,
1512     .start = isp116x_start,
1513     .stop = isp116x_stop,
1514 
1515     .urb_enqueue = isp116x_urb_enqueue,
1516     .urb_dequeue = isp116x_urb_dequeue,
1517     .endpoint_disable = isp116x_endpoint_disable,
1518 
1519     .get_frame_number = isp116x_get_frame,
1520 
1521     .hub_status_data = isp116x_hub_status_data,
1522     .hub_control = isp116x_hub_control,
1523     .bus_suspend = isp116x_bus_suspend,
1524     .bus_resume = isp116x_bus_resume,
1525 };
1526 
1527 /*----------------------------------------------------------------*/
1528 
1529 static int isp116x_remove(struct platform_device *pdev)
1530 {
1531     struct usb_hcd *hcd = platform_get_drvdata(pdev);
1532     struct isp116x *isp116x;
1533     struct resource *res;
1534 
1535     if (!hcd)
1536         return 0;
1537     isp116x = hcd_to_isp116x(hcd);
1538     remove_debug_file(isp116x);
1539     usb_remove_hcd(hcd);
1540 
1541     iounmap(isp116x->data_reg);
1542     res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1543     if (res)
1544         release_mem_region(res->start, 2);
1545     iounmap(isp116x->addr_reg);
1546     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1547     if (res)
1548         release_mem_region(res->start, 2);
1549 
1550     usb_put_hcd(hcd);
1551     return 0;
1552 }
1553 
1554 static int isp116x_probe(struct platform_device *pdev)
1555 {
1556     struct usb_hcd *hcd;
1557     struct isp116x *isp116x;
1558     struct resource *addr, *data, *ires;
1559     void __iomem *addr_reg;
1560     void __iomem *data_reg;
1561     int irq;
1562     int ret = 0;
1563     unsigned long irqflags;
1564 
1565     if (usb_disabled())
1566         return -ENODEV;
1567 
1568     if (pdev->num_resources < 3) {
1569         ret = -ENODEV;
1570         goto err1;
1571     }
1572 
1573     data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1574     addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1575     ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1576 
1577     if (!addr || !data || !ires) {
1578         ret = -ENODEV;
1579         goto err1;
1580     }
1581 
1582     irq = ires->start;
1583     irqflags = ires->flags & IRQF_TRIGGER_MASK;
1584 
1585     if (!request_mem_region(addr->start, 2, hcd_name)) {
1586         ret = -EBUSY;
1587         goto err1;
1588     }
1589     addr_reg = ioremap(addr->start, resource_size(addr));
1590     if (addr_reg == NULL) {
1591         ret = -ENOMEM;
1592         goto err2;
1593     }
1594     if (!request_mem_region(data->start, 2, hcd_name)) {
1595         ret = -EBUSY;
1596         goto err3;
1597     }
1598     data_reg = ioremap(data->start, resource_size(data));
1599     if (data_reg == NULL) {
1600         ret = -ENOMEM;
1601         goto err4;
1602     }
1603 
1604     /* allocate and initialize hcd */
1605     hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1606     if (!hcd) {
1607         ret = -ENOMEM;
1608         goto err5;
1609     }
1610     /* this rsrc_start is bogus */
1611     hcd->rsrc_start = addr->start;
1612     isp116x = hcd_to_isp116x(hcd);
1613     isp116x->data_reg = data_reg;
1614     isp116x->addr_reg = addr_reg;
1615     spin_lock_init(&isp116x->lock);
1616     INIT_LIST_HEAD(&isp116x->async);
1617     isp116x->board = dev_get_platdata(&pdev->dev);
1618 
1619     if (!isp116x->board) {
1620         ERR("Platform data structure not initialized\n");
1621         ret = -ENODEV;
1622         goto err6;
1623     }
1624     if (isp116x_check_platform_delay(isp116x)) {
1625         ERR("USE_PLATFORM_DELAY defined, but delay function not "
1626             "implemented.\n");
1627         ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1628         ret = -ENODEV;
1629         goto err6;
1630     }
1631 
1632     ret = usb_add_hcd(hcd, irq, irqflags);
1633     if (ret)
1634         goto err6;
1635 
1636     device_wakeup_enable(hcd->self.controller);
1637 
1638     create_debug_file(isp116x);
1639 
1640     return 0;
1641 
1642       err6:
1643     usb_put_hcd(hcd);
1644       err5:
1645     iounmap(data_reg);
1646       err4:
1647     release_mem_region(data->start, 2);
1648       err3:
1649     iounmap(addr_reg);
1650       err2:
1651     release_mem_region(addr->start, 2);
1652       err1:
1653     ERR("init error, %d\n", ret);
1654     return ret;
1655 }
1656 
1657 #ifdef  CONFIG_PM
1658 /*
1659   Suspend of platform device
1660 */
1661 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1662 {
1663     VDBG("%s: state %x\n", __func__, state.event);
1664     return 0;
1665 }
1666 
1667 /*
1668   Resume platform device
1669 */
1670 static int isp116x_resume(struct platform_device *dev)
1671 {
1672     VDBG("%s\n", __func__);
1673     return 0;
1674 }
1675 
1676 #else
1677 
1678 #define isp116x_suspend    NULL
1679 #define isp116x_resume     NULL
1680 
1681 #endif
1682 
1683 /* work with hotplug and coldplug */
1684 MODULE_ALIAS("platform:isp116x-hcd");
1685 
1686 static struct platform_driver isp116x_driver = {
1687     .probe = isp116x_probe,
1688     .remove = isp116x_remove,
1689     .suspend = isp116x_suspend,
1690     .resume = isp116x_resume,
1691     .driver = {
1692         .name = hcd_name,
1693     },
1694 };
1695 
1696 module_platform_driver(isp116x_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!