?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spi: spi-fsl-qspi: Fix return value check of devm_ioremap() in probe
[linux/fpc-iii.git] / drivers / usb / gadget / udc / aspeed-vhub / hub.c
blob6e565c3dbb5b88d87889649a522c3585e2b806f2
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget
4 *
5 * hub.c - virtual hub handling
6 *
7 * Copyright 2017 IBM Corporation
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/delay.h>
19 #include <linux/ioport.h>
20 #include <linux/slab.h>
21 #include <linux/errno.h>
22 #include <linux/list.h>
23 #include <linux/interrupt.h>
24 #include <linux/proc_fs.h>
25 #include <linux/prefetch.h>
26 #include <linux/clk.h>
27 #include <linux/usb/gadget.h>
28 #include <linux/of.h>
29 #include <linux/of_gpio.h>
30 #include <linux/regmap.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/bcd.h>
33 #include <linux/version.h>
34 #include <linux/usb.h>
35 #include <linux/usb/hcd.h>
36
37 #include "vhub.h"
38
39 /* usb 2.0 hub device descriptor
40 *
41 * A few things we may want to improve here:
42 *
43 * - We may need to indicate TT support
44 * - We may need a device qualifier descriptor
45 * as devices can pretend to be usb1 or 2
46 * - Make vid/did overridable
47 * - make it look like usb1 if usb1 mode forced
48 */
49 #define KERNEL_REL bin2bcd(((LINUX_VERSION_CODE >> 16) & 0x0ff))
50 #define KERNEL_VER bin2bcd(((LINUX_VERSION_CODE >> 8) & 0x0ff))
51
52 enum {
53 AST_VHUB_STR_MANUF = 3,
54 AST_VHUB_STR_PRODUCT = 2,
55 AST_VHUB_STR_SERIAL = 1,
56 };
57
58 static const struct usb_device_descriptor ast_vhub_dev_desc = {
59 .bLength = USB_DT_DEVICE_SIZE,
60 .bDescriptorType = USB_DT_DEVICE,
61 .bcdUSB = cpu_to_le16(0x0200),
62 .bDeviceClass = USB_CLASS_HUB,
63 .bDeviceSubClass = 0,
64 .bDeviceProtocol = 1,
65 .bMaxPacketSize0 = 64,
66 .idVendor = cpu_to_le16(0x1d6b),
67 .idProduct = cpu_to_le16(0x0107),
68 .bcdDevice = cpu_to_le16(0x0100),
69 .iManufacturer = AST_VHUB_STR_MANUF,
70 .iProduct = AST_VHUB_STR_PRODUCT,
71 .iSerialNumber = AST_VHUB_STR_SERIAL,
72 .bNumConfigurations = 1,
73 };
74
75 /* Patches to the above when forcing USB1 mode */
76 static void ast_vhub_patch_dev_desc_usb1(struct usb_device_descriptor *desc)
77 {
78 desc->bcdUSB = cpu_to_le16(0x0100);
79 desc->bDeviceProtocol = 0;
80 }
81
82 /*
83 * Configuration descriptor: same comments as above
84 * regarding handling USB1 mode.
85 */
86
87 /*
88 * We don't use sizeof() as Linux definition of
89 * struct usb_endpoint_descriptor contains 2
90 * extra bytes
91 */
92 #define AST_VHUB_CONF_DESC_SIZE (USB_DT_CONFIG_SIZE + \
93 USB_DT_INTERFACE_SIZE + \
94 USB_DT_ENDPOINT_SIZE)
95
96 static const struct ast_vhub_full_cdesc ast_vhub_conf_desc = {
97 .cfg = {
98 .bLength = USB_DT_CONFIG_SIZE,
99 .bDescriptorType = USB_DT_CONFIG,
100 .wTotalLength = cpu_to_le16(AST_VHUB_CONF_DESC_SIZE),
101 .bNumInterfaces = 1,
102 .bConfigurationValue = 1,
103 .iConfiguration = 0,
104 .bmAttributes = USB_CONFIG_ATT_ONE |
105 USB_CONFIG_ATT_SELFPOWER |
106 USB_CONFIG_ATT_WAKEUP,
107 .bMaxPower = 0,
108 },
109 .intf = {
110 .bLength = USB_DT_INTERFACE_SIZE,
111 .bDescriptorType = USB_DT_INTERFACE,
112 .bInterfaceNumber = 0,
113 .bAlternateSetting = 0,
114 .bNumEndpoints = 1,
115 .bInterfaceClass = USB_CLASS_HUB,
116 .bInterfaceSubClass = 0,
117 .bInterfaceProtocol = 0,
118 .iInterface = 0,
119 },
120 .ep = {
121 .bLength = USB_DT_ENDPOINT_SIZE,
122 .bDescriptorType = USB_DT_ENDPOINT,
123 .bEndpointAddress = 0x81,
124 .bmAttributes = USB_ENDPOINT_XFER_INT,
125 .wMaxPacketSize = cpu_to_le16(1),
126 .bInterval = 0x0c,
127 },
128 };
129
130 #define AST_VHUB_HUB_DESC_SIZE (USB_DT_HUB_NONVAR_SIZE + 2)
131
132 static const struct usb_hub_descriptor ast_vhub_hub_desc = {
133 .bDescLength = AST_VHUB_HUB_DESC_SIZE,
134 .bDescriptorType = USB_DT_HUB,
135 .bNbrPorts = AST_VHUB_NUM_PORTS,
136 .wHubCharacteristics = cpu_to_le16(HUB_CHAR_NO_LPSM),
137 .bPwrOn2PwrGood = 10,
138 .bHubContrCurrent = 0,
139 .u.hs.DeviceRemovable[0] = 0,
140 .u.hs.DeviceRemovable[1] = 0xff,
141 };
142
143 /*
144 * These strings converted to UTF-16 must be smaller than
145 * our EP0 buffer.
146 */
147 static const struct usb_string ast_vhub_str_array[] = {
148 {
149 .id = AST_VHUB_STR_SERIAL,
150 .s = "00000000"
151 },
152 {
153 .id = AST_VHUB_STR_PRODUCT,
154 .s = "USB Virtual Hub"
155 },
156 {
157 .id = AST_VHUB_STR_MANUF,
158 .s = "Aspeed"
159 },
160 { }
161 };
162
163 static const struct usb_gadget_strings ast_vhub_strings = {
164 .language = 0x0409,
165 .strings = (struct usb_string *)ast_vhub_str_array
166 };
167
168 static int ast_vhub_hub_dev_status(struct ast_vhub_ep *ep,
169 u16 wIndex, u16 wValue)
170 {
171 u8 st0;
172
173 EPDBG(ep, "GET_STATUS(dev)\n");
174
175 /*
176 * Mark it as self-powered, I doubt the BMC is powered off
177 * the USB bus ...
178 */
179 st0 = 1 << USB_DEVICE_SELF_POWERED;
180
181 /*
182 * Need to double check how remote wakeup actually works
183 * on that chip and what triggers it.
184 */
185 if (ep->vhub->wakeup_en)
186 st0 |= 1 << USB_DEVICE_REMOTE_WAKEUP;
187
188 return ast_vhub_simple_reply(ep, st0, 0);
189 }
190
191 static int ast_vhub_hub_ep_status(struct ast_vhub_ep *ep,
192 u16 wIndex, u16 wValue)
193 {
194 int ep_num;
195 u8 st0 = 0;
196
197 ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK;
198 EPDBG(ep, "GET_STATUS(ep%d)\n", ep_num);
199
200 /* On the hub we have only EP 0 and 1 */
201 if (ep_num == 1) {
202 if (ep->vhub->ep1_stalled)
203 st0 |= 1 << USB_ENDPOINT_HALT;
204 } else if (ep_num != 0)
205 return std_req_stall;
206
207 return ast_vhub_simple_reply(ep, st0, 0);
208 }
209
210 static int ast_vhub_hub_dev_feature(struct ast_vhub_ep *ep,
211 u16 wIndex, u16 wValue,
212 bool is_set)
213 {
214 EPDBG(ep, "%s_FEATURE(dev val=%02x)\n",
215 is_set ? "SET" : "CLEAR", wValue);
216
217 if (wValue != USB_DEVICE_REMOTE_WAKEUP)
218 return std_req_stall;
219
220 ep->vhub->wakeup_en = is_set;
221 EPDBG(ep, "Hub remote wakeup %s\n",
222 is_set ? "enabled" : "disabled");
223
224 return std_req_complete;
225 }
226
227 static int ast_vhub_hub_ep_feature(struct ast_vhub_ep *ep,
228 u16 wIndex, u16 wValue,
229 bool is_set)
230 {
231 int ep_num;
232 u32 reg;
233
234 ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK;
235 EPDBG(ep, "%s_FEATURE(ep%d val=%02x)\n",
236 is_set ? "SET" : "CLEAR", ep_num, wValue);
237
238 if (ep_num > 1)
239 return std_req_stall;
240 if (wValue != USB_ENDPOINT_HALT)
241 return std_req_stall;
242 if (ep_num == 0)
243 return std_req_complete;
244
245 EPDBG(ep, "%s stall on EP 1\n",
246 is_set ? "setting" : "clearing");
247
248 ep->vhub->ep1_stalled = is_set;
249 reg = readl(ep->vhub->regs + AST_VHUB_EP1_CTRL);
250 if (is_set) {
251 reg |= VHUB_EP1_CTRL_STALL;
252 } else {
253 reg &= ~VHUB_EP1_CTRL_STALL;
254 reg |= VHUB_EP1_CTRL_RESET_TOGGLE;
255 }
256 writel(reg, ep->vhub->regs + AST_VHUB_EP1_CTRL);
257
258 return std_req_complete;
259 }
260
261 static int ast_vhub_rep_desc(struct ast_vhub_ep *ep,
262 u8 desc_type, u16 len)
263 {
264 size_t dsize;
265 struct ast_vhub *vhub = ep->vhub;
266
267 EPDBG(ep, "GET_DESCRIPTOR(type:%d)\n", desc_type);
268
269 /*
270 * Copy first to EP buffer and send from there, so
271 * we can do some in-place patching if needed. We know
272 * the EP buffer is big enough but ensure that doesn't
273 * change. We do that now rather than later after we
274 * have checked sizes etc... to avoid a gcc bug where
275 * it thinks len is constant and barfs about read
276 * overflows in memcpy.
277 */
278 switch(desc_type) {
279 case USB_DT_DEVICE:
280 dsize = USB_DT_DEVICE_SIZE;
281 memcpy(ep->buf, &vhub->vhub_dev_desc, dsize);
282 BUILD_BUG_ON(dsize > sizeof(vhub->vhub_dev_desc));
283 BUILD_BUG_ON(USB_DT_DEVICE_SIZE >= AST_VHUB_EP0_MAX_PACKET);
284 break;
285 case USB_DT_CONFIG:
286 dsize = AST_VHUB_CONF_DESC_SIZE;
287 memcpy(ep->buf, &vhub->vhub_conf_desc, dsize);
288 BUILD_BUG_ON(dsize > sizeof(vhub->vhub_conf_desc));
289 BUILD_BUG_ON(AST_VHUB_CONF_DESC_SIZE >= AST_VHUB_EP0_MAX_PACKET);
290 break;
291 case USB_DT_HUB:
292 dsize = AST_VHUB_HUB_DESC_SIZE;
293 memcpy(ep->buf, &vhub->vhub_hub_desc, dsize);
294 BUILD_BUG_ON(dsize > sizeof(vhub->vhub_hub_desc));
295 BUILD_BUG_ON(AST_VHUB_HUB_DESC_SIZE >= AST_VHUB_EP0_MAX_PACKET);
296 break;
297 default:
298 return std_req_stall;
299 }
300
301 /* Crop requested length */
302 if (len > dsize)
303 len = dsize;
304
305 /* Patch it if forcing USB1 */
306 if (desc_type == USB_DT_DEVICE && ep->vhub->force_usb1)
307 ast_vhub_patch_dev_desc_usb1(ep->buf);
308
309 /* Shoot it from the EP buffer */
310 return ast_vhub_reply(ep, NULL, len);
311 }
312
313 static int ast_vhub_rep_string(struct ast_vhub_ep *ep,
314 u8 string_id, u16 lang_id,
315 u16 len)
316 {
317 int rc = usb_gadget_get_string(&ep->vhub->vhub_str_desc,
318 string_id, ep->buf);
319
320 /*
321 * This should never happen unless we put too big strings in
322 * the array above
323 */
324 BUG_ON(rc >= AST_VHUB_EP0_MAX_PACKET);
325
326 if (rc < 0)
327 return std_req_stall;
328
329 /* Shoot it from the EP buffer */
330 return ast_vhub_reply(ep, NULL, min_t(u16, rc, len));
331 }
332
333 enum std_req_rc ast_vhub_std_hub_request(struct ast_vhub_ep *ep,
334 struct usb_ctrlrequest *crq)
335 {
336 struct ast_vhub *vhub = ep->vhub;
337 u16 wValue, wIndex, wLength;
338
339 wValue = le16_to_cpu(crq->wValue);
340 wIndex = le16_to_cpu(crq->wIndex);
341 wLength = le16_to_cpu(crq->wLength);
342
343 /* First packet, grab speed */
344 if (vhub->speed == USB_SPEED_UNKNOWN) {
345 u32 ustat = readl(vhub->regs + AST_VHUB_USBSTS);
346 if (ustat & VHUB_USBSTS_HISPEED)
347 vhub->speed = USB_SPEED_HIGH;
348 else
349 vhub->speed = USB_SPEED_FULL;
350 UDCDBG(vhub, "USB status=%08x speed=%s\n", ustat,
351 vhub->speed == USB_SPEED_HIGH ? "high" : "full");
352 }
353
354 switch ((crq->bRequestType << 8) | crq->bRequest) {
355 /* SET_ADDRESS */
356 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
357 EPDBG(ep, "SET_ADDRESS: Got address %x\n", wValue);
358 writel(wValue, vhub->regs + AST_VHUB_CONF);
359 return std_req_complete;
360
361 /* GET_STATUS */
362 case DeviceRequest | USB_REQ_GET_STATUS:
363 return ast_vhub_hub_dev_status(ep, wIndex, wValue);
364 case InterfaceRequest | USB_REQ_GET_STATUS:
365 return ast_vhub_simple_reply(ep, 0, 0);
366 case EndpointRequest | USB_REQ_GET_STATUS:
367 return ast_vhub_hub_ep_status(ep, wIndex, wValue);
368
369 /* SET/CLEAR_FEATURE */
370 case DeviceOutRequest | USB_REQ_SET_FEATURE:
371 return ast_vhub_hub_dev_feature(ep, wIndex, wValue, true);
372 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
373 return ast_vhub_hub_dev_feature(ep, wIndex, wValue, false);
374 case EndpointOutRequest | USB_REQ_SET_FEATURE:
375 return ast_vhub_hub_ep_feature(ep, wIndex, wValue, true);
376 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
377 return ast_vhub_hub_ep_feature(ep, wIndex, wValue, false);
378
379 /* GET/SET_CONFIGURATION */
380 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
381 return ast_vhub_simple_reply(ep, 1);
382 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
383 if (wValue != 1)
384 return std_req_stall;
385 return std_req_complete;
386
387 /* GET_DESCRIPTOR */
388 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
389 switch (wValue >> 8) {
390 case USB_DT_DEVICE:
391 case USB_DT_CONFIG:
392 return ast_vhub_rep_desc(ep, wValue >> 8,
393 wLength);
394 case USB_DT_STRING:
395 return ast_vhub_rep_string(ep, wValue & 0xff,
396 wIndex, wLength);
397 }
398 return std_req_stall;
399
400 /* GET/SET_INTERFACE */
401 case DeviceRequest | USB_REQ_GET_INTERFACE:
402 return ast_vhub_simple_reply(ep, 0);
403 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
404 if (wValue != 0 || wIndex != 0)
405 return std_req_stall;
406 return std_req_complete;
407 }
408 return std_req_stall;
409 }
410
411 static void ast_vhub_update_hub_ep1(struct ast_vhub *vhub,
412 unsigned int port)
413 {
414 /* Update HW EP1 response */
415 u32 reg = readl(vhub->regs + AST_VHUB_EP1_STS_CHG);
416 u32 pmask = (1 << (port + 1));
417 if (vhub->ports[port].change)
418 reg |= pmask;
419 else
420 reg &= ~pmask;
421 writel(reg, vhub->regs + AST_VHUB_EP1_STS_CHG);
422 }
423
424 static void ast_vhub_change_port_stat(struct ast_vhub *vhub,
425 unsigned int port,
426 u16 clr_flags,
427 u16 set_flags,
428 bool set_c)
429 {
430 struct ast_vhub_port *p = &vhub->ports[port];
431 u16 prev;
432
433 /* Update port status */
434 prev = p->status;
435 p->status = (prev & ~clr_flags) | set_flags;
436 DDBG(&p->dev, "port %d status %04x -> %04x (C=%d)\n",
437 port + 1, prev, p->status, set_c);
438
439 /* Update change bits if needed */
440 if (set_c) {
441 u16 chg = p->status ^ prev;
442
443 /* Only these are relevant for change */
444 chg &= USB_PORT_STAT_C_CONNECTION |
445 USB_PORT_STAT_C_ENABLE |
446 USB_PORT_STAT_C_SUSPEND |
447 USB_PORT_STAT_C_OVERCURRENT |
448 USB_PORT_STAT_C_RESET |
449 USB_PORT_STAT_C_L1;
450
451 /*
452 * We only set USB_PORT_STAT_C_ENABLE if we are disabling
453 * the port as per USB spec, otherwise MacOS gets upset
454 */
455 if (p->status & USB_PORT_STAT_ENABLE)
456 chg &= ~USB_PORT_STAT_C_ENABLE;
457
458 p->change = chg;
459 ast_vhub_update_hub_ep1(vhub, port);
460 }
461 }
462
463 static void ast_vhub_send_host_wakeup(struct ast_vhub *vhub)
464 {
465 u32 reg = readl(vhub->regs + AST_VHUB_CTRL);
466 UDCDBG(vhub, "Waking up host !\n");
467 reg |= VHUB_CTRL_MANUAL_REMOTE_WAKEUP;
468 writel(reg, vhub->regs + AST_VHUB_CTRL);
469 }
470
471 void ast_vhub_device_connect(struct ast_vhub *vhub,
472 unsigned int port, bool on)
473 {
474 if (on)
475 ast_vhub_change_port_stat(vhub, port, 0,
476 USB_PORT_STAT_CONNECTION, true);
477 else
478 ast_vhub_change_port_stat(vhub, port,
479 USB_PORT_STAT_CONNECTION |
480 USB_PORT_STAT_ENABLE,
481 0, true);
482
483 /*
484 * If the hub is set to wakup the host on connection events
485 * then send a wakeup.
486 */
487 if (vhub->wakeup_en)
488 ast_vhub_send_host_wakeup(vhub);
489 }
490
491 static void ast_vhub_wake_work(struct work_struct *work)
492 {
493 struct ast_vhub *vhub = container_of(work,
494 struct ast_vhub,
495 wake_work);
496 unsigned long flags;
497 unsigned int i;
498
499 /*
500 * Wake all sleeping ports. If a port is suspended by
501 * the host suspend (without explicit state suspend),
502 * we let the normal host wake path deal with it later.
503 */
504 spin_lock_irqsave(&vhub->lock, flags);
505 for (i = 0; i < vhub->max_ports; i++) {
506 struct ast_vhub_port *p = &vhub->ports[i];
507
508 if (!(p->status & USB_PORT_STAT_SUSPEND))
509 continue;
510 ast_vhub_change_port_stat(vhub, i,
511 USB_PORT_STAT_SUSPEND,
512 0, true);
513 ast_vhub_dev_resume(&p->dev);
514 }
515 ast_vhub_send_host_wakeup(vhub);
516 spin_unlock_irqrestore(&vhub->lock, flags);
517 }
518
519 void ast_vhub_hub_wake_all(struct ast_vhub *vhub)
520 {
521 /*
522 * A device is trying to wake the world, because this
523 * can recurse into the device, we break the call chain
524 * using a work queue
525 */
526 schedule_work(&vhub->wake_work);
527 }
528
529 static void ast_vhub_port_reset(struct ast_vhub *vhub, u8 port)
530 {
531 struct ast_vhub_port *p = &vhub->ports[port];
532 u16 set, clr, speed;
533
534 /* First mark disabled */
535 ast_vhub_change_port_stat(vhub, port,
536 USB_PORT_STAT_ENABLE |
537 USB_PORT_STAT_SUSPEND,
538 USB_PORT_STAT_RESET,
539 false);
540
541 if (!p->dev.driver)
542 return;
543
544 /*
545 * This will either "start" the port or reset the
546 * device if already started...
547 */
548 ast_vhub_dev_reset(&p->dev);
549
550 /* Grab the right speed */
551 speed = p->dev.driver->max_speed;
552 if (speed == USB_SPEED_UNKNOWN || speed > vhub->speed)
553 speed = vhub->speed;
554
555 switch (speed) {
556 case USB_SPEED_LOW:
557 set = USB_PORT_STAT_LOW_SPEED;
558 clr = USB_PORT_STAT_HIGH_SPEED;
559 break;
560 case USB_SPEED_FULL:
561 set = 0;
562 clr = USB_PORT_STAT_LOW_SPEED |
563 USB_PORT_STAT_HIGH_SPEED;
564 break;
565 case USB_SPEED_HIGH:
566 set = USB_PORT_STAT_HIGH_SPEED;
567 clr = USB_PORT_STAT_LOW_SPEED;
568 break;
569 default:
570 UDCDBG(vhub, "Unsupported speed %d when"
571 " connecting device\n",
572 speed);
573 return;
574 }
575 clr |= USB_PORT_STAT_RESET;
576 set |= USB_PORT_STAT_ENABLE;
577
578 /* This should ideally be delayed ... */
579 ast_vhub_change_port_stat(vhub, port, clr, set, true);
580 }
581
582 static enum std_req_rc ast_vhub_set_port_feature(struct ast_vhub_ep *ep,
583 u8 port, u16 feat)
584 {
585 struct ast_vhub *vhub = ep->vhub;
586 struct ast_vhub_port *p;
587
588 if (port == 0 || port > vhub->max_ports)
589 return std_req_stall;
590 port--;
591 p = &vhub->ports[port];
592
593 switch(feat) {
594 case USB_PORT_FEAT_SUSPEND:
595 if (!(p->status & USB_PORT_STAT_ENABLE))
596 return std_req_complete;
597 ast_vhub_change_port_stat(vhub, port,
598 0, USB_PORT_STAT_SUSPEND,
599 false);
600 ast_vhub_dev_suspend(&p->dev);
601 return std_req_complete;
602 case USB_PORT_FEAT_RESET:
603 EPDBG(ep, "Port reset !\n");
604 ast_vhub_port_reset(vhub, port);
605 return std_req_complete;
606 case USB_PORT_FEAT_POWER:
607 /*
608 * On Power-on, we mark the connected flag changed,
609 * if there's a connected device, some hosts will
610 * otherwise fail to detect it.
611 */
612 if (p->status & USB_PORT_STAT_CONNECTION) {
613 p->change |= USB_PORT_STAT_C_CONNECTION;
614 ast_vhub_update_hub_ep1(vhub, port);
615 }
616 return std_req_complete;
617 case USB_PORT_FEAT_TEST:
618 case USB_PORT_FEAT_INDICATOR:
619 /* We don't do anything with these */
620 return std_req_complete;
621 }
622 return std_req_stall;
623 }
624
625 static enum std_req_rc ast_vhub_clr_port_feature(struct ast_vhub_ep *ep,
626 u8 port, u16 feat)
627 {
628 struct ast_vhub *vhub = ep->vhub;
629 struct ast_vhub_port *p;
630
631 if (port == 0 || port > vhub->max_ports)
632 return std_req_stall;
633 port--;
634 p = &vhub->ports[port];
635
636 switch(feat) {
637 case USB_PORT_FEAT_ENABLE:
638 ast_vhub_change_port_stat(vhub, port,
639 USB_PORT_STAT_ENABLE |
640 USB_PORT_STAT_SUSPEND, 0,
641 false);
642 ast_vhub_dev_suspend(&p->dev);
643 return std_req_complete;
644 case USB_PORT_FEAT_SUSPEND:
645 if (!(p->status & USB_PORT_STAT_SUSPEND))
646 return std_req_complete;
647 ast_vhub_change_port_stat(vhub, port,
648 USB_PORT_STAT_SUSPEND, 0,
649 false);
650 ast_vhub_dev_resume(&p->dev);
651 return std_req_complete;
652 case USB_PORT_FEAT_POWER:
653 /* We don't do power control */
654 return std_req_complete;
655 case USB_PORT_FEAT_INDICATOR:
656 /* We don't have indicators */
657 return std_req_complete;
658 case USB_PORT_FEAT_C_CONNECTION:
659 case USB_PORT_FEAT_C_ENABLE:
660 case USB_PORT_FEAT_C_SUSPEND:
661 case USB_PORT_FEAT_C_OVER_CURRENT:
662 case USB_PORT_FEAT_C_RESET:
663 /* Clear state-change feature */
664 p->change &= ~(1u << (feat - 16));
665 ast_vhub_update_hub_ep1(vhub, port);
666 return std_req_complete;
667 }
668 return std_req_stall;
669 }
670
671 static enum std_req_rc ast_vhub_get_port_stat(struct ast_vhub_ep *ep,
672 u8 port)
673 {
674 struct ast_vhub *vhub = ep->vhub;
675 u16 stat, chg;
676
677 if (port == 0 || port > vhub->max_ports)
678 return std_req_stall;
679 port--;
680
681 stat = vhub->ports[port].status;
682 chg = vhub->ports[port].change;
683
684 /* We always have power */
685 stat |= USB_PORT_STAT_POWER;
686
687 EPDBG(ep, " port status=%04x change=%04x\n", stat, chg);
688
689 return ast_vhub_simple_reply(ep,
690 stat & 0xff,
691 stat >> 8,
692 chg & 0xff,
693 chg >> 8);
694 }
695
696 enum std_req_rc ast_vhub_class_hub_request(struct ast_vhub_ep *ep,
697 struct usb_ctrlrequest *crq)
698 {
699 u16 wValue, wIndex, wLength;
700
701 wValue = le16_to_cpu(crq->wValue);
702 wIndex = le16_to_cpu(crq->wIndex);
703 wLength = le16_to_cpu(crq->wLength);
704
705 switch ((crq->bRequestType << 8) | crq->bRequest) {
706 case GetHubStatus:
707 EPDBG(ep, "GetHubStatus\n");
708 return ast_vhub_simple_reply(ep, 0, 0, 0, 0);
709 case GetPortStatus:
710 EPDBG(ep, "GetPortStatus(%d)\n", wIndex & 0xff);
711 return ast_vhub_get_port_stat(ep, wIndex & 0xf);
712 case GetHubDescriptor:
713 if (wValue != (USB_DT_HUB << 8))
714 return std_req_stall;
715 EPDBG(ep, "GetHubDescriptor(%d)\n", wIndex & 0xff);
716 return ast_vhub_rep_desc(ep, USB_DT_HUB, wLength);
717 case SetHubFeature:
718 case ClearHubFeature:
719 EPDBG(ep, "Get/SetHubFeature(%d)\n", wValue);
720 /* No feature, just complete the requests */
721 if (wValue == C_HUB_LOCAL_POWER ||
722 wValue == C_HUB_OVER_CURRENT)
723 return std_req_complete;
724 return std_req_stall;
725 case SetPortFeature:
726 EPDBG(ep, "SetPortFeature(%d,%d)\n", wIndex & 0xf, wValue);
727 return ast_vhub_set_port_feature(ep, wIndex & 0xf, wValue);
728 case ClearPortFeature:
729 EPDBG(ep, "ClearPortFeature(%d,%d)\n", wIndex & 0xf, wValue);
730 return ast_vhub_clr_port_feature(ep, wIndex & 0xf, wValue);
731 case ClearTTBuffer:
732 case ResetTT:
733 case StopTT:
734 return std_req_complete;
735 case GetTTState:
736 return ast_vhub_simple_reply(ep, 0, 0, 0, 0);
737 default:
738 EPDBG(ep, "Unknown class request\n");
739 }
740 return std_req_stall;
741 }
742
743 void ast_vhub_hub_suspend(struct ast_vhub *vhub)
744 {
745 unsigned int i;
746
747 UDCDBG(vhub, "USB bus suspend\n");
748
749 if (vhub->suspended)
750 return;
751
752 vhub->suspended = true;
753
754 /*
755 * Forward to unsuspended ports without changing
756 * their connection status.
757 */
758 for (i = 0; i < vhub->max_ports; i++) {
759 struct ast_vhub_port *p = &vhub->ports[i];
760
761 if (!(p->status & USB_PORT_STAT_SUSPEND))
762 ast_vhub_dev_suspend(&p->dev);
763 }
764 }
765
766 void ast_vhub_hub_resume(struct ast_vhub *vhub)
767 {
768 unsigned int i;
769
770 UDCDBG(vhub, "USB bus resume\n");
771
772 if (!vhub->suspended)
773 return;
774
775 vhub->suspended = false;
776
777 /*
778 * Forward to unsuspended ports without changing
779 * their connection status.
780 */
781 for (i = 0; i < vhub->max_ports; i++) {
782 struct ast_vhub_port *p = &vhub->ports[i];
783
784 if (!(p->status & USB_PORT_STAT_SUSPEND))
785 ast_vhub_dev_resume(&p->dev);
786 }
787 }
788
789 void ast_vhub_hub_reset(struct ast_vhub *vhub)
790 {
791 unsigned int i;
792
793 UDCDBG(vhub, "USB bus reset\n");
794
795 /*
796 * Is the speed known ? If not we don't care, we aren't
797 * initialized yet and ports haven't been enabled.
798 */
799 if (vhub->speed == USB_SPEED_UNKNOWN)
800 return;
801
802 /* We aren't suspended anymore obviously */
803 vhub->suspended = false;
804
805 /* No speed set */
806 vhub->speed = USB_SPEED_UNKNOWN;
807
808 /* Wakeup not enabled anymore */
809 vhub->wakeup_en = false;
810
811 /*
812 * Clear all port status, disable gadgets and "suspend"
813 * them. They will be woken up by a port reset.
814 */
815 for (i = 0; i < vhub->max_ports; i++) {
816 struct ast_vhub_port *p = &vhub->ports[i];
817
818 /* Only keep the connected flag */
819 p->status &= USB_PORT_STAT_CONNECTION;
820 p->change = 0;
821
822 /* Suspend the gadget if any */
823 ast_vhub_dev_suspend(&p->dev);
824 }
825
826 /* Cleanup HW */
827 writel(0, vhub->regs + AST_VHUB_CONF);
828 writel(0, vhub->regs + AST_VHUB_EP0_CTRL);
829 writel(VHUB_EP1_CTRL_RESET_TOGGLE |
830 VHUB_EP1_CTRL_ENABLE,
831 vhub->regs + AST_VHUB_EP1_CTRL);
832 writel(0, vhub->regs + AST_VHUB_EP1_STS_CHG);
833 }
834
835 static void ast_vhub_init_desc(struct ast_vhub *vhub)
836 {
837 /* Initialize vhub Device Descriptor. */
838 memcpy(&vhub->vhub_dev_desc, &ast_vhub_dev_desc,
839 sizeof(vhub->vhub_dev_desc));
840
841 /* Initialize vhub Configuration Descriptor. */
842 memcpy(&vhub->vhub_conf_desc, &ast_vhub_conf_desc,
843 sizeof(vhub->vhub_conf_desc));
844
845 /* Initialize vhub Hub Descriptor. */
846 memcpy(&vhub->vhub_hub_desc, &ast_vhub_hub_desc,
847 sizeof(vhub->vhub_hub_desc));
848 vhub->vhub_hub_desc.bNbrPorts = vhub->max_ports;
849
850 /* Initialize vhub String Descriptors. */
851 memcpy(&vhub->vhub_str_desc, &ast_vhub_strings,
852 sizeof(vhub->vhub_str_desc));
853 }
854
855 void ast_vhub_init_hub(struct ast_vhub *vhub)
856 {
857 vhub->speed = USB_SPEED_UNKNOWN;
858 INIT_WORK(&vhub->wake_work, ast_vhub_wake_work);
859
860 ast_vhub_init_desc(vhub);
861 }
862
Linux with added FPC-III support