?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: isp1760: Support board-specific hardware configurations
[linux-2.6/btrfs-unstable.git] / drivers / usb / host / isp1760-hcd.c
blobc858f2adb929904631746151469696c73b22cd22
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");
(deprecated) Btrfs devel tree