diff options
author | Chanwoo Choi <cw00.choi@samsung.com> | 2012-05-08 23:31:58 -0400 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2012-05-09 18:14:19 -0400 |
commit | b76668ba8a7722f589af2e13a340f3629430a35a (patch) | |
tree | acc6ea6cac985e3c6b2ef08f5d20eb53e055fffe /drivers/extcon | |
parent | 3b552b92817c63fdccfe9d5f3ce7424b57e9ee8f (diff) |
Extcon: add MAX8997 extcon driver
This patch add extcon-max8997 driver to support the muic feature
of Maxim max8997 by using Extcon framework.
The extcon-max8997 driver is implemented based on 'drivers/misc/
max8997-muic.c' and then use Extcon interface instead of callback
function in struct max8997_muic_platform_data to notify cable state
of notifee which want to know always newly cable state when external
connector(e.g., USB, TA, JIG) is attached or detached.
v1
- Use Extcon interface to notify cable state of notifee instead of
callback function when external connector is attached or detached.
- Bug fix of getting platform_data for irq_base value.
Signed-off-by: Chanwoo Choi <cw00.choi@samsung.com>
Signed-off-by: Myungjoo Ham <myungjoo.ham@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Diffstat (limited to 'drivers/extcon')
-rw-r--r-- | drivers/extcon/Kconfig | 8 | ||||
-rw-r--r-- | drivers/extcon/Makefile | 1 | ||||
-rw-r--r-- | drivers/extcon/extcon-max8997.c | 537 |
3 files changed, 546 insertions, 0 deletions
diff --git a/drivers/extcon/Kconfig b/drivers/extcon/Kconfig index 85cecff36db3..29c5cf852efc 100644 --- a/drivers/extcon/Kconfig +++ b/drivers/extcon/Kconfig | |||
@@ -21,4 +21,12 @@ config EXTCON_GPIO | |||
21 | Say Y here to enable GPIO based extcon support. Note that GPIO | 21 | Say Y here to enable GPIO based extcon support. Note that GPIO |
22 | extcon supports single state per extcon instance. | 22 | extcon supports single state per extcon instance. |
23 | 23 | ||
24 | config EXTCON_MAX8997 | ||
25 | tristate "MAX8997 EXTCON Support" | ||
26 | depends on MFD_MAX8997 | ||
27 | help | ||
28 | If you say yes here you get support for the MUIC device of | ||
29 | Maxim MAX8997 PMIC. The MAX8997 MUIC is a USB port accessory | ||
30 | detector and switch. | ||
31 | |||
24 | endif # MULTISTATE_SWITCH | 32 | endif # MULTISTATE_SWITCH |
diff --git a/drivers/extcon/Makefile b/drivers/extcon/Makefile index 2c46d4176d18..86020bdb6da0 100644 --- a/drivers/extcon/Makefile +++ b/drivers/extcon/Makefile | |||
@@ -4,3 +4,4 @@ | |||
4 | 4 | ||
5 | obj-$(CONFIG_EXTCON) += extcon_class.o | 5 | obj-$(CONFIG_EXTCON) += extcon_class.o |
6 | obj-$(CONFIG_EXTCON_GPIO) += extcon_gpio.o | 6 | obj-$(CONFIG_EXTCON_GPIO) += extcon_gpio.o |
7 | obj-$(CONFIG_EXTCON_MAX8997) += extcon-max8997.o | ||
diff --git a/drivers/extcon/extcon-max8997.c b/drivers/extcon/extcon-max8997.c new file mode 100644 index 000000000000..2b1aa04a27dd --- /dev/null +++ b/drivers/extcon/extcon-max8997.c | |||
@@ -0,0 +1,537 @@ | |||
1 | /* | ||
2 | * extcon-max8997.c - MAX8997 extcon driver to support MAX8997 MUIC | ||
3 | * | ||
4 | * Copyright (C) 2012 Samsung Electrnoics | ||
5 | * Donggeun Kim <dg77.kim@samsung.com> | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | */ | ||
17 | |||
18 | #include <linux/kernel.h> | ||
19 | #include <linux/module.h> | ||
20 | #include <linux/i2c.h> | ||
21 | #include <linux/slab.h> | ||
22 | #include <linux/interrupt.h> | ||
23 | #include <linux/err.h> | ||
24 | #include <linux/platform_device.h> | ||
25 | #include <linux/kobject.h> | ||
26 | #include <linux/mfd/max8997.h> | ||
27 | #include <linux/mfd/max8997-private.h> | ||
28 | #include <linux/extcon.h> | ||
29 | |||
30 | #define DEV_NAME "max8997-muic" | ||
31 | |||
32 | /* MAX8997-MUIC STATUS1 register */ | ||
33 | #define STATUS1_ADC_SHIFT 0 | ||
34 | #define STATUS1_ADCLOW_SHIFT 5 | ||
35 | #define STATUS1_ADCERR_SHIFT 6 | ||
36 | #define STATUS1_ADC_MASK (0x1f << STATUS1_ADC_SHIFT) | ||
37 | #define STATUS1_ADCLOW_MASK (0x1 << STATUS1_ADCLOW_SHIFT) | ||
38 | #define STATUS1_ADCERR_MASK (0x1 << STATUS1_ADCERR_SHIFT) | ||
39 | |||
40 | /* MAX8997-MUIC STATUS2 register */ | ||
41 | #define STATUS2_CHGTYP_SHIFT 0 | ||
42 | #define STATUS2_CHGDETRUN_SHIFT 3 | ||
43 | #define STATUS2_DCDTMR_SHIFT 4 | ||
44 | #define STATUS2_DBCHG_SHIFT 5 | ||
45 | #define STATUS2_VBVOLT_SHIFT 6 | ||
46 | #define STATUS2_CHGTYP_MASK (0x7 << STATUS2_CHGTYP_SHIFT) | ||
47 | #define STATUS2_CHGDETRUN_MASK (0x1 << STATUS2_CHGDETRUN_SHIFT) | ||
48 | #define STATUS2_DCDTMR_MASK (0x1 << STATUS2_DCDTMR_SHIFT) | ||
49 | #define STATUS2_DBCHG_MASK (0x1 << STATUS2_DBCHG_SHIFT) | ||
50 | #define STATUS2_VBVOLT_MASK (0x1 << STATUS2_VBVOLT_SHIFT) | ||
51 | |||
52 | /* MAX8997-MUIC STATUS3 register */ | ||
53 | #define STATUS3_OVP_SHIFT 2 | ||
54 | #define STATUS3_OVP_MASK (0x1 << STATUS3_OVP_SHIFT) | ||
55 | |||
56 | /* MAX8997-MUIC CONTROL1 register */ | ||
57 | #define COMN1SW_SHIFT 0 | ||
58 | #define COMP2SW_SHIFT 3 | ||
59 | #define COMN1SW_MASK (0x7 << COMN1SW_SHIFT) | ||
60 | #define COMP2SW_MASK (0x7 << COMP2SW_SHIFT) | ||
61 | #define SW_MASK (COMP2SW_MASK | COMN1SW_MASK) | ||
62 | |||
63 | #define MAX8997_SW_USB ((1 << COMP2SW_SHIFT) | (1 << COMN1SW_SHIFT)) | ||
64 | #define MAX8997_SW_AUDIO ((2 << COMP2SW_SHIFT) | (2 << COMN1SW_SHIFT)) | ||
65 | #define MAX8997_SW_UART ((3 << COMP2SW_SHIFT) | (3 << COMN1SW_SHIFT)) | ||
66 | #define MAX8997_SW_OPEN ((0 << COMP2SW_SHIFT) | (0 << COMN1SW_SHIFT)) | ||
67 | |||
68 | #define MAX8997_ADC_GROUND 0x00 | ||
69 | #define MAX8997_ADC_MHL 0x01 | ||
70 | #define MAX8997_ADC_JIG_USB_1 0x18 | ||
71 | #define MAX8997_ADC_JIG_USB_2 0x19 | ||
72 | #define MAX8997_ADC_DESKDOCK 0x1a | ||
73 | #define MAX8997_ADC_JIG_UART 0x1c | ||
74 | #define MAX8997_ADC_CARDOCK 0x1d | ||
75 | #define MAX8997_ADC_OPEN 0x1f | ||
76 | |||
77 | struct max8997_muic_irq { | ||
78 | unsigned int irq; | ||
79 | const char *name; | ||
80 | }; | ||
81 | |||
82 | static struct max8997_muic_irq muic_irqs[] = { | ||
83 | { MAX8997_MUICIRQ_ADCError, "muic-ADC_error" }, | ||
84 | { MAX8997_MUICIRQ_ADCLow, "muic-ADC_low" }, | ||
85 | { MAX8997_MUICIRQ_ADC, "muic-ADC" }, | ||
86 | { MAX8997_MUICIRQ_VBVolt, "muic-VB_voltage" }, | ||
87 | { MAX8997_MUICIRQ_DBChg, "muic-DB_charger" }, | ||
88 | { MAX8997_MUICIRQ_DCDTmr, "muic-DCD_timer" }, | ||
89 | { MAX8997_MUICIRQ_ChgDetRun, "muic-CDR_status" }, | ||
90 | { MAX8997_MUICIRQ_ChgTyp, "muic-charger_type" }, | ||
91 | { MAX8997_MUICIRQ_OVP, "muic-over_voltage" }, | ||
92 | }; | ||
93 | |||
94 | struct max8997_muic_info { | ||
95 | struct device *dev; | ||
96 | struct i2c_client *muic; | ||
97 | struct max8997_muic_platform_data *muic_pdata; | ||
98 | |||
99 | int irq; | ||
100 | struct work_struct irq_work; | ||
101 | |||
102 | enum max8997_muic_charger_type pre_charger_type; | ||
103 | int pre_adc; | ||
104 | |||
105 | struct mutex mutex; | ||
106 | |||
107 | struct extcon_dev *edev; | ||
108 | }; | ||
109 | |||
110 | const char *max8997_extcon_cable[] = { | ||
111 | [0] = "USB", | ||
112 | [1] = "USB-Host", | ||
113 | [2] = "TA", | ||
114 | [3] = "Fast-charger", | ||
115 | [4] = "Slow-charger", | ||
116 | [5] = "Charge-downstream", | ||
117 | [6] = "MHL", | ||
118 | [7] = "Dock-desk", | ||
119 | [7] = "Dock-card", | ||
120 | [8] = "JIG", | ||
121 | |||
122 | NULL, | ||
123 | }; | ||
124 | |||
125 | static int max8997_muic_handle_usb(struct max8997_muic_info *info, | ||
126 | enum max8997_muic_usb_type usb_type, bool attached) | ||
127 | { | ||
128 | int ret = 0; | ||
129 | |||
130 | if (usb_type == MAX8997_USB_HOST) { | ||
131 | /* switch to USB */ | ||
132 | ret = max8997_update_reg(info->muic, MAX8997_MUIC_REG_CONTROL1, | ||
133 | attached ? MAX8997_SW_USB : MAX8997_SW_OPEN, | ||
134 | SW_MASK); | ||
135 | if (ret) { | ||
136 | dev_err(info->dev, "failed to update muic register\n"); | ||
137 | goto out; | ||
138 | } | ||
139 | } | ||
140 | |||
141 | switch (usb_type) { | ||
142 | case MAX8997_USB_HOST: | ||
143 | extcon_set_cable_state(info->edev, "USB-Host", attached); | ||
144 | break; | ||
145 | case MAX8997_USB_DEVICE: | ||
146 | extcon_set_cable_state(info->edev, "USB", attached); | ||
147 | break; | ||
148 | default: | ||
149 | ret = -EINVAL; | ||
150 | break; | ||
151 | } | ||
152 | |||
153 | out: | ||
154 | return ret; | ||
155 | } | ||
156 | |||
157 | static int max8997_muic_handle_dock(struct max8997_muic_info *info, | ||
158 | int adc, bool attached) | ||
159 | { | ||
160 | int ret = 0; | ||
161 | |||
162 | /* switch to AUDIO */ | ||
163 | ret = max8997_update_reg(info->muic, MAX8997_MUIC_REG_CONTROL1, | ||
164 | attached ? MAX8997_SW_AUDIO : MAX8997_SW_OPEN, | ||
165 | SW_MASK); | ||
166 | if (ret) { | ||
167 | dev_err(info->dev, "failed to update muic register\n"); | ||
168 | goto out; | ||
169 | } | ||
170 | |||
171 | switch (adc) { | ||
172 | case MAX8997_ADC_DESKDOCK: | ||
173 | extcon_set_cable_state(info->edev, "Dock-desk", attached); | ||
174 | break; | ||
175 | case MAX8997_ADC_CARDOCK: | ||
176 | extcon_set_cable_state(info->edev, "Dock-card", attached); | ||
177 | break; | ||
178 | default: | ||
179 | ret = -EINVAL; | ||
180 | break; | ||
181 | } | ||
182 | out: | ||
183 | return ret; | ||
184 | } | ||
185 | |||
186 | static int max8997_muic_handle_jig_uart(struct max8997_muic_info *info, | ||
187 | bool attached) | ||
188 | { | ||
189 | int ret = 0; | ||
190 | |||
191 | /* switch to UART */ | ||
192 | ret = max8997_update_reg(info->muic, MAX8997_MUIC_REG_CONTROL1, | ||
193 | attached ? MAX8997_SW_UART : MAX8997_SW_OPEN, | ||
194 | SW_MASK); | ||
195 | if (ret) { | ||
196 | dev_err(info->dev, "failed to update muic register\n"); | ||
197 | goto out; | ||
198 | } | ||
199 | |||
200 | extcon_set_cable_state(info->edev, "JIG", attached); | ||
201 | out: | ||
202 | return ret; | ||
203 | } | ||
204 | |||
205 | static int max8997_muic_handle_adc_detach(struct max8997_muic_info *info) | ||
206 | { | ||
207 | int ret = 0; | ||
208 | |||
209 | switch (info->pre_adc) { | ||
210 | case MAX8997_ADC_GROUND: | ||
211 | ret = max8997_muic_handle_usb(info, MAX8997_USB_HOST, false); | ||
212 | break; | ||
213 | case MAX8997_ADC_MHL: | ||
214 | extcon_set_cable_state(info->edev, "MHL", false); | ||
215 | break; | ||
216 | case MAX8997_ADC_JIG_USB_1: | ||
217 | case MAX8997_ADC_JIG_USB_2: | ||
218 | ret = max8997_muic_handle_usb(info, MAX8997_USB_DEVICE, false); | ||
219 | break; | ||
220 | case MAX8997_ADC_DESKDOCK: | ||
221 | case MAX8997_ADC_CARDOCK: | ||
222 | ret = max8997_muic_handle_dock(info, info->pre_adc, false); | ||
223 | break; | ||
224 | case MAX8997_ADC_JIG_UART: | ||
225 | ret = max8997_muic_handle_jig_uart(info, false); | ||
226 | break; | ||
227 | default: | ||
228 | break; | ||
229 | } | ||
230 | |||
231 | return ret; | ||
232 | } | ||
233 | |||
234 | static int max8997_muic_handle_adc(struct max8997_muic_info *info, int adc) | ||
235 | { | ||
236 | int ret = 0; | ||
237 | |||
238 | switch (adc) { | ||
239 | case MAX8997_ADC_GROUND: | ||
240 | ret = max8997_muic_handle_usb(info, MAX8997_USB_HOST, true); | ||
241 | break; | ||
242 | case MAX8997_ADC_MHL: | ||
243 | extcon_set_cable_state(info->edev, "MHL", true); | ||
244 | break; | ||
245 | case MAX8997_ADC_JIG_USB_1: | ||
246 | case MAX8997_ADC_JIG_USB_2: | ||
247 | ret = max8997_muic_handle_usb(info, MAX8997_USB_DEVICE, true); | ||
248 | break; | ||
249 | case MAX8997_ADC_DESKDOCK: | ||
250 | case MAX8997_ADC_CARDOCK: | ||
251 | ret = max8997_muic_handle_dock(info, adc, true); | ||
252 | break; | ||
253 | case MAX8997_ADC_JIG_UART: | ||
254 | ret = max8997_muic_handle_jig_uart(info, true); | ||
255 | break; | ||
256 | case MAX8997_ADC_OPEN: | ||
257 | ret = max8997_muic_handle_adc_detach(info); | ||
258 | break; | ||
259 | default: | ||
260 | ret = -EINVAL; | ||
261 | goto out; | ||
262 | } | ||
263 | |||
264 | info->pre_adc = adc; | ||
265 | out: | ||
266 | return ret; | ||
267 | } | ||
268 | |||
269 | static int max8997_muic_handle_charger_type_detach( | ||
270 | struct max8997_muic_info *info) | ||
271 | { | ||
272 | int ret = 0; | ||
273 | |||
274 | switch (info->pre_charger_type) { | ||
275 | case MAX8997_CHARGER_TYPE_USB: | ||
276 | extcon_set_cable_state(info->edev, "USB", false); | ||
277 | break; | ||
278 | case MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT: | ||
279 | extcon_set_cable_state(info->edev, "Charge-downstream", false); | ||
280 | break; | ||
281 | case MAX8997_CHARGER_TYPE_DEDICATED_CHG: | ||
282 | extcon_set_cable_state(info->edev, "TA", false); | ||
283 | break; | ||
284 | case MAX8997_CHARGER_TYPE_500MA: | ||
285 | extcon_set_cable_state(info->edev, "Slow-charger", false); | ||
286 | break; | ||
287 | case MAX8997_CHARGER_TYPE_1A: | ||
288 | extcon_set_cable_state(info->edev, "Fast-charger", false); | ||
289 | break; | ||
290 | default: | ||
291 | ret = -EINVAL; | ||
292 | break; | ||
293 | } | ||
294 | |||
295 | return ret; | ||
296 | } | ||
297 | |||
298 | static int max8997_muic_handle_charger_type(struct max8997_muic_info *info, | ||
299 | enum max8997_muic_charger_type charger_type) | ||
300 | { | ||
301 | u8 adc; | ||
302 | int ret; | ||
303 | |||
304 | ret = max8997_read_reg(info->muic, MAX8997_MUIC_REG_STATUS1, &adc); | ||
305 | if (ret) { | ||
306 | dev_err(info->dev, "failed to read muic register\n"); | ||
307 | goto out; | ||
308 | } | ||
309 | |||
310 | switch (charger_type) { | ||
311 | case MAX8997_CHARGER_TYPE_NONE: | ||
312 | ret = max8997_muic_handle_charger_type_detach(info); | ||
313 | break; | ||
314 | case MAX8997_CHARGER_TYPE_USB: | ||
315 | if ((adc & STATUS1_ADC_MASK) == MAX8997_ADC_OPEN) { | ||
316 | max8997_muic_handle_usb(info, | ||
317 | MAX8997_USB_DEVICE, true); | ||
318 | } | ||
319 | break; | ||
320 | case MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT: | ||
321 | extcon_set_cable_state(info->edev, "Charge-downstream", true); | ||
322 | break; | ||
323 | case MAX8997_CHARGER_TYPE_DEDICATED_CHG: | ||
324 | extcon_set_cable_state(info->edev, "TA", true); | ||
325 | break; | ||
326 | case MAX8997_CHARGER_TYPE_500MA: | ||
327 | extcon_set_cable_state(info->edev, "Slow-charger", true); | ||
328 | break; | ||
329 | case MAX8997_CHARGER_TYPE_1A: | ||
330 | extcon_set_cable_state(info->edev, "Fast-charger", true); | ||
331 | break; | ||
332 | default: | ||
333 | ret = -EINVAL; | ||
334 | goto out; | ||
335 | } | ||
336 | |||
337 | info->pre_charger_type = charger_type; | ||
338 | out: | ||
339 | return ret; | ||
340 | } | ||
341 | |||
342 | static void max8997_muic_irq_work(struct work_struct *work) | ||
343 | { | ||
344 | struct max8997_muic_info *info = container_of(work, | ||
345 | struct max8997_muic_info, irq_work); | ||
346 | struct max8997_dev *max8997 = i2c_get_clientdata(info->muic); | ||
347 | u8 status[2]; | ||
348 | u8 adc, chg_type; | ||
349 | |||
350 | int irq_type = info->irq - max8997->irq_base; | ||
351 | int ret; | ||
352 | |||
353 | mutex_lock(&info->mutex); | ||
354 | |||
355 | ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1, | ||
356 | 2, status); | ||
357 | if (ret) { | ||
358 | dev_err(info->dev, "failed to read muic register\n"); | ||
359 | mutex_unlock(&info->mutex); | ||
360 | return; | ||
361 | } | ||
362 | |||
363 | dev_dbg(info->dev, "%s: STATUS1:0x%x, 2:0x%x\n", __func__, | ||
364 | status[0], status[1]); | ||
365 | |||
366 | switch (irq_type) { | ||
367 | case MAX8997_MUICIRQ_ADC: | ||
368 | adc = status[0] & STATUS1_ADC_MASK; | ||
369 | adc >>= STATUS1_ADC_SHIFT; | ||
370 | |||
371 | max8997_muic_handle_adc(info, adc); | ||
372 | break; | ||
373 | case MAX8997_MUICIRQ_ChgTyp: | ||
374 | chg_type = status[1] & STATUS2_CHGTYP_MASK; | ||
375 | chg_type >>= STATUS2_CHGTYP_SHIFT; | ||
376 | |||
377 | max8997_muic_handle_charger_type(info, chg_type); | ||
378 | break; | ||
379 | default: | ||
380 | dev_info(info->dev, "misc interrupt: irq %d occurred\n", | ||
381 | irq_type); | ||
382 | break; | ||
383 | } | ||
384 | |||
385 | mutex_unlock(&info->mutex); | ||
386 | |||
387 | return; | ||
388 | } | ||
389 | |||
390 | static irqreturn_t max8997_muic_irq_handler(int irq, void *data) | ||
391 | { | ||
392 | struct max8997_muic_info *info = data; | ||
393 | |||
394 | dev_dbg(info->dev, "irq:%d\n", irq); | ||
395 | info->irq = irq; | ||
396 | |||
397 | schedule_work(&info->irq_work); | ||
398 | |||
399 | return IRQ_HANDLED; | ||
400 | } | ||
401 | |||
402 | static void max8997_muic_detect_dev(struct max8997_muic_info *info) | ||
403 | { | ||
404 | int ret; | ||
405 | u8 status[2], adc, chg_type; | ||
406 | |||
407 | ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1, | ||
408 | 2, status); | ||
409 | if (ret) { | ||
410 | dev_err(info->dev, "failed to read muic register\n"); | ||
411 | return; | ||
412 | } | ||
413 | |||
414 | dev_info(info->dev, "STATUS1:0x%x, STATUS2:0x%x\n", | ||
415 | status[0], status[1]); | ||
416 | |||
417 | adc = status[0] & STATUS1_ADC_MASK; | ||
418 | adc >>= STATUS1_ADC_SHIFT; | ||
419 | |||
420 | chg_type = status[1] & STATUS2_CHGTYP_MASK; | ||
421 | chg_type >>= STATUS2_CHGTYP_SHIFT; | ||
422 | |||
423 | max8997_muic_handle_adc(info, adc); | ||
424 | max8997_muic_handle_charger_type(info, chg_type); | ||
425 | } | ||
426 | |||
427 | static int __devinit max8997_muic_probe(struct platform_device *pdev) | ||
428 | { | ||
429 | struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent); | ||
430 | struct max8997_platform_data *pdata = dev_get_platdata(max8997->dev); | ||
431 | struct max8997_muic_info *info; | ||
432 | int ret, i; | ||
433 | |||
434 | info = kzalloc(sizeof(struct max8997_muic_info), GFP_KERNEL); | ||
435 | if (!info) { | ||
436 | dev_err(&pdev->dev, "failed to allocate memory\n"); | ||
437 | ret = -ENOMEM; | ||
438 | goto err_kfree; | ||
439 | } | ||
440 | |||
441 | info->dev = &pdev->dev; | ||
442 | info->muic = max8997->muic; | ||
443 | |||
444 | platform_set_drvdata(pdev, info); | ||
445 | mutex_init(&info->mutex); | ||
446 | |||
447 | INIT_WORK(&info->irq_work, max8997_muic_irq_work); | ||
448 | |||
449 | for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) { | ||
450 | struct max8997_muic_irq *muic_irq = &muic_irqs[i]; | ||
451 | |||
452 | ret = request_threaded_irq(pdata->irq_base + muic_irq->irq, | ||
453 | NULL, max8997_muic_irq_handler, | ||
454 | 0, muic_irq->name, | ||
455 | info); | ||
456 | if (ret) { | ||
457 | dev_err(&pdev->dev, | ||
458 | "failed: irq request (IRQ: %d," | ||
459 | " error :%d)\n", | ||
460 | muic_irq->irq, ret); | ||
461 | |||
462 | for (i = i - 1; i >= 0; i--) | ||
463 | free_irq(muic_irq->irq, info); | ||
464 | |||
465 | goto err_irq; | ||
466 | } | ||
467 | } | ||
468 | |||
469 | /* External connector */ | ||
470 | info->edev = kzalloc(sizeof(struct extcon_dev), GFP_KERNEL); | ||
471 | if (!info->edev) { | ||
472 | dev_err(&pdev->dev, "failed to allocate memory for extcon\n"); | ||
473 | ret = -ENOMEM; | ||
474 | goto err_irq; | ||
475 | } | ||
476 | info->edev->name = DEV_NAME; | ||
477 | info->edev->supported_cable = max8997_extcon_cable; | ||
478 | ret = extcon_dev_register(info->edev, NULL); | ||
479 | if (ret) { | ||
480 | dev_err(&pdev->dev, "failed to register extcon device\n"); | ||
481 | goto err_extcon; | ||
482 | } | ||
483 | |||
484 | /* Initialize registers according to platform data */ | ||
485 | if (pdata->muic_pdata) { | ||
486 | struct max8997_muic_platform_data *mdata = info->muic_pdata; | ||
487 | |||
488 | for (i = 0; i < mdata->num_init_data; i++) { | ||
489 | max8997_write_reg(info->muic, mdata->init_data[i].addr, | ||
490 | mdata->init_data[i].data); | ||
491 | } | ||
492 | } | ||
493 | |||
494 | /* Initial device detection */ | ||
495 | max8997_muic_detect_dev(info); | ||
496 | |||
497 | return ret; | ||
498 | |||
499 | err_extcon: | ||
500 | kfree(info->edev); | ||
501 | err_irq: | ||
502 | kfree(info); | ||
503 | err_kfree: | ||
504 | return ret; | ||
505 | } | ||
506 | |||
507 | static int __devexit max8997_muic_remove(struct platform_device *pdev) | ||
508 | { | ||
509 | struct max8997_muic_info *info = platform_get_drvdata(pdev); | ||
510 | struct max8997_dev *max8997 = i2c_get_clientdata(info->muic); | ||
511 | int i; | ||
512 | |||
513 | for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) | ||
514 | free_irq(max8997->irq_base + muic_irqs[i].irq, info); | ||
515 | cancel_work_sync(&info->irq_work); | ||
516 | |||
517 | extcon_dev_unregister(info->edev); | ||
518 | |||
519 | kfree(info); | ||
520 | |||
521 | return 0; | ||
522 | } | ||
523 | |||
524 | static struct platform_driver max8997_muic_driver = { | ||
525 | .driver = { | ||
526 | .name = DEV_NAME, | ||
527 | .owner = THIS_MODULE, | ||
528 | }, | ||
529 | .probe = max8997_muic_probe, | ||
530 | .remove = __devexit_p(max8997_muic_remove), | ||
531 | }; | ||
532 | |||
533 | module_platform_driver(max8997_muic_driver); | ||
534 | |||
535 | MODULE_DESCRIPTION("Maxim MAX8997 Extcon driver"); | ||
536 | MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>"); | ||
537 | MODULE_LICENSE("GPL"); | ||