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