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