1 // SPDX-License-Identifier: GPL-2.0+
3 * aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget
5 * core.c - Top level support
7 * Copyright 2017 IBM Corporation
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.
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>
29 #include <linux/of_gpio.h>
30 #include <linux/regmap.h>
31 #include <linux/dma-mapping.h>
35 void ast_vhub_done(struct ast_vhub_ep *ep, struct ast_vhub_req *req,
38 bool internal = req->internal;
39 struct ast_vhub *vhub = ep->vhub;
41 EPVDBG(ep, "completing request @%p, status %d\n", req, status);
43 list_del_init(&req->queue);
45 if (req->req.status == -EINPROGRESS)
46 req->req.status = status;
49 if (!WARN_ON(!ep->dev))
50 usb_gadget_unmap_request_by_dev(&vhub->pdev->dev,
51 &req->req, ep->epn.is_in);
56 * If this isn't an internal EP0 request, call the core
57 * to call the gadget completion.
60 spin_unlock(&ep->vhub->lock);
61 usb_gadget_giveback_request(&ep->ep, &req->req);
62 spin_lock(&ep->vhub->lock);
66 void ast_vhub_nuke(struct ast_vhub_ep *ep, int status)
68 struct ast_vhub_req *req;
70 EPDBG(ep, "Nuking\n");
72 /* Beware, lock will be dropped & req-acquired by done() */
73 while (!list_empty(&ep->queue)) {
74 req = list_first_entry(&ep->queue, struct ast_vhub_req, queue);
75 ast_vhub_done(ep, req, status);
79 struct usb_request *ast_vhub_alloc_request(struct usb_ep *u_ep,
82 struct ast_vhub_req *req;
84 req = kzalloc(sizeof(*req), gfp_flags);
90 void ast_vhub_free_request(struct usb_ep *u_ep, struct usb_request *u_req)
92 struct ast_vhub_req *req = to_ast_req(u_req);
97 static irqreturn_t ast_vhub_irq(int irq, void *data)
99 struct ast_vhub *vhub = data;
100 irqreturn_t iret = IRQ_NONE;
103 /* Stale interrupt while tearing down */
107 spin_lock(&vhub->lock);
109 /* Read and ACK interrupts */
110 istat = readl(vhub->regs + AST_VHUB_ISR);
113 writel(istat, vhub->regs + AST_VHUB_ISR);
116 UDCVDBG(vhub, "irq status=%08x, ep_acks=%08x ep_nacks=%08x\n",
118 readl(vhub->regs + AST_VHUB_EP_ACK_ISR),
119 readl(vhub->regs + AST_VHUB_EP_NACK_ISR));
121 /* Handle generic EPs first */
122 if (istat & VHUB_IRQ_EP_POOL_ACK_STALL) {
123 u32 i, ep_acks = readl(vhub->regs + AST_VHUB_EP_ACK_ISR);
124 writel(ep_acks, vhub->regs + AST_VHUB_EP_ACK_ISR);
126 for (i = 0; ep_acks && i < AST_VHUB_NUM_GEN_EPs; i++) {
127 u32 mask = VHUB_EP_IRQ(i);
128 if (ep_acks & mask) {
129 ast_vhub_epn_ack_irq(&vhub->epns[i]);
135 /* Handle device interrupts */
136 if (istat & (VHUB_IRQ_DEVICE1 |
141 if (istat & VHUB_IRQ_DEVICE1)
142 ast_vhub_dev_irq(&vhub->ports[0].dev);
143 if (istat & VHUB_IRQ_DEVICE2)
144 ast_vhub_dev_irq(&vhub->ports[1].dev);
145 if (istat & VHUB_IRQ_DEVICE3)
146 ast_vhub_dev_irq(&vhub->ports[2].dev);
147 if (istat & VHUB_IRQ_DEVICE4)
148 ast_vhub_dev_irq(&vhub->ports[3].dev);
149 if (istat & VHUB_IRQ_DEVICE5)
150 ast_vhub_dev_irq(&vhub->ports[4].dev);
153 /* Handle top-level vHub EP0 interrupts */
154 if (istat & (VHUB_IRQ_HUB_EP0_OUT_ACK_STALL |
155 VHUB_IRQ_HUB_EP0_IN_ACK_STALL |
156 VHUB_IRQ_HUB_EP0_SETUP)) {
157 if (istat & VHUB_IRQ_HUB_EP0_IN_ACK_STALL)
158 ast_vhub_ep0_handle_ack(&vhub->ep0, true);
159 if (istat & VHUB_IRQ_HUB_EP0_OUT_ACK_STALL)
160 ast_vhub_ep0_handle_ack(&vhub->ep0, false);
161 if (istat & VHUB_IRQ_HUB_EP0_SETUP)
162 ast_vhub_ep0_handle_setup(&vhub->ep0);
165 /* Various top level bus events */
166 if (istat & (VHUB_IRQ_BUS_RESUME |
167 VHUB_IRQ_BUS_SUSPEND |
168 VHUB_IRQ_BUS_RESET)) {
169 if (istat & VHUB_IRQ_BUS_RESUME)
170 ast_vhub_hub_resume(vhub);
171 if (istat & VHUB_IRQ_BUS_SUSPEND)
172 ast_vhub_hub_suspend(vhub);
173 if (istat & VHUB_IRQ_BUS_RESET)
174 ast_vhub_hub_reset(vhub);
178 spin_unlock(&vhub->lock);
182 void ast_vhub_init_hw(struct ast_vhub *vhub)
186 UDCDBG(vhub,"(Re)Starting HW ...\n");
189 ctrl = VHUB_CTRL_PHY_CLK |
190 VHUB_CTRL_PHY_RESET_DIS;
193 * We do *NOT* set the VHUB_CTRL_CLK_STOP_SUSPEND bit
194 * to stop the logic clock during suspend because
195 * it causes the registers to become inaccessible and
196 * we haven't yet figured out a good wayt to bring the
197 * controller back into life to issue a wakeup.
201 * Set some ISO & split control bits according to Aspeed
204 * VHUB_CTRL_ISO_RSP_CTRL: When set tells the HW to respond
205 * with 0 bytes data packet to ISO IN endpoints when no data
208 * VHUB_CTRL_SPLIT_IN: This makes a SOF complete a split IN
211 ctrl |= VHUB_CTRL_ISO_RSP_CTRL | VHUB_CTRL_SPLIT_IN;
212 writel(ctrl, vhub->regs + AST_VHUB_CTRL);
215 /* Set descriptor ring size */
216 if (AST_VHUB_DESCS_COUNT == 256) {
217 ctrl |= VHUB_CTRL_LONG_DESC;
218 writel(ctrl, vhub->regs + AST_VHUB_CTRL);
220 BUILD_BUG_ON(AST_VHUB_DESCS_COUNT != 32);
223 /* Reset all devices */
224 writel(VHUB_SW_RESET_ALL, vhub->regs + AST_VHUB_SW_RESET);
226 writel(0, vhub->regs + AST_VHUB_SW_RESET);
228 /* Disable and cleanup EP ACK/NACK interrupts */
229 writel(0, vhub->regs + AST_VHUB_EP_ACK_IER);
230 writel(0, vhub->regs + AST_VHUB_EP_NACK_IER);
231 writel(VHUB_EP_IRQ_ALL, vhub->regs + AST_VHUB_EP_ACK_ISR);
232 writel(VHUB_EP_IRQ_ALL, vhub->regs + AST_VHUB_EP_NACK_ISR);
234 /* Default settings for EP0, enable HW hub EP1 */
235 writel(0, vhub->regs + AST_VHUB_EP0_CTRL);
236 writel(VHUB_EP1_CTRL_RESET_TOGGLE |
237 VHUB_EP1_CTRL_ENABLE,
238 vhub->regs + AST_VHUB_EP1_CTRL);
239 writel(0, vhub->regs + AST_VHUB_EP1_STS_CHG);
241 /* Configure EP0 DMA buffer */
242 writel(vhub->ep0.buf_dma, vhub->regs + AST_VHUB_EP0_DATA);
245 writel(0, vhub->regs + AST_VHUB_CONF);
247 /* Pullup hub (activate on host) */
248 if (vhub->force_usb1)
249 ctrl |= VHUB_CTRL_FULL_SPEED_ONLY;
251 ctrl |= VHUB_CTRL_UPSTREAM_CONNECT;
252 writel(ctrl, vhub->regs + AST_VHUB_CTRL);
254 /* Enable some interrupts */
255 writel(VHUB_IRQ_HUB_EP0_IN_ACK_STALL |
256 VHUB_IRQ_HUB_EP0_OUT_ACK_STALL |
257 VHUB_IRQ_HUB_EP0_SETUP |
258 VHUB_IRQ_EP_POOL_ACK_STALL |
259 VHUB_IRQ_BUS_RESUME |
260 VHUB_IRQ_BUS_SUSPEND |
262 vhub->regs + AST_VHUB_IER);
265 static int ast_vhub_remove(struct platform_device *pdev)
267 struct ast_vhub *vhub = platform_get_drvdata(pdev);
271 if (!vhub || !vhub->regs)
275 for (i = 0; i < AST_VHUB_NUM_PORTS; i++)
276 ast_vhub_del_dev(&vhub->ports[i].dev);
278 spin_lock_irqsave(&vhub->lock, flags);
280 /* Mask & ack all interrupts */
281 writel(0, vhub->regs + AST_VHUB_IER);
282 writel(VHUB_IRQ_ACK_ALL, vhub->regs + AST_VHUB_ISR);
284 /* Pull device, leave PHY enabled */
285 writel(VHUB_CTRL_PHY_CLK |
286 VHUB_CTRL_PHY_RESET_DIS,
287 vhub->regs + AST_VHUB_CTRL);
290 clk_disable_unprepare(vhub->clk);
292 spin_unlock_irqrestore(&vhub->lock, flags);
295 dma_free_coherent(&pdev->dev,
296 AST_VHUB_EP0_MAX_PACKET *
297 (AST_VHUB_NUM_PORTS + 1),
300 vhub->ep0_bufs = NULL;
305 static int ast_vhub_probe(struct platform_device *pdev)
307 enum usb_device_speed max_speed;
308 struct ast_vhub *vhub;
309 struct resource *res;
312 vhub = devm_kzalloc(&pdev->dev, sizeof(*vhub), GFP_KERNEL);
316 spin_lock_init(&vhub->lock);
319 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
320 vhub->regs = devm_ioremap_resource(&pdev->dev, res);
321 if (IS_ERR(vhub->regs)) {
322 dev_err(&pdev->dev, "Failed to map resources\n");
323 return PTR_ERR(vhub->regs);
325 UDCDBG(vhub, "vHub@%pR mapped @%p\n", res, vhub->regs);
327 platform_set_drvdata(pdev, vhub);
329 vhub->clk = devm_clk_get(&pdev->dev, NULL);
330 if (IS_ERR(vhub->clk)) {
331 rc = PTR_ERR(vhub->clk);
334 rc = clk_prepare_enable(vhub->clk);
336 dev_err(&pdev->dev, "Error couldn't enable clock (%d)\n", rc);
340 /* Check if we need to limit the HW to USB1 */
341 max_speed = usb_get_maximum_speed(&pdev->dev);
342 if (max_speed != USB_SPEED_UNKNOWN && max_speed < USB_SPEED_HIGH)
343 vhub->force_usb1 = true;
345 /* Mask & ack all interrupts before installing the handler */
346 writel(0, vhub->regs + AST_VHUB_IER);
347 writel(VHUB_IRQ_ACK_ALL, vhub->regs + AST_VHUB_ISR);
349 /* Find interrupt and install handler */
350 vhub->irq = platform_get_irq(pdev, 0);
352 dev_err(&pdev->dev, "Failed to get interrupt\n");
356 rc = devm_request_irq(&pdev->dev, vhub->irq, ast_vhub_irq, 0,
357 KBUILD_MODNAME, vhub);
359 dev_err(&pdev->dev, "Failed to request interrupt\n");
364 * Allocate DMA buffers for all EP0s in one chunk,
365 * one per port and one for the vHub itself
367 vhub->ep0_bufs = dma_alloc_coherent(&pdev->dev,
368 AST_VHUB_EP0_MAX_PACKET *
369 (AST_VHUB_NUM_PORTS + 1),
370 &vhub->ep0_bufs_dma, GFP_KERNEL);
371 if (!vhub->ep0_bufs) {
372 dev_err(&pdev->dev, "Failed to allocate EP0 DMA buffers\n");
376 UDCVDBG(vhub, "EP0 DMA buffers @%p (DMA 0x%08x)\n",
377 vhub->ep0_bufs, (u32)vhub->ep0_bufs_dma);
380 ast_vhub_init_ep0(vhub, &vhub->ep0, NULL);
383 for (i = 0; i < AST_VHUB_NUM_PORTS && rc == 0; i++)
384 rc = ast_vhub_init_dev(vhub, i);
388 /* Init hub emulation */
389 ast_vhub_init_hub(vhub);
392 ast_vhub_init_hw(vhub);
394 dev_info(&pdev->dev, "Initialized virtual hub in USB%d mode\n",
395 vhub->force_usb1 ? 1 : 2);
399 ast_vhub_remove(pdev);
403 static const struct of_device_id ast_vhub_dt_ids[] = {
405 .compatible = "aspeed,ast2400-usb-vhub",
408 .compatible = "aspeed,ast2500-usb-vhub",
412 MODULE_DEVICE_TABLE(of, ast_vhub_dt_ids);
414 static struct platform_driver ast_vhub_driver = {
415 .probe = ast_vhub_probe,
416 .remove = ast_vhub_remove,
418 .name = KBUILD_MODNAME,
419 .of_match_table = ast_vhub_dt_ids,
422 module_platform_driver(ast_vhub_driver);
424 MODULE_DESCRIPTION("Aspeed vHub udc driver");
425 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
426 MODULE_LICENSE("GPL");