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 { | |
71 | struct otg_transceiver otg; | |
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 | ||
85 | static inline struct ab8500_usb *xceiv_to_ab(struct otg_transceiver *x) | |
86 | { | |
87 | return container_of(x, struct ab8500_usb, otg); | |
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; | |
156 | enum usb_xceiv_events event; | |
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); | |
172 | ab->otg.state = OTG_STATE_B_IDLE; | |
173 | ab->otg.default_a = false; | |
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: | |
184 | if (ab->otg.gadget) { | |
185 | /* TODO: Enable regulators. */ | |
186 | ab8500_usb_peri_phy_en(ab); | |
187 | v = ab->otg.gadget; | |
188 | } | |
189 | event = USB_EVENT_VBUS; | |
190 | break; | |
191 | ||
192 | case USB_LINK_HM_IDGND: | |
193 | if (ab->otg.host) { | |
194 | /* TODO: Enable regulators. */ | |
195 | ab8500_usb_host_phy_en(ab); | |
196 | v = ab->otg.host; | |
197 | } | |
198 | ab->otg.state = OTG_STATE_A_IDLE; | |
199 | ab->otg.default_a = true; | |
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 | ||
cccad6d4 | 215 | atomic_notifier_call_chain(&ab->otg.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 | ||
265 | if (!ab->otg.host) | |
266 | ab8500_usb_host_phy_dis(ab); | |
267 | ||
268 | if (!ab->otg.gadget) | |
269 | ab8500_usb_peri_phy_dis(ab); | |
270 | } | |
271 | ||
272 | static int ab8500_usb_set_power(struct otg_transceiver *otg, unsigned mA) | |
273 | { | |
274 | struct ab8500_usb *ab; | |
275 | ||
276 | if (!otg) | |
277 | return -ENODEV; | |
278 | ||
279 | ab = xceiv_to_ab(otg); | |
280 | ||
281 | ab->vbus_draw = mA; | |
282 | ||
283 | if (mA) | |
cccad6d4 | 284 | atomic_notifier_call_chain(&ab->otg.notifier, |
96915234 MYK |
285 | USB_EVENT_ENUMERATED, ab->otg.gadget); |
286 | return 0; | |
287 | } | |
288 | ||
289 | /* TODO: Implement some way for charging or other drivers to read | |
290 | * ab->vbus_draw. | |
291 | */ | |
292 | ||
293 | static int ab8500_usb_set_suspend(struct otg_transceiver *x, int suspend) | |
294 | { | |
295 | /* TODO */ | |
296 | return 0; | |
297 | } | |
298 | ||
299 | static int ab8500_usb_set_peripheral(struct otg_transceiver *otg, | |
300 | struct usb_gadget *gadget) | |
301 | { | |
302 | struct ab8500_usb *ab; | |
303 | ||
304 | if (!otg) | |
305 | return -ENODEV; | |
306 | ||
307 | ab = xceiv_to_ab(otg); | |
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. */ | |
316 | ab->otg.gadget = NULL; | |
317 | schedule_work(&ab->phy_dis_work); | |
318 | } else { | |
319 | ab->otg.gadget = gadget; | |
320 | ab->otg.state = OTG_STATE_B_IDLE; | |
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 | ||
332 | static int ab8500_usb_set_host(struct otg_transceiver *otg, | |
333 | struct usb_bus *host) | |
334 | { | |
335 | struct ab8500_usb *ab; | |
336 | ||
337 | if (!otg) | |
338 | return -ENODEV; | |
339 | ||
340 | ab = xceiv_to_ab(otg); | |
341 | ||
342 | /* Some drivers call this function in atomic context. | |
343 | * Do not update ab8500 registers directly till this | |
344 | * is fixed. | |
345 | */ | |
346 | ||
347 | if (!host) { | |
348 | /* TODO: Disable regulators. */ | |
349 | ab->otg.host = NULL; | |
350 | schedule_work(&ab->phy_dis_work); | |
351 | } else { | |
352 | ab->otg.host = host; | |
353 | /* Phy will not be enabled if cable is already | |
354 | * plugged-in. Schedule to enable phy. | |
355 | * Use same delay to avoid any race condition. | |
356 | */ | |
357 | schedule_delayed_work(&ab->dwork, ab->link_status_wait); | |
358 | } | |
359 | ||
360 | return 0; | |
361 | } | |
362 | ||
363 | static void ab8500_usb_irq_free(struct ab8500_usb *ab) | |
364 | { | |
365 | if (ab->rev < 0x20) { | |
366 | free_irq(ab->irq_num_id_rise, ab); | |
367 | free_irq(ab->irq_num_id_fall, ab); | |
368 | free_irq(ab->irq_num_vbus_rise, ab); | |
369 | free_irq(ab->irq_num_vbus_fall, ab); | |
370 | } else { | |
371 | free_irq(ab->irq_num_link_status, ab); | |
372 | } | |
373 | } | |
374 | ||
375 | static int ab8500_usb_v1x_res_setup(struct platform_device *pdev, | |
376 | struct ab8500_usb *ab) | |
377 | { | |
378 | int err; | |
379 | ||
380 | ab->irq_num_id_rise = platform_get_irq_byname(pdev, "ID_WAKEUP_R"); | |
381 | if (ab->irq_num_id_rise < 0) { | |
382 | dev_err(&pdev->dev, "ID rise irq not found\n"); | |
383 | return ab->irq_num_id_rise; | |
384 | } | |
385 | err = request_threaded_irq(ab->irq_num_id_rise, NULL, | |
386 | ab8500_usb_v1x_common_irq, | |
387 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
388 | "usb-id-rise", ab); | |
389 | if (err < 0) { | |
390 | dev_err(ab->dev, "request_irq failed for ID rise irq\n"); | |
391 | goto fail0; | |
392 | } | |
393 | ||
394 | ab->irq_num_id_fall = platform_get_irq_byname(pdev, "ID_WAKEUP_F"); | |
395 | if (ab->irq_num_id_fall < 0) { | |
396 | dev_err(&pdev->dev, "ID fall irq not found\n"); | |
397 | return ab->irq_num_id_fall; | |
398 | } | |
399 | err = request_threaded_irq(ab->irq_num_id_fall, NULL, | |
400 | ab8500_usb_v1x_common_irq, | |
401 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
402 | "usb-id-fall", ab); | |
403 | if (err < 0) { | |
404 | dev_err(ab->dev, "request_irq failed for ID fall irq\n"); | |
405 | goto fail1; | |
406 | } | |
407 | ||
408 | ab->irq_num_vbus_rise = platform_get_irq_byname(pdev, "VBUS_DET_R"); | |
409 | if (ab->irq_num_vbus_rise < 0) { | |
410 | dev_err(&pdev->dev, "VBUS rise irq not found\n"); | |
411 | return ab->irq_num_vbus_rise; | |
412 | } | |
413 | err = request_threaded_irq(ab->irq_num_vbus_rise, NULL, | |
414 | ab8500_usb_v1x_common_irq, | |
415 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
416 | "usb-vbus-rise", ab); | |
417 | if (err < 0) { | |
418 | dev_err(ab->dev, "request_irq failed for Vbus rise irq\n"); | |
419 | goto fail2; | |
420 | } | |
421 | ||
422 | ab->irq_num_vbus_fall = platform_get_irq_byname(pdev, "VBUS_DET_F"); | |
423 | if (ab->irq_num_vbus_fall < 0) { | |
424 | dev_err(&pdev->dev, "VBUS fall irq not found\n"); | |
425 | return ab->irq_num_vbus_fall; | |
426 | } | |
427 | err = request_threaded_irq(ab->irq_num_vbus_fall, NULL, | |
428 | ab8500_usb_v1x_vbus_fall_irq, | |
429 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
430 | "usb-vbus-fall", ab); | |
431 | if (err < 0) { | |
432 | dev_err(ab->dev, "request_irq failed for Vbus fall irq\n"); | |
433 | goto fail3; | |
434 | } | |
435 | ||
436 | return 0; | |
437 | fail3: | |
438 | free_irq(ab->irq_num_vbus_rise, ab); | |
439 | fail2: | |
440 | free_irq(ab->irq_num_id_fall, ab); | |
441 | fail1: | |
442 | free_irq(ab->irq_num_id_rise, ab); | |
443 | fail0: | |
444 | return err; | |
445 | } | |
446 | ||
447 | static int ab8500_usb_v2_res_setup(struct platform_device *pdev, | |
448 | struct ab8500_usb *ab) | |
449 | { | |
450 | int err; | |
451 | ||
452 | ab->irq_num_link_status = platform_get_irq_byname(pdev, | |
453 | "USB_LINK_STATUS"); | |
454 | if (ab->irq_num_link_status < 0) { | |
455 | dev_err(&pdev->dev, "Link status irq not found\n"); | |
456 | return ab->irq_num_link_status; | |
457 | } | |
458 | ||
459 | err = request_threaded_irq(ab->irq_num_link_status, NULL, | |
460 | ab8500_usb_v20_irq, | |
461 | IRQF_NO_SUSPEND | IRQF_SHARED, | |
462 | "usb-link-status", ab); | |
463 | if (err < 0) { | |
464 | dev_err(ab->dev, | |
465 | "request_irq failed for link status irq\n"); | |
466 | return err; | |
467 | } | |
468 | ||
469 | return 0; | |
470 | } | |
471 | ||
472 | static int __devinit ab8500_usb_probe(struct platform_device *pdev) | |
473 | { | |
474 | struct ab8500_usb *ab; | |
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 | ||
491 | ab->dev = &pdev->dev; | |
492 | ab->rev = rev; | |
493 | ab->otg.dev = ab->dev; | |
494 | ab->otg.label = "ab8500"; | |
495 | ab->otg.state = OTG_STATE_UNDEFINED; | |
496 | ab->otg.set_host = ab8500_usb_set_host; | |
497 | ab->otg.set_peripheral = ab8500_usb_set_peripheral; | |
498 | ab->otg.set_suspend = ab8500_usb_set_suspend; | |
499 | ab->otg.set_power = ab8500_usb_set_power; | |
500 | ||
501 | platform_set_drvdata(pdev, ab); | |
502 | ||
cccad6d4 | 503 | ATOMIC_INIT_NOTIFIER_HEAD(&ab->otg.notifier); |
96915234 MYK |
504 | |
505 | /* v1: Wait for link status to become stable. | |
506 | * all: Updates form set_host and set_peripheral as they are atomic. | |
507 | */ | |
508 | INIT_DELAYED_WORK(&ab->dwork, ab8500_usb_delayed_work); | |
509 | ||
510 | /* all: Disable phy when called from set_host and set_peripheral */ | |
511 | INIT_WORK(&ab->phy_dis_work, ab8500_usb_phy_disable_work); | |
512 | ||
513 | if (ab->rev < 0x20) { | |
514 | err = ab8500_usb_v1x_res_setup(pdev, ab); | |
515 | ab->link_status_wait = AB8500_V1x_LINK_STAT_WAIT; | |
516 | } else { | |
517 | err = ab8500_usb_v2_res_setup(pdev, ab); | |
518 | } | |
519 | ||
520 | if (err < 0) | |
521 | goto fail0; | |
522 | ||
523 | err = otg_set_transceiver(&ab->otg); | |
524 | if (err) { | |
525 | dev_err(&pdev->dev, "Can't register transceiver\n"); | |
526 | goto fail1; | |
527 | } | |
528 | ||
529 | dev_info(&pdev->dev, "AB8500 usb driver initialized\n"); | |
530 | ||
531 | return 0; | |
532 | fail1: | |
533 | ab8500_usb_irq_free(ab); | |
534 | fail0: | |
535 | kfree(ab); | |
536 | return err; | |
537 | } | |
538 | ||
539 | static int __devexit ab8500_usb_remove(struct platform_device *pdev) | |
540 | { | |
541 | struct ab8500_usb *ab = platform_get_drvdata(pdev); | |
542 | ||
543 | ab8500_usb_irq_free(ab); | |
544 | ||
545 | cancel_delayed_work_sync(&ab->dwork); | |
546 | ||
547 | cancel_work_sync(&ab->phy_dis_work); | |
548 | ||
549 | otg_set_transceiver(NULL); | |
550 | ||
551 | ab8500_usb_host_phy_dis(ab); | |
552 | ab8500_usb_peri_phy_dis(ab); | |
553 | ||
554 | platform_set_drvdata(pdev, NULL); | |
555 | ||
556 | kfree(ab); | |
557 | ||
558 | return 0; | |
559 | } | |
560 | ||
561 | static struct platform_driver ab8500_usb_driver = { | |
562 | .probe = ab8500_usb_probe, | |
563 | .remove = __devexit_p(ab8500_usb_remove), | |
564 | .driver = { | |
565 | .name = "ab8500-usb", | |
566 | .owner = THIS_MODULE, | |
567 | }, | |
568 | }; | |
569 | ||
570 | static int __init ab8500_usb_init(void) | |
571 | { | |
572 | return platform_driver_register(&ab8500_usb_driver); | |
573 | } | |
574 | subsys_initcall(ab8500_usb_init); | |
575 | ||
576 | static void __exit ab8500_usb_exit(void) | |
577 | { | |
578 | platform_driver_unregister(&ab8500_usb_driver); | |
579 | } | |
580 | module_exit(ab8500_usb_exit); | |
581 | ||
582 | MODULE_ALIAS("platform:ab8500_usb"); | |
583 | MODULE_AUTHOR("ST-Ericsson AB"); | |
584 | MODULE_DESCRIPTION("AB8500 usb transceiver driver"); | |
585 | MODULE_LICENSE("GPL"); |