?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: isp1362-hcd, fix double lock
[linux-2.6/kvm.git] / drivers / usb / host / isp1362-hcd.c
blob0587ad4ce5c2948500dbd339b5d03f322b905fb6
1 /*
2 * ISP1362 HCD (Host Controller Driver) for USB.
3 *
4 * Copyright (C) 2005 Lothar Wassmann <LW@KARO-electronics.de>
5 *
6 * Derived from the SL811 HCD, rewritten for ISP116x.
7 * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
8 *
9 * Portions:
10 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
11 * Copyright (C) 2004 David Brownell
12 */
13
14 /*
15 * The ISP1362 chip requires a large delay (300ns and 462ns) between
16 * accesses to the address and data register.
17 * The following timing options exist:
18 *
19 * 1. Configure your memory controller to add such delays if it can (the best)
20 * 2. Implement platform-specific delay function possibly
21 * combined with configuring the memory controller; see
22 * include/linux/usb_isp1362.h for more info.
23 * 3. Use ndelay (easiest, poorest).
24 *
25 * Use the corresponding macros USE_PLATFORM_DELAY and USE_NDELAY in the
26 * platform specific section of isp1362.h to select the appropriate variant.
27 *
28 * Also note that according to the Philips "ISP1362 Errata" document
29 * Rev 1.00 from 27 May data corruption may occur when the #WR signal
30 * is reasserted (even with #CS deasserted) within 132ns after a
31 * write cycle to any controller register. If the hardware doesn't
32 * implement the recommended fix (gating the #WR with #CS) software
33 * must ensure that no further write cycle (not necessarily to the chip!)
34 * is issued by the CPU within this interval.
35
36 * For PXA25x this can be ensured by using VLIO with the maximum
37 * recovery time (MSCx = 0x7f8c) with a memory clock of 99.53 MHz.
38 */
39
40 #ifdef CONFIG_USB_DEBUG
41 # define ISP1362_DEBUG
42 #else
43 # undef ISP1362_DEBUG
44 #endif
45
46 /*
47 * The PXA255 UDC apparently doesn't handle GET_STATUS, GET_CONFIG and
48 * GET_INTERFACE requests correctly when the SETUP and DATA stages of the
49 * requests are carried out in separate frames. This will delay any SETUP
50 * packets until the start of the next frame so that this situation is
51 * unlikely to occur (and makes usbtest happy running with a PXA255 target
52 * device).
53 */
54 #undef BUGGY_PXA2XX_UDC_USBTEST
55
56 #undef PTD_TRACE
57 #undef URB_TRACE
58 #undef VERBOSE
59 #undef REGISTERS
60
61 /* This enables a memory test on the ISP1362 chip memory to make sure the
62 * chip access timing is correct.
63 */
64 #undef CHIP_BUFFER_TEST
65
66 #include <linux/module.h>
67 #include <linux/moduleparam.h>
68 #include <linux/kernel.h>
69 #include <linux/delay.h>
70 #include <linux/ioport.h>
71 #include <linux/sched.h>
72 #include <linux/slab.h>
73 #include <linux/smp_lock.h>
74 #include <linux/errno.h>
75 #include <linux/init.h>
76 #include <linux/list.h>
77 #include <linux/interrupt.h>
78 #include <linux/usb.h>
79 #include <linux/usb/isp1362.h>
80 #include <linux/usb/hcd.h>
81 #include <linux/platform_device.h>
82 #include <linux/pm.h>
83 #include <linux/io.h>
84 #include <linux/bitmap.h>
85
86 #include <asm/irq.h>
87 #include <asm/system.h>
88 #include <asm/byteorder.h>
89 #include <asm/unaligned.h>
90
91 static int dbg_level;
92 #ifdef ISP1362_DEBUG
93 module_param(dbg_level, int, 0644);
94 #else
95 module_param(dbg_level, int, 0);
96 #define STUB_DEBUG_FILE
97 #endif
98
99 #include "../core/usb.h"
100 #include "isp1362.h"
101
102
103 #define DRIVER_VERSION "2005-04-04"
104 #define DRIVER_DESC "ISP1362 USB Host Controller Driver"
105
106 MODULE_DESCRIPTION(DRIVER_DESC);
107 MODULE_LICENSE("GPL");
108
109 static const char hcd_name[] = "isp1362-hcd";
110
111 static void isp1362_hc_stop(struct usb_hcd *hcd);
112 static int isp1362_hc_start(struct usb_hcd *hcd);
113
114 /*-------------------------------------------------------------------------*/
115
116 /*
117 * When called from the interrupthandler only isp1362_hcd->irqenb is modified,
118 * since the interrupt handler will write isp1362_hcd->irqenb to HCuPINT upon
119 * completion.
120 * We don't need a 'disable' counterpart, since interrupts will be disabled
121 * only by the interrupt handler.
122 */
123 static inline void isp1362_enable_int(struct isp1362_hcd *isp1362_hcd, u16 mask)
124 {
125 if ((isp1362_hcd->irqenb | mask) == isp1362_hcd->irqenb)
126 return;
127 if (mask & ~isp1362_hcd->irqenb)
128 isp1362_write_reg16(isp1362_hcd, HCuPINT, mask & ~isp1362_hcd->irqenb);
129 isp1362_hcd->irqenb |= mask;
130 if (isp1362_hcd->irq_active)
131 return;
132 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
133 }
134
135 /*-------------------------------------------------------------------------*/
136
137 static inline struct isp1362_ep_queue *get_ptd_queue(struct isp1362_hcd *isp1362_hcd,
138 u16 offset)
139 {
140 struct isp1362_ep_queue *epq = NULL;
141
142 if (offset < isp1362_hcd->istl_queue[1].buf_start)
143 epq = &isp1362_hcd->istl_queue[0];
144 else if (offset < isp1362_hcd->intl_queue.buf_start)
145 epq = &isp1362_hcd->istl_queue[1];
146 else if (offset < isp1362_hcd->atl_queue.buf_start)
147 epq = &isp1362_hcd->intl_queue;
148 else if (offset < isp1362_hcd->atl_queue.buf_start +
149 isp1362_hcd->atl_queue.buf_size)
150 epq = &isp1362_hcd->atl_queue;
151
152 if (epq)
153 DBG(1, "%s: PTD $%04x is on %s queue\n", __func__, offset, epq->name);
154 else
155 pr_warning("%s: invalid PTD $%04x\n", __func__, offset);
156
157 return epq;
158 }
159
160 static inline int get_ptd_offset(struct isp1362_ep_queue *epq, u8 index)
161 {
162 int offset;
163
164 if (index * epq->blk_size > epq->buf_size) {
165 pr_warning("%s: Bad %s index %d(%d)\n", __func__, epq->name, index,
166 epq->buf_size / epq->blk_size);
167 return -EINVAL;
168 }
169 offset = epq->buf_start + index * epq->blk_size;
170 DBG(3, "%s: %s PTD[%02x] # %04x\n", __func__, epq->name, index, offset);
171
172 return offset;
173 }
174
175 /*-------------------------------------------------------------------------*/
176
177 static inline u16 max_transfer_size(struct isp1362_ep_queue *epq, size_t size,
178 int mps)
179 {
180 u16 xfer_size = min_t(size_t, MAX_XFER_SIZE, size);
181
182 xfer_size = min_t(size_t, xfer_size, epq->buf_avail * epq->blk_size - PTD_HEADER_SIZE);
183 if (xfer_size < size && xfer_size % mps)
184 xfer_size -= xfer_size % mps;
185
186 return xfer_size;
187 }
188
189 static int claim_ptd_buffers(struct isp1362_ep_queue *epq,
190 struct isp1362_ep *ep, u16 len)
191 {
192 int ptd_offset = -EINVAL;
193 int num_ptds = ((len + PTD_HEADER_SIZE - 1) / epq->blk_size) + 1;
194 int found;
195
196 BUG_ON(len > epq->buf_size);
197
198 if (!epq->buf_avail)
199 return -ENOMEM;
200
201 if (ep->num_ptds)
202 pr_err("%s: %s len %d/%d num_ptds %d buf_map %08lx skip_map %08lx\n", __func__,
203 epq->name, len, epq->blk_size, num_ptds, epq->buf_map, epq->skip_map);
204 BUG_ON(ep->num_ptds != 0);
205
206 found = bitmap_find_next_zero_area(&epq->buf_map, epq->buf_count, 0,
207 num_ptds, 0);
208 if (found >= epq->buf_count)
209 return -EOVERFLOW;
210
211 DBG(1, "%s: Found %d PTDs[%d] for %d/%d byte\n", __func__,
212 num_ptds, found, len, (int)(epq->blk_size - PTD_HEADER_SIZE));
213 ptd_offset = get_ptd_offset(epq, found);
214 WARN_ON(ptd_offset < 0);
215 ep->ptd_offset = ptd_offset;
216 ep->num_ptds += num_ptds;
217 epq->buf_avail -= num_ptds;
218 BUG_ON(epq->buf_avail > epq->buf_count);
219 ep->ptd_index = found;
220 bitmap_set(&epq->buf_map, found, num_ptds);
221 DBG(1, "%s: Done %s PTD[%d] $%04x, avail %d count %d claimed %d %08lx:%08lx\n",
222 __func__, epq->name, ep->ptd_index, ep->ptd_offset,
223 epq->buf_avail, epq->buf_count, num_ptds, epq->buf_map, epq->skip_map);
224
225 return found;
226 }
227
228 static inline void release_ptd_buffers(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
229 {
230 int index = ep->ptd_index;
231 int last = ep->ptd_index + ep->num_ptds;
232
233 if (last > epq->buf_count)
234 pr_err("%s: ep %p req %d len %d %s PTD[%d] $%04x num_ptds %d buf_count %d buf_avail %d buf_map %08lx skip_map %08lx\n",
235 __func__, ep, ep->num_req, ep->length, epq->name, ep->ptd_index,
236 ep->ptd_offset, ep->num_ptds, epq->buf_count, epq->buf_avail,
237 epq->buf_map, epq->skip_map);
238 BUG_ON(last > epq->buf_count);
239
240 for (; index < last; index++) {
241 __clear_bit(index, &epq->buf_map);
242 __set_bit(index, &epq->skip_map);
243 }
244 epq->buf_avail += ep->num_ptds;
245 epq->ptd_count--;
246
247 BUG_ON(epq->buf_avail > epq->buf_count);
248 BUG_ON(epq->ptd_count > epq->buf_count);
249
250 DBG(1, "%s: Done %s PTDs $%04x released %d avail %d count %d\n",
251 __func__, epq->name,
252 ep->ptd_offset, ep->num_ptds, epq->buf_avail, epq->buf_count);
253 DBG(1, "%s: buf_map %08lx skip_map %08lx\n", __func__,
254 epq->buf_map, epq->skip_map);
255
256 ep->num_ptds = 0;
257 ep->ptd_offset = -EINVAL;
258 ep->ptd_index = -EINVAL;
259 }
260
261 /*-------------------------------------------------------------------------*/
262
263 /*
264 Set up PTD's.
265 */
266 static void prepare_ptd(struct isp1362_hcd *isp1362_hcd, struct urb *urb,
267 struct isp1362_ep *ep, struct isp1362_ep_queue *epq,
268 u16 fno)
269 {
270 struct ptd *ptd;
271 int toggle;
272 int dir;
273 u16 len;
274 size_t buf_len = urb->transfer_buffer_length - urb->actual_length;
275
276 DBG(3, "%s: %s ep %p\n", __func__, epq->name, ep);
277
278 ptd = &ep->ptd;
279
280 ep->data = (unsigned char *)urb->transfer_buffer + urb->actual_length;
281
282 switch (ep->nextpid) {
283 case USB_PID_IN:
284 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
285 dir = PTD_DIR_IN;
286 if (usb_pipecontrol(urb->pipe)) {
287 len = min_t(size_t, ep->maxpacket, buf_len);
288 } else if (usb_pipeisoc(urb->pipe)) {
289 len = min_t(size_t, urb->iso_frame_desc[fno].length, MAX_XFER_SIZE);
290 ep->data = urb->transfer_buffer + urb->iso_frame_desc[fno].offset;
291 } else
292 len = max_transfer_size(epq, buf_len, ep->maxpacket);
293 DBG(1, "%s: IN len %d/%d/%d from URB\n", __func__, len, ep->maxpacket,
294 (int)buf_len);
295 break;
296 case USB_PID_OUT:
297 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
298 dir = PTD_DIR_OUT;
299 if (usb_pipecontrol(urb->pipe))
300 len = min_t(size_t, ep->maxpacket, buf_len);
301 else if (usb_pipeisoc(urb->pipe))
302 len = min_t(size_t, urb->iso_frame_desc[0].length, MAX_XFER_SIZE);
303 else
304 len = max_transfer_size(epq, buf_len, ep->maxpacket);
305 if (len == 0)
306 pr_info("%s: Sending ZERO packet: %d\n", __func__,
307 urb->transfer_flags & URB_ZERO_PACKET);
308 DBG(1, "%s: OUT len %d/%d/%d from URB\n", __func__, len, ep->maxpacket,
309 (int)buf_len);
310 break;
311 case USB_PID_SETUP:
312 toggle = 0;
313 dir = PTD_DIR_SETUP;
314 len = sizeof(struct usb_ctrlrequest);
315 DBG(1, "%s: SETUP len %d\n", __func__, len);
316 ep->data = urb->setup_packet;
317 break;
318 case USB_PID_ACK:
319 toggle = 1;
320 len = 0;
321 dir = (urb->transfer_buffer_length && usb_pipein(urb->pipe)) ?
322 PTD_DIR_OUT : PTD_DIR_IN;
323 DBG(1, "%s: ACK len %d\n", __func__, len);
324 break;
325 default:
326 toggle = dir = len = 0;
327 pr_err("%s@%d: ep->nextpid %02x\n", __func__, __LINE__, ep->nextpid);
328 BUG_ON(1);
329 }
330
331 ep->length = len;
332 if (!len)
333 ep->data = NULL;
334
335 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
336 ptd->mps = PTD_MPS(ep->maxpacket) | PTD_SPD(urb->dev->speed == USB_SPEED_LOW) |
337 PTD_EP(ep->epnum);
338 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
339 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
340
341 if (usb_pipeint(urb->pipe)) {
342 ptd->faddr |= PTD_SF_INT(ep->branch);
343 ptd->faddr |= PTD_PR(ep->interval ? __ffs(ep->interval) : 0);
344 }
345 if (usb_pipeisoc(urb->pipe))
346 ptd->faddr |= PTD_SF_ISO(fno);
347
348 DBG(1, "%s: Finished\n", __func__);
349 }
350
351 static void isp1362_write_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
352 struct isp1362_ep_queue *epq)
353 {
354 struct ptd *ptd = &ep->ptd;
355 int len = PTD_GET_DIR(ptd) == PTD_DIR_IN ? 0 : ep->length;
356
357 _BUG_ON(ep->ptd_offset < 0);
358
359 prefetch(ptd);
360 isp1362_write_buffer(isp1362_hcd, ptd, ep->ptd_offset, PTD_HEADER_SIZE);
361 if (len)
362 isp1362_write_buffer(isp1362_hcd, ep->data,
363 ep->ptd_offset + PTD_HEADER_SIZE, len);
364
365 dump_ptd(ptd);
366 dump_ptd_out_data(ptd, ep->data);
367 }
368
369 static void isp1362_read_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
370 struct isp1362_ep_queue *epq)
371 {
372 struct ptd *ptd = &ep->ptd;
373 int act_len;
374
375 WARN_ON(list_empty(&ep->active));
376 BUG_ON(ep->ptd_offset < 0);
377
378 list_del_init(&ep->active);
379 DBG(1, "%s: ep %p removed from active list %p\n", __func__, ep, &epq->active);
380
381 prefetchw(ptd);
382 isp1362_read_buffer(isp1362_hcd, ptd, ep->ptd_offset, PTD_HEADER_SIZE);
383 dump_ptd(ptd);
384 act_len = PTD_GET_COUNT(ptd);
385 if (PTD_GET_DIR(ptd) != PTD_DIR_IN || act_len == 0)
386 return;
387 if (act_len > ep->length)
388 pr_err("%s: ep %p PTD $%04x act_len %d ep->length %d\n", __func__, ep,
389 ep->ptd_offset, act_len, ep->length);
390 BUG_ON(act_len > ep->length);
391 /* Only transfer the amount of data that has actually been overwritten
392 * in the chip buffer. We don't want any data that doesn't belong to the
393 * transfer to leak out of the chip to the callers transfer buffer!
394 */
395 prefetchw(ep->data);
396 isp1362_read_buffer(isp1362_hcd, ep->data,
397 ep->ptd_offset + PTD_HEADER_SIZE, act_len);
398 dump_ptd_in_data(ptd, ep->data);
399 }
400
401 /*
402 * INT PTDs will stay in the chip until data is available.
403 * This function will remove a PTD from the chip when the URB is dequeued.
404 * Must be called with the spinlock held and IRQs disabled
405 */
406 static void remove_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep)
407
408 {
409 int index;
410 struct isp1362_ep_queue *epq;
411
412 DBG(1, "%s: ep %p PTD[%d] $%04x\n", __func__, ep, ep->ptd_index, ep->ptd_offset);
413 BUG_ON(ep->ptd_offset < 0);
414
415 epq = get_ptd_queue(isp1362_hcd, ep->ptd_offset);
416 BUG_ON(!epq);
417
418 /* put ep in remove_list for cleanup */
419 WARN_ON(!list_empty(&ep->remove_list));
420 list_add_tail(&ep->remove_list, &isp1362_hcd->remove_list);
421 /* let SOF interrupt handle the cleanup */
422 isp1362_enable_int(isp1362_hcd, HCuPINT_SOF);
423
424 index = ep->ptd_index;
425 if (index < 0)
426 /* ISO queues don't have SKIP registers */
427 return;
428
429 DBG(1, "%s: Disabling PTD[%02x] $%04x %08lx|%08x\n", __func__,
430 index, ep->ptd_offset, epq->skip_map, 1 << index);
431
432 /* prevent further processing of PTD (will be effective after next SOF) */
433 epq->skip_map |= 1 << index;
434 if (epq == &isp1362_hcd->atl_queue) {
435 DBG(2, "%s: ATLSKIP = %08x -> %08lx\n", __func__,
436 isp1362_read_reg32(isp1362_hcd, HCATLSKIP), epq->skip_map);
437 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, epq->skip_map);
438 if (~epq->skip_map == 0)
439 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
440 } else if (epq == &isp1362_hcd->intl_queue) {
441 DBG(2, "%s: INTLSKIP = %08x -> %08lx\n", __func__,
442 isp1362_read_reg32(isp1362_hcd, HCINTLSKIP), epq->skip_map);
443 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, epq->skip_map);
444 if (~epq->skip_map == 0)
445 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
446 }
447 }
448
449 /*
450 Take done or failed requests out of schedule. Give back
451 processed urbs.
452 */
453 static void finish_request(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
454 struct urb *urb, int status)
455 __releases(isp1362_hcd->lock)
456 __acquires(isp1362_hcd->lock)
457 {
458 urb->hcpriv = NULL;
459 ep->error_count = 0;
460
461 if (usb_pipecontrol(urb->pipe))
462 ep->nextpid = USB_PID_SETUP;
463
464 URB_DBG("%s: req %d FA %d ep%d%s %s: len %d/%d %s stat %d\n", __func__,
465 ep->num_req, usb_pipedevice(urb->pipe),
466 usb_pipeendpoint(urb->pipe),
467 !usb_pipein(urb->pipe) ? "out" : "in",
468 usb_pipecontrol(urb->pipe) ? "ctrl" :
469 usb_pipeint(urb->pipe) ? "int" :
470 usb_pipebulk(urb->pipe) ? "bulk" :
471 "iso",
472 urb->actual_length, urb->transfer_buffer_length,
473 !(urb->transfer_flags & URB_SHORT_NOT_OK) ?
474 "short_ok" : "", urb->status);
475
476
477 usb_hcd_unlink_urb_from_ep(isp1362_hcd_to_hcd(isp1362_hcd), urb);
478 spin_unlock(&isp1362_hcd->lock);
479 usb_hcd_giveback_urb(isp1362_hcd_to_hcd(isp1362_hcd), urb, status);
480 spin_lock(&isp1362_hcd->lock);
481
482 /* take idle endpoints out of the schedule right away */
483 if (!list_empty(&ep->hep->urb_list))
484 return;
485
486 /* async deschedule */
487 if (!list_empty(&ep->schedule)) {
488 list_del_init(&ep->schedule);
489 return;
490 }
491
492
493 if (ep->interval) {
494 /* periodic deschedule */
495 DBG(1, "deschedule qh%d/%p branch %d load %d bandwidth %d -> %d\n", ep->interval,
496 ep, ep->branch, ep->load,
497 isp1362_hcd->load[ep->branch],
498 isp1362_hcd->load[ep->branch] - ep->load);
499 isp1362_hcd->load[ep->branch] -= ep->load;
500 ep->branch = PERIODIC_SIZE;
501 }
502 }
503
504 /*
505 * Analyze transfer results, handle partial transfers and errors
506 */
507 static void postproc_ep(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep)
508 {
509 struct urb *urb = get_urb(ep);
510 struct usb_device *udev;
511 struct ptd *ptd;
512 int short_ok;
513 u16 len;
514 int urbstat = -EINPROGRESS;
515 u8 cc;
516
517 DBG(2, "%s: ep %p req %d\n", __func__, ep, ep->num_req);
518
519 udev = urb->dev;
520 ptd = &ep->ptd;
521 cc = PTD_GET_CC(ptd);
522 if (cc == PTD_NOTACCESSED) {
523 pr_err("%s: req %d PTD %p Untouched by ISP1362\n", __func__,
524 ep->num_req, ptd);
525 cc = PTD_DEVNOTRESP;
526 }
527
528 short_ok = !(urb->transfer_flags & URB_SHORT_NOT_OK);
529 len = urb->transfer_buffer_length - urb->actual_length;
530
531 /* Data underrun is special. For allowed underrun
532 we clear the error and continue as normal. For
533 forbidden underrun we finish the DATA stage
534 immediately while for control transfer,
535 we do a STATUS stage.
536 */
537 if (cc == PTD_DATAUNDERRUN) {
538 if (short_ok) {
539 DBG(1, "%s: req %d Allowed data underrun short_%sok %d/%d/%d byte\n",
540 __func__, ep->num_req, short_ok ? "" : "not_",
541 PTD_GET_COUNT(ptd), ep->maxpacket, len);
542 cc = PTD_CC_NOERROR;
543 urbstat = 0;
544 } else {
545 DBG(1, "%s: req %d Data Underrun %s nextpid %02x short_%sok %d/%d/%d byte\n",
546 __func__, ep->num_req,
547 usb_pipein(urb->pipe) ? "IN" : "OUT", ep->nextpid,
548 short_ok ? "" : "not_",
549 PTD_GET_COUNT(ptd), ep->maxpacket, len);
550 if (usb_pipecontrol(urb->pipe)) {
551 ep->nextpid = USB_PID_ACK;
552 /* save the data underrun error code for later and
553 * procede with the status stage
554 */
555 urb->actual_length += PTD_GET_COUNT(ptd);
556 BUG_ON(urb->actual_length > urb->transfer_buffer_length);
557
558 if (urb->status == -EINPROGRESS)
559 urb->status = cc_to_error[PTD_DATAUNDERRUN];
560 } else {
561 usb_settoggle(udev, ep->epnum, ep->nextpid == USB_PID_OUT,
562 PTD_GET_TOGGLE(ptd));
563 urbstat = cc_to_error[PTD_DATAUNDERRUN];
564 }
565 goto out;
566 }
567 }
568
569 if (cc != PTD_CC_NOERROR) {
570 if (++ep->error_count >= 3 || cc == PTD_CC_STALL || cc == PTD_DATAOVERRUN) {
571 urbstat = cc_to_error[cc];
572 DBG(1, "%s: req %d nextpid %02x, status %d, error %d, error_count %d\n",
573 __func__, ep->num_req, ep->nextpid, urbstat, cc,
574 ep->error_count);
575 }
576 goto out;
577 }
578
579 switch (ep->nextpid) {
580 case USB_PID_OUT:
581 if (PTD_GET_COUNT(ptd) != ep->length)
582 pr_err("%s: count=%d len=%d\n", __func__,
583 PTD_GET_COUNT(ptd), ep->length);
584 BUG_ON(PTD_GET_COUNT(ptd) != ep->length);
585 urb->actual_length += ep->length;
586 BUG_ON(urb->actual_length > urb->transfer_buffer_length);
587 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd));
588 if (urb->actual_length == urb->transfer_buffer_length) {
589 DBG(3, "%s: req %d xfer complete %d/%d status %d -> 0\n", __func__,
590 ep->num_req, len, ep->maxpacket, urbstat);
591 if (usb_pipecontrol(urb->pipe)) {
592 DBG(3, "%s: req %d %s Wait for ACK\n", __func__,
593 ep->num_req,
594 usb_pipein(urb->pipe) ? "IN" : "OUT");
595 ep->nextpid = USB_PID_ACK;
596 } else {
597 if (len % ep->maxpacket ||
598 !(urb->transfer_flags & URB_ZERO_PACKET)) {
599 urbstat = 0;
600 DBG(3, "%s: req %d URB %s status %d count %d/%d/%d\n",
601 __func__, ep->num_req, usb_pipein(urb->pipe) ? "IN" : "OUT",
602 urbstat, len, ep->maxpacket, urb->actual_length);
603 }
604 }
605 }
606 break;
607 case USB_PID_IN:
608 len = PTD_GET_COUNT(ptd);
609 BUG_ON(len > ep->length);
610 urb->actual_length += len;
611 BUG_ON(urb->actual_length > urb->transfer_buffer_length);
612 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd));
613 /* if transfer completed or (allowed) data underrun */
614 if ((urb->transfer_buffer_length == urb->actual_length) ||
615 len % ep->maxpacket) {
616 DBG(3, "%s: req %d xfer complete %d/%d status %d -> 0\n", __func__,
617 ep->num_req, len, ep->maxpacket, urbstat);
618 if (usb_pipecontrol(urb->pipe)) {
619 DBG(3, "%s: req %d %s Wait for ACK\n", __func__,
620 ep->num_req,
621 usb_pipein(urb->pipe) ? "IN" : "OUT");
622 ep->nextpid = USB_PID_ACK;
623 } else {
624 urbstat = 0;
625 DBG(3, "%s: req %d URB %s status %d count %d/%d/%d\n",
626 __func__, ep->num_req, usb_pipein(urb->pipe) ? "IN" : "OUT",
627 urbstat, len, ep->maxpacket, urb->actual_length);
628 }
629 }
630 break;
631 case USB_PID_SETUP:
632 if (urb->transfer_buffer_length == urb->actual_length) {
633 ep->nextpid = USB_PID_ACK;
634 } else if (usb_pipeout(urb->pipe)) {
635 usb_settoggle(udev, 0, 1, 1);
636 ep->nextpid = USB_PID_OUT;
637 } else {
638 usb_settoggle(udev, 0, 0, 1);
639 ep->nextpid = USB_PID_IN;
640 }
641 break;
642 case USB_PID_ACK:
643 DBG(3, "%s: req %d got ACK %d -> 0\n", __func__, ep->num_req,
644 urbstat);
645 WARN_ON(urbstat != -EINPROGRESS);
646 urbstat = 0;
647 ep->nextpid = 0;
648 break;
649 default:
650 BUG_ON(1);
651 }
652
653 out:
654 if (urbstat != -EINPROGRESS) {
655 DBG(2, "%s: Finishing ep %p req %d urb %p status %d\n", __func__,
656 ep, ep->num_req, urb, urbstat);
657 finish_request(isp1362_hcd, ep, urb, urbstat);
658 }
659 }
660
661 static void finish_unlinks(struct isp1362_hcd *isp1362_hcd)
662 {
663 struct isp1362_ep *ep;
664 struct isp1362_ep *tmp;
665
666 list_for_each_entry_safe(ep, tmp, &isp1362_hcd->remove_list, remove_list) {
667 struct isp1362_ep_queue *epq =
668 get_ptd_queue(isp1362_hcd, ep->ptd_offset);
669 int index = ep->ptd_index;
670
671 BUG_ON(epq == NULL);
672 if (index >= 0) {
673 DBG(1, "%s: remove PTD[%d] $%04x\n", __func__, index, ep->ptd_offset);
674 BUG_ON(ep->num_ptds == 0);
675 release_ptd_buffers(epq, ep);
676 }
677 if (!list_empty(&ep->hep->urb_list)) {
678 struct urb *urb = get_urb(ep);
679
680 DBG(1, "%s: Finishing req %d ep %p from remove_list\n", __func__,
681 ep->num_req, ep);
682 finish_request(isp1362_hcd, ep, urb, -ESHUTDOWN);
683 }
684 WARN_ON(list_empty(&ep->active));
685 if (!list_empty(&ep->active)) {
686 list_del_init(&ep->active);
687 DBG(1, "%s: ep %p removed from active list\n", __func__, ep);
688 }
689 list_del_init(&ep->remove_list);
690 DBG(1, "%s: ep %p removed from remove_list\n", __func__, ep);
691 }
692 DBG(1, "%s: Done\n", __func__);
693 }
694
695 static inline void enable_atl_transfers(struct isp1362_hcd *isp1362_hcd, int count)
696 {
697 if (count > 0) {
698 if (count < isp1362_hcd->atl_queue.ptd_count)
699 isp1362_write_reg16(isp1362_hcd, HCATLDTC, count);
700 isp1362_enable_int(isp1362_hcd, HCuPINT_ATL);
701 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, isp1362_hcd->atl_queue.skip_map);
702 isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
703 } else
704 isp1362_enable_int(isp1362_hcd, HCuPINT_SOF);
705 }
706
707 static inline void enable_intl_transfers(struct isp1362_hcd *isp1362_hcd)
708 {
709 isp1362_enable_int(isp1362_hcd, HCuPINT_INTL);
710 isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
711 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, isp1362_hcd->intl_queue.skip_map);
712 }
713
714 static inline void enable_istl_transfers(struct isp1362_hcd *isp1362_hcd, int flip)
715 {
716 isp1362_enable_int(isp1362_hcd, flip ? HCuPINT_ISTL1 : HCuPINT_ISTL0);
717 isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, flip ?
718 HCBUFSTAT_ISTL1_FULL : HCBUFSTAT_ISTL0_FULL);
719 }
720
721 static int submit_req(struct isp1362_hcd *isp1362_hcd, struct urb *urb,
722 struct isp1362_ep *ep, struct isp1362_ep_queue *epq)
723 {
724 int index = epq->free_ptd;
725
726 prepare_ptd(isp1362_hcd, urb, ep, epq, 0);
727 index = claim_ptd_buffers(epq, ep, ep->length);
728 if (index == -ENOMEM) {
729 DBG(1, "%s: req %d No free %s PTD available: %d, %08lx:%08lx\n", __func__,
730 ep->num_req, epq->name, ep->num_ptds, epq->buf_map, epq->skip_map);
731 return index;
732 } else if (index == -EOVERFLOW) {
733 DBG(1, "%s: req %d Not enough space for %d byte %s PTD %d %08lx:%08lx\n",
734 __func__, ep->num_req, ep->length, epq->name, ep->num_ptds,
735 epq->buf_map, epq->skip_map);
736 return index;
737 } else
738 BUG_ON(index < 0);
739 list_add_tail(&ep->active, &epq->active);
740 DBG(1, "%s: ep %p req %d len %d added to active list %p\n", __func__,
741 ep, ep->num_req, ep->length, &epq->active);
742 DBG(1, "%s: Submitting %s PTD $%04x for ep %p req %d\n", __func__, epq->name,
743 ep->ptd_offset, ep, ep->num_req);
744 isp1362_write_ptd(isp1362_hcd, ep, epq);
745 __clear_bit(ep->ptd_index, &epq->skip_map);
746
747 return 0;
748 }
749
750 static void start_atl_transfers(struct isp1362_hcd *isp1362_hcd)
751 {
752 int ptd_count = 0;
753 struct isp1362_ep_queue *epq = &isp1362_hcd->atl_queue;
754 struct isp1362_ep *ep;
755 int defer = 0;
756
757 if (atomic_read(&epq->finishing)) {
758 DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
759 return;
760 }
761
762 list_for_each_entry(ep, &isp1362_hcd->async, schedule) {
763 struct urb *urb = get_urb(ep);
764 int ret;
765
766 if (!list_empty(&ep->active)) {
767 DBG(2, "%s: Skipping active %s ep %p\n", __func__, epq->name, ep);
768 continue;
769 }
770
771 DBG(1, "%s: Processing %s ep %p req %d\n", __func__, epq->name,
772 ep, ep->num_req);
773
774 ret = submit_req(isp1362_hcd, urb, ep, epq);
775 if (ret == -ENOMEM) {
776 defer = 1;
777 break;
778 } else if (ret == -EOVERFLOW) {
779 defer = 1;
780 continue;
781 }
782 #ifdef BUGGY_PXA2XX_UDC_USBTEST
783 defer = ep->nextpid == USB_PID_SETUP;
784 #endif
785 ptd_count++;
786 }
787
788 /* Avoid starving of endpoints */
789 if (isp1362_hcd->async.next != isp1362_hcd->async.prev) {
790 DBG(2, "%s: Cycling ASYNC schedule %d\n", __func__, ptd_count);
791 list_move(&isp1362_hcd->async, isp1362_hcd->async.next);
792 }
793 if (ptd_count || defer)
794 enable_atl_transfers(isp1362_hcd, defer ? 0 : ptd_count);
795
796 epq->ptd_count += ptd_count;
797 if (epq->ptd_count > epq->stat_maxptds) {
798 epq->stat_maxptds = epq->ptd_count;
799 DBG(0, "%s: max_ptds: %d\n", __func__, epq->stat_maxptds);
800 }
801 }
802
803 static void start_intl_transfers(struct isp1362_hcd *isp1362_hcd)
804 {
805 int ptd_count = 0;
806 struct isp1362_ep_queue *epq = &isp1362_hcd->intl_queue;
807 struct isp1362_ep *ep;
808
809 if (atomic_read(&epq->finishing)) {
810 DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
811 return;
812 }
813
814 list_for_each_entry(ep, &isp1362_hcd->periodic, schedule) {
815 struct urb *urb = get_urb(ep);
816 int ret;
817
818 if (!list_empty(&ep->active)) {
819 DBG(1, "%s: Skipping active %s ep %p\n", __func__,
820 epq->name, ep);
821 continue;
822 }
823
824 DBG(1, "%s: Processing %s ep %p req %d\n", __func__,
825 epq->name, ep, ep->num_req);
826 ret = submit_req(isp1362_hcd, urb, ep, epq);
827 if (ret == -ENOMEM)
828 break;
829 else if (ret == -EOVERFLOW)
830 continue;
831 ptd_count++;
832 }
833
834 if (ptd_count) {
835 static int last_count;
836
837 if (ptd_count != last_count) {
838 DBG(0, "%s: ptd_count: %d\n", __func__, ptd_count);
839 last_count = ptd_count;
840 }
841 enable_intl_transfers(isp1362_hcd);
842 }
843
844 epq->ptd_count += ptd_count;
845 if (epq->ptd_count > epq->stat_maxptds)
846 epq->stat_maxptds = epq->ptd_count;
847 }
848
849 static inline int next_ptd(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
850 {
851 u16 ptd_offset = ep->ptd_offset;
852 int num_ptds = (ep->length + PTD_HEADER_SIZE + (epq->blk_size - 1)) / epq->blk_size;
853
854 DBG(2, "%s: PTD offset $%04x + %04x => %d * %04x -> $%04x\n", __func__, ptd_offset,
855 ep->length, num_ptds, epq->blk_size, ptd_offset + num_ptds * epq->blk_size);
856
857 ptd_offset += num_ptds * epq->blk_size;
858 if (ptd_offset < epq->buf_start + epq->buf_size)
859 return ptd_offset;
860 else
861 return -ENOMEM;
862 }
863
864 static void start_iso_transfers(struct isp1362_hcd *isp1362_hcd)
865 {
866 int ptd_count = 0;
867 int flip = isp1362_hcd->istl_flip;
868 struct isp1362_ep_queue *epq;
869 int ptd_offset;
870 struct isp1362_ep *ep;
871 struct isp1362_ep *tmp;
872 u16 fno = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
873
874 fill2:
875 epq = &isp1362_hcd->istl_queue[flip];
876 if (atomic_read(&epq->finishing)) {
877 DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
878 return;
879 }
880
881 if (!list_empty(&epq->active))
882 return;
883
884 ptd_offset = epq->buf_start;
885 list_for_each_entry_safe(ep, tmp, &isp1362_hcd->isoc, schedule) {
886 struct urb *urb = get_urb(ep);
887 s16 diff = fno - (u16)urb->start_frame;
888
889 DBG(1, "%s: Processing %s ep %p\n", __func__, epq->name, ep);
890
891 if (diff > urb->number_of_packets) {
892 /* time frame for this URB has elapsed */
893 finish_request(isp1362_hcd, ep, urb, -EOVERFLOW);
894 continue;
895 } else if (diff < -1) {
896 /* URB is not due in this frame or the next one.
897 * Comparing with '-1' instead of '0' accounts for double
898 * buffering in the ISP1362 which enables us to queue the PTD
899 * one frame ahead of time
900 */
901 } else if (diff == -1) {
902 /* submit PTD's that are due in the next frame */
903 prepare_ptd(isp1362_hcd, urb, ep, epq, fno);
904 if (ptd_offset + PTD_HEADER_SIZE + ep->length >
905 epq->buf_start + epq->buf_size) {
906 pr_err("%s: Not enough ISO buffer space for %d byte PTD\n",
907 __func__, ep->length);
908 continue;
909 }
910 ep->ptd_offset = ptd_offset;
911 list_add_tail(&ep->active, &epq->active);
912
913 ptd_offset = next_ptd(epq, ep);
914 if (ptd_offset < 0) {
915 pr_warning("%s: req %d No more %s PTD buffers available\n", __func__,
916 ep->num_req, epq->name);
917 break;
918 }
919 }
920 }
921 list_for_each_entry(ep, &epq->active, active) {
922 if (epq->active.next == &ep->active)
923 ep->ptd.mps |= PTD_LAST_MSK;
924 isp1362_write_ptd(isp1362_hcd, ep, epq);
925 ptd_count++;
926 }
927
928 if (ptd_count)
929 enable_istl_transfers(isp1362_hcd, flip);
930
931 epq->ptd_count += ptd_count;
932 if (epq->ptd_count > epq->stat_maxptds)
933 epq->stat_maxptds = epq->ptd_count;
934
935 /* check, whether the second ISTL buffer may also be filled */
936 if (!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
937 (flip ? HCBUFSTAT_ISTL0_FULL : HCBUFSTAT_ISTL1_FULL))) {
938 fno++;
939 ptd_count = 0;
940 flip = 1 - flip;
941 goto fill2;
942 }
943 }
944
945 static void finish_transfers(struct isp1362_hcd *isp1362_hcd, unsigned long done_map,
946 struct isp1362_ep_queue *epq)
947 {
948 struct isp1362_ep *ep;
949 struct isp1362_ep *tmp;
950
951 if (list_empty(&epq->active)) {
952 DBG(1, "%s: Nothing to do for %s queue\n", __func__, epq->name);
953 return;
954 }
955
956 DBG(1, "%s: Finishing %s transfers %08lx\n", __func__, epq->name, done_map);
957
958 atomic_inc(&epq->finishing);
959 list_for_each_entry_safe(ep, tmp, &epq->active, active) {
960 int index = ep->ptd_index;
961
962 DBG(1, "%s: Checking %s PTD[%02x] $%04x\n", __func__, epq->name,
963 index, ep->ptd_offset);
964
965 BUG_ON(index < 0);
966 if (__test_and_clear_bit(index, &done_map)) {
967 isp1362_read_ptd(isp1362_hcd, ep, epq);
968 epq->free_ptd = index;
969 BUG_ON(ep->num_ptds == 0);
970 release_ptd_buffers(epq, ep);
971
972 DBG(1, "%s: ep %p req %d removed from active list\n", __func__,
973 ep, ep->num_req);
974 if (!list_empty(&ep->remove_list)) {
975 list_del_init(&ep->remove_list);
976 DBG(1, "%s: ep %p removed from remove list\n", __func__, ep);
977 }
978 DBG(1, "%s: Postprocessing %s ep %p req %d\n", __func__, epq->name,
979 ep, ep->num_req);
980 postproc_ep(isp1362_hcd, ep);
981 }
982 if (!done_map)
983 break;
984 }
985 if (done_map)
986 pr_warning("%s: done_map not clear: %08lx:%08lx\n", __func__, done_map,
987 epq->skip_map);
988 atomic_dec(&epq->finishing);
989 }
990
991 static void finish_iso_transfers(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep_queue *epq)
992 {
993 struct isp1362_ep *ep;
994 struct isp1362_ep *tmp;
995
996 if (list_empty(&epq->active)) {
997 DBG(1, "%s: Nothing to do for %s queue\n", __func__, epq->name);
998 return;
999 }
1000
1001 DBG(1, "%s: Finishing %s transfers\n", __func__, epq->name);
1002
1003 atomic_inc(&epq->finishing);
1004 list_for_each_entry_safe(ep, tmp, &epq->active, active) {
1005 DBG(1, "%s: Checking PTD $%04x\n", __func__, ep->ptd_offset);
1006
1007 isp1362_read_ptd(isp1362_hcd, ep, epq);
1008 DBG(1, "%s: Postprocessing %s ep %p\n", __func__, epq->name, ep);
1009 postproc_ep(isp1362_hcd, ep);
1010 }
1011 WARN_ON(epq->blk_size != 0);
1012 atomic_dec(&epq->finishing);
1013 }
1014
1015 static irqreturn_t isp1362_irq(struct usb_hcd *hcd)
1016 {
1017 int handled = 0;
1018 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1019 u16 irqstat;
1020 u16 svc_mask;
1021
1022 spin_lock(&isp1362_hcd->lock);
1023
1024 BUG_ON(isp1362_hcd->irq_active++);
1025
1026 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
1027
1028 irqstat = isp1362_read_reg16(isp1362_hcd, HCuPINT);
1029 DBG(3, "%s: got IRQ %04x:%04x\n", __func__, irqstat, isp1362_hcd->irqenb);
1030
1031 /* only handle interrupts that are currently enabled */
1032 irqstat &= isp1362_hcd->irqenb;
1033 isp1362_write_reg16(isp1362_hcd, HCuPINT, irqstat);
1034 svc_mask = irqstat;
1035
1036 if (irqstat & HCuPINT_SOF) {
1037 isp1362_hcd->irqenb &= ~HCuPINT_SOF;
1038 isp1362_hcd->irq_stat[ISP1362_INT_SOF]++;
1039 handled = 1;
1040 svc_mask &= ~HCuPINT_SOF;
1041 DBG(3, "%s: SOF\n", __func__);
1042 isp1362_hcd->fmindex = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
1043 if (!list_empty(&isp1362_hcd->remove_list))
1044 finish_unlinks(isp1362_hcd);
1045 if (!list_empty(&isp1362_hcd->async) && !(irqstat & HCuPINT_ATL)) {
1046 if (list_empty(&isp1362_hcd->atl_queue.active)) {
1047 start_atl_transfers(isp1362_hcd);
1048 } else {
1049 isp1362_enable_int(isp1362_hcd, HCuPINT_ATL);
1050 isp1362_write_reg32(isp1362_hcd, HCATLSKIP,
1051 isp1362_hcd->atl_queue.skip_map);
1052 isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
1053 }
1054 }
1055 }
1056
1057 if (irqstat & HCuPINT_ISTL0) {
1058 isp1362_hcd->irq_stat[ISP1362_INT_ISTL0]++;
1059 handled = 1;
1060 svc_mask &= ~HCuPINT_ISTL0;
1061 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ISTL0_FULL);
1062 DBG(1, "%s: ISTL0\n", __func__);
1063 WARN_ON((int)!!isp1362_hcd->istl_flip);
1064 WARN_ON(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1065 HCBUFSTAT_ISTL0_ACTIVE);
1066 WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1067 HCBUFSTAT_ISTL0_DONE));
1068 isp1362_hcd->irqenb &= ~HCuPINT_ISTL0;
1069 }
1070
1071 if (irqstat & HCuPINT_ISTL1) {
1072 isp1362_hcd->irq_stat[ISP1362_INT_ISTL1]++;
1073 handled = 1;
1074 svc_mask &= ~HCuPINT_ISTL1;
1075 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ISTL1_FULL);
1076 DBG(1, "%s: ISTL1\n", __func__);
1077 WARN_ON(!(int)isp1362_hcd->istl_flip);
1078 WARN_ON(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1079 HCBUFSTAT_ISTL1_ACTIVE);
1080 WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1081 HCBUFSTAT_ISTL1_DONE));
1082 isp1362_hcd->irqenb &= ~HCuPINT_ISTL1;
1083 }
1084
1085 if (irqstat & (HCuPINT_ISTL0 | HCuPINT_ISTL1)) {
1086 WARN_ON((irqstat & (HCuPINT_ISTL0 | HCuPINT_ISTL1)) ==
1087 (HCuPINT_ISTL0 | HCuPINT_ISTL1));
1088 finish_iso_transfers(isp1362_hcd,
1089 &isp1362_hcd->istl_queue[isp1362_hcd->istl_flip]);
1090 start_iso_transfers(isp1362_hcd);
1091 isp1362_hcd->istl_flip = 1 - isp1362_hcd->istl_flip;
1092 }
1093
1094 if (irqstat & HCuPINT_INTL) {
1095 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCINTLDONE);
1096 u32 skip_map = isp1362_read_reg32(isp1362_hcd, HCINTLSKIP);
1097 isp1362_hcd->irq_stat[ISP1362_INT_INTL]++;
1098
1099 DBG(2, "%s: INTL\n", __func__);
1100
1101 svc_mask &= ~HCuPINT_INTL;
1102
1103 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, skip_map | done_map);
1104 if (~(done_map | skip_map) == 0)
1105 /* All PTDs are finished, disable INTL processing entirely */
1106 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
1107
1108 handled = 1;
1109 WARN_ON(!done_map);
1110 if (done_map) {
1111 DBG(3, "%s: INTL done_map %08x\n", __func__, done_map);
1112 finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->intl_queue);
1113 start_intl_transfers(isp1362_hcd);
1114 }
1115 }
1116
1117 if (irqstat & HCuPINT_ATL) {
1118 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCATLDONE);
1119 u32 skip_map = isp1362_read_reg32(isp1362_hcd, HCATLSKIP);
1120 isp1362_hcd->irq_stat[ISP1362_INT_ATL]++;
1121
1122 DBG(2, "%s: ATL\n", __func__);
1123
1124 svc_mask &= ~HCuPINT_ATL;
1125
1126 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, skip_map | done_map);
1127 if (~(done_map | skip_map) == 0)
1128 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
1129 if (done_map) {
1130 DBG(3, "%s: ATL done_map %08x\n", __func__, done_map);
1131 finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->atl_queue);
1132 start_atl_transfers(isp1362_hcd);
1133 }
1134 handled = 1;
1135 }
1136
1137 if (irqstat & HCuPINT_OPR) {
1138 u32 intstat = isp1362_read_reg32(isp1362_hcd, HCINTSTAT);
1139 isp1362_hcd->irq_stat[ISP1362_INT_OPR]++;
1140
1141 svc_mask &= ~HCuPINT_OPR;
1142 DBG(2, "%s: OPR %08x:%08x\n", __func__, intstat, isp1362_hcd->intenb);
1143 intstat &= isp1362_hcd->intenb;
1144 if (intstat & OHCI_INTR_UE) {
1145 pr_err("Unrecoverable error\n");
1146 /* FIXME: do here reset or cleanup or whatever */
1147 }
1148 if (intstat & OHCI_INTR_RHSC) {
1149 isp1362_hcd->rhstatus = isp1362_read_reg32(isp1362_hcd, HCRHSTATUS);
1150 isp1362_hcd->rhport[0] = isp1362_read_reg32(isp1362_hcd, HCRHPORT1);
1151 isp1362_hcd->rhport[1] = isp1362_read_reg32(isp1362_hcd, HCRHPORT2);
1152 }
1153 if (intstat & OHCI_INTR_RD) {
1154 pr_info("%s: RESUME DETECTED\n", __func__);
1155 isp1362_show_reg(isp1362_hcd, HCCONTROL);
1156 usb_hcd_resume_root_hub(hcd);
1157 }
1158 isp1362_write_reg32(isp1362_hcd, HCINTSTAT, intstat);
1159 irqstat &= ~HCuPINT_OPR;
1160 handled = 1;
1161 }
1162
1163 if (irqstat & HCuPINT_SUSP) {
1164 isp1362_hcd->irq_stat[ISP1362_INT_SUSP]++;
1165 handled = 1;
1166 svc_mask &= ~HCuPINT_SUSP;
1167
1168 pr_info("%s: SUSPEND IRQ\n", __func__);
1169 }
1170
1171 if (irqstat & HCuPINT_CLKRDY) {
1172 isp1362_hcd->irq_stat[ISP1362_INT_CLKRDY]++;
1173 handled = 1;
1174 isp1362_hcd->irqenb &= ~HCuPINT_CLKRDY;
1175 svc_mask &= ~HCuPINT_CLKRDY;
1176 pr_info("%s: CLKRDY IRQ\n", __func__);
1177 }
1178
1179 if (svc_mask)
1180 pr_err("%s: Unserviced interrupt(s) %04x\n", __func__, svc_mask);
1181
1182 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
1183 isp1362_hcd->irq_active--;
1184 spin_unlock(&isp1362_hcd->lock);
1185
1186 return IRQ_RETVAL(handled);
1187 }
1188
1189 /*-------------------------------------------------------------------------*/
1190
1191 #define MAX_PERIODIC_LOAD 900 /* out of 1000 usec */
1192 static int balance(struct isp1362_hcd *isp1362_hcd, u16 interval, u16 load)
1193 {
1194 int i, branch = -ENOSPC;
1195
1196 /* search for the least loaded schedule branch of that interval
1197 * which has enough bandwidth left unreserved.
1198 */
1199 for (i = 0; i < interval; i++) {
1200 if (branch < 0 || isp1362_hcd->load[branch] > isp1362_hcd->load[i]) {
1201 int j;
1202
1203 for (j = i; j < PERIODIC_SIZE; j += interval) {
1204 if ((isp1362_hcd->load[j] + load) > MAX_PERIODIC_LOAD) {
1205 pr_err("%s: new load %d load[%02x] %d max %d\n", __func__,
1206 load, j, isp1362_hcd->load[j], MAX_PERIODIC_LOAD);
1207 break;
1208 }
1209 }
1210 if (j < PERIODIC_SIZE)
1211 continue;
1212 branch = i;
1213 }
1214 }
1215 return branch;
1216 }
1217
1218 /* NB! ALL the code above this point runs with isp1362_hcd->lock
1219 held, irqs off
1220 */
1221
1222 /*-------------------------------------------------------------------------*/
1223
1224 static int isp1362_urb_enqueue(struct usb_hcd *hcd,
1225 struct urb *urb,
1226 gfp_t mem_flags)
1227 {
1228 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1229 struct usb_device *udev = urb->dev;
1230 unsigned int pipe = urb->pipe;
1231 int is_out = !usb_pipein(pipe);
1232 int type = usb_pipetype(pipe);
1233 int epnum = usb_pipeendpoint(pipe);
1234 struct usb_host_endpoint *hep = urb->ep;
1235 struct isp1362_ep *ep = NULL;
1236 unsigned long flags;
1237 int retval = 0;
1238
1239 DBG(3, "%s: urb %p\n", __func__, urb);
1240
1241 if (type == PIPE_ISOCHRONOUS) {
1242 pr_err("Isochronous transfers not supported\n");
1243 return -ENOSPC;
1244 }
1245
1246 URB_DBG("%s: FA %d ep%d%s %s: len %d %s%s\n", __func__,
1247 usb_pipedevice(pipe), epnum,
1248 is_out ? "out" : "in",
1249 usb_pipecontrol(pipe) ? "ctrl" :
1250 usb_pipeint(pipe) ? "int" :
1251 usb_pipebulk(pipe) ? "bulk" :
1252 "iso",
1253 urb->transfer_buffer_length,
1254 (urb->transfer_flags & URB_ZERO_PACKET) ? "ZERO_PACKET " : "",
1255 !(urb->transfer_flags & URB_SHORT_NOT_OK) ?
1256 "short_ok" : "");
1257
1258 /* avoid all allocations within spinlocks: request or endpoint */
1259 if (!hep->hcpriv) {
1260 ep = kzalloc(sizeof *ep, mem_flags);
1261 if (!ep)
1262 return -ENOMEM;
1263 }
1264 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1265
1266 /* don't submit to a dead or disabled port */
1267 if (!((isp1362_hcd->rhport[0] | isp1362_hcd->rhport[1]) &
1268 USB_PORT_STAT_ENABLE) ||
1269 !HC_IS_RUNNING(hcd->state)) {
1270 kfree(ep);
1271 retval = -ENODEV;
1272 goto fail_not_linked;
1273 }
1274
1275 retval = usb_hcd_link_urb_to_ep(hcd, urb);
1276 if (retval) {
1277 kfree(ep);
1278 goto fail_not_linked;
1279 }
1280
1281 if (hep->hcpriv) {
1282 ep = hep->hcpriv;
1283 } else {
1284 INIT_LIST_HEAD(&ep->schedule);
1285 INIT_LIST_HEAD(&ep->active);
1286 INIT_LIST_HEAD(&ep->remove_list);
1287 ep->udev = usb_get_dev(udev);
1288 ep->hep = hep;
1289 ep->epnum = epnum;
1290 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
1291 ep->ptd_offset = -EINVAL;
1292 ep->ptd_index = -EINVAL;
1293 usb_settoggle(udev, epnum, is_out, 0);
1294
1295 if (type == PIPE_CONTROL)
1296 ep->nextpid = USB_PID_SETUP;
1297 else if (is_out)
1298 ep->nextpid = USB_PID_OUT;
1299 else
1300 ep->nextpid = USB_PID_IN;
1301
1302 switch (type) {
1303 case PIPE_ISOCHRONOUS:
1304 case PIPE_INTERRUPT:
1305 if (urb->interval > PERIODIC_SIZE)
1306 urb->interval = PERIODIC_SIZE;
1307 ep->interval = urb->interval;
1308 ep->branch = PERIODIC_SIZE;
1309 ep->load = usb_calc_bus_time(udev->speed, !is_out,
1310 (type == PIPE_ISOCHRONOUS),
1311 usb_maxpacket(udev, pipe, is_out)) / 1000;
1312 break;
1313 }
1314 hep->hcpriv = ep;
1315 }
1316 ep->num_req = isp1362_hcd->req_serial++;
1317
1318 /* maybe put endpoint into schedule */
1319 switch (type) {
1320 case PIPE_CONTROL:
1321 case PIPE_BULK:
1322 if (list_empty(&ep->schedule)) {
1323 DBG(1, "%s: Adding ep %p req %d to async schedule\n",
1324 __func__, ep, ep->num_req);
1325 list_add_tail(&ep->schedule, &isp1362_hcd->async);
1326 }
1327 break;
1328 case PIPE_ISOCHRONOUS:
1329 case PIPE_INTERRUPT:
1330 urb->interval = ep->interval;
1331
1332 /* urb submitted for already existing EP */
1333 if (ep->branch < PERIODIC_SIZE)
1334 break;
1335
1336 retval = balance(isp1362_hcd, ep->interval, ep->load);
1337 if (retval < 0) {
1338 pr_err("%s: balance returned %d\n", __func__, retval);
1339 goto fail;
1340 }
1341 ep->branch = retval;
1342 retval = 0;
1343 isp1362_hcd->fmindex = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
1344 DBG(1, "%s: Current frame %04x branch %02x start_frame %04x(%04x)\n",
1345 __func__, isp1362_hcd->fmindex, ep->branch,
1346 ((isp1362_hcd->fmindex + PERIODIC_SIZE - 1) &
1347 ~(PERIODIC_SIZE - 1)) + ep->branch,
1348 (isp1362_hcd->fmindex & (PERIODIC_SIZE - 1)) + ep->branch);
1349
1350 if (list_empty(&ep->schedule)) {
1351 if (type == PIPE_ISOCHRONOUS) {
1352 u16 frame = isp1362_hcd->fmindex;
1353
1354 frame += max_t(u16, 8, ep->interval);
1355 frame &= ~(ep->interval - 1);
1356 frame |= ep->branch;
1357 if (frame_before(frame, isp1362_hcd->fmindex))
1358 frame += ep->interval;
1359 urb->start_frame = frame;
1360
1361 DBG(1, "%s: Adding ep %p to isoc schedule\n", __func__, ep);
1362 list_add_tail(&ep->schedule, &isp1362_hcd->isoc);
1363 } else {
1364 DBG(1, "%s: Adding ep %p to periodic schedule\n", __func__, ep);
1365 list_add_tail(&ep->schedule, &isp1362_hcd->periodic);
1366 }
1367 } else
1368 DBG(1, "%s: ep %p already scheduled\n", __func__, ep);
1369
1370 DBG(2, "%s: load %d bandwidth %d -> %d\n", __func__,
1371 ep->load / ep->interval, isp1362_hcd->load[ep->branch],
1372 isp1362_hcd->load[ep->branch] + ep->load);
1373 isp1362_hcd->load[ep->branch] += ep->load;
1374 }
1375
1376 urb->hcpriv = hep;
1377 ALIGNSTAT(isp1362_hcd, urb->transfer_buffer);
1378
1379 switch (type) {
1380 case PIPE_CONTROL:
1381 case PIPE_BULK:
1382 start_atl_transfers(isp1362_hcd);
1383 break;
1384 case PIPE_INTERRUPT:
1385 start_intl_transfers(isp1362_hcd);
1386 break;
1387 case PIPE_ISOCHRONOUS:
1388 start_iso_transfers(isp1362_hcd);
1389 break;
1390 default:
1391 BUG();
1392 }
1393 fail:
1394 if (retval)
1395 usb_hcd_unlink_urb_from_ep(hcd, urb);
1396
1397
1398 fail_not_linked:
1399 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1400 if (retval)
1401 DBG(0, "%s: urb %p failed with %d\n", __func__, urb, retval);
1402 return retval;
1403 }
1404
1405 static int isp1362_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1406 {
1407 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1408 struct usb_host_endpoint *hep;
1409 unsigned long flags;
1410 struct isp1362_ep *ep;
1411 int retval = 0;
1412
1413 DBG(3, "%s: urb %p\n", __func__, urb);
1414
1415 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1416 retval = usb_hcd_check_unlink_urb(hcd, urb, status);
1417 if (retval)
1418 goto done;
1419
1420 hep = urb->hcpriv;
1421
1422 if (!hep) {
1423 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1424 return -EIDRM;
1425 }
1426
1427 ep = hep->hcpriv;
1428 if (ep) {
1429 /* In front of queue? */
1430 if (ep->hep->urb_list.next == &urb->urb_list) {
1431 if (!list_empty(&ep->active)) {
1432 DBG(1, "%s: urb %p ep %p req %d active PTD[%d] $%04x\n", __func__,
1433 urb, ep, ep->num_req, ep->ptd_index, ep->ptd_offset);
1434 /* disable processing and queue PTD for removal */
1435 remove_ptd(isp1362_hcd, ep);
1436 urb = NULL;
1437 }
1438 }
1439 if (urb) {
1440 DBG(1, "%s: Finishing ep %p req %d\n", __func__, ep,
1441 ep->num_req);
1442 finish_request(isp1362_hcd, ep, urb, status);
1443 } else
1444 DBG(1, "%s: urb %p active; wait4irq\n", __func__, urb);
1445 } else {
1446 pr_warning("%s: No EP in URB %p\n", __func__, urb);
1447 retval = -EINVAL;
1448 }
1449 done:
1450 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1451
1452 DBG(3, "%s: exit\n", __func__);
1453
1454 return retval;
1455 }
1456
1457 static void isp1362_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
1458 {
1459 struct isp1362_ep *ep = hep->hcpriv;
1460 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1461 unsigned long flags;
1462
1463 DBG(1, "%s: ep %p\n", __func__, ep);
1464 if (!ep)
1465 return;
1466 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1467 if (!list_empty(&hep->urb_list)) {
1468 if (!list_empty(&ep->active) && list_empty(&ep->remove_list)) {
1469 DBG(1, "%s: Removing ep %p req %d PTD[%d] $%04x\n", __func__,
1470 ep, ep->num_req, ep->ptd_index, ep->ptd_offset);
1471 remove_ptd(isp1362_hcd, ep);
1472 pr_info("%s: Waiting for Interrupt to clean up\n", __func__);
1473 }
1474 }
1475 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1476 /* Wait for interrupt to clear out active list */
1477 while (!list_empty(&ep->active))
1478 msleep(1);
1479
1480 DBG(1, "%s: Freeing EP %p\n", __func__, ep);
1481
1482 usb_put_dev(ep->udev);
1483 kfree(ep);
1484 hep->hcpriv = NULL;
1485 }
1486
1487 static int isp1362_get_frame(struct usb_hcd *hcd)
1488 {
1489 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1490 u32 fmnum;
1491 unsigned long flags;
1492
1493 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1494 fmnum = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
1495 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1496
1497 return (int)fmnum;
1498 }
1499
1500 /*-------------------------------------------------------------------------*/
1501
1502 /* Adapted from ohci-hub.c */
1503 static int isp1362_hub_status_data(struct usb_hcd *hcd, char *buf)
1504 {
1505 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1506 int ports, i, changed = 0;
1507 unsigned long flags;
1508
1509 if (!HC_IS_RUNNING(hcd->state))
1510 return -ESHUTDOWN;
1511
1512 /* Report no status change now, if we are scheduled to be
1513 called later */
1514 if (timer_pending(&hcd->rh_timer))
1515 return 0;
1516
1517 ports = isp1362_hcd->rhdesca & RH_A_NDP;
1518 BUG_ON(ports > 2);
1519
1520 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1521 /* init status */
1522 if (isp1362_hcd->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
1523 buf[0] = changed = 1;
1524 else
1525 buf[0] = 0;
1526
1527 for (i = 0; i < ports; i++) {
1528 u32 status = isp1362_hcd->rhport[i];
1529
1530 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC |
1531 RH_PS_OCIC | RH_PS_PRSC)) {
1532 changed = 1;
1533 buf[0] |= 1 << (i + 1);
1534 continue;
1535 }
1536
1537 if (!(status & RH_PS_CCS))
1538 continue;
1539 }
1540 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1541 return changed;
1542 }
1543
1544 static void isp1362_hub_descriptor(struct isp1362_hcd *isp1362_hcd,
1545 struct usb_hub_descriptor *desc)
1546 {
1547 u32 reg = isp1362_hcd->rhdesca;
1548
1549 DBG(3, "%s: enter\n", __func__);
1550
1551 desc->bDescriptorType = 0x29;
1552 desc->bDescLength = 9;
1553 desc->bHubContrCurrent = 0;
1554 desc->bNbrPorts = reg & 0x3;
1555 /* Power switching, device type, overcurrent. */
1556 desc->wHubCharacteristics = cpu_to_le16((reg >> 8) & 0x1f);
1557 DBG(0, "%s: hubcharacteristics = %02x\n", __func__, cpu_to_le16((reg >> 8) & 0x1f));
1558 desc->bPwrOn2PwrGood = (reg >> 24) & 0xff;
1559 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
1560 desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
1561 desc->bitmap[1] = ~0;
1562
1563 DBG(3, "%s: exit\n", __func__);
1564 }
1565
1566 /* Adapted from ohci-hub.c */
1567 static int isp1362_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
1568 u16 wIndex, char *buf, u16 wLength)
1569 {
1570 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1571 int retval = 0;
1572 unsigned long flags;
1573 unsigned long t1;
1574 int ports = isp1362_hcd->rhdesca & RH_A_NDP;
1575 u32 tmp = 0;
1576
1577 switch (typeReq) {
1578 case ClearHubFeature:
1579 DBG(0, "ClearHubFeature: ");
1580 switch (wValue) {
1581 case C_HUB_OVER_CURRENT:
1582 _DBG(0, "C_HUB_OVER_CURRENT\n");
1583 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1584 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_OCIC);
1585 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1586 case C_HUB_LOCAL_POWER:
1587 _DBG(0, "C_HUB_LOCAL_POWER\n");
1588 break;
1589 default:
1590 goto error;
1591 }
1592 break;
1593 case SetHubFeature:
1594 DBG(0, "SetHubFeature: ");
1595 switch (wValue) {
1596 case C_HUB_OVER_CURRENT:
1597 case C_HUB_LOCAL_POWER:
1598 _DBG(0, "C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1599 break;
1600 default:
1601 goto error;
1602 }
1603 break;
1604 case GetHubDescriptor:
1605 DBG(0, "GetHubDescriptor\n");
1606 isp1362_hub_descriptor(isp1362_hcd, (struct usb_hub_descriptor *)buf);
1607 break;
1608 case GetHubStatus:
1609 DBG(0, "GetHubStatus\n");
1610 put_unaligned(cpu_to_le32(0), (__le32 *) buf);
1611 break;
1612 case GetPortStatus:
1613 #ifndef VERBOSE
1614 DBG(0, "GetPortStatus\n");
1615 #endif
1616 if (!wIndex || wIndex > ports)
1617 goto error;
1618 tmp = isp1362_hcd->rhport[--wIndex];
1619 put_unaligned(cpu_to_le32(tmp), (__le32 *) buf);
1620 break;
1621 case ClearPortFeature:
1622 DBG(0, "ClearPortFeature: ");
1623 if (!wIndex || wIndex > ports)
1624 goto error;
1625 wIndex--;
1626
1627 switch (wValue) {
1628 case USB_PORT_FEAT_ENABLE:
1629 _DBG(0, "USB_PORT_FEAT_ENABLE\n");
1630 tmp = RH_PS_CCS;
1631 break;
1632 case USB_PORT_FEAT_C_ENABLE:
1633 _DBG(0, "USB_PORT_FEAT_C_ENABLE\n");
1634 tmp = RH_PS_PESC;
1635 break;
1636 case USB_PORT_FEAT_SUSPEND:
1637 _DBG(0, "USB_PORT_FEAT_SUSPEND\n");
1638 tmp = RH_PS_POCI;
1639 break;
1640 case USB_PORT_FEAT_C_SUSPEND:
1641 _DBG(0, "USB_PORT_FEAT_C_SUSPEND\n");
1642 tmp = RH_PS_PSSC;
1643 break;
1644 case USB_PORT_FEAT_POWER:
1645 _DBG(0, "USB_PORT_FEAT_POWER\n");
1646 tmp = RH_PS_LSDA;
1647
1648 break;
1649 case USB_PORT_FEAT_C_CONNECTION:
1650 _DBG(0, "USB_PORT_FEAT_C_CONNECTION\n");
1651 tmp = RH_PS_CSC;
1652 break;
1653 case USB_PORT_FEAT_C_OVER_CURRENT:
1654 _DBG(0, "USB_PORT_FEAT_C_OVER_CURRENT\n");
1655 tmp = RH_PS_OCIC;
1656 break;
1657 case USB_PORT_FEAT_C_RESET:
1658 _DBG(0, "USB_PORT_FEAT_C_RESET\n");
1659 tmp = RH_PS_PRSC;
1660 break;
1661 default:
1662 goto error;
1663 }
1664
1665 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1666 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, tmp);
1667 isp1362_hcd->rhport[wIndex] =
1668 isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1669 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1670 break;
1671 case SetPortFeature:
1672 DBG(0, "SetPortFeature: ");
1673 if (!wIndex || wIndex > ports)
1674 goto error;
1675 wIndex--;
1676 switch (wValue) {
1677 case USB_PORT_FEAT_SUSPEND:
1678 _DBG(0, "USB_PORT_FEAT_SUSPEND\n");
1679 #ifdef CONFIG_USB_OTG
1680 if (ohci->hcd.self.otg_port == (wIndex + 1) &&
1681 ohci->hcd.self.b_hnp_enable) {
1682 start_hnp(ohci);
1683 break;
1684 }
1685 #endif
1686 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1687 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PSS);
1688 isp1362_hcd->rhport[wIndex] =
1689 isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1690 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1691 break;
1692 case USB_PORT_FEAT_POWER:
1693 _DBG(0, "USB_PORT_FEAT_POWER\n");
1694 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1695 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PPS);
1696 isp1362_hcd->rhport[wIndex] =
1697 isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1698 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1699 break;
1700 case USB_PORT_FEAT_RESET:
1701 _DBG(0, "USB_PORT_FEAT_RESET\n");
1702 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1703
1704 t1 = jiffies + msecs_to_jiffies(USB_RESET_WIDTH);
1705 while (time_before(jiffies, t1)) {
1706 /* spin until any current reset finishes */
1707 for (;;) {
1708 tmp = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1709 if (!(tmp & RH_PS_PRS))
1710 break;
1711 udelay(500);
1712 }
1713 if (!(tmp & RH_PS_CCS))
1714 break;
1715 /* Reset lasts 10ms (claims datasheet) */
1716 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, (RH_PS_PRS));
1717
1718 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1719 msleep(10);
1720 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1721 }
1722
1723 isp1362_hcd->rhport[wIndex] = isp1362_read_reg32(isp1362_hcd,
1724 HCRHPORT1 + wIndex);
1725 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1726 break;
1727 default:
1728 goto error;
1729 }
1730 break;
1731
1732 default:
1733 error:
1734 /* "protocol stall" on error */
1735 _DBG(0, "PROTOCOL STALL\n");
1736 retval = -EPIPE;
1737 }
1738
1739 return retval;
1740 }
1741
1742 #ifdef CONFIG_PM
1743 static int isp1362_bus_suspend(struct usb_hcd *hcd)
1744 {
1745 int status = 0;
1746 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1747 unsigned long flags;
1748
1749 if (time_before(jiffies, isp1362_hcd->next_statechange))
1750 msleep(5);
1751
1752 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1753
1754 isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1755 switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
1756 case OHCI_USB_RESUME:
1757 DBG(0, "%s: resume/suspend?\n", __func__);
1758 isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
1759 isp1362_hcd->hc_control |= OHCI_USB_RESET;
1760 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1761 /* FALL THROUGH */
1762 case OHCI_USB_RESET:
1763 status = -EBUSY;
1764 pr_warning("%s: needs reinit!\n", __func__);
1765 goto done;
1766 case OHCI_USB_SUSPEND:
1767 pr_warning("%s: already suspended?\n", __func__);
1768 goto done;
1769 }
1770 DBG(0, "%s: suspend root hub\n", __func__);
1771
1772 /* First stop any processing */
1773 hcd->state = HC_STATE_QUIESCING;
1774 if (!list_empty(&isp1362_hcd->atl_queue.active) ||
1775 !list_empty(&isp1362_hcd->intl_queue.active) ||
1776 !list_empty(&isp1362_hcd->istl_queue[0] .active) ||
1777 !list_empty(&isp1362_hcd->istl_queue[1] .active)) {
1778 int limit;
1779
1780 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
1781 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
1782 isp1362_write_reg16(isp1362_hcd, HCBUFSTAT, 0);
1783 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
1784 isp1362_write_reg32(isp1362_hcd, HCINTSTAT, OHCI_INTR_SF);
1785
1786 DBG(0, "%s: stopping schedules ...\n", __func__);
1787 limit = 2000;
1788 while (limit > 0) {
1789 udelay(250);
1790 limit -= 250;
1791 if (isp1362_read_reg32(isp1362_hcd, HCINTSTAT) & OHCI_INTR_SF)
1792 break;
1793 }
1794 mdelay(7);
1795 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ATL) {
1796 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCATLDONE);
1797 finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->atl_queue);
1798 }
1799 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_INTL) {
1800 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCINTLDONE);
1801 finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->intl_queue);
1802 }
1803 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL0)
1804 finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[0]);
1805 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL1)
1806 finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[1]);
1807 }
1808 DBG(0, "%s: HCINTSTAT: %08x\n", __func__,
1809 isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
1810 isp1362_write_reg32(isp1362_hcd, HCINTSTAT,
1811 isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
1812
1813 /* Suspend hub */
1814 isp1362_hcd->hc_control = OHCI_USB_SUSPEND;
1815 isp1362_show_reg(isp1362_hcd, HCCONTROL);
1816 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1817 isp1362_show_reg(isp1362_hcd, HCCONTROL);
1818
1819 #if 1
1820 isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1821 if ((isp1362_hcd->hc_control & OHCI_CTRL_HCFS) != OHCI_USB_SUSPEND) {
1822 pr_err("%s: controller won't suspend %08x\n", __func__,
1823 isp1362_hcd->hc_control);
1824 status = -EBUSY;
1825 } else
1826 #endif
1827 {
1828 /* no resumes until devices finish suspending */
1829 isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(5);
1830 }
1831 done:
1832 if (status == 0) {
1833 hcd->state = HC_STATE_SUSPENDED;
1834 DBG(0, "%s: HCD suspended: %08x\n", __func__,
1835 isp1362_read_reg32(isp1362_hcd, HCCONTROL));
1836 }
1837 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1838 return status;
1839 }
1840
1841 static int isp1362_bus_resume(struct usb_hcd *hcd)
1842 {
1843 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1844 u32 port;
1845 unsigned long flags;
1846 int status = -EINPROGRESS;
1847
1848 if (time_before(jiffies, isp1362_hcd->next_statechange))
1849 msleep(5);
1850
1851 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1852 isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1853 pr_info("%s: HCCONTROL: %08x\n", __func__, isp1362_hcd->hc_control);
1854 if (hcd->state == HC_STATE_RESUMING) {
1855 pr_warning("%s: duplicate resume\n", __func__);
1856 status = 0;
1857 } else
1858 switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
1859 case OHCI_USB_SUSPEND:
1860 DBG(0, "%s: resume root hub\n", __func__);
1861 isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
1862 isp1362_hcd->hc_control |= OHCI_USB_RESUME;
1863 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1864 break;
1865 case OHCI_USB_RESUME:
1866 /* HCFS changes sometime after INTR_RD */
1867 DBG(0, "%s: remote wakeup\n", __func__);
1868 break;
1869 case OHCI_USB_OPER:
1870 DBG(0, "%s: odd resume\n", __func__);
1871 status = 0;
1872 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1873 break;
1874 default: /* RESET, we lost power */
1875 DBG(0, "%s: root hub hardware reset\n", __func__);
1876 status = -EBUSY;
1877 }
1878 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1879 if (status == -EBUSY) {
1880 DBG(0, "%s: Restarting HC\n", __func__);
1881 isp1362_hc_stop(hcd);
1882 return isp1362_hc_start(hcd);
1883 }
1884 if (status != -EINPROGRESS)
1885 return status;
1886 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1887 port = isp1362_read_reg32(isp1362_hcd, HCRHDESCA) & RH_A_NDP;
1888 while (port--) {
1889 u32 stat = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + port);
1890
1891 /* force global, not selective, resume */
1892 if (!(stat & RH_PS_PSS)) {
1893 DBG(0, "%s: Not Resuming RH port %d\n", __func__, port);
1894 continue;
1895 }
1896 DBG(0, "%s: Resuming RH port %d\n", __func__, port);
1897 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + port, RH_PS_POCI);
1898 }
1899 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1900
1901 /* Some controllers (lucent) need extra-long delays */
1902 hcd->state = HC_STATE_RESUMING;
1903 mdelay(20 /* usb 11.5.1.10 */ + 15);
1904
1905 isp1362_hcd->hc_control = OHCI_USB_OPER;
1906 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1907 isp1362_show_reg(isp1362_hcd, HCCONTROL);
1908 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1909 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1910 /* TRSMRCY */
1911 msleep(10);
1912
1913 /* keep it alive for ~5x suspend + resume costs */
1914 isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(250);
1915
1916 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1917 hcd->state = HC_STATE_RUNNING;
1918 return 0;
1919 }
1920 #else
1921 #define isp1362_bus_suspend NULL
1922 #define isp1362_bus_resume NULL
1923 #endif
1924
1925 /*-------------------------------------------------------------------------*/
1926
1927 #ifdef STUB_DEBUG_FILE
1928
1929 static inline void create_debug_file(struct isp1362_hcd *isp1362_hcd)
1930 {
1931 }
1932 static inline void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
1933 {
1934 }
1935
1936 #else
1937
1938 #include <linux/proc_fs.h>
1939 #include <linux/seq_file.h>
1940
1941 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1942 {
1943 seq_printf(s, "%-15s %04x%s%s%s%s%s%s\n", label, mask,
1944 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1945 mask & HCuPINT_SUSP ? " susp" : "",
1946 mask & HCuPINT_OPR ? " opr" : "",
1947 mask & HCuPINT_EOT ? " eot" : "",
1948 mask & HCuPINT_ATL ? " atl" : "",
1949 mask & HCuPINT_SOF ? " sof" : "");
1950 }
1951
1952 static void dump_int(struct seq_file *s, char *label, u32 mask)
1953 {
1954 seq_printf(s, "%-15s %08x%s%s%s%s%s%s%s\n", label, mask,
1955 mask & OHCI_INTR_MIE ? " MIE" : "",
1956 mask & OHCI_INTR_RHSC ? " rhsc" : "",
1957 mask & OHCI_INTR_FNO ? " fno" : "",
1958 mask & OHCI_INTR_UE ? " ue" : "",
1959 mask & OHCI_INTR_RD ? " rd" : "",
1960 mask & OHCI_INTR_SF ? " sof" : "",
1961 mask & OHCI_INTR_SO ? " so" : "");
1962 }
1963
1964 static void dump_ctrl(struct seq_file *s, char *label, u32 mask)
1965 {
1966 seq_printf(s, "%-15s %08x%s%s%s\n", label, mask,
1967 mask & OHCI_CTRL_RWC ? " rwc" : "",
1968 mask & OHCI_CTRL_RWE ? " rwe" : "",
1969 ({
1970 char *hcfs;
1971 switch (mask & OHCI_CTRL_HCFS) {
1972 case OHCI_USB_OPER:
1973 hcfs = " oper";
1974 break;
1975 case OHCI_USB_RESET:
1976 hcfs = " reset";
1977 break;
1978 case OHCI_USB_RESUME:
1979 hcfs = " resume";
1980 break;
1981 case OHCI_USB_SUSPEND:
1982 hcfs = " suspend";
1983 break;
1984 default:
1985 hcfs = " ?";
1986 }
1987 hcfs;
1988 }));
1989 }
1990
1991 static void dump_regs(struct seq_file *s, struct isp1362_hcd *isp1362_hcd)
1992 {
1993 seq_printf(s, "HCREVISION [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCREVISION),
1994 isp1362_read_reg32(isp1362_hcd, HCREVISION));
1995 seq_printf(s, "HCCONTROL [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCONTROL),
1996 isp1362_read_reg32(isp1362_hcd, HCCONTROL));
1997 seq_printf(s, "HCCMDSTAT [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCMDSTAT),
1998 isp1362_read_reg32(isp1362_hcd, HCCMDSTAT));
1999 seq_printf(s, "HCINTSTAT [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTSTAT),
2000 isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
2001 seq_printf(s, "HCINTENB [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTENB),
2002 isp1362_read_reg32(isp1362_hcd, HCINTENB));
2003 seq_printf(s, "HCFMINTVL [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMINTVL),
2004 isp1362_read_reg32(isp1362_hcd, HCFMINTVL));
2005 seq_printf(s, "HCFMREM [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMREM),
2006 isp1362_read_reg32(isp1362_hcd, HCFMREM));
2007 seq_printf(s, "HCFMNUM [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMNUM),
2008 isp1362_read_reg32(isp1362_hcd, HCFMNUM));
2009 seq_printf(s, "HCLSTHRESH [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCLSTHRESH),
2010 isp1362_read_reg32(isp1362_hcd, HCLSTHRESH));
2011 seq_printf(s, "HCRHDESCA [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCA),
2012 isp1362_read_reg32(isp1362_hcd, HCRHDESCA));
2013 seq_printf(s, "HCRHDESCB [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCB),
2014 isp1362_read_reg32(isp1362_hcd, HCRHDESCB));
2015 seq_printf(s, "HCRHSTATUS [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHSTATUS),
2016 isp1362_read_reg32(isp1362_hcd, HCRHSTATUS));
2017 seq_printf(s, "HCRHPORT1 [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT1),
2018 isp1362_read_reg32(isp1362_hcd, HCRHPORT1));
2019 seq_printf(s, "HCRHPORT2 [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT2),
2020 isp1362_read_reg32(isp1362_hcd, HCRHPORT2));
2021 seq_printf(s, "\n");
2022 seq_printf(s, "HCHWCFG [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCHWCFG),
2023 isp1362_read_reg16(isp1362_hcd, HCHWCFG));
2024 seq_printf(s, "HCDMACFG [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCDMACFG),
2025 isp1362_read_reg16(isp1362_hcd, HCDMACFG));
2026 seq_printf(s, "HCXFERCTR [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCXFERCTR),
2027 isp1362_read_reg16(isp1362_hcd, HCXFERCTR));
2028 seq_printf(s, "HCuPINT [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINT),
2029 isp1362_read_reg16(isp1362_hcd, HCuPINT));
2030 seq_printf(s, "HCuPINTENB [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINTENB),
2031 isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
2032 seq_printf(s, "HCCHIPID [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCCHIPID),
2033 isp1362_read_reg16(isp1362_hcd, HCCHIPID));
2034 seq_printf(s, "HCSCRATCH [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCSCRATCH),
2035 isp1362_read_reg16(isp1362_hcd, HCSCRATCH));
2036 seq_printf(s, "HCBUFSTAT [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCBUFSTAT),
2037 isp1362_read_reg16(isp1362_hcd, HCBUFSTAT));
2038 seq_printf(s, "HCDIRADDR [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCDIRADDR),
2039 isp1362_read_reg32(isp1362_hcd, HCDIRADDR));
2040 #if 0
2041 seq_printf(s, "HCDIRDATA [%02x] %04x\n", ISP1362_REG_NO(HCDIRDATA),
2042 isp1362_read_reg16(isp1362_hcd, HCDIRDATA));
2043 #endif
2044 seq_printf(s, "HCISTLBUFSZ[%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLBUFSZ),
2045 isp1362_read_reg16(isp1362_hcd, HCISTLBUFSZ));
2046 seq_printf(s, "HCISTLRATE [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLRATE),
2047 isp1362_read_reg16(isp1362_hcd, HCISTLRATE));
2048 seq_printf(s, "\n");
2049 seq_printf(s, "HCINTLBUFSZ[%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBUFSZ),
2050 isp1362_read_reg16(isp1362_hcd, HCINTLBUFSZ));
2051 seq_printf(s, "HCINTLBLKSZ[%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBLKSZ),
2052 isp1362_read_reg16(isp1362_hcd, HCINTLBLKSZ));
2053 seq_printf(s, "HCINTLDONE [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLDONE),
2054 isp1362_read_reg32(isp1362_hcd, HCINTLDONE));
2055 seq_printf(s, "HCINTLSKIP [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLSKIP),
2056 isp1362_read_reg32(isp1362_hcd, HCINTLSKIP));
2057 seq_printf(s, "HCINTLLAST [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLLAST),
2058 isp1362_read_reg32(isp1362_hcd, HCINTLLAST));
2059 seq_printf(s, "HCINTLCURR [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLCURR),
2060 isp1362_read_reg16(isp1362_hcd, HCINTLCURR));
2061 seq_printf(s, "\n");
2062 seq_printf(s, "HCATLBUFSZ [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBUFSZ),
2063 isp1362_read_reg16(isp1362_hcd, HCATLBUFSZ));
2064 seq_printf(s, "HCATLBLKSZ [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBLKSZ),
2065 isp1362_read_reg16(isp1362_hcd, HCATLBLKSZ));
2066 #if 0
2067 seq_printf(s, "HCATLDONE [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDONE),
2068 isp1362_read_reg32(isp1362_hcd, HCATLDONE));
2069 #endif
2070 seq_printf(s, "HCATLSKIP [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLSKIP),
2071 isp1362_read_reg32(isp1362_hcd, HCATLSKIP));
2072 seq_printf(s, "HCATLLAST [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLLAST),
2073 isp1362_read_reg32(isp1362_hcd, HCATLLAST));
2074 seq_printf(s, "HCATLCURR [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLCURR),
2075 isp1362_read_reg16(isp1362_hcd, HCATLCURR));
2076 seq_printf(s, "\n");
2077 seq_printf(s, "HCATLDTC [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTC),
2078 isp1362_read_reg16(isp1362_hcd, HCATLDTC));
2079 seq_printf(s, "HCATLDTCTO [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTCTO),
2080 isp1362_read_reg16(isp1362_hcd, HCATLDTCTO));
2081 }
2082
2083 static int proc_isp1362_show(struct seq_file *s, void *unused)
2084 {
2085 struct isp1362_hcd *isp1362_hcd = s->private;
2086 struct isp1362_ep *ep;
2087 int i;
2088
2089 seq_printf(s, "%s\n%s version %s\n",
2090 isp1362_hcd_to_hcd(isp1362_hcd)->product_desc, hcd_name, DRIVER_VERSION);
2091
2092 /* collect statistics to help estimate potential win for
2093 * DMA engines that care about alignment (PXA)
2094 */
2095 seq_printf(s, "alignment: 16b/%ld 8b/%ld 4b/%ld 2b/%ld 1b/%ld\n",
2096 isp1362_hcd->stat16, isp1362_hcd->stat8, isp1362_hcd->stat4,
2097 isp1362_hcd->stat2, isp1362_hcd->stat1);
2098 seq_printf(s, "max # ptds in ATL fifo: %d\n", isp1362_hcd->atl_queue.stat_maxptds);
2099 seq_printf(s, "max # ptds in INTL fifo: %d\n", isp1362_hcd->intl_queue.stat_maxptds);
2100 seq_printf(s, "max # ptds in ISTL fifo: %d\n",
2101 max(isp1362_hcd->istl_queue[0] .stat_maxptds,
2102 isp1362_hcd->istl_queue[1] .stat_maxptds));
2103
2104 /* FIXME: don't show the following in suspended state */
2105 spin_lock_irq(&isp1362_hcd->lock);
2106
2107 dump_irq(s, "hc_irq_enable", isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
2108 dump_irq(s, "hc_irq_status", isp1362_read_reg16(isp1362_hcd, HCuPINT));
2109 dump_int(s, "ohci_int_enable", isp1362_read_reg32(isp1362_hcd, HCINTENB));
2110 dump_int(s, "ohci_int_status", isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
2111 dump_ctrl(s, "ohci_control", isp1362_read_reg32(isp1362_hcd, HCCONTROL));
2112
2113 for (i = 0; i < NUM_ISP1362_IRQS; i++)
2114 if (isp1362_hcd->irq_stat[i])
2115 seq_printf(s, "%-15s: %d\n",
2116 ISP1362_INT_NAME(i), isp1362_hcd->irq_stat[i]);
2117
2118 dump_regs(s, isp1362_hcd);
2119 list_for_each_entry(ep, &isp1362_hcd->async, schedule) {
2120 struct urb *urb;
2121
2122 seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep, ep->epnum,
2123 ({
2124 char *s;
2125 switch (ep->nextpid) {
2126 case USB_PID_IN:
2127 s = "in";
2128 break;
2129 case USB_PID_OUT:
2130 s = "out";
2131 break;
2132 case USB_PID_SETUP:
2133 s = "setup";
2134 break;
2135 case USB_PID_ACK:
2136 s = "status";
2137 break;
2138 default:
2139 s = "?";
2140 break;
2141 };
2142 s;}), ep->maxpacket) ;
2143 list_for_each_entry(urb, &ep->hep->urb_list, urb_list) {
2144 seq_printf(s, " urb%p, %d/%d\n", urb,
2145 urb->actual_length,
2146 urb->transfer_buffer_length);
2147 }
2148 }
2149 if (!list_empty(&isp1362_hcd->async))
2150 seq_printf(s, "\n");
2151 dump_ptd_queue(&isp1362_hcd->atl_queue);
2152
2153 seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
2154
2155 list_for_each_entry(ep, &isp1362_hcd->periodic, schedule) {
2156 seq_printf(s, "branch:%2d load:%3d PTD[%d] $%04x:\n", ep->branch,
2157 isp1362_hcd->load[ep->branch], ep->ptd_index, ep->ptd_offset);
2158
2159 seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n",
2160 ep->interval, ep,
2161 (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
2162 ep->udev->devnum, ep->epnum,
2163 (ep->epnum == 0) ? "" :
2164 ((ep->nextpid == USB_PID_IN) ?
2165 "in" : "out"), ep->maxpacket);
2166 }
2167 dump_ptd_queue(&isp1362_hcd->intl_queue);
2168
2169 seq_printf(s, "ISO:\n");
2170
2171 list_for_each_entry(ep, &isp1362_hcd->isoc, schedule) {
2172 seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n",
2173 ep->interval, ep,
2174 (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
2175 ep->udev->devnum, ep->epnum,
2176 (ep->epnum == 0) ? "" :
2177 ((ep->nextpid == USB_PID_IN) ?
2178 "in" : "out"), ep->maxpacket);
2179 }
2180
2181 spin_unlock_irq(&isp1362_hcd->lock);
2182 seq_printf(s, "\n");
2183
2184 return 0;
2185 }
2186
2187 static int proc_isp1362_open(struct inode *inode, struct file *file)
2188 {
2189 return single_open(file, proc_isp1362_show, PDE(inode)->data);
2190 }
2191
2192 static const struct file_operations proc_ops = {
2193 .open = proc_isp1362_open,
2194 .read = seq_read,
2195 .llseek = seq_lseek,
2196 .release = single_release,
2197 };
2198
2199 /* expect just one isp1362_hcd per system */
2200 static const char proc_filename[] = "driver/isp1362";
2201
2202 static void create_debug_file(struct isp1362_hcd *isp1362_hcd)
2203 {
2204 struct proc_dir_entry *pde;
2205
2206 pde = create_proc_entry(proc_filename, 0, NULL);
2207 if (pde == NULL) {
2208 pr_warning("%s: Failed to create debug file '%s'\n", __func__, proc_filename);
2209 return;
2210 }
2211
2212 pde->proc_fops = &proc_ops;
2213 pde->data = isp1362_hcd;
2214 isp1362_hcd->pde = pde;
2215 }
2216
2217 static void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
2218 {
2219 if (isp1362_hcd->pde)
2220 remove_proc_entry(proc_filename, NULL);
2221 }
2222
2223 #endif
2224
2225 /*-------------------------------------------------------------------------*/
2226
2227 static void __isp1362_sw_reset(struct isp1362_hcd *isp1362_hcd)
2228 {
2229 int tmp = 20;
2230
2231 isp1362_write_reg16(isp1362_hcd, HCSWRES, HCSWRES_MAGIC);
2232 isp1362_write_reg32(isp1362_hcd, HCCMDSTAT, OHCI_HCR);
2233 while (--tmp) {
2234 mdelay(1);
2235 if (!(isp1362_read_reg32(isp1362_hcd, HCCMDSTAT) & OHCI_HCR))
2236 break;
2237 }
2238 if (!tmp)
2239 pr_err("Software reset timeout\n");
2240 }
2241
2242 static void isp1362_sw_reset(struct isp1362_hcd *isp1362_hcd)
2243 {
2244 unsigned long flags;
2245
2246 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2247 __isp1362_sw_reset(isp1362_hcd);
2248 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2249 }
2250
2251 static int isp1362_mem_config(struct usb_hcd *hcd)
2252 {
2253 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2254 unsigned long flags;
2255 u32 total;
2256 u16 istl_size = ISP1362_ISTL_BUFSIZE;
2257 u16 intl_blksize = ISP1362_INTL_BLKSIZE + PTD_HEADER_SIZE;
2258 u16 intl_size = ISP1362_INTL_BUFFERS * intl_blksize;
2259 u16 atl_blksize = ISP1362_ATL_BLKSIZE + PTD_HEADER_SIZE;
2260 u16 atl_buffers = (ISP1362_BUF_SIZE - (istl_size + intl_size)) / atl_blksize;
2261 u16 atl_size;
2262 int i;
2263
2264 WARN_ON(istl_size & 3);
2265 WARN_ON(atl_blksize & 3);
2266 WARN_ON(intl_blksize & 3);
2267 WARN_ON(atl_blksize < PTD_HEADER_SIZE);
2268 WARN_ON(intl_blksize < PTD_HEADER_SIZE);
2269
2270 BUG_ON((unsigned)ISP1362_INTL_BUFFERS > 32);
2271 if (atl_buffers > 32)
2272 atl_buffers = 32;
2273 atl_size = atl_buffers * atl_blksize;
2274 total = atl_size + intl_size + istl_size;
2275 dev_info(hcd->self.controller, "ISP1362 Memory usage:\n");
2276 dev_info(hcd->self.controller, " ISTL: 2 * %4d: %4d @ $%04x:$%04x\n",
2277 istl_size / 2, istl_size, 0, istl_size / 2);
2278 dev_info(hcd->self.controller, " INTL: %4d * (%3zu+8): %4d @ $%04x\n",
2279 ISP1362_INTL_BUFFERS, intl_blksize - PTD_HEADER_SIZE,
2280 intl_size, istl_size);
2281 dev_info(hcd->self.controller, " ATL : %4d * (%3zu+8): %4d @ $%04x\n",
2282 atl_buffers, atl_blksize - PTD_HEADER_SIZE,
2283 atl_size, istl_size + intl_size);
2284 dev_info(hcd->self.controller, " USED/FREE: %4d %4d\n", total,
2285 ISP1362_BUF_SIZE - total);
2286
2287 if (total > ISP1362_BUF_SIZE) {
2288 dev_err(hcd->self.controller, "%s: Memory requested: %d, available %d\n",
2289 __func__, total, ISP1362_BUF_SIZE);
2290 return -ENOMEM;
2291 }
2292
2293 total = istl_size + intl_size + atl_size;
2294 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2295
2296 for (i = 0; i < 2; i++) {
2297 isp1362_hcd->istl_queue[i].buf_start = i * istl_size / 2,
2298 isp1362_hcd->istl_queue[i].buf_size = istl_size / 2;
2299 isp1362_hcd->istl_queue[i].blk_size = 4;
2300 INIT_LIST_HEAD(&isp1362_hcd->istl_queue[i].active);
2301 snprintf(isp1362_hcd->istl_queue[i].name,
2302 sizeof(isp1362_hcd->istl_queue[i].name), "ISTL%d", i);
2303 DBG(3, "%s: %5s buf $%04x %d\n", __func__,
2304 isp1362_hcd->istl_queue[i].name,
2305 isp1362_hcd->istl_queue[i].buf_start,
2306 isp1362_hcd->istl_queue[i].buf_size);
2307 }
2308 isp1362_write_reg16(isp1362_hcd, HCISTLBUFSZ, istl_size / 2);
2309
2310 isp1362_hcd->intl_queue.buf_start = istl_size;
2311 isp1362_hcd->intl_queue.buf_size = intl_size;
2312 isp1362_hcd->intl_queue.buf_count = ISP1362_INTL_BUFFERS;
2313 isp1362_hcd->intl_queue.blk_size = intl_blksize;
2314 isp1362_hcd->intl_queue.buf_avail = isp1362_hcd->intl_queue.buf_count;
2315 isp1362_hcd->intl_queue.skip_map = ~0;
2316 INIT_LIST_HEAD(&isp1362_hcd->intl_queue.active);
2317
2318 isp1362_write_reg16(isp1362_hcd, HCINTLBUFSZ,
2319 isp1362_hcd->intl_queue.buf_size);
2320 isp1362_write_reg16(isp1362_hcd, HCINTLBLKSZ,
2321 isp1362_hcd->intl_queue.blk_size - PTD_HEADER_SIZE);
2322 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
2323 isp1362_write_reg32(isp1362_hcd, HCINTLLAST,
2324 1 << (ISP1362_INTL_BUFFERS - 1));
2325
2326 isp1362_hcd->atl_queue.buf_start = istl_size + intl_size;
2327 isp1362_hcd->atl_queue.buf_size = atl_size;
2328 isp1362_hcd->atl_queue.buf_count = atl_buffers;
2329 isp1362_hcd->atl_queue.blk_size = atl_blksize;
2330 isp1362_hcd->atl_queue.buf_avail = isp1362_hcd->atl_queue.buf_count;
2331 isp1362_hcd->atl_queue.skip_map = ~0;
2332 INIT_LIST_HEAD(&isp1362_hcd->atl_queue.active);
2333
2334 isp1362_write_reg16(isp1362_hcd, HCATLBUFSZ,
2335 isp1362_hcd->atl_queue.buf_size);
2336 isp1362_write_reg16(isp1362_hcd, HCATLBLKSZ,
2337 isp1362_hcd->atl_queue.blk_size - PTD_HEADER_SIZE);
2338 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
2339 isp1362_write_reg32(isp1362_hcd, HCATLLAST,
2340 1 << (atl_buffers - 1));
2341
2342 snprintf(isp1362_hcd->atl_queue.name,
2343 sizeof(isp1362_hcd->atl_queue.name), "ATL");
2344 snprintf(isp1362_hcd->intl_queue.name,
2345 sizeof(isp1362_hcd->intl_queue.name), "INTL");
2346 DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
2347 isp1362_hcd->intl_queue.name,
2348 isp1362_hcd->intl_queue.buf_start,
2349 ISP1362_INTL_BUFFERS, isp1362_hcd->intl_queue.blk_size,
2350 isp1362_hcd->intl_queue.buf_size);
2351 DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
2352 isp1362_hcd->atl_queue.name,
2353 isp1362_hcd->atl_queue.buf_start,
2354 atl_buffers, isp1362_hcd->atl_queue.blk_size,
2355 isp1362_hcd->atl_queue.buf_size);
2356
2357 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2358
2359 return 0;
2360 }
2361
2362 static int isp1362_hc_reset(struct usb_hcd *hcd)
2363 {
2364 int ret = 0;
2365 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2366 unsigned long t;
2367 unsigned long timeout = 100;
2368 unsigned long flags;
2369 int clkrdy = 0;
2370
2371 pr_info("%s:\n", __func__);
2372
2373 if (isp1362_hcd->board && isp1362_hcd->board->reset) {
2374 isp1362_hcd->board->reset(hcd->self.controller, 1);
2375 msleep(20);
2376 if (isp1362_hcd->board->clock)
2377 isp1362_hcd->board->clock(hcd->self.controller, 1);
2378 isp1362_hcd->board->reset(hcd->self.controller, 0);
2379 } else
2380 isp1362_sw_reset(isp1362_hcd);
2381
2382 /* chip has been reset. First we need to see a clock */
2383 t = jiffies + msecs_to_jiffies(timeout);
2384 while (!clkrdy && time_before_eq(jiffies, t)) {
2385 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2386 clkrdy = isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_CLKRDY;
2387 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2388 if (!clkrdy)
2389 msleep(4);
2390 }
2391
2392 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2393 isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_CLKRDY);
2394 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2395 if (!clkrdy) {
2396 pr_err("Clock not ready after %lums\n", timeout);
2397 ret = -ENODEV;
2398 }
2399 return ret;
2400 }
2401
2402 static void isp1362_hc_stop(struct usb_hcd *hcd)
2403 {
2404 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2405 unsigned long flags;
2406 u32 tmp;
2407
2408 pr_info("%s:\n", __func__);
2409
2410 del_timer_sync(&hcd->rh_timer);
2411
2412 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2413
2414 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
2415
2416 /* Switch off power for all ports */
2417 tmp = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
2418 tmp &= ~(RH_A_NPS | RH_A_PSM);
2419 isp1362_write_reg32(isp1362_hcd, HCRHDESCA, tmp);
2420 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
2421
2422 /* Reset the chip */
2423 if (isp1362_hcd->board && isp1362_hcd->board->reset)
2424 isp1362_hcd->board->reset(hcd->self.controller, 1);
2425 else
2426 __isp1362_sw_reset(isp1362_hcd);
2427
2428 if (isp1362_hcd->board && isp1362_hcd->board->clock)
2429 isp1362_hcd->board->clock(hcd->self.controller, 0);
2430
2431 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2432 }
2433
2434 #ifdef CHIP_BUFFER_TEST
2435 static int isp1362_chip_test(struct isp1362_hcd *isp1362_hcd)
2436 {
2437 int ret = 0;
2438 u16 *ref;
2439 unsigned long flags;
2440
2441 ref = kmalloc(2 * ISP1362_BUF_SIZE, GFP_KERNEL);
2442 if (ref) {
2443 int offset;
2444 u16 *tst = &ref[ISP1362_BUF_SIZE / 2];
2445
2446 for (offset = 0; offset < ISP1362_BUF_SIZE / 2; offset++) {
2447 ref[offset] = ~offset;
2448 tst[offset] = offset;
2449 }
2450
2451 for (offset = 0; offset < 4; offset++) {
2452 int j;
2453
2454 for (j = 0; j < 8; j++) {
2455 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2456 isp1362_write_buffer(isp1362_hcd, (u8 *)ref + offset, 0, j);
2457 isp1362_read_buffer(isp1362_hcd, (u8 *)tst + offset, 0, j);
2458 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2459
2460 if (memcmp(ref, tst, j)) {
2461 ret = -ENODEV;
2462 pr_err("%s: memory check with %d byte offset %d failed\n",
2463 __func__, j, offset);
2464 dump_data((u8 *)ref + offset, j);
2465 dump_data((u8 *)tst + offset, j);
2466 }
2467 }
2468 }
2469
2470 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2471 isp1362_write_buffer(isp1362_hcd, ref, 0, ISP1362_BUF_SIZE);
2472 isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2473 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2474
2475 if (memcmp(ref, tst, ISP1362_BUF_SIZE)) {
2476 ret = -ENODEV;
2477 pr_err("%s: memory check failed\n", __func__);
2478 dump_data((u8 *)tst, ISP1362_BUF_SIZE / 2);
2479 }
2480
2481 for (offset = 0; offset < 256; offset++) {
2482 int test_size = 0;
2483
2484 yield();
2485
2486 memset(tst, 0, ISP1362_BUF_SIZE);
2487 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2488 isp1362_write_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2489 isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2490 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2491 if (memcmp(tst, tst + (ISP1362_BUF_SIZE / (2 * sizeof(*tst))),
2492 ISP1362_BUF_SIZE / 2)) {
2493 pr_err("%s: Failed to clear buffer\n", __func__);
2494 dump_data((u8 *)tst, ISP1362_BUF_SIZE);
2495 break;
2496 }
2497 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2498 isp1362_write_buffer(isp1362_hcd, ref, offset * 2, PTD_HEADER_SIZE);
2499 isp1362_write_buffer(isp1362_hcd, ref + PTD_HEADER_SIZE / sizeof(*ref),
2500 offset * 2 + PTD_HEADER_SIZE, test_size);
2501 isp1362_read_buffer(isp1362_hcd, tst, offset * 2,
2502 PTD_HEADER_SIZE + test_size);
2503 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2504 if (memcmp(ref, tst, PTD_HEADER_SIZE + test_size)) {
2505 dump_data(((u8 *)ref) + offset, PTD_HEADER_SIZE + test_size);
2506 dump_data((u8 *)tst, PTD_HEADER_SIZE + test_size);
2507 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2508 isp1362_read_buffer(isp1362_hcd, tst, offset * 2,
2509 PTD_HEADER_SIZE + test_size);
2510 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2511 if (memcmp(ref, tst, PTD_HEADER_SIZE + test_size)) {
2512 ret = -ENODEV;
2513 pr_err("%s: memory check with offset %02x failed\n",
2514 __func__, offset);
2515 break;
2516 }
2517 pr_warning("%s: memory check with offset %02x ok after second read\n",
2518 __func__, offset);
2519 }
2520 }
2521 kfree(ref);
2522 }
2523 return ret;
2524 }
2525 #endif
2526
2527 static int isp1362_hc_start(struct usb_hcd *hcd)
2528 {
2529 int ret;
2530 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2531 struct isp1362_platform_data *board = isp1362_hcd->board;
2532 u16 hwcfg;
2533 u16 chipid;
2534 unsigned long flags;
2535
2536 pr_info("%s:\n", __func__);
2537
2538 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2539 chipid = isp1362_read_reg16(isp1362_hcd, HCCHIPID);
2540 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2541
2542 if ((chipid & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
2543 pr_err("%s: Invalid chip ID %04x\n", __func__, chipid);
2544 return -ENODEV;
2545 }
2546
2547 #ifdef CHIP_BUFFER_TEST
2548 ret = isp1362_chip_test(isp1362_hcd);
2549 if (ret)
2550 return -ENODEV;
2551 #endif
2552 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2553 /* clear interrupt status and disable all interrupt sources */
2554 isp1362_write_reg16(isp1362_hcd, HCuPINT, 0xff);
2555 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
2556
2557 /* HW conf */
2558 hwcfg = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
2559 if (board->sel15Kres)
2560 hwcfg |= HCHWCFG_PULLDOWN_DS2 |
2561 ((MAX_ROOT_PORTS > 1) ? HCHWCFG_PULLDOWN_DS1 : 0);
2562 if (board->clknotstop)
2563 hwcfg |= HCHWCFG_CLKNOTSTOP;
2564 if (board->oc_enable)
2565 hwcfg |= HCHWCFG_ANALOG_OC;
2566 if (board->int_act_high)
2567 hwcfg |= HCHWCFG_INT_POL;
2568 if (board->int_edge_triggered)
2569 hwcfg |= HCHWCFG_INT_TRIGGER;
2570 if (board->dreq_act_high)
2571 hwcfg |= HCHWCFG_DREQ_POL;
2572 if (board->dack_act_high)
2573 hwcfg |= HCHWCFG_DACK_POL;
2574 isp1362_write_reg16(isp1362_hcd, HCHWCFG, hwcfg);
2575 isp1362_show_reg(isp1362_hcd, HCHWCFG);
2576 isp1362_write_reg16(isp1362_hcd, HCDMACFG, 0);
2577 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2578
2579 ret = isp1362_mem_config(hcd);
2580 if (ret)
2581 return ret;
2582
2583 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2584
2585 /* Root hub conf */
2586 isp1362_hcd->rhdesca = 0;
2587 if (board->no_power_switching)
2588 isp1362_hcd->rhdesca |= RH_A_NPS;
2589 if (board->power_switching_mode)
2590 isp1362_hcd->rhdesca |= RH_A_PSM;
2591 if (board->potpg)
2592 isp1362_hcd->rhdesca |= (board->potpg << 24) & RH_A_POTPGT;
2593 else
2594 isp1362_hcd->rhdesca |= (25 << 24) & RH_A_POTPGT;
2595
2596 isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca & ~RH_A_OCPM);
2597 isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca | RH_A_OCPM);
2598 isp1362_hcd->rhdesca = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
2599
2600 isp1362_hcd->rhdescb = RH_B_PPCM;
2601 isp1362_write_reg32(isp1362_hcd, HCRHDESCB, isp1362_hcd->rhdescb);
2602 isp1362_hcd->rhdescb = isp1362_read_reg32(isp1362_hcd, HCRHDESCB);
2603
2604 isp1362_read_reg32(isp1362_hcd, HCFMINTVL);
2605 isp1362_write_reg32(isp1362_hcd, HCFMINTVL, (FSMP(FI) << 16) | FI);
2606 isp1362_write_reg32(isp1362_hcd, HCLSTHRESH, LSTHRESH);
2607
2608 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2609
2610 isp1362_hcd->hc_control = OHCI_USB_OPER;
2611 hcd->state = HC_STATE_RUNNING;
2612
2613 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2614 /* Set up interrupts */
2615 isp1362_hcd->intenb = OHCI_INTR_MIE | OHCI_INTR_RHSC | OHCI_INTR_UE;
2616 isp1362_hcd->intenb |= OHCI_INTR_RD;
2617 isp1362_hcd->irqenb = HCuPINT_OPR | HCuPINT_SUSP;
2618 isp1362_write_reg32(isp1362_hcd, HCINTENB, isp1362_hcd->intenb);
2619 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
2620
2621 /* Go operational */
2622 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
2623 /* enable global power */
2624 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC | RH_HS_DRWE);
2625
2626 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2627
2628 return 0;
2629 }
2630
2631 /*-------------------------------------------------------------------------*/
2632
2633 static struct hc_driver isp1362_hc_driver = {
2634 .description = hcd_name,
2635 .product_desc = "ISP1362 Host Controller",
2636 .hcd_priv_size = sizeof(struct isp1362_hcd),
2637
2638 .irq = isp1362_irq,
2639 .flags = HCD_USB11 | HCD_MEMORY,
2640
2641 .reset = isp1362_hc_reset,
2642 .start = isp1362_hc_start,
2643 .stop = isp1362_hc_stop,
2644
2645 .urb_enqueue = isp1362_urb_enqueue,
2646 .urb_dequeue = isp1362_urb_dequeue,
2647 .endpoint_disable = isp1362_endpoint_disable,
2648
2649 .get_frame_number = isp1362_get_frame,
2650
2651 .hub_status_data = isp1362_hub_status_data,
2652 .hub_control = isp1362_hub_control,
2653 .bus_suspend = isp1362_bus_suspend,
2654 .bus_resume = isp1362_bus_resume,
2655 };
2656
2657 /*-------------------------------------------------------------------------*/
2658
2659 #define resource_len(r) (((r)->end - (r)->start) + 1)
2660
2661 static int __devexit isp1362_remove(struct platform_device *pdev)
2662 {
2663 struct usb_hcd *hcd = platform_get_drvdata(pdev);
2664 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2665 struct resource *res;
2666
2667 remove_debug_file(isp1362_hcd);
2668 DBG(0, "%s: Removing HCD\n", __func__);
2669 usb_remove_hcd(hcd);
2670
2671 DBG(0, "%s: Unmapping data_reg @ %p\n", __func__,
2672 isp1362_hcd->data_reg);
2673 iounmap(isp1362_hcd->data_reg);
2674
2675 DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__,
2676 isp1362_hcd->addr_reg);
2677 iounmap(isp1362_hcd->addr_reg);
2678
2679 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2680 DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
2681 if (res)
2682 release_mem_region(res->start, resource_len(res));
2683
2684 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2685 DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
2686 if (res)
2687 release_mem_region(res->start, resource_len(res));
2688
2689 DBG(0, "%s: put_hcd\n", __func__);
2690 usb_put_hcd(hcd);
2691 DBG(0, "%s: Done\n", __func__);
2692
2693 return 0;
2694 }
2695
2696 static int __init isp1362_probe(struct platform_device *pdev)
2697 {
2698 struct usb_hcd *hcd;
2699 struct isp1362_hcd *isp1362_hcd;
2700 struct resource *addr, *data;
2701 void __iomem *addr_reg;
2702 void __iomem *data_reg;
2703 int irq;
2704 int retval = 0;
2705 struct resource *irq_res;
2706 unsigned int irq_flags = 0;
2707
2708 /* basic sanity checks first. board-specific init logic should
2709 * have initialized this the three resources and probably board
2710 * specific platform_data. we don't probe for IRQs, and do only
2711 * minimal sanity checking.
2712 */
2713 if (pdev->num_resources < 3) {
2714 retval = -ENODEV;
2715 goto err1;
2716 }
2717
2718 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2719 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2720 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2721 if (!addr || !data || !irq_res) {
2722 retval = -ENODEV;
2723 goto err1;
2724 }
2725 irq = irq_res->start;
2726
2727 if (pdev->dev.dma_mask) {
2728 DBG(1, "won't do DMA");
2729 retval = -ENODEV;
2730 goto err1;
2731 }
2732
2733 if (!request_mem_region(addr->start, resource_len(addr), hcd_name)) {
2734 retval = -EBUSY;
2735 goto err1;
2736 }
2737 addr_reg = ioremap(addr->start, resource_len(addr));
2738 if (addr_reg == NULL) {
2739 retval = -ENOMEM;
2740 goto err2;
2741 }
2742
2743 if (!request_mem_region(data->start, resource_len(data), hcd_name)) {
2744 retval = -EBUSY;
2745 goto err3;
2746 }
2747 data_reg = ioremap(data->start, resource_len(data));
2748 if (data_reg == NULL) {
2749 retval = -ENOMEM;
2750 goto err4;
2751 }
2752
2753 /* allocate and initialize hcd */
2754 hcd = usb_create_hcd(&isp1362_hc_driver, &pdev->dev, dev_name(&pdev->dev));
2755 if (!hcd) {
2756 retval = -ENOMEM;
2757 goto err5;
2758 }
2759 hcd->rsrc_start = data->start;
2760 isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2761 isp1362_hcd->data_reg = data_reg;
2762 isp1362_hcd->addr_reg = addr_reg;
2763
2764 isp1362_hcd->next_statechange = jiffies;
2765 spin_lock_init(&isp1362_hcd->lock);
2766 INIT_LIST_HEAD(&isp1362_hcd->async);
2767 INIT_LIST_HEAD(&isp1362_hcd->periodic);
2768 INIT_LIST_HEAD(&isp1362_hcd->isoc);
2769 INIT_LIST_HEAD(&isp1362_hcd->remove_list);
2770 isp1362_hcd->board = pdev->dev.platform_data;
2771 #if USE_PLATFORM_DELAY
2772 if (!isp1362_hcd->board->delay) {
2773 dev_err(hcd->self.controller, "No platform delay function given\n");
2774 retval = -ENODEV;
2775 goto err6;
2776 }
2777 #endif
2778
2779 if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2780 irq_flags |= IRQF_TRIGGER_RISING;
2781 if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2782 irq_flags |= IRQF_TRIGGER_FALLING;
2783 if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2784 irq_flags |= IRQF_TRIGGER_HIGH;
2785 if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2786 irq_flags |= IRQF_TRIGGER_LOW;
2787
2788 retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_DISABLED | IRQF_SHARED);
2789 if (retval != 0)
2790 goto err6;
2791 pr_info("%s, irq %d\n", hcd->product_desc, irq);
2792
2793 create_debug_file(isp1362_hcd);
2794
2795 return 0;
2796
2797 err6:
2798 DBG(0, "%s: Freeing dev %p\n", __func__, isp1362_hcd);
2799 usb_put_hcd(hcd);
2800 err5:
2801 DBG(0, "%s: Unmapping data_reg @ %p\n", __func__, data_reg);
2802 iounmap(data_reg);
2803 err4:
2804 DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)data->start);
2805 release_mem_region(data->start, resource_len(data));
2806 err3:
2807 DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__, addr_reg);
2808 iounmap(addr_reg);
2809 err2:
2810 DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)addr->start);
2811 release_mem_region(addr->start, resource_len(addr));
2812 err1:
2813 pr_err("%s: init error, %d\n", __func__, retval);
2814
2815 return retval;
2816 }
2817
2818 #ifdef CONFIG_PM
2819 static int isp1362_suspend(struct platform_device *pdev, pm_message_t state)
2820 {
2821 struct usb_hcd *hcd = platform_get_drvdata(pdev);
2822 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2823 unsigned long flags;
2824 int retval = 0;
2825
2826 DBG(0, "%s: Suspending device\n", __func__);
2827
2828 if (state.event == PM_EVENT_FREEZE) {
2829 DBG(0, "%s: Suspending root hub\n", __func__);
2830 retval = isp1362_bus_suspend(hcd);
2831 } else {
2832 DBG(0, "%s: Suspending RH ports\n", __func__);
2833 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2834 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
2835 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2836 }
2837 if (retval == 0)
2838 pdev->dev.power.power_state = state;
2839 return retval;
2840 }
2841
2842 static int isp1362_resume(struct platform_device *pdev)
2843 {
2844 struct usb_hcd *hcd = platform_get_drvdata(pdev);
2845 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2846 unsigned long flags;
2847
2848 DBG(0, "%s: Resuming\n", __func__);
2849
2850 if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2851 DBG(0, "%s: Resume RH ports\n", __func__);
2852 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2853 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC);
2854 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2855 return 0;
2856 }
2857
2858 pdev->dev.power.power_state = PMSG_ON;
2859
2860 return isp1362_bus_resume(isp1362_hcd_to_hcd(isp1362_hcd));
2861 }
2862 #else
2863 #define isp1362_suspend NULL
2864 #define isp1362_resume NULL
2865 #endif
2866
2867 static struct platform_driver isp1362_driver = {
2868 .probe = isp1362_probe,
2869 .remove = __devexit_p(isp1362_remove),
2870
2871 .suspend = isp1362_suspend,
2872 .resume = isp1362_resume,
2873 .driver = {
2874 .name = (char *)hcd_name,
2875 .owner = THIS_MODULE,
2876 },
2877 };
2878
2879 /*-------------------------------------------------------------------------*/
2880
2881 static int __init isp1362_init(void)
2882 {
2883 if (usb_disabled())
2884 return -ENODEV;
2885 pr_info("driver %s, %s\n", hcd_name, DRIVER_VERSION);
2886 return platform_driver_register(&isp1362_driver);
2887 }
2888 module_init(isp1362_init);
2889
2890 static void __exit isp1362_cleanup(void)
2891 {
2892 platform_driver_unregister(&isp1362_driver);
2893 }
2894 module_exit(isp1362_cleanup);
kernel-based virtual machine