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