1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget
4  *
5  * dev.c - Individual device/gadget management (ie, a port = a gadget)
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/usb.h>
33 #include <linux/usb/hcd.h>
34 
35 #include "vhub.h"
36 
37 void ast_vhub_dev_irq(struct ast_vhub_dev *d)
38 {
39 	u32 istat = readl(d->regs + AST_VHUB_DEV_ISR);
40 
41 	writel(istat, d->regs + AST_VHUB_DEV_ISR);
42 
43 	if (istat & VHUV_DEV_IRQ_EP0_IN_ACK_STALL)
44 		ast_vhub_ep0_handle_ack(&d->ep0, true);
45 	if (istat & VHUV_DEV_IRQ_EP0_OUT_ACK_STALL)
46 		ast_vhub_ep0_handle_ack(&d->ep0, false);
47 	if (istat & VHUV_DEV_IRQ_EP0_SETUP)
48 		ast_vhub_ep0_handle_setup(&d->ep0);
49 }
50 
51 static void ast_vhub_dev_enable(struct ast_vhub_dev *d)
52 {
53 	u32 reg, hmsk;
54 
55 	if (d->enabled)
56 		return;
57 
58 	/* Enable device and its EP0 interrupts */
59 	reg = VHUB_DEV_EN_ENABLE_PORT |
60 		VHUB_DEV_EN_EP0_IN_ACK_IRQEN |
61 		VHUB_DEV_EN_EP0_OUT_ACK_IRQEN |
62 		VHUB_DEV_EN_EP0_SETUP_IRQEN;
63 	if (d->gadget.speed == USB_SPEED_HIGH)
64 		reg |= VHUB_DEV_EN_SPEED_SEL_HIGH;
65 	writel(reg, d->regs + AST_VHUB_DEV_EN_CTRL);
66 
67 	/* Enable device interrupt in the hub as well */
68 	hmsk = VHUB_IRQ_DEVICE1 << d->index;
69 	reg = readl(d->vhub->regs + AST_VHUB_IER);
70 	reg |= hmsk;
71 	writel(reg, d->vhub->regs + AST_VHUB_IER);
72 
73 	/* Set EP0 DMA buffer address */
74 	writel(d->ep0.buf_dma, d->regs + AST_VHUB_DEV_EP0_DATA);
75 
76 	d->enabled = true;
77 }
78 
79 static void ast_vhub_dev_disable(struct ast_vhub_dev *d)
80 {
81 	u32 reg, hmsk;
82 
83 	if (!d->enabled)
84 		return;
85 
86 	/* Disable device interrupt in the hub */
87 	hmsk = VHUB_IRQ_DEVICE1 << d->index;
88 	reg = readl(d->vhub->regs + AST_VHUB_IER);
89 	reg &= ~hmsk;
90 	writel(reg, d->vhub->regs + AST_VHUB_IER);
91 
92 	/* Then disable device */
93 	writel(0, d->regs + AST_VHUB_DEV_EN_CTRL);
94 	d->gadget.speed = USB_SPEED_UNKNOWN;
95 	d->enabled = false;
96 	d->suspended = false;
97 }
98 
99 static int ast_vhub_dev_feature(struct ast_vhub_dev *d,
100 				u16 wIndex, u16 wValue,
101 				bool is_set)
102 {
103 	DDBG(d, "%s_FEATURE(dev val=%02x)\n",
104 	     is_set ? "SET" : "CLEAR", wValue);
105 
106 	if (wValue != USB_DEVICE_REMOTE_WAKEUP)
107 		return std_req_driver;
108 
109 	d->wakeup_en = is_set;
110 
111 	return std_req_complete;
112 }
113 
114 static int ast_vhub_ep_feature(struct ast_vhub_dev *d,
115 			       u16 wIndex, u16 wValue, bool is_set)
116 {
117 	struct ast_vhub_ep *ep;
118 	int ep_num;
119 
120 	ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK;
121 	DDBG(d, "%s_FEATURE(ep%d val=%02x)\n",
122 	     is_set ? "SET" : "CLEAR", ep_num, wValue);
123 	if (ep_num == 0)
124 		return std_req_complete;
125 	if (ep_num >= AST_VHUB_NUM_GEN_EPs || !d->epns[ep_num - 1])
126 		return std_req_stall;
127 	if (wValue != USB_ENDPOINT_HALT)
128 		return std_req_driver;
129 
130 	ep = d->epns[ep_num - 1];
131 	if (WARN_ON(!ep))
132 		return std_req_stall;
133 
134 	if (!ep->epn.enabled || !ep->ep.desc || ep->epn.is_iso ||
135 	    ep->epn.is_in != !!(wIndex & USB_DIR_IN))
136 		return std_req_stall;
137 
138 	DDBG(d, "%s stall on EP %d\n",
139 	     is_set ? "setting" : "clearing", ep_num);
140 	ep->epn.stalled = is_set;
141 	ast_vhub_update_epn_stall(ep);
142 
143 	return std_req_complete;
144 }
145 
146 static int ast_vhub_dev_status(struct ast_vhub_dev *d,
147 			       u16 wIndex, u16 wValue)
148 {
149 	u8 st0;
150 
151 	DDBG(d, "GET_STATUS(dev)\n");
152 
153 	st0 = d->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED;
154 	if (d->wakeup_en)
155 		st0 |= 1 << USB_DEVICE_REMOTE_WAKEUP;
156 
157 	return ast_vhub_simple_reply(&d->ep0, st0, 0);
158 }
159 
160 static int ast_vhub_ep_status(struct ast_vhub_dev *d,
161 			      u16 wIndex, u16 wValue)
162 {
163 	int ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK;
164 	struct ast_vhub_ep *ep;
165 	u8 st0 = 0;
166 
167 	DDBG(d, "GET_STATUS(ep%d)\n", ep_num);
168 
169 	if (ep_num >= AST_VHUB_NUM_GEN_EPs)
170 		return std_req_stall;
171 	if (ep_num != 0) {
172 		ep = d->epns[ep_num - 1];
173 		if (!ep)
174 			return std_req_stall;
175 		if (!ep->epn.enabled || !ep->ep.desc || ep->epn.is_iso ||
176 		    ep->epn.is_in != !!(wIndex & USB_DIR_IN))
177 			return std_req_stall;
178 		if (ep->epn.stalled)
179 			st0 |= 1 << USB_ENDPOINT_HALT;
180 	}
181 
182 	return ast_vhub_simple_reply(&d->ep0, st0, 0);
183 }
184 
185 static void ast_vhub_dev_set_address(struct ast_vhub_dev *d, u8 addr)
186 {
187 	u32 reg;
188 
189 	DDBG(d, "SET_ADDRESS: Got address %x\n", addr);
190 
191 	reg = readl(d->regs + AST_VHUB_DEV_EN_CTRL);
192 	reg &= ~VHUB_DEV_EN_ADDR_MASK;
193 	reg |= VHUB_DEV_EN_SET_ADDR(addr);
194 	writel(reg, d->regs + AST_VHUB_DEV_EN_CTRL);
195 }
196 
197 int ast_vhub_std_dev_request(struct ast_vhub_ep *ep,
198 			     struct usb_ctrlrequest *crq)
199 {
200 	struct ast_vhub_dev *d = ep->dev;
201 	u16 wValue, wIndex;
202 
203 	/* No driver, we shouldn't be enabled ... */
204 	if (!d->driver || !d->enabled || d->suspended) {
205 		EPDBG(ep,
206 		      "Device is wrong state driver=%p enabled=%d"
207 		      " suspended=%d\n",
208 		      d->driver, d->enabled, d->suspended);
209 		return std_req_stall;
210 	}
211 
212 	/* First packet, grab speed */
213 	if (d->gadget.speed == USB_SPEED_UNKNOWN) {
214 		d->gadget.speed = ep->vhub->speed;
215 		if (d->gadget.speed > d->driver->max_speed)
216 			d->gadget.speed = d->driver->max_speed;
217 		DDBG(d, "fist packet, captured speed %d\n",
218 		     d->gadget.speed);
219 	}
220 
221 	wValue = le16_to_cpu(crq->wValue);
222 	wIndex = le16_to_cpu(crq->wIndex);
223 
224 	switch ((crq->bRequestType << 8) | crq->bRequest) {
225 		/* SET_ADDRESS */
226 	case DeviceOutRequest | USB_REQ_SET_ADDRESS:
227 		ast_vhub_dev_set_address(d, wValue);
228 		return std_req_complete;
229 
230 		/* GET_STATUS */
231 	case DeviceRequest | USB_REQ_GET_STATUS:
232 		return ast_vhub_dev_status(d, wIndex, wValue);
233 	case InterfaceRequest | USB_REQ_GET_STATUS:
234 		return ast_vhub_simple_reply(ep, 0, 0);
235 	case EndpointRequest | USB_REQ_GET_STATUS:
236 		return ast_vhub_ep_status(d, wIndex, wValue);
237 
238 		/* SET/CLEAR_FEATURE */
239 	case DeviceOutRequest | USB_REQ_SET_FEATURE:
240 		return ast_vhub_dev_feature(d, wIndex, wValue, true);
241 	case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
242 		return ast_vhub_dev_feature(d, wIndex, wValue, false);
243 	case EndpointOutRequest | USB_REQ_SET_FEATURE:
244 		return ast_vhub_ep_feature(d, wIndex, wValue, true);
245 	case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
246 		return ast_vhub_ep_feature(d, wIndex, wValue, false);
247 	}
248 	return std_req_driver;
249 }
250 
251 static int ast_vhub_udc_wakeup(struct usb_gadget* gadget)
252 {
253 	struct ast_vhub_dev *d = to_ast_dev(gadget);
254 	unsigned long flags;
255 	int rc = -EINVAL;
256 
257 	spin_lock_irqsave(&d->vhub->lock, flags);
258 	if (!d->wakeup_en)
259 		goto err;
260 
261 	DDBG(d, "Device initiated wakeup\n");
262 
263 	/* Wakeup the host */
264 	ast_vhub_hub_wake_all(d->vhub);
265 	rc = 0;
266  err:
267 	spin_unlock_irqrestore(&d->vhub->lock, flags);
268 	return rc;
269 }
270 
271 static int ast_vhub_udc_get_frame(struct usb_gadget* gadget)
272 {
273 	struct ast_vhub_dev *d = to_ast_dev(gadget);
274 
275 	return (readl(d->vhub->regs + AST_VHUB_USBSTS) >> 16) & 0x7ff;
276 }
277 
278 static void ast_vhub_dev_nuke(struct ast_vhub_dev *d)
279 {
280 	unsigned int i;
281 
282 	for (i = 0; i < AST_VHUB_NUM_GEN_EPs; i++) {
283 		if (!d->epns[i])
284 			continue;
285 		ast_vhub_nuke(d->epns[i], -ESHUTDOWN);
286 	}
287 }
288 
289 static int ast_vhub_udc_pullup(struct usb_gadget* gadget, int on)
290 {
291 	struct ast_vhub_dev *d = to_ast_dev(gadget);
292 	unsigned long flags;
293 
294 	spin_lock_irqsave(&d->vhub->lock, flags);
295 
296 	DDBG(d, "pullup(%d)\n", on);
297 
298 	/* Mark disconnected in the hub */
299 	ast_vhub_device_connect(d->vhub, d->index, on);
300 
301 	/*
302 	 * If enabled, nuke all requests if any (there shouldn't be)
303 	 * and disable the port. This will clear the address too.
304 	 */
305 	if (d->enabled) {
306 		ast_vhub_dev_nuke(d);
307 		ast_vhub_dev_disable(d);
308 	}
309 
310 	spin_unlock_irqrestore(&d->vhub->lock, flags);
311 
312 	return 0;
313 }
314 
315 static int ast_vhub_udc_start(struct usb_gadget *gadget,
316 			      struct usb_gadget_driver *driver)
317 {
318 	struct ast_vhub_dev *d = to_ast_dev(gadget);
319 	unsigned long flags;
320 
321 	spin_lock_irqsave(&d->vhub->lock, flags);
322 
323 	DDBG(d, "start\n");
324 
325 	/* We don't do much more until the hub enables us */
326 	d->driver = driver;
327 	d->gadget.is_selfpowered = 1;
328 
329 	spin_unlock_irqrestore(&d->vhub->lock, flags);
330 
331 	return 0;
332 }
333 
334 static struct usb_ep *ast_vhub_udc_match_ep(struct usb_gadget *gadget,
335 					    struct usb_endpoint_descriptor *desc,
336 					    struct usb_ss_ep_comp_descriptor *ss)
337 {
338 	struct ast_vhub_dev *d = to_ast_dev(gadget);
339 	struct ast_vhub_ep *ep;
340 	struct usb_ep *u_ep;
341 	unsigned int max, addr, i;
342 
343 	DDBG(d, "Match EP type %d\n", usb_endpoint_type(desc));
344 
345 	/*
346 	 * First we need to look for an existing unclaimed EP as another
347 	 * configuration may have already associated a bunch of EPs with
348 	 * this gadget. This duplicates the code in usb_ep_autoconfig_ss()
349 	 * unfortunately.
350 	 */
351 	list_for_each_entry(u_ep, &gadget->ep_list, ep_list) {
352 		if (usb_gadget_ep_match_desc(gadget, u_ep, desc, ss)) {
353 			DDBG(d, " -> using existing EP%d\n",
354 			     to_ast_ep(u_ep)->d_idx);
355 			return u_ep;
356 		}
357 	}
358 
359 	/*
360 	 * We didn't find one, we need to grab one from the pool.
361 	 *
362 	 * First let's do some sanity checking
363 	 */
364 	switch(usb_endpoint_type(desc)) {
365 	case USB_ENDPOINT_XFER_CONTROL:
366 		/* Only EP0 can be a control endpoint */
367 		return NULL;
368 	case USB_ENDPOINT_XFER_ISOC:
369 		/* ISO:	 limit 1023 bytes full speed, 1024 high/super speed */
370 		if (gadget_is_dualspeed(gadget))
371 			max = 1024;
372 		else
373 			max = 1023;
374 		break;
375 	case USB_ENDPOINT_XFER_BULK:
376 		if (gadget_is_dualspeed(gadget))
377 			max = 512;
378 		else
379 			max = 64;
380 		break;
381 	case USB_ENDPOINT_XFER_INT:
382 		if (gadget_is_dualspeed(gadget))
383 			max = 1024;
384 		else
385 			max = 64;
386 		break;
387 	}
388 	if (usb_endpoint_maxp(desc) > max)
389 		return NULL;
390 
391 	/*
392 	 * Find a free EP address for that device. We can't
393 	 * let the generic code assign these as it would
394 	 * create overlapping numbers for IN and OUT which
395 	 * we don't support, so also create a suitable name
396 	 * that will allow the generic code to use our
397 	 * assigned address.
398 	 */
399 	for (i = 0; i < AST_VHUB_NUM_GEN_EPs; i++)
400 		if (d->epns[i] == NULL)
401 			break;
402 	if (i >= AST_VHUB_NUM_GEN_EPs)
403 		return NULL;
404 	addr = i + 1;
405 
406 	/*
407 	 * Now grab an EP from the shared pool and associate
408 	 * it with our device
409 	 */
410 	ep = ast_vhub_alloc_epn(d, addr);
411 	if (!ep)
412 		return NULL;
413 	DDBG(d, "Allocated epn#%d for port EP%d\n",
414 	     ep->epn.g_idx, addr);
415 
416 	return &ep->ep;
417 }
418 
419 static int ast_vhub_udc_stop(struct usb_gadget *gadget)
420 {
421 	struct ast_vhub_dev *d = to_ast_dev(gadget);
422 	unsigned long flags;
423 
424 	spin_lock_irqsave(&d->vhub->lock, flags);
425 
426 	DDBG(d, "stop\n");
427 
428 	d->driver = NULL;
429 	d->gadget.speed = USB_SPEED_UNKNOWN;
430 
431 	ast_vhub_dev_nuke(d);
432 
433 	if (d->enabled)
434 		ast_vhub_dev_disable(d);
435 
436 	spin_unlock_irqrestore(&d->vhub->lock, flags);
437 
438 	return 0;
439 }
440 
441 static const struct usb_gadget_ops ast_vhub_udc_ops = {
442 	.get_frame	= ast_vhub_udc_get_frame,
443 	.wakeup		= ast_vhub_udc_wakeup,
444 	.pullup		= ast_vhub_udc_pullup,
445 	.udc_start	= ast_vhub_udc_start,
446 	.udc_stop	= ast_vhub_udc_stop,
447 	.match_ep	= ast_vhub_udc_match_ep,
448 };
449 
450 void ast_vhub_dev_suspend(struct ast_vhub_dev *d)
451 {
452 	d->suspended = true;
453 	if (d->driver) {
454 		spin_unlock(&d->vhub->lock);
455 		d->driver->suspend(&d->gadget);
456 		spin_lock(&d->vhub->lock);
457 	}
458 }
459 
460 void ast_vhub_dev_resume(struct ast_vhub_dev *d)
461 {
462 	d->suspended = false;
463 	if (d->driver) {
464 		spin_unlock(&d->vhub->lock);
465 		d->driver->resume(&d->gadget);
466 		spin_lock(&d->vhub->lock);
467 	}
468 }
469 
470 void ast_vhub_dev_reset(struct ast_vhub_dev *d)
471 {
472 	/*
473 	 * If speed is not set, we enable the port. If it is,
474 	 * send reset to the gadget and reset "speed".
475 	 *
476 	 * Speed is an indication that we have got the first
477 	 * setup packet to the device.
478 	 */
479 	if (d->gadget.speed == USB_SPEED_UNKNOWN && !d->enabled) {
480 		DDBG(d, "Reset at unknown speed of disabled device, enabling...\n");
481 		ast_vhub_dev_enable(d);
482 		d->suspended = false;
483 	}
484 	if (d->gadget.speed != USB_SPEED_UNKNOWN && d->driver) {
485 		unsigned int i;
486 
487 		DDBG(d, "Reset at known speed of bound device, resetting...\n");
488 		spin_unlock(&d->vhub->lock);
489 		d->driver->reset(&d->gadget);
490 		spin_lock(&d->vhub->lock);
491 
492 		/*
493 		 * Disable/re-enable HW, this will clear the address
494 		 * and speed setting.
495 		 */
496 		ast_vhub_dev_disable(d);
497 		ast_vhub_dev_enable(d);
498 
499 		/* Clear stall on all EPs */
500 		for (i = 0; i < AST_VHUB_NUM_GEN_EPs; i++) {
501 			struct ast_vhub_ep *ep = d->epns[i];
502 
503 			if (ep && ep->epn.stalled) {
504 				ep->epn.stalled = false;
505 				ast_vhub_update_epn_stall(ep);
506 			}
507 		}
508 
509 		/* Additional cleanups */
510 		d->wakeup_en = false;
511 		d->suspended = false;
512 	}
513 }
514 
515 void ast_vhub_del_dev(struct ast_vhub_dev *d)
516 {
517 	unsigned long flags;
518 
519 	spin_lock_irqsave(&d->vhub->lock, flags);
520 	if (!d->registered) {
521 		spin_unlock_irqrestore(&d->vhub->lock, flags);
522 		return;
523 	}
524 	d->registered = false;
525 	spin_unlock_irqrestore(&d->vhub->lock, flags);
526 
527 	usb_del_gadget_udc(&d->gadget);
528 	device_unregister(d->port_dev);
529 }
530 
531 static void ast_vhub_dev_release(struct device *dev)
532 {
533 	kfree(dev);
534 }
535 
536 int ast_vhub_init_dev(struct ast_vhub *vhub, unsigned int idx)
537 {
538 	struct ast_vhub_dev *d = &vhub->ports[idx].dev;
539 	struct device *parent = &vhub->pdev->dev;
540 	int rc;
541 
542 	d->vhub = vhub;
543 	d->index = idx;
544 	d->name = devm_kasprintf(parent, GFP_KERNEL, "port%d", idx+1);
545 	d->regs = vhub->regs + 0x100 + 0x10 * idx;
546 
547 	ast_vhub_init_ep0(vhub, &d->ep0, d);
548 
549 	/*
550 	 * The UDC core really needs us to have separate and uniquely
551 	 * named "parent" devices for each port so we create a sub device
552 	 * here for that purpose
553 	 */
554 	d->port_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
555 	if (!d->port_dev)
556 		return -ENOMEM;
557 	device_initialize(d->port_dev);
558 	d->port_dev->release = ast_vhub_dev_release;
559 	d->port_dev->parent = parent;
560 	dev_set_name(d->port_dev, "%s:p%d", dev_name(parent), idx + 1);
561 	rc = device_add(d->port_dev);
562 	if (rc)
563 		goto fail_add;
564 
565 	/* Populate gadget */
566 	INIT_LIST_HEAD(&d->gadget.ep_list);
567 	d->gadget.ops = &ast_vhub_udc_ops;
568 	d->gadget.ep0 = &d->ep0.ep;
569 	d->gadget.name = KBUILD_MODNAME;
570 	if (vhub->force_usb1)
571 		d->gadget.max_speed = USB_SPEED_FULL;
572 	else
573 		d->gadget.max_speed = USB_SPEED_HIGH;
574 	d->gadget.speed = USB_SPEED_UNKNOWN;
575 	d->gadget.dev.of_node = vhub->pdev->dev.of_node;
576 
577 	rc = usb_add_gadget_udc(d->port_dev, &d->gadget);
578 	if (rc != 0)
579 		goto fail_udc;
580 	d->registered = true;
581 
582 	return 0;
583  fail_udc:
584 	device_del(d->port_dev);
585  fail_add:
586 	put_device(d->port_dev);
587 
588 	return rc;
589 }
590