1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget 4 * 5 * hub.c - virtual hub handling 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/bcd.h> 27 #include <linux/version.h> 28 #include <linux/usb.h> 29 #include <linux/usb/hcd.h> 30 31 #include "vhub.h" 32 33 /* usb 2.0 hub device descriptor 34 * 35 * A few things we may want to improve here: 36 * 37 * - We may need to indicate TT support 38 * - We may need a device qualifier descriptor 39 * as devices can pretend to be usb1 or 2 40 * - Make vid/did overridable 41 * - make it look like usb1 if usb1 mode forced 42 */ 43 #define KERNEL_REL bin2bcd(LINUX_VERSION_MAJOR) 44 #define KERNEL_VER bin2bcd(LINUX_VERSION_PATCHLEVEL) 45 46 enum { 47 AST_VHUB_STR_INDEX_MAX = 4, 48 AST_VHUB_STR_MANUF = 3, 49 AST_VHUB_STR_PRODUCT = 2, 50 AST_VHUB_STR_SERIAL = 1, 51 }; 52 53 static const struct usb_device_descriptor ast_vhub_dev_desc = { 54 .bLength = USB_DT_DEVICE_SIZE, 55 .bDescriptorType = USB_DT_DEVICE, 56 .bcdUSB = cpu_to_le16(0x0200), 57 .bDeviceClass = USB_CLASS_HUB, 58 .bDeviceSubClass = 0, 59 .bDeviceProtocol = 1, 60 .bMaxPacketSize0 = 64, 61 .idVendor = cpu_to_le16(0x1d6b), 62 .idProduct = cpu_to_le16(0x0107), 63 .bcdDevice = cpu_to_le16(0x0100), 64 .iManufacturer = AST_VHUB_STR_MANUF, 65 .iProduct = AST_VHUB_STR_PRODUCT, 66 .iSerialNumber = AST_VHUB_STR_SERIAL, 67 .bNumConfigurations = 1, 68 }; 69 70 static const struct usb_qualifier_descriptor ast_vhub_qual_desc = { 71 .bLength = 0xA, 72 .bDescriptorType = USB_DT_DEVICE_QUALIFIER, 73 .bcdUSB = cpu_to_le16(0x0200), 74 .bDeviceClass = USB_CLASS_HUB, 75 .bDeviceSubClass = 0, 76 .bDeviceProtocol = 0, 77 .bMaxPacketSize0 = 64, 78 .bNumConfigurations = 1, 79 .bRESERVED = 0, 80 }; 81 82 /* 83 * Configuration descriptor: same comments as above 84 * regarding handling USB1 mode. 85 */ 86 87 /* 88 * We don't use sizeof() as Linux definition of 89 * struct usb_endpoint_descriptor contains 2 90 * extra bytes 91 */ 92 #define AST_VHUB_CONF_DESC_SIZE (USB_DT_CONFIG_SIZE + \ 93 USB_DT_INTERFACE_SIZE + \ 94 USB_DT_ENDPOINT_SIZE) 95 96 static const struct ast_vhub_full_cdesc ast_vhub_conf_desc = { 97 .cfg = { 98 .bLength = USB_DT_CONFIG_SIZE, 99 .bDescriptorType = USB_DT_CONFIG, 100 .wTotalLength = cpu_to_le16(AST_VHUB_CONF_DESC_SIZE), 101 .bNumInterfaces = 1, 102 .bConfigurationValue = 1, 103 .iConfiguration = 0, 104 .bmAttributes = USB_CONFIG_ATT_ONE | 105 USB_CONFIG_ATT_SELFPOWER | 106 USB_CONFIG_ATT_WAKEUP, 107 .bMaxPower = 0, 108 }, 109 .intf = { 110 .bLength = USB_DT_INTERFACE_SIZE, 111 .bDescriptorType = USB_DT_INTERFACE, 112 .bInterfaceNumber = 0, 113 .bAlternateSetting = 0, 114 .bNumEndpoints = 1, 115 .bInterfaceClass = USB_CLASS_HUB, 116 .bInterfaceSubClass = 0, 117 .bInterfaceProtocol = 0, 118 .iInterface = 0, 119 }, 120 .ep = { 121 .bLength = USB_DT_ENDPOINT_SIZE, 122 .bDescriptorType = USB_DT_ENDPOINT, 123 .bEndpointAddress = 0x81, 124 .bmAttributes = USB_ENDPOINT_XFER_INT, 125 .wMaxPacketSize = cpu_to_le16(1), 126 .bInterval = 0x0c, 127 }, 128 }; 129 130 #define AST_VHUB_HUB_DESC_SIZE (USB_DT_HUB_NONVAR_SIZE + 2) 131 132 static const struct usb_hub_descriptor ast_vhub_hub_desc = { 133 .bDescLength = AST_VHUB_HUB_DESC_SIZE, 134 .bDescriptorType = USB_DT_HUB, 135 .bNbrPorts = AST_VHUB_NUM_PORTS, 136 .wHubCharacteristics = cpu_to_le16(HUB_CHAR_NO_LPSM), 137 .bPwrOn2PwrGood = 10, 138 .bHubContrCurrent = 0, 139 .u.hs.DeviceRemovable[0] = 0, 140 .u.hs.DeviceRemovable[1] = 0xff, 141 }; 142 143 /* 144 * These strings converted to UTF-16 must be smaller than 145 * our EP0 buffer. 146 */ 147 static const struct usb_string ast_vhub_str_array[] = { 148 { 149 .id = AST_VHUB_STR_SERIAL, 150 .s = "00000000" 151 }, 152 { 153 .id = AST_VHUB_STR_PRODUCT, 154 .s = "USB Virtual Hub" 155 }, 156 { 157 .id = AST_VHUB_STR_MANUF, 158 .s = "Aspeed" 159 }, 160 { } 161 }; 162 163 static const struct usb_gadget_strings ast_vhub_strings = { 164 .language = 0x0409, 165 .strings = (struct usb_string *)ast_vhub_str_array 166 }; 167 168 static int ast_vhub_hub_dev_status(struct ast_vhub_ep *ep, 169 u16 wIndex, u16 wValue) 170 { 171 u8 st0; 172 173 EPDBG(ep, "GET_STATUS(dev)\n"); 174 175 /* 176 * Mark it as self-powered, I doubt the BMC is powered off 177 * the USB bus ... 178 */ 179 st0 = 1 << USB_DEVICE_SELF_POWERED; 180 181 /* 182 * Need to double check how remote wakeup actually works 183 * on that chip and what triggers it. 184 */ 185 if (ep->vhub->wakeup_en) 186 st0 |= 1 << USB_DEVICE_REMOTE_WAKEUP; 187 188 return ast_vhub_simple_reply(ep, st0, 0); 189 } 190 191 static int ast_vhub_hub_ep_status(struct ast_vhub_ep *ep, 192 u16 wIndex, u16 wValue) 193 { 194 int ep_num; 195 u8 st0 = 0; 196 197 ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK; 198 EPDBG(ep, "GET_STATUS(ep%d)\n", ep_num); 199 200 /* On the hub we have only EP 0 and 1 */ 201 if (ep_num == 1) { 202 if (ep->vhub->ep1_stalled) 203 st0 |= 1 << USB_ENDPOINT_HALT; 204 } else if (ep_num != 0) 205 return std_req_stall; 206 207 return ast_vhub_simple_reply(ep, st0, 0); 208 } 209 210 static int ast_vhub_hub_dev_feature(struct ast_vhub_ep *ep, 211 u16 wIndex, u16 wValue, 212 bool is_set) 213 { 214 u32 val; 215 216 EPDBG(ep, "%s_FEATURE(dev val=%02x)\n", 217 is_set ? "SET" : "CLEAR", wValue); 218 219 if (wValue == USB_DEVICE_REMOTE_WAKEUP) { 220 ep->vhub->wakeup_en = is_set; 221 EPDBG(ep, "Hub remote wakeup %s\n", 222 is_set ? "enabled" : "disabled"); 223 return std_req_complete; 224 } 225 226 if (wValue == USB_DEVICE_TEST_MODE) { 227 val = readl(ep->vhub->regs + AST_VHUB_CTRL); 228 val &= ~GENMASK(10, 8); 229 val |= VHUB_CTRL_SET_TEST_MODE((wIndex >> 8) & 0x7); 230 writel(val, ep->vhub->regs + AST_VHUB_CTRL); 231 232 return std_req_complete; 233 } 234 235 return std_req_stall; 236 } 237 238 static int ast_vhub_hub_ep_feature(struct ast_vhub_ep *ep, 239 u16 wIndex, u16 wValue, 240 bool is_set) 241 { 242 int ep_num; 243 u32 reg; 244 245 ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK; 246 EPDBG(ep, "%s_FEATURE(ep%d val=%02x)\n", 247 is_set ? "SET" : "CLEAR", ep_num, wValue); 248 249 if (ep_num > 1) 250 return std_req_stall; 251 if (wValue != USB_ENDPOINT_HALT) 252 return std_req_stall; 253 if (ep_num == 0) 254 return std_req_complete; 255 256 EPDBG(ep, "%s stall on EP 1\n", 257 is_set ? "setting" : "clearing"); 258 259 ep->vhub->ep1_stalled = is_set; 260 reg = readl(ep->vhub->regs + AST_VHUB_EP1_CTRL); 261 if (is_set) { 262 reg |= VHUB_EP1_CTRL_STALL; 263 } else { 264 reg &= ~VHUB_EP1_CTRL_STALL; 265 reg |= VHUB_EP1_CTRL_RESET_TOGGLE; 266 } 267 writel(reg, ep->vhub->regs + AST_VHUB_EP1_CTRL); 268 269 return std_req_complete; 270 } 271 272 static int ast_vhub_rep_desc(struct ast_vhub_ep *ep, 273 u8 desc_type, u16 len) 274 { 275 size_t dsize; 276 struct ast_vhub *vhub = ep->vhub; 277 278 EPDBG(ep, "GET_DESCRIPTOR(type:%d)\n", desc_type); 279 280 /* 281 * Copy first to EP buffer and send from there, so 282 * we can do some in-place patching if needed. We know 283 * the EP buffer is big enough but ensure that doesn't 284 * change. We do that now rather than later after we 285 * have checked sizes etc... to avoid a gcc bug where 286 * it thinks len is constant and barfs about read 287 * overflows in memcpy. 288 */ 289 switch(desc_type) { 290 case USB_DT_DEVICE: 291 dsize = USB_DT_DEVICE_SIZE; 292 memcpy(ep->buf, &vhub->vhub_dev_desc, dsize); 293 BUILD_BUG_ON(dsize > sizeof(vhub->vhub_dev_desc)); 294 BUILD_BUG_ON(USB_DT_DEVICE_SIZE >= AST_VHUB_EP0_MAX_PACKET); 295 break; 296 case USB_DT_OTHER_SPEED_CONFIG: 297 case USB_DT_CONFIG: 298 dsize = AST_VHUB_CONF_DESC_SIZE; 299 memcpy(ep->buf, &vhub->vhub_conf_desc, dsize); 300 ((u8 *)ep->buf)[1] = desc_type; 301 BUILD_BUG_ON(dsize > sizeof(vhub->vhub_conf_desc)); 302 BUILD_BUG_ON(AST_VHUB_CONF_DESC_SIZE >= AST_VHUB_EP0_MAX_PACKET); 303 break; 304 case USB_DT_HUB: 305 dsize = AST_VHUB_HUB_DESC_SIZE; 306 memcpy(ep->buf, &vhub->vhub_hub_desc, dsize); 307 BUILD_BUG_ON(dsize > sizeof(vhub->vhub_hub_desc)); 308 BUILD_BUG_ON(AST_VHUB_HUB_DESC_SIZE >= AST_VHUB_EP0_MAX_PACKET); 309 break; 310 case USB_DT_DEVICE_QUALIFIER: 311 dsize = sizeof(vhub->vhub_qual_desc); 312 memcpy(ep->buf, &vhub->vhub_qual_desc, dsize); 313 break; 314 default: 315 return std_req_stall; 316 } 317 318 /* Crop requested length */ 319 if (len > dsize) 320 len = dsize; 321 322 /* Shoot it from the EP buffer */ 323 return ast_vhub_reply(ep, NULL, len); 324 } 325 326 static struct usb_gadget_strings* 327 ast_vhub_str_of_container(struct usb_gadget_string_container *container) 328 { 329 return (struct usb_gadget_strings *)container->stash; 330 } 331 332 static int ast_vhub_collect_languages(struct ast_vhub *vhub, void *buf, 333 size_t size) 334 { 335 int rc, hdr_len, nlangs, max_langs; 336 struct usb_gadget_strings *lang_str; 337 struct usb_gadget_string_container *container; 338 struct usb_string_descriptor *sdesc = buf; 339 340 nlangs = 0; 341 hdr_len = sizeof(struct usb_descriptor_header); 342 max_langs = (size - hdr_len) / sizeof(sdesc->wData[0]); 343 list_for_each_entry(container, &vhub->vhub_str_desc, list) { 344 if (nlangs >= max_langs) 345 break; 346 347 lang_str = ast_vhub_str_of_container(container); 348 sdesc->wData[nlangs++] = cpu_to_le16(lang_str->language); 349 } 350 351 rc = hdr_len + nlangs * sizeof(sdesc->wData[0]); 352 sdesc->bLength = rc; 353 sdesc->bDescriptorType = USB_DT_STRING; 354 355 return rc; 356 } 357 358 static struct usb_gadget_strings *ast_vhub_lookup_string(struct ast_vhub *vhub, 359 u16 lang_id) 360 { 361 struct usb_gadget_strings *lang_str; 362 struct usb_gadget_string_container *container; 363 364 list_for_each_entry(container, &vhub->vhub_str_desc, list) { 365 lang_str = ast_vhub_str_of_container(container); 366 if (lang_str->language == lang_id) 367 return lang_str; 368 } 369 370 return NULL; 371 } 372 373 static int ast_vhub_rep_string(struct ast_vhub_ep *ep, 374 u8 string_id, u16 lang_id, 375 u16 len) 376 { 377 int rc; 378 u8 buf[256]; 379 struct ast_vhub *vhub = ep->vhub; 380 struct usb_gadget_strings *lang_str; 381 382 if (string_id == 0) { 383 rc = ast_vhub_collect_languages(vhub, buf, sizeof(buf)); 384 } else { 385 lang_str = ast_vhub_lookup_string(vhub, lang_id); 386 if (!lang_str) 387 return std_req_stall; 388 389 rc = usb_gadget_get_string(lang_str, string_id, buf); 390 } 391 392 if (rc < 0 || rc >= AST_VHUB_EP0_MAX_PACKET) 393 return std_req_stall; 394 395 /* Shoot it from the EP buffer */ 396 memcpy(ep->buf, buf, rc); 397 return ast_vhub_reply(ep, NULL, min_t(u16, rc, len)); 398 } 399 400 enum std_req_rc ast_vhub_std_hub_request(struct ast_vhub_ep *ep, 401 struct usb_ctrlrequest *crq) 402 { 403 struct ast_vhub *vhub = ep->vhub; 404 u16 wValue, wIndex, wLength; 405 406 wValue = le16_to_cpu(crq->wValue); 407 wIndex = le16_to_cpu(crq->wIndex); 408 wLength = le16_to_cpu(crq->wLength); 409 410 /* First packet, grab speed */ 411 if (vhub->speed == USB_SPEED_UNKNOWN) { 412 u32 ustat = readl(vhub->regs + AST_VHUB_USBSTS); 413 if (ustat & VHUB_USBSTS_HISPEED) 414 vhub->speed = USB_SPEED_HIGH; 415 else 416 vhub->speed = USB_SPEED_FULL; 417 UDCDBG(vhub, "USB status=%08x speed=%s\n", ustat, 418 vhub->speed == USB_SPEED_HIGH ? "high" : "full"); 419 } 420 421 switch ((crq->bRequestType << 8) | crq->bRequest) { 422 /* SET_ADDRESS */ 423 case DeviceOutRequest | USB_REQ_SET_ADDRESS: 424 EPDBG(ep, "SET_ADDRESS: Got address %x\n", wValue); 425 writel(wValue, vhub->regs + AST_VHUB_CONF); 426 return std_req_complete; 427 428 /* GET_STATUS */ 429 case DeviceRequest | USB_REQ_GET_STATUS: 430 return ast_vhub_hub_dev_status(ep, wIndex, wValue); 431 case InterfaceRequest | USB_REQ_GET_STATUS: 432 return ast_vhub_simple_reply(ep, 0, 0); 433 case EndpointRequest | USB_REQ_GET_STATUS: 434 return ast_vhub_hub_ep_status(ep, wIndex, wValue); 435 436 /* SET/CLEAR_FEATURE */ 437 case DeviceOutRequest | USB_REQ_SET_FEATURE: 438 return ast_vhub_hub_dev_feature(ep, wIndex, wValue, true); 439 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE: 440 return ast_vhub_hub_dev_feature(ep, wIndex, wValue, false); 441 case EndpointOutRequest | USB_REQ_SET_FEATURE: 442 return ast_vhub_hub_ep_feature(ep, wIndex, wValue, true); 443 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE: 444 return ast_vhub_hub_ep_feature(ep, wIndex, wValue, false); 445 446 /* GET/SET_CONFIGURATION */ 447 case DeviceRequest | USB_REQ_GET_CONFIGURATION: 448 return ast_vhub_simple_reply(ep, 1); 449 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: 450 if (wValue != 1) 451 return std_req_stall; 452 return std_req_complete; 453 454 /* GET_DESCRIPTOR */ 455 case DeviceRequest | USB_REQ_GET_DESCRIPTOR: 456 switch (wValue >> 8) { 457 case USB_DT_DEVICE: 458 case USB_DT_CONFIG: 459 case USB_DT_DEVICE_QUALIFIER: 460 case USB_DT_OTHER_SPEED_CONFIG: 461 return ast_vhub_rep_desc(ep, wValue >> 8, 462 wLength); 463 case USB_DT_STRING: 464 return ast_vhub_rep_string(ep, wValue & 0xff, 465 wIndex, wLength); 466 } 467 return std_req_stall; 468 469 /* GET/SET_INTERFACE */ 470 case DeviceRequest | USB_REQ_GET_INTERFACE: 471 return ast_vhub_simple_reply(ep, 0); 472 case DeviceOutRequest | USB_REQ_SET_INTERFACE: 473 if (wValue != 0 || wIndex != 0) 474 return std_req_stall; 475 return std_req_complete; 476 } 477 return std_req_stall; 478 } 479 480 static void ast_vhub_update_hub_ep1(struct ast_vhub *vhub, 481 unsigned int port) 482 { 483 /* Update HW EP1 response */ 484 u32 reg = readl(vhub->regs + AST_VHUB_EP1_STS_CHG); 485 u32 pmask = (1 << (port + 1)); 486 if (vhub->ports[port].change) 487 reg |= pmask; 488 else 489 reg &= ~pmask; 490 writel(reg, vhub->regs + AST_VHUB_EP1_STS_CHG); 491 } 492 493 static void ast_vhub_change_port_stat(struct ast_vhub *vhub, 494 unsigned int port, 495 u16 clr_flags, 496 u16 set_flags, 497 bool set_c) 498 { 499 struct ast_vhub_port *p = &vhub->ports[port]; 500 u16 prev; 501 502 /* Update port status */ 503 prev = p->status; 504 p->status = (prev & ~clr_flags) | set_flags; 505 DDBG(&p->dev, "port %d status %04x -> %04x (C=%d)\n", 506 port + 1, prev, p->status, set_c); 507 508 /* Update change bits if needed */ 509 if (set_c) { 510 u16 chg = p->status ^ prev; 511 512 /* Only these are relevant for change */ 513 chg &= USB_PORT_STAT_C_CONNECTION | 514 USB_PORT_STAT_C_ENABLE | 515 USB_PORT_STAT_C_SUSPEND | 516 USB_PORT_STAT_C_OVERCURRENT | 517 USB_PORT_STAT_C_RESET | 518 USB_PORT_STAT_C_L1; 519 520 /* 521 * We only set USB_PORT_STAT_C_ENABLE if we are disabling 522 * the port as per USB spec, otherwise MacOS gets upset 523 */ 524 if (p->status & USB_PORT_STAT_ENABLE) 525 chg &= ~USB_PORT_STAT_C_ENABLE; 526 527 p->change = chg; 528 ast_vhub_update_hub_ep1(vhub, port); 529 } 530 } 531 532 static void ast_vhub_send_host_wakeup(struct ast_vhub *vhub) 533 { 534 u32 reg = readl(vhub->regs + AST_VHUB_CTRL); 535 UDCDBG(vhub, "Waking up host !\n"); 536 reg |= VHUB_CTRL_MANUAL_REMOTE_WAKEUP; 537 writel(reg, vhub->regs + AST_VHUB_CTRL); 538 } 539 540 void ast_vhub_device_connect(struct ast_vhub *vhub, 541 unsigned int port, bool on) 542 { 543 if (on) 544 ast_vhub_change_port_stat(vhub, port, 0, 545 USB_PORT_STAT_CONNECTION, true); 546 else 547 ast_vhub_change_port_stat(vhub, port, 548 USB_PORT_STAT_CONNECTION | 549 USB_PORT_STAT_ENABLE, 550 0, true); 551 552 /* 553 * If the hub is set to wakup the host on connection events 554 * then send a wakeup. 555 */ 556 if (vhub->wakeup_en) 557 ast_vhub_send_host_wakeup(vhub); 558 } 559 560 static void ast_vhub_wake_work(struct work_struct *work) 561 { 562 struct ast_vhub *vhub = container_of(work, 563 struct ast_vhub, 564 wake_work); 565 unsigned long flags; 566 unsigned int i; 567 568 /* 569 * Wake all sleeping ports. If a port is suspended by 570 * the host suspend (without explicit state suspend), 571 * we let the normal host wake path deal with it later. 572 */ 573 spin_lock_irqsave(&vhub->lock, flags); 574 for (i = 0; i < vhub->max_ports; i++) { 575 struct ast_vhub_port *p = &vhub->ports[i]; 576 577 if (!(p->status & USB_PORT_STAT_SUSPEND)) 578 continue; 579 ast_vhub_change_port_stat(vhub, i, 580 USB_PORT_STAT_SUSPEND, 581 0, true); 582 ast_vhub_dev_resume(&p->dev); 583 } 584 ast_vhub_send_host_wakeup(vhub); 585 spin_unlock_irqrestore(&vhub->lock, flags); 586 } 587 588 void ast_vhub_hub_wake_all(struct ast_vhub *vhub) 589 { 590 /* 591 * A device is trying to wake the world, because this 592 * can recurse into the device, we break the call chain 593 * using a work queue 594 */ 595 schedule_work(&vhub->wake_work); 596 } 597 598 static void ast_vhub_port_reset(struct ast_vhub *vhub, u8 port) 599 { 600 struct ast_vhub_port *p = &vhub->ports[port]; 601 u16 set, clr, speed; 602 603 /* First mark disabled */ 604 ast_vhub_change_port_stat(vhub, port, 605 USB_PORT_STAT_ENABLE | 606 USB_PORT_STAT_SUSPEND, 607 USB_PORT_STAT_RESET, 608 false); 609 610 if (!p->dev.driver) 611 return; 612 613 /* 614 * This will either "start" the port or reset the 615 * device if already started... 616 */ 617 ast_vhub_dev_reset(&p->dev); 618 619 /* Grab the right speed */ 620 speed = p->dev.driver->max_speed; 621 if (speed == USB_SPEED_UNKNOWN || speed > vhub->speed) 622 speed = vhub->speed; 623 624 switch (speed) { 625 case USB_SPEED_LOW: 626 set = USB_PORT_STAT_LOW_SPEED; 627 clr = USB_PORT_STAT_HIGH_SPEED; 628 break; 629 case USB_SPEED_FULL: 630 set = 0; 631 clr = USB_PORT_STAT_LOW_SPEED | 632 USB_PORT_STAT_HIGH_SPEED; 633 break; 634 case USB_SPEED_HIGH: 635 set = USB_PORT_STAT_HIGH_SPEED; 636 clr = USB_PORT_STAT_LOW_SPEED; 637 break; 638 default: 639 UDCDBG(vhub, "Unsupported speed %d when" 640 " connecting device\n", 641 speed); 642 return; 643 } 644 clr |= USB_PORT_STAT_RESET; 645 set |= USB_PORT_STAT_ENABLE; 646 647 /* This should ideally be delayed ... */ 648 ast_vhub_change_port_stat(vhub, port, clr, set, true); 649 } 650 651 static enum std_req_rc ast_vhub_set_port_feature(struct ast_vhub_ep *ep, 652 u8 port, u16 feat) 653 { 654 struct ast_vhub *vhub = ep->vhub; 655 struct ast_vhub_port *p; 656 657 if (port == 0 || port > vhub->max_ports) 658 return std_req_stall; 659 port--; 660 p = &vhub->ports[port]; 661 662 switch(feat) { 663 case USB_PORT_FEAT_SUSPEND: 664 if (!(p->status & USB_PORT_STAT_ENABLE)) 665 return std_req_complete; 666 ast_vhub_change_port_stat(vhub, port, 667 0, USB_PORT_STAT_SUSPEND, 668 false); 669 ast_vhub_dev_suspend(&p->dev); 670 return std_req_complete; 671 case USB_PORT_FEAT_RESET: 672 EPDBG(ep, "Port reset !\n"); 673 ast_vhub_port_reset(vhub, port); 674 return std_req_complete; 675 case USB_PORT_FEAT_POWER: 676 /* 677 * On Power-on, we mark the connected flag changed, 678 * if there's a connected device, some hosts will 679 * otherwise fail to detect it. 680 */ 681 if (p->status & USB_PORT_STAT_CONNECTION) { 682 p->change |= USB_PORT_STAT_C_CONNECTION; 683 ast_vhub_update_hub_ep1(vhub, port); 684 } 685 return std_req_complete; 686 case USB_PORT_FEAT_TEST: 687 case USB_PORT_FEAT_INDICATOR: 688 /* We don't do anything with these */ 689 return std_req_complete; 690 } 691 return std_req_stall; 692 } 693 694 static enum std_req_rc ast_vhub_clr_port_feature(struct ast_vhub_ep *ep, 695 u8 port, u16 feat) 696 { 697 struct ast_vhub *vhub = ep->vhub; 698 struct ast_vhub_port *p; 699 700 if (port == 0 || port > vhub->max_ports) 701 return std_req_stall; 702 port--; 703 p = &vhub->ports[port]; 704 705 switch(feat) { 706 case USB_PORT_FEAT_ENABLE: 707 ast_vhub_change_port_stat(vhub, port, 708 USB_PORT_STAT_ENABLE | 709 USB_PORT_STAT_SUSPEND, 0, 710 false); 711 ast_vhub_dev_suspend(&p->dev); 712 return std_req_complete; 713 case USB_PORT_FEAT_SUSPEND: 714 if (!(p->status & USB_PORT_STAT_SUSPEND)) 715 return std_req_complete; 716 ast_vhub_change_port_stat(vhub, port, 717 USB_PORT_STAT_SUSPEND, 0, 718 false); 719 ast_vhub_dev_resume(&p->dev); 720 return std_req_complete; 721 case USB_PORT_FEAT_POWER: 722 /* We don't do power control */ 723 return std_req_complete; 724 case USB_PORT_FEAT_INDICATOR: 725 /* We don't have indicators */ 726 return std_req_complete; 727 case USB_PORT_FEAT_C_CONNECTION: 728 case USB_PORT_FEAT_C_ENABLE: 729 case USB_PORT_FEAT_C_SUSPEND: 730 case USB_PORT_FEAT_C_OVER_CURRENT: 731 case USB_PORT_FEAT_C_RESET: 732 /* Clear state-change feature */ 733 p->change &= ~(1u << (feat - 16)); 734 ast_vhub_update_hub_ep1(vhub, port); 735 return std_req_complete; 736 } 737 return std_req_stall; 738 } 739 740 static enum std_req_rc ast_vhub_get_port_stat(struct ast_vhub_ep *ep, 741 u8 port) 742 { 743 struct ast_vhub *vhub = ep->vhub; 744 u16 stat, chg; 745 746 if (port == 0 || port > vhub->max_ports) 747 return std_req_stall; 748 port--; 749 750 stat = vhub->ports[port].status; 751 chg = vhub->ports[port].change; 752 753 /* We always have power */ 754 stat |= USB_PORT_STAT_POWER; 755 756 EPDBG(ep, " port status=%04x change=%04x\n", stat, chg); 757 758 return ast_vhub_simple_reply(ep, 759 stat & 0xff, 760 stat >> 8, 761 chg & 0xff, 762 chg >> 8); 763 } 764 765 enum std_req_rc ast_vhub_class_hub_request(struct ast_vhub_ep *ep, 766 struct usb_ctrlrequest *crq) 767 { 768 u16 wValue, wIndex, wLength; 769 770 wValue = le16_to_cpu(crq->wValue); 771 wIndex = le16_to_cpu(crq->wIndex); 772 wLength = le16_to_cpu(crq->wLength); 773 774 switch ((crq->bRequestType << 8) | crq->bRequest) { 775 case GetHubStatus: 776 EPDBG(ep, "GetHubStatus\n"); 777 return ast_vhub_simple_reply(ep, 0, 0, 0, 0); 778 case GetPortStatus: 779 EPDBG(ep, "GetPortStatus(%d)\n", wIndex & 0xff); 780 return ast_vhub_get_port_stat(ep, wIndex & 0xf); 781 case GetHubDescriptor: 782 if (wValue != (USB_DT_HUB << 8)) 783 return std_req_stall; 784 EPDBG(ep, "GetHubDescriptor(%d)\n", wIndex & 0xff); 785 return ast_vhub_rep_desc(ep, USB_DT_HUB, wLength); 786 case SetHubFeature: 787 case ClearHubFeature: 788 EPDBG(ep, "Get/SetHubFeature(%d)\n", wValue); 789 /* No feature, just complete the requests */ 790 if (wValue == C_HUB_LOCAL_POWER || 791 wValue == C_HUB_OVER_CURRENT) 792 return std_req_complete; 793 return std_req_stall; 794 case SetPortFeature: 795 EPDBG(ep, "SetPortFeature(%d,%d)\n", wIndex & 0xf, wValue); 796 return ast_vhub_set_port_feature(ep, wIndex & 0xf, wValue); 797 case ClearPortFeature: 798 EPDBG(ep, "ClearPortFeature(%d,%d)\n", wIndex & 0xf, wValue); 799 return ast_vhub_clr_port_feature(ep, wIndex & 0xf, wValue); 800 case ClearTTBuffer: 801 case ResetTT: 802 case StopTT: 803 return std_req_complete; 804 case GetTTState: 805 return ast_vhub_simple_reply(ep, 0, 0, 0, 0); 806 default: 807 EPDBG(ep, "Unknown class request\n"); 808 } 809 return std_req_stall; 810 } 811 812 void ast_vhub_hub_suspend(struct ast_vhub *vhub) 813 { 814 unsigned int i; 815 816 UDCDBG(vhub, "USB bus suspend\n"); 817 818 if (vhub->suspended) 819 return; 820 821 vhub->suspended = true; 822 823 /* 824 * Forward to unsuspended ports without changing 825 * their connection status. 826 */ 827 for (i = 0; i < vhub->max_ports; i++) { 828 struct ast_vhub_port *p = &vhub->ports[i]; 829 830 if (!(p->status & USB_PORT_STAT_SUSPEND)) 831 ast_vhub_dev_suspend(&p->dev); 832 } 833 } 834 835 void ast_vhub_hub_resume(struct ast_vhub *vhub) 836 { 837 unsigned int i; 838 839 UDCDBG(vhub, "USB bus resume\n"); 840 841 if (!vhub->suspended) 842 return; 843 844 vhub->suspended = false; 845 846 /* 847 * Forward to unsuspended ports without changing 848 * their connection status. 849 */ 850 for (i = 0; i < vhub->max_ports; i++) { 851 struct ast_vhub_port *p = &vhub->ports[i]; 852 853 if (!(p->status & USB_PORT_STAT_SUSPEND)) 854 ast_vhub_dev_resume(&p->dev); 855 } 856 } 857 858 void ast_vhub_hub_reset(struct ast_vhub *vhub) 859 { 860 unsigned int i; 861 862 UDCDBG(vhub, "USB bus reset\n"); 863 864 /* 865 * Is the speed known ? If not we don't care, we aren't 866 * initialized yet and ports haven't been enabled. 867 */ 868 if (vhub->speed == USB_SPEED_UNKNOWN) 869 return; 870 871 /* We aren't suspended anymore obviously */ 872 vhub->suspended = false; 873 874 /* No speed set */ 875 vhub->speed = USB_SPEED_UNKNOWN; 876 877 /* Wakeup not enabled anymore */ 878 vhub->wakeup_en = false; 879 880 /* 881 * Clear all port status, disable gadgets and "suspend" 882 * them. They will be woken up by a port reset. 883 */ 884 for (i = 0; i < vhub->max_ports; i++) { 885 struct ast_vhub_port *p = &vhub->ports[i]; 886 887 /* Only keep the connected flag */ 888 p->status &= USB_PORT_STAT_CONNECTION; 889 p->change = 0; 890 891 /* Suspend the gadget if any */ 892 ast_vhub_dev_suspend(&p->dev); 893 } 894 895 /* Cleanup HW */ 896 writel(0, vhub->regs + AST_VHUB_CONF); 897 writel(0, vhub->regs + AST_VHUB_EP0_CTRL); 898 writel(VHUB_EP1_CTRL_RESET_TOGGLE | 899 VHUB_EP1_CTRL_ENABLE, 900 vhub->regs + AST_VHUB_EP1_CTRL); 901 writel(0, vhub->regs + AST_VHUB_EP1_STS_CHG); 902 } 903 904 static void ast_vhub_of_parse_dev_desc(struct ast_vhub *vhub, 905 const struct device_node *vhub_np) 906 { 907 u16 id; 908 u32 data; 909 910 if (!of_property_read_u32(vhub_np, "vhub-vendor-id", &data)) { 911 id = (u16)data; 912 vhub->vhub_dev_desc.idVendor = cpu_to_le16(id); 913 } 914 if (!of_property_read_u32(vhub_np, "vhub-product-id", &data)) { 915 id = (u16)data; 916 vhub->vhub_dev_desc.idProduct = cpu_to_le16(id); 917 } 918 if (!of_property_read_u32(vhub_np, "vhub-device-revision", &data)) { 919 id = (u16)data; 920 vhub->vhub_dev_desc.bcdDevice = cpu_to_le16(id); 921 } 922 } 923 924 static void ast_vhub_fixup_usb1_dev_desc(struct ast_vhub *vhub) 925 { 926 vhub->vhub_dev_desc.bcdUSB = cpu_to_le16(0x0100); 927 vhub->vhub_dev_desc.bDeviceProtocol = 0; 928 } 929 930 static struct usb_gadget_string_container* 931 ast_vhub_str_container_alloc(struct ast_vhub *vhub) 932 { 933 unsigned int size; 934 struct usb_string *str_array; 935 struct usb_gadget_strings *lang_str; 936 struct usb_gadget_string_container *container; 937 938 size = sizeof(*container); 939 size += sizeof(struct usb_gadget_strings); 940 size += sizeof(struct usb_string) * AST_VHUB_STR_INDEX_MAX; 941 container = devm_kzalloc(&vhub->pdev->dev, size, GFP_KERNEL); 942 if (!container) 943 return ERR_PTR(-ENOMEM); 944 945 lang_str = ast_vhub_str_of_container(container); 946 str_array = (struct usb_string *)(lang_str + 1); 947 lang_str->strings = str_array; 948 return container; 949 } 950 951 static void ast_vhub_str_deep_copy(struct usb_gadget_strings *dest, 952 const struct usb_gadget_strings *src) 953 { 954 struct usb_string *src_array = src->strings; 955 struct usb_string *dest_array = dest->strings; 956 957 dest->language = src->language; 958 if (src_array && dest_array) { 959 do { 960 *dest_array = *src_array; 961 dest_array++; 962 src_array++; 963 } while (src_array->s); 964 } 965 } 966 967 static int ast_vhub_str_alloc_add(struct ast_vhub *vhub, 968 const struct usb_gadget_strings *src_str) 969 { 970 struct usb_gadget_strings *dest_str; 971 struct usb_gadget_string_container *container; 972 973 container = ast_vhub_str_container_alloc(vhub); 974 if (IS_ERR(container)) 975 return PTR_ERR(container); 976 977 dest_str = ast_vhub_str_of_container(container); 978 ast_vhub_str_deep_copy(dest_str, src_str); 979 list_add_tail(&container->list, &vhub->vhub_str_desc); 980 981 return 0; 982 } 983 984 static const struct { 985 const char *name; 986 u8 id; 987 } str_id_map[] = { 988 {"manufacturer", AST_VHUB_STR_MANUF}, 989 {"product", AST_VHUB_STR_PRODUCT}, 990 {"serial-number", AST_VHUB_STR_SERIAL}, 991 {}, 992 }; 993 994 static int ast_vhub_of_parse_str_desc(struct ast_vhub *vhub, 995 const struct device_node *desc_np) 996 { 997 u32 langid; 998 int ret = 0; 999 int i, offset; 1000 const char *str; 1001 struct device_node *child; 1002 struct usb_string str_array[AST_VHUB_STR_INDEX_MAX]; 1003 struct usb_gadget_strings lang_str = { 1004 .strings = (struct usb_string *)str_array, 1005 }; 1006 1007 for_each_child_of_node(desc_np, child) { 1008 if (of_property_read_u32(child, "reg", &langid)) 1009 continue; /* no language identifier specified */ 1010 1011 if (!usb_validate_langid(langid)) 1012 continue; /* invalid language identifier */ 1013 1014 lang_str.language = langid; 1015 for (i = offset = 0; str_id_map[i].name; i++) { 1016 str = of_get_property(child, str_id_map[i].name, NULL); 1017 if (str) { 1018 str_array[offset].s = str; 1019 str_array[offset].id = str_id_map[i].id; 1020 offset++; 1021 } 1022 } 1023 str_array[offset].id = 0; 1024 str_array[offset].s = NULL; 1025 1026 ret = ast_vhub_str_alloc_add(vhub, &lang_str); 1027 if (ret) { 1028 of_node_put(child); 1029 break; 1030 } 1031 } 1032 1033 return ret; 1034 } 1035 1036 static int ast_vhub_init_desc(struct ast_vhub *vhub) 1037 { 1038 int ret; 1039 struct device_node *desc_np; 1040 const struct device_node *vhub_np = vhub->pdev->dev.of_node; 1041 1042 /* Initialize vhub Device Descriptor. */ 1043 memcpy(&vhub->vhub_dev_desc, &ast_vhub_dev_desc, 1044 sizeof(vhub->vhub_dev_desc)); 1045 ast_vhub_of_parse_dev_desc(vhub, vhub_np); 1046 if (vhub->force_usb1) 1047 ast_vhub_fixup_usb1_dev_desc(vhub); 1048 1049 /* Initialize vhub Configuration Descriptor. */ 1050 memcpy(&vhub->vhub_conf_desc, &ast_vhub_conf_desc, 1051 sizeof(vhub->vhub_conf_desc)); 1052 1053 /* Initialize vhub Hub Descriptor. */ 1054 memcpy(&vhub->vhub_hub_desc, &ast_vhub_hub_desc, 1055 sizeof(vhub->vhub_hub_desc)); 1056 vhub->vhub_hub_desc.bNbrPorts = vhub->max_ports; 1057 1058 /* Initialize vhub String Descriptors. */ 1059 INIT_LIST_HEAD(&vhub->vhub_str_desc); 1060 desc_np = of_get_child_by_name(vhub_np, "vhub-strings"); 1061 if (desc_np) { 1062 ret = ast_vhub_of_parse_str_desc(vhub, desc_np); 1063 of_node_put(desc_np); 1064 } 1065 else 1066 ret = ast_vhub_str_alloc_add(vhub, &ast_vhub_strings); 1067 1068 /* Initialize vhub Qualifier Descriptor. */ 1069 memcpy(&vhub->vhub_qual_desc, &ast_vhub_qual_desc, 1070 sizeof(vhub->vhub_qual_desc)); 1071 1072 return ret; 1073 } 1074 1075 int ast_vhub_init_hub(struct ast_vhub *vhub) 1076 { 1077 vhub->speed = USB_SPEED_UNKNOWN; 1078 INIT_WORK(&vhub->wake_work, ast_vhub_wake_work); 1079 1080 return ast_vhub_init_desc(vhub); 1081 } 1082