projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'for-4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/kishon/linux...
[deliverable/linux.git] / drivers / usb / host / isp116x-hcd.c
CommitLineData
4808a1c0
OK		 1/*
2 * ISP116x HCD (Host Controller Driver) for USB.
3 *
4 * Derived from the SL811 HCD, rewritten for ISP116x.
5 * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
6 *
7 * Portions:
8 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
9 * Copyright (C) 2004 David Brownell
10 *
11 * Periodic scheduling is based on Roman's OHCI code
12 * Copyright (C) 1999 Roman Weissgaerber
13 *
14 */
15
16/*
17 * The driver basically works. A number of people have used it with a range
18 * of devices.
19 *
17f8bb73 20 * The driver passes all usbtests 1-14.
4808a1c0
OK		 21 *
22 * Suspending/resuming of root hub via sysfs works. Remote wakeup works too.
23 * And suspending/resuming of platform device works too. Suspend/resume
24 * via HCD operations vector is not implemented.
25 *
26 * Iso transfer support is not implemented. Adding this would include
27 * implementing recovery from the failure to service the processed ITL
28 * fifo ram in time, which will involve chip reset.
29 *
30 * TODO:
31 + More testing of suspend/resume.
32*/
33
34/*
35 ISP116x chips require certain delays between accesses to its
36 registers. The following timing options exist.
37
38 1. Configure your memory controller (the best)
39 2. Implement platform-specific delay function possibly
40 combined with configuring the memory controller; see
41 include/linux/usb-isp116x.h for more info. Some broken
42 memory controllers line LH7A400 SMC need this. Also,
43 uncomment for that to work the following
44 USE_PLATFORM_DELAY macro.
45 3. Use ndelay (easiest, poorest). For that, uncomment
46 the following USE_NDELAY macro.
47*/
48#define USE_PLATFORM_DELAY
49//#define USE_NDELAY
50
51//#define DEBUG
52//#define VERBOSE
53/* Transfer descriptors. See dump_ptd() for printout format */
54//#define PTD_TRACE
55/* enqueuing/finishing log of urbs */
56//#define URB_TRACE
57
4808a1c0 58#include <linux/module.h>
4808a1c0 59#include <linux/delay.h>
959eea21
OK		 60#include <linux/debugfs.h>
61#include <linux/seq_file.h>
4808a1c0 62#include <linux/errno.h>
4808a1c0 63#include <linux/list.h>
5a0e3ad6 64#include <linux/slab.h>
4808a1c0 65#include <linux/usb.h>
325a4af6 66#include <linux/usb/isp116x.h>
27729aad 67#include <linux/usb/hcd.h>
d052d1be 68#include <linux/platform_device.h>
4808a1c0
OK		 69
70#include <asm/io.h>
71#include <asm/irq.h>
4808a1c0
OK		 72#include <asm/byteorder.h>
73
4808a1c0
OK		 74#include "isp116x.h"
75
959eea21 76#define DRIVER_VERSION "03 Nov 2005"
4808a1c0
OK		 77#define DRIVER_DESC "ISP116x USB Host Controller Driver"
78
79MODULE_DESCRIPTION(DRIVER_DESC);
80MODULE_LICENSE("GPL");
81
82static const char hcd_name[] = "isp116x-hcd";
83
84/*-----------------------------------------------------------------*/
85
86/*
87 Write len bytes to fifo, pad till 32-bit boundary
88 */
89static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
90{
91 u8 *dp = (u8 *) buf;
92 u16 *dp2 = (u16 *) buf;
93 u16 w;
94 int quot = len % 4;
95
28874b7e
JM		 96 /* buffer is already in 'usb data order', which is LE. */
97 /* When reading buffer as u16, we have to take care byte order */
98 /* doesn't get mixed up */
99
4808a1c0
OK		 100 if ((unsigned long)dp2 & 1) {
101 /* not aligned */
102 for (; len > 1; len -= 2) {
103 w = *dp++;
104 w |= *dp++ << 8;
105 isp116x_raw_write_data16(isp116x, w);
106 }
107 if (len)
108 isp116x_write_data16(isp116x, (u16) * dp);
109 } else {
110 /* aligned */
28874b7e
JM		 111 for (; len > 1; len -= 2) {
112 /* Keep byte order ! */
113 isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
114 }
115
4808a1c0
OK		 116 if (len)
117 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
118 }
119 if (quot == 1 || quot == 2)
120 isp116x_raw_write_data16(isp116x, 0);
121}
122
123/*
124 Read len bytes from fifo and then read till 32-bit boundary.
125 */
126static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
127{
128 u8 *dp = (u8 *) buf;
129 u16 *dp2 = (u16 *) buf;
130 u16 w;
131 int quot = len % 4;
132
28874b7e
JM		 133 /* buffer is already in 'usb data order', which is LE. */
134 /* When reading buffer as u16, we have to take care byte order */
135 /* doesn't get mixed up */
136
4808a1c0
OK		 137 if ((unsigned long)dp2 & 1) {
138 /* not aligned */
139 for (; len > 1; len -= 2) {
140 w = isp116x_raw_read_data16(isp116x);
141 *dp++ = w & 0xff;
142 *dp++ = (w >> 8) & 0xff;
143 }
28874b7e 144
4808a1c0
OK		 145 if (len)
146 *dp = 0xff & isp116x_read_data16(isp116x);
147 } else {
148 /* aligned */
28874b7e
JM		 149 for (; len > 1; len -= 2) {
150 /* Keep byte order! */
151 *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
152 }
153
4808a1c0
OK		 154 if (len)
155 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
156 }
157 if (quot == 1 || quot == 2)
158 isp116x_raw_read_data16(isp116x);
159}
160
161/*
162 Write ptd's and data for scheduled transfers into
163 the fifo ram. Fifo must be empty and ready.
164*/
165static void pack_fifo(struct isp116x *isp116x)
166{
167 struct isp116x_ep *ep;
168 struct ptd *ptd;
169 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
170 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
4808a1c0
OK		 171
172 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
173 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
174 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
175 for (ep = isp116x->atl_active; ep; ep = ep->active) {
4808a1c0
OK		 176 ptd = &ep->ptd;
177 dump_ptd(ptd);
178 dump_ptd_out_data(ptd, ep->data);
179 isp116x_write_data16(isp116x, ptd->count);
180 isp116x_write_data16(isp116x, ptd->mps);
181 isp116x_write_data16(isp116x, ptd->len);
182 isp116x_write_data16(isp116x, ptd->faddr);
183 buflen -= sizeof(struct ptd);
184 /* Skip writing data for last IN PTD */
185 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
186 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
187 buflen -= ALIGN(ep->length, 4);
188 }
189 }
190 BUG_ON(buflen);
191}
192
193/*
194 Read the processed ptd's and data from fifo ram back to
195 URBs' buffers. Fifo must be full and done
196*/
197static void unpack_fifo(struct isp116x *isp116x)
198{
199 struct isp116x_ep *ep;
200 struct ptd *ptd;
201 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
202 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
203
204 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
205 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
206 isp116x_write_addr(isp116x, HCATLPORT);
207 for (ep = isp116x->atl_active; ep; ep = ep->active) {
208 ptd = &ep->ptd;
209 ptd->count = isp116x_read_data16(isp116x);
210 ptd->mps = isp116x_read_data16(isp116x);
211 ptd->len = isp116x_read_data16(isp116x);
212 ptd->faddr = isp116x_read_data16(isp116x);
213 buflen -= sizeof(struct ptd);
214 /* Skip reading data for last Setup or Out PTD */
215 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
216 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
217 buflen -= ALIGN(ep->length, 4);
218 }
219 dump_ptd(ptd);
220 dump_ptd_in_data(ptd, ep->data);
221 }
222 BUG_ON(buflen);
223}
224
225/*---------------------------------------------------------------*/
226
227/*
228 Set up PTD's.
229*/
230static void preproc_atl_queue(struct isp116x *isp116x)
231{
232 struct isp116x_ep *ep;
233 struct urb *urb;
234 struct ptd *ptd;
f10eff26 235 u16 len;
4808a1c0
OK		 236
237 for (ep = isp116x->atl_active; ep; ep = ep->active) {
f10eff26
OK		 238 u16 toggle = 0, dir = PTD_DIR_SETUP;
239
4808a1c0
OK		 240 BUG_ON(list_empty(&ep->hep->urb_list));
241 urb = container_of(ep->hep->urb_list.next,
242 struct urb, urb_list);
243 ptd = &ep->ptd;
244 len = ep->length;
4808a1c0
OK		 245 ep->data = (unsigned char *)urb->transfer_buffer
246 + urb->actual_length;
247
248 switch (ep->nextpid) {
249 case USB_PID_IN:
250 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
251 dir = PTD_DIR_IN;
252 break;
253 case USB_PID_OUT:
254 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
255 dir = PTD_DIR_OUT;
256 break;
257 case USB_PID_SETUP:
4808a1c0
OK		 258 len = sizeof(struct usb_ctrlrequest);
259 ep->data = urb->setup_packet;
260 break;
261 case USB_PID_ACK:
262 toggle = 1;
263 len = 0;
264 dir = (urb->transfer_buffer_length
265 && usb_pipein(urb->pipe))
266 ? PTD_DIR_OUT : PTD_DIR_IN;
267 break;
268 default:
4808a1c0
OK		 269 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
270 ep->nextpid);
17f8bb73 271 BUG();
4808a1c0
OK		 272 }
273
274 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
275 ptd->mps = PTD_MPS(ep->maxpacket)
276 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
277 | PTD_EP(ep->epnum);
278 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
279 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
4808a1c0
OK		 280 if (!ep->active) {
281 ptd->mps |= PTD_LAST_MSK;
282 isp116x->atl_last_dir = dir;
283 }
284 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
285 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
286 }
287}
288
1b4cd43b
AS		 289/*
290 Take done or failed requests out of schedule. Give back
291 processed urbs.
292*/
293static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
4a00027d 294 struct urb *urb, int status)
1b4cd43b
AS		 295__releases(isp116x->lock) __acquires(isp116x->lock)
296{
297 unsigned i;
298
1b4cd43b
AS		 299 ep->error_count = 0;
300
301 if (usb_pipecontrol(urb->pipe))
302 ep->nextpid = USB_PID_SETUP;
303
304 urb_dbg(urb, "Finish");
305
e9df41c5 306 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
1b4cd43b 307 spin_unlock(&isp116x->lock);
4a00027d 308 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
1b4cd43b
AS		 309 spin_lock(&isp116x->lock);
310
311 /* take idle endpoints out of the schedule */
312 if (!list_empty(&ep->hep->urb_list))
313 return;
314
315 /* async deschedule */
316 if (!list_empty(&ep->schedule)) {
317 list_del_init(&ep->schedule);
318 return;
319 }
320
321 /* periodic deschedule */
322 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
323 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
324 struct isp116x_ep *temp;
325 struct isp116x_ep **prev = &isp116x->periodic[i];
326
327 while (*prev && ((temp = *prev) != ep))
328 prev = &temp->next;
329 if (*prev)
330 *prev = ep->next;
331 isp116x->load[i] -= ep->load;
332 }
333 ep->branch = PERIODIC_SIZE;
334 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
335 ep->load / ep->period;
336
337 /* switch irq type? */
338 if (!--isp116x->periodic_count) {
339 isp116x->irqenb &= ~HCuPINT_SOF;
340 isp116x->irqenb |= HCuPINT_ATL;
341 }
342}
343
4808a1c0
OK		 344/*
345 Analyze transfer results, handle partial transfers and errors
346*/
347static void postproc_atl_queue(struct isp116x *isp116x)
348{
349 struct isp116x_ep *ep;
350 struct urb *urb;
351 struct usb_device *udev;
352 struct ptd *ptd;
353 int short_not_ok;
1b4cd43b 354 int status;
4808a1c0
OK		 355 u8 cc;
356
357 for (ep = isp116x->atl_active; ep; ep = ep->active) {
358 BUG_ON(list_empty(&ep->hep->urb_list));
359 urb =
360 container_of(ep->hep->urb_list.next, struct urb, urb_list);
361 udev = urb->dev;
362 ptd = &ep->ptd;
363 cc = PTD_GET_CC(ptd);
4808a1c0 364 short_not_ok = 1;
1b4cd43b 365 status = -EINPROGRESS;
4808a1c0
OK		 366
367 /* Data underrun is special. For allowed underrun
368 we clear the error and continue as normal. For
369 forbidden underrun we finish the DATA stage
370 immediately while for control transfer,
371 we do a STATUS stage. */
372 if (cc == TD_DATAUNDERRUN) {
1b4cd43b
AS		 373 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
374 usb_pipecontrol(urb->pipe)) {
375 DBG("Allowed or control data underrun\n");
4808a1c0
OK		 376 cc = TD_CC_NOERROR;
377 short_not_ok = 0;
378 } else {
379 ep->error_count = 1;
1b4cd43b
AS		 380 usb_settoggle(udev, ep->epnum,
381 ep->nextpid == USB_PID_OUT,
382 PTD_GET_TOGGLE(ptd));
e9b765de 383 urb->actual_length += PTD_GET_COUNT(ptd);
1b4cd43b
AS		 384 status = cc_to_error[TD_DATAUNDERRUN];
385 goto done;
4808a1c0
OK		 386 }
387 }
4808a1c0
OK		 388
389 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
390 && (++ep->error_count >= 3 || cc == TD_CC_STALL
391 || cc == TD_DATAOVERRUN)) {
1b4cd43b 392 status = cc_to_error[cc];
4808a1c0
OK		 393 if (ep->nextpid == USB_PID_ACK)
394 ep->nextpid = 0;
1b4cd43b 395 goto done;
4808a1c0
OK		 396 }
397 /* According to usb spec, zero-length Int transfer signals
398 finishing of the urb. Hey, does this apply only
399 for IN endpoints? */
400 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
1b4cd43b
AS		 401 status = 0;
402 goto done;
4808a1c0
OK		 403 }
404
405 /* Relax after previously failed, but later succeeded
406 or correctly NAK'ed retransmission attempt */
407 if (ep->error_count
408 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
409 ep->error_count = 0;
410
411 /* Take into account idiosyncracies of the isp116x chip
412 regarding toggle bit for failed transfers */
413 if (ep->nextpid == USB_PID_OUT)
414 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
415 ^ (ep->error_count > 0));
416 else if (ep->nextpid == USB_PID_IN)
417 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
418 ^ (ep->error_count > 0));
419
420 switch (ep->nextpid) {
421 case USB_PID_IN:
422 case USB_PID_OUT:
423 urb->actual_length += PTD_GET_COUNT(ptd);
424 if (PTD_GET_ACTIVE(ptd)
425 || (cc != TD_CC_NOERROR && cc < 0x0E))
426 break;
427 if (urb->transfer_buffer_length != urb->actual_length) {
428 if (short_not_ok)
429 break;
430 } else {
431 if (urb->transfer_flags & URB_ZERO_PACKET
432 && ep->nextpid == USB_PID_OUT
433 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
434 DBG("Zero packet requested\n");
435 break;
436 }
437 }
438 /* All data for this URB is transferred, let's finish */
439 if (usb_pipecontrol(urb->pipe))
440 ep->nextpid = USB_PID_ACK;
1b4cd43b
AS		 441 else
442 status = 0;
4808a1c0
OK		 443 break;
444 case USB_PID_SETUP:
445 if (PTD_GET_ACTIVE(ptd)
446 || (cc != TD_CC_NOERROR && cc < 0x0E))
447 break;
448 if (urb->transfer_buffer_length == urb->actual_length)
449 ep->nextpid = USB_PID_ACK;
450 else if (usb_pipeout(urb->pipe)) {
451 usb_settoggle(udev, 0, 1, 1);
452 ep->nextpid = USB_PID_OUT;
453 } else {
454 usb_settoggle(udev, 0, 0, 1);
455 ep->nextpid = USB_PID_IN;
456 }
457 break;
458 case USB_PID_ACK:
459 if (PTD_GET_ACTIVE(ptd)
460 || (cc != TD_CC_NOERROR && cc < 0x0E))
461 break;
b0d9efba 462 status = 0;
4808a1c0
OK		 463 ep->nextpid = 0;
464 break;
465 default:
959eea21 466 BUG();
4808a1c0 467 }
4808a1c0 468
1b4cd43b 469 done:
4a00027d
AS		 470 if (status != -EINPROGRESS || urb->unlinked)
471 finish_request(isp116x, ep, urb, status);
4808a1c0
OK		 472 }
473}
474
475/*
476 Scan transfer lists, schedule transfers, send data off
477 to chip.
478 */
479static void start_atl_transfers(struct isp116x *isp116x)
480{
481 struct isp116x_ep *last_ep = NULL, *ep;
482 struct urb *urb;
483 u16 load = 0;
484 int len, index, speed, byte_time;
485
486 if (atomic_read(&isp116x->atl_finishing))
487 return;
488
489 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
490 return;
491
492 /* FIFO not empty? */
493 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
494 return;
495
496 isp116x->atl_active = NULL;
497 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
498
499 /* Schedule int transfers */
500 if (isp116x->periodic_count) {
501 isp116x->fmindex = index =
502 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
503 if ((load = isp116x->load[index])) {
504 /* Bring all int transfers for this frame
505 into the active queue */
506 isp116x->atl_active = last_ep =
507 isp116x->periodic[index];
508 while (last_ep->next)
509 last_ep = (last_ep->active = last_ep->next);
510 last_ep->active = NULL;
511 }
512 }
513
514 /* Schedule control/bulk transfers */
515 list_for_each_entry(ep, &isp116x->async, schedule) {
516 urb = container_of(ep->hep->urb_list.next,
517 struct urb, urb_list);
518 speed = urb->dev->speed;
519 byte_time = speed == USB_SPEED_LOW
520 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
521
522 if (ep->nextpid == USB_PID_SETUP) {
523 len = sizeof(struct usb_ctrlrequest);
524 } else if (ep->nextpid == USB_PID_ACK) {
525 len = 0;
526 } else {
527 /* Find current free length ... */
528 len = (MAX_LOAD_LIMIT - load) / byte_time;
529
530 /* ... then limit it to configured max size ... */
531 len = min(len, speed == USB_SPEED_LOW ?
532 MAX_TRANSFER_SIZE_LOWSPEED :
533 MAX_TRANSFER_SIZE_FULLSPEED);
534
535 /* ... and finally cut to the multiple of MaxPacketSize,
536 or to the real length if there's enough room. */
537 if (len <
538 (urb->transfer_buffer_length -
539 urb->actual_length)) {
540 len -= len % ep->maxpacket;
541 if (!len)
542 continue;
543 } else
544 len = urb->transfer_buffer_length -
545 urb->actual_length;
546 BUG_ON(len < 0);
547 }
548
549 load += len * byte_time;
550 if (load > MAX_LOAD_LIMIT)
551 break;
552
553 ep->active = NULL;
554 ep->length = len;
555 if (last_ep)
556 last_ep->active = ep;
557 else
558 isp116x->atl_active = ep;
559 last_ep = ep;
560 }
561
562 /* Avoid starving of endpoints */
563 if ((&isp116x->async)->next != (&isp116x->async)->prev)
564 list_move(&isp116x->async, (&isp116x->async)->next);
565
566 if (isp116x->atl_active) {
567 preproc_atl_queue(isp116x);
568 pack_fifo(isp116x);
569 }
570}
571
572/*
573 Finish the processed transfers
574*/
7d12e780 575static void finish_atl_transfers(struct isp116x *isp116x)
4808a1c0 576{
4808a1c0
OK		 577 if (!isp116x->atl_active)
578 return;
579 /* Fifo not ready? */
580 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
581 return;
582
583 atomic_inc(&isp116x->atl_finishing);
584 unpack_fifo(isp116x);
585 postproc_atl_queue(isp116x);
4808a1c0
OK		 586 atomic_dec(&isp116x->atl_finishing);
587}
588
7d12e780 589static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
4808a1c0
OK		 590{
591 struct isp116x *isp116x = hcd_to_isp116x(hcd);
592 u16 irqstat;
593 irqreturn_t ret = IRQ_NONE;
594
595 spin_lock(&isp116x->lock);
596 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
597 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
598 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
599
600 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
601 ret = IRQ_HANDLED;
7d12e780 602 finish_atl_transfers(isp116x);
4808a1c0
OK		 603 }
604
605 if (irqstat & HCuPINT_OPR) {
606 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
607 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
608 if (intstat & HCINT_UE) {
959eea21
OK		 609 ERR("Unrecoverable error, HC is dead!\n");
610 /* IRQ's are off, we do no DMA,
611 perfectly ready to die ... */
612 hcd->state = HC_STATE_HALT;
69fff59d 613 usb_hc_died(hcd);
959eea21
OK		 614 ret = IRQ_HANDLED;
615 goto done;
4808a1c0 616 }
9a57116b
OK		 617 if (intstat & HCINT_RHSC)
618 /* When root hub or any of its ports is going
619 to come out of suspend, it may take more
620 than 10ms for status bits to stabilize. */
621 mod_timer(&hcd->rh_timer, jiffies
622 + msecs_to_jiffies(20) + 1);
4808a1c0
OK		 623 if (intstat & HCINT_RD) {
624 DBG("---- remote wakeup\n");
ccdcf77a 625 usb_hcd_resume_root_hub(hcd);
4808a1c0
OK		 626 }
627 irqstat &= ~HCuPINT_OPR;
628 ret = IRQ_HANDLED;
629 }
630
631 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
632 start_atl_transfers(isp116x);
633 }
634
635 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
959eea21 636 done:
4808a1c0
OK		 637 spin_unlock(&isp116x->lock);
638 return ret;
639}
640
641/*-----------------------------------------------------------------*/
642
643/* usb 1.1 says max 90% of a frame is available for periodic transfers.
644 * this driver doesn't promise that much since it's got to handle an
645 * IRQ per packet; irq handling latencies also use up that time.
646 */
647
648/* out of 1000 us */
649#define MAX_PERIODIC_LOAD 600
650static int balance(struct isp116x *isp116x, u16 period, u16 load)
651{
652 int i, branch = -ENOSPC;
653
654 /* search for the least loaded schedule branch of that period
655 which has enough bandwidth left unreserved. */
656 for (i = 0; i < period; i++) {
657 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
658 int j;
659
660 for (j = i; j < PERIODIC_SIZE; j += period) {
661 if ((isp116x->load[j] + load)
662 > MAX_PERIODIC_LOAD)
663 break;
664 }
665 if (j < PERIODIC_SIZE)
666 continue;
667 branch = i;
668 }
669 }
670 return branch;
671}
672
673/* NB! ALL the code above this point runs with isp116x->lock
674 held, irqs off
675*/
676
677/*-----------------------------------------------------------------*/
678
679static int isp116x_urb_enqueue(struct usb_hcd *hcd,
e9df41c5 680 struct urb *urb,
55016f10 681 gfp_t mem_flags)
4808a1c0
OK		 682{
683 struct isp116x *isp116x = hcd_to_isp116x(hcd);
684 struct usb_device *udev = urb->dev;
685 unsigned int pipe = urb->pipe;
686 int is_out = !usb_pipein(pipe);
687 int type = usb_pipetype(pipe);
688 int epnum = usb_pipeendpoint(pipe);
e9df41c5 689 struct usb_host_endpoint *hep = urb->ep;
4808a1c0
OK		 690 struct isp116x_ep *ep = NULL;
691 unsigned long flags;
692 int i;
693 int ret = 0;
694
695 urb_dbg(urb, "Enqueue");
696
697 if (type == PIPE_ISOCHRONOUS) {
698 ERR("Isochronous transfers not supported\n");
699 urb_dbg(urb, "Refused to enqueue");
700 return -ENXIO;
701 }
702 /* avoid all allocations within spinlocks: request or endpoint */
703 if (!hep->hcpriv) {
7b842b6e 704 ep = kzalloc(sizeof *ep, mem_flags);
4808a1c0
OK		 705 if (!ep)
706 return -ENOMEM;
707 }
708
709 spin_lock_irqsave(&isp116x->lock, flags);
710 if (!HC_IS_RUNNING(hcd->state)) {
959eea21 711 kfree(ep);
4808a1c0 712 ret = -ENODEV;
e9df41c5
AS		 713 goto fail_not_linked;
714 }
715 ret = usb_hcd_link_urb_to_ep(hcd, urb);
716 if (ret) {
717 kfree(ep);
718 goto fail_not_linked;
4808a1c0
OK		 719 }
720
721 if (hep->hcpriv)
722 ep = hep->hcpriv;
723 else {
724 INIT_LIST_HEAD(&ep->schedule);
6a8e87b2 725 ep->udev = udev;
4808a1c0
OK		 726 ep->epnum = epnum;
727 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
728 usb_settoggle(udev, epnum, is_out, 0);
729
730 if (type == PIPE_CONTROL) {
731 ep->nextpid = USB_PID_SETUP;
732 } else if (is_out) {
733 ep->nextpid = USB_PID_OUT;
734 } else {
735 ep->nextpid = USB_PID_IN;
736 }
737
738 if (urb->interval) {
739 /*
740 With INT URBs submitted, the driver works with SOF
741 interrupt enabled and ATL interrupt disabled. After
742 the PTDs are written to fifo ram, the chip starts
743 fifo processing and usb transfers after the next
744 SOF and continues until the transfers are finished
745 (succeeded or failed) or the frame ends. Therefore,
746 the transfers occur only in every second frame,
747 while fifo reading/writing and data processing
748 occur in every other second frame. */
749 if (urb->interval < 2)
750 urb->interval = 2;
751 if (urb->interval > 2 * PERIODIC_SIZE)
752 urb->interval = 2 * PERIODIC_SIZE;
753 ep->period = urb->interval >> 1;
754 ep->branch = PERIODIC_SIZE;
755 ep->load = usb_calc_bus_time(udev->speed,
756 !is_out,
757 (type == PIPE_ISOCHRONOUS),
758 usb_maxpacket(udev, pipe,
759 is_out)) /
760 1000;
761 }
762 hep->hcpriv = ep;
763 ep->hep = hep;
764 }
765
766 /* maybe put endpoint into schedule */
767 switch (type) {
768 case PIPE_CONTROL:
769 case PIPE_BULK:
770 if (list_empty(&ep->schedule))
771 list_add_tail(&ep->schedule, &isp116x->async);
772 break;
773 case PIPE_INTERRUPT:
774 urb->interval = ep->period;
16e2e5f6 775 ep->length = min_t(u32, ep->maxpacket,
4808a1c0
OK		 776 urb->transfer_buffer_length);
777
778 /* urb submitted for already existing endpoint */
779 if (ep->branch < PERIODIC_SIZE)
780 break;
781
d5ce1379 782 ep->branch = ret = balance(isp116x, ep->period, ep->load);
4808a1c0
OK		 783 if (ret < 0)
784 goto fail;
785 ret = 0;
786
787 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
788 + ep->branch;
789
790 /* sort each schedule branch by period (slow before fast)
791 to share the faster parts of the tree without needing
792 dummy/placeholder nodes */
793 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
794 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
795 struct isp116x_ep **prev = &isp116x->periodic[i];
796 struct isp116x_ep *here = *prev;
797
798 while (here && ep != here) {
799 if (ep->period > here->period)
800 break;
801 prev = &here->next;
802 here = *prev;
803 }
804 if (ep != here) {
805 ep->next = here;
806 *prev = ep;
807 }
808 isp116x->load[i] += ep->load;
809 }
810 hcd->self.bandwidth_allocated += ep->load / ep->period;
811
812 /* switch over to SOFint */
813 if (!isp116x->periodic_count++) {
814 isp116x->irqenb &= ~HCuPINT_ATL;
815 isp116x->irqenb |= HCuPINT_SOF;
816 isp116x_write_reg16(isp116x, HCuPINTENB,
817 isp116x->irqenb);
818 }
819 }
820
4808a1c0 821 urb->hcpriv = hep;
4808a1c0
OK		 822 start_atl_transfers(isp116x);
823
824 fail:
e9df41c5
AS		 825 if (ret)
826 usb_hcd_unlink_urb_from_ep(hcd, urb);
827 fail_not_linked:
4808a1c0
OK		 828 spin_unlock_irqrestore(&isp116x->lock, flags);
829 return ret;
830}
831
832/*
833 Dequeue URBs.
834*/
e9df41c5
AS		 835static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
836 int status)
4808a1c0
OK		 837{
838 struct isp116x *isp116x = hcd_to_isp116x(hcd);
839 struct usb_host_endpoint *hep;
840 struct isp116x_ep *ep, *ep_act;
841 unsigned long flags;
e9df41c5 842 int rc;
4808a1c0
OK		 843
844 spin_lock_irqsave(&isp116x->lock, flags);
e9df41c5
AS		 845 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
846 if (rc)
847 goto done;
848
4808a1c0 849 hep = urb->hcpriv;
4808a1c0
OK		 850 ep = hep->hcpriv;
851 WARN_ON(hep != ep->hep);
852
853 /* In front of queue? */
854 if (ep->hep->urb_list.next == &urb->urb_list)
855 /* active? */
856 for (ep_act = isp116x->atl_active; ep_act;
857 ep_act = ep_act->active)
858 if (ep_act == ep) {
859 VDBG("dequeue, urb %p active; wait for irq\n",
860 urb);
861 urb = NULL;
862 break;
863 }
864
865 if (urb)
4a00027d 866 finish_request(isp116x, ep, urb, status);
e9df41c5 867 done:
4808a1c0 868 spin_unlock_irqrestore(&isp116x->lock, flags);
e9df41c5 869 return rc;
4808a1c0
OK		 870}
871
872static void isp116x_endpoint_disable(struct usb_hcd *hcd,
873 struct usb_host_endpoint *hep)
874{
875 int i;
959eea21 876 struct isp116x_ep *ep = hep->hcpriv;
4808a1c0
OK		 877
878 if (!ep)
879 return;
880
881 /* assume we'd just wait for the irq */
882 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
883 msleep(3);
884 if (!list_empty(&hep->urb_list))
b6c63937 885 WARNING("ep %p not empty?\n", ep);
4808a1c0 886
4808a1c0
OK		 887 kfree(ep);
888 hep->hcpriv = NULL;
889}
890
891static int isp116x_get_frame(struct usb_hcd *hcd)
892{
893 struct isp116x *isp116x = hcd_to_isp116x(hcd);
894 u32 fmnum;
895 unsigned long flags;
896
897 spin_lock_irqsave(&isp116x->lock, flags);
898 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
899 spin_unlock_irqrestore(&isp116x->lock, flags);
900 return (int)fmnum;
901}
902
4808a1c0
OK		 903/*
904 Adapted from ohci-hub.c. Currently we don't support autosuspend.
905*/
906static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
907{
908 struct isp116x *isp116x = hcd_to_isp116x(hcd);
909 int ports, i, changed = 0;
9a57116b 910 unsigned long flags;
4808a1c0
OK		 911
912 if (!HC_IS_RUNNING(hcd->state))
913 return -ESHUTDOWN;
914
9a57116b
OK		 915 /* Report no status change now, if we are scheduled to be
916 called later */
917 if (timer_pending(&hcd->rh_timer))
918 return 0;
4808a1c0 919
9a57116b
OK		 920 ports = isp116x->rhdesca & RH_A_NDP;
921 spin_lock_irqsave(&isp116x->lock, flags);
922 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
4808a1c0
OK		 923 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
924 buf[0] = changed = 1;
925 else
926 buf[0] = 0;
927
928 for (i = 0; i < ports; i++) {
0ed930bf 929 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
4808a1c0
OK		 930
931 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
932 | RH_PS_OCIC | RH_PS_PRSC)) {
933 changed = 1;
934 buf[0] |= 1 << (i + 1);
4808a1c0
OK		 935 }
936 }
9a57116b 937 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 938 return changed;
939}
940
941static void isp116x_hub_descriptor(struct isp116x *isp116x,
942 struct usb_hub_descriptor *desc)
943{
944 u32 reg = isp116x->rhdesca;
945
6a085567 946 desc->bDescriptorType = USB_DT_HUB;
4808a1c0
OK		 947 desc->bDescLength = 9;
948 desc->bHubContrCurrent = 0;
949 desc->bNbrPorts = (u8) (reg & 0x3);
950 /* Power switching, device type, overcurrent. */
f3c4140d
SS		 951 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) &
952 (HUB_CHAR_LPSM |
953 HUB_CHAR_COMPOUND |
954 HUB_CHAR_OCPM)));
4808a1c0 955 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
da13051c 956 /* ports removable, and legacy PortPwrCtrlMask */
dbe79bbe
JY		 957 desc->u.hs.DeviceRemovable[0] = 0;
958 desc->u.hs.DeviceRemovable[1] = ~0;
4808a1c0
OK		 959}
960
961/* Perform reset of a given port.
962 It would be great to just start the reset and let the
963 USB core to clear the reset in due time. However,
964 root hub ports should be reset for at least 50 ms, while
965 our chip stays in reset for about 10 ms. I.e., we must
966 repeatedly reset it ourself here.
967*/
968static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
969{
970 u32 tmp;
971 unsigned long flags, t;
972
973 /* Root hub reset should be 50 ms, but some devices
974 want it even longer. */
975 t = jiffies + msecs_to_jiffies(100);
976
977 while (time_before(jiffies, t)) {
978 spin_lock_irqsave(&isp116x->lock, flags);
979 /* spin until any current reset finishes */
980 for (;;) {
981 tmp = isp116x_read_reg32(isp116x, port ?
982 HCRHPORT2 : HCRHPORT1);
983 if (!(tmp & RH_PS_PRS))
984 break;
985 udelay(500);
986 }
987 /* Don't reset a disconnected port */
988 if (!(tmp & RH_PS_CCS)) {
989 spin_unlock_irqrestore(&isp116x->lock, flags);
990 break;
991 }
992 /* Reset lasts 10ms (claims datasheet) */
993 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
994 HCRHPORT1, (RH_PS_PRS));
995 spin_unlock_irqrestore(&isp116x->lock, flags);
996 msleep(10);
997 }
998}
999
1000/* Adapted from ohci-hub.c */
1001static int isp116x_hub_control(struct usb_hcd *hcd,
1002 u16 typeReq,
1003 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1004{
1005 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1006 int ret = 0;
1007 unsigned long flags;
1008 int ports = isp116x->rhdesca & RH_A_NDP;
1009 u32 tmp = 0;
1010
1011 switch (typeReq) {
1012 case ClearHubFeature:
1013 DBG("ClearHubFeature: ");
1014 switch (wValue) {
1015 case C_HUB_OVER_CURRENT:
1016 DBG("C_HUB_OVER_CURRENT\n");
1017 spin_lock_irqsave(&isp116x->lock, flags);
1018 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1019 spin_unlock_irqrestore(&isp116x->lock, flags);
1020 case C_HUB_LOCAL_POWER:
1021 DBG("C_HUB_LOCAL_POWER\n");
1022 break;
1023 default:
1024 goto error;
1025 }
1026 break;
1027 case SetHubFeature:
1028 DBG("SetHubFeature: ");
1029 switch (wValue) {
1030 case C_HUB_OVER_CURRENT:
1031 case C_HUB_LOCAL_POWER:
1032 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1033 break;
1034 default:
1035 goto error;
1036 }
1037 break;
1038 case GetHubDescriptor:
1039 DBG("GetHubDescriptor\n");
1040 isp116x_hub_descriptor(isp116x,
1041 (struct usb_hub_descriptor *)buf);
1042 break;
1043 case GetHubStatus:
1044 DBG("GetHubStatus\n");
17f8bb73 1045 *(__le32 *) buf = 0;
4808a1c0
OK		 1046 break;
1047 case GetPortStatus:
1048 DBG("GetPortStatus\n");
1049 if (!wIndex || wIndex > ports)
1050 goto error;
0ed930bf
AS		 1051 spin_lock_irqsave(&isp116x->lock, flags);
1052 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1053 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 1054 *(__le32 *) buf = cpu_to_le32(tmp);
1055 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1056 break;
1057 case ClearPortFeature:
1058 DBG("ClearPortFeature: ");
1059 if (!wIndex || wIndex > ports)
1060 goto error;
1061 wIndex--;
1062
1063 switch (wValue) {
1064 case USB_PORT_FEAT_ENABLE:
1065 DBG("USB_PORT_FEAT_ENABLE\n");
1066 tmp = RH_PS_CCS;
1067 break;
1068 case USB_PORT_FEAT_C_ENABLE:
1069 DBG("USB_PORT_FEAT_C_ENABLE\n");
1070 tmp = RH_PS_PESC;
1071 break;
1072 case USB_PORT_FEAT_SUSPEND:
1073 DBG("USB_PORT_FEAT_SUSPEND\n");
1074 tmp = RH_PS_POCI;
1075 break;
1076 case USB_PORT_FEAT_C_SUSPEND:
1077 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1078 tmp = RH_PS_PSSC;
1079 break;
1080 case USB_PORT_FEAT_POWER:
1081 DBG("USB_PORT_FEAT_POWER\n");
1082 tmp = RH_PS_LSDA;
1083 break;
1084 case USB_PORT_FEAT_C_CONNECTION:
1085 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1086 tmp = RH_PS_CSC;
1087 break;
1088 case USB_PORT_FEAT_C_OVER_CURRENT:
1089 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1090 tmp = RH_PS_OCIC;
1091 break;
1092 case USB_PORT_FEAT_C_RESET:
1093 DBG("USB_PORT_FEAT_C_RESET\n");
1094 tmp = RH_PS_PRSC;
1095 break;
1096 default:
1097 goto error;
1098 }
1099 spin_lock_irqsave(&isp116x->lock, flags);
1100 isp116x_write_reg32(isp116x, wIndex
1101 ? HCRHPORT2 : HCRHPORT1, tmp);
4808a1c0
OK		 1102 spin_unlock_irqrestore(&isp116x->lock, flags);
1103 break;
1104 case SetPortFeature:
1105 DBG("SetPortFeature: ");
1106 if (!wIndex || wIndex > ports)
1107 goto error;
1108 wIndex--;
1109 switch (wValue) {
1110 case USB_PORT_FEAT_SUSPEND:
1111 DBG("USB_PORT_FEAT_SUSPEND\n");
1112 spin_lock_irqsave(&isp116x->lock, flags);
1113 isp116x_write_reg32(isp116x, wIndex
1114 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
0ed930bf 1115 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 1116 break;
1117 case USB_PORT_FEAT_POWER:
1118 DBG("USB_PORT_FEAT_POWER\n");
1119 spin_lock_irqsave(&isp116x->lock, flags);
1120 isp116x_write_reg32(isp116x, wIndex
1121 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
0ed930bf 1122 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 1123 break;
1124 case USB_PORT_FEAT_RESET:
1125 DBG("USB_PORT_FEAT_RESET\n");
1126 root_port_reset(isp116x, wIndex);
4808a1c0
OK		 1127 break;
1128 default:
1129 goto error;
1130 }
4808a1c0
OK		 1131 break;
1132
1133 default:
1134 error:
1135 /* "protocol stall" on error */
1136 DBG("PROTOCOL STALL\n");
1137 ret = -EPIPE;
1138 }
1139 return ret;
1140}
1141
4808a1c0
OK		 1142/*-----------------------------------------------------------------*/
1143
959eea21 1144#ifdef CONFIG_DEBUG_FS
4808a1c0
OK		 1145
1146static void dump_irq(struct seq_file *s, char *label, u16 mask)
1147{
1148 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1149 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1150 mask & HCuPINT_SUSP ? " susp" : "",
1151 mask & HCuPINT_OPR ? " opr" : "",
1152 mask & HCuPINT_AIIEOT ? " eot" : "",
1153 mask & HCuPINT_ATL ? " atl" : "",
1154 mask & HCuPINT_SOF ? " sof" : "");
1155}
1156
1157static void dump_int(struct seq_file *s, char *label, u32 mask)
1158{
1159 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1160 mask & HCINT_MIE ? " MIE" : "",
1161 mask & HCINT_RHSC ? " rhsc" : "",
1162 mask & HCINT_FNO ? " fno" : "",
1163 mask & HCINT_UE ? " ue" : "",
1164 mask & HCINT_RD ? " rd" : "",
1165 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1166}
1167
959eea21 1168static int isp116x_show_dbg(struct seq_file *s, void *unused)
4808a1c0
OK		 1169{
1170 struct isp116x *isp116x = s->private;
4808a1c0
OK		 1171
1172 seq_printf(s, "%s\n%s version %s\n",
1173 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1174 DRIVER_VERSION);
1175
1176 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1177 seq_printf(s, "HCD is suspended\n");
1178 return 0;
1179 }
1180 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1181 seq_printf(s, "HCD not running\n");
1182 return 0;
1183 }
1184
1185 spin_lock_irq(&isp116x->lock);
4808a1c0
OK		 1186 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1187 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1188 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1189 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
959eea21 1190 isp116x_show_regs_seq(isp116x, s);
4808a1c0
OK		 1191 spin_unlock_irq(&isp116x->lock);
1192 seq_printf(s, "\n");
1193
1194 return 0;
1195}
1196
959eea21 1197static int isp116x_open_seq(struct inode *inode, struct file *file)
4808a1c0 1198{
8e18e294 1199 return single_open(file, isp116x_show_dbg, inode->i_private);
4808a1c0
OK		 1200}
1201
066202dd 1202static const struct file_operations isp116x_debug_fops = {
959eea21 1203 .open = isp116x_open_seq,
4808a1c0
OK		 1204 .read = seq_read,
1205 .llseek = seq_lseek,
1206 .release = single_release,
1207};
1208
959eea21 1209static int create_debug_file(struct isp116x *isp116x)
4808a1c0 1210{
959eea21
OK		 1211 isp116x->dentry = debugfs_create_file(hcd_name,
1212 S_IRUGO, NULL, isp116x,
1213 &isp116x_debug_fops);
1214 if (!isp116x->dentry)
1215 return -ENOMEM;
1216 return 0;
4808a1c0
OK		 1217}
1218
1219static void remove_debug_file(struct isp116x *isp116x)
1220{
959eea21 1221 debugfs_remove(isp116x->dentry);
4808a1c0
OK		 1222}
1223
959eea21
OK		 1224#else
1225
1226#define create_debug_file(d) 0
1227#define remove_debug_file(d) do{}while(0)
1228
1229#endif /* CONFIG_DEBUG_FS */
4808a1c0
OK		 1230
1231/*-----------------------------------------------------------------*/
1232
1233/*
1234 Software reset - can be called from any contect.
1235*/
1236static int isp116x_sw_reset(struct isp116x *isp116x)
1237{
1238 int retries = 15;
1239 unsigned long flags;
1240 int ret = 0;
1241
1242 spin_lock_irqsave(&isp116x->lock, flags);
1243 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1244 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1245 while (--retries) {
1246 /* It usually resets within 1 ms */
1247 mdelay(1);
1248 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1249 break;
1250 }
1251 if (!retries) {
1252 ERR("Software reset timeout\n");
1253 ret = -ETIME;
1254 }
1255 spin_unlock_irqrestore(&isp116x->lock, flags);
1256 return ret;
1257}
1258
4808a1c0
OK		 1259static int isp116x_reset(struct usb_hcd *hcd)
1260{
1261 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1262 unsigned long t;
1263 u16 clkrdy = 0;
959eea21 1264 int ret, timeout = 15 /* ms */ ;
4808a1c0 1265
f8d23d30 1266 ret = isp116x_sw_reset(isp116x);
4808a1c0
OK		 1267 if (ret)
1268 return ret;
1269
1270 t = jiffies + msecs_to_jiffies(timeout);
1271 while (time_before_eq(jiffies, t)) {
1272 msleep(4);
1273 spin_lock_irq(&isp116x->lock);
1274 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1275 spin_unlock_irq(&isp116x->lock);
1276 if (clkrdy)
1277 break;
1278 }
1279 if (!clkrdy) {
959eea21 1280 ERR("Clock not ready after %dms\n", timeout);
589a0083
OK		 1281 /* After sw_reset the clock won't report to be ready, if
1282 H_WAKEUP pin is high. */
f8d23d30 1283 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
4808a1c0
OK		 1284 ret = -ENODEV;
1285 }
1286 return ret;
1287}
1288
1289static void isp116x_stop(struct usb_hcd *hcd)
1290{
1291 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1292 unsigned long flags;
1293 u32 val;
1294
1295 spin_lock_irqsave(&isp116x->lock, flags);
1296 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1297
1298 /* Switch off ports' power, some devices don't come up
1299 after next 'insmod' without this */
1300 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1301 val &= ~(RH_A_NPS | RH_A_PSM);
1302 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1303 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1304 spin_unlock_irqrestore(&isp116x->lock, flags);
1305
f8d23d30 1306 isp116x_sw_reset(isp116x);
4808a1c0
OK		 1307}
1308
1309/*
1310 Configure the chip. The chip must be successfully reset by now.
1311*/
1312static int isp116x_start(struct usb_hcd *hcd)
1313{
1314 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1315 struct isp116x_platform_data *board = isp116x->board;
4808a1c0
OK		 1316 u32 val;
1317 unsigned long flags;
1318
1319 spin_lock_irqsave(&isp116x->lock, flags);
1320
1321 /* clear interrupt status and disable all interrupt sources */
1322 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1323 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1324
1325 val = isp116x_read_reg16(isp116x, HCCHIPID);
1326 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1327 ERR("Invalid chip ID %04x\n", val);
1328 spin_unlock_irqrestore(&isp116x->lock, flags);
1329 return -ENODEV;
1330 }
1331
9a57116b
OK		 1332 /* To be removed in future */
1333 hcd->uses_new_polling = 1;
1334
4808a1c0
OK		 1335 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1336 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1337
1338 /* ----- HW conf */
1339 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1340 if (board->sel15Kres)
1341 val |= HCHWCFG_15KRSEL;
1342 /* Remote wakeup won't work without working clock */
d4d62861 1343 if (board->remote_wakeup_enable)
4808a1c0
OK		 1344 val |= HCHWCFG_CLKNOTSTOP;
1345 if (board->oc_enable)
1346 val |= HCHWCFG_ANALOG_OC;
1347 if (board->int_act_high)
1348 val |= HCHWCFG_INT_POL;
1349 if (board->int_edge_triggered)
1350 val |= HCHWCFG_INT_TRIGGER;
1351 isp116x_write_reg16(isp116x, HCHWCFG, val);
1352
1353 /* ----- Root hub conf */
dc5bed09 1354 val = (25 << 24) & RH_A_POTPGT;
165c0f39
OK		 1355 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1356 be always set. Yet, instead, we request individual port
1357 power switching. */
1358 val |= RH_A_PSM;
9d233d9f
OK		 1359 /* Report overcurrent per port */
1360 val |= RH_A_OCPM;
4808a1c0
OK		 1361 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1362 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1363
1364 val = RH_B_PPCM;
1365 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1366 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1367
1368 val = 0;
1369 if (board->remote_wakeup_enable) {
704aa0b7
DB		 1370 if (!device_can_wakeup(hcd->self.controller))
1371 device_init_wakeup(hcd->self.controller, 1);
4808a1c0
OK		 1372 val |= RH_HS_DRWE;
1373 }
1374 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1375 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1376
1377 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
4808a1c0 1378
4808a1c0
OK		 1379 hcd->state = HC_STATE_RUNNING;
1380
4808a1c0
OK		 1381 /* Set up interrupts */
1382 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1383 if (board->remote_wakeup_enable)
1384 isp116x->intenb |= HCINT_RD;
1385 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1386 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1387 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1388
1389 /* Go operational */
1390 val = HCCONTROL_USB_OPER;
4808a1c0
OK		 1391 if (board->remote_wakeup_enable)
1392 val |= HCCONTROL_RWE;
1393 isp116x_write_reg32(isp116x, HCCONTROL, val);
1394
1395 /* Disable ports to avoid race in device enumeration */
1396 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1397 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1398
959eea21 1399 isp116x_show_regs_log(isp116x);
4808a1c0
OK		 1400 spin_unlock_irqrestore(&isp116x->lock, flags);
1401 return 0;
1402}
1403
959eea21
OK		 1404#ifdef CONFIG_PM
1405
1406static int isp116x_bus_suspend(struct usb_hcd *hcd)
1407{
1408 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1409 unsigned long flags;
1410 u32 val;
1411 int ret = 0;
1412
1413 spin_lock_irqsave(&isp116x->lock, flags);
959eea21 1414 val = isp116x_read_reg32(isp116x, HCCONTROL);
0be930c5 1415
959eea21
OK		 1416 switch (val & HCCONTROL_HCFS) {
1417 case HCCONTROL_USB_OPER:
0be930c5 1418 spin_unlock_irqrestore(&isp116x->lock, flags);
959eea21
OK		 1419 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1420 val |= HCCONTROL_USB_SUSPEND;
58a97ffe 1421 if (hcd->self.root_hub->do_remote_wakeup)
959eea21
OK		 1422 val |= HCCONTROL_RWE;
1423 /* Wait for usb transfers to finish */
0be930c5
OK		 1424 msleep(2);
1425 spin_lock_irqsave(&isp116x->lock, flags);
959eea21 1426 isp116x_write_reg32(isp116x, HCCONTROL, val);
0be930c5 1427 spin_unlock_irqrestore(&isp116x->lock, flags);
959eea21 1428 /* Wait for devices to suspend */
0be930c5 1429 msleep(5);
959eea21
OK		 1430 break;
1431 case HCCONTROL_USB_RESUME:
1432 isp116x_write_reg32(isp116x, HCCONTROL,
1433 (val & ~HCCONTROL_HCFS) |
1434 HCCONTROL_USB_RESET);
1435 case HCCONTROL_USB_RESET:
1436 ret = -EBUSY;
0be930c5
OK		 1437 default: /* HCCONTROL_USB_SUSPEND */
1438 spin_unlock_irqrestore(&isp116x->lock, flags);
959eea21 1439 break;
959eea21
OK		 1440 }
1441
959eea21
OK		 1442 return ret;
1443}
1444
1445static int isp116x_bus_resume(struct usb_hcd *hcd)
1446{
1447 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1448 u32 val;
1449
1450 msleep(5);
1451 spin_lock_irq(&isp116x->lock);
1452
1453 val = isp116x_read_reg32(isp116x, HCCONTROL);
1454 switch (val & HCCONTROL_HCFS) {
1455 case HCCONTROL_USB_SUSPEND:
1456 val &= ~HCCONTROL_HCFS;
1457 val |= HCCONTROL_USB_RESUME;
1458 isp116x_write_reg32(isp116x, HCCONTROL, val);
1459 case HCCONTROL_USB_RESUME:
1460 break;
1461 case HCCONTROL_USB_OPER:
1462 spin_unlock_irq(&isp116x->lock);
959eea21
OK		 1463 return 0;
1464 default:
1465 /* HCCONTROL_USB_RESET: this may happen, when during
1466 suspension the HC lost power. Reinitialize completely */
1467 spin_unlock_irq(&isp116x->lock);
1468 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1469 isp116x_reset(hcd);
1470 isp116x_start(hcd);
1471 isp116x_hub_control(hcd, SetPortFeature,
1472 USB_PORT_FEAT_POWER, 1, NULL, 0);
1473 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1474 isp116x_hub_control(hcd, SetPortFeature,
1475 USB_PORT_FEAT_POWER, 2, NULL, 0);
959eea21
OK		 1476 return 0;
1477 }
1478
1479 val = isp116x->rhdesca & RH_A_NDP;
1480 while (val--) {
1481 u32 stat =
1482 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1483 /* force global, not selective, resume */
1484 if (!(stat & RH_PS_PSS))
1485 continue;
1486 DBG("%s: Resuming port %d\n", __func__, val);
1487 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1488 ? HCRHPORT2 : HCRHPORT1);
1489 }
1490 spin_unlock_irq(&isp116x->lock);
1491
1492 hcd->state = HC_STATE_RESUMING;
8c0ae657 1493 msleep(USB_RESUME_TIMEOUT);
959eea21
OK		 1494
1495 /* Go operational */
1496 spin_lock_irq(&isp116x->lock);
1497 val = isp116x_read_reg32(isp116x, HCCONTROL);
1498 isp116x_write_reg32(isp116x, HCCONTROL,
1499 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1500 spin_unlock_irq(&isp116x->lock);
959eea21
OK		 1501 hcd->state = HC_STATE_RUNNING;
1502
1503 return 0;
1504}
1505
1506#else
1507
1508#define isp116x_bus_suspend NULL
1509#define isp116x_bus_resume NULL
1510
1511#endif
4808a1c0
OK		 1512
1513static struct hc_driver isp116x_hc_driver = {
1514 .description = hcd_name,
1515 .product_desc = "ISP116x Host Controller",
1516 .hcd_priv_size = sizeof(struct isp116x),
1517
1518 .irq = isp116x_irq,
1519 .flags = HCD_USB11,
1520
1521 .reset = isp116x_reset,
1522 .start = isp116x_start,
1523 .stop = isp116x_stop,
1524
1525 .urb_enqueue = isp116x_urb_enqueue,
1526 .urb_dequeue = isp116x_urb_dequeue,
1527 .endpoint_disable = isp116x_endpoint_disable,
1528
1529 .get_frame_number = isp116x_get_frame,
1530
1531 .hub_status_data = isp116x_hub_status_data,
1532 .hub_control = isp116x_hub_control,
0c0382e3
AS		 1533 .bus_suspend = isp116x_bus_suspend,
1534 .bus_resume = isp116x_bus_resume,
4808a1c0
OK		 1535};
1536
1537/*----------------------------------------------------------------*/
1538
b712548c 1539static int isp116x_remove(struct platform_device *pdev)
4808a1c0 1540{
3ae5eaec 1541 struct usb_hcd *hcd = platform_get_drvdata(pdev);
589a0083 1542 struct isp116x *isp116x;
4808a1c0
OK		 1543 struct resource *res;
1544
9a57116b 1545 if (!hcd)
589a0083
OK		 1546 return 0;
1547 isp116x = hcd_to_isp116x(hcd);
4808a1c0
OK		 1548 remove_debug_file(isp116x);
1549 usb_remove_hcd(hcd);
1550
1551 iounmap(isp116x->data_reg);
1552 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1553 release_mem_region(res->start, 2);
1554 iounmap(isp116x->addr_reg);
1555 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1556 release_mem_region(res->start, 2);
1557
1558 usb_put_hcd(hcd);
1559 return 0;
1560}
1561
41ac7b3a 1562static int isp116x_probe(struct platform_device *pdev)
4808a1c0
OK		 1563{
1564 struct usb_hcd *hcd;
1565 struct isp116x *isp116x;
27140219 1566 struct resource *addr, *data, *ires;
4808a1c0
OK		 1567 void __iomem *addr_reg;
1568 void __iomem *data_reg;
1569 int irq;
1570 int ret = 0;
27140219 1571 unsigned long irqflags;
4808a1c0 1572
2e8d3fe4
TK		 1573 if (usb_disabled())
1574 return -ENODEV;
1575
4808a1c0
OK		 1576 if (pdev->num_resources < 3) {
1577 ret = -ENODEV;
1578 goto err1;
1579 }
1580
1581 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1582 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
27140219
MZ		 1583 ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1584
1585 if (!addr || !data || !ires) {
4808a1c0
OK		 1586 ret = -ENODEV;
1587 goto err1;
1588 }
1589
27140219
MZ		 1590 irq = ires->start;
1591 irqflags = ires->flags & IRQF_TRIGGER_MASK;
1592
3ae5eaec 1593 if (pdev->dev.dma_mask) {
4808a1c0
OK		 1594 DBG("DMA not supported\n");
1595 ret = -EINVAL;
1596 goto err1;
1597 }
1598
1599 if (!request_mem_region(addr->start, 2, hcd_name)) {
1600 ret = -EBUSY;
1601 goto err1;
1602 }
7a9d93e5 1603 addr_reg = ioremap(addr->start, resource_size(addr));
4808a1c0
OK		 1604 if (addr_reg == NULL) {
1605 ret = -ENOMEM;
1606 goto err2;
1607 }
1608 if (!request_mem_region(data->start, 2, hcd_name)) {
1609 ret = -EBUSY;
1610 goto err3;
1611 }
7a9d93e5 1612 data_reg = ioremap(data->start, resource_size(data));
4808a1c0
OK		 1613 if (data_reg == NULL) {
1614 ret = -ENOMEM;
1615 goto err4;
1616 }
1617
1618 /* allocate and initialize hcd */
7071a3ce 1619 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
4808a1c0
OK		 1620 if (!hcd) {
1621 ret = -ENOMEM;
1622 goto err5;
1623 }
1624 /* this rsrc_start is bogus */
1625 hcd->rsrc_start = addr->start;
1626 isp116x = hcd_to_isp116x(hcd);
1627 isp116x->data_reg = data_reg;
1628 isp116x->addr_reg = addr_reg;
1629 spin_lock_init(&isp116x->lock);
1630 INIT_LIST_HEAD(&isp116x->async);
d4f09e28 1631 isp116x->board = dev_get_platdata(&pdev->dev);
4808a1c0
OK		 1632
1633 if (!isp116x->board) {
1634 ERR("Platform data structure not initialized\n");
1635 ret = -ENODEV;
1636 goto err6;
1637 }
1638 if (isp116x_check_platform_delay(isp116x)) {
1639 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1640 "implemented.\n");
1641 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1642 ret = -ENODEV;
1643 goto err6;
1644 }
1645
b5dd18d8 1646 ret = usb_add_hcd(hcd, irq, irqflags);
959eea21 1647 if (ret)
4808a1c0
OK		 1648 goto err6;
1649
3c9740a1
PC		 1650 device_wakeup_enable(hcd->self.controller);
1651
959eea21
OK		 1652 ret = create_debug_file(isp116x);
1653 if (ret) {
1654 ERR("Couldn't create debugfs entry\n");
1655 goto err7;
1656 }
1657
4808a1c0
OK		 1658 return 0;
1659
959eea21
OK		 1660 err7:
1661 usb_remove_hcd(hcd);
4808a1c0
OK		 1662 err6:
1663 usb_put_hcd(hcd);
1664 err5:
1665 iounmap(data_reg);
1666 err4:
1667 release_mem_region(data->start, 2);
1668 err3:
1669 iounmap(addr_reg);
1670 err2:
1671 release_mem_region(addr->start, 2);
1672 err1:
1673 ERR("init error, %d\n", ret);
1674 return ret;
1675}
1676
1677#ifdef CONFIG_PM
1678/*
1679 Suspend of platform device
1680*/
3ae5eaec 1681static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
4808a1c0 1682{
959eea21 1683 VDBG("%s: state %x\n", __func__, state.event);
959eea21 1684 return 0;
4808a1c0
OK		 1685}
1686
1687/*
1688 Resume platform device
1689*/
3ae5eaec 1690static int isp116x_resume(struct platform_device *dev)
4808a1c0 1691{
70a1c9e0 1692 VDBG("%s\n", __func__);
959eea21 1693 return 0;
4808a1c0
OK		 1694}
1695
1696#else
1697
1698#define isp116x_suspend NULL
1699#define isp116x_resume NULL
1700
1701#endif
1702
f4fce61d
KS		 1703/* work with hotplug and coldplug */
1704MODULE_ALIAS("platform:isp116x-hcd");
1705
3ae5eaec 1706static struct platform_driver isp116x_driver = {
4808a1c0
OK		 1707 .probe = isp116x_probe,
1708 .remove = isp116x_remove,
1709 .suspend = isp116x_suspend,
1710 .resume = isp116x_resume,
0be930c5 1711 .driver = {
a458677d 1712 .name = hcd_name,
f4fce61d 1713 },
4808a1c0
OK		 1714};
1715
2e8d3fe4 1716module_platform_driver(isp116x_driver);
Linux kernel - Deliverables
This page took 0.90595 seconds and 5 git commands to generate.