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