]>
Commit | Line | Data |
---|---|---|
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" | |
112 | static const char hcd_name[] = "isp116x-hcd"; | |
113 | ||
114 | struct isp116x isp116x_dev; | |
115 | struct isp116x_platform_data isp116x_board; | |
785c1347 | 116 | static int got_rhsc; /* root hub status change */ |
822af351 | 117 | struct usb_device *devgone; /* device which was disconnected */ |
785c1347 | 118 | static 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 | ||
128 | static 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 | ||
173 | static 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 | ||
180 | static 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 | */ | |
218 | static 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 | ||
238 | static 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 */ | |
274 | static __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 */ | |
296 | static __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 | ||
329 | static 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 | ||
336 | static 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 | ||
379 | static 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 | */ | |
403 | static 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 | */ | |
432 | static 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 */ | |
461 | static 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 */ | |
495 | static 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 | */ | |
542 | static 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 | */ | |
600 | struct ptd ptd[1]; | |
601 | ||
822af351 RG |
602 | static 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 | */ | |
614 | static 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 | 680 | retry_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 | */ | |
808 | static 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 | ||
1137 | int 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 | ||
1146 | int 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 | ||
1208 | int 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 | ||
1243 | static 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 | ||
1267 | static 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 | ||
1295 | static 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 | */ | |
1316 | static 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 | ||
1383 | int 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 | ||
1396 | int 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 | ||
1433 | int 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 */ |