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