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