Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

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

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