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 
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/delay.h>
14 #include <linux/ioport.h>
15 #include <linux/slab.h>
16 #include <linux/errno.h>
17 #include <linux/list.h>
18 #include <linux/interrupt.h>
19 #include <linux/proc_fs.h>
20 #include <linux/prefetch.h>
21 #include <linux/clk.h>
22 #include <linux/usb/gadget.h>
23 #include <linux/of.h>
24 #include <linux/regmap.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/bcd.h>
27 #include <linux/version.h>
28 #include <linux/usb.h>
29 #include <linux/usb/hcd.h>
30 
31 #include "vhub.h"
32 
33 /* usb 2.0 hub device descriptor
34  *
35  * A few things we may want to improve here:
36  *
37  *    - We may need to indicate TT support
38  *    - We may need a device qualifier descriptor
39  *	as devices can pretend to be usb1 or 2
40  *    - Make vid/did overridable
41  *    - make it look like usb1 if usb1 mode forced
42  */
43 #define KERNEL_REL	bin2bcd(LINUX_VERSION_MAJOR)
44 #define KERNEL_VER	bin2bcd(LINUX_VERSION_PATCHLEVEL)
45 
46 enum {
47 	AST_VHUB_STR_INDEX_MAX = 4,
48 	AST_VHUB_STR_MANUF = 3,
49 	AST_VHUB_STR_PRODUCT = 2,
50 	AST_VHUB_STR_SERIAL = 1,
51 };
52 
53 static const struct usb_device_descriptor ast_vhub_dev_desc = {
54 	.bLength		= USB_DT_DEVICE_SIZE,
55 	.bDescriptorType	= USB_DT_DEVICE,
56 	.bcdUSB			= cpu_to_le16(0x0200),
57 	.bDeviceClass		= USB_CLASS_HUB,
58 	.bDeviceSubClass	= 0,
59 	.bDeviceProtocol	= 1,
60 	.bMaxPacketSize0	= 64,
61 	.idVendor		= cpu_to_le16(0x1d6b),
62 	.idProduct		= cpu_to_le16(0x0107),
63 	.bcdDevice		= cpu_to_le16(0x0100),
64 	.iManufacturer		= AST_VHUB_STR_MANUF,
65 	.iProduct		= AST_VHUB_STR_PRODUCT,
66 	.iSerialNumber		= AST_VHUB_STR_SERIAL,
67 	.bNumConfigurations	= 1,
68 };
69 
70 static const struct usb_qualifier_descriptor ast_vhub_qual_desc = {
71 	.bLength = 0xA,
72 	.bDescriptorType = USB_DT_DEVICE_QUALIFIER,
73 	.bcdUSB = cpu_to_le16(0x0200),
74 	.bDeviceClass = USB_CLASS_HUB,
75 	.bDeviceSubClass = 0,
76 	.bDeviceProtocol = 0,
77 	.bMaxPacketSize0 = 64,
78 	.bNumConfigurations = 1,
79 	.bRESERVED = 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 	u32 val;
215 
216 	EPDBG(ep, "%s_FEATURE(dev val=%02x)\n",
217 	      is_set ? "SET" : "CLEAR", wValue);
218 
219 	if (wValue == USB_DEVICE_REMOTE_WAKEUP) {
220 		ep->vhub->wakeup_en = is_set;
221 		EPDBG(ep, "Hub remote wakeup %s\n",
222 		      is_set ? "enabled" : "disabled");
223 		return std_req_complete;
224 	}
225 
226 	if (wValue == USB_DEVICE_TEST_MODE) {
227 		val = readl(ep->vhub->regs + AST_VHUB_CTRL);
228 		val &= ~GENMASK(10, 8);
229 		val |= VHUB_CTRL_SET_TEST_MODE((wIndex >> 8) & 0x7);
230 		writel(val, ep->vhub->regs + AST_VHUB_CTRL);
231 
232 		return std_req_complete;
233 	}
234 
235 	return std_req_stall;
236 }
237 
238 static int ast_vhub_hub_ep_feature(struct ast_vhub_ep *ep,
239 				   u16 wIndex, u16 wValue,
240 				   bool is_set)
241 {
242 	int ep_num;
243 	u32 reg;
244 
245 	ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK;
246 	EPDBG(ep, "%s_FEATURE(ep%d val=%02x)\n",
247 	      is_set ? "SET" : "CLEAR", ep_num, wValue);
248 
249 	if (ep_num > 1)
250 		return std_req_stall;
251 	if (wValue != USB_ENDPOINT_HALT)
252 		return std_req_stall;
253 	if (ep_num == 0)
254 		return std_req_complete;
255 
256 	EPDBG(ep, "%s stall on EP 1\n",
257 	      is_set ? "setting" : "clearing");
258 
259 	ep->vhub->ep1_stalled = is_set;
260 	reg = readl(ep->vhub->regs + AST_VHUB_EP1_CTRL);
261 	if (is_set) {
262 		reg |= VHUB_EP1_CTRL_STALL;
263 	} else {
264 		reg &= ~VHUB_EP1_CTRL_STALL;
265 		reg |= VHUB_EP1_CTRL_RESET_TOGGLE;
266 	}
267 	writel(reg, ep->vhub->regs + AST_VHUB_EP1_CTRL);
268 
269 	return std_req_complete;
270 }
271 
272 static int ast_vhub_rep_desc(struct ast_vhub_ep *ep,
273 			     u8 desc_type, u16 len)
274 {
275 	size_t dsize;
276 	struct ast_vhub *vhub = ep->vhub;
277 
278 	EPDBG(ep, "GET_DESCRIPTOR(type:%d)\n", desc_type);
279 
280 	/*
281 	 * Copy first to EP buffer and send from there, so
282 	 * we can do some in-place patching if needed. We know
283 	 * the EP buffer is big enough but ensure that doesn't
284 	 * change. We do that now rather than later after we
285 	 * have checked sizes etc... to avoid a gcc bug where
286 	 * it thinks len is constant and barfs about read
287 	 * overflows in memcpy.
288 	 */
289 	switch(desc_type) {
290 	case USB_DT_DEVICE:
291 		dsize = USB_DT_DEVICE_SIZE;
292 		memcpy(ep->buf, &vhub->vhub_dev_desc, dsize);
293 		BUILD_BUG_ON(dsize > sizeof(vhub->vhub_dev_desc));
294 		BUILD_BUG_ON(USB_DT_DEVICE_SIZE >= AST_VHUB_EP0_MAX_PACKET);
295 		break;
296 	case USB_DT_OTHER_SPEED_CONFIG:
297 	case USB_DT_CONFIG:
298 		dsize = AST_VHUB_CONF_DESC_SIZE;
299 		memcpy(ep->buf, &vhub->vhub_conf_desc, dsize);
300 		((u8 *)ep->buf)[1] = desc_type;
301 		BUILD_BUG_ON(dsize > sizeof(vhub->vhub_conf_desc));
302 		BUILD_BUG_ON(AST_VHUB_CONF_DESC_SIZE >= AST_VHUB_EP0_MAX_PACKET);
303 		break;
304 	case USB_DT_HUB:
305 		dsize = AST_VHUB_HUB_DESC_SIZE;
306 		memcpy(ep->buf, &vhub->vhub_hub_desc, dsize);
307 		BUILD_BUG_ON(dsize > sizeof(vhub->vhub_hub_desc));
308 		BUILD_BUG_ON(AST_VHUB_HUB_DESC_SIZE >= AST_VHUB_EP0_MAX_PACKET);
309 		break;
310 	case USB_DT_DEVICE_QUALIFIER:
311 		dsize = sizeof(vhub->vhub_qual_desc);
312 		memcpy(ep->buf, &vhub->vhub_qual_desc, dsize);
313 		break;
314 	default:
315 		return std_req_stall;
316 	}
317 
318 	/* Crop requested length */
319 	if (len > dsize)
320 		len = dsize;
321 
322 	/* Shoot it from the EP buffer */
323 	return ast_vhub_reply(ep, NULL, len);
324 }
325 
326 static struct usb_gadget_strings*
327 ast_vhub_str_of_container(struct usb_gadget_string_container *container)
328 {
329 	return (struct usb_gadget_strings *)container->stash;
330 }
331 
332 static int ast_vhub_collect_languages(struct ast_vhub *vhub, void *buf,
333 				      size_t size)
334 {
335 	int rc, hdr_len, nlangs, max_langs;
336 	struct usb_gadget_strings *lang_str;
337 	struct usb_gadget_string_container *container;
338 	struct usb_string_descriptor *sdesc = buf;
339 
340 	nlangs = 0;
341 	hdr_len = sizeof(struct usb_descriptor_header);
342 	max_langs = (size - hdr_len) / sizeof(sdesc->wData[0]);
343 	list_for_each_entry(container, &vhub->vhub_str_desc, list) {
344 		if (nlangs >= max_langs)
345 			break;
346 
347 		lang_str = ast_vhub_str_of_container(container);
348 		sdesc->wData[nlangs++] = cpu_to_le16(lang_str->language);
349 	}
350 
351 	rc = hdr_len + nlangs * sizeof(sdesc->wData[0]);
352 	sdesc->bLength = rc;
353 	sdesc->bDescriptorType = USB_DT_STRING;
354 
355 	return rc;
356 }
357 
358 static struct usb_gadget_strings *ast_vhub_lookup_string(struct ast_vhub *vhub,
359 							 u16 lang_id)
360 {
361 	struct usb_gadget_strings *lang_str;
362 	struct usb_gadget_string_container *container;
363 
364 	list_for_each_entry(container, &vhub->vhub_str_desc, list) {
365 		lang_str = ast_vhub_str_of_container(container);
366 		if (lang_str->language == lang_id)
367 			return lang_str;
368 	}
369 
370 	return NULL;
371 }
372 
373 static int ast_vhub_rep_string(struct ast_vhub_ep *ep,
374 			       u8 string_id, u16 lang_id,
375 			       u16 len)
376 {
377 	int rc;
378 	u8 buf[256];
379 	struct ast_vhub *vhub = ep->vhub;
380 	struct usb_gadget_strings *lang_str;
381 
382 	if (string_id == 0) {
383 		rc = ast_vhub_collect_languages(vhub, buf, sizeof(buf));
384 	} else {
385 		lang_str = ast_vhub_lookup_string(vhub, lang_id);
386 		if (!lang_str)
387 			return std_req_stall;
388 
389 		rc = usb_gadget_get_string(lang_str, string_id, buf);
390 	}
391 
392 	if (rc < 0 || rc >= AST_VHUB_EP0_MAX_PACKET)
393 		return std_req_stall;
394 
395 	/* Shoot it from the EP buffer */
396 	memcpy(ep->buf, buf, rc);
397 	return ast_vhub_reply(ep, NULL, min_t(u16, rc, len));
398 }
399 
400 enum std_req_rc ast_vhub_std_hub_request(struct ast_vhub_ep *ep,
401 					 struct usb_ctrlrequest *crq)
402 {
403 	struct ast_vhub *vhub = ep->vhub;
404 	u16 wValue, wIndex, wLength;
405 
406 	wValue = le16_to_cpu(crq->wValue);
407 	wIndex = le16_to_cpu(crq->wIndex);
408 	wLength = le16_to_cpu(crq->wLength);
409 
410 	/* First packet, grab speed */
411 	if (vhub->speed == USB_SPEED_UNKNOWN) {
412 		u32 ustat = readl(vhub->regs + AST_VHUB_USBSTS);
413 		if (ustat & VHUB_USBSTS_HISPEED)
414 			vhub->speed = USB_SPEED_HIGH;
415 		else
416 			vhub->speed = USB_SPEED_FULL;
417 		UDCDBG(vhub, "USB status=%08x speed=%s\n", ustat,
418 		       vhub->speed == USB_SPEED_HIGH ? "high" : "full");
419 	}
420 
421 	switch ((crq->bRequestType << 8) | crq->bRequest) {
422 		/* SET_ADDRESS */
423 	case DeviceOutRequest | USB_REQ_SET_ADDRESS:
424 		EPDBG(ep, "SET_ADDRESS: Got address %x\n", wValue);
425 		writel(wValue, vhub->regs + AST_VHUB_CONF);
426 		return std_req_complete;
427 
428 		/* GET_STATUS */
429 	case DeviceRequest | USB_REQ_GET_STATUS:
430 		return ast_vhub_hub_dev_status(ep, wIndex, wValue);
431 	case InterfaceRequest | USB_REQ_GET_STATUS:
432 		return ast_vhub_simple_reply(ep, 0, 0);
433 	case EndpointRequest | USB_REQ_GET_STATUS:
434 		return ast_vhub_hub_ep_status(ep, wIndex, wValue);
435 
436 		/* SET/CLEAR_FEATURE */
437 	case DeviceOutRequest | USB_REQ_SET_FEATURE:
438 		return ast_vhub_hub_dev_feature(ep, wIndex, wValue, true);
439 	case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
440 		return ast_vhub_hub_dev_feature(ep, wIndex, wValue, false);
441 	case EndpointOutRequest | USB_REQ_SET_FEATURE:
442 		return ast_vhub_hub_ep_feature(ep, wIndex, wValue, true);
443 	case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
444 		return ast_vhub_hub_ep_feature(ep, wIndex, wValue, false);
445 
446 		/* GET/SET_CONFIGURATION */
447 	case DeviceRequest | USB_REQ_GET_CONFIGURATION:
448 		return ast_vhub_simple_reply(ep, 1);
449 	case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
450 		if (wValue != 1)
451 			return std_req_stall;
452 		return std_req_complete;
453 
454 		/* GET_DESCRIPTOR */
455 	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
456 		switch (wValue >> 8) {
457 		case USB_DT_DEVICE:
458 		case USB_DT_CONFIG:
459 		case USB_DT_DEVICE_QUALIFIER:
460 		case USB_DT_OTHER_SPEED_CONFIG:
461 			return ast_vhub_rep_desc(ep, wValue >> 8,
462 						 wLength);
463 		case USB_DT_STRING:
464 			return ast_vhub_rep_string(ep, wValue & 0xff,
465 						   wIndex, wLength);
466 		}
467 		return std_req_stall;
468 
469 		/* GET/SET_INTERFACE */
470 	case DeviceRequest | USB_REQ_GET_INTERFACE:
471 		return ast_vhub_simple_reply(ep, 0);
472 	case DeviceOutRequest | USB_REQ_SET_INTERFACE:
473 		if (wValue != 0 || wIndex != 0)
474 			return std_req_stall;
475 		return std_req_complete;
476 	}
477 	return std_req_stall;
478 }
479 
480 static void ast_vhub_update_hub_ep1(struct ast_vhub *vhub,
481 				    unsigned int port)
482 {
483 	/* Update HW EP1 response */
484 	u32 reg = readl(vhub->regs + AST_VHUB_EP1_STS_CHG);
485 	u32 pmask = (1 << (port + 1));
486 	if (vhub->ports[port].change)
487 		reg |= pmask;
488 	else
489 		reg &= ~pmask;
490 	writel(reg, vhub->regs + AST_VHUB_EP1_STS_CHG);
491 }
492 
493 static void ast_vhub_change_port_stat(struct ast_vhub *vhub,
494 				      unsigned int port,
495 				      u16 clr_flags,
496 				      u16 set_flags,
497 				      bool set_c)
498 {
499 	struct ast_vhub_port *p = &vhub->ports[port];
500 	u16 prev;
501 
502 	/* Update port status */
503 	prev = p->status;
504 	p->status = (prev & ~clr_flags) | set_flags;
505 	DDBG(&p->dev, "port %d status %04x -> %04x (C=%d)\n",
506 	     port + 1, prev, p->status, set_c);
507 
508 	/* Update change bits if needed */
509 	if (set_c) {
510 		u16 chg = p->status ^ prev;
511 
512 		/* Only these are relevant for change */
513 		chg &= USB_PORT_STAT_C_CONNECTION |
514 		       USB_PORT_STAT_C_ENABLE |
515 		       USB_PORT_STAT_C_SUSPEND |
516 		       USB_PORT_STAT_C_OVERCURRENT |
517 		       USB_PORT_STAT_C_RESET |
518 		       USB_PORT_STAT_C_L1;
519 
520 		/*
521 		 * We only set USB_PORT_STAT_C_ENABLE if we are disabling
522 		 * the port as per USB spec, otherwise MacOS gets upset
523 		 */
524 		if (p->status & USB_PORT_STAT_ENABLE)
525 			chg &= ~USB_PORT_STAT_C_ENABLE;
526 
527 		p->change = chg;
528 		ast_vhub_update_hub_ep1(vhub, port);
529 	}
530 }
531 
532 static void ast_vhub_send_host_wakeup(struct ast_vhub *vhub)
533 {
534 	u32 reg = readl(vhub->regs + AST_VHUB_CTRL);
535 	UDCDBG(vhub, "Waking up host !\n");
536 	reg |= VHUB_CTRL_MANUAL_REMOTE_WAKEUP;
537 	writel(reg, vhub->regs + AST_VHUB_CTRL);
538 }
539 
540 void ast_vhub_device_connect(struct ast_vhub *vhub,
541 			     unsigned int port, bool on)
542 {
543 	if (on)
544 		ast_vhub_change_port_stat(vhub, port, 0,
545 					  USB_PORT_STAT_CONNECTION, true);
546 	else
547 		ast_vhub_change_port_stat(vhub, port,
548 					  USB_PORT_STAT_CONNECTION |
549 					  USB_PORT_STAT_ENABLE,
550 					  0, true);
551 
552 	/*
553 	 * If the hub is set to wakup the host on connection events
554 	 * then send a wakeup.
555 	 */
556 	if (vhub->wakeup_en)
557 		ast_vhub_send_host_wakeup(vhub);
558 }
559 
560 static void ast_vhub_wake_work(struct work_struct *work)
561 {
562 	struct ast_vhub *vhub = container_of(work,
563 					     struct ast_vhub,
564 					     wake_work);
565 	unsigned long flags;
566 	unsigned int i;
567 
568 	/*
569 	 * Wake all sleeping ports. If a port is suspended by
570 	 * the host suspend (without explicit state suspend),
571 	 * we let the normal host wake path deal with it later.
572 	 */
573 	spin_lock_irqsave(&vhub->lock, flags);
574 	for (i = 0; i < vhub->max_ports; i++) {
575 		struct ast_vhub_port *p = &vhub->ports[i];
576 
577 		if (!(p->status & USB_PORT_STAT_SUSPEND))
578 			continue;
579 		ast_vhub_change_port_stat(vhub, i,
580 					  USB_PORT_STAT_SUSPEND,
581 					  0, true);
582 		ast_vhub_dev_resume(&p->dev);
583 	}
584 	ast_vhub_send_host_wakeup(vhub);
585 	spin_unlock_irqrestore(&vhub->lock, flags);
586 }
587 
588 void ast_vhub_hub_wake_all(struct ast_vhub *vhub)
589 {
590 	/*
591 	 * A device is trying to wake the world, because this
592 	 * can recurse into the device, we break the call chain
593 	 * using a work queue
594 	 */
595 	schedule_work(&vhub->wake_work);
596 }
597 
598 static void ast_vhub_port_reset(struct ast_vhub *vhub, u8 port)
599 {
600 	struct ast_vhub_port *p = &vhub->ports[port];
601 	u16 set, clr, speed;
602 
603 	/* First mark disabled */
604 	ast_vhub_change_port_stat(vhub, port,
605 				  USB_PORT_STAT_ENABLE |
606 				  USB_PORT_STAT_SUSPEND,
607 				  USB_PORT_STAT_RESET,
608 				  false);
609 
610 	if (!p->dev.driver)
611 		return;
612 
613 	/*
614 	 * This will either "start" the port or reset the
615 	 * device if already started...
616 	 */
617 	ast_vhub_dev_reset(&p->dev);
618 
619 	/* Grab the right speed */
620 	speed = p->dev.driver->max_speed;
621 	if (speed == USB_SPEED_UNKNOWN || speed > vhub->speed)
622 		speed = vhub->speed;
623 
624 	switch (speed) {
625 	case USB_SPEED_LOW:
626 		set = USB_PORT_STAT_LOW_SPEED;
627 		clr = USB_PORT_STAT_HIGH_SPEED;
628 		break;
629 	case USB_SPEED_FULL:
630 		set = 0;
631 		clr = USB_PORT_STAT_LOW_SPEED |
632 			USB_PORT_STAT_HIGH_SPEED;
633 		break;
634 	case USB_SPEED_HIGH:
635 		set = USB_PORT_STAT_HIGH_SPEED;
636 		clr = USB_PORT_STAT_LOW_SPEED;
637 		break;
638 	default:
639 		UDCDBG(vhub, "Unsupported speed %d when"
640 		       " connecting device\n",
641 		       speed);
642 		return;
643 	}
644 	clr |= USB_PORT_STAT_RESET;
645 	set |= USB_PORT_STAT_ENABLE;
646 
647 	/* This should ideally be delayed ... */
648 	ast_vhub_change_port_stat(vhub, port, clr, set, true);
649 }
650 
651 static enum std_req_rc ast_vhub_set_port_feature(struct ast_vhub_ep *ep,
652 						 u8 port, u16 feat)
653 {
654 	struct ast_vhub *vhub = ep->vhub;
655 	struct ast_vhub_port *p;
656 
657 	if (port == 0 || port > vhub->max_ports)
658 		return std_req_stall;
659 	port--;
660 	p = &vhub->ports[port];
661 
662 	switch(feat) {
663 	case USB_PORT_FEAT_SUSPEND:
664 		if (!(p->status & USB_PORT_STAT_ENABLE))
665 			return std_req_complete;
666 		ast_vhub_change_port_stat(vhub, port,
667 					  0, USB_PORT_STAT_SUSPEND,
668 					  false);
669 		ast_vhub_dev_suspend(&p->dev);
670 		return std_req_complete;
671 	case USB_PORT_FEAT_RESET:
672 		EPDBG(ep, "Port reset !\n");
673 		ast_vhub_port_reset(vhub, port);
674 		return std_req_complete;
675 	case USB_PORT_FEAT_POWER:
676 		/*
677 		 * On Power-on, we mark the connected flag changed,
678 		 * if there's a connected device, some hosts will
679 		 * otherwise fail to detect it.
680 		 */
681 		if (p->status & USB_PORT_STAT_CONNECTION) {
682 			p->change |= USB_PORT_STAT_C_CONNECTION;
683 			ast_vhub_update_hub_ep1(vhub, port);
684 		}
685 		return std_req_complete;
686 	case USB_PORT_FEAT_TEST:
687 	case USB_PORT_FEAT_INDICATOR:
688 		/* We don't do anything with these */
689 		return std_req_complete;
690 	}
691 	return std_req_stall;
692 }
693 
694 static enum std_req_rc ast_vhub_clr_port_feature(struct ast_vhub_ep *ep,
695 						 u8 port, u16 feat)
696 {
697 	struct ast_vhub *vhub = ep->vhub;
698 	struct ast_vhub_port *p;
699 
700 	if (port == 0 || port > vhub->max_ports)
701 		return std_req_stall;
702 	port--;
703 	p = &vhub->ports[port];
704 
705 	switch(feat) {
706 	case USB_PORT_FEAT_ENABLE:
707 		ast_vhub_change_port_stat(vhub, port,
708 					  USB_PORT_STAT_ENABLE |
709 					  USB_PORT_STAT_SUSPEND, 0,
710 					  false);
711 		ast_vhub_dev_suspend(&p->dev);
712 		return std_req_complete;
713 	case USB_PORT_FEAT_SUSPEND:
714 		if (!(p->status & USB_PORT_STAT_SUSPEND))
715 			return std_req_complete;
716 		ast_vhub_change_port_stat(vhub, port,
717 					  USB_PORT_STAT_SUSPEND, 0,
718 					  false);
719 		ast_vhub_dev_resume(&p->dev);
720 		return std_req_complete;
721 	case USB_PORT_FEAT_POWER:
722 		/* We don't do power control */
723 		return std_req_complete;
724 	case USB_PORT_FEAT_INDICATOR:
725 		/* We don't have indicators */
726 		return std_req_complete;
727 	case USB_PORT_FEAT_C_CONNECTION:
728 	case USB_PORT_FEAT_C_ENABLE:
729 	case USB_PORT_FEAT_C_SUSPEND:
730 	case USB_PORT_FEAT_C_OVER_CURRENT:
731 	case USB_PORT_FEAT_C_RESET:
732 		/* Clear state-change feature */
733 		p->change &= ~(1u << (feat - 16));
734 		ast_vhub_update_hub_ep1(vhub, port);
735 		return std_req_complete;
736 	}
737 	return std_req_stall;
738 }
739 
740 static enum std_req_rc ast_vhub_get_port_stat(struct ast_vhub_ep *ep,
741 					      u8 port)
742 {
743 	struct ast_vhub *vhub = ep->vhub;
744 	u16 stat, chg;
745 
746 	if (port == 0 || port > vhub->max_ports)
747 		return std_req_stall;
748 	port--;
749 
750 	stat = vhub->ports[port].status;
751 	chg = vhub->ports[port].change;
752 
753 	/* We always have power */
754 	stat |= USB_PORT_STAT_POWER;
755 
756 	EPDBG(ep, " port status=%04x change=%04x\n", stat, chg);
757 
758 	return ast_vhub_simple_reply(ep,
759 				     stat & 0xff,
760 				     stat >> 8,
761 				     chg & 0xff,
762 				     chg >> 8);
763 }
764 
765 enum std_req_rc ast_vhub_class_hub_request(struct ast_vhub_ep *ep,
766 					   struct usb_ctrlrequest *crq)
767 {
768 	u16 wValue, wIndex, wLength;
769 
770 	wValue = le16_to_cpu(crq->wValue);
771 	wIndex = le16_to_cpu(crq->wIndex);
772 	wLength = le16_to_cpu(crq->wLength);
773 
774 	switch ((crq->bRequestType << 8) | crq->bRequest) {
775 	case GetHubStatus:
776 		EPDBG(ep, "GetHubStatus\n");
777 		return ast_vhub_simple_reply(ep, 0, 0, 0, 0);
778 	case GetPortStatus:
779 		EPDBG(ep, "GetPortStatus(%d)\n", wIndex & 0xff);
780 		return ast_vhub_get_port_stat(ep, wIndex & 0xf);
781 	case GetHubDescriptor:
782 		if (wValue != (USB_DT_HUB << 8))
783 			return std_req_stall;
784 		EPDBG(ep, "GetHubDescriptor(%d)\n", wIndex & 0xff);
785 		return ast_vhub_rep_desc(ep, USB_DT_HUB, wLength);
786 	case SetHubFeature:
787 	case ClearHubFeature:
788 		EPDBG(ep, "Get/SetHubFeature(%d)\n", wValue);
789 		/* No feature, just complete the requests */
790 		if (wValue == C_HUB_LOCAL_POWER ||
791 		    wValue == C_HUB_OVER_CURRENT)
792 			return std_req_complete;
793 		return std_req_stall;
794 	case SetPortFeature:
795 		EPDBG(ep, "SetPortFeature(%d,%d)\n", wIndex & 0xf, wValue);
796 		return ast_vhub_set_port_feature(ep, wIndex & 0xf, wValue);
797 	case ClearPortFeature:
798 		EPDBG(ep, "ClearPortFeature(%d,%d)\n", wIndex & 0xf, wValue);
799 		return ast_vhub_clr_port_feature(ep, wIndex & 0xf, wValue);
800 	case ClearTTBuffer:
801 	case ResetTT:
802 	case StopTT:
803 		return std_req_complete;
804 	case GetTTState:
805 		return ast_vhub_simple_reply(ep, 0, 0, 0, 0);
806 	default:
807 		EPDBG(ep, "Unknown class request\n");
808 	}
809 	return std_req_stall;
810 }
811 
812 void ast_vhub_hub_suspend(struct ast_vhub *vhub)
813 {
814 	unsigned int i;
815 
816 	UDCDBG(vhub, "USB bus suspend\n");
817 
818 	if (vhub->suspended)
819 		return;
820 
821 	vhub->suspended = true;
822 
823 	/*
824 	 * Forward to unsuspended ports without changing
825 	 * their connection status.
826 	 */
827 	for (i = 0; i < vhub->max_ports; i++) {
828 		struct ast_vhub_port *p = &vhub->ports[i];
829 
830 		if (!(p->status & USB_PORT_STAT_SUSPEND))
831 			ast_vhub_dev_suspend(&p->dev);
832 	}
833 }
834 
835 void ast_vhub_hub_resume(struct ast_vhub *vhub)
836 {
837 	unsigned int i;
838 
839 	UDCDBG(vhub, "USB bus resume\n");
840 
841 	if (!vhub->suspended)
842 		return;
843 
844 	vhub->suspended = false;
845 
846 	/*
847 	 * Forward to unsuspended ports without changing
848 	 * their connection status.
849 	 */
850 	for (i = 0; i < vhub->max_ports; i++) {
851 		struct ast_vhub_port *p = &vhub->ports[i];
852 
853 		if (!(p->status & USB_PORT_STAT_SUSPEND))
854 			ast_vhub_dev_resume(&p->dev);
855 	}
856 }
857 
858 void ast_vhub_hub_reset(struct ast_vhub *vhub)
859 {
860 	unsigned int i;
861 
862 	UDCDBG(vhub, "USB bus reset\n");
863 
864 	/*
865 	 * Is the speed known ? If not we don't care, we aren't
866 	 * initialized yet and ports haven't been enabled.
867 	 */
868 	if (vhub->speed == USB_SPEED_UNKNOWN)
869 		return;
870 
871 	/* We aren't suspended anymore obviously */
872 	vhub->suspended = false;
873 
874 	/* No speed set */
875 	vhub->speed = USB_SPEED_UNKNOWN;
876 
877 	/* Wakeup not enabled anymore */
878 	vhub->wakeup_en = false;
879 
880 	/*
881 	 * Clear all port status, disable gadgets and "suspend"
882 	 * them. They will be woken up by a port reset.
883 	 */
884 	for (i = 0; i < vhub->max_ports; i++) {
885 		struct ast_vhub_port *p = &vhub->ports[i];
886 
887 		/* Only keep the connected flag */
888 		p->status &= USB_PORT_STAT_CONNECTION;
889 		p->change = 0;
890 
891 		/* Suspend the gadget if any */
892 		ast_vhub_dev_suspend(&p->dev);
893 	}
894 
895 	/* Cleanup HW */
896 	writel(0, vhub->regs + AST_VHUB_CONF);
897 	writel(0, vhub->regs + AST_VHUB_EP0_CTRL);
898 	writel(VHUB_EP1_CTRL_RESET_TOGGLE |
899 	       VHUB_EP1_CTRL_ENABLE,
900 	       vhub->regs + AST_VHUB_EP1_CTRL);
901 	writel(0, vhub->regs + AST_VHUB_EP1_STS_CHG);
902 }
903 
904 static void ast_vhub_of_parse_dev_desc(struct ast_vhub *vhub,
905 				       const struct device_node *vhub_np)
906 {
907 	u16 id;
908 	u32 data;
909 
910 	if (!of_property_read_u32(vhub_np, "vhub-vendor-id", &data)) {
911 		id = (u16)data;
912 		vhub->vhub_dev_desc.idVendor = cpu_to_le16(id);
913 	}
914 	if (!of_property_read_u32(vhub_np, "vhub-product-id", &data)) {
915 		id = (u16)data;
916 		vhub->vhub_dev_desc.idProduct = cpu_to_le16(id);
917 	}
918 	if (!of_property_read_u32(vhub_np, "vhub-device-revision", &data)) {
919 		id = (u16)data;
920 		vhub->vhub_dev_desc.bcdDevice = cpu_to_le16(id);
921 	}
922 }
923 
924 static void ast_vhub_fixup_usb1_dev_desc(struct ast_vhub *vhub)
925 {
926 	vhub->vhub_dev_desc.bcdUSB = cpu_to_le16(0x0100);
927 	vhub->vhub_dev_desc.bDeviceProtocol = 0;
928 }
929 
930 static struct usb_gadget_string_container*
931 ast_vhub_str_container_alloc(struct ast_vhub *vhub)
932 {
933 	unsigned int size;
934 	struct usb_string *str_array;
935 	struct usb_gadget_strings *lang_str;
936 	struct usb_gadget_string_container *container;
937 
938 	size = sizeof(*container);
939 	size += sizeof(struct usb_gadget_strings);
940 	size += sizeof(struct usb_string) * AST_VHUB_STR_INDEX_MAX;
941 	container = devm_kzalloc(&vhub->pdev->dev, size, GFP_KERNEL);
942 	if (!container)
943 		return ERR_PTR(-ENOMEM);
944 
945 	lang_str = ast_vhub_str_of_container(container);
946 	str_array = (struct usb_string *)(lang_str + 1);
947 	lang_str->strings = str_array;
948 	return container;
949 }
950 
951 static void ast_vhub_str_deep_copy(struct usb_gadget_strings *dest,
952 				   const struct usb_gadget_strings *src)
953 {
954 	struct usb_string *src_array = src->strings;
955 	struct usb_string *dest_array = dest->strings;
956 
957 	dest->language = src->language;
958 	if (src_array && dest_array) {
959 		do {
960 			*dest_array = *src_array;
961 			dest_array++;
962 			src_array++;
963 		} while (src_array->s);
964 	}
965 }
966 
967 static int ast_vhub_str_alloc_add(struct ast_vhub *vhub,
968 				  const struct usb_gadget_strings *src_str)
969 {
970 	struct usb_gadget_strings *dest_str;
971 	struct usb_gadget_string_container *container;
972 
973 	container = ast_vhub_str_container_alloc(vhub);
974 	if (IS_ERR(container))
975 		return PTR_ERR(container);
976 
977 	dest_str = ast_vhub_str_of_container(container);
978 	ast_vhub_str_deep_copy(dest_str, src_str);
979 	list_add_tail(&container->list, &vhub->vhub_str_desc);
980 
981 	return 0;
982 }
983 
984 static const struct {
985 	const char *name;
986 	u8 id;
987 } str_id_map[] = {
988 	{"manufacturer",	AST_VHUB_STR_MANUF},
989 	{"product",		AST_VHUB_STR_PRODUCT},
990 	{"serial-number",	AST_VHUB_STR_SERIAL},
991 	{},
992 };
993 
994 static int ast_vhub_of_parse_str_desc(struct ast_vhub *vhub,
995 				      const struct device_node *desc_np)
996 {
997 	u32 langid;
998 	int ret = 0;
999 	int i, offset;
1000 	const char *str;
1001 	struct device_node *child;
1002 	struct usb_string str_array[AST_VHUB_STR_INDEX_MAX];
1003 	struct usb_gadget_strings lang_str = {
1004 		.strings = (struct usb_string *)str_array,
1005 	};
1006 
1007 	for_each_child_of_node(desc_np, child) {
1008 		if (of_property_read_u32(child, "reg", &langid))
1009 			continue; /* no language identifier specified */
1010 
1011 		if (!usb_validate_langid(langid))
1012 			continue; /* invalid language identifier */
1013 
1014 		lang_str.language = langid;
1015 		for (i = offset = 0; str_id_map[i].name; i++) {
1016 			str = of_get_property(child, str_id_map[i].name, NULL);
1017 			if (str) {
1018 				str_array[offset].s = str;
1019 				str_array[offset].id = str_id_map[i].id;
1020 				offset++;
1021 			}
1022 		}
1023 		str_array[offset].id = 0;
1024 		str_array[offset].s = NULL;
1025 
1026 		ret = ast_vhub_str_alloc_add(vhub, &lang_str);
1027 		if (ret) {
1028 			of_node_put(child);
1029 			break;
1030 		}
1031 	}
1032 
1033 	return ret;
1034 }
1035 
1036 static int ast_vhub_init_desc(struct ast_vhub *vhub)
1037 {
1038 	int ret;
1039 	struct device_node *desc_np;
1040 	const struct device_node *vhub_np = vhub->pdev->dev.of_node;
1041 
1042 	/* Initialize vhub Device Descriptor. */
1043 	memcpy(&vhub->vhub_dev_desc, &ast_vhub_dev_desc,
1044 		sizeof(vhub->vhub_dev_desc));
1045 	ast_vhub_of_parse_dev_desc(vhub, vhub_np);
1046 	if (vhub->force_usb1)
1047 		ast_vhub_fixup_usb1_dev_desc(vhub);
1048 
1049 	/* Initialize vhub Configuration Descriptor. */
1050 	memcpy(&vhub->vhub_conf_desc, &ast_vhub_conf_desc,
1051 		sizeof(vhub->vhub_conf_desc));
1052 
1053 	/* Initialize vhub Hub Descriptor. */
1054 	memcpy(&vhub->vhub_hub_desc, &ast_vhub_hub_desc,
1055 		sizeof(vhub->vhub_hub_desc));
1056 	vhub->vhub_hub_desc.bNbrPorts = vhub->max_ports;
1057 
1058 	/* Initialize vhub String Descriptors. */
1059 	INIT_LIST_HEAD(&vhub->vhub_str_desc);
1060 	desc_np = of_get_child_by_name(vhub_np, "vhub-strings");
1061 	if (desc_np) {
1062 		ret = ast_vhub_of_parse_str_desc(vhub, desc_np);
1063 		of_node_put(desc_np);
1064 	}
1065 	else
1066 		ret = ast_vhub_str_alloc_add(vhub, &ast_vhub_strings);
1067 
1068 	/* Initialize vhub Qualifier Descriptor. */
1069 	memcpy(&vhub->vhub_qual_desc, &ast_vhub_qual_desc,
1070 		sizeof(vhub->vhub_qual_desc));
1071 
1072 	return ret;
1073 }
1074 
1075 int ast_vhub_init_hub(struct ast_vhub *vhub)
1076 {
1077 	vhub->speed = USB_SPEED_UNKNOWN;
1078 	INIT_WORK(&vhub->wake_work, ast_vhub_wake_work);
1079 
1080 	return ast_vhub_init_desc(vhub);
1081 }
1082