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

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget
   4  *
   5  * core.c - Top level support
   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
  33 #include "vhub.h"
  34
  35 void ast_vhub_done(struct ast_vhub_ep *ep, struct ast_vhub_req *req,
  36                    int status)
  37 {
  38         bool internal = req->internal;
  39
  40         EPVDBG(ep, "completing request @%p, status %d\n", req, status);
  41
  42         list_del_init(&req->queue);
  43
  44         if (req->req.status == -EINPROGRESS)
  45                 req->req.status = status;
  46
  47         if (req->req.dma) {
  48                 if (!WARN_ON(!ep->dev))
  49                         usb_gadget_unmap_request(&ep->dev->gadget,
  50                                                  &req->req, ep->epn.is_in);
  51                 req->req.dma = 0;
  52         }
  53
  54         /*
  55          * If this isn't an internal EP0 request, call the core
  56          * to call the gadget completion.
  57          */
  58         if (!internal) {
  59                 spin_unlock(&ep->vhub->lock);
  60                 usb_gadget_giveback_request(&ep->ep, &req->req);
  61                 spin_lock(&ep->vhub->lock);
  62         }
  63 }
  64
  65 void ast_vhub_nuke(struct ast_vhub_ep *ep, int status)
  66 {
  67         struct ast_vhub_req *req;
  68         int count = 0;
  69
  70         /* Beware, lock will be dropped & req-acquired by done() */
  71         while (!list_empty(&ep->queue)) {
  72                 req = list_first_entry(&ep->queue, struct ast_vhub_req, queue);
  73                 ast_vhub_done(ep, req, status);
  74                 count++;
  75         }
  76         if (count)
  77                 EPDBG(ep, "Nuked %d request(s)\n", count);
  78 }
  79
  80 struct usb_request *ast_vhub_alloc_request(struct usb_ep *u_ep,
  81                                            gfp_t gfp_flags)
  82 {
  83         struct ast_vhub_req *req;
  84
  85         req = kzalloc(sizeof(*req), gfp_flags);
  86         if (!req)
  87                 return NULL;
  88         return &req->req;
  89 }
  90
  91 void ast_vhub_free_request(struct usb_ep *u_ep, struct usb_request *u_req)
  92 {
  93         struct ast_vhub_req *req = to_ast_req(u_req);
  94
  95         kfree(req);
  96 }
  97
  98 static irqreturn_t ast_vhub_irq(int irq, void *data)
  99 {
 100         struct ast_vhub *vhub = data;
 101         irqreturn_t iret = IRQ_NONE;
 102         u32 i, istat;
 103
 104         /* Stale interrupt while tearing down */
 105         if (!vhub->ep0_bufs)
 106                 return IRQ_NONE;
 107
 108         spin_lock(&vhub->lock);
 109
 110         /* Read and ACK interrupts */
 111         istat = readl(vhub->regs + AST_VHUB_ISR);
 112         if (!istat)
 113                 goto bail;
 114         writel(istat, vhub->regs + AST_VHUB_ISR);
 115         iret = IRQ_HANDLED;
 116
 117         UDCVDBG(vhub, "irq status=%08x, ep_acks=%08x ep_nacks=%08x\n",
 118                istat,
 119                readl(vhub->regs + AST_VHUB_EP_ACK_ISR),
 120                readl(vhub->regs + AST_VHUB_EP_NACK_ISR));
 121
 122         /* Handle generic EPs first */
 123         if (istat & VHUB_IRQ_EP_POOL_ACK_STALL) {
 124                 u32 ep_acks = readl(vhub->regs + AST_VHUB_EP_ACK_ISR);
 125                 writel(ep_acks, vhub->regs + AST_VHUB_EP_ACK_ISR);
 126
 127                 for (i = 0; ep_acks && i < vhub->max_epns; i++) {
 128                         u32 mask = VHUB_EP_IRQ(i);
 129                         if (ep_acks & mask) {
 130                                 ast_vhub_epn_ack_irq(&vhub->epns[i]);
 131                                 ep_acks &= ~mask;
 132                         }
 133                 }
 134         }
 135
 136         /* Handle device interrupts */
 137         if (istat & vhub->port_irq_mask) {
 138                 for (i = 0; i < vhub->max_ports; i++) {
 139                         if (istat & VHUB_DEV_IRQ(i))
 140                                 ast_vhub_dev_irq(&vhub->ports[i].dev);
 141                 }
 142         }
 143
 144         /* Handle top-level vHub EP0 interrupts */
 145         if (istat & (VHUB_IRQ_HUB_EP0_OUT_ACK_STALL |
 146                      VHUB_IRQ_HUB_EP0_IN_ACK_STALL |
 147                      VHUB_IRQ_HUB_EP0_SETUP)) {
 148                 if (istat & VHUB_IRQ_HUB_EP0_IN_ACK_STALL)
 149                         ast_vhub_ep0_handle_ack(&vhub->ep0, true);
 150                 if (istat & VHUB_IRQ_HUB_EP0_OUT_ACK_STALL)
 151                         ast_vhub_ep0_handle_ack(&vhub->ep0, false);
 152                 if (istat & VHUB_IRQ_HUB_EP0_SETUP)
 153                         ast_vhub_ep0_handle_setup(&vhub->ep0);
 154         }
 155
 156         /* Various top level bus events */
 157         if (istat & (VHUB_IRQ_BUS_RESUME |
 158                      VHUB_IRQ_BUS_SUSPEND |
 159                      VHUB_IRQ_BUS_RESET)) {
 160                 if (istat & VHUB_IRQ_BUS_RESUME)
 161                         ast_vhub_hub_resume(vhub);
 162                 if (istat & VHUB_IRQ_BUS_SUSPEND)
 163                         ast_vhub_hub_suspend(vhub);
 164                 if (istat & VHUB_IRQ_BUS_RESET)
 165                         ast_vhub_hub_reset(vhub);
 166         }
 167
 168  bail:
 169         spin_unlock(&vhub->lock);
 170         return iret;
 171 }
 172
 173 void ast_vhub_init_hw(struct ast_vhub *vhub)
 174 {
 175         u32 ctrl, port_mask, epn_mask;
 176
 177         UDCDBG(vhub,"(Re)Starting HW ...\n");
 178
 179         /* Enable PHY */
 180         ctrl = VHUB_CTRL_PHY_CLK |
 181                 VHUB_CTRL_PHY_RESET_DIS;
 182
 183        /*
 184         * We do *NOT* set the VHUB_CTRL_CLK_STOP_SUSPEND bit
 185         * to stop the logic clock during suspend because
 186         * it causes the registers to become inaccessible and
 187         * we haven't yet figured out a good wayt to bring the
 188         * controller back into life to issue a wakeup.
 189         */
 190
 191         /*
 192          * Set some ISO & split control bits according to Aspeed
 193          * recommendation
 194          *
 195          * VHUB_CTRL_ISO_RSP_CTRL: When set tells the HW to respond
 196          * with 0 bytes data packet to ISO IN endpoints when no data
 197          * is available.
 198          *
 199          * VHUB_CTRL_SPLIT_IN: This makes a SOF complete a split IN
 200          * transaction.
 201          */
 202         ctrl |= VHUB_CTRL_ISO_RSP_CTRL | VHUB_CTRL_SPLIT_IN;
 203         writel(ctrl, vhub->regs + AST_VHUB_CTRL);
 204         udelay(1);
 205
 206         /* Set descriptor ring size */
 207         if (AST_VHUB_DESCS_COUNT == 256) {
 208                 ctrl |= VHUB_CTRL_LONG_DESC;
 209                 writel(ctrl, vhub->regs + AST_VHUB_CTRL);
 210         } else {
 211                 BUILD_BUG_ON(AST_VHUB_DESCS_COUNT != 32);
 212         }
 213
 214         /* Reset all devices */
 215         port_mask = GENMASK(vhub->max_ports, 1);
 216         writel(VHUB_SW_RESET_ROOT_HUB |
 217                VHUB_SW_RESET_DMA_CONTROLLER |
 218                VHUB_SW_RESET_EP_POOL |
 219                port_mask, vhub->regs + AST_VHUB_SW_RESET);
 220         udelay(1);
 221         writel(0, vhub->regs + AST_VHUB_SW_RESET);
 222
 223         /* Disable and cleanup EP ACK/NACK interrupts */
 224         epn_mask = GENMASK(vhub->max_epns - 1, 0);
 225         writel(0, vhub->regs + AST_VHUB_EP_ACK_IER);
 226         writel(0, vhub->regs + AST_VHUB_EP_NACK_IER);
 227         writel(epn_mask, vhub->regs + AST_VHUB_EP_ACK_ISR);
 228         writel(epn_mask, vhub->regs + AST_VHUB_EP_NACK_ISR);
 229
 230         /* Default settings for EP0, enable HW hub EP1 */
 231         writel(0, vhub->regs + AST_VHUB_EP0_CTRL);
 232         writel(VHUB_EP1_CTRL_RESET_TOGGLE |
 233                VHUB_EP1_CTRL_ENABLE,
 234                vhub->regs + AST_VHUB_EP1_CTRL);
 235         writel(0, vhub->regs + AST_VHUB_EP1_STS_CHG);
 236
 237         /* Configure EP0 DMA buffer */
 238         writel(vhub->ep0.buf_dma, vhub->regs + AST_VHUB_EP0_DATA);
 239
 240         /* Clear address */
 241         writel(0, vhub->regs + AST_VHUB_CONF);
 242
 243         /* Pullup hub (activate on host) */
 244         if (vhub->force_usb1)
 245                 ctrl |= VHUB_CTRL_FULL_SPEED_ONLY;
 246
 247         ctrl |= VHUB_CTRL_UPSTREAM_CONNECT;
 248         writel(ctrl, vhub->regs + AST_VHUB_CTRL);
 249
 250         /* Enable some interrupts */
 251         writel(VHUB_IRQ_HUB_EP0_IN_ACK_STALL |
 252                VHUB_IRQ_HUB_EP0_OUT_ACK_STALL |
 253                VHUB_IRQ_HUB_EP0_SETUP |
 254                VHUB_IRQ_EP_POOL_ACK_STALL |
 255                VHUB_IRQ_BUS_RESUME |
 256                VHUB_IRQ_BUS_SUSPEND |
 257                VHUB_IRQ_BUS_RESET,
 258                vhub->regs + AST_VHUB_IER);
 259 }
 260
 261 static int ast_vhub_remove(struct platform_device *pdev)
 262 {
 263         struct ast_vhub *vhub = platform_get_drvdata(pdev);
 264         unsigned long flags;
 265         int i;
 266
 267         if (!vhub || !vhub->regs)
 268                 return 0;
 269
 270         /* Remove devices */
 271         for (i = 0; i < vhub->max_ports; i++)
 272                 ast_vhub_del_dev(&vhub->ports[i].dev);
 273
 274         spin_lock_irqsave(&vhub->lock, flags);
 275
 276         /* Mask & ack all interrupts  */
 277         writel(0, vhub->regs + AST_VHUB_IER);
 278         writel(VHUB_IRQ_ACK_ALL, vhub->regs + AST_VHUB_ISR);
 279
 280         /* Pull device, leave PHY enabled */
 281         writel(VHUB_CTRL_PHY_CLK |
 282                VHUB_CTRL_PHY_RESET_DIS,
 283                vhub->regs + AST_VHUB_CTRL);
 284
 285         if (vhub->clk)
 286                 clk_disable_unprepare(vhub->clk);
 287
 288         spin_unlock_irqrestore(&vhub->lock, flags);
 289
 290         if (vhub->ep0_bufs)
 291                 dma_free_coherent(&pdev->dev,
 292                                   AST_VHUB_EP0_MAX_PACKET *
 293                                   (vhub->max_ports + 1),
 294                                   vhub->ep0_bufs,
 295                                   vhub->ep0_bufs_dma);
 296         vhub->ep0_bufs = NULL;
 297
 298         return 0;
 299 }
 300
 301 static int ast_vhub_probe(struct platform_device *pdev)
 302 {
 303         enum usb_device_speed max_speed;
 304         struct ast_vhub *vhub;
 305         struct resource *res;
 306         int i, rc = 0;
 307         const struct device_node *np = pdev->dev.of_node;
 308
 309         vhub = devm_kzalloc(&pdev->dev, sizeof(*vhub), GFP_KERNEL);
 310         if (!vhub)
 311                 return -ENOMEM;
 312
 313         rc = of_property_read_u32(np, "aspeed,vhub-downstream-ports",
 314                                   &vhub->max_ports);
 315         if (rc < 0)
 316                 vhub->max_ports = AST_VHUB_NUM_PORTS;
 317
 318         vhub->ports = devm_kcalloc(&pdev->dev, vhub->max_ports,
 319                                    sizeof(*vhub->ports), GFP_KERNEL);
 320         if (!vhub->ports)
 321                 return -ENOMEM;
 322
 323         rc = of_property_read_u32(np, "aspeed,vhub-generic-endpoints",
 324                                   &vhub->max_epns);
 325         if (rc < 0)
 326                 vhub->max_epns = AST_VHUB_NUM_GEN_EPs;
 327
 328         vhub->epns = devm_kcalloc(&pdev->dev, vhub->max_epns,
 329                                   sizeof(*vhub->epns), GFP_KERNEL);
 330         if (!vhub->epns)
 331                 return -ENOMEM;
 332
 333         spin_lock_init(&vhub->lock);
 334         vhub->pdev = pdev;
 335         vhub->port_irq_mask = GENMASK(VHUB_IRQ_DEV1_BIT + vhub->max_ports - 1,
 336                                       VHUB_IRQ_DEV1_BIT);
 337
 338         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 339         vhub->regs = devm_ioremap_resource(&pdev->dev, res);
 340         if (IS_ERR(vhub->regs)) {
 341                 dev_err(&pdev->dev, "Failed to map resources\n");
 342                 return PTR_ERR(vhub->regs);
 343         }
 344         UDCDBG(vhub, "vHub@%pR mapped @%p\n", res, vhub->regs);
 345
 346         platform_set_drvdata(pdev, vhub);
 347
 348         vhub->clk = devm_clk_get(&pdev->dev, NULL);
 349         if (IS_ERR(vhub->clk)) {
 350                 rc = PTR_ERR(vhub->clk);
 351                 goto err;
 352         }
 353         rc = clk_prepare_enable(vhub->clk);
 354         if (rc) {
 355                 dev_err(&pdev->dev, "Error couldn't enable clock (%d)\n", rc);
 356                 goto err;
 357         }
 358
 359         /* Check if we need to limit the HW to USB1 */
 360         max_speed = usb_get_maximum_speed(&pdev->dev);
 361         if (max_speed != USB_SPEED_UNKNOWN && max_speed < USB_SPEED_HIGH)
 362                 vhub->force_usb1 = true;
 363
 364         /* Mask & ack all interrupts before installing the handler */
 365         writel(0, vhub->regs + AST_VHUB_IER);
 366         writel(VHUB_IRQ_ACK_ALL, vhub->regs + AST_VHUB_ISR);
 367
 368         /* Find interrupt and install handler */
 369         vhub->irq = platform_get_irq(pdev, 0);
 370         if (vhub->irq < 0) {
 371                 rc = vhub->irq;
 372                 goto err;
 373         }
 374         rc = devm_request_irq(&pdev->dev, vhub->irq, ast_vhub_irq, 0,
 375                               KBUILD_MODNAME, vhub);
 376         if (rc) {
 377                 dev_err(&pdev->dev, "Failed to request interrupt\n");
 378                 goto err;
 379         }
 380
 381         /*
 382          * Allocate DMA buffers for all EP0s in one chunk,
 383          * one per port and one for the vHub itself
 384          */
 385         vhub->ep0_bufs = dma_alloc_coherent(&pdev->dev,
 386                                             AST_VHUB_EP0_MAX_PACKET *
 387                                             (vhub->max_ports + 1),
 388                                             &vhub->ep0_bufs_dma, GFP_KERNEL);
 389         if (!vhub->ep0_bufs) {
 390                 dev_err(&pdev->dev, "Failed to allocate EP0 DMA buffers\n");
 391                 rc = -ENOMEM;
 392                 goto err;
 393         }
 394         UDCVDBG(vhub, "EP0 DMA buffers @%p (DMA 0x%08x)\n",
 395                 vhub->ep0_bufs, (u32)vhub->ep0_bufs_dma);
 396
 397         /* Init vHub EP0 */
 398         ast_vhub_init_ep0(vhub, &vhub->ep0, NULL);
 399
 400         /* Init devices */
 401         for (i = 0; i < vhub->max_ports && rc == 0; i++)
 402                 rc = ast_vhub_init_dev(vhub, i);
 403         if (rc)
 404                 goto err;
 405
 406         /* Init hub emulation */
 407         rc = ast_vhub_init_hub(vhub);
 408         if (rc)
 409                 goto err;
 410
 411         /* Initialize HW */
 412         ast_vhub_init_hw(vhub);
 413
 414         dev_info(&pdev->dev, "Initialized virtual hub in USB%d mode\n",
 415                  vhub->force_usb1 ? 1 : 2);
 416
 417         return 0;
 418  err:
 419         ast_vhub_remove(pdev);
 420         return rc;
 421 }
 422
 423 static const struct of_device_id ast_vhub_dt_ids[] = {
 424         {
 425                 .compatible = "aspeed,ast2400-usb-vhub",
 426         },
 427         {
 428                 .compatible = "aspeed,ast2500-usb-vhub",
 429         },
 430         {
 431                 .compatible = "aspeed,ast2600-usb-vhub",
 432         },
 433         { }
 434 };
 435 MODULE_DEVICE_TABLE(of, ast_vhub_dt_ids);
 436
 437 static struct platform_driver ast_vhub_driver = {
 438         .probe          = ast_vhub_probe,
 439         .remove         = ast_vhub_remove,
 440         .driver         = {
 441                 .name   = KBUILD_MODNAME,
 442                 .of_match_table = ast_vhub_dt_ids,
 443         },
 444 };
 445 module_platform_driver(ast_vhub_driver);
 446
 447 MODULE_DESCRIPTION("Aspeed vHub udc driver");
 448 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
 449 MODULE_LICENSE("GPL");