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