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