Commit | Line | Data |
---|---|---|
7043c2cc HM |
1 | /* |
2 | * Sonics Silicon Backplane | |
3 | * Broadcom USB-core driver (SSB bus glue) | |
4 | * | |
5 | * Copyright 2011-2012 Hauke Mehrtens <hauke@hauke-m.de> | |
6 | * | |
7 | * Based on ssb-ohci driver | |
8 | * Copyright 2007 Michael Buesch <m@bues.ch> | |
9 | * | |
10 | * Derived from the OHCI-PCI driver | |
11 | * Copyright 1999 Roman Weissgaerber | |
12 | * Copyright 2000-2002 David Brownell | |
13 | * Copyright 1999 Linus Torvalds | |
14 | * Copyright 1999 Gregory P. Smith | |
15 | * | |
16 | * Derived from the USBcore related parts of Broadcom-SB | |
17 | * Copyright 2005-2011 Broadcom Corporation | |
18 | * | |
19 | * Licensed under the GNU/GPL. See COPYING for details. | |
20 | */ | |
21 | #include <linux/ssb/ssb.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/platform_device.h> | |
24 | #include <linux/module.h> | |
4627b1ea | 25 | #include <linux/slab.h> |
7043c2cc HM |
26 | #include <linux/usb/ehci_pdriver.h> |
27 | #include <linux/usb/ohci_pdriver.h> | |
28 | ||
29 | MODULE_AUTHOR("Hauke Mehrtens"); | |
30 | MODULE_DESCRIPTION("Common USB driver for SSB Bus"); | |
31 | MODULE_LICENSE("GPL"); | |
32 | ||
33 | #define SSB_HCD_TMSLOW_HOSTMODE (1 << 29) | |
34 | ||
35 | struct ssb_hcd_device { | |
36 | struct platform_device *ehci_dev; | |
37 | struct platform_device *ohci_dev; | |
38 | ||
39 | u32 enable_flags; | |
40 | }; | |
41 | ||
41ac7b3a | 42 | static void ssb_hcd_5354wa(struct ssb_device *dev) |
7043c2cc HM |
43 | { |
44 | #ifdef CONFIG_SSB_DRIVER_MIPS | |
45 | /* Work around for 5354 failures */ | |
46 | if (dev->id.revision == 2 && dev->bus->chip_id == 0x5354) { | |
47 | /* Change syn01 reg */ | |
48 | ssb_write32(dev, 0x894, 0x00fe00fe); | |
49 | ||
50 | /* Change syn03 reg */ | |
51 | ssb_write32(dev, 0x89c, ssb_read32(dev, 0x89c) | 0x1); | |
52 | } | |
53 | #endif | |
54 | } | |
55 | ||
41ac7b3a | 56 | static void ssb_hcd_usb20wa(struct ssb_device *dev) |
7043c2cc HM |
57 | { |
58 | if (dev->id.coreid == SSB_DEV_USB20_HOST) { | |
59 | /* | |
60 | * USB 2.0 special considerations: | |
61 | * | |
62 | * In addition to the standard SSB reset sequence, the Host | |
63 | * Control Register must be programmed to bring the USB core | |
64 | * and various phy components out of reset. | |
65 | */ | |
66 | ssb_write32(dev, 0x200, 0x7ff); | |
67 | ||
68 | /* Change Flush control reg */ | |
69 | ssb_write32(dev, 0x400, ssb_read32(dev, 0x400) & ~8); | |
70 | ssb_read32(dev, 0x400); | |
71 | ||
72 | /* Change Shim control reg */ | |
73 | ssb_write32(dev, 0x304, ssb_read32(dev, 0x304) & ~0x100); | |
74 | ssb_read32(dev, 0x304); | |
75 | ||
76 | udelay(1); | |
77 | ||
78 | ssb_hcd_5354wa(dev); | |
79 | } | |
80 | } | |
81 | ||
82 | /* based on arch/mips/brcm-boards/bcm947xx/pcibios.c */ | |
41ac7b3a | 83 | static u32 ssb_hcd_init_chip(struct ssb_device *dev) |
7043c2cc HM |
84 | { |
85 | u32 flags = 0; | |
86 | ||
87 | if (dev->id.coreid == SSB_DEV_USB11_HOSTDEV) | |
88 | /* Put the device into host-mode. */ | |
89 | flags |= SSB_HCD_TMSLOW_HOSTMODE; | |
90 | ||
91 | ssb_device_enable(dev, flags); | |
92 | ||
93 | ssb_hcd_usb20wa(dev); | |
94 | ||
95 | return flags; | |
96 | } | |
97 | ||
98 | static const struct usb_ehci_pdata ehci_pdata = { | |
99 | }; | |
100 | ||
101 | static const struct usb_ohci_pdata ohci_pdata = { | |
102 | }; | |
103 | ||
41ac7b3a | 104 | static struct platform_device *ssb_hcd_create_pdev(struct ssb_device *dev, bool ohci, u32 addr, u32 len) |
7043c2cc HM |
105 | { |
106 | struct platform_device *hci_dev; | |
107 | struct resource hci_res[2]; | |
87997195 | 108 | int ret; |
7043c2cc HM |
109 | |
110 | memset(hci_res, 0, sizeof(hci_res)); | |
111 | ||
112 | hci_res[0].start = addr; | |
113 | hci_res[0].end = hci_res[0].start + len - 1; | |
114 | hci_res[0].flags = IORESOURCE_MEM; | |
115 | ||
116 | hci_res[1].start = dev->irq; | |
117 | hci_res[1].flags = IORESOURCE_IRQ; | |
118 | ||
119 | hci_dev = platform_device_alloc(ohci ? "ohci-platform" : | |
120 | "ehci-platform" , 0); | |
121 | if (!hci_dev) | |
87997195 | 122 | return ERR_PTR(-ENOMEM); |
7043c2cc HM |
123 | |
124 | hci_dev->dev.parent = dev->dev; | |
125 | hci_dev->dev.dma_mask = &hci_dev->dev.coherent_dma_mask; | |
126 | ||
127 | ret = platform_device_add_resources(hci_dev, hci_res, | |
128 | ARRAY_SIZE(hci_res)); | |
129 | if (ret) | |
130 | goto err_alloc; | |
131 | if (ohci) | |
132 | ret = platform_device_add_data(hci_dev, &ohci_pdata, | |
133 | sizeof(ohci_pdata)); | |
134 | else | |
135 | ret = platform_device_add_data(hci_dev, &ehci_pdata, | |
136 | sizeof(ehci_pdata)); | |
137 | if (ret) | |
138 | goto err_alloc; | |
139 | ret = platform_device_add(hci_dev); | |
140 | if (ret) | |
141 | goto err_alloc; | |
142 | ||
143 | return hci_dev; | |
144 | ||
145 | err_alloc: | |
146 | platform_device_put(hci_dev); | |
147 | return ERR_PTR(ret); | |
148 | } | |
149 | ||
41ac7b3a | 150 | static int ssb_hcd_probe(struct ssb_device *dev, |
7043c2cc HM |
151 | const struct ssb_device_id *id) |
152 | { | |
153 | int err, tmp; | |
154 | int start, len; | |
155 | u16 chipid_top; | |
156 | u16 coreid = dev->id.coreid; | |
157 | struct ssb_hcd_device *usb_dev; | |
158 | ||
159 | /* USBcores are only connected on embedded devices. */ | |
160 | chipid_top = (dev->bus->chip_id & 0xFF00); | |
161 | if (chipid_top != 0x4700 && chipid_top != 0x5300) | |
162 | return -ENODEV; | |
163 | ||
164 | /* TODO: Probably need checks here; is the core connected? */ | |
165 | ||
01edb5e1 | 166 | if (dma_set_mask_and_coherent(dev->dma_dev, DMA_BIT_MASK(32))) |
7043c2cc HM |
167 | return -EOPNOTSUPP; |
168 | ||
b0a252ed HM |
169 | usb_dev = devm_kzalloc(dev->dev, sizeof(struct ssb_hcd_device), |
170 | GFP_KERNEL); | |
7043c2cc HM |
171 | if (!usb_dev) |
172 | return -ENOMEM; | |
173 | ||
174 | /* We currently always attach SSB_DEV_USB11_HOSTDEV | |
175 | * as HOST OHCI. If we want to attach it as Client device, | |
176 | * we must branch here and call into the (yet to | |
177 | * be written) Client mode driver. Same for remove(). */ | |
178 | usb_dev->enable_flags = ssb_hcd_init_chip(dev); | |
179 | ||
180 | tmp = ssb_read32(dev, SSB_ADMATCH0); | |
181 | ||
182 | start = ssb_admatch_base(tmp); | |
183 | len = (coreid == SSB_DEV_USB20_HOST) ? 0x800 : ssb_admatch_size(tmp); | |
184 | usb_dev->ohci_dev = ssb_hcd_create_pdev(dev, true, start, len); | |
b0a252ed HM |
185 | if (IS_ERR(usb_dev->ohci_dev)) |
186 | return PTR_ERR(usb_dev->ohci_dev); | |
7043c2cc HM |
187 | |
188 | if (coreid == SSB_DEV_USB20_HOST) { | |
189 | start = ssb_admatch_base(tmp) + 0x800; /* ehci core offset */ | |
190 | usb_dev->ehci_dev = ssb_hcd_create_pdev(dev, false, start, len); | |
191 | if (IS_ERR(usb_dev->ehci_dev)) { | |
192 | err = PTR_ERR(usb_dev->ehci_dev); | |
193 | goto err_unregister_ohci_dev; | |
194 | } | |
195 | } | |
196 | ||
197 | ssb_set_drvdata(dev, usb_dev); | |
198 | return 0; | |
199 | ||
200 | err_unregister_ohci_dev: | |
201 | platform_device_unregister(usb_dev->ohci_dev); | |
7043c2cc HM |
202 | return err; |
203 | } | |
204 | ||
fb4e98ab | 205 | static void ssb_hcd_remove(struct ssb_device *dev) |
7043c2cc HM |
206 | { |
207 | struct ssb_hcd_device *usb_dev = ssb_get_drvdata(dev); | |
208 | struct platform_device *ohci_dev = usb_dev->ohci_dev; | |
209 | struct platform_device *ehci_dev = usb_dev->ehci_dev; | |
210 | ||
211 | if (ohci_dev) | |
212 | platform_device_unregister(ohci_dev); | |
213 | if (ehci_dev) | |
214 | platform_device_unregister(ehci_dev); | |
215 | ||
216 | ssb_device_disable(dev, 0); | |
217 | } | |
218 | ||
fb4e98ab | 219 | static void ssb_hcd_shutdown(struct ssb_device *dev) |
7043c2cc HM |
220 | { |
221 | ssb_device_disable(dev, 0); | |
222 | } | |
223 | ||
224 | #ifdef CONFIG_PM | |
225 | ||
226 | static int ssb_hcd_suspend(struct ssb_device *dev, pm_message_t state) | |
227 | { | |
228 | ssb_device_disable(dev, 0); | |
229 | ||
230 | return 0; | |
231 | } | |
232 | ||
233 | static int ssb_hcd_resume(struct ssb_device *dev) | |
234 | { | |
235 | struct ssb_hcd_device *usb_dev = ssb_get_drvdata(dev); | |
236 | ||
237 | ssb_device_enable(dev, usb_dev->enable_flags); | |
238 | ||
239 | return 0; | |
240 | } | |
241 | ||
242 | #else /* !CONFIG_PM */ | |
243 | #define ssb_hcd_suspend NULL | |
244 | #define ssb_hcd_resume NULL | |
245 | #endif /* CONFIG_PM */ | |
246 | ||
2f82686e | 247 | static const struct ssb_device_id ssb_hcd_table[] = { |
7043c2cc HM |
248 | SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOSTDEV, SSB_ANY_REV), |
249 | SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOST, SSB_ANY_REV), | |
250 | SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB20_HOST, SSB_ANY_REV), | |
673e2baa | 251 | {}, |
7043c2cc HM |
252 | }; |
253 | MODULE_DEVICE_TABLE(ssb, ssb_hcd_table); | |
254 | ||
255 | static struct ssb_driver ssb_hcd_driver = { | |
256 | .name = KBUILD_MODNAME, | |
257 | .id_table = ssb_hcd_table, | |
258 | .probe = ssb_hcd_probe, | |
7690417d | 259 | .remove = ssb_hcd_remove, |
7043c2cc HM |
260 | .shutdown = ssb_hcd_shutdown, |
261 | .suspend = ssb_hcd_suspend, | |
262 | .resume = ssb_hcd_resume, | |
263 | }; | |
264 | ||
265 | static int __init ssb_hcd_init(void) | |
266 | { | |
267 | return ssb_driver_register(&ssb_hcd_driver); | |
268 | } | |
269 | module_init(ssb_hcd_init); | |
270 | ||
271 | static void __exit ssb_hcd_exit(void) | |
272 | { | |
273 | ssb_driver_unregister(&ssb_hcd_driver); | |
274 | } | |
275 | module_exit(ssb_hcd_exit); |