Commit | Line | Data |
---|---|---|
1213a366 KK |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | // | |
3 | // extcon-max8997.c - MAX8997 extcon driver to support MAX8997 MUIC | |
4 | // | |
5 | // Copyright (C) 2012 Samsung Electronics | |
6 | // Donggeun Kim <dg77.kim@samsung.com> | |
99f09beb DK |
7 | |
8 | #include <linux/kernel.h> | |
9 | #include <linux/module.h> | |
10 | #include <linux/i2c.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/interrupt.h> | |
13 | #include <linux/err.h> | |
14 | #include <linux/platform_device.h> | |
15 | #include <linux/kobject.h> | |
16 | #include <linux/mfd/max8997.h> | |
17 | #include <linux/mfd/max8997-private.h> | |
176aa360 | 18 | #include <linux/extcon-provider.h> |
dca1a71e | 19 | #include <linux/irqdomain.h> |
b76668ba CC |
20 | |
21 | #define DEV_NAME "max8997-muic" | |
af5eb1a1 | 22 | #define DELAY_MS_DEFAULT 20000 /* unit: millisecond */ |
99f09beb | 23 | |
027fcd50 CC |
24 | enum max8997_muic_adc_debounce_time { |
25 | ADC_DEBOUNCE_TIME_0_5MS = 0, /* 0.5ms */ | |
26 | ADC_DEBOUNCE_TIME_10MS, /* 10ms */ | |
27 | ADC_DEBOUNCE_TIME_25MS, /* 25ms */ | |
28 | ADC_DEBOUNCE_TIME_38_62MS, /* 38.62ms */ | |
29 | }; | |
30 | ||
99f09beb DK |
31 | struct max8997_muic_irq { |
32 | unsigned int irq; | |
33 | const char *name; | |
dca1a71e | 34 | unsigned int virq; |
99f09beb DK |
35 | }; |
36 | ||
37 | static struct max8997_muic_irq muic_irqs[] = { | |
f73f6232 CC |
38 | { MAX8997_MUICIRQ_ADCError, "muic-ADCERROR" }, |
39 | { MAX8997_MUICIRQ_ADCLow, "muic-ADCLOW" }, | |
40 | { MAX8997_MUICIRQ_ADC, "muic-ADC" }, | |
41 | { MAX8997_MUICIRQ_VBVolt, "muic-VBVOLT" }, | |
42 | { MAX8997_MUICIRQ_DBChg, "muic-DBCHG" }, | |
43 | { MAX8997_MUICIRQ_DCDTmr, "muic-DCDTMR" }, | |
44 | { MAX8997_MUICIRQ_ChgDetRun, "muic-CHGDETRUN" }, | |
45 | { MAX8997_MUICIRQ_ChgTyp, "muic-CHGTYP" }, | |
46 | { MAX8997_MUICIRQ_OVP, "muic-OVP" }, | |
47 | }; | |
48 | ||
49 | /* Define supported cable type */ | |
50 | enum max8997_muic_acc_type { | |
51 | MAX8997_MUIC_ADC_GROUND = 0x0, | |
52 | MAX8997_MUIC_ADC_MHL, /* MHL*/ | |
53 | MAX8997_MUIC_ADC_REMOTE_S1_BUTTON, | |
54 | MAX8997_MUIC_ADC_REMOTE_S2_BUTTON, | |
55 | MAX8997_MUIC_ADC_REMOTE_S3_BUTTON, | |
56 | MAX8997_MUIC_ADC_REMOTE_S4_BUTTON, | |
57 | MAX8997_MUIC_ADC_REMOTE_S5_BUTTON, | |
58 | MAX8997_MUIC_ADC_REMOTE_S6_BUTTON, | |
59 | MAX8997_MUIC_ADC_REMOTE_S7_BUTTON, | |
60 | MAX8997_MUIC_ADC_REMOTE_S8_BUTTON, | |
61 | MAX8997_MUIC_ADC_REMOTE_S9_BUTTON, | |
62 | MAX8997_MUIC_ADC_REMOTE_S10_BUTTON, | |
63 | MAX8997_MUIC_ADC_REMOTE_S11_BUTTON, | |
64 | MAX8997_MUIC_ADC_REMOTE_S12_BUTTON, | |
65 | MAX8997_MUIC_ADC_RESERVED_ACC_1, | |
66 | MAX8997_MUIC_ADC_RESERVED_ACC_2, | |
67 | MAX8997_MUIC_ADC_RESERVED_ACC_3, | |
68 | MAX8997_MUIC_ADC_RESERVED_ACC_4, | |
69 | MAX8997_MUIC_ADC_RESERVED_ACC_5, | |
70 | MAX8997_MUIC_ADC_CEA936_AUDIO, | |
71 | MAX8997_MUIC_ADC_PHONE_POWERED_DEV, | |
72 | MAX8997_MUIC_ADC_TTY_CONVERTER, | |
73 | MAX8997_MUIC_ADC_UART_CABLE, | |
74 | MAX8997_MUIC_ADC_CEA936A_TYPE1_CHG, | |
75 | MAX8997_MUIC_ADC_FACTORY_MODE_USB_OFF, /* JIG-USB-OFF */ | |
76 | MAX8997_MUIC_ADC_FACTORY_MODE_USB_ON, /* JIG-USB-ON */ | |
77 | MAX8997_MUIC_ADC_AV_CABLE_NOLOAD, /* DESKDOCK */ | |
78 | MAX8997_MUIC_ADC_CEA936A_TYPE2_CHG, | |
79 | MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF, /* JIG-UART */ | |
80 | MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON, /* CARDOCK */ | |
81 | MAX8997_MUIC_ADC_AUDIO_MODE_REMOTE, | |
82 | MAX8997_MUIC_ADC_OPEN, /* OPEN */ | |
83 | }; | |
84 | ||
85 | enum max8997_muic_cable_group { | |
86 | MAX8997_CABLE_GROUP_ADC = 0, | |
87 | MAX8997_CABLE_GROUP_ADC_GND, | |
88 | MAX8997_CABLE_GROUP_CHG, | |
89 | MAX8997_CABLE_GROUP_VBVOLT, | |
90 | }; | |
91 | ||
92 | enum max8997_muic_usb_type { | |
93 | MAX8997_USB_HOST, | |
94 | MAX8997_USB_DEVICE, | |
95 | }; | |
96 | ||
97 | enum max8997_muic_charger_type { | |
98 | MAX8997_CHARGER_TYPE_NONE = 0, | |
99 | MAX8997_CHARGER_TYPE_USB, | |
100 | MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT, | |
101 | MAX8997_CHARGER_TYPE_DEDICATED_CHG, | |
102 | MAX8997_CHARGER_TYPE_500MA, | |
103 | MAX8997_CHARGER_TYPE_1A, | |
104 | MAX8997_CHARGER_TYPE_DEAD_BATTERY = 7, | |
99f09beb DK |
105 | }; |
106 | ||
107 | struct max8997_muic_info { | |
108 | struct device *dev; | |
99f09beb | 109 | struct i2c_client *muic; |
f73f6232 CC |
110 | struct extcon_dev *edev; |
111 | int prev_cable_type; | |
112 | int prev_chg_type; | |
113 | u8 status[2]; | |
99f09beb DK |
114 | |
115 | int irq; | |
116 | struct work_struct irq_work; | |
99f09beb | 117 | struct mutex mutex; |
b76668ba | 118 | |
f73f6232 CC |
119 | struct max8997_muic_platform_data *muic_pdata; |
120 | enum max8997_muic_charger_type pre_charger_type; | |
685dc9a7 | 121 | |
af5eb1a1 CC |
122 | /* |
123 | * Use delayed workqueue to detect cable state and then | |
124 | * notify cable state to notifiee/platform through uevent. | |
125 | * After completing the booting of platform, the extcon provider | |
126 | * driver should notify cable state to upper layer. | |
127 | */ | |
128 | struct delayed_work wq_detcable; | |
129 | ||
685dc9a7 CC |
130 | /* |
131 | * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB | |
132 | * h/w path of COMP2/COMN1 on CONTROL1 register. | |
133 | */ | |
134 | int path_usb; | |
135 | int path_uart; | |
b76668ba CC |
136 | }; |
137 | ||
73b6ecdb | 138 | static const unsigned int max8997_extcon_cable[] = { |
2a9de9c0 CC |
139 | EXTCON_USB, |
140 | EXTCON_USB_HOST, | |
8b45b6a0 | 141 | EXTCON_CHG_USB_SDP, |
11eecf91 CC |
142 | EXTCON_CHG_USB_DCP, |
143 | EXTCON_CHG_USB_FAST, | |
144 | EXTCON_CHG_USB_SLOW, | |
145 | EXTCON_CHG_USB_CDP, | |
146 | EXTCON_DISP_MHL, | |
2a9de9c0 CC |
147 | EXTCON_DOCK, |
148 | EXTCON_JIG, | |
149 | EXTCON_NONE, | |
99f09beb DK |
150 | }; |
151 | ||
027fcd50 CC |
152 | /* |
153 | * max8997_muic_set_debounce_time - Set the debounce time of ADC | |
154 | * @info: the instance including private data of max8997 MUIC | |
155 | * @time: the debounce time of ADC | |
156 | */ | |
157 | static int max8997_muic_set_debounce_time(struct max8997_muic_info *info, | |
158 | enum max8997_muic_adc_debounce_time time) | |
159 | { | |
160 | int ret; | |
161 | ||
162 | switch (time) { | |
163 | case ADC_DEBOUNCE_TIME_0_5MS: | |
164 | case ADC_DEBOUNCE_TIME_10MS: | |
165 | case ADC_DEBOUNCE_TIME_25MS: | |
166 | case ADC_DEBOUNCE_TIME_38_62MS: | |
167 | ret = max8997_update_reg(info->muic, | |
168 | MAX8997_MUIC_REG_CONTROL3, | |
169 | time << CONTROL3_ADCDBSET_SHIFT, | |
170 | CONTROL3_ADCDBSET_MASK); | |
171 | if (ret) { | |
172 | dev_err(info->dev, "failed to set ADC debounce time\n"); | |
3ad9e86d | 173 | return ret; |
027fcd50 CC |
174 | } |
175 | break; | |
176 | default: | |
177 | dev_err(info->dev, "invalid ADC debounce time\n"); | |
178 | return -EINVAL; | |
179 | } | |
180 | ||
181 | return 0; | |
182 | }; | |
183 | ||
07c70503 CC |
184 | /* |
185 | * max8997_muic_set_path - Set hardware line according to attached cable | |
186 | * @info: the instance including private data of max8997 MUIC | |
187 | * @value: the path according to attached cable | |
188 | * @attached: the state of cable (true:attached, false:detached) | |
189 | * | |
190 | * The max8997 MUIC device share outside H/W line among a varity of cables, | |
191 | * so this function set internal path of H/W line according to the type of | |
192 | * attached cable. | |
193 | */ | |
194 | static int max8997_muic_set_path(struct max8997_muic_info *info, | |
195 | u8 val, bool attached) | |
196 | { | |
00c2f524 | 197 | int ret; |
07c70503 CC |
198 | u8 ctrl1, ctrl2 = 0; |
199 | ||
200 | if (attached) | |
201 | ctrl1 = val; | |
202 | else | |
203 | ctrl1 = CONTROL1_SW_OPEN; | |
204 | ||
205 | ret = max8997_update_reg(info->muic, | |
206 | MAX8997_MUIC_REG_CONTROL1, ctrl1, COMP_SW_MASK); | |
207 | if (ret < 0) { | |
208 | dev_err(info->dev, "failed to update MUIC register\n"); | |
3ad9e86d | 209 | return ret; |
07c70503 CC |
210 | } |
211 | ||
212 | if (attached) | |
213 | ctrl2 |= CONTROL2_CPEN_MASK; /* LowPwr=0, CPEn=1 */ | |
214 | else | |
215 | ctrl2 |= CONTROL2_LOWPWR_MASK; /* LowPwr=1, CPEn=0 */ | |
216 | ||
217 | ret = max8997_update_reg(info->muic, | |
218 | MAX8997_MUIC_REG_CONTROL2, ctrl2, | |
219 | CONTROL2_LOWPWR_MASK | CONTROL2_CPEN_MASK); | |
220 | if (ret < 0) { | |
221 | dev_err(info->dev, "failed to update MUIC register\n"); | |
3ad9e86d | 222 | return ret; |
07c70503 CC |
223 | } |
224 | ||
225 | dev_info(info->dev, | |
226 | "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n", | |
227 | ctrl1, ctrl2, attached ? "attached" : "detached"); | |
228 | ||
229 | return 0; | |
230 | } | |
231 | ||
f73f6232 CC |
232 | /* |
233 | * max8997_muic_get_cable_type - Return cable type and check cable state | |
234 | * @info: the instance including private data of max8997 MUIC | |
235 | * @group: the path according to attached cable | |
236 | * @attached: store cable state and return | |
237 | * | |
238 | * This function check the cable state either attached or detached, | |
239 | * and then divide precise type of cable according to cable group. | |
240 | * - MAX8997_CABLE_GROUP_ADC | |
241 | * - MAX8997_CABLE_GROUP_CHG | |
242 | */ | |
243 | static int max8997_muic_get_cable_type(struct max8997_muic_info *info, | |
244 | enum max8997_muic_cable_group group, bool *attached) | |
245 | { | |
246 | int cable_type = 0; | |
247 | int adc; | |
248 | int chg_type; | |
249 | ||
250 | switch (group) { | |
251 | case MAX8997_CABLE_GROUP_ADC: | |
252 | /* | |
253 | * Read ADC value to check cable type and decide cable state | |
254 | * according to cable type | |
255 | */ | |
256 | adc = info->status[0] & STATUS1_ADC_MASK; | |
257 | adc >>= STATUS1_ADC_SHIFT; | |
258 | ||
259 | /* | |
260 | * Check current cable state/cable type and store cable type | |
261 | * (info->prev_cable_type) for handling cable when cable is | |
262 | * detached. | |
263 | */ | |
264 | if (adc == MAX8997_MUIC_ADC_OPEN) { | |
265 | *attached = false; | |
266 | ||
267 | cable_type = info->prev_cable_type; | |
268 | info->prev_cable_type = MAX8997_MUIC_ADC_OPEN; | |
269 | } else { | |
270 | *attached = true; | |
271 | ||
272 | cable_type = info->prev_cable_type = adc; | |
273 | } | |
274 | break; | |
275 | case MAX8997_CABLE_GROUP_CHG: | |
276 | /* | |
277 | * Read charger type to check cable type and decide cable state | |
278 | * according to type of charger cable. | |
279 | */ | |
280 | chg_type = info->status[1] & STATUS2_CHGTYP_MASK; | |
281 | chg_type >>= STATUS2_CHGTYP_SHIFT; | |
282 | ||
283 | if (chg_type == MAX8997_CHARGER_TYPE_NONE) { | |
284 | *attached = false; | |
285 | ||
286 | cable_type = info->prev_chg_type; | |
287 | info->prev_chg_type = MAX8997_CHARGER_TYPE_NONE; | |
288 | } else { | |
289 | *attached = true; | |
290 | ||
291 | /* | |
292 | * Check current cable state/cable type and store cable | |
293 | * type(info->prev_chg_type) for handling cable when | |
294 | * charger cable is detached. | |
295 | */ | |
296 | cable_type = info->prev_chg_type = chg_type; | |
297 | } | |
298 | ||
299 | break; | |
300 | default: | |
301 | dev_err(info->dev, "Unknown cable group (%d)\n", group); | |
302 | cable_type = -EINVAL; | |
303 | break; | |
304 | } | |
305 | ||
306 | return cable_type; | |
307 | } | |
308 | ||
99f09beb DK |
309 | static int max8997_muic_handle_usb(struct max8997_muic_info *info, |
310 | enum max8997_muic_usb_type usb_type, bool attached) | |
311 | { | |
99f09beb DK |
312 | int ret = 0; |
313 | ||
a2dc5091 MS |
314 | ret = max8997_muic_set_path(info, info->path_usb, attached); |
315 | if (ret < 0) { | |
316 | dev_err(info->dev, "failed to update muic register\n"); | |
317 | return ret; | |
99f09beb DK |
318 | } |
319 | ||
b76668ba CC |
320 | switch (usb_type) { |
321 | case MAX8997_USB_HOST: | |
8670b459 | 322 | extcon_set_state_sync(info->edev, EXTCON_USB_HOST, attached); |
b76668ba CC |
323 | break; |
324 | case MAX8997_USB_DEVICE: | |
8670b459 CC |
325 | extcon_set_state_sync(info->edev, EXTCON_USB, attached); |
326 | extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP, | |
8b45b6a0 | 327 | attached); |
b76668ba CC |
328 | break; |
329 | default: | |
f73f6232 CC |
330 | dev_err(info->dev, "failed to detect %s usb cable\n", |
331 | attached ? "attached" : "detached"); | |
332 | return -EINVAL; | |
b76668ba CC |
333 | } |
334 | ||
f73f6232 | 335 | return 0; |
99f09beb DK |
336 | } |
337 | ||
99f09beb | 338 | static int max8997_muic_handle_dock(struct max8997_muic_info *info, |
f73f6232 | 339 | int cable_type, bool attached) |
99f09beb | 340 | { |
99f09beb DK |
341 | int ret = 0; |
342 | ||
07c70503 | 343 | ret = max8997_muic_set_path(info, CONTROL1_SW_AUDIO, attached); |
99f09beb DK |
344 | if (ret) { |
345 | dev_err(info->dev, "failed to update muic register\n"); | |
f73f6232 | 346 | return ret; |
99f09beb DK |
347 | } |
348 | ||
f73f6232 CC |
349 | switch (cable_type) { |
350 | case MAX8997_MUIC_ADC_AV_CABLE_NOLOAD: | |
f73f6232 | 351 | case MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON: |
8670b459 | 352 | extcon_set_state_sync(info->edev, EXTCON_DOCK, attached); |
99f09beb DK |
353 | break; |
354 | default: | |
f73f6232 CC |
355 | dev_err(info->dev, "failed to detect %s dock device\n", |
356 | attached ? "attached" : "detached"); | |
357 | return -EINVAL; | |
99f09beb | 358 | } |
f73f6232 CC |
359 | |
360 | return 0; | |
99f09beb DK |
361 | } |
362 | ||
363 | static int max8997_muic_handle_jig_uart(struct max8997_muic_info *info, | |
364 | bool attached) | |
365 | { | |
99f09beb DK |
366 | int ret = 0; |
367 | ||
368 | /* switch to UART */ | |
685dc9a7 | 369 | ret = max8997_muic_set_path(info, info->path_uart, attached); |
99f09beb DK |
370 | if (ret) { |
371 | dev_err(info->dev, "failed to update muic register\n"); | |
3ad9e86d | 372 | return ret; |
99f09beb DK |
373 | } |
374 | ||
8670b459 | 375 | extcon_set_state_sync(info->edev, EXTCON_JIG, attached); |
99f09beb | 376 | |
f73f6232 | 377 | return 0; |
99f09beb DK |
378 | } |
379 | ||
f73f6232 | 380 | static int max8997_muic_adc_handler(struct max8997_muic_info *info) |
99f09beb | 381 | { |
f73f6232 CC |
382 | int cable_type; |
383 | bool attached; | |
99f09beb DK |
384 | int ret = 0; |
385 | ||
f73f6232 CC |
386 | /* Check cable state which is either detached or attached */ |
387 | cable_type = max8997_muic_get_cable_type(info, | |
388 | MAX8997_CABLE_GROUP_ADC, &attached); | |
389 | ||
390 | switch (cable_type) { | |
391 | case MAX8997_MUIC_ADC_GROUND: | |
392 | ret = max8997_muic_handle_usb(info, MAX8997_USB_HOST, attached); | |
393 | if (ret < 0) | |
394 | return ret; | |
395 | break; | |
396 | case MAX8997_MUIC_ADC_MHL: | |
8670b459 | 397 | extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, attached); |
f73f6232 CC |
398 | break; |
399 | case MAX8997_MUIC_ADC_FACTORY_MODE_USB_OFF: | |
400 | case MAX8997_MUIC_ADC_FACTORY_MODE_USB_ON: | |
c2275d2f CC |
401 | ret = max8997_muic_handle_usb(info, |
402 | MAX8997_USB_DEVICE, attached); | |
f73f6232 CC |
403 | if (ret < 0) |
404 | return ret; | |
405 | break; | |
406 | case MAX8997_MUIC_ADC_AV_CABLE_NOLOAD: | |
407 | case MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON: | |
408 | ret = max8997_muic_handle_dock(info, cable_type, attached); | |
409 | if (ret < 0) | |
410 | return ret; | |
411 | break; | |
412 | case MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF: | |
413 | ret = max8997_muic_handle_jig_uart(info, attached); | |
414 | break; | |
415 | case MAX8997_MUIC_ADC_REMOTE_S1_BUTTON: | |
416 | case MAX8997_MUIC_ADC_REMOTE_S2_BUTTON: | |
417 | case MAX8997_MUIC_ADC_REMOTE_S3_BUTTON: | |
418 | case MAX8997_MUIC_ADC_REMOTE_S4_BUTTON: | |
419 | case MAX8997_MUIC_ADC_REMOTE_S5_BUTTON: | |
420 | case MAX8997_MUIC_ADC_REMOTE_S6_BUTTON: | |
421 | case MAX8997_MUIC_ADC_REMOTE_S7_BUTTON: | |
422 | case MAX8997_MUIC_ADC_REMOTE_S8_BUTTON: | |
423 | case MAX8997_MUIC_ADC_REMOTE_S9_BUTTON: | |
424 | case MAX8997_MUIC_ADC_REMOTE_S10_BUTTON: | |
425 | case MAX8997_MUIC_ADC_REMOTE_S11_BUTTON: | |
426 | case MAX8997_MUIC_ADC_REMOTE_S12_BUTTON: | |
427 | case MAX8997_MUIC_ADC_RESERVED_ACC_1: | |
428 | case MAX8997_MUIC_ADC_RESERVED_ACC_2: | |
429 | case MAX8997_MUIC_ADC_RESERVED_ACC_3: | |
430 | case MAX8997_MUIC_ADC_RESERVED_ACC_4: | |
431 | case MAX8997_MUIC_ADC_RESERVED_ACC_5: | |
432 | case MAX8997_MUIC_ADC_CEA936_AUDIO: | |
433 | case MAX8997_MUIC_ADC_PHONE_POWERED_DEV: | |
434 | case MAX8997_MUIC_ADC_TTY_CONVERTER: | |
435 | case MAX8997_MUIC_ADC_UART_CABLE: | |
436 | case MAX8997_MUIC_ADC_CEA936A_TYPE1_CHG: | |
437 | case MAX8997_MUIC_ADC_CEA936A_TYPE2_CHG: | |
438 | case MAX8997_MUIC_ADC_AUDIO_MODE_REMOTE: | |
439 | /* | |
440 | * This cable isn't used in general case if it is specially | |
441 | * needed to detect additional cable, should implement | |
442 | * proper operation when this cable is attached/detached. | |
443 | */ | |
444 | dev_info(info->dev, | |
445 | "cable is %s but it isn't used (type:0x%x)\n", | |
446 | attached ? "attached" : "detached", cable_type); | |
447 | return -EAGAIN; | |
b76668ba | 448 | default: |
f73f6232 CC |
449 | dev_err(info->dev, |
450 | "failed to detect %s unknown cable (type:0x%x)\n", | |
451 | attached ? "attached" : "detached", cable_type); | |
3cafbd4e | 452 | return -EINVAL; |
b76668ba | 453 | } |
99f09beb | 454 | |
3cafbd4e | 455 | return 0; |
99f09beb DK |
456 | } |
457 | ||
f73f6232 | 458 | static int max8997_muic_chg_handler(struct max8997_muic_info *info) |
99f09beb | 459 | { |
f73f6232 CC |
460 | int chg_type; |
461 | bool attached; | |
462 | int adc; | |
99f09beb | 463 | |
f73f6232 CC |
464 | chg_type = max8997_muic_get_cable_type(info, |
465 | MAX8997_CABLE_GROUP_CHG, &attached); | |
99f09beb | 466 | |
f73f6232 | 467 | switch (chg_type) { |
99f09beb | 468 | case MAX8997_CHARGER_TYPE_NONE: |
99f09beb DK |
469 | break; |
470 | case MAX8997_CHARGER_TYPE_USB: | |
f73f6232 CC |
471 | adc = info->status[0] & STATUS1_ADC_MASK; |
472 | adc >>= STATUS1_ADC_SHIFT; | |
473 | ||
474 | if ((adc & STATUS1_ADC_MASK) == MAX8997_MUIC_ADC_OPEN) { | |
99f09beb | 475 | max8997_muic_handle_usb(info, |
f73f6232 | 476 | MAX8997_USB_DEVICE, attached); |
99f09beb | 477 | } |
99f09beb DK |
478 | break; |
479 | case MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT: | |
8670b459 | 480 | extcon_set_state_sync(info->edev, EXTCON_CHG_USB_CDP, |
2a9de9c0 | 481 | attached); |
b76668ba | 482 | break; |
99f09beb | 483 | case MAX8997_CHARGER_TYPE_DEDICATED_CHG: |
8670b459 | 484 | extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP, |
11eecf91 | 485 | attached); |
b76668ba | 486 | break; |
99f09beb | 487 | case MAX8997_CHARGER_TYPE_500MA: |
8670b459 | 488 | extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SLOW, |
2a9de9c0 | 489 | attached); |
b76668ba | 490 | break; |
99f09beb | 491 | case MAX8997_CHARGER_TYPE_1A: |
8670b459 | 492 | extcon_set_state_sync(info->edev, EXTCON_CHG_USB_FAST, |
2a9de9c0 | 493 | attached); |
99f09beb DK |
494 | break; |
495 | default: | |
f73f6232 CC |
496 | dev_err(info->dev, |
497 | "failed to detect %s unknown chg cable (type:0x%x)\n", | |
498 | attached ? "attached" : "detached", chg_type); | |
499 | return -EINVAL; | |
99f09beb DK |
500 | } |
501 | ||
f73f6232 | 502 | return 0; |
99f09beb DK |
503 | } |
504 | ||
505 | static void max8997_muic_irq_work(struct work_struct *work) | |
506 | { | |
507 | struct max8997_muic_info *info = container_of(work, | |
508 | struct max8997_muic_info, irq_work); | |
dca1a71e CC |
509 | int irq_type = 0; |
510 | int i, ret; | |
99f09beb | 511 | |
f73f6232 CC |
512 | if (!info->edev) |
513 | return; | |
514 | ||
99f09beb DK |
515 | mutex_lock(&info->mutex); |
516 | ||
ad07d8b4 | 517 | for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) |
f73f6232 CC |
518 | if (info->irq == muic_irqs[i].virq) |
519 | irq_type = muic_irqs[i].irq; | |
520 | ||
99f09beb | 521 | ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1, |
f73f6232 | 522 | 2, info->status); |
99f09beb DK |
523 | if (ret) { |
524 | dev_err(info->dev, "failed to read muic register\n"); | |
525 | mutex_unlock(&info->mutex); | |
526 | return; | |
527 | } | |
528 | ||
99f09beb | 529 | switch (irq_type) { |
f73f6232 CC |
530 | case MAX8997_MUICIRQ_ADCError: |
531 | case MAX8997_MUICIRQ_ADCLow: | |
99f09beb | 532 | case MAX8997_MUICIRQ_ADC: |
f73f6232 CC |
533 | /* Handle all of cable except for charger cable */ |
534 | ret = max8997_muic_adc_handler(info); | |
99f09beb | 535 | break; |
f73f6232 CC |
536 | case MAX8997_MUICIRQ_VBVolt: |
537 | case MAX8997_MUICIRQ_DBChg: | |
538 | case MAX8997_MUICIRQ_DCDTmr: | |
539 | case MAX8997_MUICIRQ_ChgDetRun: | |
99f09beb | 540 | case MAX8997_MUICIRQ_ChgTyp: |
f73f6232 CC |
541 | /* Handle charger cable */ |
542 | ret = max8997_muic_chg_handler(info); | |
543 | break; | |
544 | case MAX8997_MUICIRQ_OVP: | |
99f09beb DK |
545 | break; |
546 | default: | |
b76668ba CC |
547 | dev_info(info->dev, "misc interrupt: irq %d occurred\n", |
548 | irq_type); | |
f73f6232 CC |
549 | mutex_unlock(&info->mutex); |
550 | return; | |
99f09beb DK |
551 | } |
552 | ||
f73f6232 CC |
553 | if (ret < 0) |
554 | dev_err(info->dev, "failed to handle MUIC interrupt\n"); | |
555 | ||
99f09beb | 556 | mutex_unlock(&info->mutex); |
99f09beb DK |
557 | } |
558 | ||
559 | static irqreturn_t max8997_muic_irq_handler(int irq, void *data) | |
560 | { | |
561 | struct max8997_muic_info *info = data; | |
562 | ||
563 | dev_dbg(info->dev, "irq:%d\n", irq); | |
564 | info->irq = irq; | |
565 | ||
566 | schedule_work(&info->irq_work); | |
567 | ||
568 | return IRQ_HANDLED; | |
569 | } | |
570 | ||
f73f6232 | 571 | static int max8997_muic_detect_dev(struct max8997_muic_info *info) |
99f09beb | 572 | { |
f73f6232 CC |
573 | int ret = 0; |
574 | int adc; | |
575 | int chg_type; | |
576 | bool attached; | |
99f09beb | 577 | |
f73f6232 CC |
578 | mutex_lock(&info->mutex); |
579 | ||
580 | /* Read STATUSx register to detect accessory */ | |
581 | ret = max8997_bulk_read(info->muic, | |
582 | MAX8997_MUIC_REG_STATUS1, 2, info->status); | |
99f09beb | 583 | if (ret) { |
f73f6232 CC |
584 | dev_err(info->dev, "failed to read MUIC register\n"); |
585 | mutex_unlock(&info->mutex); | |
3ad9e86d | 586 | return ret; |
99f09beb DK |
587 | } |
588 | ||
f73f6232 CC |
589 | adc = max8997_muic_get_cable_type(info, MAX8997_CABLE_GROUP_ADC, |
590 | &attached); | |
591 | if (attached && adc != MAX8997_MUIC_ADC_OPEN) { | |
592 | ret = max8997_muic_adc_handler(info); | |
593 | if (ret < 0) { | |
594 | dev_err(info->dev, "Cannot detect ADC cable\n"); | |
595 | mutex_unlock(&info->mutex); | |
596 | return ret; | |
597 | } | |
598 | } | |
99f09beb | 599 | |
f73f6232 CC |
600 | chg_type = max8997_muic_get_cable_type(info, MAX8997_CABLE_GROUP_CHG, |
601 | &attached); | |
602 | if (attached && chg_type != MAX8997_CHARGER_TYPE_NONE) { | |
603 | ret = max8997_muic_chg_handler(info); | |
604 | if (ret < 0) { | |
605 | dev_err(info->dev, "Cannot detect charger cable\n"); | |
606 | mutex_unlock(&info->mutex); | |
607 | return ret; | |
608 | } | |
609 | } | |
99f09beb | 610 | |
f73f6232 | 611 | mutex_unlock(&info->mutex); |
99f09beb | 612 | |
f73f6232 | 613 | return 0; |
99f09beb DK |
614 | } |
615 | ||
af5eb1a1 CC |
616 | static void max8997_muic_detect_cable_wq(struct work_struct *work) |
617 | { | |
618 | struct max8997_muic_info *info = container_of(to_delayed_work(work), | |
619 | struct max8997_muic_info, wq_detcable); | |
620 | int ret; | |
621 | ||
622 | ret = max8997_muic_detect_dev(info); | |
623 | if (ret < 0) | |
6ed28105 | 624 | dev_err(info->dev, "failed to detect cable type\n"); |
af5eb1a1 CC |
625 | } |
626 | ||
44f34fd4 | 627 | static int max8997_muic_probe(struct platform_device *pdev) |
99f09beb | 628 | { |
b76668ba CC |
629 | struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent); |
630 | struct max8997_platform_data *pdata = dev_get_platdata(max8997->dev); | |
99f09beb | 631 | struct max8997_muic_info *info; |
af5eb1a1 | 632 | int delay_jiffies; |
3e34c819 MS |
633 | int cable_type; |
634 | bool attached; | |
99f09beb DK |
635 | int ret, i; |
636 | ||
0b672e9b SK |
637 | info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_muic_info), |
638 | GFP_KERNEL); | |
0a16ee63 | 639 | if (!info) |
0b672e9b | 640 | return -ENOMEM; |
99f09beb | 641 | |
99f09beb | 642 | info->dev = &pdev->dev; |
b76668ba | 643 | info->muic = max8997->muic; |
99f09beb DK |
644 | |
645 | platform_set_drvdata(pdev, info); | |
646 | mutex_init(&info->mutex); | |
647 | ||
99f09beb DK |
648 | INIT_WORK(&info->irq_work, max8997_muic_irq_work); |
649 | ||
650 | for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) { | |
651 | struct max8997_muic_irq *muic_irq = &muic_irqs[i]; | |
68c9274d | 652 | unsigned int virq = 0; |
dca1a71e CC |
653 | |
654 | virq = irq_create_mapping(max8997->irq_domain, muic_irq->irq); | |
68c9274d SK |
655 | if (!virq) { |
656 | ret = -EINVAL; | |
dca1a71e | 657 | goto err_irq; |
68c9274d | 658 | } |
dca1a71e | 659 | muic_irq->virq = virq; |
99f09beb | 660 | |
ae3b3215 CC |
661 | ret = request_threaded_irq(virq, NULL, |
662 | max8997_muic_irq_handler, | |
663 | IRQF_NO_SUSPEND, | |
664 | muic_irq->name, info); | |
99f09beb DK |
665 | if (ret) { |
666 | dev_err(&pdev->dev, | |
34825e51 | 667 | "failed: irq request (IRQ: %d, error :%d)\n", |
99f09beb | 668 | muic_irq->irq, ret); |
99f09beb DK |
669 | goto err_irq; |
670 | } | |
671 | } | |
672 | ||
b76668ba | 673 | /* External connector */ |
22f9afb9 CC |
674 | info->edev = devm_extcon_dev_allocate(&pdev->dev, max8997_extcon_cable); |
675 | if (IS_ERR(info->edev)) { | |
b76668ba CC |
676 | dev_err(&pdev->dev, "failed to allocate memory for extcon\n"); |
677 | ret = -ENOMEM; | |
678 | goto err_irq; | |
679 | } | |
22f9afb9 | 680 | |
2923803d | 681 | ret = devm_extcon_dev_register(&pdev->dev, info->edev); |
b76668ba CC |
682 | if (ret) { |
683 | dev_err(&pdev->dev, "failed to register extcon device\n"); | |
0b672e9b | 684 | goto err_irq; |
b76668ba CC |
685 | } |
686 | ||
dfee4111 | 687 | if (pdata && pdata->muic_pdata) { |
810d601f CC |
688 | struct max8997_muic_platform_data *muic_pdata |
689 | = pdata->muic_pdata; | |
690 | ||
691 | /* Initialize registers according to platform data */ | |
692 | for (i = 0; i < muic_pdata->num_init_data; i++) { | |
693 | max8997_write_reg(info->muic, | |
694 | muic_pdata->init_data[i].addr, | |
695 | muic_pdata->init_data[i].data); | |
b76668ba | 696 | } |
99f09beb | 697 | |
810d601f CC |
698 | /* |
699 | * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB | |
700 | * h/w path of COMP2/COMN1 on CONTROL1 register. | |
701 | */ | |
702 | if (muic_pdata->path_uart) | |
703 | info->path_uart = muic_pdata->path_uart; | |
704 | else | |
705 | info->path_uart = CONTROL1_SW_UART; | |
685dc9a7 | 706 | |
810d601f CC |
707 | if (muic_pdata->path_usb) |
708 | info->path_usb = muic_pdata->path_usb; | |
709 | else | |
710 | info->path_usb = CONTROL1_SW_USB; | |
711 | ||
712 | /* | |
713 | * Default delay time for detecting cable state | |
714 | * after certain time. | |
715 | */ | |
716 | if (muic_pdata->detcable_delay_ms) | |
717 | delay_jiffies = | |
718 | msecs_to_jiffies(muic_pdata->detcable_delay_ms); | |
719 | else | |
720 | delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); | |
721 | } else { | |
722 | info->path_uart = CONTROL1_SW_UART; | |
685dc9a7 | 723 | info->path_usb = CONTROL1_SW_USB; |
810d601f CC |
724 | delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); |
725 | } | |
685dc9a7 | 726 | |
3e34c819 MS |
727 | /* Set initial path for UART when JIG is connected to get serial logs */ |
728 | ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1, | |
729 | 2, info->status); | |
730 | if (ret) { | |
731 | dev_err(info->dev, "failed to read MUIC register\n"); | |
732 | return ret; | |
733 | } | |
734 | cable_type = max8997_muic_get_cable_type(info, | |
735 | MAX8997_CABLE_GROUP_ADC, &attached); | |
736 | if (attached && cable_type == MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF) | |
737 | max8997_muic_set_path(info, info->path_uart, true); | |
685dc9a7 | 738 | |
027fcd50 CC |
739 | /* Set ADC debounce time */ |
740 | max8997_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS); | |
741 | ||
af5eb1a1 CC |
742 | /* |
743 | * Detect accessory after completing the initialization of platform | |
744 | * | |
745 | * - Use delayed workqueue to detect cable state and then | |
746 | * notify cable state to notifiee/platform through uevent. | |
747 | * After completing the booting of platform, the extcon provider | |
748 | * driver should notify cable state to upper layer. | |
749 | */ | |
750 | INIT_DELAYED_WORK(&info->wq_detcable, max8997_muic_detect_cable_wq); | |
bf9509e0 KK |
751 | queue_delayed_work(system_power_efficient_wq, &info->wq_detcable, |
752 | delay_jiffies); | |
99f09beb | 753 | |
af5eb1a1 | 754 | return 0; |
99f09beb DK |
755 | |
756 | err_irq: | |
3241d56e | 757 | while (--i >= 0) |
dca1a71e | 758 | free_irq(muic_irqs[i].virq, info); |
99f09beb DK |
759 | return ret; |
760 | } | |
761 | ||
93ed0327 | 762 | static int max8997_muic_remove(struct platform_device *pdev) |
99f09beb DK |
763 | { |
764 | struct max8997_muic_info *info = platform_get_drvdata(pdev); | |
99f09beb DK |
765 | int i; |
766 | ||
99f09beb | 767 | for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) |
dca1a71e | 768 | free_irq(muic_irqs[i].virq, info); |
71e58782 | 769 | cancel_work_sync(&info->irq_work); |
99f09beb | 770 | |
99f09beb DK |
771 | return 0; |
772 | } | |
773 | ||
774 | static struct platform_driver max8997_muic_driver = { | |
775 | .driver = { | |
b76668ba | 776 | .name = DEV_NAME, |
99f09beb DK |
777 | }, |
778 | .probe = max8997_muic_probe, | |
5f7e2228 | 779 | .remove = max8997_muic_remove, |
99f09beb DK |
780 | }; |
781 | ||
b00e126f | 782 | module_platform_driver(max8997_muic_driver); |
99f09beb | 783 | |
b76668ba | 784 | MODULE_DESCRIPTION("Maxim MAX8997 Extcon driver"); |
99f09beb DK |
785 | MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>"); |
786 | MODULE_LICENSE("GPL"); |