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

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

DEFINITIONS
