Merge branch 'timers-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / drivers / usb / host / isp1760-hcd.c
1 /*
2  * Driver for the NXP ISP1760 chip
3  *
4  * However, the code might contain some bugs. What doesn't work for sure is:
5  * - ISO
6  * - OTG
7  e The interrupt line is configured as active low, level.
8  *
9  * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de>
10  *
11  */
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/list.h>
16 #include <linux/usb.h>
17 #include <linux/debugfs.h>
18 #include <linux/uaccess.h>
19 #include <linux/io.h>
20 #include <asm/unaligned.h>
21
22 #include "../core/hcd.h"
23 #include "isp1760-hcd.h"
24
25 static struct kmem_cache *qtd_cachep;
26 static struct kmem_cache *qh_cachep;
27
28 struct isp1760_hcd {
29         u32 hcs_params;
30         spinlock_t              lock;
31         struct inter_packet_info atl_ints[32];
32         struct inter_packet_info int_ints[32];
33         struct memory_chunk memory_pool[BLOCKS];
34
35         /* periodic schedule support */
36 #define DEFAULT_I_TDPS          1024
37         unsigned                periodic_size;
38         unsigned                i_thresh;
39         unsigned long           reset_done;
40         unsigned long           next_statechange;
41         unsigned int            devflags;
42 };
43
44 static inline struct isp1760_hcd *hcd_to_priv(struct usb_hcd *hcd)
45 {
46         return (struct isp1760_hcd *) (hcd->hcd_priv);
47 }
48 static inline struct usb_hcd *priv_to_hcd(struct isp1760_hcd *priv)
49 {
50         return container_of((void *) priv, struct usb_hcd, hcd_priv);
51 }
52
53 /* Section 2.2 Host Controller Capability Registers */
54 #define HC_LENGTH(p)            (((p)>>00)&0x00ff)      /* bits 7:0 */
55 #define HC_VERSION(p)           (((p)>>16)&0xffff)      /* bits 31:16 */
56 #define HCS_INDICATOR(p)        ((p)&(1 << 16)) /* true: has port indicators */
57 #define HCS_PPC(p)              ((p)&(1 << 4))  /* true: port power control */
58 #define HCS_N_PORTS(p)          (((p)>>0)&0xf)  /* bits 3:0, ports on HC */
59 #define HCC_ISOC_CACHE(p)       ((p)&(1 << 7))  /* true: can cache isoc frame */
60 #define HCC_ISOC_THRES(p)       (((p)>>4)&0x7)  /* bits 6:4, uframes cached */
61
62 /* Section 2.3 Host Controller Operational Registers */
63 #define CMD_LRESET      (1<<7)          /* partial reset (no ports, etc) */
64 #define CMD_RESET       (1<<1)          /* reset HC not bus */
65 #define CMD_RUN         (1<<0)          /* start/stop HC */
66 #define STS_PCD         (1<<2)          /* port change detect */
67 #define FLAG_CF         (1<<0)          /* true: we'll support "high speed" */
68
69 #define PORT_OWNER      (1<<13)         /* true: companion hc owns this port */
70 #define PORT_POWER      (1<<12)         /* true: has power (see PPC) */
71 #define PORT_USB11(x) (((x) & (3 << 10)) == (1 << 10))  /* USB 1.1 device */
72 #define PORT_RESET      (1<<8)          /* reset port */
73 #define PORT_SUSPEND    (1<<7)          /* suspend port */
74 #define PORT_RESUME     (1<<6)          /* resume it */
75 #define PORT_PE         (1<<2)          /* port enable */
76 #define PORT_CSC        (1<<1)          /* connect status change */
77 #define PORT_CONNECT    (1<<0)          /* device connected */
78 #define PORT_RWC_BITS   (PORT_CSC)
79
80 struct isp1760_qtd {
81         struct isp1760_qtd *hw_next;
82         u8 packet_type;
83         u8 toggle;
84
85         void *data_buffer;
86         /* the rest is HCD-private */
87         struct list_head qtd_list;
88         struct urb *urb;
89         size_t length;
90
91         /* isp special*/
92         u32 status;
93 #define URB_COMPLETE_NOTIFY     (1 << 0)
94 #define URB_ENQUEUED            (1 << 1)
95 #define URB_TYPE_ATL            (1 << 2)
96 #define URB_TYPE_INT            (1 << 3)
97 };
98
99 struct isp1760_qh {
100         /* first part defined by EHCI spec */
101         struct list_head qtd_list;
102         struct isp1760_hcd *priv;
103
104         /* periodic schedule info */
105         unsigned short period;          /* polling interval */
106         struct usb_device *dev;
107
108         u32 toggle;
109         u32 ping;
110 };
111
112 #define ehci_port_speed(priv, portsc) (1 << USB_PORT_FEAT_HIGHSPEED)
113
114 static unsigned int isp1760_readl(__u32 __iomem *regs)
115 {
116         return readl(regs);
117 }
118
119 static void isp1760_writel(const unsigned int val, __u32 __iomem *regs)
120 {
121         writel(val, regs);
122 }
123
124 /*
125  * The next two copy via MMIO data to/from the device. memcpy_{to|from}io()
126  * doesn't quite work because some people have to enforce 32-bit access
127  */
128 static void priv_read_copy(struct isp1760_hcd *priv, u32 *src,
129                 __u32 __iomem *dst, u32 offset, u32 len)
130 {
131         struct usb_hcd *hcd = priv_to_hcd(priv);
132         u32 val;
133         u8 *buff8;
134
135         if (!src) {
136                 printk(KERN_ERR "ERROR: buffer: %p len: %d\n", src, len);
137                 return;
138         }
139         isp1760_writel(offset,  hcd->regs + HC_MEMORY_REG);
140         /* XXX
141          * 90nsec delay, the spec says something how this could be avoided.
142          */
143         mdelay(1);
144
145         while (len >= 4) {
146                 *src = __raw_readl(dst);
147                 len -= 4;
148                 src++;
149                 dst++;
150         }
151
152         if (!len)
153                 return;
154
155         /* in case we have 3, 2 or 1 by left. The dst buffer may not be fully
156          * allocated.
157          */
158         val = isp1760_readl(dst);
159
160         buff8 = (u8 *)src;
161         while (len) {
162
163                 *buff8 = val;
164                 val >>= 8;
165                 len--;
166                 buff8++;
167         }
168 }
169
170 static void priv_write_copy(const struct isp1760_hcd *priv, const u32 *src,
171                 __u32 __iomem *dst, u32 len)
172 {
173         while (len >= 4) {
174                 __raw_writel(*src, dst);
175                 len -= 4;
176                 src++;
177                 dst++;
178         }
179
180         if (!len)
181                 return;
182         /* in case we have 3, 2 or 1 by left. The buffer is allocated and the
183          * extra bytes should not be read by the HW
184          */
185
186         __raw_writel(*src, dst);
187 }
188
189 /* memory management of the 60kb on the chip from 0x1000 to 0xffff */
190 static void init_memory(struct isp1760_hcd *priv)
191 {
192         int i;
193         u32 payload;
194
195         payload = 0x1000;
196         for (i = 0; i < BLOCK_1_NUM; i++) {
197                 priv->memory_pool[i].start = payload;
198                 priv->memory_pool[i].size = BLOCK_1_SIZE;
199                 priv->memory_pool[i].free = 1;
200                 payload += priv->memory_pool[i].size;
201         }
202
203
204         for (i = BLOCK_1_NUM; i < BLOCK_1_NUM + BLOCK_2_NUM; i++) {
205                 priv->memory_pool[i].start = payload;
206                 priv->memory_pool[i].size = BLOCK_2_SIZE;
207                 priv->memory_pool[i].free = 1;
208                 payload += priv->memory_pool[i].size;
209         }
210
211
212         for (i = BLOCK_1_NUM + BLOCK_2_NUM; i < BLOCKS; i++) {
213                 priv->memory_pool[i].start = payload;
214                 priv->memory_pool[i].size = BLOCK_3_SIZE;
215                 priv->memory_pool[i].free = 1;
216                 payload += priv->memory_pool[i].size;
217         }
218
219         BUG_ON(payload - priv->memory_pool[i - 1].size > PAYLOAD_SIZE);
220 }
221
222 static u32 alloc_mem(struct isp1760_hcd *priv, u32 size)
223 {
224         int i;
225
226         if (!size)
227                 return ISP1760_NULL_POINTER;
228
229         for (i = 0; i < BLOCKS; i++) {
230                 if (priv->memory_pool[i].size >= size &&
231                                 priv->memory_pool[i].free) {
232
233                         priv->memory_pool[i].free = 0;
234                         return priv->memory_pool[i].start;
235                 }
236         }
237
238         printk(KERN_ERR "ISP1760 MEM: can not allocate %d bytes of memory\n",
239                         size);
240         printk(KERN_ERR "Current memory map:\n");
241         for (i = 0; i < BLOCKS; i++) {
242                 printk(KERN_ERR "Pool %2d size %4d status: %d\n",
243                                 i, priv->memory_pool[i].size,
244                                 priv->memory_pool[i].free);
245         }
246         /* XXX maybe -ENOMEM could be possible */
247         BUG();
248         return 0;
249 }
250
251 static void free_mem(struct isp1760_hcd *priv, u32 mem)
252 {
253         int i;
254
255         if (mem == ISP1760_NULL_POINTER)
256                 return;
257
258         for (i = 0; i < BLOCKS; i++) {
259                 if (priv->memory_pool[i].start == mem) {
260
261                         BUG_ON(priv->memory_pool[i].free);
262
263                         priv->memory_pool[i].free = 1;
264                         return ;
265                 }
266         }
267
268         printk(KERN_ERR "Trying to free not-here-allocated memory :%08x\n",
269                         mem);
270         BUG();
271 }
272
273 static void isp1760_init_regs(struct usb_hcd *hcd)
274 {
275         isp1760_writel(0, hcd->regs + HC_BUFFER_STATUS_REG);
276         isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
277                         HC_ATL_PTD_SKIPMAP_REG);
278         isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
279                         HC_INT_PTD_SKIPMAP_REG);
280         isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
281                         HC_ISO_PTD_SKIPMAP_REG);
282
283         isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
284                         HC_ATL_PTD_DONEMAP_REG);
285         isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
286                         HC_INT_PTD_DONEMAP_REG);
287         isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
288                         HC_ISO_PTD_DONEMAP_REG);
289 }
290
291 static int handshake(struct isp1760_hcd *priv, void __iomem *ptr,
292                       u32 mask, u32 done, int usec)
293 {
294         u32 result;
295
296         do {
297                 result = isp1760_readl(ptr);
298                 if (result == ~0)
299                         return -ENODEV;
300                 result &= mask;
301                 if (result == done)
302                         return 0;
303                 udelay(1);
304                 usec--;
305         } while (usec > 0);
306         return -ETIMEDOUT;
307 }
308
309 /* reset a non-running (STS_HALT == 1) controller */
310 static int ehci_reset(struct isp1760_hcd *priv)
311 {
312         int retval;
313         struct usb_hcd *hcd = priv_to_hcd(priv);
314         u32 command = isp1760_readl(hcd->regs + HC_USBCMD);
315
316         command |= CMD_RESET;
317         isp1760_writel(command, hcd->regs + HC_USBCMD);
318         hcd->state = HC_STATE_HALT;
319         priv->next_statechange = jiffies;
320         retval = handshake(priv, hcd->regs + HC_USBCMD,
321                             CMD_RESET, 0, 250 * 1000);
322         return retval;
323 }
324
325 static void qh_destroy(struct isp1760_qh *qh)
326 {
327         BUG_ON(!list_empty(&qh->qtd_list));
328         kmem_cache_free(qh_cachep, qh);
329 }
330
331 static struct isp1760_qh *isp1760_qh_alloc(struct isp1760_hcd *priv,
332                 gfp_t flags)
333 {
334         struct isp1760_qh *qh;
335
336         qh = kmem_cache_zalloc(qh_cachep, flags);
337         if (!qh)
338                 return qh;
339
340         INIT_LIST_HEAD(&qh->qtd_list);
341         qh->priv = priv;
342         return qh;
343 }
344
345 /* magic numbers that can affect system performance */
346 #define EHCI_TUNE_CERR          3       /* 0-3 qtd retries; 0 == don't stop */
347 #define EHCI_TUNE_RL_HS         4       /* nak throttle; see 4.9 */
348 #define EHCI_TUNE_RL_TT         0
349 #define EHCI_TUNE_MULT_HS       1       /* 1-3 transactions/uframe; 4.10.3 */
350 #define EHCI_TUNE_MULT_TT       1
351 #define EHCI_TUNE_FLS           2       /* (small) 256 frame schedule */
352
353 /* one-time init, only for memory state */
354 static int priv_init(struct usb_hcd *hcd)
355 {
356         struct isp1760_hcd              *priv = hcd_to_priv(hcd);
357         u32                     hcc_params;
358
359         spin_lock_init(&priv->lock);
360
361         /*
362          * hw default: 1K periodic list heads, one per frame.
363          * periodic_size can shrink by USBCMD update if hcc_params allows.
364          */
365         priv->periodic_size = DEFAULT_I_TDPS;
366
367         /* controllers may cache some of the periodic schedule ... */
368         hcc_params = isp1760_readl(hcd->regs + HC_HCCPARAMS);
369         /* full frame cache */
370         if (HCC_ISOC_CACHE(hcc_params))
371                 priv->i_thresh = 8;
372         else /* N microframes cached */
373                 priv->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
374
375         return 0;
376 }
377
378 static int isp1760_hc_setup(struct usb_hcd *hcd)
379 {
380         struct isp1760_hcd *priv = hcd_to_priv(hcd);
381         int result;
382         u32 scratch, hwmode;
383
384         /* Setup HW Mode Control: This assumes a level active-low interrupt */
385         hwmode = HW_DATA_BUS_32BIT;
386
387         if (priv->devflags & ISP1760_FLAG_BUS_WIDTH_16)
388                 hwmode &= ~HW_DATA_BUS_32BIT;
389         if (priv->devflags & ISP1760_FLAG_ANALOG_OC)
390                 hwmode |= HW_ANA_DIGI_OC;
391         if (priv->devflags & ISP1760_FLAG_DACK_POL_HIGH)
392                 hwmode |= HW_DACK_POL_HIGH;
393         if (priv->devflags & ISP1760_FLAG_DREQ_POL_HIGH)
394                 hwmode |= HW_DREQ_POL_HIGH;
395
396         /*
397          * We have to set this first in case we're in 16-bit mode.
398          * Write it twice to ensure correct upper bits if switching
399          * to 16-bit mode.
400          */
401         isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
402         isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
403
404         isp1760_writel(0xdeadbabe, hcd->regs + HC_SCRATCH_REG);
405         /* Change bus pattern */
406         scratch = isp1760_readl(hcd->regs + HC_CHIP_ID_REG);
407         scratch = isp1760_readl(hcd->regs + HC_SCRATCH_REG);
408         if (scratch != 0xdeadbabe) {
409                 printk(KERN_ERR "ISP1760: Scratch test failed.\n");
410                 return -ENODEV;
411         }
412
413         /* pre reset */
414         isp1760_init_regs(hcd);
415
416         /* reset */
417         isp1760_writel(SW_RESET_RESET_ALL, hcd->regs + HC_RESET_REG);
418         mdelay(100);
419
420         isp1760_writel(SW_RESET_RESET_HC, hcd->regs + HC_RESET_REG);
421         mdelay(100);
422
423         result = ehci_reset(priv);
424         if (result)
425                 return result;
426
427         /* Step 11 passed */
428
429         isp1760_info(priv, "bus width: %d, oc: %s\n",
430                            (priv->devflags & ISP1760_FLAG_BUS_WIDTH_16) ?
431                            16 : 32, (priv->devflags & ISP1760_FLAG_ANALOG_OC) ?
432                            "analog" : "digital");
433
434         /* ATL reset */
435         isp1760_writel(hwmode | ALL_ATX_RESET, hcd->regs + HC_HW_MODE_CTRL);
436         mdelay(10);
437         isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
438
439         isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_REG);
440         isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_ENABLE);
441
442         /*
443          * PORT 1 Control register of the ISP1760 is the OTG control
444          * register on ISP1761.
445          */
446         if (!(priv->devflags & ISP1760_FLAG_ISP1761) &&
447             !(priv->devflags & ISP1760_FLAG_PORT1_DIS)) {
448                 isp1760_writel(PORT1_POWER | PORT1_INIT2,
449                                hcd->regs + HC_PORT1_CTRL);
450                 mdelay(10);
451         }
452
453         priv->hcs_params = isp1760_readl(hcd->regs + HC_HCSPARAMS);
454
455         return priv_init(hcd);
456 }
457
458 static void isp1760_init_maps(struct usb_hcd *hcd)
459 {
460         /*set last maps, for iso its only 1, else 32 tds bitmap*/
461         isp1760_writel(0x80000000, hcd->regs + HC_ATL_PTD_LASTPTD_REG);
462         isp1760_writel(0x80000000, hcd->regs + HC_INT_PTD_LASTPTD_REG);
463         isp1760_writel(0x00000001, hcd->regs + HC_ISO_PTD_LASTPTD_REG);
464 }
465
466 static void isp1760_enable_interrupts(struct usb_hcd *hcd)
467 {
468         isp1760_writel(0, hcd->regs + HC_ATL_IRQ_MASK_AND_REG);
469         isp1760_writel(0, hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
470         isp1760_writel(0, hcd->regs + HC_INT_IRQ_MASK_AND_REG);
471         isp1760_writel(0, hcd->regs + HC_INT_IRQ_MASK_OR_REG);
472         isp1760_writel(0, hcd->regs + HC_ISO_IRQ_MASK_AND_REG);
473         isp1760_writel(0xffffffff, hcd->regs + HC_ISO_IRQ_MASK_OR_REG);
474         /* step 23 passed */
475 }
476
477 static int isp1760_run(struct usb_hcd *hcd)
478 {
479         struct isp1760_hcd *priv = hcd_to_priv(hcd);
480         int retval;
481         u32 temp;
482         u32 command;
483         u32 chipid;
484
485         hcd->uses_new_polling = 1;
486         hcd->poll_rh = 0;
487
488         hcd->state = HC_STATE_RUNNING;
489         isp1760_enable_interrupts(hcd);
490         temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
491         isp1760_writel(temp | HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
492
493         command = isp1760_readl(hcd->regs + HC_USBCMD);
494         command &= ~(CMD_LRESET|CMD_RESET);
495         command |= CMD_RUN;
496         isp1760_writel(command, hcd->regs + HC_USBCMD);
497
498         retval = handshake(priv, hcd->regs + HC_USBCMD, CMD_RUN, CMD_RUN,
499                         250 * 1000);
500         if (retval)
501                 return retval;
502
503         /*
504          * XXX
505          * Spec says to write FLAG_CF as last config action, priv code grabs
506          * the semaphore while doing so.
507          */
508         down_write(&ehci_cf_port_reset_rwsem);
509         isp1760_writel(FLAG_CF, hcd->regs + HC_CONFIGFLAG);
510
511         retval = handshake(priv, hcd->regs + HC_CONFIGFLAG, FLAG_CF, FLAG_CF,
512                         250 * 1000);
513         up_write(&ehci_cf_port_reset_rwsem);
514         if (retval)
515                 return retval;
516
517         chipid = isp1760_readl(hcd->regs + HC_CHIP_ID_REG);
518         isp1760_info(priv, "USB ISP %04x HW rev. %d started\n", chipid & 0xffff,
519                         chipid >> 16);
520
521         /* PTD Register Init Part 2, Step 28 */
522         /* enable INTs */
523         isp1760_init_maps(hcd);
524
525         /* GRR this is run-once init(), being done every time the HC starts.
526          * So long as they're part of class devices, we can't do it init()
527          * since the class device isn't created that early.
528          */
529         return 0;
530 }
531
532 static u32 base_to_chip(u32 base)
533 {
534         return ((base - 0x400) >> 3);
535 }
536
537 static void transform_into_atl(struct isp1760_hcd *priv, struct isp1760_qh *qh,
538                         struct isp1760_qtd *qtd, struct urb *urb,
539                         u32 payload, struct ptd *ptd)
540 {
541         u32 dw0;
542         u32 dw1;
543         u32 dw2;
544         u32 dw3;
545         u32 maxpacket;
546         u32 multi;
547         u32 pid_code;
548         u32 rl = RL_COUNTER;
549         u32 nak = NAK_COUNTER;
550
551         /* according to 3.6.2, max packet len can not be > 0x400 */
552         maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
553         multi =  1 + ((maxpacket >> 11) & 0x3);
554         maxpacket &= 0x7ff;
555
556         /* DW0 */
557         dw0 = PTD_VALID;
558         dw0 |= PTD_LENGTH(qtd->length);
559         dw0 |= PTD_MAXPACKET(maxpacket);
560         dw0 |= PTD_ENDPOINT(usb_pipeendpoint(urb->pipe));
561         dw1 = usb_pipeendpoint(urb->pipe) >> 1;
562
563         /* DW1 */
564         dw1 |= PTD_DEVICE_ADDR(usb_pipedevice(urb->pipe));
565
566         pid_code = qtd->packet_type;
567         dw1 |= PTD_PID_TOKEN(pid_code);
568
569         if (usb_pipebulk(urb->pipe))
570                 dw1 |= PTD_TRANS_BULK;
571         else if  (usb_pipeint(urb->pipe))
572                 dw1 |= PTD_TRANS_INT;
573
574         if (urb->dev->speed != USB_SPEED_HIGH) {
575                 /* split transaction */
576
577                 dw1 |= PTD_TRANS_SPLIT;
578                 if (urb->dev->speed == USB_SPEED_LOW)
579                         dw1 |= PTD_SE_USB_LOSPEED;
580
581                 dw1 |= PTD_PORT_NUM(urb->dev->ttport);
582                 dw1 |= PTD_HUB_NUM(urb->dev->tt->hub->devnum);
583
584                 /* SE bit for Split INT transfers */
585                 if (usb_pipeint(urb->pipe) &&
586                                 (urb->dev->speed == USB_SPEED_LOW))
587                         dw1 |= 2 << 16;
588
589                 dw3 = 0;
590                 rl = 0;
591                 nak = 0;
592         } else {
593                 dw0 |= PTD_MULTI(multi);
594                 if (usb_pipecontrol(urb->pipe) || usb_pipebulk(urb->pipe))
595                         dw3 = qh->ping;
596                 else
597                         dw3 = 0;
598         }
599         /* DW2 */
600         dw2 = 0;
601         dw2 |= PTD_DATA_START_ADDR(base_to_chip(payload));
602         dw2 |= PTD_RL_CNT(rl);
603         dw3 |= PTD_NAC_CNT(nak);
604
605         /* DW3 */
606         if (usb_pipecontrol(urb->pipe))
607                 dw3 |= PTD_DATA_TOGGLE(qtd->toggle);
608         else
609                 dw3 |= qh->toggle;
610
611
612         dw3 |= PTD_ACTIVE;
613         /* Cerr */
614         dw3 |= PTD_CERR(ERR_COUNTER);
615
616         memset(ptd, 0, sizeof(*ptd));
617
618         ptd->dw0 = cpu_to_le32(dw0);
619         ptd->dw1 = cpu_to_le32(dw1);
620         ptd->dw2 = cpu_to_le32(dw2);
621         ptd->dw3 = cpu_to_le32(dw3);
622 }
623
624 static void transform_add_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
625                         struct isp1760_qtd *qtd, struct urb *urb,
626                         u32 payload, struct ptd *ptd)
627 {
628         u32 maxpacket;
629         u32 multi;
630         u32 numberofusofs;
631         u32 i;
632         u32 usofmask, usof;
633         u32 period;
634
635         maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
636         multi =  1 + ((maxpacket >> 11) & 0x3);
637         maxpacket &= 0x7ff;
638         /* length of the data per uframe */
639         maxpacket = multi * maxpacket;
640
641         numberofusofs = urb->transfer_buffer_length / maxpacket;
642         if (urb->transfer_buffer_length % maxpacket)
643                 numberofusofs += 1;
644
645         usofmask = 1;
646         usof = 0;
647         for (i = 0; i < numberofusofs; i++) {
648                 usof |= usofmask;
649                 usofmask <<= 1;
650         }
651
652         if (urb->dev->speed != USB_SPEED_HIGH) {
653                 /* split */
654                 ptd->dw5 = __constant_cpu_to_le32(0x1c);
655
656                 if (qh->period >= 32)
657                         period = qh->period / 2;
658                 else
659                         period = qh->period;
660
661         } else {
662
663                 if (qh->period >= 8)
664                         period = qh->period/8;
665                 else
666                         period = qh->period;
667
668                 if (period >= 32)
669                         period  = 16;
670
671                 if (qh->period >= 8) {
672                         /* millisecond period */
673                         period = (period << 3);
674                 } else {
675                         /* usof based tranmsfers */
676                         /* minimum 4 usofs */
677                         usof = 0x11;
678                 }
679         }
680
681         ptd->dw2 |= cpu_to_le32(period);
682         ptd->dw4 = cpu_to_le32(usof);
683 }
684
685 static void transform_into_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
686                         struct isp1760_qtd *qtd, struct urb *urb,
687                         u32 payload, struct ptd *ptd)
688 {
689         transform_into_atl(priv, qh, qtd, urb, payload, ptd);
690         transform_add_int(priv, qh, qtd, urb,  payload, ptd);
691 }
692
693 static int qtd_fill(struct isp1760_qtd *qtd, void *databuffer, size_t len,
694                 u32 token)
695 {
696         int count;
697
698         qtd->data_buffer = databuffer;
699         qtd->packet_type = GET_QTD_TOKEN_TYPE(token);
700         qtd->toggle = GET_DATA_TOGGLE(token);
701
702         if (len > HC_ATL_PL_SIZE)
703                 count = HC_ATL_PL_SIZE;
704         else
705                 count = len;
706
707         qtd->length = count;
708         return count;
709 }
710
711 static int check_error(struct ptd *ptd)
712 {
713         int error = 0;
714         u32 dw3;
715
716         dw3 = le32_to_cpu(ptd->dw3);
717         if (dw3 & DW3_HALT_BIT)
718                 error = -EPIPE;
719
720         if (dw3 & DW3_ERROR_BIT) {
721                 printk(KERN_ERR "error bit is set in DW3\n");
722                 error = -EPIPE;
723         }
724
725         if (dw3 & DW3_QTD_ACTIVE) {
726                 printk(KERN_ERR "transfer active bit is set DW3\n");
727                 printk(KERN_ERR "nak counter: %d, rl: %d\n", (dw3 >> 19) & 0xf,
728                                 (le32_to_cpu(ptd->dw2) >> 25) & 0xf);
729         }
730
731         return error;
732 }
733
734 static void check_int_err_status(u32 dw4)
735 {
736         u32 i;
737
738         dw4 >>= 8;
739
740         for (i = 0; i < 8; i++) {
741                 switch (dw4 & 0x7) {
742                 case INT_UNDERRUN:
743                         printk(KERN_ERR "ERROR: under run , %d\n", i);
744                         break;
745
746                 case INT_EXACT:
747                         printk(KERN_ERR "ERROR: transaction error, %d\n", i);
748                         break;
749
750                 case INT_BABBLE:
751                         printk(KERN_ERR "ERROR: babble error, %d\n", i);
752                         break;
753                 }
754                 dw4 >>= 3;
755         }
756 }
757
758 static void enqueue_one_qtd(struct isp1760_qtd *qtd, struct isp1760_hcd *priv,
759                 u32 payload)
760 {
761         u32 token;
762         struct usb_hcd *hcd = priv_to_hcd(priv);
763
764         token = qtd->packet_type;
765
766         if (qtd->length && (qtd->length <= HC_ATL_PL_SIZE)) {
767                 switch (token) {
768                 case IN_PID:
769                         break;
770                 case OUT_PID:
771                 case SETUP_PID:
772                         priv_write_copy(priv, qtd->data_buffer,
773                                         hcd->regs + payload,
774                                         qtd->length);
775                 }
776         }
777 }
778
779 static void enqueue_one_atl_qtd(u32 atl_regs, u32 payload,
780                 struct isp1760_hcd *priv, struct isp1760_qh *qh,
781                 struct urb *urb, u32 slot, struct isp1760_qtd *qtd)
782 {
783         struct ptd ptd;
784         struct usb_hcd *hcd = priv_to_hcd(priv);
785
786         transform_into_atl(priv, qh, qtd, urb, payload, &ptd);
787         priv_write_copy(priv, (u32 *)&ptd, hcd->regs + atl_regs, sizeof(ptd));
788         enqueue_one_qtd(qtd, priv, payload);
789
790         priv->atl_ints[slot].urb = urb;
791         priv->atl_ints[slot].qh = qh;
792         priv->atl_ints[slot].qtd = qtd;
793         priv->atl_ints[slot].data_buffer = qtd->data_buffer;
794         priv->atl_ints[slot].payload = payload;
795         qtd->status |= URB_ENQUEUED | URB_TYPE_ATL;
796         qtd->status |= slot << 16;
797 }
798
799 static void enqueue_one_int_qtd(u32 int_regs, u32 payload,
800                 struct isp1760_hcd *priv, struct isp1760_qh *qh,
801                 struct urb *urb, u32 slot,  struct isp1760_qtd *qtd)
802 {
803         struct ptd ptd;
804         struct usb_hcd *hcd = priv_to_hcd(priv);
805
806         transform_into_int(priv, qh, qtd, urb, payload, &ptd);
807         priv_write_copy(priv, (u32 *)&ptd, hcd->regs + int_regs, sizeof(ptd));
808         enqueue_one_qtd(qtd, priv, payload);
809
810         priv->int_ints[slot].urb = urb;
811         priv->int_ints[slot].qh = qh;
812         priv->int_ints[slot].qtd = qtd;
813         priv->int_ints[slot].data_buffer = qtd->data_buffer;
814         priv->int_ints[slot].payload = payload;
815         qtd->status |= URB_ENQUEUED | URB_TYPE_INT;
816         qtd->status |= slot << 16;
817 }
818
819 static void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
820                                   struct isp1760_qtd *qtd)
821 {
822         struct isp1760_hcd *priv = hcd_to_priv(hcd);
823         u32 skip_map, or_map;
824         u32 queue_entry;
825         u32 slot;
826         u32 atl_regs, payload;
827         u32 buffstatus;
828
829         skip_map = isp1760_readl(hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
830
831         BUG_ON(!skip_map);
832         slot = __ffs(skip_map);
833         queue_entry = 1 << slot;
834
835         atl_regs = ATL_REGS_OFFSET + slot * sizeof(struct ptd);
836
837         payload = alloc_mem(priv, qtd->length);
838
839         enqueue_one_atl_qtd(atl_regs, payload, priv, qh, qtd->urb, slot, qtd);
840
841         or_map = isp1760_readl(hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
842         or_map |= queue_entry;
843         isp1760_writel(or_map, hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
844
845         skip_map &= ~queue_entry;
846         isp1760_writel(skip_map, hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
847
848         buffstatus = isp1760_readl(hcd->regs + HC_BUFFER_STATUS_REG);
849         buffstatus |= ATL_BUFFER;
850         isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG);
851 }
852
853 static void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
854                                   struct isp1760_qtd *qtd)
855 {
856         struct isp1760_hcd *priv = hcd_to_priv(hcd);
857         u32 skip_map, or_map;
858         u32 queue_entry;
859         u32 slot;
860         u32 int_regs, payload;
861         u32 buffstatus;
862
863         skip_map = isp1760_readl(hcd->regs + HC_INT_PTD_SKIPMAP_REG);
864
865         BUG_ON(!skip_map);
866         slot = __ffs(skip_map);
867         queue_entry = 1 << slot;
868
869         int_regs = INT_REGS_OFFSET + slot * sizeof(struct ptd);
870
871         payload = alloc_mem(priv, qtd->length);
872
873         enqueue_one_int_qtd(int_regs, payload, priv, qh, qtd->urb, slot, qtd);
874
875         or_map = isp1760_readl(hcd->regs + HC_INT_IRQ_MASK_OR_REG);
876         or_map |= queue_entry;
877         isp1760_writel(or_map, hcd->regs + HC_INT_IRQ_MASK_OR_REG);
878
879         skip_map &= ~queue_entry;
880         isp1760_writel(skip_map, hcd->regs + HC_INT_PTD_SKIPMAP_REG);
881
882         buffstatus = isp1760_readl(hcd->regs + HC_BUFFER_STATUS_REG);
883         buffstatus |= INT_BUFFER;
884         isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG);
885 }
886
887 static void isp1760_urb_done(struct isp1760_hcd *priv, struct urb *urb, int status)
888 __releases(priv->lock)
889 __acquires(priv->lock)
890 {
891         if (!urb->unlinked) {
892                 if (status == -EINPROGRESS)
893                         status = 0;
894         }
895
896         /* complete() can reenter this HCD */
897         usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv), urb);
898         spin_unlock(&priv->lock);
899         usb_hcd_giveback_urb(priv_to_hcd(priv), urb, status);
900         spin_lock(&priv->lock);
901 }
902
903 static void isp1760_qtd_free(struct isp1760_qtd *qtd)
904 {
905         kmem_cache_free(qtd_cachep, qtd);
906 }
907
908 static struct isp1760_qtd *clean_this_qtd(struct isp1760_qtd *qtd)
909 {
910         struct isp1760_qtd *tmp_qtd;
911
912         tmp_qtd = qtd->hw_next;
913         list_del(&qtd->qtd_list);
914         isp1760_qtd_free(qtd);
915         return tmp_qtd;
916 }
917
918 /*
919  * Remove this QTD from the QH list and free its memory. If this QTD
920  * isn't the last one than remove also his successor(s).
921  * Returns the QTD which is part of an new URB and should be enqueued.
922  */
923 static struct isp1760_qtd *clean_up_qtdlist(struct isp1760_qtd *qtd)
924 {
925         struct isp1760_qtd *tmp_qtd;
926         int last_one;
927
928         do {
929                 tmp_qtd = qtd->hw_next;
930                 last_one = qtd->status & URB_COMPLETE_NOTIFY;
931                 list_del(&qtd->qtd_list);
932                 isp1760_qtd_free(qtd);
933                 qtd = tmp_qtd;
934         } while (!last_one && qtd);
935
936         return qtd;
937 }
938
939 static void do_atl_int(struct usb_hcd *usb_hcd)
940 {
941         struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
942         u32 done_map, skip_map;
943         struct ptd ptd;
944         struct urb *urb = NULL;
945         u32 atl_regs_base;
946         u32 atl_regs;
947         u32 queue_entry;
948         u32 payload;
949         u32 length;
950         u32 or_map;
951         u32 status = -EINVAL;
952         int error;
953         struct isp1760_qtd *qtd;
954         struct isp1760_qh *qh;
955         u32 rl;
956         u32 nakcount;
957
958         done_map = isp1760_readl(usb_hcd->regs +
959                         HC_ATL_PTD_DONEMAP_REG);
960         skip_map = isp1760_readl(usb_hcd->regs +
961                         HC_ATL_PTD_SKIPMAP_REG);
962
963         or_map = isp1760_readl(usb_hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
964         or_map &= ~done_map;
965         isp1760_writel(or_map, usb_hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
966
967         atl_regs_base = ATL_REGS_OFFSET;
968         while (done_map) {
969                 u32 dw1;
970                 u32 dw2;
971                 u32 dw3;
972
973                 status = 0;
974
975                 queue_entry = __ffs(done_map);
976                 done_map &= ~(1 << queue_entry);
977                 skip_map |= 1 << queue_entry;
978
979                 atl_regs = atl_regs_base + queue_entry * sizeof(struct ptd);
980
981                 urb = priv->atl_ints[queue_entry].urb;
982                 qtd = priv->atl_ints[queue_entry].qtd;
983                 qh = priv->atl_ints[queue_entry].qh;
984                 payload = priv->atl_ints[queue_entry].payload;
985
986                 if (!qh) {
987                         printk(KERN_ERR "qh is 0\n");
988                         continue;
989                 }
990                 priv_read_copy(priv, (u32 *)&ptd, usb_hcd->regs + atl_regs,
991                                 atl_regs, sizeof(ptd));
992
993                 dw1 = le32_to_cpu(ptd.dw1);
994                 dw2 = le32_to_cpu(ptd.dw2);
995                 dw3 = le32_to_cpu(ptd.dw3);
996                 rl = (dw2 >> 25) & 0x0f;
997                 nakcount = (dw3 >> 19) & 0xf;
998
999                 /* Transfer Error, *but* active and no HALT -> reload */
1000                 if ((dw3 & DW3_ERROR_BIT) && (dw3 & DW3_QTD_ACTIVE) &&
1001                                 !(dw3 & DW3_HALT_BIT)) {
1002
1003                         /* according to ppriv code, we have to
1004                          * reload this one if trasfered bytes != requested bytes
1005                          * else act like everything went smooth..
1006                          * XXX This just doesn't feel right and hasn't
1007                          * triggered so far.
1008                          */
1009
1010                         length = PTD_XFERRED_LENGTH(dw3);
1011                         printk(KERN_ERR "Should reload now.... transfered %d "
1012                                         "of %zu\n", length, qtd->length);
1013                         BUG();
1014                 }
1015
1016                 if (!nakcount && (dw3 & DW3_QTD_ACTIVE)) {
1017                         u32 buffstatus;
1018
1019                         /* XXX
1020                          * NAKs are handled in HW by the chip. Usually if the
1021                          * device is not able to send data fast enough.
1022                          * This did not trigger for a long time now.
1023                          */
1024                         printk(KERN_ERR "Reloading ptd %p/%p... qh %p readed: "
1025                                         "%d of %zu done: %08x cur: %08x\n", qtd,
1026                                         urb, qh, PTD_XFERRED_LENGTH(dw3),
1027                                         qtd->length, done_map,
1028                                         (1 << queue_entry));
1029
1030                         /* RL counter = ERR counter */
1031                         dw3 &= ~(0xf << 19);
1032                         dw3 |= rl << 19;
1033                         dw3 &= ~(3 << (55 - 32));
1034                         dw3 |= ERR_COUNTER << (55 - 32);
1035
1036                         /*
1037                          * It is not needed to write skip map back because it
1038                          * is unchanged. Just make sure that this entry is
1039                          * unskipped once it gets written to the HW.
1040                          */
1041                         skip_map &= ~(1 << queue_entry);
1042                         or_map = isp1760_readl(usb_hcd->regs +
1043                                         HC_ATL_IRQ_MASK_OR_REG);
1044                         or_map |= 1 << queue_entry;
1045                         isp1760_writel(or_map, usb_hcd->regs +
1046                                         HC_ATL_IRQ_MASK_OR_REG);
1047
1048                         ptd.dw3 = cpu_to_le32(dw3);
1049                         priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
1050                                         atl_regs, sizeof(ptd));
1051
1052                         ptd.dw0 |= __constant_cpu_to_le32(PTD_VALID);
1053                         priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
1054                                         atl_regs, sizeof(ptd));
1055
1056                         buffstatus = isp1760_readl(usb_hcd->regs +
1057                                         HC_BUFFER_STATUS_REG);
1058                         buffstatus |= ATL_BUFFER;
1059                         isp1760_writel(buffstatus, usb_hcd->regs +
1060                                         HC_BUFFER_STATUS_REG);
1061                         continue;
1062                 }
1063
1064                 error = check_error(&ptd);
1065                 if (error) {
1066                         status = error;
1067                         priv->atl_ints[queue_entry].qh->toggle = 0;
1068                         priv->atl_ints[queue_entry].qh->ping = 0;
1069                         urb->status = -EPIPE;
1070
1071 #if 0
1072                         printk(KERN_ERR "Error in %s().\n", __func__);
1073                         printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
1074                                         "dw3: %08x dw4: %08x dw5: %08x dw6: "
1075                                         "%08x dw7: %08x\n",
1076                                         ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
1077                                         ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
1078 #endif
1079                 } else {
1080                         if (usb_pipetype(urb->pipe) == PIPE_BULK) {
1081                                 priv->atl_ints[queue_entry].qh->toggle = dw3 &
1082                                         (1 << 25);
1083                                 priv->atl_ints[queue_entry].qh->ping = dw3 &
1084                                         (1 << 26);
1085                         }
1086                 }
1087
1088                 length = PTD_XFERRED_LENGTH(dw3);
1089                 if (length) {
1090                         switch (DW1_GET_PID(dw1)) {
1091                         case IN_PID:
1092                                 priv_read_copy(priv,
1093                                         priv->atl_ints[queue_entry].data_buffer,
1094                                         usb_hcd->regs + payload, payload,
1095                                         length);
1096
1097                         case OUT_PID:
1098
1099                                 urb->actual_length += length;
1100
1101                         case SETUP_PID:
1102                                 break;
1103                         }
1104                 }
1105
1106                 priv->atl_ints[queue_entry].data_buffer = NULL;
1107                 priv->atl_ints[queue_entry].urb = NULL;
1108                 priv->atl_ints[queue_entry].qtd = NULL;
1109                 priv->atl_ints[queue_entry].qh = NULL;
1110
1111                 free_mem(priv, payload);
1112
1113                 isp1760_writel(skip_map, usb_hcd->regs +
1114                                 HC_ATL_PTD_SKIPMAP_REG);
1115
1116                 if (urb->status == -EPIPE) {
1117                         /* HALT was received */
1118
1119                         qtd = clean_up_qtdlist(qtd);
1120                         isp1760_urb_done(priv, urb, urb->status);
1121
1122                 } else if (usb_pipebulk(urb->pipe) && (length < qtd->length)) {
1123                         /* short BULK received */
1124
1125                         printk(KERN_ERR "short bulk, %d instead %zu\n", length,
1126                                         qtd->length);
1127                         if (urb->transfer_flags & URB_SHORT_NOT_OK) {
1128                                 urb->status = -EREMOTEIO;
1129                                 printk(KERN_ERR "not okey\n");
1130                         }
1131
1132                         if (urb->status == -EINPROGRESS)
1133                                 urb->status = 0;
1134
1135                         qtd = clean_up_qtdlist(qtd);
1136
1137                         isp1760_urb_done(priv, urb, urb->status);
1138
1139                 } else if (qtd->status & URB_COMPLETE_NOTIFY) {
1140                         /* that was the last qtd of that URB */
1141
1142                         if (urb->status == -EINPROGRESS)
1143                                 urb->status = 0;
1144
1145                         qtd = clean_this_qtd(qtd);
1146                         isp1760_urb_done(priv, urb, urb->status);
1147
1148                 } else {
1149                         /* next QTD of this URB */
1150
1151                         qtd = clean_this_qtd(qtd);
1152                         BUG_ON(!qtd);
1153                 }
1154
1155                 if (qtd)
1156                         enqueue_an_ATL_packet(usb_hcd, qh, qtd);
1157
1158                 skip_map = isp1760_readl(usb_hcd->regs +
1159                                 HC_ATL_PTD_SKIPMAP_REG);
1160         }
1161 }
1162
1163 static void do_intl_int(struct usb_hcd *usb_hcd)
1164 {
1165         struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
1166         u32 done_map, skip_map;
1167         struct ptd ptd;
1168         struct urb *urb = NULL;
1169         u32 int_regs;
1170         u32 int_regs_base;
1171         u32 payload;
1172         u32 length;
1173         u32 or_map;
1174         int error;
1175         u32 queue_entry;
1176         struct isp1760_qtd *qtd;
1177         struct isp1760_qh *qh;
1178
1179         done_map = isp1760_readl(usb_hcd->regs +
1180                         HC_INT_PTD_DONEMAP_REG);
1181         skip_map = isp1760_readl(usb_hcd->regs +
1182                         HC_INT_PTD_SKIPMAP_REG);
1183
1184         or_map = isp1760_readl(usb_hcd->regs + HC_INT_IRQ_MASK_OR_REG);
1185         or_map &= ~done_map;
1186         isp1760_writel(or_map, usb_hcd->regs + HC_INT_IRQ_MASK_OR_REG);
1187
1188         int_regs_base = INT_REGS_OFFSET;
1189
1190         while (done_map) {
1191                 u32 dw1;
1192                 u32 dw3;
1193
1194                 queue_entry = __ffs(done_map);
1195                 done_map &= ~(1 << queue_entry);
1196                 skip_map |= 1 << queue_entry;
1197
1198                 int_regs = int_regs_base + queue_entry * sizeof(struct ptd);
1199                 urb = priv->int_ints[queue_entry].urb;
1200                 qtd = priv->int_ints[queue_entry].qtd;
1201                 qh = priv->int_ints[queue_entry].qh;
1202                 payload = priv->int_ints[queue_entry].payload;
1203
1204                 if (!qh) {
1205                         printk(KERN_ERR "(INT) qh is 0\n");
1206                         continue;
1207                 }
1208
1209                 priv_read_copy(priv, (u32 *)&ptd, usb_hcd->regs + int_regs,
1210                                 int_regs, sizeof(ptd));
1211                 dw1 = le32_to_cpu(ptd.dw1);
1212                 dw3 = le32_to_cpu(ptd.dw3);
1213                 check_int_err_status(le32_to_cpu(ptd.dw4));
1214
1215                 error = check_error(&ptd);
1216                 if (error) {
1217 #if 0
1218                         printk(KERN_ERR "Error in %s().\n", __func__);
1219                         printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
1220                                         "dw3: %08x dw4: %08x dw5: %08x dw6: "
1221                                         "%08x dw7: %08x\n",
1222                                         ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
1223                                         ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
1224 #endif
1225                         urb->status = -EPIPE;
1226                         priv->int_ints[queue_entry].qh->toggle = 0;
1227                         priv->int_ints[queue_entry].qh->ping = 0;
1228
1229                 } else {
1230                         priv->int_ints[queue_entry].qh->toggle =
1231                                 dw3 & (1 << 25);
1232                         priv->int_ints[queue_entry].qh->ping = dw3 & (1 << 26);
1233                 }
1234
1235                 if (urb->dev->speed != USB_SPEED_HIGH)
1236                         length = PTD_XFERRED_LENGTH_LO(dw3);
1237                 else
1238                         length = PTD_XFERRED_LENGTH(dw3);
1239
1240                 if (length) {
1241                         switch (DW1_GET_PID(dw1)) {
1242                         case IN_PID:
1243                                 priv_read_copy(priv,
1244                                         priv->int_ints[queue_entry].data_buffer,
1245                                         usb_hcd->regs + payload , payload,
1246                                         length);
1247                         case OUT_PID:
1248
1249                                 urb->actual_length += length;
1250
1251                         case SETUP_PID:
1252                                 break;
1253                         }
1254                 }
1255
1256                 priv->int_ints[queue_entry].data_buffer = NULL;
1257                 priv->int_ints[queue_entry].urb = NULL;
1258                 priv->int_ints[queue_entry].qtd = NULL;
1259                 priv->int_ints[queue_entry].qh = NULL;
1260
1261                 isp1760_writel(skip_map, usb_hcd->regs +
1262                                 HC_INT_PTD_SKIPMAP_REG);
1263                 free_mem(priv, payload);
1264
1265                 if (urb->status == -EPIPE) {
1266                         /* HALT received */
1267
1268                          qtd = clean_up_qtdlist(qtd);
1269                          isp1760_urb_done(priv, urb, urb->status);
1270
1271                 } else if (qtd->status & URB_COMPLETE_NOTIFY) {
1272
1273                         if (urb->status == -EINPROGRESS)
1274                                 urb->status = 0;
1275
1276                         qtd = clean_this_qtd(qtd);
1277                         isp1760_urb_done(priv, urb, urb->status);
1278
1279                 } else {
1280                         /* next QTD of this URB */
1281
1282                         qtd = clean_this_qtd(qtd);
1283                         BUG_ON(!qtd);
1284                 }
1285
1286                 if (qtd)
1287                         enqueue_an_INT_packet(usb_hcd, qh, qtd);
1288
1289                 skip_map = isp1760_readl(usb_hcd->regs +
1290                                 HC_INT_PTD_SKIPMAP_REG);
1291         }
1292 }
1293
1294 #define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
1295 static struct isp1760_qh *qh_make(struct isp1760_hcd *priv, struct urb *urb,
1296                 gfp_t flags)
1297 {
1298         struct isp1760_qh *qh;
1299         int is_input, type;
1300
1301         qh = isp1760_qh_alloc(priv, flags);
1302         if (!qh)
1303                 return qh;
1304
1305         /*
1306          * init endpoint/device data for this QH
1307          */
1308         is_input = usb_pipein(urb->pipe);
1309         type = usb_pipetype(urb->pipe);
1310
1311         if (type == PIPE_INTERRUPT) {
1312
1313                 if (urb->dev->speed == USB_SPEED_HIGH) {
1314
1315                         qh->period = urb->interval >> 3;
1316                         if (qh->period == 0 && urb->interval != 1) {
1317                                 /* NOTE interval 2 or 4 uframes could work.
1318                                  * But interval 1 scheduling is simpler, and
1319                                  * includes high bandwidth.
1320                                  */
1321                                 printk(KERN_ERR "intr period %d uframes, NYET!",
1322                                                 urb->interval);
1323                                 qh_destroy(qh);
1324                                 return NULL;
1325                         }
1326                 } else {
1327                         qh->period = urb->interval;
1328                 }
1329         }
1330
1331         /* support for tt scheduling, and access to toggles */
1332         qh->dev = urb->dev;
1333
1334         if (!usb_pipecontrol(urb->pipe))
1335                 usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), !is_input,
1336                                 1);
1337         return qh;
1338 }
1339
1340 /*
1341  * For control/bulk/interrupt, return QH with these TDs appended.
1342  * Allocates and initializes the QH if necessary.
1343  * Returns null if it can't allocate a QH it needs to.
1344  * If the QH has TDs (urbs) already, that's great.
1345  */
1346 static struct isp1760_qh *qh_append_tds(struct isp1760_hcd *priv,
1347                 struct urb *urb, struct list_head *qtd_list, int epnum,
1348                 void **ptr)
1349 {
1350         struct isp1760_qh *qh;
1351         struct isp1760_qtd *qtd;
1352         struct isp1760_qtd *prev_qtd;
1353
1354         qh = (struct isp1760_qh *)*ptr;
1355         if (!qh) {
1356                 /* can't sleep here, we have priv->lock... */
1357                 qh = qh_make(priv, urb, GFP_ATOMIC);
1358                 if (!qh)
1359                         return qh;
1360                 *ptr = qh;
1361         }
1362
1363         qtd = list_entry(qtd_list->next, struct isp1760_qtd,
1364                         qtd_list);
1365         if (!list_empty(&qh->qtd_list))
1366                 prev_qtd = list_entry(qh->qtd_list.prev,
1367                                 struct isp1760_qtd, qtd_list);
1368         else
1369                 prev_qtd = NULL;
1370
1371         list_splice(qtd_list, qh->qtd_list.prev);
1372         if (prev_qtd) {
1373                 BUG_ON(prev_qtd->hw_next);
1374                 prev_qtd->hw_next = qtd;
1375         }
1376
1377         urb->hcpriv = qh;
1378         return qh;
1379 }
1380
1381 static void qtd_list_free(struct isp1760_hcd *priv, struct urb *urb,
1382                 struct list_head *qtd_list)
1383 {
1384         struct list_head *entry, *temp;
1385
1386         list_for_each_safe(entry, temp, qtd_list) {
1387                 struct isp1760_qtd      *qtd;
1388
1389                 qtd = list_entry(entry, struct isp1760_qtd, qtd_list);
1390                 list_del(&qtd->qtd_list);
1391                 isp1760_qtd_free(qtd);
1392         }
1393 }
1394
1395 static int isp1760_prepare_enqueue(struct isp1760_hcd *priv, struct urb *urb,
1396                 struct list_head *qtd_list, gfp_t mem_flags, packet_enqueue *p)
1397 {
1398         struct isp1760_qtd         *qtd;
1399         int                     epnum;
1400         unsigned long           flags;
1401         struct isp1760_qh          *qh = NULL;
1402         int                     rc;
1403         int qh_busy;
1404
1405         qtd = list_entry(qtd_list->next, struct isp1760_qtd, qtd_list);
1406         epnum = urb->ep->desc.bEndpointAddress;
1407
1408         spin_lock_irqsave(&priv->lock, flags);
1409         if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &priv_to_hcd(priv)->flags)) {
1410                 rc = -ESHUTDOWN;
1411                 goto done;
1412         }
1413         rc = usb_hcd_link_urb_to_ep(priv_to_hcd(priv), urb);
1414         if (rc)
1415                 goto done;
1416
1417         qh = urb->ep->hcpriv;
1418         if (qh)
1419                 qh_busy = !list_empty(&qh->qtd_list);
1420         else
1421                 qh_busy = 0;
1422
1423         qh = qh_append_tds(priv, urb, qtd_list, epnum, &urb->ep->hcpriv);
1424         if (!qh) {
1425                 usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv), urb);
1426                 rc = -ENOMEM;
1427                 goto done;
1428         }
1429
1430         if (!qh_busy)
1431                 p(priv_to_hcd(priv), qh, qtd);
1432
1433 done:
1434         spin_unlock_irqrestore(&priv->lock, flags);
1435         if (!qh)
1436                 qtd_list_free(priv, urb, qtd_list);
1437         return rc;
1438 }
1439
1440 static struct isp1760_qtd *isp1760_qtd_alloc(struct isp1760_hcd *priv,
1441                 gfp_t flags)
1442 {
1443         struct isp1760_qtd *qtd;
1444
1445         qtd = kmem_cache_zalloc(qtd_cachep, flags);
1446         if (qtd)
1447                 INIT_LIST_HEAD(&qtd->qtd_list);
1448
1449         return qtd;
1450 }
1451
1452 /*
1453  * create a list of filled qtds for this URB; won't link into qh.
1454  */
1455 static struct list_head *qh_urb_transaction(struct isp1760_hcd *priv,
1456                 struct urb *urb, struct list_head *head, gfp_t flags)
1457 {
1458         struct isp1760_qtd *qtd, *qtd_prev;
1459         void *buf;
1460         int len, maxpacket;
1461         int is_input;
1462         u32 token;
1463
1464         /*
1465          * URBs map to sequences of QTDs:  one logical transaction
1466          */
1467         qtd = isp1760_qtd_alloc(priv, flags);
1468         if (!qtd)
1469                 return NULL;
1470
1471         list_add_tail(&qtd->qtd_list, head);
1472         qtd->urb = urb;
1473         urb->status = -EINPROGRESS;
1474
1475         token = 0;
1476         /* for split transactions, SplitXState initialized to zero */
1477
1478         len = urb->transfer_buffer_length;
1479         is_input = usb_pipein(urb->pipe);
1480         if (usb_pipecontrol(urb->pipe)) {
1481                 /* SETUP pid */
1482                 qtd_fill(qtd, urb->setup_packet,
1483                                 sizeof(struct usb_ctrlrequest),
1484                                 token | SETUP_PID);
1485
1486                 /* ... and always at least one more pid */
1487                 token ^= DATA_TOGGLE;
1488                 qtd_prev = qtd;
1489                 qtd = isp1760_qtd_alloc(priv, flags);
1490                 if (!qtd)
1491                         goto cleanup;
1492                 qtd->urb = urb;
1493                 qtd_prev->hw_next = qtd;
1494                 list_add_tail(&qtd->qtd_list, head);
1495
1496                 /* for zero length DATA stages, STATUS is always IN */
1497                 if (len == 0)
1498                         token |= IN_PID;
1499         }
1500
1501         /*
1502          * data transfer stage:  buffer setup
1503          */
1504         buf = urb->transfer_buffer;
1505
1506         if (is_input)
1507                 token |= IN_PID;
1508         else
1509                 token |= OUT_PID;
1510
1511         maxpacket = max_packet(usb_maxpacket(urb->dev, urb->pipe, !is_input));
1512
1513         /*
1514          * buffer gets wrapped in one or more qtds;
1515          * last one may be "short" (including zero len)
1516          * and may serve as a control status ack
1517          */
1518         for (;;) {
1519                 int this_qtd_len;
1520
1521                 if (!buf && len) {
1522                         /* XXX This looks like usb storage / SCSI bug */
1523                         printk(KERN_ERR "buf is null, dma is %08lx len is %d\n",
1524                                         (long unsigned)urb->transfer_dma, len);
1525                         WARN_ON(1);
1526                 }
1527
1528                 this_qtd_len = qtd_fill(qtd, buf, len, token);
1529                 len -= this_qtd_len;
1530                 buf += this_qtd_len;
1531
1532                 /* qh makes control packets use qtd toggle; maybe switch it */
1533                 if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
1534                         token ^= DATA_TOGGLE;
1535
1536                 if (len <= 0)
1537                         break;
1538
1539                 qtd_prev = qtd;
1540                 qtd = isp1760_qtd_alloc(priv, flags);
1541                 if (!qtd)
1542                         goto cleanup;
1543                 qtd->urb = urb;
1544                 qtd_prev->hw_next = qtd;
1545                 list_add_tail(&qtd->qtd_list, head);
1546         }
1547
1548         /*
1549          * control requests may need a terminating data "status" ack;
1550          * bulk ones may need a terminating short packet (zero length).
1551          */
1552         if (urb->transfer_buffer_length != 0) {
1553                 int one_more = 0;
1554
1555                 if (usb_pipecontrol(urb->pipe)) {
1556                         one_more = 1;
1557                         /* "in" <--> "out"  */
1558                         token ^= IN_PID;
1559                         /* force DATA1 */
1560                         token |= DATA_TOGGLE;
1561                 } else if (usb_pipebulk(urb->pipe)
1562                                 && (urb->transfer_flags & URB_ZERO_PACKET)
1563                                 && !(urb->transfer_buffer_length % maxpacket)) {
1564                         one_more = 1;
1565                 }
1566                 if (one_more) {
1567                         qtd_prev = qtd;
1568                         qtd = isp1760_qtd_alloc(priv, flags);
1569                         if (!qtd)
1570                                 goto cleanup;
1571                         qtd->urb = urb;
1572                         qtd_prev->hw_next = qtd;
1573                         list_add_tail(&qtd->qtd_list, head);
1574
1575                         /* never any data in such packets */
1576                         qtd_fill(qtd, NULL, 0, token);
1577                 }
1578         }
1579
1580         qtd->status = URB_COMPLETE_NOTIFY;
1581         return head;
1582
1583 cleanup:
1584         qtd_list_free(priv, urb, head);
1585         return NULL;
1586 }
1587
1588 static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
1589                 gfp_t mem_flags)
1590 {
1591         struct isp1760_hcd *priv = hcd_to_priv(hcd);
1592         struct list_head qtd_list;
1593         packet_enqueue *pe;
1594
1595         INIT_LIST_HEAD(&qtd_list);
1596
1597         switch (usb_pipetype(urb->pipe)) {
1598         case PIPE_CONTROL:
1599         case PIPE_BULK:
1600
1601                 if (!qh_urb_transaction(priv, urb, &qtd_list, mem_flags))
1602                         return -ENOMEM;
1603                 pe =  enqueue_an_ATL_packet;
1604                 break;
1605
1606         case PIPE_INTERRUPT:
1607                 if (!qh_urb_transaction(priv, urb, &qtd_list, mem_flags))
1608                         return -ENOMEM;
1609                 pe = enqueue_an_INT_packet;
1610                 break;
1611
1612         case PIPE_ISOCHRONOUS:
1613                 printk(KERN_ERR "PIPE_ISOCHRONOUS ain't supported\n");
1614         default:
1615                 return -EPIPE;
1616         }
1617
1618         isp1760_prepare_enqueue(priv, urb, &qtd_list, mem_flags, pe);
1619         return 0;
1620 }
1621
1622 static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
1623                 int status)
1624 {
1625         struct isp1760_hcd *priv = hcd_to_priv(hcd);
1626         struct inter_packet_info *ints;
1627         u32 i;
1628         u32 reg_base, or_reg, skip_reg;
1629         unsigned long flags;
1630         struct ptd ptd;
1631
1632         switch (usb_pipetype(urb->pipe)) {
1633         case PIPE_ISOCHRONOUS:
1634                 return -EPIPE;
1635                 break;
1636
1637         case PIPE_INTERRUPT:
1638                 ints = priv->int_ints;
1639                 reg_base = INT_REGS_OFFSET;
1640                 or_reg = HC_INT_IRQ_MASK_OR_REG;
1641                 skip_reg = HC_INT_PTD_SKIPMAP_REG;
1642                 break;
1643
1644         default:
1645                 ints = priv->atl_ints;
1646                 reg_base = ATL_REGS_OFFSET;
1647                 or_reg = HC_ATL_IRQ_MASK_OR_REG;
1648                 skip_reg = HC_ATL_PTD_SKIPMAP_REG;
1649                 break;
1650         }
1651
1652         memset(&ptd, 0, sizeof(ptd));
1653         spin_lock_irqsave(&priv->lock, flags);
1654
1655         for (i = 0; i < 32; i++) {
1656                 if (ints->urb == urb) {
1657                         u32 skip_map;
1658                         u32 or_map;
1659                         struct isp1760_qtd *qtd;
1660
1661                         skip_map = isp1760_readl(hcd->regs + skip_reg);
1662                         skip_map |= 1 << i;
1663                         isp1760_writel(skip_map, hcd->regs + skip_reg);
1664
1665                         or_map = isp1760_readl(hcd->regs + or_reg);
1666                         or_map &= ~(1 << i);
1667                         isp1760_writel(or_map, hcd->regs + or_reg);
1668
1669                         priv_write_copy(priv, (u32 *)&ptd, hcd->regs + reg_base
1670                                         + i * sizeof(ptd), sizeof(ptd));
1671                         qtd = ints->qtd;
1672
1673                         clean_up_qtdlist(qtd);
1674
1675                         free_mem(priv, ints->payload);
1676
1677                         ints->urb = NULL;
1678                         ints->qh = NULL;
1679                         ints->qtd = NULL;
1680                         ints->data_buffer = NULL;
1681                         ints->payload = 0;
1682
1683                         isp1760_urb_done(priv, urb, status);
1684                         break;
1685                 }
1686                 ints++;
1687         }
1688
1689         spin_unlock_irqrestore(&priv->lock, flags);
1690         return 0;
1691 }
1692
1693 static irqreturn_t isp1760_irq(struct usb_hcd *usb_hcd)
1694 {
1695         struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
1696         u32 imask;
1697         irqreturn_t irqret = IRQ_NONE;
1698
1699         spin_lock(&priv->lock);
1700
1701         if (!(usb_hcd->state & HC_STATE_RUNNING))
1702                 goto leave;
1703
1704         imask = isp1760_readl(usb_hcd->regs + HC_INTERRUPT_REG);
1705         if (unlikely(!imask))
1706                 goto leave;
1707
1708         isp1760_writel(imask, usb_hcd->regs + HC_INTERRUPT_REG);
1709         if (imask & HC_ATL_INT)
1710                 do_atl_int(usb_hcd);
1711
1712         if (imask & HC_INTL_INT)
1713                 do_intl_int(usb_hcd);
1714
1715         irqret = IRQ_HANDLED;
1716 leave:
1717         spin_unlock(&priv->lock);
1718         return irqret;
1719 }
1720
1721 static int isp1760_hub_status_data(struct usb_hcd *hcd, char *buf)
1722 {
1723         struct isp1760_hcd *priv = hcd_to_priv(hcd);
1724         u32 temp, status = 0;
1725         u32 mask;
1726         int retval = 1;
1727         unsigned long flags;
1728
1729         /* if !USB_SUSPEND, root hub timers won't get shut down ... */
1730         if (!HC_IS_RUNNING(hcd->state))
1731                 return 0;
1732
1733         /* init status to no-changes */
1734         buf[0] = 0;
1735         mask = PORT_CSC;
1736
1737         spin_lock_irqsave(&priv->lock, flags);
1738         temp = isp1760_readl(hcd->regs + HC_PORTSC1);
1739
1740         if (temp & PORT_OWNER) {
1741                 if (temp & PORT_CSC) {
1742                         temp &= ~PORT_CSC;
1743                         isp1760_writel(temp, hcd->regs + HC_PORTSC1);
1744                         goto done;
1745                 }
1746         }
1747
1748         /*
1749          * Return status information even for ports with OWNER set.
1750          * Otherwise khubd wouldn't see the disconnect event when a
1751          * high-speed device is switched over to the companion
1752          * controller by the user.
1753          */
1754
1755         if ((temp & mask) != 0
1756                         || ((temp & PORT_RESUME) != 0
1757                                 && time_after_eq(jiffies,
1758                                         priv->reset_done))) {
1759                 buf [0] |= 1 << (0 + 1);
1760                 status = STS_PCD;
1761         }
1762         /* FIXME autosuspend idle root hubs */
1763 done:
1764         spin_unlock_irqrestore(&priv->lock, flags);
1765         return status ? retval : 0;
1766 }
1767
1768 static void isp1760_hub_descriptor(struct isp1760_hcd *priv,
1769                 struct usb_hub_descriptor *desc)
1770 {
1771         int ports = HCS_N_PORTS(priv->hcs_params);
1772         u16 temp;
1773
1774         desc->bDescriptorType = 0x29;
1775         /* priv 1.0, 2.3.9 says 20ms max */
1776         desc->bPwrOn2PwrGood = 10;
1777         desc->bHubContrCurrent = 0;
1778
1779         desc->bNbrPorts = ports;
1780         temp = 1 + (ports / 8);
1781         desc->bDescLength = 7 + 2 * temp;
1782
1783         /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
1784         memset(&desc->bitmap[0], 0, temp);
1785         memset(&desc->bitmap[temp], 0xff, temp);
1786
1787         /* per-port overcurrent reporting */
1788         temp = 0x0008;
1789         if (HCS_PPC(priv->hcs_params))
1790                 /* per-port power control */
1791                 temp |= 0x0001;
1792         else
1793                 /* no power switching */
1794                 temp |= 0x0002;
1795         desc->wHubCharacteristics = cpu_to_le16(temp);
1796 }
1797
1798 #define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
1799
1800 static int check_reset_complete(struct isp1760_hcd *priv, int index,
1801                 u32 __iomem *status_reg, int port_status)
1802 {
1803         if (!(port_status & PORT_CONNECT))
1804                 return port_status;
1805
1806         /* if reset finished and it's still not enabled -- handoff */
1807         if (!(port_status & PORT_PE)) {
1808
1809                 printk(KERN_ERR "port %d full speed --> companion\n",
1810                         index + 1);
1811
1812                 port_status |= PORT_OWNER;
1813                 port_status &= ~PORT_RWC_BITS;
1814                 isp1760_writel(port_status, status_reg);
1815
1816         } else
1817                 printk(KERN_ERR "port %d high speed\n", index + 1);
1818
1819         return port_status;
1820 }
1821
1822 static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
1823                 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1824 {
1825         struct isp1760_hcd *priv = hcd_to_priv(hcd);
1826         int ports = HCS_N_PORTS(priv->hcs_params);
1827         u32 __iomem *status_reg = hcd->regs + HC_PORTSC1;
1828         u32 temp, status;
1829         unsigned long flags;
1830         int retval = 0;
1831         unsigned selector;
1832
1833         /*
1834          * FIXME:  support SetPortFeatures USB_PORT_FEAT_INDICATOR.
1835          * HCS_INDICATOR may say we can change LEDs to off/amber/green.
1836          * (track current state ourselves) ... blink for diagnostics,
1837          * power, "this is the one", etc.  EHCI spec supports this.
1838          */
1839
1840         spin_lock_irqsave(&priv->lock, flags);
1841         switch (typeReq) {
1842         case ClearHubFeature:
1843                 switch (wValue) {
1844                 case C_HUB_LOCAL_POWER:
1845                 case C_HUB_OVER_CURRENT:
1846                         /* no hub-wide feature/status flags */
1847                         break;
1848                 default:
1849                         goto error;
1850                 }
1851                 break;
1852         case ClearPortFeature:
1853                 if (!wIndex || wIndex > ports)
1854                         goto error;
1855                 wIndex--;
1856                 temp = isp1760_readl(status_reg);
1857
1858                 /*
1859                  * Even if OWNER is set, so the port is owned by the
1860                  * companion controller, khubd needs to be able to clear
1861                  * the port-change status bits (especially
1862                  * USB_PORT_FEAT_C_CONNECTION).
1863                  */
1864
1865                 switch (wValue) {
1866                 case USB_PORT_FEAT_ENABLE:
1867                         isp1760_writel(temp & ~PORT_PE, status_reg);
1868                         break;
1869                 case USB_PORT_FEAT_C_ENABLE:
1870                         /* XXX error? */
1871                         break;
1872                 case USB_PORT_FEAT_SUSPEND:
1873                         if (temp & PORT_RESET)
1874                                 goto error;
1875
1876                         if (temp & PORT_SUSPEND) {
1877                                 if ((temp & PORT_PE) == 0)
1878                                         goto error;
1879                                 /* resume signaling for 20 msec */
1880                                 temp &= ~(PORT_RWC_BITS);
1881                                 isp1760_writel(temp | PORT_RESUME,
1882                                                 status_reg);
1883                                 priv->reset_done = jiffies +
1884                                         msecs_to_jiffies(20);
1885                         }
1886                         break;
1887                 case USB_PORT_FEAT_C_SUSPEND:
1888                         /* we auto-clear this feature */
1889                         break;
1890                 case USB_PORT_FEAT_POWER:
1891                         if (HCS_PPC(priv->hcs_params))
1892                                 isp1760_writel(temp & ~PORT_POWER, status_reg);
1893                         break;
1894                 case USB_PORT_FEAT_C_CONNECTION:
1895                         isp1760_writel(temp | PORT_CSC,
1896                                         status_reg);
1897                         break;
1898                 case USB_PORT_FEAT_C_OVER_CURRENT:
1899                         /* XXX error ?*/
1900                         break;
1901                 case USB_PORT_FEAT_C_RESET:
1902                         /* GetPortStatus clears reset */
1903                         break;
1904                 default:
1905                         goto error;
1906                 }
1907                 isp1760_readl(hcd->regs + HC_USBCMD);
1908                 break;
1909         case GetHubDescriptor:
1910                 isp1760_hub_descriptor(priv, (struct usb_hub_descriptor *)
1911                         buf);
1912                 break;
1913         case GetHubStatus:
1914                 /* no hub-wide feature/status flags */
1915                 memset(buf, 0, 4);
1916                 break;
1917         case GetPortStatus:
1918                 if (!wIndex || wIndex > ports)
1919                         goto error;
1920                 wIndex--;
1921                 status = 0;
1922                 temp = isp1760_readl(status_reg);
1923
1924                 /* wPortChange bits */
1925                 if (temp & PORT_CSC)
1926                         status |= 1 << USB_PORT_FEAT_C_CONNECTION;
1927
1928
1929                 /* whoever resumes must GetPortStatus to complete it!! */
1930                 if (temp & PORT_RESUME) {
1931                         printk(KERN_ERR "Port resume should be skipped.\n");
1932
1933                         /* Remote Wakeup received? */
1934                         if (!priv->reset_done) {
1935                                 /* resume signaling for 20 msec */
1936                                 priv->reset_done = jiffies
1937                                                 + msecs_to_jiffies(20);
1938                                 /* check the port again */
1939                                 mod_timer(&priv_to_hcd(priv)->rh_timer,
1940                                                 priv->reset_done);
1941                         }
1942
1943                         /* resume completed? */
1944                         else if (time_after_eq(jiffies,
1945                                         priv->reset_done)) {
1946                                 status |= 1 << USB_PORT_FEAT_C_SUSPEND;
1947                                 priv->reset_done = 0;
1948
1949                                 /* stop resume signaling */
1950                                 temp = isp1760_readl(status_reg);
1951                                 isp1760_writel(
1952                                         temp & ~(PORT_RWC_BITS | PORT_RESUME),
1953                                         status_reg);
1954                                 retval = handshake(priv, status_reg,
1955                                            PORT_RESUME, 0, 2000 /* 2msec */);
1956                                 if (retval != 0) {
1957                                         isp1760_err(priv,
1958                                                 "port %d resume error %d\n",
1959                                                 wIndex + 1, retval);
1960                                         goto error;
1961                                 }
1962                                 temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
1963                         }
1964                 }
1965
1966                 /* whoever resets must GetPortStatus to complete it!! */
1967                 if ((temp & PORT_RESET)
1968                                 && time_after_eq(jiffies,
1969                                         priv->reset_done)) {
1970                         status |= 1 << USB_PORT_FEAT_C_RESET;
1971                         priv->reset_done = 0;
1972
1973                         /* force reset to complete */
1974                         isp1760_writel(temp & ~PORT_RESET,
1975                                         status_reg);
1976                         /* REVISIT:  some hardware needs 550+ usec to clear
1977                          * this bit; seems too long to spin routinely...
1978                          */
1979                         retval = handshake(priv, status_reg,
1980                                         PORT_RESET, 0, 750);
1981                         if (retval != 0) {
1982                                 isp1760_err(priv, "port %d reset error %d\n",
1983                                                 wIndex + 1, retval);
1984                                 goto error;
1985                         }
1986
1987                         /* see what we found out */
1988                         temp = check_reset_complete(priv, wIndex, status_reg,
1989                                         isp1760_readl(status_reg));
1990                 }
1991                 /*
1992                  * Even if OWNER is set, there's no harm letting khubd
1993                  * see the wPortStatus values (they should all be 0 except
1994                  * for PORT_POWER anyway).
1995                  */
1996
1997                 if (temp & PORT_OWNER)
1998                         printk(KERN_ERR "Warning: PORT_OWNER is set\n");
1999
2000                 if (temp & PORT_CONNECT) {
2001                         status |= 1 << USB_PORT_FEAT_CONNECTION;
2002                         /* status may be from integrated TT */
2003                         status |= ehci_port_speed(priv, temp);
2004                 }
2005                 if (temp & PORT_PE)
2006                         status |= 1 << USB_PORT_FEAT_ENABLE;
2007                 if (temp & (PORT_SUSPEND|PORT_RESUME))
2008                         status |= 1 << USB_PORT_FEAT_SUSPEND;
2009                 if (temp & PORT_RESET)
2010                         status |= 1 << USB_PORT_FEAT_RESET;
2011                 if (temp & PORT_POWER)
2012                         status |= 1 << USB_PORT_FEAT_POWER;
2013
2014                 put_unaligned(cpu_to_le32(status), (__le32 *) buf);
2015                 break;
2016         case SetHubFeature:
2017                 switch (wValue) {
2018                 case C_HUB_LOCAL_POWER:
2019                 case C_HUB_OVER_CURRENT:
2020                         /* no hub-wide feature/status flags */
2021                         break;
2022                 default:
2023                         goto error;
2024                 }
2025                 break;
2026         case SetPortFeature:
2027                 selector = wIndex >> 8;
2028                 wIndex &= 0xff;
2029                 if (!wIndex || wIndex > ports)
2030                         goto error;
2031                 wIndex--;
2032                 temp = isp1760_readl(status_reg);
2033                 if (temp & PORT_OWNER)
2034                         break;
2035
2036 /*              temp &= ~PORT_RWC_BITS; */
2037                 switch (wValue) {
2038                 case USB_PORT_FEAT_ENABLE:
2039                         isp1760_writel(temp | PORT_PE, status_reg);
2040                         break;
2041
2042                 case USB_PORT_FEAT_SUSPEND:
2043                         if ((temp & PORT_PE) == 0
2044                                         || (temp & PORT_RESET) != 0)
2045                                 goto error;
2046
2047                         isp1760_writel(temp | PORT_SUSPEND, status_reg);
2048                         break;
2049                 case USB_PORT_FEAT_POWER:
2050                         if (HCS_PPC(priv->hcs_params))
2051                                 isp1760_writel(temp | PORT_POWER,
2052                                                 status_reg);
2053                         break;
2054                 case USB_PORT_FEAT_RESET:
2055                         if (temp & PORT_RESUME)
2056                                 goto error;
2057                         /* line status bits may report this as low speed,
2058                          * which can be fine if this root hub has a
2059                          * transaction translator built in.
2060                          */
2061                         if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
2062                                         && PORT_USB11(temp)) {
2063                                 temp |= PORT_OWNER;
2064                         } else {
2065                                 temp |= PORT_RESET;
2066                                 temp &= ~PORT_PE;
2067
2068                                 /*
2069                                  * caller must wait, then call GetPortStatus
2070                                  * usb 2.0 spec says 50 ms resets on root
2071                                  */
2072                                 priv->reset_done = jiffies +
2073                                         msecs_to_jiffies(50);
2074                         }
2075                         isp1760_writel(temp, status_reg);
2076                         break;
2077                 default:
2078                         goto error;
2079                 }
2080                 isp1760_readl(hcd->regs + HC_USBCMD);
2081                 break;
2082
2083         default:
2084 error:
2085                 /* "stall" on error */
2086                 retval = -EPIPE;
2087         }
2088         spin_unlock_irqrestore(&priv->lock, flags);
2089         return retval;
2090 }
2091
2092 static void isp1760_endpoint_disable(struct usb_hcd *usb_hcd,
2093                 struct usb_host_endpoint *ep)
2094 {
2095         struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
2096         struct isp1760_qh *qh;
2097         struct isp1760_qtd *qtd;
2098         unsigned long flags;
2099
2100         spin_lock_irqsave(&priv->lock, flags);
2101         qh = ep->hcpriv;
2102         if (!qh)
2103                 goto out;
2104
2105         ep->hcpriv = NULL;
2106         do {
2107                 /* more than entry might get removed */
2108                 if (list_empty(&qh->qtd_list))
2109                         break;
2110
2111                 qtd = list_first_entry(&qh->qtd_list, struct isp1760_qtd,
2112                                 qtd_list);
2113
2114                 if (qtd->status & URB_ENQUEUED) {
2115
2116                         spin_unlock_irqrestore(&priv->lock, flags);
2117                         isp1760_urb_dequeue(usb_hcd, qtd->urb, -ECONNRESET);
2118                         spin_lock_irqsave(&priv->lock, flags);
2119                 } else {
2120                         struct urb *urb;
2121
2122                         urb = qtd->urb;
2123                         clean_up_qtdlist(qtd);
2124                         isp1760_urb_done(priv, urb, -ECONNRESET);
2125                 }
2126         } while (1);
2127
2128         qh_destroy(qh);
2129         /* remove requests and leak them.
2130          * ATL are pretty fast done, INT could take a while...
2131          * The latter shoule be removed
2132          */
2133 out:
2134         spin_unlock_irqrestore(&priv->lock, flags);
2135 }
2136
2137 static int isp1760_get_frame(struct usb_hcd *hcd)
2138 {
2139         struct isp1760_hcd *priv = hcd_to_priv(hcd);
2140         u32 fr;
2141
2142         fr = isp1760_readl(hcd->regs + HC_FRINDEX);
2143         return (fr >> 3) % priv->periodic_size;
2144 }
2145
2146 static void isp1760_stop(struct usb_hcd *hcd)
2147 {
2148         struct isp1760_hcd *priv = hcd_to_priv(hcd);
2149         u32 temp;
2150
2151         isp1760_hub_control(hcd, ClearPortFeature, USB_PORT_FEAT_POWER, 1,
2152                         NULL, 0);
2153         mdelay(20);
2154
2155         spin_lock_irq(&priv->lock);
2156         ehci_reset(priv);
2157         /* Disable IRQ */
2158         temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
2159         isp1760_writel(temp &= ~HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
2160         spin_unlock_irq(&priv->lock);
2161
2162         isp1760_writel(0, hcd->regs + HC_CONFIGFLAG);
2163 }
2164
2165 static void isp1760_shutdown(struct usb_hcd *hcd)
2166 {
2167         u32 command, temp;
2168
2169         isp1760_stop(hcd);
2170         temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
2171         isp1760_writel(temp &= ~HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
2172
2173         command = isp1760_readl(hcd->regs + HC_USBCMD);
2174         command &= ~CMD_RUN;
2175         isp1760_writel(command, hcd->regs + HC_USBCMD);
2176 }
2177
2178 static const struct hc_driver isp1760_hc_driver = {
2179         .description            = "isp1760-hcd",
2180         .product_desc           = "NXP ISP1760 USB Host Controller",
2181         .hcd_priv_size          = sizeof(struct isp1760_hcd),
2182         .irq                    = isp1760_irq,
2183         .flags                  = HCD_MEMORY | HCD_USB2,
2184         .reset                  = isp1760_hc_setup,
2185         .start                  = isp1760_run,
2186         .stop                   = isp1760_stop,
2187         .shutdown               = isp1760_shutdown,
2188         .urb_enqueue            = isp1760_urb_enqueue,
2189         .urb_dequeue            = isp1760_urb_dequeue,
2190         .endpoint_disable       = isp1760_endpoint_disable,
2191         .get_frame_number       = isp1760_get_frame,
2192         .hub_status_data        = isp1760_hub_status_data,
2193         .hub_control            = isp1760_hub_control,
2194 };
2195
2196 int __init init_kmem_once(void)
2197 {
2198         qtd_cachep = kmem_cache_create("isp1760_qtd",
2199                         sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY |
2200                         SLAB_MEM_SPREAD, NULL);
2201
2202         if (!qtd_cachep)
2203                 return -ENOMEM;
2204
2205         qh_cachep = kmem_cache_create("isp1760_qh", sizeof(struct isp1760_qh),
2206                         0, SLAB_TEMPORARY | SLAB_MEM_SPREAD, NULL);
2207
2208         if (!qh_cachep) {
2209                 kmem_cache_destroy(qtd_cachep);
2210                 return -ENOMEM;
2211         }
2212
2213         return 0;
2214 }
2215
2216 void deinit_kmem_cache(void)
2217 {
2218         kmem_cache_destroy(qtd_cachep);
2219         kmem_cache_destroy(qh_cachep);
2220 }
2221
2222 struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
2223                 u64 irqflags, struct device *dev, const char *busname,
2224                 unsigned int devflags)
2225 {
2226         struct usb_hcd *hcd;
2227         struct isp1760_hcd *priv;
2228         int ret;
2229
2230         if (usb_disabled())
2231                 return ERR_PTR(-ENODEV);
2232
2233         /* prevent usb-core allocating DMA pages */
2234         dev->dma_mask = NULL;
2235
2236         hcd = usb_create_hcd(&isp1760_hc_driver, dev, dev_name(dev));
2237         if (!hcd)
2238                 return ERR_PTR(-ENOMEM);
2239
2240         priv = hcd_to_priv(hcd);
2241         priv->devflags = devflags;
2242         init_memory(priv);
2243         hcd->regs = ioremap(res_start, res_len);
2244         if (!hcd->regs) {
2245                 ret = -EIO;
2246                 goto err_put;
2247         }
2248
2249         hcd->irq = irq;
2250         hcd->rsrc_start = res_start;
2251         hcd->rsrc_len = res_len;
2252
2253         ret = usb_add_hcd(hcd, irq, irqflags);
2254         if (ret)
2255                 goto err_unmap;
2256
2257         return hcd;
2258
2259 err_unmap:
2260          iounmap(hcd->regs);
2261
2262 err_put:
2263          usb_put_hcd(hcd);
2264
2265          return ERR_PTR(ret);
2266 }
2267
2268 MODULE_DESCRIPTION("Driver for the ISP1760 USB-controller from NXP");
2269 MODULE_AUTHOR("Sebastian Siewior <bigeasy@linuxtronix.de>");
2270 MODULE_LICENSE("GPL v2");