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