Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/extcon/extcon-max14577.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us