blob: bb27dd514ad07443ebf88bb9e7bc77f3e7ec387f [file] [log] [blame]
wdenk5cf91d62004-04-23 20:32:05 +00001/*
2 * (C) Copyright 2004
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * This code is based on linux driver for sl811hs chip, source at
6 * drivers/usb/host/sl811.c:
7 *
8 * SL811 Host Controller Interface driver for USB.
9 *
10 * Copyright (c) 2003/06, Courage Co., Ltd.
11 *
12 * Based on:
13 * 1.uhci.c by Linus Torvalds, Johannes Erdfelt, Randy Dunlap,
14 * Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber,
15 * Adam Richter, Gregory P. Smith;
16 * 2.Original SL811 driver (hc_sl811.o) by Pei Liu <pbl@cypress.com>
17 * 3.Rewrited as sl811.o by Yin Aihua <yinah:couragetech.com.cn>
18 *
19 * See file CREDITS for list of people who contributed to this
20 * project.
21 *
22 * This program is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU General Public License as
24 * published by the Free Software Foundation; either version 2 of
25 * the License, or (at your option) any later version.
26 *
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
31 *
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
35 * MA 02111-1307 USA
36 */
37
38#include <common.h>
wdenk5cf91d62004-04-23 20:32:05 +000039#include <mpc8xx.h>
40#include <usb.h>
41#include "sl811.h"
42
Jean-Christophe PLAGNIOL-VILLARD2731b9a2009-04-03 12:46:58 +020043#include "../../../board/kup/common/kup.h"
wdenk5cf91d62004-04-23 20:32:05 +000044
45#ifdef __PPC__
46# define EIEIO __asm__ volatile ("eieio")
47#else
48# define EIEIO /* nothing */
49#endif
50
51#define SL811_ADR (0x50000000)
52#define SL811_DAT (0x50000001)
53
wdenk5cf91d62004-04-23 20:32:05 +000054#ifdef SL811_DEBUG
55static int debug = 9;
56#endif
57
58static int root_hub_devnum = 0;
59static struct usb_port_status rh_status = { 0 };/* root hub port status */
60
61static int sl811_rh_submit_urb(struct usb_device *usb_dev, unsigned long pipe,
62 void *data, int buf_len, struct devrequest *cmd);
63
64static void sl811_write (__u8 index, __u8 data)
65{
66 *(volatile unsigned char *) (SL811_ADR) = index;
67 EIEIO;
68 *(volatile unsigned char *) (SL811_DAT) = data;
69 EIEIO;
70}
71
72static __u8 sl811_read (__u8 index)
73{
74 __u8 data;
75
76 *(volatile unsigned char *) (SL811_ADR) = index;
77 EIEIO;
78 data = *(volatile unsigned char *) (SL811_DAT);
79 EIEIO;
80 return (data);
81}
82
83/*
84 * Read consecutive bytes of data from the SL811H/SL11H buffer
85 */
86static void inline sl811_read_buf(__u8 offset, __u8 *buf, __u8 size)
87{
88 *(volatile unsigned char *) (SL811_ADR) = offset;
89 EIEIO;
90 while (size--) {
91 *buf++ = *(volatile unsigned char *) (SL811_DAT);
92 EIEIO;
93 }
94}
95
96/*
97 * Write consecutive bytes of data to the SL811H/SL11H buffer
98 */
99static void inline sl811_write_buf(__u8 offset, __u8 *buf, __u8 size)
100{
101 *(volatile unsigned char *) (SL811_ADR) = offset;
102 EIEIO;
103 while (size--) {
104 *(volatile unsigned char *) (SL811_DAT) = *buf++;
105 EIEIO;
106 }
107}
108
109int usb_init_kup4x (void)
110{
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200111 volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
wdenk5cf91d62004-04-23 20:32:05 +0000112 volatile memctl8xx_t *memctl = &immap->im_memctl;
113 int i;
114 unsigned char tmp;
115
116 memctl = &immap->im_memctl;
117 memctl->memc_or7 = 0xFFFF8726;
118 memctl->memc_br7 = 0x50000401; /* start at 0x50000000 */
119 /* BP 14 low = USB ON */
120 immap->im_cpm.cp_pbdat &= ~(BP_USB_VCC);
121 /* PB 14 nomal port */
122 immap->im_cpm.cp_pbpar &= ~(BP_USB_VCC);
123 /* output */
124 immap->im_cpm.cp_pbdir |= (BP_USB_VCC);
125
126 puts ("USB: ");
127
128 for (i = 0x10; i < 0xff; i++) {
129 sl811_write(i, i);
130 tmp = (sl811_read(i));
131 if (tmp != i) {
132 printf ("SL811 compare error index=0x%02x read=0x%02x\n", i, tmp);
133 return (-1);
134 }
135 }
136 printf ("SL811 ready\n");
137 return (0);
138}
139
140/*
141 * This function resets SL811HS controller and detects the speed of
142 * the connecting device
143 *
144 * Return: 0 = no device attached; 1 = USB device attached
145 */
146static int sl811_hc_reset(void)
147{
148 int status ;
149
150 sl811_write(SL811_CTRL2, SL811_CTL2_HOST | SL811_12M_HI);
151 sl811_write(SL811_CTRL1, SL811_CTRL1_RESET);
152
153 mdelay(20);
154
155 /* Disable hardware SOF generation, clear all irq status. */
156 sl811_write(SL811_CTRL1, 0);
157 mdelay(2);
158 sl811_write(SL811_INTRSTS, 0xff);
159 status = sl811_read(SL811_INTRSTS);
160
161 if (status & SL811_INTR_NOTPRESENT) {
162 /* Device is not present */
163 PDEBUG(0, "Device not present\n");
164 rh_status.wPortStatus &= ~(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE);
165 rh_status.wPortChange |= USB_PORT_STAT_C_CONNECTION;
166 sl811_write(SL811_INTR, SL811_INTR_INSRMV);
167 return 0;
168 }
169
170 /* Send SOF to address 0, endpoint 0. */
171 sl811_write(SL811_LEN_B, 0);
172 sl811_write(SL811_PIDEP_B, PIDEP(USB_PID_SOF, 0));
173 sl811_write(SL811_DEV_B, 0x00);
174 sl811_write(SL811_SOFLOW, SL811_12M_LOW);
175
176 if (status & SL811_INTR_SPEED_FULL) {
177 /* full speed device connect directly to root hub */
178 PDEBUG (0, "Full speed Device attached\n");
179
180 sl811_write(SL811_CTRL1, SL811_CTRL1_RESET);
181 mdelay(20);
182 sl811_write(SL811_CTRL2, SL811_CTL2_HOST | SL811_12M_HI);
183 sl811_write(SL811_CTRL1, SL811_CTRL1_SOF);
184
185 /* start the SOF or EOP */
186 sl811_write(SL811_CTRL_B, SL811_USB_CTRL_ARM);
187 rh_status.wPortStatus |= USB_PORT_STAT_CONNECTION;
188 rh_status.wPortStatus &= ~USB_PORT_STAT_LOW_SPEED;
189 mdelay(2);
190 sl811_write(SL811_INTRSTS, 0xff);
191 } else {
192 /* slow speed device connect directly to root-hub */
193 PDEBUG(0, "Low speed Device attached\n");
194
195 sl811_write(SL811_CTRL1, SL811_CTRL1_RESET);
196 mdelay(20);
197 sl811_write(SL811_CTRL2, SL811_CTL2_HOST | SL811_CTL2_DSWAP | SL811_12M_HI);
198 sl811_write(SL811_CTRL1, SL811_CTRL1_SPEED_LOW | SL811_CTRL1_SOF);
199
200 /* start the SOF or EOP */
201 sl811_write(SL811_CTRL_B, SL811_USB_CTRL_ARM);
202 rh_status.wPortStatus |= USB_PORT_STAT_CONNECTION | USB_PORT_STAT_LOW_SPEED;
203 mdelay(2);
204 sl811_write(SL811_INTRSTS, 0xff);
205 }
206
207 rh_status.wPortChange |= USB_PORT_STAT_C_CONNECTION;
208 sl811_write(SL811_INTR, /*SL811_INTR_INSRMV*/SL811_INTR_DONE_A);
209
210 return 1;
211}
212
213int usb_lowlevel_init(void)
214{
215 root_hub_devnum = 0;
216 sl811_hc_reset();
217 return 0;
218}
219
220int usb_lowlevel_stop(void)
221{
222 sl811_hc_reset();
223 return 0;
224}
225
wdenk953e2062004-05-12 13:20:19 +0000226static int calc_needed_buswidth(int bytes, int need_preamble)
wdenk32877d62004-05-05 19:44:41 +0000227{
wdenk953e2062004-05-12 13:20:19 +0000228 return !need_preamble ? bytes * 8 + 256 : 8 * 8 * bytes + 2048;
wdenk32877d62004-05-05 19:44:41 +0000229}
230
wdenk953e2062004-05-12 13:20:19 +0000231static int sl811_send_packet(struct usb_device *dev, unsigned long pipe, __u8 *buffer, int len)
wdenk5cf91d62004-04-23 20:32:05 +0000232{
233 __u8 ctrl = SL811_USB_CTRL_ARM | SL811_USB_CTRL_ENABLE;
wdenk2729af92004-05-03 20:45:30 +0000234 __u16 status = 0;
wdenk953e2062004-05-12 13:20:19 +0000235 int err = 0, time_start = get_timer(0);
236 int need_preamble = !(rh_status.wPortStatus & USB_PORT_STAT_LOW_SPEED) &&
237 usb_pipeslow(pipe);
wdenk5cf91d62004-04-23 20:32:05 +0000238
239 if (len > 239)
240 return -1;
241
wdenk953e2062004-05-12 13:20:19 +0000242 if (usb_pipeout(pipe))
wdenk5cf91d62004-04-23 20:32:05 +0000243 ctrl |= SL811_USB_CTRL_DIR_OUT;
wdenk953e2062004-05-12 13:20:19 +0000244 if (usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)))
wdenk5cf91d62004-04-23 20:32:05 +0000245 ctrl |= SL811_USB_CTRL_TOGGLE_1;
wdenk953e2062004-05-12 13:20:19 +0000246 if (need_preamble)
247 ctrl |= SL811_USB_CTRL_PREAMBLE;
wdenk02b11f82004-05-12 22:54:36 +0000248
wdenk2729af92004-05-03 20:45:30 +0000249 sl811_write(SL811_INTRSTS, 0xff);
wdenk5cf91d62004-04-23 20:32:05 +0000250
251 while (err < 3) {
wdenk2729af92004-05-03 20:45:30 +0000252 sl811_write(SL811_ADDR_A, 0x10);
253 sl811_write(SL811_LEN_A, len);
wdenk953e2062004-05-12 13:20:19 +0000254 if (usb_pipeout(pipe) && len)
wdenk2729af92004-05-03 20:45:30 +0000255 sl811_write_buf(0x10, buffer, len);
256
wdenk953e2062004-05-12 13:20:19 +0000257 if (!(rh_status.wPortStatus & USB_PORT_STAT_LOW_SPEED) &&
258 sl811_read(SL811_SOFCNTDIV)*64 < calc_needed_buswidth(len, need_preamble))
wdenk5cf91d62004-04-23 20:32:05 +0000259 ctrl |= SL811_USB_CTRL_SOF;
260 else
261 ctrl &= ~SL811_USB_CTRL_SOF;
wdenk2729af92004-05-03 20:45:30 +0000262
wdenk5cf91d62004-04-23 20:32:05 +0000263 sl811_write(SL811_CTRL_A, ctrl);
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200264 while (!(sl811_read(SL811_INTRSTS) & SL811_INTR_DONE_A)) {
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200265 if (5*CONFIG_SYS_HZ < get_timer(time_start)) {
wdenk2729af92004-05-03 20:45:30 +0000266 printf("USB transmit timed out\n");
267 return -USB_ST_CRC_ERR;
268 }
269 }
wdenk5cf91d62004-04-23 20:32:05 +0000270
271 sl811_write(SL811_INTRSTS, 0xff);
272 status = sl811_read(SL811_STS_A);
273
274 if (status & SL811_USB_STS_ACK) {
275 int remainder = sl811_read(SL811_CNT_A);
276 if (remainder) {
277 PDEBUG(0, "usb transfer remainder = %d\n", remainder);
278 len -= remainder;
279 }
wdenk953e2062004-05-12 13:20:19 +0000280 if (usb_pipein(pipe) && len)
wdenk5cf91d62004-04-23 20:32:05 +0000281 sl811_read_buf(0x10, buffer, len);
282 return len;
283 }
284
285 if ((status & SL811_USB_STS_NAK) == SL811_USB_STS_NAK)
286 continue;
287
288 PDEBUG(0, "usb transfer error %#x\n", (int)status);
289 err++;
290 }
291
wdenk2729af92004-05-03 20:45:30 +0000292 err = 0;
293
294 if (status & SL811_USB_STS_ERROR)
295 err |= USB_ST_BUF_ERR;
296 if (status & SL811_USB_STS_TIMEOUT)
297 err |= USB_ST_CRC_ERR;
298 if (status & SL811_USB_STS_STALL)
299 err |= USB_ST_STALLED;
300
301 return -err;
wdenk5cf91d62004-04-23 20:32:05 +0000302}
303
304int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
305 int len)
306{
307 int dir_out = usb_pipeout(pipe);
308 int ep = usb_pipeendpoint(pipe);
wdenk5cf91d62004-04-23 20:32:05 +0000309 int max = usb_maxpacket(dev, pipe);
310 int done = 0;
311
312 PDEBUG(7, "dev = %ld pipe = %ld buf = %p size = %d dir_out = %d\n",
313 usb_pipedevice(pipe), usb_pipeendpoint(pipe), buffer, len, dir_out);
314
315 dev->status = 0;
316
317 sl811_write(SL811_DEV_A, usb_pipedevice(pipe));
318 sl811_write(SL811_PIDEP_A, PIDEP(!dir_out ? USB_PID_IN : USB_PID_OUT, ep));
319 while (done < len) {
wdenk953e2062004-05-12 13:20:19 +0000320 int res = sl811_send_packet(dev, pipe, (__u8*)buffer+done,
wdenk5cf91d62004-04-23 20:32:05 +0000321 max > len - done ? len - done : max);
322 if (res < 0) {
wdenk2729af92004-05-03 20:45:30 +0000323 dev->status = -res;
wdenk5cf91d62004-04-23 20:32:05 +0000324 return res;
325 }
326
327 if (!dir_out && res < max) /* short packet */
328 break;
329
330 done += res;
331 usb_dotoggle(dev, ep, dir_out);
332 }
333
334 dev->act_len = done;
335
336 return 0;
337}
338
339int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
340 int len,struct devrequest *setup)
341{
342 int done = 0;
343 int devnum = usb_pipedevice(pipe);
wdenk953e2062004-05-12 13:20:19 +0000344 int ep = usb_pipeendpoint(pipe);
wdenk5cf91d62004-04-23 20:32:05 +0000345
346 dev->status = 0;
347
348 if (devnum == root_hub_devnum)
349 return sl811_rh_submit_urb(dev, pipe, buffer, len, setup);
350
wdenk953e2062004-05-12 13:20:19 +0000351 PDEBUG(7, "dev = %d pipe = %ld buf = %p size = %d rt = %#x req = %#x bus = %i\n",
352 devnum, ep, buffer, len, (int)setup->requesttype,
353 (int)setup->request, sl811_read(SL811_SOFCNTDIV)*64);
wdenk5cf91d62004-04-23 20:32:05 +0000354
355 sl811_write(SL811_DEV_A, devnum);
wdenk953e2062004-05-12 13:20:19 +0000356 sl811_write(SL811_PIDEP_A, PIDEP(USB_PID_SETUP, ep));
wdenk5cf91d62004-04-23 20:32:05 +0000357 /* setup phase */
wdenk953e2062004-05-12 13:20:19 +0000358 usb_settoggle(dev, ep, 1, 0);
359 if (sl811_send_packet(dev, usb_sndctrlpipe(dev, ep),
360 (__u8*)setup, sizeof(*setup)) == sizeof(*setup)) {
361 int dir_in = usb_pipein(pipe);
wdenk5cf91d62004-04-23 20:32:05 +0000362 int max = usb_maxpacket(dev, pipe);
363
364 /* data phase */
365 sl811_write(SL811_PIDEP_A,
wdenk953e2062004-05-12 13:20:19 +0000366 PIDEP(dir_in ? USB_PID_IN : USB_PID_OUT, ep));
367 usb_settoggle(dev, ep, usb_pipeout(pipe), 1);
wdenk5cf91d62004-04-23 20:32:05 +0000368 while (done < len) {
wdenk953e2062004-05-12 13:20:19 +0000369 int res = sl811_send_packet(dev, pipe, (__u8*)buffer+done,
wdenk5cf91d62004-04-23 20:32:05 +0000370 max > len - done ? len - done : max);
wdenk2729af92004-05-03 20:45:30 +0000371 if (res < 0) {
wdenk953e2062004-05-12 13:20:19 +0000372 PDEBUG(0, "status data failed!\n");
wdenk2729af92004-05-03 20:45:30 +0000373 dev->status = -res;
374 return 0;
375 }
wdenk5cf91d62004-04-23 20:32:05 +0000376 done += res;
wdenk953e2062004-05-12 13:20:19 +0000377 usb_dotoggle(dev, ep, usb_pipeout(pipe));
wdenk5cf91d62004-04-23 20:32:05 +0000378 if (dir_in && res < max) /* short packet */
379 break;
wdenk5cf91d62004-04-23 20:32:05 +0000380 }
381
382 /* status phase */
383 sl811_write(SL811_PIDEP_A,
wdenk953e2062004-05-12 13:20:19 +0000384 PIDEP(!dir_in ? USB_PID_IN : USB_PID_OUT, ep));
385 usb_settoggle(dev, ep, !usb_pipeout(pipe), 1);
wdenk02b11f82004-05-12 22:54:36 +0000386 if (sl811_send_packet(dev,
387 !dir_in ? usb_rcvctrlpipe(dev, ep) :
388 usb_sndctrlpipe(dev, ep),
wdenk953e2062004-05-12 13:20:19 +0000389 0, 0) < 0) {
wdenk5cf91d62004-04-23 20:32:05 +0000390 PDEBUG(0, "status phase failed!\n");
391 dev->status = -1;
392 }
393 } else {
394 PDEBUG(0, "setup phase failed!\n");
395 dev->status = -1;
396 }
397
398 dev->act_len = done;
399
400 return done;
401}
402
403int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
404 int len, int interval)
405{
wdenk2729af92004-05-03 20:45:30 +0000406 PDEBUG(0, "dev = %p pipe = %#lx buf = %p size = %d int = %d\n", dev, pipe,
wdenk5cf91d62004-04-23 20:32:05 +0000407 buffer, len, interval);
408 return -1;
409}
410
411/*
412 * SL811 Virtual Root Hub
413 */
414
415/* Device descriptor */
416static __u8 sl811_rh_dev_des[] =
417{
418 0x12, /* __u8 bLength; */
419 0x01, /* __u8 bDescriptorType; Device */
420 0x10, /* __u16 bcdUSB; v1.1 */
421 0x01,
422 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
423 0x00, /* __u8 bDeviceSubClass; */
424 0x00, /* __u8 bDeviceProtocol; */
425 0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
426 0x00, /* __u16 idVendor; */
427 0x00,
428 0x00, /* __u16 idProduct; */
429 0x00,
430 0x00, /* __u16 bcdDevice; */
431 0x00,
432 0x00, /* __u8 iManufacturer; */
433 0x02, /* __u8 iProduct; */
434 0x01, /* __u8 iSerialNumber; */
435 0x01 /* __u8 bNumConfigurations; */
436};
437
438/* Configuration descriptor */
439static __u8 sl811_rh_config_des[] =
440{
441 0x09, /* __u8 bLength; */
442 0x02, /* __u8 bDescriptorType; Configuration */
443 0x19, /* __u16 wTotalLength; */
444 0x00,
445 0x01, /* __u8 bNumInterfaces; */
446 0x01, /* __u8 bConfigurationValue; */
447 0x00, /* __u8 iConfiguration; */
448 0x40, /* __u8 bmAttributes;
449 Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup,
450 4..0: resvd */
451 0x00, /* __u8 MaxPower; */
452
453 /* interface */
454 0x09, /* __u8 if_bLength; */
455 0x04, /* __u8 if_bDescriptorType; Interface */
456 0x00, /* __u8 if_bInterfaceNumber; */
457 0x00, /* __u8 if_bAlternateSetting; */
458 0x01, /* __u8 if_bNumEndpoints; */
459 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
460 0x00, /* __u8 if_bInterfaceSubClass; */
461 0x00, /* __u8 if_bInterfaceProtocol; */
462 0x00, /* __u8 if_iInterface; */
463
464 /* endpoint */
465 0x07, /* __u8 ep_bLength; */
466 0x05, /* __u8 ep_bDescriptorType; Endpoint */
467 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
468 0x03, /* __u8 ep_bmAttributes; Interrupt */
469 0x08, /* __u16 ep_wMaxPacketSize; */
470 0x00,
471 0xff /* __u8 ep_bInterval; 255 ms */
472};
473
474/* root hub class descriptor*/
475static __u8 sl811_rh_hub_des[] =
476{
477 0x09, /* __u8 bLength; */
478 0x29, /* __u8 bDescriptorType; Hub-descriptor */
479 0x01, /* __u8 bNbrPorts; */
480 0x00, /* __u16 wHubCharacteristics; */
481 0x00,
482 0x50, /* __u8 bPwrOn2pwrGood; 2ms */
483 0x00, /* __u8 bHubContrCurrent; 0 mA */
484 0xfc, /* __u8 DeviceRemovable; *** 7 Ports max *** */
485 0xff /* __u8 PortPwrCtrlMask; *** 7 ports max *** */
486};
487
488/*
489 * helper routine for returning string descriptors in UTF-16LE
490 * input can actually be ISO-8859-1; ASCII is its 7-bit subset
491 */
492static int ascii2utf (char *s, u8 *utf, int utfmax)
493{
494 int retval;
495
496 for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
497 *utf++ = *s++;
498 *utf++ = 0;
499 }
500 return retval;
501}
502
503/*
504 * root_hub_string is used by each host controller's root hub code,
505 * so that they're identified consistently throughout the system.
506 */
wdenk32877d62004-05-05 19:44:41 +0000507static int usb_root_hub_string (int id, int serial, char *type, __u8 *data, int len)
wdenk5cf91d62004-04-23 20:32:05 +0000508{
509 char buf [30];
510
511 /* assert (len > (2 * (sizeof (buf) + 1)));
512 assert (strlen (type) <= 8);*/
513
514 /* language ids */
515 if (id == 0) {
wdenk953e2062004-05-12 13:20:19 +0000516 *data++ = 4; *data++ = 3; /* 4 bytes data */
wdenk5cf91d62004-04-23 20:32:05 +0000517 *data++ = 0; *data++ = 0; /* some language id */
518 return 4;
519
520 /* serial number */
521 } else if (id == 1) {
wdenk953e2062004-05-12 13:20:19 +0000522 sprintf (buf, "%#x", serial);
wdenk5cf91d62004-04-23 20:32:05 +0000523
524 /* product description */
525 } else if (id == 2) {
526 sprintf (buf, "USB %s Root Hub", type);
527
528 /* id 3 == vendor description */
529
530 /* unsupported IDs --> "stall" */
531 } else
532 return 0;
533
wdenk953e2062004-05-12 13:20:19 +0000534 ascii2utf (buf, data + 2, len - 2);
535 data [0] = 2 + strlen(buf) * 2;
wdenk5cf91d62004-04-23 20:32:05 +0000536 data [1] = 3;
537 return data [0];
538}
539
540/* helper macro */
541#define OK(x) len = (x); break
542
543/*
544 * This function handles all USB request to the the virtual root hub
545 */
546static int sl811_rh_submit_urb(struct usb_device *usb_dev, unsigned long pipe,
547 void *data, int buf_len, struct devrequest *cmd)
548{
549 __u8 data_buf[16];
550 __u8 *bufp = data_buf;
551 int len = 0;
552 int status = 0;
wdenk5cf91d62004-04-23 20:32:05 +0000553 __u16 bmRType_bReq;
Wolfgang Denkb0b20d42011-11-29 22:17:51 +0000554 __u16 wValue = le16_to_cpu (cmd->value);
555 __u16 wLength = le16_to_cpu (cmd->length);
556#ifdef SL811_DEBUG
557 __u16 wIndex = le16_to_cpu (cmd->index);
558#endif
wdenk5cf91d62004-04-23 20:32:05 +0000559
560 if (usb_pipeint(pipe)) {
561 PDEBUG(0, "interrupt transfer unimplemented!\n");
562 return 0;
563 }
564
565 bmRType_bReq = cmd->requesttype | (cmd->request << 8);
wdenk5cf91d62004-04-23 20:32:05 +0000566
567 PDEBUG(5, "submit rh urb, req = %d(%x) val = %#x index = %#x len=%d\n",
568 bmRType_bReq, bmRType_bReq, wValue, wIndex, wLength);
569
570 /* Request Destination:
571 without flags: Device,
572 USB_RECIP_INTERFACE: interface,
573 USB_RECIP_ENDPOINT: endpoint,
574 USB_TYPE_CLASS means HUB here,
575 USB_RECIP_OTHER | USB_TYPE_CLASS almost ever means HUB_PORT here
576 */
577 switch (bmRType_bReq) {
578 case RH_GET_STATUS:
579 *(__u16 *)bufp = cpu_to_le16(1);
580 OK(2);
581
582 case RH_GET_STATUS | USB_RECIP_INTERFACE:
583 *(__u16 *)bufp = cpu_to_le16(0);
584 OK(2);
585
586 case RH_GET_STATUS | USB_RECIP_ENDPOINT:
587 *(__u16 *)bufp = cpu_to_le16(0);
588 OK(2);
589
590 case RH_GET_STATUS | USB_TYPE_CLASS:
591 *(__u32 *)bufp = cpu_to_le32(0);
592 OK(4);
593
594 case RH_GET_STATUS | USB_RECIP_OTHER | USB_TYPE_CLASS:
595 *(__u32 *)bufp = cpu_to_le32(rh_status.wPortChange<<16 | rh_status.wPortStatus);
596 OK(4);
597
598 case RH_CLEAR_FEATURE | USB_RECIP_ENDPOINT:
599 switch (wValue) {
600 case 1:
601 OK(0);
602 }
603 break;
604
605 case RH_CLEAR_FEATURE | USB_TYPE_CLASS:
606 switch (wValue) {
607 case C_HUB_LOCAL_POWER:
608 OK(0);
609
610 case C_HUB_OVER_CURRENT:
611 OK(0);
612 }
613 break;
614
615 case RH_CLEAR_FEATURE | USB_RECIP_OTHER | USB_TYPE_CLASS:
616 switch (wValue) {
617 case USB_PORT_FEAT_ENABLE:
618 rh_status.wPortStatus &= ~USB_PORT_STAT_ENABLE;
619 OK(0);
620
621 case USB_PORT_FEAT_SUSPEND:
622 rh_status.wPortStatus &= ~USB_PORT_STAT_SUSPEND;
623 OK(0);
624
625 case USB_PORT_FEAT_POWER:
626 rh_status.wPortStatus &= ~USB_PORT_STAT_POWER;
627 OK(0);
628
629 case USB_PORT_FEAT_C_CONNECTION:
630 rh_status.wPortChange &= ~USB_PORT_STAT_C_CONNECTION;
631 OK(0);
632
633 case USB_PORT_FEAT_C_ENABLE:
634 rh_status.wPortChange &= ~USB_PORT_STAT_C_ENABLE;
635 OK(0);
636
637 case USB_PORT_FEAT_C_SUSPEND:
638 rh_status.wPortChange &= ~USB_PORT_STAT_C_SUSPEND;
639 OK(0);
640
641 case USB_PORT_FEAT_C_OVER_CURRENT:
642 rh_status.wPortChange &= ~USB_PORT_STAT_C_OVERCURRENT;
643 OK(0);
644
645 case USB_PORT_FEAT_C_RESET:
646 rh_status.wPortChange &= ~USB_PORT_STAT_C_RESET;
647 OK(0);
648 }
649 break;
650
651 case RH_SET_FEATURE | USB_RECIP_OTHER | USB_TYPE_CLASS:
652 switch (wValue) {
653 case USB_PORT_FEAT_SUSPEND:
654 rh_status.wPortStatus |= USB_PORT_STAT_SUSPEND;
655 OK(0);
656
657 case USB_PORT_FEAT_RESET:
658 rh_status.wPortStatus |= USB_PORT_STAT_RESET;
659 rh_status.wPortChange = 0;
660 rh_status.wPortChange |= USB_PORT_STAT_C_RESET;
661 rh_status.wPortStatus &= ~USB_PORT_STAT_RESET;
662 rh_status.wPortStatus |= USB_PORT_STAT_ENABLE;
663 OK(0);
664
665 case USB_PORT_FEAT_POWER:
666 rh_status.wPortStatus |= USB_PORT_STAT_POWER;
667 OK(0);
668
669 case USB_PORT_FEAT_ENABLE:
670 rh_status.wPortStatus |= USB_PORT_STAT_ENABLE;
671 OK(0);
672 }
673 break;
674
675 case RH_SET_ADDRESS:
676 root_hub_devnum = wValue;
677 OK(0);
678
679 case RH_GET_DESCRIPTOR:
680 switch ((wValue & 0xff00) >> 8) {
681 case USB_DT_DEVICE:
682 len = sizeof(sl811_rh_dev_des);
683 bufp = sl811_rh_dev_des;
684 OK(len);
685
686 case USB_DT_CONFIG:
687 len = sizeof(sl811_rh_config_des);
688 bufp = sl811_rh_config_des;
689 OK(len);
690
691 case USB_DT_STRING:
692 len = usb_root_hub_string(wValue & 0xff, (int)(long)0, "SL811HS", data, wLength);
693 if (len > 0) {
694 bufp = data;
695 OK(len);
696 }
697
698 default:
699 status = -32;
700 }
701 break;
702
703 case RH_GET_DESCRIPTOR | USB_TYPE_CLASS:
704 len = sizeof(sl811_rh_hub_des);
705 bufp = sl811_rh_hub_des;
706 OK(len);
707
708 case RH_GET_CONFIGURATION:
709 bufp[0] = 0x01;
710 OK(1);
711
712 case RH_SET_CONFIGURATION:
713 OK(0);
714
715 default:
716 PDEBUG(1, "unsupported root hub command\n");
717 status = -32;
718 }
719
720 len = min(len, buf_len);
721 if (data != bufp)
722 memcpy(data, bufp, len);
723
724 PDEBUG(5, "len = %d, status = %d\n", len, status);
725
726 usb_dev->status = status;
727 usb_dev->act_len = len;
728
729 return status == 0 ? len : status;
730}