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 31void 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 45static 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 89static 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 108static 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 134static 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 166static 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 180static 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 205static 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 217int 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 276static 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 296static 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 303static 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 314static 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 340static 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 359static 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 444static 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 466static 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 475void 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 484void 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 493void 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 520void 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 537static void ast_vhub_dev_release(struct device *dev) 538{ 539 kfree(dev); 540} 541 542int 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