Commit | Line | Data |
---|---|---|
ec46475f HK |
1 | /* |
2 | * ISP1704 USB Charger Detection driver | |
3 | * | |
4 | * Copyright (C) 2010 Nokia Corporation | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 | */ | |
20 | ||
21 | #include <linux/kernel.h> | |
22 | #include <linux/module.h> | |
23 | #include <linux/err.h> | |
24 | #include <linux/init.h> | |
25 | #include <linux/types.h> | |
26 | #include <linux/device.h> | |
27 | #include <linux/sysfs.h> | |
28 | #include <linux/platform_device.h> | |
29 | #include <linux/power_supply.h> | |
30 | #include <linux/delay.h> | |
31 | ||
32 | #include <linux/usb/otg.h> | |
33 | #include <linux/usb/ulpi.h> | |
34 | #include <linux/usb/ch9.h> | |
35 | #include <linux/usb/gadget.h> | |
2785cefc | 36 | #include <linux/power/isp1704_charger.h> |
ec46475f HK |
37 | |
38 | /* Vendor specific Power Control register */ | |
39 | #define ISP1704_PWR_CTRL 0x3d | |
40 | #define ISP1704_PWR_CTRL_SWCTRL (1 << 0) | |
41 | #define ISP1704_PWR_CTRL_DET_COMP (1 << 1) | |
42 | #define ISP1704_PWR_CTRL_BVALID_RISE (1 << 2) | |
43 | #define ISP1704_PWR_CTRL_BVALID_FALL (1 << 3) | |
44 | #define ISP1704_PWR_CTRL_DP_WKPU_EN (1 << 4) | |
45 | #define ISP1704_PWR_CTRL_VDAT_DET (1 << 5) | |
46 | #define ISP1704_PWR_CTRL_DPVSRC_EN (1 << 6) | |
47 | #define ISP1704_PWR_CTRL_HWDETECT (1 << 7) | |
48 | ||
49 | #define NXP_VENDOR_ID 0x04cc | |
50 | ||
51 | static u16 isp170x_id[] = { | |
52 | 0x1704, | |
53 | 0x1707, | |
54 | }; | |
55 | ||
56 | struct isp1704_charger { | |
57 | struct device *dev; | |
58 | struct power_supply psy; | |
fcc8ebc9 | 59 | struct usb_phy *phy; |
ec46475f HK |
60 | struct notifier_block nb; |
61 | struct work_struct work; | |
62 | ||
bac43b20 | 63 | /* properties */ |
746d8fb8 | 64 | char model[8]; |
ec46475f | 65 | unsigned present:1; |
bac43b20 HK |
66 | unsigned online:1; |
67 | unsigned current_max; | |
68 | ||
69 | /* temp storage variables */ | |
70 | unsigned long event; | |
71 | unsigned max_power; | |
ec46475f HK |
72 | }; |
73 | ||
fcc8ebc9 HK |
74 | static inline int isp1704_read(struct isp1704_charger *isp, u32 reg) |
75 | { | |
76 | return usb_phy_io_read(isp->phy, reg); | |
77 | } | |
78 | ||
79 | static inline int isp1704_write(struct isp1704_charger *isp, u32 val, u32 reg) | |
80 | { | |
81 | return usb_phy_io_write(isp->phy, val, reg); | |
82 | } | |
83 | ||
2785cefc KJ |
84 | /* |
85 | * Disable/enable the power from the isp1704 if a function for it | |
86 | * has been provided with platform data. | |
87 | */ | |
88 | static void isp1704_charger_set_power(struct isp1704_charger *isp, bool on) | |
89 | { | |
90 | struct isp1704_charger_data *board = isp->dev->platform_data; | |
91 | ||
c934502d | 92 | if (board && board->set_power) |
2785cefc KJ |
93 | board->set_power(on); |
94 | } | |
95 | ||
bac43b20 HK |
96 | /* |
97 | * Determine is the charging port DCP (dedicated charger) or CDP (Host/HUB | |
98 | * chargers). | |
99 | * | |
100 | * REVISIT: The method is defined in Battery Charging Specification and is | |
101 | * applicable to any ULPI transceiver. Nothing isp170x specific here. | |
102 | */ | |
103 | static inline int isp1704_charger_type(struct isp1704_charger *isp) | |
104 | { | |
105 | u8 reg; | |
106 | u8 func_ctrl; | |
107 | u8 otg_ctrl; | |
108 | int type = POWER_SUPPLY_TYPE_USB_DCP; | |
109 | ||
fcc8ebc9 HK |
110 | func_ctrl = isp1704_read(isp, ULPI_FUNC_CTRL); |
111 | otg_ctrl = isp1704_read(isp, ULPI_OTG_CTRL); | |
bac43b20 HK |
112 | |
113 | /* disable pulldowns */ | |
114 | reg = ULPI_OTG_CTRL_DM_PULLDOWN | ULPI_OTG_CTRL_DP_PULLDOWN; | |
fcc8ebc9 | 115 | isp1704_write(isp, ULPI_CLR(ULPI_OTG_CTRL), reg); |
bac43b20 HK |
116 | |
117 | /* full speed */ | |
fcc8ebc9 | 118 | isp1704_write(isp, ULPI_CLR(ULPI_FUNC_CTRL), |
bac43b20 | 119 | ULPI_FUNC_CTRL_XCVRSEL_MASK); |
fcc8ebc9 | 120 | isp1704_write(isp, ULPI_SET(ULPI_FUNC_CTRL), |
bac43b20 HK |
121 | ULPI_FUNC_CTRL_FULL_SPEED); |
122 | ||
123 | /* Enable strong pull-up on DP (1.5K) and reset */ | |
124 | reg = ULPI_FUNC_CTRL_TERMSELECT | ULPI_FUNC_CTRL_RESET; | |
fcc8ebc9 | 125 | isp1704_write(isp, ULPI_SET(ULPI_FUNC_CTRL), reg); |
bac43b20 HK |
126 | usleep_range(1000, 2000); |
127 | ||
fcc8ebc9 | 128 | reg = isp1704_read(isp, ULPI_DEBUG); |
bac43b20 HK |
129 | if ((reg & 3) != 3) |
130 | type = POWER_SUPPLY_TYPE_USB_CDP; | |
131 | ||
132 | /* recover original state */ | |
fcc8ebc9 HK |
133 | isp1704_write(isp, ULPI_FUNC_CTRL, func_ctrl); |
134 | isp1704_write(isp, ULPI_OTG_CTRL, otg_ctrl); | |
bac43b20 HK |
135 | |
136 | return type; | |
137 | } | |
138 | ||
ec46475f HK |
139 | /* |
140 | * ISP1704 detects PS/2 adapters as charger. To make sure the detected charger | |
141 | * is actually a dedicated charger, the following steps need to be taken. | |
142 | */ | |
143 | static inline int isp1704_charger_verify(struct isp1704_charger *isp) | |
144 | { | |
145 | int ret = 0; | |
146 | u8 r; | |
147 | ||
148 | /* Reset the transceiver */ | |
fcc8ebc9 | 149 | r = isp1704_read(isp, ULPI_FUNC_CTRL); |
ec46475f | 150 | r |= ULPI_FUNC_CTRL_RESET; |
fcc8ebc9 | 151 | isp1704_write(isp, ULPI_FUNC_CTRL, r); |
ec46475f HK |
152 | usleep_range(1000, 2000); |
153 | ||
154 | /* Set normal mode */ | |
155 | r &= ~(ULPI_FUNC_CTRL_RESET | ULPI_FUNC_CTRL_OPMODE_MASK); | |
fcc8ebc9 | 156 | isp1704_write(isp, ULPI_FUNC_CTRL, r); |
ec46475f HK |
157 | |
158 | /* Clear the DP and DM pull-down bits */ | |
159 | r = ULPI_OTG_CTRL_DP_PULLDOWN | ULPI_OTG_CTRL_DM_PULLDOWN; | |
fcc8ebc9 | 160 | isp1704_write(isp, ULPI_CLR(ULPI_OTG_CTRL), r); |
ec46475f HK |
161 | |
162 | /* Enable strong pull-up on DP (1.5K) and reset */ | |
163 | r = ULPI_FUNC_CTRL_TERMSELECT | ULPI_FUNC_CTRL_RESET; | |
fcc8ebc9 | 164 | isp1704_write(isp, ULPI_SET(ULPI_FUNC_CTRL), r); |
ec46475f HK |
165 | usleep_range(1000, 2000); |
166 | ||
167 | /* Read the line state */ | |
fcc8ebc9 | 168 | if (!isp1704_read(isp, ULPI_DEBUG)) { |
ec46475f | 169 | /* Disable strong pull-up on DP (1.5K) */ |
fcc8ebc9 | 170 | isp1704_write(isp, ULPI_CLR(ULPI_FUNC_CTRL), |
ec46475f HK |
171 | ULPI_FUNC_CTRL_TERMSELECT); |
172 | return 1; | |
173 | } | |
174 | ||
175 | /* Is it a charger or PS/2 connection */ | |
176 | ||
177 | /* Enable weak pull-up resistor on DP */ | |
fcc8ebc9 | 178 | isp1704_write(isp, ULPI_SET(ISP1704_PWR_CTRL), |
ec46475f HK |
179 | ISP1704_PWR_CTRL_DP_WKPU_EN); |
180 | ||
181 | /* Disable strong pull-up on DP (1.5K) */ | |
fcc8ebc9 | 182 | isp1704_write(isp, ULPI_CLR(ULPI_FUNC_CTRL), |
ec46475f HK |
183 | ULPI_FUNC_CTRL_TERMSELECT); |
184 | ||
185 | /* Enable weak pull-down resistor on DM */ | |
fcc8ebc9 | 186 | isp1704_write(isp, ULPI_SET(ULPI_OTG_CTRL), |
ec46475f HK |
187 | ULPI_OTG_CTRL_DM_PULLDOWN); |
188 | ||
189 | /* It's a charger if the line states are clear */ | |
fcc8ebc9 | 190 | if (!(isp1704_read(isp, ULPI_DEBUG))) |
ec46475f HK |
191 | ret = 1; |
192 | ||
193 | /* Disable weak pull-up resistor on DP */ | |
fcc8ebc9 | 194 | isp1704_write(isp, ULPI_CLR(ISP1704_PWR_CTRL), |
ec46475f HK |
195 | ISP1704_PWR_CTRL_DP_WKPU_EN); |
196 | ||
197 | return ret; | |
198 | } | |
199 | ||
200 | static inline int isp1704_charger_detect(struct isp1704_charger *isp) | |
201 | { | |
202 | unsigned long timeout; | |
bac43b20 | 203 | u8 pwr_ctrl; |
ec46475f HK |
204 | int ret = 0; |
205 | ||
fcc8ebc9 | 206 | pwr_ctrl = isp1704_read(isp, ISP1704_PWR_CTRL); |
bac43b20 | 207 | |
ec46475f | 208 | /* set SW control bit in PWR_CTRL register */ |
fcc8ebc9 | 209 | isp1704_write(isp, ISP1704_PWR_CTRL, |
ec46475f HK |
210 | ISP1704_PWR_CTRL_SWCTRL); |
211 | ||
212 | /* enable manual charger detection */ | |
fcc8ebc9 | 213 | isp1704_write(isp, ULPI_SET(ISP1704_PWR_CTRL), |
bac43b20 HK |
214 | ISP1704_PWR_CTRL_SWCTRL |
215 | | ISP1704_PWR_CTRL_DPVSRC_EN); | |
ec46475f HK |
216 | usleep_range(1000, 2000); |
217 | ||
218 | timeout = jiffies + msecs_to_jiffies(300); | |
219 | do { | |
220 | /* Check if there is a charger */ | |
fcc8ebc9 | 221 | if (isp1704_read(isp, ISP1704_PWR_CTRL) |
ec46475f HK |
222 | & ISP1704_PWR_CTRL_VDAT_DET) { |
223 | ret = isp1704_charger_verify(isp); | |
224 | break; | |
225 | } | |
bac43b20 HK |
226 | } while (!time_after(jiffies, timeout) && isp->online); |
227 | ||
228 | /* recover original state */ | |
fcc8ebc9 | 229 | isp1704_write(isp, ISP1704_PWR_CTRL, pwr_ctrl); |
ec46475f HK |
230 | |
231 | return ret; | |
232 | } | |
233 | ||
234 | static void isp1704_charger_work(struct work_struct *data) | |
235 | { | |
236 | int detect; | |
bac43b20 HK |
237 | unsigned long event; |
238 | unsigned power; | |
ec46475f HK |
239 | struct isp1704_charger *isp = |
240 | container_of(data, struct isp1704_charger, work); | |
bac43b20 | 241 | static DEFINE_MUTEX(lock); |
ec46475f | 242 | |
bac43b20 HK |
243 | event = isp->event; |
244 | power = isp->max_power; | |
ec46475f | 245 | |
bac43b20 | 246 | mutex_lock(&lock); |
ec46475f | 247 | |
2785cefc KJ |
248 | if (event != USB_EVENT_NONE) |
249 | isp1704_charger_set_power(isp, 1); | |
250 | ||
ec46475f HK |
251 | switch (event) { |
252 | case USB_EVENT_VBUS: | |
bac43b20 HK |
253 | isp->online = true; |
254 | ||
255 | /* detect charger */ | |
256 | detect = isp1704_charger_detect(isp); | |
257 | ||
258 | if (detect) { | |
259 | isp->present = detect; | |
260 | isp->psy.type = isp1704_charger_type(isp); | |
261 | } | |
262 | ||
263 | switch (isp->psy.type) { | |
264 | case POWER_SUPPLY_TYPE_USB_DCP: | |
265 | isp->current_max = 1800; | |
266 | break; | |
267 | case POWER_SUPPLY_TYPE_USB_CDP: | |
268 | /* | |
269 | * Only 500mA here or high speed chirp | |
270 | * handshaking may break | |
271 | */ | |
272 | isp->current_max = 500; | |
273 | /* FALLTHROUGH */ | |
274 | case POWER_SUPPLY_TYPE_USB: | |
275 | default: | |
276 | /* enable data pullups */ | |
b1c711d6 HK |
277 | if (isp->phy->otg->gadget) |
278 | usb_gadget_connect(isp->phy->otg->gadget); | |
bac43b20 | 279 | } |
ec46475f HK |
280 | break; |
281 | case USB_EVENT_NONE: | |
bac43b20 HK |
282 | isp->online = false; |
283 | isp->current_max = 0; | |
284 | isp->present = 0; | |
285 | isp->current_max = 0; | |
286 | isp->psy.type = POWER_SUPPLY_TYPE_USB; | |
287 | ||
288 | /* | |
289 | * Disable data pullups. We need to prevent the controller from | |
290 | * enumerating. | |
291 | * | |
292 | * FIXME: This is here to allow charger detection with Host/HUB | |
293 | * chargers. The pullups may be enabled elsewhere, so this can | |
294 | * not be the final solution. | |
295 | */ | |
b1c711d6 HK |
296 | if (isp->phy->otg->gadget) |
297 | usb_gadget_disconnect(isp->phy->otg->gadget); | |
2785cefc KJ |
298 | |
299 | isp1704_charger_set_power(isp, 0); | |
bac43b20 HK |
300 | break; |
301 | case USB_EVENT_ENUMERATED: | |
302 | if (isp->present) | |
303 | isp->current_max = 1800; | |
304 | else | |
305 | isp->current_max = power; | |
ec46475f HK |
306 | break; |
307 | default: | |
bac43b20 | 308 | goto out; |
ec46475f HK |
309 | } |
310 | ||
bac43b20 HK |
311 | power_supply_changed(&isp->psy); |
312 | out: | |
313 | mutex_unlock(&lock); | |
314 | } | |
315 | ||
316 | static int isp1704_notifier_call(struct notifier_block *nb, | |
317 | unsigned long event, void *power) | |
318 | { | |
319 | struct isp1704_charger *isp = | |
320 | container_of(nb, struct isp1704_charger, nb); | |
321 | ||
322 | isp->event = event; | |
323 | ||
324 | if (power) | |
325 | isp->max_power = *((unsigned *)power); | |
326 | ||
327 | schedule_work(&isp->work); | |
328 | ||
ec46475f HK |
329 | return NOTIFY_OK; |
330 | } | |
331 | ||
332 | static int isp1704_charger_get_property(struct power_supply *psy, | |
333 | enum power_supply_property psp, | |
334 | union power_supply_propval *val) | |
335 | { | |
336 | struct isp1704_charger *isp = | |
337 | container_of(psy, struct isp1704_charger, psy); | |
338 | ||
339 | switch (psp) { | |
340 | case POWER_SUPPLY_PROP_PRESENT: | |
341 | val->intval = isp->present; | |
342 | break; | |
bac43b20 HK |
343 | case POWER_SUPPLY_PROP_ONLINE: |
344 | val->intval = isp->online; | |
345 | break; | |
346 | case POWER_SUPPLY_PROP_CURRENT_MAX: | |
347 | val->intval = isp->current_max; | |
348 | break; | |
ec46475f HK |
349 | case POWER_SUPPLY_PROP_MODEL_NAME: |
350 | val->strval = isp->model; | |
351 | break; | |
352 | case POWER_SUPPLY_PROP_MANUFACTURER: | |
353 | val->strval = "NXP"; | |
354 | break; | |
355 | default: | |
356 | return -EINVAL; | |
357 | } | |
358 | return 0; | |
359 | } | |
360 | ||
361 | static enum power_supply_property power_props[] = { | |
362 | POWER_SUPPLY_PROP_PRESENT, | |
bac43b20 HK |
363 | POWER_SUPPLY_PROP_ONLINE, |
364 | POWER_SUPPLY_PROP_CURRENT_MAX, | |
ec46475f HK |
365 | POWER_SUPPLY_PROP_MODEL_NAME, |
366 | POWER_SUPPLY_PROP_MANUFACTURER, | |
367 | }; | |
368 | ||
369 | static inline int isp1704_test_ulpi(struct isp1704_charger *isp) | |
370 | { | |
371 | int vendor; | |
372 | int product; | |
373 | int i; | |
374 | int ret = -ENODEV; | |
375 | ||
376 | /* Test ULPI interface */ | |
fcc8ebc9 | 377 | ret = isp1704_write(isp, ULPI_SCRATCH, 0xaa); |
ec46475f HK |
378 | if (ret < 0) |
379 | return ret; | |
380 | ||
fcc8ebc9 | 381 | ret = isp1704_read(isp, ULPI_SCRATCH); |
ec46475f HK |
382 | if (ret < 0) |
383 | return ret; | |
384 | ||
385 | if (ret != 0xaa) | |
386 | return -ENODEV; | |
387 | ||
388 | /* Verify the product and vendor id matches */ | |
fcc8ebc9 HK |
389 | vendor = isp1704_read(isp, ULPI_VENDOR_ID_LOW); |
390 | vendor |= isp1704_read(isp, ULPI_VENDOR_ID_HIGH) << 8; | |
ec46475f HK |
391 | if (vendor != NXP_VENDOR_ID) |
392 | return -ENODEV; | |
393 | ||
fcc8ebc9 HK |
394 | product = isp1704_read(isp, ULPI_PRODUCT_ID_LOW); |
395 | product |= isp1704_read(isp, ULPI_PRODUCT_ID_HIGH) << 8; | |
ec46475f HK |
396 | |
397 | for (i = 0; i < ARRAY_SIZE(isp170x_id); i++) { | |
398 | if (product == isp170x_id[i]) { | |
399 | sprintf(isp->model, "isp%x", product); | |
400 | return product; | |
401 | } | |
402 | } | |
403 | ||
404 | dev_err(isp->dev, "product id %x not matching known ids", product); | |
405 | ||
406 | return -ENODEV; | |
407 | } | |
408 | ||
409 | static int __devinit isp1704_charger_probe(struct platform_device *pdev) | |
410 | { | |
411 | struct isp1704_charger *isp; | |
412 | int ret = -ENODEV; | |
413 | ||
414 | isp = kzalloc(sizeof *isp, GFP_KERNEL); | |
415 | if (!isp) | |
416 | return -ENOMEM; | |
417 | ||
662dca54 | 418 | isp->phy = usb_get_phy(USB_PHY_TYPE_USB2); |
ded017ee | 419 | if (IS_ERR_OR_NULL(isp->phy)) |
ec46475f HK |
420 | goto fail0; |
421 | ||
a4607d9f HK |
422 | isp->dev = &pdev->dev; |
423 | platform_set_drvdata(pdev, isp); | |
424 | ||
2785cefc KJ |
425 | isp1704_charger_set_power(isp, 1); |
426 | ||
ec46475f HK |
427 | ret = isp1704_test_ulpi(isp); |
428 | if (ret < 0) | |
429 | goto fail1; | |
430 | ||
ec46475f HK |
431 | isp->psy.name = "isp1704"; |
432 | isp->psy.type = POWER_SUPPLY_TYPE_USB; | |
433 | isp->psy.properties = power_props; | |
434 | isp->psy.num_properties = ARRAY_SIZE(power_props); | |
435 | isp->psy.get_property = isp1704_charger_get_property; | |
436 | ||
437 | ret = power_supply_register(isp->dev, &isp->psy); | |
438 | if (ret) | |
439 | goto fail1; | |
440 | ||
441 | /* | |
fcc8ebc9 | 442 | * REVISIT: using work in order to allow the usb notifications to be |
ec46475f HK |
443 | * made atomically in the future. |
444 | */ | |
445 | INIT_WORK(&isp->work, isp1704_charger_work); | |
446 | ||
447 | isp->nb.notifier_call = isp1704_notifier_call; | |
448 | ||
fcc8ebc9 | 449 | ret = usb_register_notifier(isp->phy, &isp->nb); |
ec46475f HK |
450 | if (ret) |
451 | goto fail2; | |
452 | ||
453 | dev_info(isp->dev, "registered with product id %s\n", isp->model); | |
454 | ||
e1a85694 HK |
455 | /* |
456 | * Taking over the D+ pullup. | |
457 | * | |
458 | * FIXME: The device will be disconnected if it was already | |
459 | * enumerated. The charger driver should be always loaded before any | |
460 | * gadget is loaded. | |
461 | */ | |
b1c711d6 HK |
462 | if (isp->phy->otg->gadget) |
463 | usb_gadget_disconnect(isp->phy->otg->gadget); | |
e1a85694 HK |
464 | |
465 | /* Detect charger if VBUS is valid (the cable was already plugged). */ | |
fcc8ebc9 | 466 | ret = isp1704_read(isp, ULPI_USB_INT_STS); |
2785cefc | 467 | isp1704_charger_set_power(isp, 0); |
fcc8ebc9 | 468 | if ((ret & ULPI_INT_VBUS_VALID) && !isp->phy->otg->default_a) { |
e1a85694 HK |
469 | isp->event = USB_EVENT_VBUS; |
470 | schedule_work(&isp->work); | |
471 | } | |
472 | ||
ec46475f HK |
473 | return 0; |
474 | fail2: | |
475 | power_supply_unregister(&isp->psy); | |
476 | fail1: | |
81a08382 | 477 | isp1704_charger_set_power(isp, 0); |
721002ec | 478 | usb_put_phy(isp->phy); |
ec46475f HK |
479 | fail0: |
480 | kfree(isp); | |
481 | ||
482 | dev_err(&pdev->dev, "failed to register isp1704 with error %d\n", ret); | |
483 | ||
484 | return ret; | |
485 | } | |
486 | ||
487 | static int __devexit isp1704_charger_remove(struct platform_device *pdev) | |
488 | { | |
489 | struct isp1704_charger *isp = platform_get_drvdata(pdev); | |
490 | ||
fcc8ebc9 | 491 | usb_unregister_notifier(isp->phy, &isp->nb); |
ec46475f | 492 | power_supply_unregister(&isp->psy); |
721002ec | 493 | usb_put_phy(isp->phy); |
2785cefc | 494 | isp1704_charger_set_power(isp, 0); |
ec46475f HK |
495 | kfree(isp); |
496 | ||
497 | return 0; | |
498 | } | |
499 | ||
500 | static struct platform_driver isp1704_charger_driver = { | |
501 | .driver = { | |
502 | .name = "isp1704_charger", | |
503 | }, | |
504 | .probe = isp1704_charger_probe, | |
505 | .remove = __devexit_p(isp1704_charger_remove), | |
506 | }; | |
507 | ||
300bac7f | 508 | module_platform_driver(isp1704_charger_driver); |
ec46475f HK |
509 | |
510 | MODULE_ALIAS("platform:isp1704_charger"); | |
511 | MODULE_AUTHOR("Nokia Corporation"); | |
512 | MODULE_DESCRIPTION("ISP170x USB Charger driver"); | |
513 | MODULE_LICENSE("GPL"); |