]>
Commit | Line | Data |
---|---|---|
96915234 MYK |
1 | /* |
2 | * drivers/usb/otg/ab8500_usb.c | |
3 | * | |
4 | * USB transceiver driver for AB8500 chip | |
5 | * | |
6 | * Copyright (C) 2010 ST-Ericsson AB | |
7 | * Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
22 | * | |
23 | */ | |
24 | ||
25 | #include <linux/module.h> | |
26 | #include <linux/platform_device.h> | |
27 | #include <linux/usb/otg.h> | |
28 | #include <linux/slab.h> | |
29 | #include <linux/notifier.h> | |
30 | #include <linux/interrupt.h> | |
31 | #include <linux/delay.h> | |
32 | #include <linux/mfd/abx500.h> | |
ee66e653 | 33 | #include <linux/mfd/abx500/ab8500.h> |
96915234 MYK |
34 | |
35 | #define AB8500_MAIN_WD_CTRL_REG 0x01 | |
36 | #define AB8500_USB_LINE_STAT_REG 0x80 | |
37 | #define AB8500_USB_PHY_CTRL_REG 0x8A | |
38 | ||
39 | #define AB8500_BIT_OTG_STAT_ID (1 << 0) | |
40 | #define AB8500_BIT_PHY_CTRL_HOST_EN (1 << 0) | |
41 | #define AB8500_BIT_PHY_CTRL_DEVICE_EN (1 << 1) | |
42 | #define AB8500_BIT_WD_CTRL_ENABLE (1 << 0) | |
43 | #define AB8500_BIT_WD_CTRL_KICK (1 << 1) | |
44 | ||
45 | #define AB8500_V1x_LINK_STAT_WAIT (HZ/10) | |
46 | #define AB8500_WD_KICK_DELAY_US 100 /* usec */ | |
47 | #define AB8500_WD_V11_DISABLE_DELAY_US 100 /* usec */ | |
48 | #define AB8500_WD_V10_DISABLE_DELAY_MS 100 /* ms */ | |
49 | ||
50 | /* Usb line status register */ | |
51 | enum ab8500_usb_link_status { | |
52 | USB_LINK_NOT_CONFIGURED = 0, | |
53 | USB_LINK_STD_HOST_NC, | |
54 | USB_LINK_STD_HOST_C_NS, | |
55 | USB_LINK_STD_HOST_C_S, | |
56 | USB_LINK_HOST_CHG_NM, | |
57 | USB_LINK_HOST_CHG_HS, | |
58 | USB_LINK_HOST_CHG_HS_CHIRP, | |
59 | USB_LINK_DEDICATED_CHG, | |
60 | USB_LINK_ACA_RID_A, | |
61 | USB_LINK_ACA_RID_B, | |
62 | USB_LINK_ACA_RID_C_NM, | |
63 | USB_LINK_ACA_RID_C_HS, | |
64 | USB_LINK_ACA_RID_C_HS_CHIRP, | |
65 | USB_LINK_HM_IDGND, | |
66 | USB_LINK_RESERVED, | |
67 | USB_LINK_NOT_VALID_LINK | |
68 | }; | |
69 | ||
70 | struct ab8500_usb { | |
144713f3 | 71 | struct usb_phy phy; |
96915234 MYK |
72 | struct device *dev; |
73 | int irq_num_id_rise; | |
74 | int irq_num_id_fall; | |
75 | int irq_num_vbus_rise; | |
76 | int irq_num_vbus_fall; | |
77 | int irq_num_link_status; | |
78 | unsigned vbus_draw; | |
79 | struct delayed_work dwork; | |
80 | struct work_struct phy_dis_work; | |
81 | unsigned long link_status_wait; | |
82 | int rev; | |
83 | }; | |
84 | ||
144713f3 | 85 | static inline struct ab8500_usb *phy_to_ab(struct usb_phy *x) |
96915234 | 86 | { |
144713f3 | 87 | return container_of(x, struct ab8500_usb, phy); |
96915234 MYK |
88 | } |
89 | ||
90 | static void ab8500_usb_wd_workaround(struct ab8500_usb *ab) | |
91 | { | |
92 | abx500_set_register_interruptible(ab->dev, | |
93 | AB8500_SYS_CTRL2_BLOCK, | |
94 | AB8500_MAIN_WD_CTRL_REG, | |
95 | AB8500_BIT_WD_CTRL_ENABLE); | |
96 | ||
97 | udelay(AB8500_WD_KICK_DELAY_US); | |
98 | ||
99 | abx500_set_register_interruptible(ab->dev, | |
100 | AB8500_SYS_CTRL2_BLOCK, | |
101 | AB8500_MAIN_WD_CTRL_REG, | |
102 | (AB8500_BIT_WD_CTRL_ENABLE | |
103 | | AB8500_BIT_WD_CTRL_KICK)); | |
104 | ||
105 | if (ab->rev > 0x10) /* v1.1 v2.0 */ | |
106 | udelay(AB8500_WD_V11_DISABLE_DELAY_US); | |
107 | else /* v1.0 */ | |
108 | msleep(AB8500_WD_V10_DISABLE_DELAY_MS); | |
109 | ||
110 | abx500_set_register_interruptible(ab->dev, | |
111 | AB8500_SYS_CTRL2_BLOCK, | |
112 | AB8500_MAIN_WD_CTRL_REG, | |
113 | 0); | |
114 | } | |
115 | ||
116 | static void ab8500_usb_phy_ctrl(struct ab8500_usb *ab, bool sel_host, | |
117 | bool enable) | |
118 | { | |
119 | u8 ctrl_reg; | |
120 | abx500_get_register_interruptible(ab->dev, | |
121 | AB8500_USB, | |
122 | AB8500_USB_PHY_CTRL_REG, | |
123 | &ctrl_reg); | |
124 | if (sel_host) { | |
125 | if (enable) | |
126 | ctrl_reg |= AB8500_BIT_PHY_CTRL_HOST_EN; | |
127 | else | |
128 | ctrl_reg &= ~AB8500_BIT_PHY_CTRL_HOST_EN; | |
129 | } else { | |
130 | if (enable) | |
131 | ctrl_reg |= AB8500_BIT_PHY_CTRL_DEVICE_EN; | |
132 | else | |
133 | ctrl_reg &= ~AB8500_BIT_PHY_CTRL_DEVICE_EN; | |
134 | } | |
135 | ||
136 | abx500_set_register_interruptible(ab->dev, | |
137 | AB8500_USB, | |
138 | AB8500_USB_PHY_CTRL_REG, | |
139 | ctrl_reg); | |
140 | ||
141 | /* Needed to enable the phy.*/ | |
142 | if (enable) | |
143 | ab8500_usb_wd_workaround(ab); | |
144 | } | |
145 | ||
146 | #define ab8500_usb_host_phy_en(ab) ab8500_usb_phy_ctrl(ab, true, true) | |
147 | #define ab8500_usb_host_phy_dis(ab) ab8500_usb_phy_ctrl(ab, true, false) | |
148 | #define ab8500_usb_peri_phy_en(ab) ab8500_usb_phy_ctrl(ab, false, true) | |
149 | #define ab8500_usb_peri_phy_dis(ab) ab8500_usb_phy_ctrl(ab, false, false) | |
150 | ||
151 | static int ab8500_usb_link_status_update(struct ab8500_usb *ab) | |
152 | { | |
153 | u8 reg; | |
154 | enum ab8500_usb_link_status lsts; | |
155 | void *v = NULL; | |
de07e18c | 156 | enum usb_phy_events event; |
96915234 MYK |
157 | |
158 | abx500_get_register_interruptible(ab->dev, | |
159 | AB8500_USB, | |
160 | AB8500_USB_LINE_STAT_REG, | |
161 | ®); | |
162 | ||
163 | lsts = (reg >> 3) & 0x0F; | |
164 | ||
165 | switch (lsts) { | |
166 | case USB_LINK_NOT_CONFIGURED: | |
167 | case USB_LINK_RESERVED: | |
168 | case USB_LINK_NOT_VALID_LINK: | |
169 | /* TODO: Disable regulators. */ | |
170 | ab8500_usb_host_phy_dis(ab); | |
171 | ab8500_usb_peri_phy_dis(ab); | |
144713f3 HK |
172 | ab->phy.state = OTG_STATE_B_IDLE; |
173 | ab->phy.otg->default_a = false; | |
96915234 MYK |
174 | ab->vbus_draw = 0; |
175 | event = USB_EVENT_NONE; | |
176 | break; | |
177 | ||
178 | case USB_LINK_STD_HOST_NC: | |
179 | case USB_LINK_STD_HOST_C_NS: | |
180 | case USB_LINK_STD_HOST_C_S: | |
181 | case USB_LINK_HOST_CHG_NM: | |
182 | case USB_LINK_HOST_CHG_HS: | |
183 | case USB_LINK_HOST_CHG_HS_CHIRP: | |
144713f3 | 184 | if (ab->phy.otg->gadget) { |
96915234 MYK |
185 | /* TODO: Enable regulators. */ |
186 | ab8500_usb_peri_phy_en(ab); | |
144713f3 | 187 | v = ab->phy.otg->gadget; |
96915234 MYK |
188 | } |
189 | event = USB_EVENT_VBUS; | |
190 | break; | |
191 | ||
192 | case USB_LINK_HM_IDGND: | |
144713f3 | 193 | if (ab->phy.otg->host) { |
96915234 MYK |
194 | /* TODO: Enable regulators. */ |
195 | ab8500_usb_host_phy_en(ab); | |
144713f3 | 196 | v = ab->phy.otg->host; |
96915234 | 197 | } |
144713f3 HK |
198 | ab->phy.state = OTG_STATE_A_IDLE; |
199 | ab->phy.otg->default_a = true; | |
96915234 MYK |
200 | event = USB_EVENT_ID; |
201 | break; | |
202 | ||
203 | case USB_LINK_ACA_RID_A: | |
204 | case USB_LINK_ACA_RID_B: | |
205 | /* TODO */ | |
206 | case USB_LINK_ACA_RID_C_NM: | |
207 | case USB_LINK_ACA_RID_C_HS: | |
208 | case USB_LINK_ACA_RID_C_HS_CHIRP: | |
209 | case USB_LINK_DEDICATED_CHG: | |
210 | /* TODO: vbus_draw */ | |
211 | event = USB_EVENT_CHARGER; | |
212 | break; | |
213 | } | |
214 | ||
144713f3 | 215 | atomic_notifier_call_chain(&ab->phy.notifier, event, v); |
96915234 MYK |
216 | |
217 | return 0; | |
218 | } | |
219 | ||
220 | static void ab8500_usb_delayed_work(struct work_struct *work) | |
221 | { | |
222 | struct ab8500_usb *ab = container_of(work, struct ab8500_usb, | |
223 | dwork.work); | |
224 | ||
225 | ab8500_usb_link_status_update(ab); | |
226 | } | |
227 | ||
228 | static irqreturn_t ab8500_usb_v1x_common_irq(int irq, void *data) | |
229 | { | |
230 | struct ab8500_usb *ab = (struct ab8500_usb *) data; | |
231 | ||
232 | /* Wait for link status to become stable. */ | |
233 | schedule_delayed_work(&ab->dwork, ab->link_status_wait); | |
234 | ||
235 | return IRQ_HANDLED; | |
236 | } | |
237 | ||
238 | static irqreturn_t ab8500_usb_v1x_vbus_fall_irq(int irq, void *data) | |
239 | { | |
240 | struct ab8500_usb *ab = (struct ab8500_usb *) data; | |
241 | ||
242 | /* Link status will not be updated till phy is disabled. */ | |
243 | ab8500_usb_peri_phy_dis(ab); | |
244 | ||
245 | /* Wait for link status to become stable. */ | |
246 | schedule_delayed_work(&ab->dwork, ab->link_status_wait); | |
247 | ||
248 | return IRQ_HANDLED; | |
249 | } | |
250 | ||
251 | static irqreturn_t ab8500_usb_v20_irq(int irq, void *data) | |
252 | { | |
253 | struct ab8500_usb *ab = (struct ab8500_usb *) data; | |
254 | ||
255 | ab8500_usb_link_status_update(ab); | |
256 | ||
257 | return IRQ_HANDLED; | |
258 | } | |
259 | ||
260 | static void ab8500_usb_phy_disable_work(struct work_struct *work) | |
261 | { | |
262 | struct ab8500_usb *ab = container_of(work, struct ab8500_usb, | |
263 | phy_dis_work); | |
264 | ||
144713f3 | 265 | if (!ab->phy.otg->host) |
96915234 MYK |
266 | ab8500_usb_host_phy_dis(ab); |
267 | ||
144713f3 | 268 | if (!ab->phy.otg->gadget) |
96915234 MYK |
269 | ab8500_usb_peri_phy_dis(ab); |
270 | } | |
271 | ||
144713f3 | 272 | static int ab8500_usb_set_power(struct usb_phy *phy, unsigned mA) |
96915234 MYK |
273 | { |
274 | struct ab8500_usb *ab; | |
275 | ||
144713f3 | 276 | if (!phy) |
96915234 MYK |
277 | return -ENODEV; |
278 | ||
144713f3 | 279 | ab = phy_to_ab(phy); |
96915234 MYK |
280 | |
281 | ab->vbus_draw = mA; | |
282 | ||
283 | if (mA) | |
144713f3 HK |
284 | atomic_notifier_call_chain(&ab->phy.notifier, |
285 | USB_EVENT_ENUMERATED, ab->phy.otg->gadget); | |
96915234 MYK |
286 | return 0; |
287 | } | |
288 | ||
289 | /* TODO: Implement some way for charging or other drivers to read | |
290 | * ab->vbus_draw. | |
291 | */ | |
292 | ||
86753811 | 293 | static int ab8500_usb_set_suspend(struct usb_phy *x, int suspend) |
96915234 MYK |
294 | { |
295 | /* TODO */ | |
296 | return 0; | |
297 | } | |
298 | ||
144713f3 HK |
299 | static int ab8500_usb_set_peripheral(struct usb_otg *otg, |
300 | struct usb_gadget *gadget) | |
96915234 MYK |
301 | { |
302 | struct ab8500_usb *ab; | |
303 | ||
304 | if (!otg) | |
305 | return -ENODEV; | |
306 | ||
144713f3 | 307 | ab = phy_to_ab(otg->phy); |
96915234 MYK |
308 | |
309 | /* Some drivers call this function in atomic context. | |
310 | * Do not update ab8500 registers directly till this | |
311 | * is fixed. | |
312 | */ | |
313 | ||
314 | if (!gadget) { | |
315 | /* TODO: Disable regulators. */ | |
144713f3 | 316 | otg->gadget = NULL; |
96915234 MYK |
317 | schedule_work(&ab->phy_dis_work); |
318 | } else { | |
144713f3 HK |
319 | otg->gadget = gadget; |
320 | otg->phy->state = OTG_STATE_B_IDLE; | |
96915234 MYK |
321 | |
322 | /* Phy will not be enabled if cable is already | |
323 | * plugged-in. Schedule to enable phy. | |
324 | * Use same delay to avoid any race condition. | |
325 | */ | |
326 | schedule_delayed_work(&ab->dwork, ab->link_status_wait); | |
327 | } | |
328 | ||
329 | return 0; | |
330 | } | |
331 | ||
144713f3 | 332 | static int ab8500_usb_set_host(struct usb_otg *otg, struct usb_bus *host) |
96915234 MYK |
333 | { |
334 | struct ab8500_usb *ab; | |
335 | ||
336 | if (!otg) | |
337 | return -ENODEV; | |
338 | ||
144713f3 | 339 | ab = phy_to_ab(otg->phy); |
96915234 MYK |
340 | |
341 | /* Some drivers call this function in atomic context. | |
342 | * Do not update ab8500 registers directly till this | |
343 | * is fixed. | |
344 | */ | |
345 | ||
346 | if (!host) { | |
347 | /* TODO: Disable regulators. */ | |
144713f3 | 348 | otg->host = NULL; |
96915234 MYK |
349 | schedule_work(&ab->phy_dis_work); |
350 | } else { | |
144713f3 | 351 | otg->host = host; |
96915234 MYK |
352 | /* Phy will not be enabled if cable is already |
353 | * plugged-in. Schedule to enable phy. | |
354 | * Use same delay to avoid any race condition. | |
355 | */ | |
356 | schedule_delayed_work(&ab->dwork, ab->link_status_wait); | |
357 | } | |
358 | ||
359 | return 0; | |
360 | } | |
361 | ||
362 | static void ab8500_usb_irq_free(struct ab8500_usb *ab) | |
363 | { | |
364 | if (ab->rev < 0x20) { | |
365 | free_irq(ab->irq_num_id_rise, ab); | |
366 | free_irq(ab->irq_num_id_fall, ab); | |
367 | free_irq(ab->irq_num_vbus_rise, ab); | |
368 | free_irq(ab->irq_num_vbus_fall, ab); | |
369 | } else { | |
370 | free_irq(ab->irq_num_link_status, ab); | |
371 | } | |
372 | } | |
373 | ||
374 | static int ab8500_usb_v1x_res_setup(struct platform_device *pdev, | |
375 | struct ab8500_usb *ab) | |
376 | { | |
377 | int err; | |
378 | ||
379 | ab->irq_num_id_rise = platform_get_irq_byname(pdev, "ID_WAKEUP_R"); | |
380 | if (ab->irq_num_id_rise < 0) { | |
381 | dev_err(&pdev->dev, "ID rise irq not found\n"); | |
382 | return ab->irq_num_id_rise; | |
383 | } | |
384 | err = request_threaded_irq(ab->irq_num_id_rise, NULL, | |
385 | ab8500_usb_v1x_common_irq, | |
386 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
387 | "usb-id-rise", ab); | |
388 | if (err < 0) { | |
389 | dev_err(ab->dev, "request_irq failed for ID rise irq\n"); | |
390 | goto fail0; | |
391 | } | |
392 | ||
393 | ab->irq_num_id_fall = platform_get_irq_byname(pdev, "ID_WAKEUP_F"); | |
394 | if (ab->irq_num_id_fall < 0) { | |
395 | dev_err(&pdev->dev, "ID fall irq not found\n"); | |
396 | return ab->irq_num_id_fall; | |
397 | } | |
398 | err = request_threaded_irq(ab->irq_num_id_fall, NULL, | |
399 | ab8500_usb_v1x_common_irq, | |
400 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
401 | "usb-id-fall", ab); | |
402 | if (err < 0) { | |
403 | dev_err(ab->dev, "request_irq failed for ID fall irq\n"); | |
404 | goto fail1; | |
405 | } | |
406 | ||
407 | ab->irq_num_vbus_rise = platform_get_irq_byname(pdev, "VBUS_DET_R"); | |
408 | if (ab->irq_num_vbus_rise < 0) { | |
409 | dev_err(&pdev->dev, "VBUS rise irq not found\n"); | |
410 | return ab->irq_num_vbus_rise; | |
411 | } | |
412 | err = request_threaded_irq(ab->irq_num_vbus_rise, NULL, | |
413 | ab8500_usb_v1x_common_irq, | |
414 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
415 | "usb-vbus-rise", ab); | |
416 | if (err < 0) { | |
417 | dev_err(ab->dev, "request_irq failed for Vbus rise irq\n"); | |
418 | goto fail2; | |
419 | } | |
420 | ||
421 | ab->irq_num_vbus_fall = platform_get_irq_byname(pdev, "VBUS_DET_F"); | |
422 | if (ab->irq_num_vbus_fall < 0) { | |
423 | dev_err(&pdev->dev, "VBUS fall irq not found\n"); | |
424 | return ab->irq_num_vbus_fall; | |
425 | } | |
426 | err = request_threaded_irq(ab->irq_num_vbus_fall, NULL, | |
427 | ab8500_usb_v1x_vbus_fall_irq, | |
428 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
429 | "usb-vbus-fall", ab); | |
430 | if (err < 0) { | |
431 | dev_err(ab->dev, "request_irq failed for Vbus fall irq\n"); | |
432 | goto fail3; | |
433 | } | |
434 | ||
435 | return 0; | |
436 | fail3: | |
437 | free_irq(ab->irq_num_vbus_rise, ab); | |
438 | fail2: | |
439 | free_irq(ab->irq_num_id_fall, ab); | |
440 | fail1: | |
441 | free_irq(ab->irq_num_id_rise, ab); | |
442 | fail0: | |
443 | return err; | |
444 | } | |
445 | ||
446 | static int ab8500_usb_v2_res_setup(struct platform_device *pdev, | |
447 | struct ab8500_usb *ab) | |
448 | { | |
449 | int err; | |
450 | ||
451 | ab->irq_num_link_status = platform_get_irq_byname(pdev, | |
452 | "USB_LINK_STATUS"); | |
453 | if (ab->irq_num_link_status < 0) { | |
454 | dev_err(&pdev->dev, "Link status irq not found\n"); | |
455 | return ab->irq_num_link_status; | |
456 | } | |
457 | ||
458 | err = request_threaded_irq(ab->irq_num_link_status, NULL, | |
459 | ab8500_usb_v20_irq, | |
460 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
461 | "usb-link-status", ab); | |
462 | if (err < 0) { | |
463 | dev_err(ab->dev, | |
464 | "request_irq failed for link status irq\n"); | |
465 | return err; | |
466 | } | |
467 | ||
468 | return 0; | |
469 | } | |
470 | ||
41ac7b3a | 471 | static int ab8500_usb_probe(struct platform_device *pdev) |
96915234 MYK |
472 | { |
473 | struct ab8500_usb *ab; | |
144713f3 | 474 | struct usb_otg *otg; |
96915234 MYK |
475 | int err; |
476 | int rev; | |
477 | ||
478 | rev = abx500_get_chip_id(&pdev->dev); | |
479 | if (rev < 0) { | |
480 | dev_err(&pdev->dev, "Chip id read failed\n"); | |
481 | return rev; | |
482 | } else if (rev < 0x10) { | |
483 | dev_err(&pdev->dev, "Unsupported AB8500 chip\n"); | |
484 | return -ENODEV; | |
485 | } | |
486 | ||
487 | ab = kzalloc(sizeof *ab, GFP_KERNEL); | |
488 | if (!ab) | |
489 | return -ENOMEM; | |
490 | ||
144713f3 | 491 | otg = kzalloc(sizeof *otg, GFP_KERNEL); |
5f0b3f99 | 492 | if (!otg) { |
144713f3 HK |
493 | kfree(ab); |
494 | return -ENOMEM; | |
495 | } | |
496 | ||
96915234 MYK |
497 | ab->dev = &pdev->dev; |
498 | ab->rev = rev; | |
144713f3 HK |
499 | ab->phy.dev = ab->dev; |
500 | ab->phy.otg = otg; | |
501 | ab->phy.label = "ab8500"; | |
502 | ab->phy.set_suspend = ab8500_usb_set_suspend; | |
503 | ab->phy.set_power = ab8500_usb_set_power; | |
504 | ab->phy.state = OTG_STATE_UNDEFINED; | |
505 | ||
506 | otg->phy = &ab->phy; | |
507 | otg->set_host = ab8500_usb_set_host; | |
508 | otg->set_peripheral = ab8500_usb_set_peripheral; | |
96915234 MYK |
509 | |
510 | platform_set_drvdata(pdev, ab); | |
511 | ||
144713f3 | 512 | ATOMIC_INIT_NOTIFIER_HEAD(&ab->phy.notifier); |
96915234 MYK |
513 | |
514 | /* v1: Wait for link status to become stable. | |
515 | * all: Updates form set_host and set_peripheral as they are atomic. | |
516 | */ | |
517 | INIT_DELAYED_WORK(&ab->dwork, ab8500_usb_delayed_work); | |
518 | ||
519 | /* all: Disable phy when called from set_host and set_peripheral */ | |
520 | INIT_WORK(&ab->phy_dis_work, ab8500_usb_phy_disable_work); | |
521 | ||
522 | if (ab->rev < 0x20) { | |
523 | err = ab8500_usb_v1x_res_setup(pdev, ab); | |
524 | ab->link_status_wait = AB8500_V1x_LINK_STAT_WAIT; | |
525 | } else { | |
526 | err = ab8500_usb_v2_res_setup(pdev, ab); | |
527 | } | |
528 | ||
529 | if (err < 0) | |
530 | goto fail0; | |
531 | ||
662dca54 | 532 | err = usb_add_phy(&ab->phy, USB_PHY_TYPE_USB2); |
96915234 MYK |
533 | if (err) { |
534 | dev_err(&pdev->dev, "Can't register transceiver\n"); | |
535 | goto fail1; | |
536 | } | |
537 | ||
538 | dev_info(&pdev->dev, "AB8500 usb driver initialized\n"); | |
539 | ||
540 | return 0; | |
541 | fail1: | |
542 | ab8500_usb_irq_free(ab); | |
543 | fail0: | |
144713f3 | 544 | kfree(otg); |
96915234 MYK |
545 | kfree(ab); |
546 | return err; | |
547 | } | |
548 | ||
fb4e98ab | 549 | static int ab8500_usb_remove(struct platform_device *pdev) |
96915234 MYK |
550 | { |
551 | struct ab8500_usb *ab = platform_get_drvdata(pdev); | |
552 | ||
553 | ab8500_usb_irq_free(ab); | |
554 | ||
555 | cancel_delayed_work_sync(&ab->dwork); | |
556 | ||
557 | cancel_work_sync(&ab->phy_dis_work); | |
558 | ||
662dca54 | 559 | usb_remove_phy(&ab->phy); |
96915234 MYK |
560 | |
561 | ab8500_usb_host_phy_dis(ab); | |
562 | ab8500_usb_peri_phy_dis(ab); | |
563 | ||
564 | platform_set_drvdata(pdev, NULL); | |
565 | ||
144713f3 | 566 | kfree(ab->phy.otg); |
96915234 MYK |
567 | kfree(ab); |
568 | ||
569 | return 0; | |
570 | } | |
571 | ||
572 | static struct platform_driver ab8500_usb_driver = { | |
573 | .probe = ab8500_usb_probe, | |
7690417d | 574 | .remove = ab8500_usb_remove, |
96915234 MYK |
575 | .driver = { |
576 | .name = "ab8500-usb", | |
577 | .owner = THIS_MODULE, | |
578 | }, | |
579 | }; | |
580 | ||
581 | static int __init ab8500_usb_init(void) | |
582 | { | |
583 | return platform_driver_register(&ab8500_usb_driver); | |
584 | } | |
585 | subsys_initcall(ab8500_usb_init); | |
586 | ||
587 | static void __exit ab8500_usb_exit(void) | |
588 | { | |
589 | platform_driver_unregister(&ab8500_usb_driver); | |
590 | } | |
591 | module_exit(ab8500_usb_exit); | |
592 | ||
593 | MODULE_ALIAS("platform:ab8500_usb"); | |
594 | MODULE_AUTHOR("ST-Ericsson AB"); | |
595 | MODULE_DESCRIPTION("AB8500 usb transceiver driver"); | |
596 | MODULE_LICENSE("GPL"); |