?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: isp1362-hcd - use resource_size instead of defining its own resource_len macro
[linux-2.6/libata-dev.git] / drivers / usb / host / isp1362-hcd.c
blob8196fa11fec43678cb96b4c3241fd63b7fc1b35f
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 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1680 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PSS);
1681 isp1362_hcd->rhport[wIndex] =
1682 isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1683 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1684 break;
1685 case USB_PORT_FEAT_POWER:
1686 _DBG(0, "USB_PORT_FEAT_POWER\n");
1687 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1688 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PPS);
1689 isp1362_hcd->rhport[wIndex] =
1690 isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1691 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1692 break;
1693 case USB_PORT_FEAT_RESET:
1694 _DBG(0, "USB_PORT_FEAT_RESET\n");
1695 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1696
1697 t1 = jiffies + msecs_to_jiffies(USB_RESET_WIDTH);
1698 while (time_before(jiffies, t1)) {
1699 /* spin until any current reset finishes */
1700 for (;;) {
1701 tmp = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1702 if (!(tmp & RH_PS_PRS))
1703 break;
1704 udelay(500);
1705 }
1706 if (!(tmp & RH_PS_CCS))
1707 break;
1708 /* Reset lasts 10ms (claims datasheet) */
1709 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, (RH_PS_PRS));
1710
1711 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1712 msleep(10);
1713 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1714 }
1715
1716 isp1362_hcd->rhport[wIndex] = isp1362_read_reg32(isp1362_hcd,
1717 HCRHPORT1 + wIndex);
1718 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1719 break;
1720 default:
1721 goto error;
1722 }
1723 break;
1724
1725 default:
1726 error:
1727 /* "protocol stall" on error */
1728 _DBG(0, "PROTOCOL STALL\n");
1729 retval = -EPIPE;
1730 }
1731
1732 return retval;
1733 }
1734
1735 #ifdef CONFIG_PM
1736 static int isp1362_bus_suspend(struct usb_hcd *hcd)
1737 {
1738 int status = 0;
1739 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1740 unsigned long flags;
1741
1742 if (time_before(jiffies, isp1362_hcd->next_statechange))
1743 msleep(5);
1744
1745 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1746
1747 isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1748 switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
1749 case OHCI_USB_RESUME:
1750 DBG(0, "%s: resume/suspend?\n", __func__);
1751 isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
1752 isp1362_hcd->hc_control |= OHCI_USB_RESET;
1753 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1754 /* FALL THROUGH */
1755 case OHCI_USB_RESET:
1756 status = -EBUSY;
1757 pr_warning("%s: needs reinit!\n", __func__);
1758 goto done;
1759 case OHCI_USB_SUSPEND:
1760 pr_warning("%s: already suspended?\n", __func__);
1761 goto done;
1762 }
1763 DBG(0, "%s: suspend root hub\n", __func__);
1764
1765 /* First stop any processing */
1766 hcd->state = HC_STATE_QUIESCING;
1767 if (!list_empty(&isp1362_hcd->atl_queue.active) ||
1768 !list_empty(&isp1362_hcd->intl_queue.active) ||
1769 !list_empty(&isp1362_hcd->istl_queue[0] .active) ||
1770 !list_empty(&isp1362_hcd->istl_queue[1] .active)) {
1771 int limit;
1772
1773 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
1774 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
1775 isp1362_write_reg16(isp1362_hcd, HCBUFSTAT, 0);
1776 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
1777 isp1362_write_reg32(isp1362_hcd, HCINTSTAT, OHCI_INTR_SF);
1778
1779 DBG(0, "%s: stopping schedules ...\n", __func__);
1780 limit = 2000;
1781 while (limit > 0) {
1782 udelay(250);
1783 limit -= 250;
1784 if (isp1362_read_reg32(isp1362_hcd, HCINTSTAT) & OHCI_INTR_SF)
1785 break;
1786 }
1787 mdelay(7);
1788 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ATL) {
1789 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCATLDONE);
1790 finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->atl_queue);
1791 }
1792 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_INTL) {
1793 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCINTLDONE);
1794 finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->intl_queue);
1795 }
1796 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL0)
1797 finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[0]);
1798 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL1)
1799 finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[1]);
1800 }
1801 DBG(0, "%s: HCINTSTAT: %08x\n", __func__,
1802 isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
1803 isp1362_write_reg32(isp1362_hcd, HCINTSTAT,
1804 isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
1805
1806 /* Suspend hub */
1807 isp1362_hcd->hc_control = OHCI_USB_SUSPEND;
1808 isp1362_show_reg(isp1362_hcd, HCCONTROL);
1809 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1810 isp1362_show_reg(isp1362_hcd, HCCONTROL);
1811
1812 #if 1
1813 isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1814 if ((isp1362_hcd->hc_control & OHCI_CTRL_HCFS) != OHCI_USB_SUSPEND) {
1815 pr_err("%s: controller won't suspend %08x\n", __func__,
1816 isp1362_hcd->hc_control);
1817 status = -EBUSY;
1818 } else
1819 #endif
1820 {
1821 /* no resumes until devices finish suspending */
1822 isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(5);
1823 }
1824 done:
1825 if (status == 0) {
1826 hcd->state = HC_STATE_SUSPENDED;
1827 DBG(0, "%s: HCD suspended: %08x\n", __func__,
1828 isp1362_read_reg32(isp1362_hcd, HCCONTROL));
1829 }
1830 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1831 return status;
1832 }
1833
1834 static int isp1362_bus_resume(struct usb_hcd *hcd)
1835 {
1836 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1837 u32 port;
1838 unsigned long flags;
1839 int status = -EINPROGRESS;
1840
1841 if (time_before(jiffies, isp1362_hcd->next_statechange))
1842 msleep(5);
1843
1844 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1845 isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1846 pr_info("%s: HCCONTROL: %08x\n", __func__, isp1362_hcd->hc_control);
1847 if (hcd->state == HC_STATE_RESUMING) {
1848 pr_warning("%s: duplicate resume\n", __func__);
1849 status = 0;
1850 } else
1851 switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
1852 case OHCI_USB_SUSPEND:
1853 DBG(0, "%s: resume root hub\n", __func__);
1854 isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
1855 isp1362_hcd->hc_control |= OHCI_USB_RESUME;
1856 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1857 break;
1858 case OHCI_USB_RESUME:
1859 /* HCFS changes sometime after INTR_RD */
1860 DBG(0, "%s: remote wakeup\n", __func__);
1861 break;
1862 case OHCI_USB_OPER:
1863 DBG(0, "%s: odd resume\n", __func__);
1864 status = 0;
1865 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1866 break;
1867 default: /* RESET, we lost power */
1868 DBG(0, "%s: root hub hardware reset\n", __func__);
1869 status = -EBUSY;
1870 }
1871 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1872 if (status == -EBUSY) {
1873 DBG(0, "%s: Restarting HC\n", __func__);
1874 isp1362_hc_stop(hcd);
1875 return isp1362_hc_start(hcd);
1876 }
1877 if (status != -EINPROGRESS)
1878 return status;
1879 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1880 port = isp1362_read_reg32(isp1362_hcd, HCRHDESCA) & RH_A_NDP;
1881 while (port--) {
1882 u32 stat = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + port);
1883
1884 /* force global, not selective, resume */
1885 if (!(stat & RH_PS_PSS)) {
1886 DBG(0, "%s: Not Resuming RH port %d\n", __func__, port);
1887 continue;
1888 }
1889 DBG(0, "%s: Resuming RH port %d\n", __func__, port);
1890 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + port, RH_PS_POCI);
1891 }
1892 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1893
1894 /* Some controllers (lucent) need extra-long delays */
1895 hcd->state = HC_STATE_RESUMING;
1896 mdelay(20 /* usb 11.5.1.10 */ + 15);
1897
1898 isp1362_hcd->hc_control = OHCI_USB_OPER;
1899 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1900 isp1362_show_reg(isp1362_hcd, HCCONTROL);
1901 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1902 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1903 /* TRSMRCY */
1904 msleep(10);
1905
1906 /* keep it alive for ~5x suspend + resume costs */
1907 isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(250);
1908
1909 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1910 hcd->state = HC_STATE_RUNNING;
1911 return 0;
1912 }
1913 #else
1914 #define isp1362_bus_suspend NULL
1915 #define isp1362_bus_resume NULL
1916 #endif
1917
1918 /*-------------------------------------------------------------------------*/
1919
1920 #ifdef STUB_DEBUG_FILE
1921
1922 static inline void create_debug_file(struct isp1362_hcd *isp1362_hcd)
1923 {
1924 }
1925 static inline void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
1926 {
1927 }
1928
1929 #else
1930
1931 #include <linux/proc_fs.h>
1932 #include <linux/seq_file.h>
1933
1934 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1935 {
1936 seq_printf(s, "%-15s %04x%s%s%s%s%s%s\n", label, mask,
1937 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1938 mask & HCuPINT_SUSP ? " susp" : "",
1939 mask & HCuPINT_OPR ? " opr" : "",
1940 mask & HCuPINT_EOT ? " eot" : "",
1941 mask & HCuPINT_ATL ? " atl" : "",
1942 mask & HCuPINT_SOF ? " sof" : "");
1943 }
1944
1945 static void dump_int(struct seq_file *s, char *label, u32 mask)
1946 {
1947 seq_printf(s, "%-15s %08x%s%s%s%s%s%s%s\n", label, mask,
1948 mask & OHCI_INTR_MIE ? " MIE" : "",
1949 mask & OHCI_INTR_RHSC ? " rhsc" : "",
1950 mask & OHCI_INTR_FNO ? " fno" : "",
1951 mask & OHCI_INTR_UE ? " ue" : "",
1952 mask & OHCI_INTR_RD ? " rd" : "",
1953 mask & OHCI_INTR_SF ? " sof" : "",
1954 mask & OHCI_INTR_SO ? " so" : "");
1955 }
1956
1957 static void dump_ctrl(struct seq_file *s, char *label, u32 mask)
1958 {
1959 seq_printf(s, "%-15s %08x%s%s%s\n", label, mask,
1960 mask & OHCI_CTRL_RWC ? " rwc" : "",
1961 mask & OHCI_CTRL_RWE ? " rwe" : "",
1962 ({
1963 char *hcfs;
1964 switch (mask & OHCI_CTRL_HCFS) {
1965 case OHCI_USB_OPER:
1966 hcfs = " oper";
1967 break;
1968 case OHCI_USB_RESET:
1969 hcfs = " reset";
1970 break;
1971 case OHCI_USB_RESUME:
1972 hcfs = " resume";
1973 break;
1974 case OHCI_USB_SUSPEND:
1975 hcfs = " suspend";
1976 break;
1977 default:
1978 hcfs = " ?";
1979 }
1980 hcfs;
1981 }));
1982 }
1983
1984 static void dump_regs(struct seq_file *s, struct isp1362_hcd *isp1362_hcd)
1985 {
1986 seq_printf(s, "HCREVISION [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCREVISION),
1987 isp1362_read_reg32(isp1362_hcd, HCREVISION));
1988 seq_printf(s, "HCCONTROL [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCONTROL),
1989 isp1362_read_reg32(isp1362_hcd, HCCONTROL));
1990 seq_printf(s, "HCCMDSTAT [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCMDSTAT),
1991 isp1362_read_reg32(isp1362_hcd, HCCMDSTAT));
1992 seq_printf(s, "HCINTSTAT [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTSTAT),
1993 isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
1994 seq_printf(s, "HCINTENB [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTENB),
1995 isp1362_read_reg32(isp1362_hcd, HCINTENB));
1996 seq_printf(s, "HCFMINTVL [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMINTVL),
1997 isp1362_read_reg32(isp1362_hcd, HCFMINTVL));
1998 seq_printf(s, "HCFMREM [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMREM),
1999 isp1362_read_reg32(isp1362_hcd, HCFMREM));
2000 seq_printf(s, "HCFMNUM [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMNUM),
2001 isp1362_read_reg32(isp1362_hcd, HCFMNUM));
2002 seq_printf(s, "HCLSTHRESH [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCLSTHRESH),
2003 isp1362_read_reg32(isp1362_hcd, HCLSTHRESH));
2004 seq_printf(s, "HCRHDESCA [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCA),
2005 isp1362_read_reg32(isp1362_hcd, HCRHDESCA));
2006 seq_printf(s, "HCRHDESCB [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCB),
2007 isp1362_read_reg32(isp1362_hcd, HCRHDESCB));
2008 seq_printf(s, "HCRHSTATUS [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHSTATUS),
2009 isp1362_read_reg32(isp1362_hcd, HCRHSTATUS));
2010 seq_printf(s, "HCRHPORT1 [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT1),
2011 isp1362_read_reg32(isp1362_hcd, HCRHPORT1));
2012 seq_printf(s, "HCRHPORT2 [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT2),
2013 isp1362_read_reg32(isp1362_hcd, HCRHPORT2));
2014 seq_printf(s, "\n");
2015 seq_printf(s, "HCHWCFG [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCHWCFG),
2016 isp1362_read_reg16(isp1362_hcd, HCHWCFG));
2017 seq_printf(s, "HCDMACFG [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCDMACFG),
2018 isp1362_read_reg16(isp1362_hcd, HCDMACFG));
2019 seq_printf(s, "HCXFERCTR [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCXFERCTR),
2020 isp1362_read_reg16(isp1362_hcd, HCXFERCTR));
2021 seq_printf(s, "HCuPINT [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINT),
2022 isp1362_read_reg16(isp1362_hcd, HCuPINT));
2023 seq_printf(s, "HCuPINTENB [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINTENB),
2024 isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
2025 seq_printf(s, "HCCHIPID [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCCHIPID),
2026 isp1362_read_reg16(isp1362_hcd, HCCHIPID));
2027 seq_printf(s, "HCSCRATCH [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCSCRATCH),
2028 isp1362_read_reg16(isp1362_hcd, HCSCRATCH));
2029 seq_printf(s, "HCBUFSTAT [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCBUFSTAT),
2030 isp1362_read_reg16(isp1362_hcd, HCBUFSTAT));
2031 seq_printf(s, "HCDIRADDR [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCDIRADDR),
2032 isp1362_read_reg32(isp1362_hcd, HCDIRADDR));
2033 #if 0
2034 seq_printf(s, "HCDIRDATA [%02x] %04x\n", ISP1362_REG_NO(HCDIRDATA),
2035 isp1362_read_reg16(isp1362_hcd, HCDIRDATA));
2036 #endif
2037 seq_printf(s, "HCISTLBUFSZ[%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLBUFSZ),
2038 isp1362_read_reg16(isp1362_hcd, HCISTLBUFSZ));
2039 seq_printf(s, "HCISTLRATE [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLRATE),
2040 isp1362_read_reg16(isp1362_hcd, HCISTLRATE));
2041 seq_printf(s, "\n");
2042 seq_printf(s, "HCINTLBUFSZ[%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBUFSZ),
2043 isp1362_read_reg16(isp1362_hcd, HCINTLBUFSZ));
2044 seq_printf(s, "HCINTLBLKSZ[%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBLKSZ),
2045 isp1362_read_reg16(isp1362_hcd, HCINTLBLKSZ));
2046 seq_printf(s, "HCINTLDONE [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLDONE),
2047 isp1362_read_reg32(isp1362_hcd, HCINTLDONE));
2048 seq_printf(s, "HCINTLSKIP [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLSKIP),
2049 isp1362_read_reg32(isp1362_hcd, HCINTLSKIP));
2050 seq_printf(s, "HCINTLLAST [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLLAST),
2051 isp1362_read_reg32(isp1362_hcd, HCINTLLAST));
2052 seq_printf(s, "HCINTLCURR [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLCURR),
2053 isp1362_read_reg16(isp1362_hcd, HCINTLCURR));
2054 seq_printf(s, "\n");
2055 seq_printf(s, "HCATLBUFSZ [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBUFSZ),
2056 isp1362_read_reg16(isp1362_hcd, HCATLBUFSZ));
2057 seq_printf(s, "HCATLBLKSZ [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBLKSZ),
2058 isp1362_read_reg16(isp1362_hcd, HCATLBLKSZ));
2059 #if 0
2060 seq_printf(s, "HCATLDONE [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDONE),
2061 isp1362_read_reg32(isp1362_hcd, HCATLDONE));
2062 #endif
2063 seq_printf(s, "HCATLSKIP [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLSKIP),
2064 isp1362_read_reg32(isp1362_hcd, HCATLSKIP));
2065 seq_printf(s, "HCATLLAST [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLLAST),
2066 isp1362_read_reg32(isp1362_hcd, HCATLLAST));
2067 seq_printf(s, "HCATLCURR [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLCURR),
2068 isp1362_read_reg16(isp1362_hcd, HCATLCURR));
2069 seq_printf(s, "\n");
2070 seq_printf(s, "HCATLDTC [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTC),
2071 isp1362_read_reg16(isp1362_hcd, HCATLDTC));
2072 seq_printf(s, "HCATLDTCTO [%02x] %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTCTO),
2073 isp1362_read_reg16(isp1362_hcd, HCATLDTCTO));
2074 }
2075
2076 static int proc_isp1362_show(struct seq_file *s, void *unused)
2077 {
2078 struct isp1362_hcd *isp1362_hcd = s->private;
2079 struct isp1362_ep *ep;
2080 int i;
2081
2082 seq_printf(s, "%s\n%s version %s\n",
2083 isp1362_hcd_to_hcd(isp1362_hcd)->product_desc, hcd_name, DRIVER_VERSION);
2084
2085 /* collect statistics to help estimate potential win for
2086 * DMA engines that care about alignment (PXA)
2087 */
2088 seq_printf(s, "alignment: 16b/%ld 8b/%ld 4b/%ld 2b/%ld 1b/%ld\n",
2089 isp1362_hcd->stat16, isp1362_hcd->stat8, isp1362_hcd->stat4,
2090 isp1362_hcd->stat2, isp1362_hcd->stat1);
2091 seq_printf(s, "max # ptds in ATL fifo: %d\n", isp1362_hcd->atl_queue.stat_maxptds);
2092 seq_printf(s, "max # ptds in INTL fifo: %d\n", isp1362_hcd->intl_queue.stat_maxptds);
2093 seq_printf(s, "max # ptds in ISTL fifo: %d\n",
2094 max(isp1362_hcd->istl_queue[0] .stat_maxptds,
2095 isp1362_hcd->istl_queue[1] .stat_maxptds));
2096
2097 /* FIXME: don't show the following in suspended state */
2098 spin_lock_irq(&isp1362_hcd->lock);
2099
2100 dump_irq(s, "hc_irq_enable", isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
2101 dump_irq(s, "hc_irq_status", isp1362_read_reg16(isp1362_hcd, HCuPINT));
2102 dump_int(s, "ohci_int_enable", isp1362_read_reg32(isp1362_hcd, HCINTENB));
2103 dump_int(s, "ohci_int_status", isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
2104 dump_ctrl(s, "ohci_control", isp1362_read_reg32(isp1362_hcd, HCCONTROL));
2105
2106 for (i = 0; i < NUM_ISP1362_IRQS; i++)
2107 if (isp1362_hcd->irq_stat[i])
2108 seq_printf(s, "%-15s: %d\n",
2109 ISP1362_INT_NAME(i), isp1362_hcd->irq_stat[i]);
2110
2111 dump_regs(s, isp1362_hcd);
2112 list_for_each_entry(ep, &isp1362_hcd->async, schedule) {
2113 struct urb *urb;
2114
2115 seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep, ep->epnum,
2116 ({
2117 char *s;
2118 switch (ep->nextpid) {
2119 case USB_PID_IN:
2120 s = "in";
2121 break;
2122 case USB_PID_OUT:
2123 s = "out";
2124 break;
2125 case USB_PID_SETUP:
2126 s = "setup";
2127 break;
2128 case USB_PID_ACK:
2129 s = "status";
2130 break;
2131 default:
2132 s = "?";
2133 break;
2134 };
2135 s;}), ep->maxpacket) ;
2136 list_for_each_entry(urb, &ep->hep->urb_list, urb_list) {
2137 seq_printf(s, " urb%p, %d/%d\n", urb,
2138 urb->actual_length,
2139 urb->transfer_buffer_length);
2140 }
2141 }
2142 if (!list_empty(&isp1362_hcd->async))
2143 seq_printf(s, "\n");
2144 dump_ptd_queue(&isp1362_hcd->atl_queue);
2145
2146 seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
2147
2148 list_for_each_entry(ep, &isp1362_hcd->periodic, schedule) {
2149 seq_printf(s, "branch:%2d load:%3d PTD[%d] $%04x:\n", ep->branch,
2150 isp1362_hcd->load[ep->branch], ep->ptd_index, ep->ptd_offset);
2151
2152 seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n",
2153 ep->interval, ep,
2154 (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
2155 ep->udev->devnum, ep->epnum,
2156 (ep->epnum == 0) ? "" :
2157 ((ep->nextpid == USB_PID_IN) ?
2158 "in" : "out"), ep->maxpacket);
2159 }
2160 dump_ptd_queue(&isp1362_hcd->intl_queue);
2161
2162 seq_printf(s, "ISO:\n");
2163
2164 list_for_each_entry(ep, &isp1362_hcd->isoc, schedule) {
2165 seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n",
2166 ep->interval, ep,
2167 (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
2168 ep->udev->devnum, ep->epnum,
2169 (ep->epnum == 0) ? "" :
2170 ((ep->nextpid == USB_PID_IN) ?
2171 "in" : "out"), ep->maxpacket);
2172 }
2173
2174 spin_unlock_irq(&isp1362_hcd->lock);
2175 seq_printf(s, "\n");
2176
2177 return 0;
2178 }
2179
2180 static int proc_isp1362_open(struct inode *inode, struct file *file)
2181 {
2182 return single_open(file, proc_isp1362_show, PDE(inode)->data);
2183 }
2184
2185 static const struct file_operations proc_ops = {
2186 .open = proc_isp1362_open,
2187 .read = seq_read,
2188 .llseek = seq_lseek,
2189 .release = single_release,
2190 };
2191
2192 /* expect just one isp1362_hcd per system */
2193 static const char proc_filename[] = "driver/isp1362";
2194
2195 static void create_debug_file(struct isp1362_hcd *isp1362_hcd)
2196 {
2197 struct proc_dir_entry *pde;
2198
2199 pde = create_proc_entry(proc_filename, 0, NULL);
2200 if (pde == NULL) {
2201 pr_warning("%s: Failed to create debug file '%s'\n", __func__, proc_filename);
2202 return;
2203 }
2204
2205 pde->proc_fops = &proc_ops;
2206 pde->data = isp1362_hcd;
2207 isp1362_hcd->pde = pde;
2208 }
2209
2210 static void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
2211 {
2212 if (isp1362_hcd->pde)
2213 remove_proc_entry(proc_filename, NULL);
2214 }
2215
2216 #endif
2217
2218 /*-------------------------------------------------------------------------*/
2219
2220 static void __isp1362_sw_reset(struct isp1362_hcd *isp1362_hcd)
2221 {
2222 int tmp = 20;
2223
2224 isp1362_write_reg16(isp1362_hcd, HCSWRES, HCSWRES_MAGIC);
2225 isp1362_write_reg32(isp1362_hcd, HCCMDSTAT, OHCI_HCR);
2226 while (--tmp) {
2227 mdelay(1);
2228 if (!(isp1362_read_reg32(isp1362_hcd, HCCMDSTAT) & OHCI_HCR))
2229 break;
2230 }
2231 if (!tmp)
2232 pr_err("Software reset timeout\n");
2233 }
2234
2235 static void isp1362_sw_reset(struct isp1362_hcd *isp1362_hcd)
2236 {
2237 unsigned long flags;
2238
2239 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2240 __isp1362_sw_reset(isp1362_hcd);
2241 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2242 }
2243
2244 static int isp1362_mem_config(struct usb_hcd *hcd)
2245 {
2246 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2247 unsigned long flags;
2248 u32 total;
2249 u16 istl_size = ISP1362_ISTL_BUFSIZE;
2250 u16 intl_blksize = ISP1362_INTL_BLKSIZE + PTD_HEADER_SIZE;
2251 u16 intl_size = ISP1362_INTL_BUFFERS * intl_blksize;
2252 u16 atl_blksize = ISP1362_ATL_BLKSIZE + PTD_HEADER_SIZE;
2253 u16 atl_buffers = (ISP1362_BUF_SIZE - (istl_size + intl_size)) / atl_blksize;
2254 u16 atl_size;
2255 int i;
2256
2257 WARN_ON(istl_size & 3);
2258 WARN_ON(atl_blksize & 3);
2259 WARN_ON(intl_blksize & 3);
2260 WARN_ON(atl_blksize < PTD_HEADER_SIZE);
2261 WARN_ON(intl_blksize < PTD_HEADER_SIZE);
2262
2263 BUG_ON((unsigned)ISP1362_INTL_BUFFERS > 32);
2264 if (atl_buffers > 32)
2265 atl_buffers = 32;
2266 atl_size = atl_buffers * atl_blksize;
2267 total = atl_size + intl_size + istl_size;
2268 dev_info(hcd->self.controller, "ISP1362 Memory usage:\n");
2269 dev_info(hcd->self.controller, " ISTL: 2 * %4d: %4d @ $%04x:$%04x\n",
2270 istl_size / 2, istl_size, 0, istl_size / 2);
2271 dev_info(hcd->self.controller, " INTL: %4d * (%3zu+8): %4d @ $%04x\n",
2272 ISP1362_INTL_BUFFERS, intl_blksize - PTD_HEADER_SIZE,
2273 intl_size, istl_size);
2274 dev_info(hcd->self.controller, " ATL : %4d * (%3zu+8): %4d @ $%04x\n",
2275 atl_buffers, atl_blksize - PTD_HEADER_SIZE,
2276 atl_size, istl_size + intl_size);
2277 dev_info(hcd->self.controller, " USED/FREE: %4d %4d\n", total,
2278 ISP1362_BUF_SIZE - total);
2279
2280 if (total > ISP1362_BUF_SIZE) {
2281 dev_err(hcd->self.controller, "%s: Memory requested: %d, available %d\n",
2282 __func__, total, ISP1362_BUF_SIZE);
2283 return -ENOMEM;
2284 }
2285
2286 total = istl_size + intl_size + atl_size;
2287 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2288
2289 for (i = 0; i < 2; i++) {
2290 isp1362_hcd->istl_queue[i].buf_start = i * istl_size / 2,
2291 isp1362_hcd->istl_queue[i].buf_size = istl_size / 2;
2292 isp1362_hcd->istl_queue[i].blk_size = 4;
2293 INIT_LIST_HEAD(&isp1362_hcd->istl_queue[i].active);
2294 snprintf(isp1362_hcd->istl_queue[i].name,
2295 sizeof(isp1362_hcd->istl_queue[i].name), "ISTL%d", i);
2296 DBG(3, "%s: %5s buf $%04x %d\n", __func__,
2297 isp1362_hcd->istl_queue[i].name,
2298 isp1362_hcd->istl_queue[i].buf_start,
2299 isp1362_hcd->istl_queue[i].buf_size);
2300 }
2301 isp1362_write_reg16(isp1362_hcd, HCISTLBUFSZ, istl_size / 2);
2302
2303 isp1362_hcd->intl_queue.buf_start = istl_size;
2304 isp1362_hcd->intl_queue.buf_size = intl_size;
2305 isp1362_hcd->intl_queue.buf_count = ISP1362_INTL_BUFFERS;
2306 isp1362_hcd->intl_queue.blk_size = intl_blksize;
2307 isp1362_hcd->intl_queue.buf_avail = isp1362_hcd->intl_queue.buf_count;
2308 isp1362_hcd->intl_queue.skip_map = ~0;
2309 INIT_LIST_HEAD(&isp1362_hcd->intl_queue.active);
2310
2311 isp1362_write_reg16(isp1362_hcd, HCINTLBUFSZ,
2312 isp1362_hcd->intl_queue.buf_size);
2313 isp1362_write_reg16(isp1362_hcd, HCINTLBLKSZ,
2314 isp1362_hcd->intl_queue.blk_size - PTD_HEADER_SIZE);
2315 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
2316 isp1362_write_reg32(isp1362_hcd, HCINTLLAST,
2317 1 << (ISP1362_INTL_BUFFERS - 1));
2318
2319 isp1362_hcd->atl_queue.buf_start = istl_size + intl_size;
2320 isp1362_hcd->atl_queue.buf_size = atl_size;
2321 isp1362_hcd->atl_queue.buf_count = atl_buffers;
2322 isp1362_hcd->atl_queue.blk_size = atl_blksize;
2323 isp1362_hcd->atl_queue.buf_avail = isp1362_hcd->atl_queue.buf_count;
2324 isp1362_hcd->atl_queue.skip_map = ~0;
2325 INIT_LIST_HEAD(&isp1362_hcd->atl_queue.active);
2326
2327 isp1362_write_reg16(isp1362_hcd, HCATLBUFSZ,
2328 isp1362_hcd->atl_queue.buf_size);
2329 isp1362_write_reg16(isp1362_hcd, HCATLBLKSZ,
2330 isp1362_hcd->atl_queue.blk_size - PTD_HEADER_SIZE);
2331 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
2332 isp1362_write_reg32(isp1362_hcd, HCATLLAST,
2333 1 << (atl_buffers - 1));
2334
2335 snprintf(isp1362_hcd->atl_queue.name,
2336 sizeof(isp1362_hcd->atl_queue.name), "ATL");
2337 snprintf(isp1362_hcd->intl_queue.name,
2338 sizeof(isp1362_hcd->intl_queue.name), "INTL");
2339 DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
2340 isp1362_hcd->intl_queue.name,
2341 isp1362_hcd->intl_queue.buf_start,
2342 ISP1362_INTL_BUFFERS, isp1362_hcd->intl_queue.blk_size,
2343 isp1362_hcd->intl_queue.buf_size);
2344 DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
2345 isp1362_hcd->atl_queue.name,
2346 isp1362_hcd->atl_queue.buf_start,
2347 atl_buffers, isp1362_hcd->atl_queue.blk_size,
2348 isp1362_hcd->atl_queue.buf_size);
2349
2350 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2351
2352 return 0;
2353 }
2354
2355 static int isp1362_hc_reset(struct usb_hcd *hcd)
2356 {
2357 int ret = 0;
2358 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2359 unsigned long t;
2360 unsigned long timeout = 100;
2361 unsigned long flags;
2362 int clkrdy = 0;
2363
2364 pr_info("%s:\n", __func__);
2365
2366 if (isp1362_hcd->board && isp1362_hcd->board->reset) {
2367 isp1362_hcd->board->reset(hcd->self.controller, 1);
2368 msleep(20);
2369 if (isp1362_hcd->board->clock)
2370 isp1362_hcd->board->clock(hcd->self.controller, 1);
2371 isp1362_hcd->board->reset(hcd->self.controller, 0);
2372 } else
2373 isp1362_sw_reset(isp1362_hcd);
2374
2375 /* chip has been reset. First we need to see a clock */
2376 t = jiffies + msecs_to_jiffies(timeout);
2377 while (!clkrdy && time_before_eq(jiffies, t)) {
2378 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2379 clkrdy = isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_CLKRDY;
2380 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2381 if (!clkrdy)
2382 msleep(4);
2383 }
2384
2385 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2386 isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_CLKRDY);
2387 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2388 if (!clkrdy) {
2389 pr_err("Clock not ready after %lums\n", timeout);
2390 ret = -ENODEV;
2391 }
2392 return ret;
2393 }
2394
2395 static void isp1362_hc_stop(struct usb_hcd *hcd)
2396 {
2397 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2398 unsigned long flags;
2399 u32 tmp;
2400
2401 pr_info("%s:\n", __func__);
2402
2403 del_timer_sync(&hcd->rh_timer);
2404
2405 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2406
2407 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
2408
2409 /* Switch off power for all ports */
2410 tmp = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
2411 tmp &= ~(RH_A_NPS | RH_A_PSM);
2412 isp1362_write_reg32(isp1362_hcd, HCRHDESCA, tmp);
2413 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
2414
2415 /* Reset the chip */
2416 if (isp1362_hcd->board && isp1362_hcd->board->reset)
2417 isp1362_hcd->board->reset(hcd->self.controller, 1);
2418 else
2419 __isp1362_sw_reset(isp1362_hcd);
2420
2421 if (isp1362_hcd->board && isp1362_hcd->board->clock)
2422 isp1362_hcd->board->clock(hcd->self.controller, 0);
2423
2424 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2425 }
2426
2427 #ifdef CHIP_BUFFER_TEST
2428 static int isp1362_chip_test(struct isp1362_hcd *isp1362_hcd)
2429 {
2430 int ret = 0;
2431 u16 *ref;
2432 unsigned long flags;
2433
2434 ref = kmalloc(2 * ISP1362_BUF_SIZE, GFP_KERNEL);
2435 if (ref) {
2436 int offset;
2437 u16 *tst = &ref[ISP1362_BUF_SIZE / 2];
2438
2439 for (offset = 0; offset < ISP1362_BUF_SIZE / 2; offset++) {
2440 ref[offset] = ~offset;
2441 tst[offset] = offset;
2442 }
2443
2444 for (offset = 0; offset < 4; offset++) {
2445 int j;
2446
2447 for (j = 0; j < 8; j++) {
2448 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2449 isp1362_write_buffer(isp1362_hcd, (u8 *)ref + offset, 0, j);
2450 isp1362_read_buffer(isp1362_hcd, (u8 *)tst + offset, 0, j);
2451 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2452
2453 if (memcmp(ref, tst, j)) {
2454 ret = -ENODEV;
2455 pr_err("%s: memory check with %d byte offset %d failed\n",
2456 __func__, j, offset);
2457 dump_data((u8 *)ref + offset, j);
2458 dump_data((u8 *)tst + offset, j);
2459 }
2460 }
2461 }
2462
2463 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2464 isp1362_write_buffer(isp1362_hcd, ref, 0, ISP1362_BUF_SIZE);
2465 isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2466 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2467
2468 if (memcmp(ref, tst, ISP1362_BUF_SIZE)) {
2469 ret = -ENODEV;
2470 pr_err("%s: memory check failed\n", __func__);
2471 dump_data((u8 *)tst, ISP1362_BUF_SIZE / 2);
2472 }
2473
2474 for (offset = 0; offset < 256; offset++) {
2475 int test_size = 0;
2476
2477 yield();
2478
2479 memset(tst, 0, ISP1362_BUF_SIZE);
2480 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2481 isp1362_write_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2482 isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2483 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2484 if (memcmp(tst, tst + (ISP1362_BUF_SIZE / (2 * sizeof(*tst))),
2485 ISP1362_BUF_SIZE / 2)) {
2486 pr_err("%s: Failed to clear buffer\n", __func__);
2487 dump_data((u8 *)tst, ISP1362_BUF_SIZE);
2488 break;
2489 }
2490 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2491 isp1362_write_buffer(isp1362_hcd, ref, offset * 2, PTD_HEADER_SIZE);
2492 isp1362_write_buffer(isp1362_hcd, ref + PTD_HEADER_SIZE / sizeof(*ref),
2493 offset * 2 + PTD_HEADER_SIZE, test_size);
2494 isp1362_read_buffer(isp1362_hcd, tst, offset * 2,
2495 PTD_HEADER_SIZE + test_size);
2496 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2497 if (memcmp(ref, tst, PTD_HEADER_SIZE + test_size)) {
2498 dump_data(((u8 *)ref) + offset, PTD_HEADER_SIZE + test_size);
2499 dump_data((u8 *)tst, PTD_HEADER_SIZE + test_size);
2500 spin_lock_irqsave(&isp1362_hcd->lock, flags);
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 ret = -ENODEV;
2506 pr_err("%s: memory check with offset %02x failed\n",
2507 __func__, offset);
2508 break;
2509 }
2510 pr_warning("%s: memory check with offset %02x ok after second read\n",
2511 __func__, offset);
2512 }
2513 }
2514 kfree(ref);
2515 }
2516 return ret;
2517 }
2518 #endif
2519
2520 static int isp1362_hc_start(struct usb_hcd *hcd)
2521 {
2522 int ret;
2523 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2524 struct isp1362_platform_data *board = isp1362_hcd->board;
2525 u16 hwcfg;
2526 u16 chipid;
2527 unsigned long flags;
2528
2529 pr_info("%s:\n", __func__);
2530
2531 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2532 chipid = isp1362_read_reg16(isp1362_hcd, HCCHIPID);
2533 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2534
2535 if ((chipid & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
2536 pr_err("%s: Invalid chip ID %04x\n", __func__, chipid);
2537 return -ENODEV;
2538 }
2539
2540 #ifdef CHIP_BUFFER_TEST
2541 ret = isp1362_chip_test(isp1362_hcd);
2542 if (ret)
2543 return -ENODEV;
2544 #endif
2545 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2546 /* clear interrupt status and disable all interrupt sources */
2547 isp1362_write_reg16(isp1362_hcd, HCuPINT, 0xff);
2548 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
2549
2550 /* HW conf */
2551 hwcfg = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
2552 if (board->sel15Kres)
2553 hwcfg |= HCHWCFG_PULLDOWN_DS2 |
2554 ((MAX_ROOT_PORTS > 1) ? HCHWCFG_PULLDOWN_DS1 : 0);
2555 if (board->clknotstop)
2556 hwcfg |= HCHWCFG_CLKNOTSTOP;
2557 if (board->oc_enable)
2558 hwcfg |= HCHWCFG_ANALOG_OC;
2559 if (board->int_act_high)
2560 hwcfg |= HCHWCFG_INT_POL;
2561 if (board->int_edge_triggered)
2562 hwcfg |= HCHWCFG_INT_TRIGGER;
2563 if (board->dreq_act_high)
2564 hwcfg |= HCHWCFG_DREQ_POL;
2565 if (board->dack_act_high)
2566 hwcfg |= HCHWCFG_DACK_POL;
2567 isp1362_write_reg16(isp1362_hcd, HCHWCFG, hwcfg);
2568 isp1362_show_reg(isp1362_hcd, HCHWCFG);
2569 isp1362_write_reg16(isp1362_hcd, HCDMACFG, 0);
2570 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2571
2572 ret = isp1362_mem_config(hcd);
2573 if (ret)
2574 return ret;
2575
2576 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2577
2578 /* Root hub conf */
2579 isp1362_hcd->rhdesca = 0;
2580 if (board->no_power_switching)
2581 isp1362_hcd->rhdesca |= RH_A_NPS;
2582 if (board->power_switching_mode)
2583 isp1362_hcd->rhdesca |= RH_A_PSM;
2584 if (board->potpg)
2585 isp1362_hcd->rhdesca |= (board->potpg << 24) & RH_A_POTPGT;
2586 else
2587 isp1362_hcd->rhdesca |= (25 << 24) & RH_A_POTPGT;
2588
2589 isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca & ~RH_A_OCPM);
2590 isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca | RH_A_OCPM);
2591 isp1362_hcd->rhdesca = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
2592
2593 isp1362_hcd->rhdescb = RH_B_PPCM;
2594 isp1362_write_reg32(isp1362_hcd, HCRHDESCB, isp1362_hcd->rhdescb);
2595 isp1362_hcd->rhdescb = isp1362_read_reg32(isp1362_hcd, HCRHDESCB);
2596
2597 isp1362_read_reg32(isp1362_hcd, HCFMINTVL);
2598 isp1362_write_reg32(isp1362_hcd, HCFMINTVL, (FSMP(FI) << 16) | FI);
2599 isp1362_write_reg32(isp1362_hcd, HCLSTHRESH, LSTHRESH);
2600
2601 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2602
2603 isp1362_hcd->hc_control = OHCI_USB_OPER;
2604 hcd->state = HC_STATE_RUNNING;
2605
2606 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2607 /* Set up interrupts */
2608 isp1362_hcd->intenb = OHCI_INTR_MIE | OHCI_INTR_RHSC | OHCI_INTR_UE;
2609 isp1362_hcd->intenb |= OHCI_INTR_RD;
2610 isp1362_hcd->irqenb = HCuPINT_OPR | HCuPINT_SUSP;
2611 isp1362_write_reg32(isp1362_hcd, HCINTENB, isp1362_hcd->intenb);
2612 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
2613
2614 /* Go operational */
2615 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
2616 /* enable global power */
2617 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC | RH_HS_DRWE);
2618
2619 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2620
2621 return 0;
2622 }
2623
2624 /*-------------------------------------------------------------------------*/
2625
2626 static struct hc_driver isp1362_hc_driver = {
2627 .description = hcd_name,
2628 .product_desc = "ISP1362 Host Controller",
2629 .hcd_priv_size = sizeof(struct isp1362_hcd),
2630
2631 .irq = isp1362_irq,
2632 .flags = HCD_USB11 | HCD_MEMORY,
2633
2634 .reset = isp1362_hc_reset,
2635 .start = isp1362_hc_start,
2636 .stop = isp1362_hc_stop,
2637
2638 .urb_enqueue = isp1362_urb_enqueue,
2639 .urb_dequeue = isp1362_urb_dequeue,
2640 .endpoint_disable = isp1362_endpoint_disable,
2641
2642 .get_frame_number = isp1362_get_frame,
2643
2644 .hub_status_data = isp1362_hub_status_data,
2645 .hub_control = isp1362_hub_control,
2646 .bus_suspend = isp1362_bus_suspend,
2647 .bus_resume = isp1362_bus_resume,
2648 };
2649
2650 /*-------------------------------------------------------------------------*/
2651
2652 static int __devexit isp1362_remove(struct platform_device *pdev)
2653 {
2654 struct usb_hcd *hcd = platform_get_drvdata(pdev);
2655 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2656 struct resource *res;
2657
2658 remove_debug_file(isp1362_hcd);
2659 DBG(0, "%s: Removing HCD\n", __func__);
2660 usb_remove_hcd(hcd);
2661
2662 DBG(0, "%s: Unmapping data_reg @ %p\n", __func__,
2663 isp1362_hcd->data_reg);
2664 iounmap(isp1362_hcd->data_reg);
2665
2666 DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__,
2667 isp1362_hcd->addr_reg);
2668 iounmap(isp1362_hcd->addr_reg);
2669
2670 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2671 DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
2672 if (res)
2673 release_mem_region(res->start, resource_size(res));
2674
2675 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2676 DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
2677 if (res)
2678 release_mem_region(res->start, resource_size(res));
2679
2680 DBG(0, "%s: put_hcd\n", __func__);
2681 usb_put_hcd(hcd);
2682 DBG(0, "%s: Done\n", __func__);
2683
2684 return 0;
2685 }
2686
2687 static int __init isp1362_probe(struct platform_device *pdev)
2688 {
2689 struct usb_hcd *hcd;
2690 struct isp1362_hcd *isp1362_hcd;
2691 struct resource *addr, *data;
2692 void __iomem *addr_reg;
2693 void __iomem *data_reg;
2694 int irq;
2695 int retval = 0;
2696 struct resource *irq_res;
2697 unsigned int irq_flags = 0;
2698
2699 /* basic sanity checks first. board-specific init logic should
2700 * have initialized this the three resources and probably board
2701 * specific platform_data. we don't probe for IRQs, and do only
2702 * minimal sanity checking.
2703 */
2704 if (pdev->num_resources < 3) {
2705 retval = -ENODEV;
2706 goto err1;
2707 }
2708
2709 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2710 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2711 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2712 if (!addr || !data || !irq_res) {
2713 retval = -ENODEV;
2714 goto err1;
2715 }
2716 irq = irq_res->start;
2717
2718 if (pdev->dev.dma_mask) {
2719 DBG(1, "won't do DMA");
2720 retval = -ENODEV;
2721 goto err1;
2722 }
2723
2724 if (!request_mem_region(addr->start, resource_size(addr), hcd_name)) {
2725 retval = -EBUSY;
2726 goto err1;
2727 }
2728 addr_reg = ioremap(addr->start, resource_size(addr));
2729 if (addr_reg == NULL) {
2730 retval = -ENOMEM;
2731 goto err2;
2732 }
2733
2734 if (!request_mem_region(data->start, resource_size(data), hcd_name)) {
2735 retval = -EBUSY;
2736 goto err3;
2737 }
2738 data_reg = ioremap(data->start, resource_size(data));
2739 if (data_reg == NULL) {
2740 retval = -ENOMEM;
2741 goto err4;
2742 }
2743
2744 /* allocate and initialize hcd */
2745 hcd = usb_create_hcd(&isp1362_hc_driver, &pdev->dev, dev_name(&pdev->dev));
2746 if (!hcd) {
2747 retval = -ENOMEM;
2748 goto err5;
2749 }
2750 hcd->rsrc_start = data->start;
2751 isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2752 isp1362_hcd->data_reg = data_reg;
2753 isp1362_hcd->addr_reg = addr_reg;
2754
2755 isp1362_hcd->next_statechange = jiffies;
2756 spin_lock_init(&isp1362_hcd->lock);
2757 INIT_LIST_HEAD(&isp1362_hcd->async);
2758 INIT_LIST_HEAD(&isp1362_hcd->periodic);
2759 INIT_LIST_HEAD(&isp1362_hcd->isoc);
2760 INIT_LIST_HEAD(&isp1362_hcd->remove_list);
2761 isp1362_hcd->board = pdev->dev.platform_data;
2762 #if USE_PLATFORM_DELAY
2763 if (!isp1362_hcd->board->delay) {
2764 dev_err(hcd->self.controller, "No platform delay function given\n");
2765 retval = -ENODEV;
2766 goto err6;
2767 }
2768 #endif
2769
2770 if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2771 irq_flags |= IRQF_TRIGGER_RISING;
2772 if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2773 irq_flags |= IRQF_TRIGGER_FALLING;
2774 if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2775 irq_flags |= IRQF_TRIGGER_HIGH;
2776 if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2777 irq_flags |= IRQF_TRIGGER_LOW;
2778
2779 retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_DISABLED | IRQF_SHARED);
2780 if (retval != 0)
2781 goto err6;
2782 pr_info("%s, irq %d\n", hcd->product_desc, irq);
2783
2784 create_debug_file(isp1362_hcd);
2785
2786 return 0;
2787
2788 err6:
2789 DBG(0, "%s: Freeing dev %p\n", __func__, isp1362_hcd);
2790 usb_put_hcd(hcd);
2791 err5:
2792 DBG(0, "%s: Unmapping data_reg @ %p\n", __func__, data_reg);
2793 iounmap(data_reg);
2794 err4:
2795 DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)data->start);
2796 release_mem_region(data->start, resource_size(data));
2797 err3:
2798 DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__, addr_reg);
2799 iounmap(addr_reg);
2800 err2:
2801 DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)addr->start);
2802 release_mem_region(addr->start, resource_size(addr));
2803 err1:
2804 pr_err("%s: init error, %d\n", __func__, retval);
2805
2806 return retval;
2807 }
2808
2809 #ifdef CONFIG_PM
2810 static int isp1362_suspend(struct platform_device *pdev, pm_message_t state)
2811 {
2812 struct usb_hcd *hcd = platform_get_drvdata(pdev);
2813 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2814 unsigned long flags;
2815 int retval = 0;
2816
2817 DBG(0, "%s: Suspending device\n", __func__);
2818
2819 if (state.event == PM_EVENT_FREEZE) {
2820 DBG(0, "%s: Suspending root hub\n", __func__);
2821 retval = isp1362_bus_suspend(hcd);
2822 } else {
2823 DBG(0, "%s: Suspending RH ports\n", __func__);
2824 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2825 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
2826 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2827 }
2828 if (retval == 0)
2829 pdev->dev.power.power_state = state;
2830 return retval;
2831 }
2832
2833 static int isp1362_resume(struct platform_device *pdev)
2834 {
2835 struct usb_hcd *hcd = platform_get_drvdata(pdev);
2836 struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2837 unsigned long flags;
2838
2839 DBG(0, "%s: Resuming\n", __func__);
2840
2841 if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2842 DBG(0, "%s: Resume RH ports\n", __func__);
2843 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2844 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC);
2845 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2846 return 0;
2847 }
2848
2849 pdev->dev.power.power_state = PMSG_ON;
2850
2851 return isp1362_bus_resume(isp1362_hcd_to_hcd(isp1362_hcd));
2852 }
2853 #else
2854 #define isp1362_suspend NULL
2855 #define isp1362_resume NULL
2856 #endif
2857
2858 static struct platform_driver isp1362_driver = {
2859 .probe = isp1362_probe,
2860 .remove = __devexit_p(isp1362_remove),
2861
2862 .suspend = isp1362_suspend,
2863 .resume = isp1362_resume,
2864 .driver = {
2865 .name = (char *)hcd_name,
2866 .owner = THIS_MODULE,
2867 },
2868 };
2869
2870 /*-------------------------------------------------------------------------*/
2871
2872 static int __init isp1362_init(void)
2873 {
2874 if (usb_disabled())
2875 return -ENODEV;
2876 pr_info("driver %s, %s\n", hcd_name, DRIVER_VERSION);
2877 return platform_driver_register(&isp1362_driver);
2878 }
2879 module_init(isp1362_init);
2880
2881 static void __exit isp1362_cleanup(void)
2882 {
2883 platform_driver_unregister(&isp1362_driver);
2884 }
2885 module_exit(isp1362_cleanup);
Linux 2.6 libata-dev (mirror)