net: mscc: ocelot: cross-check the sequence id from the timestamp FIFO with the skb...
[linux-2.6-microblaze.git] / drivers / extcon / extcon-max14577.c
1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // extcon-max14577.c - MAX14577/77836 extcon driver to support MUIC
4 //
5 // Copyright (C) 2013,2014 Samsung Electronics
6 // Chanwoo Choi <cw00.choi@samsung.com>
7 // Krzysztof Kozlowski <krzk@kernel.org>
8
9 #include <linux/devm-helpers.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/i2c.h>
13 #include <linux/interrupt.h>
14 #include <linux/platform_device.h>
15 #include <linux/mfd/max14577.h>
16 #include <linux/mfd/max14577-private.h>
17 #include <linux/extcon-provider.h>
18
19 #define DELAY_MS_DEFAULT                17000           /* unit: millisecond */
20
21 enum max14577_muic_adc_debounce_time {
22         ADC_DEBOUNCE_TIME_5MS = 0,
23         ADC_DEBOUNCE_TIME_10MS,
24         ADC_DEBOUNCE_TIME_25MS,
25         ADC_DEBOUNCE_TIME_38_62MS,
26 };
27
28 enum max14577_muic_status {
29         MAX14577_MUIC_STATUS1 = 0,
30         MAX14577_MUIC_STATUS2 = 1,
31         MAX14577_MUIC_STATUS_END,
32 };
33
34 /**
35  * struct max14577_muic_irq
36  * @irq: the index of irq list of MUIC device.
37  * @name: the name of irq.
38  * @virq: the virtual irq to use irq domain
39  */
40 struct max14577_muic_irq {
41         unsigned int irq;
42         const char *name;
43         unsigned int virq;
44 };
45
46 static struct max14577_muic_irq max14577_muic_irqs[] = {
47         { MAX14577_IRQ_INT1_ADC,        "muic-ADC" },
48         { MAX14577_IRQ_INT1_ADCLOW,     "muic-ADCLOW" },
49         { MAX14577_IRQ_INT1_ADCERR,     "muic-ADCError" },
50         { MAX14577_IRQ_INT2_CHGTYP,     "muic-CHGTYP" },
51         { MAX14577_IRQ_INT2_CHGDETRUN,  "muic-CHGDETRUN" },
52         { MAX14577_IRQ_INT2_DCDTMR,     "muic-DCDTMR" },
53         { MAX14577_IRQ_INT2_DBCHG,      "muic-DBCHG" },
54         { MAX14577_IRQ_INT2_VBVOLT,     "muic-VBVOLT" },
55 };
56
57 static struct max14577_muic_irq max77836_muic_irqs[] = {
58         { MAX14577_IRQ_INT1_ADC,        "muic-ADC" },
59         { MAX14577_IRQ_INT1_ADCLOW,     "muic-ADCLOW" },
60         { MAX14577_IRQ_INT1_ADCERR,     "muic-ADCError" },
61         { MAX77836_IRQ_INT1_ADC1K,      "muic-ADC1K" },
62         { MAX14577_IRQ_INT2_CHGTYP,     "muic-CHGTYP" },
63         { MAX14577_IRQ_INT2_CHGDETRUN,  "muic-CHGDETRUN" },
64         { MAX14577_IRQ_INT2_DCDTMR,     "muic-DCDTMR" },
65         { MAX14577_IRQ_INT2_DBCHG,      "muic-DBCHG" },
66         { MAX14577_IRQ_INT2_VBVOLT,     "muic-VBVOLT" },
67         { MAX77836_IRQ_INT2_VIDRM,      "muic-VIDRM" },
68 };
69
70 struct max14577_muic_info {
71         struct device *dev;
72         struct max14577 *max14577;
73         struct extcon_dev *edev;
74         int prev_cable_type;
75         int prev_chg_type;
76         u8 status[MAX14577_MUIC_STATUS_END];
77
78         struct max14577_muic_irq *muic_irqs;
79         unsigned int muic_irqs_num;
80         bool irq_adc;
81         bool irq_chg;
82         struct work_struct irq_work;
83         struct mutex mutex;
84
85         /*
86          * Use delayed workqueue to detect cable state and then
87          * notify cable state to notifiee/platform through uevent.
88          * After completing the booting of platform, the extcon provider
89          * driver should notify cable state to upper layer.
90          */
91         struct delayed_work wq_detcable;
92
93         /*
94          * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
95          * h/w path of COMP2/COMN1 on CONTROL1 register.
96          */
97         int path_usb;
98         int path_uart;
99 };
100
101 enum max14577_muic_cable_group {
102         MAX14577_CABLE_GROUP_ADC = 0,
103         MAX14577_CABLE_GROUP_CHG,
104 };
105
106 /* Define supported accessory type */
107 enum max14577_muic_acc_type {
108         MAX14577_MUIC_ADC_GROUND = 0x0,
109         MAX14577_MUIC_ADC_SEND_END_BUTTON,
110         MAX14577_MUIC_ADC_REMOTE_S1_BUTTON,
111         MAX14577_MUIC_ADC_REMOTE_S2_BUTTON,
112         MAX14577_MUIC_ADC_REMOTE_S3_BUTTON,
113         MAX14577_MUIC_ADC_REMOTE_S4_BUTTON,
114         MAX14577_MUIC_ADC_REMOTE_S5_BUTTON,
115         MAX14577_MUIC_ADC_REMOTE_S6_BUTTON,
116         MAX14577_MUIC_ADC_REMOTE_S7_BUTTON,
117         MAX14577_MUIC_ADC_REMOTE_S8_BUTTON,
118         MAX14577_MUIC_ADC_REMOTE_S9_BUTTON,
119         MAX14577_MUIC_ADC_REMOTE_S10_BUTTON,
120         MAX14577_MUIC_ADC_REMOTE_S11_BUTTON,
121         MAX14577_MUIC_ADC_REMOTE_S12_BUTTON,
122         MAX14577_MUIC_ADC_RESERVED_ACC_1,
123         MAX14577_MUIC_ADC_RESERVED_ACC_2,
124         MAX14577_MUIC_ADC_RESERVED_ACC_3,
125         MAX14577_MUIC_ADC_RESERVED_ACC_4,
126         MAX14577_MUIC_ADC_RESERVED_ACC_5,
127         MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2,
128         MAX14577_MUIC_ADC_PHONE_POWERED_DEV,
129         MAX14577_MUIC_ADC_TTY_CONVERTER,
130         MAX14577_MUIC_ADC_UART_CABLE,
131         MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG,
132         MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF,
133         MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON,
134         MAX14577_MUIC_ADC_AV_CABLE_NOLOAD,
135         MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG,
136         MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF,
137         MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON,
138         MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1, /* with Remote and Simple Ctrl */
139         MAX14577_MUIC_ADC_OPEN,
140 };
141
142 static const unsigned int max14577_extcon_cable[] = {
143         EXTCON_USB,
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_JIG,
150         EXTCON_NONE,
151 };
152
153 /*
154  * max14577_muic_set_debounce_time - Set the debounce time of ADC
155  * @info: the instance including private data of max14577 MUIC
156  * @time: the debounce time of ADC
157  */
158 static int max14577_muic_set_debounce_time(struct max14577_muic_info *info,
159                 enum max14577_muic_adc_debounce_time time)
160 {
161         u8 ret;
162
163         switch (time) {
164         case ADC_DEBOUNCE_TIME_5MS:
165         case ADC_DEBOUNCE_TIME_10MS:
166         case ADC_DEBOUNCE_TIME_25MS:
167         case ADC_DEBOUNCE_TIME_38_62MS:
168                 ret = max14577_update_reg(info->max14577->regmap,
169                                           MAX14577_MUIC_REG_CONTROL3,
170                                           CTRL3_ADCDBSET_MASK,
171                                           time << CTRL3_ADCDBSET_SHIFT);
172                 if (ret) {
173                         dev_err(info->dev, "failed to set ADC debounce time\n");
174                         return ret;
175                 }
176                 break;
177         default:
178                 dev_err(info->dev, "invalid ADC debounce time\n");
179                 return -EINVAL;
180         }
181
182         return 0;
183 };
184
185 /*
186  * max14577_muic_set_path - Set hardware line according to attached cable
187  * @info: the instance including private data of max14577 MUIC
188  * @value: the path according to attached cable
189  * @attached: the state of cable (true:attached, false:detached)
190  *
191  * The max14577 MUIC device share outside H/W line among a varity of cables
192  * so, this function set internal path of H/W line according to the type of
193  * attached cable.
194  */
195 static int max14577_muic_set_path(struct max14577_muic_info *info,
196                 u8 val, bool attached)
197 {
198         u8 ctrl1, ctrl2 = 0;
199         int ret;
200
201         /* Set open state to path before changing hw path */
202         ret = max14577_update_reg(info->max14577->regmap,
203                                 MAX14577_MUIC_REG_CONTROL1,
204                                 CLEAR_IDBEN_MICEN_MASK, CTRL1_SW_OPEN);
205         if (ret < 0) {
206                 dev_err(info->dev, "failed to update MUIC register\n");
207                 return ret;
208         }
209
210         if (attached)
211                 ctrl1 = val;
212         else
213                 ctrl1 = CTRL1_SW_OPEN;
214
215         ret = max14577_update_reg(info->max14577->regmap,
216                                 MAX14577_MUIC_REG_CONTROL1,
217                                 CLEAR_IDBEN_MICEN_MASK, ctrl1);
218         if (ret < 0) {
219                 dev_err(info->dev, "failed to update MUIC register\n");
220                 return ret;
221         }
222
223         if (attached)
224                 ctrl2 |= CTRL2_CPEN_MASK;       /* LowPwr=0, CPEn=1 */
225         else
226                 ctrl2 |= CTRL2_LOWPWR_MASK;     /* LowPwr=1, CPEn=0 */
227
228         ret = max14577_update_reg(info->max14577->regmap,
229                         MAX14577_REG_CONTROL2,
230                         CTRL2_LOWPWR_MASK | CTRL2_CPEN_MASK, ctrl2);
231         if (ret < 0) {
232                 dev_err(info->dev, "failed to update MUIC register\n");
233                 return ret;
234         }
235
236         dev_dbg(info->dev,
237                 "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n",
238                 ctrl1, ctrl2, attached ? "attached" : "detached");
239
240         return 0;
241 }
242
243 /*
244  * max14577_muic_get_cable_type - Return cable type and check cable state
245  * @info: the instance including private data of max14577 MUIC
246  * @group: the path according to attached cable
247  * @attached: store cable state and return
248  *
249  * This function check the cable state either attached or detached,
250  * and then divide precise type of cable according to cable group.
251  *      - max14577_CABLE_GROUP_ADC
252  *      - max14577_CABLE_GROUP_CHG
253  */
254 static int max14577_muic_get_cable_type(struct max14577_muic_info *info,
255                 enum max14577_muic_cable_group group, bool *attached)
256 {
257         int cable_type = 0;
258         int adc;
259         int chg_type;
260
261         switch (group) {
262         case MAX14577_CABLE_GROUP_ADC:
263                 /*
264                  * Read ADC value to check cable type and decide cable state
265                  * according to cable type
266                  */
267                 adc = info->status[MAX14577_MUIC_STATUS1] & STATUS1_ADC_MASK;
268                 adc >>= STATUS1_ADC_SHIFT;
269
270                 /*
271                  * Check current cable state/cable type and store cable type
272                  * (info->prev_cable_type) for handling cable when cable is
273                  * detached.
274                  */
275                 if (adc == MAX14577_MUIC_ADC_OPEN) {
276                         *attached = false;
277
278                         cable_type = info->prev_cable_type;
279                         info->prev_cable_type = MAX14577_MUIC_ADC_OPEN;
280                 } else {
281                         *attached = true;
282
283                         cable_type = info->prev_cable_type = adc;
284                 }
285                 break;
286         case MAX14577_CABLE_GROUP_CHG:
287                 /*
288                  * Read charger type to check cable type and decide cable state
289                  * according to type of charger cable.
290                  */
291                 chg_type = info->status[MAX14577_MUIC_STATUS2] &
292                         STATUS2_CHGTYP_MASK;
293                 chg_type >>= STATUS2_CHGTYP_SHIFT;
294
295                 if (chg_type == MAX14577_CHARGER_TYPE_NONE) {
296                         *attached = false;
297
298                         cable_type = info->prev_chg_type;
299                         info->prev_chg_type = MAX14577_CHARGER_TYPE_NONE;
300                 } else {
301                         *attached = true;
302
303                         /*
304                          * Check current cable state/cable type and store cable
305                          * type(info->prev_chg_type) for handling cable when
306                          * charger cable is detached.
307                          */
308                         cable_type = info->prev_chg_type = chg_type;
309                 }
310
311                 break;
312         default:
313                 dev_err(info->dev, "Unknown cable group (%d)\n", group);
314                 cable_type = -EINVAL;
315                 break;
316         }
317
318         return cable_type;
319 }
320
321 static int max14577_muic_jig_handler(struct max14577_muic_info *info,
322                 int cable_type, bool attached)
323 {
324         int ret = 0;
325         u8 path = CTRL1_SW_OPEN;
326
327         dev_dbg(info->dev,
328                 "external connector is %s (adc:0x%02x)\n",
329                 attached ? "attached" : "detached", cable_type);
330
331         switch (cable_type) {
332         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF:    /* ADC_JIG_USB_OFF */
333         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON:     /* ADC_JIG_USB_ON */
334                 /* PATH:AP_USB */
335                 path = CTRL1_SW_USB;
336                 break;
337         case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF:   /* ADC_JIG_UART_OFF */
338                 /* PATH:AP_UART */
339                 path = CTRL1_SW_UART;
340                 break;
341         default:
342                 dev_err(info->dev, "failed to detect %s jig cable\n",
343                         attached ? "attached" : "detached");
344                 return -EINVAL;
345         }
346
347         ret = max14577_muic_set_path(info, path, attached);
348         if (ret < 0)
349                 return ret;
350
351         extcon_set_state_sync(info->edev, EXTCON_JIG, attached);
352
353         return 0;
354 }
355
356 static int max14577_muic_adc_handler(struct max14577_muic_info *info)
357 {
358         int cable_type;
359         bool attached;
360         int ret = 0;
361
362         /* Check accessory state which is either detached or attached */
363         cable_type = max14577_muic_get_cable_type(info,
364                                 MAX14577_CABLE_GROUP_ADC, &attached);
365
366         dev_dbg(info->dev,
367                 "external connector is %s (adc:0x%02x, prev_adc:0x%x)\n",
368                 attached ? "attached" : "detached", cable_type,
369                 info->prev_cable_type);
370
371         switch (cable_type) {
372         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF:
373         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON:
374         case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF:
375                 /* JIG */
376                 ret = max14577_muic_jig_handler(info, cable_type, attached);
377                 if (ret < 0)
378                         return ret;
379                 break;
380         case MAX14577_MUIC_ADC_GROUND:
381         case MAX14577_MUIC_ADC_SEND_END_BUTTON:
382         case MAX14577_MUIC_ADC_REMOTE_S1_BUTTON:
383         case MAX14577_MUIC_ADC_REMOTE_S2_BUTTON:
384         case MAX14577_MUIC_ADC_REMOTE_S3_BUTTON:
385         case MAX14577_MUIC_ADC_REMOTE_S4_BUTTON:
386         case MAX14577_MUIC_ADC_REMOTE_S5_BUTTON:
387         case MAX14577_MUIC_ADC_REMOTE_S6_BUTTON:
388         case MAX14577_MUIC_ADC_REMOTE_S7_BUTTON:
389         case MAX14577_MUIC_ADC_REMOTE_S8_BUTTON:
390         case MAX14577_MUIC_ADC_REMOTE_S9_BUTTON:
391         case MAX14577_MUIC_ADC_REMOTE_S10_BUTTON:
392         case MAX14577_MUIC_ADC_REMOTE_S11_BUTTON:
393         case MAX14577_MUIC_ADC_REMOTE_S12_BUTTON:
394         case MAX14577_MUIC_ADC_RESERVED_ACC_1:
395         case MAX14577_MUIC_ADC_RESERVED_ACC_2:
396         case MAX14577_MUIC_ADC_RESERVED_ACC_3:
397         case MAX14577_MUIC_ADC_RESERVED_ACC_4:
398         case MAX14577_MUIC_ADC_RESERVED_ACC_5:
399         case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2:
400         case MAX14577_MUIC_ADC_PHONE_POWERED_DEV:
401         case MAX14577_MUIC_ADC_TTY_CONVERTER:
402         case MAX14577_MUIC_ADC_UART_CABLE:
403         case MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG:
404         case MAX14577_MUIC_ADC_AV_CABLE_NOLOAD:
405         case MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG:
406         case MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON:
407         case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1:
408                 /*
409                  * This accessory isn't used in general case if it is specially
410                  * needed to detect additional accessory, should implement
411                  * proper operation when this accessory is attached/detached.
412                  */
413                 dev_info(info->dev,
414                         "accessory is %s but it isn't used (adc:0x%x)\n",
415                         attached ? "attached" : "detached", cable_type);
416                 return -EAGAIN;
417         default:
418                 dev_err(info->dev,
419                         "failed to detect %s accessory (adc:0x%x)\n",
420                         attached ? "attached" : "detached", cable_type);
421                 return -EINVAL;
422         }
423
424         return 0;
425 }
426
427 static int max14577_muic_chg_handler(struct max14577_muic_info *info)
428 {
429         int chg_type;
430         bool attached;
431         int ret = 0;
432
433         chg_type = max14577_muic_get_cable_type(info,
434                                 MAX14577_CABLE_GROUP_CHG, &attached);
435
436         dev_dbg(info->dev,
437                 "external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n",
438                         attached ? "attached" : "detached",
439                         chg_type, info->prev_chg_type);
440
441         switch (chg_type) {
442         case MAX14577_CHARGER_TYPE_USB:
443                 /* PATH:AP_USB */
444                 ret = max14577_muic_set_path(info, info->path_usb, attached);
445                 if (ret < 0)
446                         return ret;
447
448                 extcon_set_state_sync(info->edev, EXTCON_USB, attached);
449                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP,
450                                         attached);
451                 break;
452         case MAX14577_CHARGER_TYPE_DEDICATED_CHG:
453                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP,
454                                         attached);
455                 break;
456         case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT:
457                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_CDP,
458                                         attached);
459                 break;
460         case MAX14577_CHARGER_TYPE_SPECIAL_500MA:
461                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SLOW,
462                                         attached);
463                 break;
464         case MAX14577_CHARGER_TYPE_SPECIAL_1A:
465                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_FAST,
466                                         attached);
467                 break;
468         case MAX14577_CHARGER_TYPE_NONE:
469         case MAX14577_CHARGER_TYPE_DEAD_BATTERY:
470                 break;
471         default:
472                 dev_err(info->dev,
473                         "failed to detect %s accessory (chg_type:0x%x)\n",
474                         attached ? "attached" : "detached", chg_type);
475                 return -EINVAL;
476         }
477
478         return 0;
479 }
480
481 static void max14577_muic_irq_work(struct work_struct *work)
482 {
483         struct max14577_muic_info *info = container_of(work,
484                         struct max14577_muic_info, irq_work);
485         int ret = 0;
486
487         if (!info->edev)
488                 return;
489
490         mutex_lock(&info->mutex);
491
492         ret = max14577_bulk_read(info->max14577->regmap,
493                         MAX14577_MUIC_REG_STATUS1, info->status, 2);
494         if (ret) {
495                 dev_err(info->dev, "failed to read MUIC register\n");
496                 mutex_unlock(&info->mutex);
497                 return;
498         }
499
500         if (info->irq_adc) {
501                 ret = max14577_muic_adc_handler(info);
502                 info->irq_adc = false;
503         }
504         if (info->irq_chg) {
505                 ret = max14577_muic_chg_handler(info);
506                 info->irq_chg = false;
507         }
508
509         if (ret < 0)
510                 dev_err(info->dev, "failed to handle MUIC interrupt\n");
511
512         mutex_unlock(&info->mutex);
513 }
514
515 /*
516  * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
517  * Returns 0 if irq_type does not match registered IRQ for this device type.
518  */
519 static int max14577_parse_irq(struct max14577_muic_info *info, int irq_type)
520 {
521         switch (irq_type) {
522         case MAX14577_IRQ_INT1_ADC:
523         case MAX14577_IRQ_INT1_ADCLOW:
524         case MAX14577_IRQ_INT1_ADCERR:
525                 /*
526                  * Handle all of accessory except for
527                  * type of charger accessory.
528                  */
529                 info->irq_adc = true;
530                 return 1;
531         case MAX14577_IRQ_INT2_CHGTYP:
532         case MAX14577_IRQ_INT2_CHGDETRUN:
533         case MAX14577_IRQ_INT2_DCDTMR:
534         case MAX14577_IRQ_INT2_DBCHG:
535         case MAX14577_IRQ_INT2_VBVOLT:
536                 /* Handle charger accessory */
537                 info->irq_chg = true;
538                 return 1;
539         default:
540                 return 0;
541         }
542 }
543
544 /*
545  * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
546  * Returns 0 if irq_type does not match registered IRQ for this device type.
547  */
548 static int max77836_parse_irq(struct max14577_muic_info *info, int irq_type)
549 {
550         /* First check common max14577 interrupts */
551         if (max14577_parse_irq(info, irq_type))
552                 return 1;
553
554         switch (irq_type) {
555         case MAX77836_IRQ_INT1_ADC1K:
556                 info->irq_adc = true;
557                 return 1;
558         case MAX77836_IRQ_INT2_VIDRM:
559                 /* Handle charger accessory */
560                 info->irq_chg = true;
561                 return 1;
562         default:
563                 return 0;
564         }
565 }
566
567 static irqreturn_t max14577_muic_irq_handler(int irq, void *data)
568 {
569         struct max14577_muic_info *info = data;
570         int i, irq_type = -1;
571         bool irq_parsed;
572
573         /*
574          * We may be called multiple times for different nested IRQ-s.
575          * Including changes in INT1_ADC and INT2_CGHTYP at once.
576          * However we only need to know whether it was ADC, charger
577          * or both interrupts so decode IRQ and turn on proper flags.
578          */
579         for (i = 0; i < info->muic_irqs_num; i++)
580                 if (irq == info->muic_irqs[i].virq)
581                         irq_type = info->muic_irqs[i].irq;
582
583         switch (info->max14577->dev_type) {
584         case MAXIM_DEVICE_TYPE_MAX77836:
585                 irq_parsed = max77836_parse_irq(info, irq_type);
586                 break;
587         case MAXIM_DEVICE_TYPE_MAX14577:
588         default:
589                 irq_parsed = max14577_parse_irq(info, irq_type);
590                 break;
591         }
592
593         if (!irq_parsed) {
594                 dev_err(info->dev, "muic interrupt: irq %d occurred, skipped\n",
595                                 irq_type);
596                 return IRQ_HANDLED;
597         }
598         schedule_work(&info->irq_work);
599
600         return IRQ_HANDLED;
601 }
602
603 static int max14577_muic_detect_accessory(struct max14577_muic_info *info)
604 {
605         int ret = 0;
606         int adc;
607         int chg_type;
608         bool attached;
609
610         mutex_lock(&info->mutex);
611
612         /* Read STATUSx register to detect accessory */
613         ret = max14577_bulk_read(info->max14577->regmap,
614                         MAX14577_MUIC_REG_STATUS1, info->status, 2);
615         if (ret) {
616                 dev_err(info->dev, "failed to read MUIC register\n");
617                 mutex_unlock(&info->mutex);
618                 return ret;
619         }
620
621         adc = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_ADC,
622                                         &attached);
623         if (attached && adc != MAX14577_MUIC_ADC_OPEN) {
624                 ret = max14577_muic_adc_handler(info);
625                 if (ret < 0) {
626                         dev_err(info->dev, "Cannot detect accessory\n");
627                         mutex_unlock(&info->mutex);
628                         return ret;
629                 }
630         }
631
632         chg_type = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_CHG,
633                                         &attached);
634         if (attached && chg_type != MAX14577_CHARGER_TYPE_NONE) {
635                 ret = max14577_muic_chg_handler(info);
636                 if (ret < 0) {
637                         dev_err(info->dev, "Cannot detect charger accessory\n");
638                         mutex_unlock(&info->mutex);
639                         return ret;
640                 }
641         }
642
643         mutex_unlock(&info->mutex);
644
645         return 0;
646 }
647
648 static void max14577_muic_detect_cable_wq(struct work_struct *work)
649 {
650         struct max14577_muic_info *info = container_of(to_delayed_work(work),
651                                 struct max14577_muic_info, wq_detcable);
652
653         max14577_muic_detect_accessory(info);
654 }
655
656 static int max14577_muic_probe(struct platform_device *pdev)
657 {
658         struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent);
659         struct max14577_muic_info *info;
660         int delay_jiffies;
661         int cable_type;
662         bool attached;
663         int ret;
664         int i;
665         u8 id;
666
667         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
668         if (!info)
669                 return -ENOMEM;
670
671         info->dev = &pdev->dev;
672         info->max14577 = max14577;
673
674         platform_set_drvdata(pdev, info);
675         mutex_init(&info->mutex);
676
677         ret = devm_work_autocancel(&pdev->dev, &info->irq_work,
678                                    max14577_muic_irq_work);
679         if (ret)
680                 return ret;
681
682         switch (max14577->dev_type) {
683         case MAXIM_DEVICE_TYPE_MAX77836:
684                 info->muic_irqs = max77836_muic_irqs;
685                 info->muic_irqs_num = ARRAY_SIZE(max77836_muic_irqs);
686                 break;
687         case MAXIM_DEVICE_TYPE_MAX14577:
688         default:
689                 info->muic_irqs = max14577_muic_irqs;
690                 info->muic_irqs_num = ARRAY_SIZE(max14577_muic_irqs);
691         }
692
693         /* Support irq domain for max14577 MUIC device */
694         for (i = 0; i < info->muic_irqs_num; i++) {
695                 struct max14577_muic_irq *muic_irq = &info->muic_irqs[i];
696                 int virq = 0;
697
698                 virq = regmap_irq_get_virq(max14577->irq_data, muic_irq->irq);
699                 if (virq <= 0)
700                         return -EINVAL;
701                 muic_irq->virq = virq;
702
703                 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
704                                 max14577_muic_irq_handler,
705                                 IRQF_NO_SUSPEND,
706                                 muic_irq->name, info);
707                 if (ret) {
708                         dev_err(&pdev->dev,
709                                 "failed: irq request (IRQ: %d, error :%d)\n",
710                                 muic_irq->irq, ret);
711                         return ret;
712                 }
713         }
714
715         /* Initialize extcon device */
716         info->edev = devm_extcon_dev_allocate(&pdev->dev,
717                                               max14577_extcon_cable);
718         if (IS_ERR(info->edev)) {
719                 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
720                 return PTR_ERR(info->edev);
721         }
722
723         ret = devm_extcon_dev_register(&pdev->dev, info->edev);
724         if (ret) {
725                 dev_err(&pdev->dev, "failed to register extcon device\n");
726                 return ret;
727         }
728
729         /* Default h/w line path */
730         info->path_usb = CTRL1_SW_USB;
731         info->path_uart = CTRL1_SW_UART;
732         delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT);
733
734         /* Set initial path for UART when JIG is connected to get serial logs */
735         ret = max14577_bulk_read(info->max14577->regmap,
736                         MAX14577_MUIC_REG_STATUS1, info->status, 2);
737         if (ret) {
738                 dev_err(info->dev, "Cannot read STATUS registers\n");
739                 return ret;
740         }
741         cable_type = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_ADC,
742                                          &attached);
743         if (attached && cable_type == MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF)
744                 max14577_muic_set_path(info, info->path_uart, true);
745
746         /* Check revision number of MUIC device*/
747         ret = max14577_read_reg(info->max14577->regmap,
748                         MAX14577_REG_DEVICEID, &id);
749         if (ret < 0) {
750                 dev_err(&pdev->dev, "failed to read revision number\n");
751                 return ret;
752         }
753         dev_info(info->dev, "device ID : 0x%x\n", id);
754
755         /* Set ADC debounce time */
756         max14577_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS);
757
758         /*
759          * Detect accessory after completing the initialization of platform
760          *
761          * - Use delayed workqueue to detect cable state and then
762          * notify cable state to notifiee/platform through uevent.
763          * After completing the booting of platform, the extcon provider
764          * driver should notify cable state to upper layer.
765          */
766         INIT_DELAYED_WORK(&info->wq_detcable, max14577_muic_detect_cable_wq);
767         queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
768                         delay_jiffies);
769
770         return ret;
771 }
772
773 static const struct platform_device_id max14577_muic_id[] = {
774         { "max14577-muic", MAXIM_DEVICE_TYPE_MAX14577, },
775         { "max77836-muic", MAXIM_DEVICE_TYPE_MAX77836, },
776         { }
777 };
778 MODULE_DEVICE_TABLE(platform, max14577_muic_id);
779
780 static const struct of_device_id of_max14577_muic_dt_match[] = {
781         { .compatible = "maxim,max14577-muic",
782           .data = (void *)MAXIM_DEVICE_TYPE_MAX14577, },
783         { .compatible = "maxim,max77836-muic",
784           .data = (void *)MAXIM_DEVICE_TYPE_MAX77836, },
785         { },
786 };
787 MODULE_DEVICE_TABLE(of, of_max14577_muic_dt_match);
788
789 static struct platform_driver max14577_muic_driver = {
790         .driver         = {
791                 .name   = "max14577-muic",
792                 .of_match_table = of_max14577_muic_dt_match,
793         },
794         .probe          = max14577_muic_probe,
795         .id_table       = max14577_muic_id,
796 };
797
798 module_platform_driver(max14577_muic_driver);
799
800 MODULE_DESCRIPTION("Maxim 14577/77836 Extcon driver");
801 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <krzk@kernel.org>");
802 MODULE_LICENSE("GPL");
803 MODULE_ALIAS("platform:extcon-max14577");