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