]> git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/usb/host/isp116x-hcd.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'u-boot-imx/master' into 'u-boot-arm/master'
[people/ms/u-boot.git] / drivers / usb / host / isp116x-hcd.c
1 /*
2 * ISP116x HCD (Host Controller Driver) for u-boot.
3 *
4 * Copyright (C) 2006-2007 Rodolfo Giometti <giometti@linux.it>
5 * Copyright (C) 2006-2007 Eurotech S.p.A. <info@eurotech.it>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of
10 * the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20 * MA 02111-1307 USA
21 *
22 *
23 * Derived in part from the SL811 HCD driver "u-boot/drivers/usb/sl811_usb.c"
24 * (original copyright message follows):
25 *
26 * (C) Copyright 2004
27 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
28 *
29 * This code is based on linux driver for sl811hs chip, source at
30 * drivers/usb/host/sl811.c:
31 *
32 * SL811 Host Controller Interface driver for USB.
33 *
34 * Copyright (c) 2003/06, Courage Co., Ltd.
35 *
36 * Based on:
37 * 1.uhci.c by Linus Torvalds, Johannes Erdfelt, Randy Dunlap,
38 * Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber,
39 * Adam Richter, Gregory P. Smith;
40 * 2.Original SL811 driver (hc_sl811.o) by Pei Liu <pbl@cypress.com>
41 * 3.Rewrited as sl811.o by Yin Aihua <yinah:couragetech.com.cn>
42 *
43 * [[GNU/GPL disclaimer]]
44 *
45 * and in part from AU1x00 OHCI HCD driver "u-boot/arch/mips/cpu/au1x00_usb_ohci.c"
46 * (original copyright message follows):
47 *
48 * URB OHCI HCD (Host Controller Driver) for USB on the AU1x00.
49 *
50 * (C) Copyright 2003
51 * Gary Jennejohn, DENX Software Engineering <garyj@denx.de>
52 *
53 * [[GNU/GPL disclaimer]]
54 *
55 * Note: Part of this code has been derived from linux
56 */
57
58 #include <common.h>
59 #include <asm/io.h>
60 #include <usb.h>
61 #include <malloc.h>
62 #include <linux/list.h>
63
64 /*
65 * ISP116x chips require certain delays between accesses to its
66 * registers. The following timing options exist.
67 *
68 * 1. Configure your memory controller (the best)
69 * 2. Use ndelay (easiest, poorest). For that, enable the following macro.
70 *
71 * Value is in microseconds.
72 */
73 #ifdef ISP116X_HCD_USE_UDELAY
74 #define UDELAY 1
75 #endif
76
77 /*
78 * On some (slowly?) machines an extra delay after data packing into
79 * controller's FIFOs is required, * otherwise you may get the following
80 * error:
81 *
82 * uboot> usb start
83 * (Re)start USB...
84 * USB: scanning bus for devices... isp116x: isp116x_submit_job: CTL:TIMEOUT
85 * isp116x: isp116x_submit_job: ****** FIFO not ready! ******
86 *
87 * USB device not responding, giving up (status=4)
88 * isp116x: isp116x_submit_job: ****** FIFO not empty! ******
89 * isp116x: isp116x_submit_job: ****** FIFO not empty! ******
90 * isp116x: isp116x_submit_job: ****** FIFO not empty! ******
91 * 3 USB Device(s) found
92 * scanning bus for storage devices... 0 Storage Device(s) found
93 *
94 * Value is in milliseconds.
95 */
96 #ifdef ISP116X_HCD_USE_EXTRA_DELAY
97 #define EXTRA_DELAY 2
98 #endif
99
100 /*
101 * Enable the following defines if you wish enable debugging messages.
102 */
103 #undef DEBUG /* enable debugging messages */
104 #undef TRACE /* enable tracing code */
105 #undef VERBOSE /* verbose debugging messages */
106
107 #include "isp116x.h"
108
109 #define DRIVER_VERSION "08 Jan 2007"
110 static const char hcd_name[] = "isp116x-hcd";
111
112 struct isp116x isp116x_dev;
113 struct isp116x_platform_data isp116x_board;
114 static int got_rhsc; /* root hub status change */
115 struct usb_device *devgone; /* device which was disconnected */
116 static int rh_devnum; /* address of Root Hub endpoint */
117
118 /* ------------------------------------------------------------------------- */
119
120 #define ALIGN(x,a) (((x)+(a)-1UL)&~((a)-1UL))
121 #define min_t(type,x,y) \
122 ({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
123
124 /* ------------------------------------------------------------------------- */
125
126 static int isp116x_reset(struct isp116x *isp116x);
127
128 /* --- Debugging functions ------------------------------------------------- */
129
130 #define isp116x_show_reg(d, r) { \
131 if ((r) < 0x20) { \
132 DBG("%-12s[%02x]: %08x", #r, \
133 r, isp116x_read_reg32(d, r)); \
134 } else { \
135 DBG("%-12s[%02x]: %04x", #r, \
136 r, isp116x_read_reg16(d, r)); \
137 } \
138 }
139
140 #define isp116x_show_regs(d) { \
141 isp116x_show_reg(d, HCREVISION); \
142 isp116x_show_reg(d, HCCONTROL); \
143 isp116x_show_reg(d, HCCMDSTAT); \
144 isp116x_show_reg(d, HCINTSTAT); \
145 isp116x_show_reg(d, HCINTENB); \
146 isp116x_show_reg(d, HCFMINTVL); \
147 isp116x_show_reg(d, HCFMREM); \
148 isp116x_show_reg(d, HCFMNUM); \
149 isp116x_show_reg(d, HCLSTHRESH); \
150 isp116x_show_reg(d, HCRHDESCA); \
151 isp116x_show_reg(d, HCRHDESCB); \
152 isp116x_show_reg(d, HCRHSTATUS); \
153 isp116x_show_reg(d, HCRHPORT1); \
154 isp116x_show_reg(d, HCRHPORT2); \
155 isp116x_show_reg(d, HCHWCFG); \
156 isp116x_show_reg(d, HCDMACFG); \
157 isp116x_show_reg(d, HCXFERCTR); \
158 isp116x_show_reg(d, HCuPINT); \
159 isp116x_show_reg(d, HCuPINTENB); \
160 isp116x_show_reg(d, HCCHIPID); \
161 isp116x_show_reg(d, HCSCRATCH); \
162 isp116x_show_reg(d, HCITLBUFLEN); \
163 isp116x_show_reg(d, HCATLBUFLEN); \
164 isp116x_show_reg(d, HCBUFSTAT); \
165 isp116x_show_reg(d, HCRDITL0LEN); \
166 isp116x_show_reg(d, HCRDITL1LEN); \
167 }
168
169 #if defined(TRACE)
170
171 static int isp116x_get_current_frame_number(struct usb_device *usb_dev)
172 {
173 struct isp116x *isp116x = &isp116x_dev;
174
175 return isp116x_read_reg32(isp116x, HCFMNUM);
176 }
177
178 static void dump_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
179 int len, char *str)
180 {
181 #if defined(VERBOSE)
182 int i;
183 #endif
184
185 DBG("%s URB:[%4x] dev:%2d,ep:%2d-%c,type:%s,len:%d stat:%#lx",
186 str,
187 isp116x_get_current_frame_number(dev),
188 usb_pipedevice(pipe),
189 usb_pipeendpoint(pipe),
190 usb_pipeout(pipe) ? 'O' : 'I',
191 usb_pipetype(pipe) < 2 ?
192 (usb_pipeint(pipe) ?
193 "INTR" : "ISOC") :
194 (usb_pipecontrol(pipe) ? "CTRL" : "BULK"), len, dev->status);
195 #if defined(VERBOSE)
196 if (len > 0 && buffer) {
197 printf(__FILE__ ": data(%d):", len);
198 for (i = 0; i < 16 && i < len; i++)
199 printf(" %02x", ((__u8 *) buffer)[i]);
200 printf("%s\n", i < len ? "..." : "");
201 }
202 #endif
203 }
204
205 #define PTD_DIR_STR(ptd) ({char __c; \
206 switch(PTD_GET_DIR(ptd)){ \
207 case 0: __c = 's'; break; \
208 case 1: __c = 'o'; break; \
209 default: __c = 'i'; break; \
210 }; __c;})
211
212 /*
213 Dump PTD info. The code documents the format
214 perfectly, right :)
215 */
216 static inline void dump_ptd(struct ptd *ptd)
217 {
218 #if defined(VERBOSE)
219 int k;
220 #endif
221
222 DBG("PTD(ext) : cc:%x %d%c%d %d,%d,%d t:%x %x%x%x",
223 PTD_GET_CC(ptd),
224 PTD_GET_FA(ptd), PTD_DIR_STR(ptd), PTD_GET_EP(ptd),
225 PTD_GET_COUNT(ptd), PTD_GET_LEN(ptd), PTD_GET_MPS(ptd),
226 PTD_GET_TOGGLE(ptd),
227 PTD_GET_ACTIVE(ptd), PTD_GET_SPD(ptd), PTD_GET_LAST(ptd));
228 #if defined(VERBOSE)
229 printf("isp116x: %s: PTD(byte): ", __FUNCTION__);
230 for (k = 0; k < sizeof(struct ptd); ++k)
231 printf("%02x ", ((u8 *) ptd)[k]);
232 printf("\n");
233 #endif
234 }
235
236 static inline void dump_ptd_data(struct ptd *ptd, u8 * buf, int type)
237 {
238 #if defined(VERBOSE)
239 int k;
240
241 if (type == 0 /* 0ut data */ ) {
242 printf("isp116x: %s: out data: ", __FUNCTION__);
243 for (k = 0; k < PTD_GET_LEN(ptd); ++k)
244 printf("%02x ", ((u8 *) buf)[k]);
245 printf("\n");
246 }
247 if (type == 1 /* 1n data */ ) {
248 printf("isp116x: %s: in data: ", __FUNCTION__);
249 for (k = 0; k < PTD_GET_COUNT(ptd); ++k)
250 printf("%02x ", ((u8 *) buf)[k]);
251 printf("\n");
252 }
253
254 if (PTD_GET_LAST(ptd))
255 DBG("--- last PTD ---");
256 #endif
257 }
258
259 #else
260
261 #define dump_msg(dev, pipe, buffer, len, str) do { } while (0)
262 #define dump_pkt(dev, pipe, buffer, len, setup, str, small) do {} while (0)
263
264 #define dump_ptd(ptd) do {} while (0)
265 #define dump_ptd_data(ptd, buf, type) do {} while (0)
266
267 #endif
268
269 /* --- Virtual Root Hub ---------------------------------------------------- */
270
271 /* Device descriptor */
272 static __u8 root_hub_dev_des[] = {
273 0x12, /* __u8 bLength; */
274 0x01, /* __u8 bDescriptorType; Device */
275 0x10, /* __u16 bcdUSB; v1.1 */
276 0x01,
277 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
278 0x00, /* __u8 bDeviceSubClass; */
279 0x00, /* __u8 bDeviceProtocol; */
280 0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
281 0x00, /* __u16 idVendor; */
282 0x00,
283 0x00, /* __u16 idProduct; */
284 0x00,
285 0x00, /* __u16 bcdDevice; */
286 0x00,
287 0x00, /* __u8 iManufacturer; */
288 0x01, /* __u8 iProduct; */
289 0x00, /* __u8 iSerialNumber; */
290 0x01 /* __u8 bNumConfigurations; */
291 };
292
293 /* Configuration descriptor */
294 static __u8 root_hub_config_des[] = {
295 0x09, /* __u8 bLength; */
296 0x02, /* __u8 bDescriptorType; Configuration */
297 0x19, /* __u16 wTotalLength; */
298 0x00,
299 0x01, /* __u8 bNumInterfaces; */
300 0x01, /* __u8 bConfigurationValue; */
301 0x00, /* __u8 iConfiguration; */
302 0x40, /* __u8 bmAttributes;
303 Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup, 4..0: resvd */
304 0x00, /* __u8 MaxPower; */
305
306 /* interface */
307 0x09, /* __u8 if_bLength; */
308 0x04, /* __u8 if_bDescriptorType; Interface */
309 0x00, /* __u8 if_bInterfaceNumber; */
310 0x00, /* __u8 if_bAlternateSetting; */
311 0x01, /* __u8 if_bNumEndpoints; */
312 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
313 0x00, /* __u8 if_bInterfaceSubClass; */
314 0x00, /* __u8 if_bInterfaceProtocol; */
315 0x00, /* __u8 if_iInterface; */
316
317 /* endpoint */
318 0x07, /* __u8 ep_bLength; */
319 0x05, /* __u8 ep_bDescriptorType; Endpoint */
320 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
321 0x03, /* __u8 ep_bmAttributes; Interrupt */
322 0x00, /* __u16 ep_wMaxPacketSize; ((MAX_ROOT_PORTS + 1) / 8 */
323 0x02,
324 0xff /* __u8 ep_bInterval; 255 ms */
325 };
326
327 static unsigned char root_hub_str_index0[] = {
328 0x04, /* __u8 bLength; */
329 0x03, /* __u8 bDescriptorType; String-descriptor */
330 0x09, /* __u8 lang ID */
331 0x04, /* __u8 lang ID */
332 };
333
334 static unsigned char root_hub_str_index1[] = {
335 0x22, /* __u8 bLength; */
336 0x03, /* __u8 bDescriptorType; String-descriptor */
337 'I', /* __u8 Unicode */
338 0, /* __u8 Unicode */
339 'S', /* __u8 Unicode */
340 0, /* __u8 Unicode */
341 'P', /* __u8 Unicode */
342 0, /* __u8 Unicode */
343 '1', /* __u8 Unicode */
344 0, /* __u8 Unicode */
345 '1', /* __u8 Unicode */
346 0, /* __u8 Unicode */
347 '6', /* __u8 Unicode */
348 0, /* __u8 Unicode */
349 'x', /* __u8 Unicode */
350 0, /* __u8 Unicode */
351 ' ', /* __u8 Unicode */
352 0, /* __u8 Unicode */
353 'R', /* __u8 Unicode */
354 0, /* __u8 Unicode */
355 'o', /* __u8 Unicode */
356 0, /* __u8 Unicode */
357 'o', /* __u8 Unicode */
358 0, /* __u8 Unicode */
359 't', /* __u8 Unicode */
360 0, /* __u8 Unicode */
361 ' ', /* __u8 Unicode */
362 0, /* __u8 Unicode */
363 'H', /* __u8 Unicode */
364 0, /* __u8 Unicode */
365 'u', /* __u8 Unicode */
366 0, /* __u8 Unicode */
367 'b', /* __u8 Unicode */
368 0, /* __u8 Unicode */
369 };
370
371 /*
372 * Hub class-specific descriptor is constructed dynamically
373 */
374
375 /* --- Virtual root hub management functions ------------------------------- */
376
377 static int rh_check_port_status(struct isp116x *isp116x)
378 {
379 u32 temp, ndp, i;
380 int res;
381
382 res = -1;
383 temp = isp116x_read_reg32(isp116x, HCRHSTATUS);
384 ndp = (temp & RH_A_NDP);
385 for (i = 0; i < ndp; i++) {
386 temp = isp116x_read_reg32(isp116x, HCRHPORT1 + i);
387 /* check for a device disconnect */
388 if (((temp & (RH_PS_PESC | RH_PS_CSC)) ==
389 (RH_PS_PESC | RH_PS_CSC)) && ((temp & RH_PS_CCS) == 0)) {
390 res = i;
391 break;
392 }
393 }
394 return res;
395 }
396
397 /* --- HC management functions --------------------------------------------- */
398
399 /* Write len bytes to fifo, pad till 32-bit boundary
400 */
401 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
402 {
403 u8 *dp = (u8 *) buf;
404 u16 *dp2 = (u16 *) buf;
405 u16 w;
406 int quot = len % 4;
407
408 if ((unsigned long)dp2 & 1) {
409 /* not aligned */
410 for (; len > 1; len -= 2) {
411 w = *dp++;
412 w |= *dp++ << 8;
413 isp116x_raw_write_data16(isp116x, w);
414 }
415 if (len)
416 isp116x_write_data16(isp116x, (u16) * dp);
417 } else {
418 /* aligned */
419 for (; len > 1; len -= 2)
420 isp116x_raw_write_data16(isp116x, *dp2++);
421 if (len)
422 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
423 }
424 if (quot == 1 || quot == 2)
425 isp116x_raw_write_data16(isp116x, 0);
426 }
427
428 /* Read len bytes from fifo and then read till 32-bit boundary
429 */
430 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
431 {
432 u8 *dp = (u8 *) buf;
433 u16 *dp2 = (u16 *) buf;
434 u16 w;
435 int quot = len % 4;
436
437 if ((unsigned long)dp2 & 1) {
438 /* not aligned */
439 for (; len > 1; len -= 2) {
440 w = isp116x_raw_read_data16(isp116x);
441 *dp++ = w & 0xff;
442 *dp++ = (w >> 8) & 0xff;
443 }
444 if (len)
445 *dp = 0xff & isp116x_read_data16(isp116x);
446 } else {
447 /* aligned */
448 for (; len > 1; len -= 2)
449 *dp2++ = isp116x_raw_read_data16(isp116x);
450 if (len)
451 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
452 }
453 if (quot == 1 || quot == 2)
454 isp116x_raw_read_data16(isp116x);
455 }
456
457 /* Write PTD's and data for scheduled transfers into the fifo ram.
458 * Fifo must be empty and ready */
459 static void pack_fifo(struct isp116x *isp116x, struct usb_device *dev,
460 unsigned long pipe, struct ptd *ptd, int n, void *data,
461 int len)
462 {
463 int buflen = n * sizeof(struct ptd) + len;
464 int i, done;
465
466 DBG("--- pack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
467
468 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
469 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
470 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
471
472 done = 0;
473 for (i = 0; i < n; i++) {
474 DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
475
476 dump_ptd(&ptd[i]);
477 isp116x_write_data16(isp116x, ptd[i].count);
478 isp116x_write_data16(isp116x, ptd[i].mps);
479 isp116x_write_data16(isp116x, ptd[i].len);
480 isp116x_write_data16(isp116x, ptd[i].faddr);
481
482 dump_ptd_data(&ptd[i], (__u8 *) data + done, 0);
483 write_ptddata_to_fifo(isp116x,
484 (__u8 *) data + done,
485 PTD_GET_LEN(&ptd[i]));
486
487 done += PTD_GET_LEN(&ptd[i]);
488 }
489 }
490
491 /* Read the processed PTD's and data from fifo ram back to URBs' buffers.
492 * Fifo must be full and done */
493 static int unpack_fifo(struct isp116x *isp116x, struct usb_device *dev,
494 unsigned long pipe, struct ptd *ptd, int n, void *data,
495 int len)
496 {
497 int buflen = n * sizeof(struct ptd) + len;
498 int i, done, cc, ret;
499
500 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
501 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
502 isp116x_write_addr(isp116x, HCATLPORT);
503
504 ret = TD_CC_NOERROR;
505 done = 0;
506 for (i = 0; i < n; i++) {
507 DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
508
509 ptd[i].count = isp116x_read_data16(isp116x);
510 ptd[i].mps = isp116x_read_data16(isp116x);
511 ptd[i].len = isp116x_read_data16(isp116x);
512 ptd[i].faddr = isp116x_read_data16(isp116x);
513 dump_ptd(&ptd[i]);
514
515 read_ptddata_from_fifo(isp116x,
516 (__u8 *) data + done,
517 PTD_GET_LEN(&ptd[i]));
518 dump_ptd_data(&ptd[i], (__u8 *) data + done, 1);
519
520 done += PTD_GET_LEN(&ptd[i]);
521
522 cc = PTD_GET_CC(&ptd[i]);
523
524 /* Data underrun means basically that we had more buffer space than
525 * the function had data. It is perfectly normal but upper levels have
526 * to know how much we actually transferred.
527 */
528 if (cc == TD_NOTACCESSED ||
529 (cc != TD_CC_NOERROR && (ret == TD_CC_NOERROR || ret == TD_DATAUNDERRUN)))
530 ret = cc;
531 }
532
533 DBG("--- unpack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
534
535 return ret;
536 }
537
538 /* Interrupt handling
539 */
540 static int isp116x_interrupt(struct isp116x *isp116x)
541 {
542 u16 irqstat;
543 u32 intstat;
544 int ret = 0;
545
546 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
547 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
548 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
549 DBG(">>>>>> irqstat %x <<<<<<", irqstat);
550
551 if (irqstat & HCuPINT_ATL) {
552 DBG(">>>>>> HCuPINT_ATL <<<<<<");
553 udelay(500);
554 ret = 1;
555 }
556
557 if (irqstat & HCuPINT_OPR) {
558 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
559 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
560 DBG(">>>>>> HCuPINT_OPR %x <<<<<<", intstat);
561
562 if (intstat & HCINT_UE) {
563 ERR("unrecoverable error, controller disabled");
564
565 /* FIXME: be optimistic, hope that bug won't repeat
566 * often. Make some non-interrupt context restart the
567 * controller. Count and limit the retries though;
568 * either hardware or software errors can go forever...
569 */
570 isp116x_reset(isp116x);
571 ret = -1;
572 return -1;
573 }
574
575 if (intstat & HCINT_RHSC) {
576 got_rhsc = 1;
577 ret = 1;
578 /* When root hub or any of its ports is going
579 to come out of suspend, it may take more
580 than 10ms for status bits to stabilize. */
581 mdelay(20);
582 }
583
584 if (intstat & HCINT_SO) {
585 ERR("schedule overrun");
586 ret = -1;
587 }
588
589 irqstat &= ~HCuPINT_OPR;
590 }
591
592 return ret;
593 }
594
595 /* With one PTD we can transfer almost 1K in one go;
596 * HC does the splitting into endpoint digestible transactions
597 */
598 struct ptd ptd[1];
599
600 static inline int max_transfer_len(struct usb_device *dev, unsigned long pipe)
601 {
602 unsigned mpck = usb_maxpacket(dev, pipe);
603
604 /* One PTD can transfer 1023 bytes but try to always
605 * transfer multiples of endpoint buffer size
606 */
607 return 1023 / mpck * mpck;
608 }
609
610 /* Do an USB transfer
611 */
612 static int isp116x_submit_job(struct usb_device *dev, unsigned long pipe,
613 int dir, void *buffer, int len)
614 {
615 struct isp116x *isp116x = &isp116x_dev;
616 int type = usb_pipetype(pipe);
617 int epnum = usb_pipeendpoint(pipe);
618 int max = usb_maxpacket(dev, pipe);
619 int dir_out = usb_pipeout(pipe);
620 int speed_low = usb_pipeslow(pipe);
621 int i, done = 0, stat, timeout, cc;
622
623 /* 500 frames or 0.5s timeout when function is busy and NAKs transactions for a while */
624 int retries = 500;
625
626 DBG("------------------------------------------------");
627 dump_msg(dev, pipe, buffer, len, "SUBMIT");
628 DBG("------------------------------------------------");
629
630 if (len >= 1024) {
631 ERR("Too big job");
632 dev->status = USB_ST_CRC_ERR;
633 return -1;
634 }
635
636 if (isp116x->disabled) {
637 ERR("EPIPE");
638 dev->status = USB_ST_CRC_ERR;
639 return -1;
640 }
641
642 /* device pulled? Shortcut the action. */
643 if (devgone == dev) {
644 ERR("ENODEV");
645 dev->status = USB_ST_CRC_ERR;
646 return USB_ST_CRC_ERR;
647 }
648
649 if (!max) {
650 ERR("pipesize for pipe %lx is zero", pipe);
651 dev->status = USB_ST_CRC_ERR;
652 return -1;
653 }
654
655 if (type == PIPE_ISOCHRONOUS) {
656 ERR("isochronous transfers not supported");
657 dev->status = USB_ST_CRC_ERR;
658 return -1;
659 }
660
661 /* FIFO not empty? */
662 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL) {
663 ERR("****** FIFO not empty! ******");
664 dev->status = USB_ST_BUF_ERR;
665 return -1;
666 }
667
668 retry:
669 isp116x_write_reg32(isp116x, HCINTSTAT, 0xff);
670
671 /* Prepare the PTD data */
672 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK |
673 PTD_TOGGLE(usb_gettoggle(dev, epnum, dir_out));
674 ptd->mps = PTD_MPS(max) | PTD_SPD(speed_low) | PTD_EP(epnum) | PTD_LAST_MSK;
675 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
676 ptd->faddr = PTD_FA(usb_pipedevice(pipe));
677
678 retry_same:
679 /* Pack data into FIFO ram */
680 pack_fifo(isp116x, dev, pipe, ptd, 1, buffer, len);
681 #ifdef EXTRA_DELAY
682 mdelay(EXTRA_DELAY);
683 #endif
684
685 /* Start the data transfer */
686
687 /* Allow more time for a BULK device to react - some are slow */
688 if (usb_pipebulk(pipe))
689 timeout = 5000;
690 else
691 timeout = 100;
692
693 /* Wait for it to complete */
694 for (;;) {
695 /* Check whether the controller is done */
696 stat = isp116x_interrupt(isp116x);
697
698 if (stat < 0) {
699 dev->status = USB_ST_CRC_ERR;
700 break;
701 }
702 if (stat > 0)
703 break;
704
705 /* Check the timeout */
706 if (--timeout)
707 udelay(1);
708 else {
709 ERR("CTL:TIMEOUT ");
710 stat = USB_ST_CRC_ERR;
711 break;
712 }
713 }
714
715 /* We got an Root Hub Status Change interrupt */
716 if (got_rhsc) {
717 isp116x_show_regs(isp116x);
718
719 got_rhsc = 0;
720
721 /* Abuse timeout */
722 timeout = rh_check_port_status(isp116x);
723 if (timeout >= 0) {
724 /*
725 * FIXME! NOTE! AAAARGH!
726 * This is potentially dangerous because it assumes
727 * that only one device is ever plugged in!
728 */
729 devgone = dev;
730 }
731 }
732
733 /* Ok, now we can read transfer status */
734
735 /* FIFO not ready? */
736 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE)) {
737 ERR("****** FIFO not ready! ******");
738 dev->status = USB_ST_BUF_ERR;
739 return -1;
740 }
741
742 /* Unpack data from FIFO ram */
743 cc = unpack_fifo(isp116x, dev, pipe, ptd, 1, buffer, len);
744
745 i = PTD_GET_COUNT(ptd);
746 done += i;
747 buffer += i;
748 len -= i;
749
750 /* There was some kind of real problem; Prepare the PTD again
751 * and retry from the failed transaction on
752 */
753 if (cc && cc != TD_NOTACCESSED && cc != TD_DATAUNDERRUN) {
754 if (retries >= 100) {
755 retries -= 100;
756 /* The chip will have toggled the toggle bit for the failed
757 * transaction too. We have to toggle it back.
758 */
759 usb_settoggle(dev, epnum, dir_out, !PTD_GET_TOGGLE(ptd));
760 goto retry;
761 }
762 }
763 /* "Normal" errors; TD_NOTACCESSED would mean in effect that the function have NAKed
764 * the transactions from the first on for the whole frame. It may be busy and we retry
765 * with the same PTD. PTD_ACTIVE (and not TD_NOTACCESSED) would mean that some of the
766 * PTD didn't make it because the function was busy or the frame ended before the PTD
767 * finished. We prepare the rest of the data and try again.
768 */
769 else if (cc == TD_NOTACCESSED || PTD_GET_ACTIVE(ptd) || (cc != TD_DATAUNDERRUN && PTD_GET_COUNT(ptd) < PTD_GET_LEN(ptd))) {
770 if (retries) {
771 --retries;
772 if (cc == TD_NOTACCESSED && PTD_GET_ACTIVE(ptd) && !PTD_GET_COUNT(ptd)) goto retry_same;
773 usb_settoggle(dev, epnum, dir_out, PTD_GET_TOGGLE(ptd));
774 goto retry;
775 }
776 }
777
778 if (cc != TD_CC_NOERROR && cc != TD_DATAUNDERRUN) {
779 DBG("****** completition code error %x ******", cc);
780 switch (cc) {
781 case TD_CC_BITSTUFFING:
782 dev->status = USB_ST_BIT_ERR;
783 break;
784 case TD_CC_STALL:
785 dev->status = USB_ST_STALLED;
786 break;
787 case TD_BUFFEROVERRUN:
788 case TD_BUFFERUNDERRUN:
789 dev->status = USB_ST_BUF_ERR;
790 break;
791 default:
792 dev->status = USB_ST_CRC_ERR;
793 }
794 return -cc;
795 }
796 else usb_settoggle(dev, epnum, dir_out, PTD_GET_TOGGLE(ptd));
797
798 dump_msg(dev, pipe, buffer, len, "SUBMIT(ret)");
799
800 dev->status = 0;
801 return done;
802 }
803
804 /* Adapted from au1x00_usb_ohci.c
805 */
806 static int isp116x_submit_rh_msg(struct usb_device *dev, unsigned long pipe,
807 void *buffer, int transfer_len,
808 struct devrequest *cmd)
809 {
810 struct isp116x *isp116x = &isp116x_dev;
811 u32 tmp = 0;
812
813 int leni = transfer_len;
814 int len = 0;
815 int stat = 0;
816 u32 datab[4];
817 u8 *data_buf = (u8 *) datab;
818 u16 bmRType_bReq;
819 u16 wValue;
820 u16 wIndex;
821 u16 wLength;
822
823 if (usb_pipeint(pipe)) {
824 INFO("Root-Hub submit IRQ: NOT implemented");
825 return 0;
826 }
827
828 bmRType_bReq = cmd->requesttype | (cmd->request << 8);
829 wValue = swap_16(cmd->value);
830 wIndex = swap_16(cmd->index);
831 wLength = swap_16(cmd->length);
832
833 DBG("--- HUB ----------------------------------------");
834 DBG("submit rh urb, req=%x val=%#x index=%#x len=%d",
835 bmRType_bReq, wValue, wIndex, wLength);
836 dump_msg(dev, pipe, buffer, transfer_len, "RH");
837 DBG("------------------------------------------------");
838
839 switch (bmRType_bReq) {
840 case RH_GET_STATUS:
841 DBG("RH_GET_STATUS");
842
843 *(__u16 *) data_buf = swap_16(1);
844 len = 2;
845 break;
846
847 case RH_GET_STATUS | RH_INTERFACE:
848 DBG("RH_GET_STATUS | RH_INTERFACE");
849
850 *(__u16 *) data_buf = swap_16(0);
851 len = 2;
852 break;
853
854 case RH_GET_STATUS | RH_ENDPOINT:
855 DBG("RH_GET_STATUS | RH_ENDPOINT");
856
857 *(__u16 *) data_buf = swap_16(0);
858 len = 2;
859 break;
860
861 case RH_GET_STATUS | RH_CLASS:
862 DBG("RH_GET_STATUS | RH_CLASS");
863
864 tmp = isp116x_read_reg32(isp116x, HCRHSTATUS);
865
866 *(__u32 *) data_buf = swap_32(tmp & ~(RH_HS_CRWE | RH_HS_DRWE));
867 len = 4;
868 break;
869
870 case RH_GET_STATUS | RH_OTHER | RH_CLASS:
871 DBG("RH_GET_STATUS | RH_OTHER | RH_CLASS");
872
873 tmp = isp116x_read_reg32(isp116x, HCRHPORT1 + wIndex - 1);
874 *(__u32 *) data_buf = swap_32(tmp);
875 isp116x_show_regs(isp116x);
876 len = 4;
877 break;
878
879 case RH_CLEAR_FEATURE | RH_ENDPOINT:
880 DBG("RH_CLEAR_FEATURE | RH_ENDPOINT");
881
882 switch (wValue) {
883 case RH_ENDPOINT_STALL:
884 DBG("C_HUB_ENDPOINT_STALL");
885 len = 0;
886 break;
887 }
888 break;
889
890 case RH_CLEAR_FEATURE | RH_CLASS:
891 DBG("RH_CLEAR_FEATURE | RH_CLASS");
892
893 switch (wValue) {
894 case RH_C_HUB_LOCAL_POWER:
895 DBG("C_HUB_LOCAL_POWER");
896 len = 0;
897 break;
898
899 case RH_C_HUB_OVER_CURRENT:
900 DBG("C_HUB_OVER_CURRENT");
901 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
902 len = 0;
903 break;
904 }
905 break;
906
907 case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
908 DBG("RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS");
909
910 switch (wValue) {
911 case RH_PORT_ENABLE:
912 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
913 RH_PS_CCS);
914 len = 0;
915 break;
916
917 case RH_PORT_SUSPEND:
918 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
919 RH_PS_POCI);
920 len = 0;
921 break;
922
923 case RH_PORT_POWER:
924 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
925 RH_PS_LSDA);
926 len = 0;
927 break;
928
929 case RH_C_PORT_CONNECTION:
930 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
931 RH_PS_CSC);
932 len = 0;
933 break;
934
935 case RH_C_PORT_ENABLE:
936 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
937 RH_PS_PESC);
938 len = 0;
939 break;
940
941 case RH_C_PORT_SUSPEND:
942 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
943 RH_PS_PSSC);
944 len = 0;
945 break;
946
947 case RH_C_PORT_OVER_CURRENT:
948 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
949 RH_PS_POCI);
950 len = 0;
951 break;
952
953 case RH_C_PORT_RESET:
954 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
955 RH_PS_PRSC);
956 len = 0;
957 break;
958
959 default:
960 ERR("invalid wValue");
961 stat = USB_ST_STALLED;
962 }
963
964 isp116x_show_regs(isp116x);
965
966 break;
967
968 case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
969 DBG("RH_SET_FEATURE | RH_OTHER | RH_CLASS");
970
971 switch (wValue) {
972 case RH_PORT_SUSPEND:
973 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
974 RH_PS_PSS);
975 len = 0;
976 break;
977
978 case RH_PORT_RESET:
979 /* Spin until any current reset finishes */
980 while (1) {
981 tmp =
982 isp116x_read_reg32(isp116x,
983 HCRHPORT1 + wIndex - 1);
984 if (!(tmp & RH_PS_PRS))
985 break;
986 mdelay(1);
987 }
988 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
989 RH_PS_PRS);
990 mdelay(10);
991
992 len = 0;
993 break;
994
995 case RH_PORT_POWER:
996 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
997 RH_PS_PPS);
998 len = 0;
999 break;
1000
1001 case RH_PORT_ENABLE:
1002 isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
1003 RH_PS_PES);
1004 len = 0;
1005 break;
1006
1007 default:
1008 ERR("invalid wValue");
1009 stat = USB_ST_STALLED;
1010 }
1011
1012 isp116x_show_regs(isp116x);
1013
1014 break;
1015
1016 case RH_SET_ADDRESS:
1017 DBG("RH_SET_ADDRESS");
1018
1019 rh_devnum = wValue;
1020 len = 0;
1021 break;
1022
1023 case RH_GET_DESCRIPTOR:
1024 DBG("RH_GET_DESCRIPTOR: %x, %d", wValue, wLength);
1025
1026 switch (wValue) {
1027 case (USB_DT_DEVICE << 8): /* device descriptor */
1028 len = min_t(unsigned int,
1029 leni, min_t(unsigned int,
1030 sizeof(root_hub_dev_des),
1031 wLength));
1032 data_buf = root_hub_dev_des;
1033 break;
1034
1035 case (USB_DT_CONFIG << 8): /* configuration descriptor */
1036 len = min_t(unsigned int,
1037 leni, min_t(unsigned int,
1038 sizeof(root_hub_config_des),
1039 wLength));
1040 data_buf = root_hub_config_des;
1041 break;
1042
1043 case ((USB_DT_STRING << 8) | 0x00): /* string 0 descriptors */
1044 len = min_t(unsigned int,
1045 leni, min_t(unsigned int,
1046 sizeof(root_hub_str_index0),
1047 wLength));
1048 data_buf = root_hub_str_index0;
1049 break;
1050
1051 case ((USB_DT_STRING << 8) | 0x01): /* string 1 descriptors */
1052 len = min_t(unsigned int,
1053 leni, min_t(unsigned int,
1054 sizeof(root_hub_str_index1),
1055 wLength));
1056 data_buf = root_hub_str_index1;
1057 break;
1058
1059 default:
1060 ERR("invalid wValue");
1061 stat = USB_ST_STALLED;
1062 }
1063
1064 break;
1065
1066 case RH_GET_DESCRIPTOR | RH_CLASS:
1067 DBG("RH_GET_DESCRIPTOR | RH_CLASS");
1068
1069 tmp = isp116x_read_reg32(isp116x, HCRHDESCA);
1070
1071 data_buf[0] = 0x09; /* min length; */
1072 data_buf[1] = 0x29;
1073 data_buf[2] = tmp & RH_A_NDP;
1074 data_buf[3] = 0;
1075 if (tmp & RH_A_PSM) /* per-port power switching? */
1076 data_buf[3] |= 0x01;
1077 if (tmp & RH_A_NOCP) /* no overcurrent reporting? */
1078 data_buf[3] |= 0x10;
1079 else if (tmp & RH_A_OCPM) /* per-port overcurrent rep? */
1080 data_buf[3] |= 0x08;
1081
1082 /* Corresponds to data_buf[4-7] */
1083 datab[1] = 0;
1084 data_buf[5] = (tmp & RH_A_POTPGT) >> 24;
1085
1086 tmp = isp116x_read_reg32(isp116x, HCRHDESCB);
1087
1088 data_buf[7] = tmp & RH_B_DR;
1089 if (data_buf[2] < 7)
1090 data_buf[8] = 0xff;
1091 else {
1092 data_buf[0] += 2;
1093 data_buf[8] = (tmp & RH_B_DR) >> 8;
1094 data_buf[10] = data_buf[9] = 0xff;
1095 }
1096
1097 len = min_t(unsigned int, leni,
1098 min_t(unsigned int, data_buf[0], wLength));
1099 break;
1100
1101 case RH_GET_CONFIGURATION:
1102 DBG("RH_GET_CONFIGURATION");
1103
1104 *(__u8 *) data_buf = 0x01;
1105 len = 1;
1106 break;
1107
1108 case RH_SET_CONFIGURATION:
1109 DBG("RH_SET_CONFIGURATION");
1110
1111 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPSC);
1112 len = 0;
1113 break;
1114
1115 default:
1116 ERR("*** *** *** unsupported root hub command *** *** ***");
1117 stat = USB_ST_STALLED;
1118 }
1119
1120 len = min_t(int, len, leni);
1121 if (buffer != data_buf)
1122 memcpy(buffer, data_buf, len);
1123
1124 dev->act_len = len;
1125 dev->status = stat;
1126 DBG("dev act_len %d, status %d", dev->act_len, dev->status);
1127
1128 dump_msg(dev, pipe, buffer, transfer_len, "RH(ret)");
1129
1130 return stat;
1131 }
1132
1133 /* --- Transfer functions -------------------------------------------------- */
1134
1135 int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1136 int len, int interval)
1137 {
1138 DBG("dev=%p pipe=%#lx buf=%p size=%d int=%d",
1139 dev, pipe, buffer, len, interval);
1140
1141 return -1;
1142 }
1143
1144 int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1145 int len, struct devrequest *setup)
1146 {
1147 int devnum = usb_pipedevice(pipe);
1148 int epnum = usb_pipeendpoint(pipe);
1149 int max = max_transfer_len(dev, pipe);
1150 int dir_in = usb_pipein(pipe);
1151 int done, ret;
1152
1153 /* Control message is for the HUB? */
1154 if (devnum == rh_devnum)
1155 return isp116x_submit_rh_msg(dev, pipe, buffer, len, setup);
1156
1157 /* Ok, no HUB message so send the message to the device */
1158
1159 /* Setup phase */
1160 DBG("--- SETUP PHASE --------------------------------");
1161 usb_settoggle(dev, epnum, 1, 0);
1162 ret = isp116x_submit_job(dev, pipe,
1163 PTD_DIR_SETUP,
1164 setup, sizeof(struct devrequest));
1165 if (ret < 0) {
1166 DBG("control setup phase error (ret = %d", ret);
1167 return -1;
1168 }
1169
1170 /* Data phase */
1171 DBG("--- DATA PHASE ---------------------------------");
1172 done = 0;
1173 usb_settoggle(dev, epnum, !dir_in, 1);
1174 while (done < len) {
1175 ret = isp116x_submit_job(dev, pipe,
1176 dir_in ? PTD_DIR_IN : PTD_DIR_OUT,
1177 (__u8 *) buffer + done,
1178 max > len - done ? len - done : max);
1179 if (ret < 0) {
1180 DBG("control data phase error (ret = %d)", ret);
1181 return -1;
1182 }
1183 done += ret;
1184
1185 if (dir_in && ret < max) /* short packet */
1186 break;
1187 }
1188
1189 /* Status phase */
1190 DBG("--- STATUS PHASE -------------------------------");
1191 usb_settoggle(dev, epnum, !dir_in, 1);
1192 ret = isp116x_submit_job(dev, pipe,
1193 !dir_in ? PTD_DIR_IN : PTD_DIR_OUT, NULL, 0);
1194 if (ret < 0) {
1195 DBG("control status phase error (ret = %d", ret);
1196 return -1;
1197 }
1198
1199 dev->act_len = done;
1200
1201 dump_msg(dev, pipe, buffer, len, "DEV(ret)");
1202
1203 return done;
1204 }
1205
1206 int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1207 int len)
1208 {
1209 int dir_out = usb_pipeout(pipe);
1210 int max = max_transfer_len(dev, pipe);
1211 int done, ret;
1212
1213 DBG("--- BULK ---------------------------------------");
1214 DBG("dev=%ld pipe=%ld buf=%p size=%d dir_out=%d",
1215 usb_pipedevice(pipe), usb_pipeendpoint(pipe), buffer, len, dir_out);
1216
1217 done = 0;
1218 while (done < len) {
1219 ret = isp116x_submit_job(dev, pipe,
1220 !dir_out ? PTD_DIR_IN : PTD_DIR_OUT,
1221 (__u8 *) buffer + done,
1222 max > len - done ? len - done : max);
1223 if (ret < 0) {
1224 DBG("error on bulk message (ret = %d)", ret);
1225 return -1;
1226 }
1227
1228 done += ret;
1229
1230 if (!dir_out && ret < max) /* short packet */
1231 break;
1232 }
1233
1234 dev->act_len = done;
1235
1236 return 0;
1237 }
1238
1239 /* --- Basic functions ----------------------------------------------------- */
1240
1241 static int isp116x_sw_reset(struct isp116x *isp116x)
1242 {
1243 int retries = 15;
1244 int ret = 0;
1245
1246 DBG("");
1247
1248 isp116x->disabled = 1;
1249
1250 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1251 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1252 while (--retries) {
1253 /* It usually resets within 1 ms */
1254 mdelay(1);
1255 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1256 break;
1257 }
1258 if (!retries) {
1259 ERR("software reset timeout");
1260 ret = -1;
1261 }
1262 return ret;
1263 }
1264
1265 static int isp116x_reset(struct isp116x *isp116x)
1266 {
1267 unsigned long t;
1268 u16 clkrdy = 0;
1269 int ret, timeout = 15 /* ms */ ;
1270
1271 DBG("");
1272
1273 ret = isp116x_sw_reset(isp116x);
1274 if (ret)
1275 return ret;
1276
1277 for (t = 0; t < timeout; t++) {
1278 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1279 if (clkrdy)
1280 break;
1281 mdelay(1);
1282 }
1283 if (!clkrdy) {
1284 ERR("clock not ready after %dms", timeout);
1285 /* After sw_reset the clock won't report to be ready, if
1286 H_WAKEUP pin is high. */
1287 ERR("please make sure that the H_WAKEUP pin is pulled low!");
1288 ret = -1;
1289 }
1290 return ret;
1291 }
1292
1293 static void isp116x_stop(struct isp116x *isp116x)
1294 {
1295 u32 val;
1296
1297 DBG("");
1298
1299 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1300
1301 /* Switch off ports' power, some devices don't come up
1302 after next 'start' without this */
1303 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1304 val &= ~(RH_A_NPS | RH_A_PSM);
1305 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1306 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1307
1308 isp116x_sw_reset(isp116x);
1309 }
1310
1311 /*
1312 * Configure the chip. The chip must be successfully reset by now.
1313 */
1314 static int isp116x_start(struct isp116x *isp116x)
1315 {
1316 struct isp116x_platform_data *board = isp116x->board;
1317 u32 val;
1318
1319 DBG("");
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 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1326 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1327
1328 /* Hardware configuration */
1329 val = HCHWCFG_DBWIDTH(1);
1330 if (board->sel15Kres)
1331 val |= HCHWCFG_15KRSEL;
1332 /* Remote wakeup won't work without working clock */
1333 if (board->remote_wakeup_enable)
1334 val |= HCHWCFG_CLKNOTSTOP;
1335 if (board->oc_enable)
1336 val |= HCHWCFG_ANALOG_OC;
1337 isp116x_write_reg16(isp116x, HCHWCFG, val);
1338
1339 /* --- Root hub configuration */
1340 val = (25 << 24) & RH_A_POTPGT;
1341 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1342 be always set. Yet, instead, we request individual port
1343 power switching. */
1344 val |= RH_A_PSM;
1345 /* Report overcurrent per port */
1346 val |= RH_A_OCPM;
1347 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1348 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1349
1350 val = RH_B_PPCM;
1351 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1352 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1353
1354 val = 0;
1355 if (board->remote_wakeup_enable)
1356 val |= RH_HS_DRWE;
1357 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1358 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1359
1360 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1361
1362 /* Go operational */
1363 val = HCCONTROL_USB_OPER;
1364 if (board->remote_wakeup_enable)
1365 val |= HCCONTROL_RWE;
1366 isp116x_write_reg32(isp116x, HCCONTROL, val);
1367
1368 /* Disable ports to avoid race in device enumeration */
1369 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1370 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1371
1372 isp116x_show_regs(isp116x);
1373
1374 isp116x->disabled = 0;
1375
1376 return 0;
1377 }
1378
1379 /* --- Init functions ------------------------------------------------------ */
1380
1381 int isp116x_check_id(struct isp116x *isp116x)
1382 {
1383 int val;
1384
1385 val = isp116x_read_reg16(isp116x, HCCHIPID);
1386 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1387 ERR("invalid chip ID %04x", val);
1388 return -1;
1389 }
1390
1391 return 0;
1392 }
1393
1394 int usb_lowlevel_init(int index, void **controller))
1395 {
1396 struct isp116x *isp116x = &isp116x_dev;
1397
1398 DBG("");
1399
1400 got_rhsc = rh_devnum = 0;
1401
1402 /* Init device registers addr */
1403 isp116x->addr_reg = (u16 *) ISP116X_HCD_ADDR;
1404 isp116x->data_reg = (u16 *) ISP116X_HCD_DATA;
1405
1406 /* Setup specific board settings */
1407 #ifdef ISP116X_HCD_SEL15kRES
1408 isp116x_board.sel15Kres = 1;
1409 #endif
1410 #ifdef ISP116X_HCD_OC_ENABLE
1411 isp116x_board.oc_enable = 1;
1412 #endif
1413 #ifdef ISP116X_HCD_REMOTE_WAKEUP_ENABLE
1414 isp116x_board.remote_wakeup_enable = 1;
1415 #endif
1416 isp116x->board = &isp116x_board;
1417
1418 /* Try to get ISP116x silicon chip ID */
1419 if (isp116x_check_id(isp116x) < 0)
1420 return -1;
1421
1422 isp116x->disabled = 1;
1423 isp116x->sleeping = 0;
1424
1425 isp116x_reset(isp116x);
1426 isp116x_start(isp116x);
1427
1428 return 0;
1429 }
1430
1431 int usb_lowlevel_stop(int index)
1432 {
1433 struct isp116x *isp116x = &isp116x_dev;
1434
1435 DBG("");
1436
1437 if (!isp116x->disabled)
1438 isp116x_stop(isp116x);
1439
1440 return 0;
1441 }
"Das U-Boot" Source Tree