1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Generic UHCI HCD (Host Controller Driver) for Platform Devices
4  *
5  * Copyright (c) 2011 Tony Prisk <linux@prisktech.co.nz>
6  *
7  * This file is based on uhci-grlib.c
8  * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
9  */
10 
11 #include <linux/of.h>
12 #include <linux/device.h>
13 #include <linux/platform_device.h>
14 
uhci_platform_init(struct usb_hcd * hcd)15 static int uhci_platform_init(struct usb_hcd *hcd)
16 {
17 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
18 
19 	/* Probe number of ports if not already provided by DT */
20 	if (!uhci->rh_numports)
21 		uhci->rh_numports = uhci_count_ports(hcd);
22 
23 	/* Set up pointers to to generic functions */
24 	uhci->reset_hc = uhci_generic_reset_hc;
25 	uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
26 
27 	/* No special actions need to be taken for the functions below */
28 	uhci->configure_hc = NULL;
29 	uhci->resume_detect_interrupts_are_broken = NULL;
30 	uhci->global_suspend_mode_is_broken = NULL;
31 
32 	/* Reset if the controller isn't already safely quiescent. */
33 	check_and_reset_hc(uhci);
34 	return 0;
35 }
36 
37 static const struct hc_driver uhci_platform_hc_driver = {
38 	.description =		hcd_name,
39 	.product_desc =		"Generic UHCI Host Controller",
40 	.hcd_priv_size =	sizeof(struct uhci_hcd),
41 
42 	/* Generic hardware linkage */
43 	.irq =			uhci_irq,
44 	.flags =		HCD_MEMORY | HCD_DMA | HCD_USB11,
45 
46 	/* Basic lifecycle operations */
47 	.reset =		uhci_platform_init,
48 	.start =		uhci_start,
49 #ifdef CONFIG_PM
50 	.pci_suspend =		NULL,
51 	.pci_resume =		NULL,
52 	.bus_suspend =		uhci_rh_suspend,
53 	.bus_resume =		uhci_rh_resume,
54 #endif
55 	.stop =			uhci_stop,
56 
57 	.urb_enqueue =		uhci_urb_enqueue,
58 	.urb_dequeue =		uhci_urb_dequeue,
59 
60 	.endpoint_disable =	uhci_hcd_endpoint_disable,
61 	.get_frame_number =	uhci_hcd_get_frame_number,
62 
63 	.hub_status_data =	uhci_hub_status_data,
64 	.hub_control =		uhci_hub_control,
65 };
66 
uhci_hcd_platform_probe(struct platform_device * pdev)67 static int uhci_hcd_platform_probe(struct platform_device *pdev)
68 {
69 	struct device_node *np = pdev->dev.of_node;
70 	struct usb_hcd *hcd;
71 	struct uhci_hcd	*uhci;
72 	struct resource *res;
73 	int ret;
74 
75 	if (usb_disabled())
76 		return -ENODEV;
77 
78 	/*
79 	 * Right now device-tree probed devices don't get dma_mask set.
80 	 * Since shared usb code relies on it, set it here for now.
81 	 * Once we have dma capability bindings this can go away.
82 	 */
83 	ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
84 	if (ret)
85 		return ret;
86 
87 	hcd = usb_create_hcd(&uhci_platform_hc_driver, &pdev->dev,
88 			pdev->name);
89 	if (!hcd)
90 		return -ENOMEM;
91 
92 	uhci = hcd_to_uhci(hcd);
93 
94 	hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
95 	if (IS_ERR(hcd->regs)) {
96 		ret = PTR_ERR(hcd->regs);
97 		goto err_rmr;
98 	}
99 	hcd->rsrc_start = res->start;
100 	hcd->rsrc_len = resource_size(res);
101 
102 	uhci->regs = hcd->regs;
103 
104 	/* Grab some things from the device-tree */
105 	if (np) {
106 		u32 num_ports;
107 
108 		if (of_property_read_u32(np, "#ports", &num_ports) == 0) {
109 			uhci->rh_numports = num_ports;
110 			dev_info(&pdev->dev,
111 				"Detected %d ports from device-tree\n",
112 				num_ports);
113 		}
114 		if (of_device_is_compatible(np, "aspeed,ast2400-uhci") ||
115 		    of_device_is_compatible(np, "aspeed,ast2500-uhci") ||
116 		    of_device_is_compatible(np, "aspeed,ast2600-uhci")) {
117 			uhci->is_aspeed = 1;
118 			dev_info(&pdev->dev,
119 				 "Enabled Aspeed implementation workarounds\n");
120 		}
121 	}
122 
123 	/* Get and enable clock if any specified */
124 	uhci->clk = devm_clk_get(&pdev->dev, NULL);
125 	if (IS_ERR(uhci->clk)) {
126 		ret = PTR_ERR(uhci->clk);
127 		goto err_rmr;
128 	}
129 	ret = clk_prepare_enable(uhci->clk);
130 	if (ret) {
131 		dev_err(&pdev->dev, "Error couldn't enable clock (%d)\n", ret);
132 		goto err_rmr;
133 	}
134 
135 	ret = platform_get_irq(pdev, 0);
136 	if (ret < 0)
137 		goto err_clk;
138 
139 	ret = usb_add_hcd(hcd, ret, IRQF_SHARED);
140 	if (ret)
141 		goto err_clk;
142 
143 	device_wakeup_enable(hcd->self.controller);
144 	return 0;
145 
146 err_clk:
147 	clk_disable_unprepare(uhci->clk);
148 err_rmr:
149 	usb_put_hcd(hcd);
150 
151 	return ret;
152 }
153 
uhci_hcd_platform_remove(struct platform_device * pdev)154 static void uhci_hcd_platform_remove(struct platform_device *pdev)
155 {
156 	struct usb_hcd *hcd = platform_get_drvdata(pdev);
157 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
158 
159 	clk_disable_unprepare(uhci->clk);
160 	usb_remove_hcd(hcd);
161 	usb_put_hcd(hcd);
162 }
163 
164 /* Make sure the controller is quiescent and that we're not using it
165  * any more.  This is mainly for the benefit of programs which, like kexec,
166  * expect the hardware to be idle: not doing DMA or generating IRQs.
167  *
168  * This routine may be called in a damaged or failing kernel.  Hence we
169  * do not acquire the spinlock before shutting down the controller.
170  */
uhci_hcd_platform_shutdown(struct platform_device * op)171 static void uhci_hcd_platform_shutdown(struct platform_device *op)
172 {
173 	struct usb_hcd *hcd = platform_get_drvdata(op);
174 
175 	uhci_hc_died(hcd_to_uhci(hcd));
176 }
177 
178 static const struct of_device_id platform_uhci_ids[] = {
179 	{ .compatible = "generic-uhci", },
180 	{ .compatible = "platform-uhci", },
181 	{}
182 };
183 MODULE_DEVICE_TABLE(of, platform_uhci_ids);
184 
185 static struct platform_driver uhci_platform_driver = {
186 	.probe		= uhci_hcd_platform_probe,
187 	.remove_new	= uhci_hcd_platform_remove,
188 	.shutdown	= uhci_hcd_platform_shutdown,
189 	.driver = {
190 		.name = "platform-uhci",
191 		.of_match_table = platform_uhci_ids,
192 	},
193 };
194