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