drivers/usb/gadget/udc/aspeed-vhub/hub.c

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