]>
Commit | Line | Data |
---|---|---|
b0848aea PK |
1 | /* ehci-msm.c - HSUSB Host Controller Driver Implementation |
2 | * | |
18f53461 | 3 | * Copyright (c) 2008-2011, Code Aurora Forum. All rights reserved. |
b0848aea PK |
4 | * |
5 | * Partly derived from ehci-fsl.c and ehci-hcd.c | |
6 | * Copyright (c) 2000-2004 by David Brownell | |
7 | * Copyright (c) 2005 MontaVista Software | |
8 | * | |
9 | * All source code in this file is licensed under the following license except | |
10 | * where indicated. | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License version 2 as published | |
14 | * by the Free Software Foundation. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
19 | * | |
20 | * See the GNU General Public License for more details. | |
21 | * You should have received a copy of the GNU General Public License | |
22 | * along with this program; if not, you can find it at http://www.fsf.org | |
23 | */ | |
24 | ||
25 | #include <linux/platform_device.h> | |
26 | #include <linux/clk.h> | |
27 | #include <linux/err.h> | |
8bb6a164 | 28 | #include <linux/pm_runtime.h> |
b0848aea PK |
29 | |
30 | #include <linux/usb/otg.h> | |
31 | #include <linux/usb/msm_hsusb_hw.h> | |
32 | ||
33 | #define MSM_USB_BASE (hcd->regs) | |
34 | ||
b96d3b08 | 35 | static struct usb_phy *phy; |
b0848aea | 36 | |
b0848aea PK |
37 | static int ehci_msm_reset(struct usb_hcd *hcd) |
38 | { | |
39 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); | |
40 | int retval; | |
41 | ||
42 | ehci->caps = USB_CAPLENGTH; | |
b0848aea | 43 | hcd->has_tt = 1; |
b0848aea | 44 | |
2cb30bb1 | 45 | retval = ehci_setup(hcd); |
b0848aea PK |
46 | if (retval) |
47 | return retval; | |
48 | ||
49 | /* bursts of unspecified length. */ | |
50 | writel(0, USB_AHBBURST); | |
51 | /* Use the AHB transactor */ | |
52 | writel(0, USB_AHBMODE); | |
53 | /* Disable streaming mode and select host mode */ | |
54 | writel(0x13, USB_USBMODE); | |
55 | ||
56 | ehci_port_power(ehci, 1); | |
57 | return 0; | |
58 | } | |
59 | ||
60 | static struct hc_driver msm_hc_driver = { | |
61 | .description = hcd_name, | |
62 | .product_desc = "Qualcomm On-Chip EHCI Host Controller", | |
63 | .hcd_priv_size = sizeof(struct ehci_hcd), | |
64 | ||
65 | /* | |
66 | * generic hardware linkage | |
67 | */ | |
68 | .irq = ehci_irq, | |
69 | .flags = HCD_USB2 | HCD_MEMORY, | |
70 | ||
71 | .reset = ehci_msm_reset, | |
5c8d61bf | 72 | .start = ehci_run, |
b0848aea PK |
73 | |
74 | .stop = ehci_stop, | |
75 | .shutdown = ehci_shutdown, | |
76 | ||
77 | /* | |
78 | * managing i/o requests and associated device resources | |
79 | */ | |
80 | .urb_enqueue = ehci_urb_enqueue, | |
81 | .urb_dequeue = ehci_urb_dequeue, | |
82 | .endpoint_disable = ehci_endpoint_disable, | |
83 | .endpoint_reset = ehci_endpoint_reset, | |
84 | .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, | |
85 | ||
86 | /* | |
87 | * scheduling support | |
88 | */ | |
89 | .get_frame_number = ehci_get_frame, | |
90 | ||
91 | /* | |
92 | * root hub support | |
93 | */ | |
94 | .hub_status_data = ehci_hub_status_data, | |
95 | .hub_control = ehci_hub_control, | |
96 | .relinquish_port = ehci_relinquish_port, | |
97 | .port_handed_over = ehci_port_handed_over, | |
98 | ||
99 | /* | |
100 | * PM support | |
101 | */ | |
102 | .bus_suspend = ehci_bus_suspend, | |
103 | .bus_resume = ehci_bus_resume, | |
104 | }; | |
105 | ||
106 | static int ehci_msm_probe(struct platform_device *pdev) | |
107 | { | |
108 | struct usb_hcd *hcd; | |
109 | struct resource *res; | |
110 | int ret; | |
111 | ||
112 | dev_dbg(&pdev->dev, "ehci_msm proble\n"); | |
113 | ||
114 | hcd = usb_create_hcd(&msm_hc_driver, &pdev->dev, dev_name(&pdev->dev)); | |
115 | if (!hcd) { | |
116 | dev_err(&pdev->dev, "Unable to create HCD\n"); | |
117 | return -ENOMEM; | |
118 | } | |
119 | ||
120 | hcd->irq = platform_get_irq(pdev, 0); | |
121 | if (hcd->irq < 0) { | |
122 | dev_err(&pdev->dev, "Unable to get IRQ resource\n"); | |
123 | ret = hcd->irq; | |
124 | goto put_hcd; | |
125 | } | |
126 | ||
127 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
128 | if (!res) { | |
129 | dev_err(&pdev->dev, "Unable to get memory resource\n"); | |
130 | ret = -ENODEV; | |
131 | goto put_hcd; | |
132 | } | |
133 | ||
134 | hcd->rsrc_start = res->start; | |
135 | hcd->rsrc_len = resource_size(res); | |
136 | hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); | |
137 | if (!hcd->regs) { | |
138 | dev_err(&pdev->dev, "ioremap failed\n"); | |
139 | ret = -ENOMEM; | |
140 | goto put_hcd; | |
141 | } | |
142 | ||
143 | /* | |
144 | * OTG driver takes care of PHY initialization, clock management, | |
8bb6a164 PK |
145 | * powering up VBUS, mapping of registers address space and power |
146 | * management. | |
b0848aea | 147 | */ |
662dca54 | 148 | phy = usb_get_phy(USB_PHY_TYPE_USB2); |
ded017ee | 149 | if (IS_ERR_OR_NULL(phy)) { |
b0848aea PK |
150 | dev_err(&pdev->dev, "unable to find transceiver\n"); |
151 | ret = -ENODEV; | |
152 | goto unmap; | |
153 | } | |
154 | ||
6e13c650 | 155 | ret = otg_set_host(phy->otg, &hcd->self); |
b0848aea PK |
156 | if (ret < 0) { |
157 | dev_err(&pdev->dev, "unable to register with transceiver\n"); | |
158 | goto put_transceiver; | |
159 | } | |
160 | ||
161 | device_init_wakeup(&pdev->dev, 1); | |
8bb6a164 PK |
162 | /* |
163 | * OTG device parent of HCD takes care of putting | |
164 | * hardware into low power mode. | |
165 | */ | |
166 | pm_runtime_no_callbacks(&pdev->dev); | |
167 | pm_runtime_enable(&pdev->dev); | |
168 | ||
b0848aea PK |
169 | return 0; |
170 | ||
171 | put_transceiver: | |
721002ec | 172 | usb_put_phy(phy); |
b0848aea PK |
173 | unmap: |
174 | iounmap(hcd->regs); | |
175 | put_hcd: | |
176 | usb_put_hcd(hcd); | |
177 | ||
178 | return ret; | |
179 | } | |
180 | ||
181 | static int __devexit ehci_msm_remove(struct platform_device *pdev) | |
182 | { | |
183 | struct usb_hcd *hcd = platform_get_drvdata(pdev); | |
184 | ||
185 | device_init_wakeup(&pdev->dev, 0); | |
8bb6a164 PK |
186 | pm_runtime_disable(&pdev->dev); |
187 | pm_runtime_set_suspended(&pdev->dev); | |
b0848aea | 188 | |
6e13c650 | 189 | otg_set_host(phy->otg, NULL); |
721002ec | 190 | usb_put_phy(phy); |
b0848aea PK |
191 | |
192 | usb_put_hcd(hcd); | |
193 | ||
194 | return 0; | |
195 | } | |
196 | ||
8bb6a164 PK |
197 | #ifdef CONFIG_PM |
198 | static int ehci_msm_pm_suspend(struct device *dev) | |
199 | { | |
200 | struct usb_hcd *hcd = dev_get_drvdata(dev); | |
c5cf9212 | 201 | bool do_wakeup = device_may_wakeup(dev); |
8bb6a164 PK |
202 | |
203 | dev_dbg(dev, "ehci-msm PM suspend\n"); | |
204 | ||
c5cf9212 | 205 | return ehci_suspend(hcd, do_wakeup); |
8bb6a164 PK |
206 | } |
207 | ||
208 | static int ehci_msm_pm_resume(struct device *dev) | |
209 | { | |
210 | struct usb_hcd *hcd = dev_get_drvdata(dev); | |
211 | ||
212 | dev_dbg(dev, "ehci-msm PM resume\n"); | |
c5cf9212 | 213 | ehci_resume(hcd, false); |
8bb6a164 PK |
214 | |
215 | return 0; | |
216 | } | |
217 | #else | |
218 | #define ehci_msm_pm_suspend NULL | |
219 | #define ehci_msm_pm_resume NULL | |
220 | #endif | |
221 | ||
222 | static const struct dev_pm_ops ehci_msm_dev_pm_ops = { | |
223 | .suspend = ehci_msm_pm_suspend, | |
224 | .resume = ehci_msm_pm_resume, | |
225 | }; | |
226 | ||
b0848aea PK |
227 | static struct platform_driver ehci_msm_driver = { |
228 | .probe = ehci_msm_probe, | |
229 | .remove = __devexit_p(ehci_msm_remove), | |
230 | .driver = { | |
231 | .name = "msm_hsusb_host", | |
8bb6a164 | 232 | .pm = &ehci_msm_dev_pm_ops, |
b0848aea PK |
233 | }, |
234 | }; |