9 files changed, 386 insertions, 174 deletions

diff --git a/drivers/extcon/Kconfig b/drivers/extcon/Kconfig
index be56e8ac95e6..aebde489c291 100644
--- a/drivers/extcon/Kconfig
+++ b/drivers/extcon/Kconfig
@@ -28,13 +28,13 @@ config EXTCON_ADC_JACK
           Say Y here to enable extcon device driver based on ADC values.
 
 config EXTCON_MAX14577
-        tristate "MAX14577 EXTCON Support"
+        tristate "MAX14577/77836 EXTCON Support"
         depends on MFD_MAX14577
         select IRQ_DOMAIN
         select REGMAP_I2C
         help
           If you say yes here you get support for the MUIC device of
-          Maxim MAX14577 PMIC. The MAX14577 MUIC is a USB port accessory
+          Maxim MAX14577/77836. The MAX14577/77836 MUIC is a USB port accessory
           detector and switch.
 
 config EXTCON_MAX77693
diff --git a/drivers/extcon/extcon-adc-jack.c b/drivers/extcon/extcon-adc-jack.c
index e23f1c2e5053..e18f95be3733 100644
--- a/drivers/extcon/extcon-adc-jack.c
+++ b/drivers/extcon/extcon-adc-jack.c
@@ -39,7 +39,7 @@
  * @chan:               iio channel being queried.
  */
 struct adc_jack_data {
-        struct extcon_dev edev;
+        struct extcon_dev *edev;
 
         const char **cable_names;
         int num_cables;
@@ -64,7 +64,7 @@ static void adc_jack_handler(struct work_struct *work)
 
         ret = iio_read_channel_raw(data->chan, &adc_val);
         if (ret < 0) {
-                dev_err(&data->edev.dev, "read channel() error: %d\n", ret);
+                dev_err(&data->edev->dev, "read channel() error: %d\n", ret);
                 return;
         }
 
@@ -80,7 +80,7 @@ static void adc_jack_handler(struct work_struct *work)
         }
         /* if no def has met, it means state = 0 (no cables attached) */
 
-        extcon_set_state(&data->edev, state);
+        extcon_set_state(data->edev, state);
 }
 
 static irqreturn_t adc_jack_irq_thread(int irq, void *_data)
@@ -102,33 +102,33 @@ static int adc_jack_probe(struct platform_device *pdev)
         if (!data)
                 return -ENOMEM;
 
-        data->edev.name = pdata->name;
-
         if (!pdata->cable_names) {
-                err = -EINVAL;
                 dev_err(&pdev->dev, "error: cable_names not defined.\n");
-                goto out;
+                return -EINVAL;
         }
 
-        data->edev.dev.parent = &pdev->dev;
-        data->edev.supported_cable = pdata->cable_names;
+        data->edev = devm_extcon_dev_allocate(&pdev->dev, pdata->cable_names);
+        if (IS_ERR(data->edev)) {
+                dev_err(&pdev->dev, "failed to allocate extcon device\n");
+                return -ENOMEM;
+        }
+        data->edev->dev.parent = &pdev->dev;
+        data->edev->name = pdata->name;
 
         /* Check the length of array and set num_cables */
-        for (i = 0; data->edev.supported_cable[i]; i++)
+        for (i = 0; data->edev->supported_cable[i]; i++)
                 ;
         if (i == 0 || i > SUPPORTED_CABLE_MAX) {
-                err = -EINVAL;
                 dev_err(&pdev->dev, "error: pdata->cable_names size = %d\n",
                                 i - 1);
-                goto out;
+                return -EINVAL;
         }
         data->num_cables = i;
 
         if (!pdata->adc_conditions ||
                         !pdata->adc_conditions[0].state) {
-                err = -EINVAL;
                 dev_err(&pdev->dev, "error: adc_conditions not defined.\n");
-                goto out;
+                return -EINVAL;
         }
         data->adc_conditions = pdata->adc_conditions;
 
@@ -138,10 +138,8 @@ static int adc_jack_probe(struct platform_device *pdev)
         data->num_conditions = i;
 
         data->chan = iio_channel_get(&pdev->dev, pdata->consumer_channel);
-        if (IS_ERR(data->chan)) {
-                err = PTR_ERR(data->chan);
-                goto out;
-        }
+        if (IS_ERR(data->chan))
+                return PTR_ERR(data->chan);
 
         data->handling_delay = msecs_to_jiffies(pdata->handling_delay_ms);
 
@@ -149,15 +147,14 @@ static int adc_jack_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, data);
 
-        err = extcon_dev_register(&data->edev);
+        err = devm_extcon_dev_register(&pdev->dev, data->edev);
         if (err)
-                goto out;
+                return err;
 
         data->irq = platform_get_irq(pdev, 0);
         if (!data->irq) {
                 dev_err(&pdev->dev, "platform_get_irq failed\n");
-                err = -ENODEV;
-                goto err_irq;
+                return -ENODEV;
         }
 
         err = request_any_context_irq(data->irq, adc_jack_irq_thread,
@@ -165,15 +162,10 @@ static int adc_jack_probe(struct platform_device *pdev)
 
         if (err < 0) {
                 dev_err(&pdev->dev, "error: irq %d\n", data->irq);
-                goto err_irq;
+                return err;
         }
 
         return 0;
-
-err_irq:
-        extcon_dev_unregister(&data->edev);
-out:
-        return err;
 }
 
 static int adc_jack_remove(struct platform_device *pdev)
@@ -182,7 +174,6 @@ static int adc_jack_remove(struct platform_device *pdev)
 
         free_irq(data->irq, data);
         cancel_work_sync(&data->handler.work);
-        extcon_dev_unregister(&data->edev);
 
         return 0;
 }
diff --git a/drivers/extcon/extcon-arizona.c b/drivers/extcon/extcon-arizona.c
index 98a14f6143a7..6c84e3d12043 100644
--- a/drivers/extcon/extcon-arizona.c
+++ b/drivers/extcon/extcon-arizona.c
@@ -91,7 +91,7 @@ struct arizona_extcon_info {
 
         int hpdet_ip;
 
-        struct extcon_dev edev;
+        struct extcon_dev *edev;
 };
 
 static const struct arizona_micd_config micd_default_modes[] = {
@@ -546,7 +546,7 @@ static irqreturn_t arizona_hpdet_irq(int irq, void *data)
         }
 
         /* If the cable was removed while measuring ignore the result */
-        ret = extcon_get_cable_state_(&info->edev, ARIZONA_CABLE_MECHANICAL);
+        ret = extcon_get_cable_state_(info->edev, ARIZONA_CABLE_MECHANICAL);
         if (ret < 0) {
                 dev_err(arizona->dev, "Failed to check cable state: %d\n",
                         ret);
@@ -581,7 +581,7 @@ static irqreturn_t arizona_hpdet_irq(int irq, void *data)
         else
                 report = ARIZONA_CABLE_HEADPHONE;
 
-        ret = extcon_set_cable_state_(&info->edev, report, true);
+        ret = extcon_set_cable_state_(info->edev, report, true);
         if (ret != 0)
                 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
                         ret);
@@ -664,7 +664,7 @@ err:
                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 
         /* Just report headphone */
-        ret = extcon_update_state(&info->edev,
+        ret = extcon_update_state(info->edev,
                                   1 << ARIZONA_CABLE_HEADPHONE,
                                   1 << ARIZONA_CABLE_HEADPHONE);
         if (ret != 0)
@@ -723,7 +723,7 @@ err:
                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 
         /* Just report headphone */
-        ret = extcon_update_state(&info->edev,
+        ret = extcon_update_state(info->edev,
                                   1 << ARIZONA_CABLE_HEADPHONE,
                                   1 << ARIZONA_CABLE_HEADPHONE);
         if (ret != 0)
@@ -764,7 +764,7 @@ static void arizona_micd_detect(struct work_struct *work)
         mutex_lock(&info->lock);
 
         /* If the cable was removed while measuring ignore the result */
-        ret = extcon_get_cable_state_(&info->edev, ARIZONA_CABLE_MECHANICAL);
+        ret = extcon_get_cable_state_(info->edev, ARIZONA_CABLE_MECHANICAL);
         if (ret < 0) {
                 dev_err(arizona->dev, "Failed to check cable state: %d\n",
                                 ret);
@@ -812,7 +812,7 @@ static void arizona_micd_detect(struct work_struct *work)
         if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
                 arizona_identify_headphone(info);
 
-                ret = extcon_update_state(&info->edev,
+                ret = extcon_update_state(info->edev,
                                           1 << ARIZONA_CABLE_MICROPHONE,
                                           1 << ARIZONA_CABLE_MICROPHONE);
 
@@ -999,7 +999,7 @@ static irqreturn_t arizona_jackdet(int irq, void *data)
 
         if (info->last_jackdet == present) {
                 dev_dbg(arizona->dev, "Detected jack\n");
-                ret = extcon_set_cable_state_(&info->edev,
+                ret = extcon_set_cable_state_(info->edev,
                                               ARIZONA_CABLE_MECHANICAL, true);
 
                 if (ret != 0)
@@ -1038,7 +1038,7 @@ static irqreturn_t arizona_jackdet(int irq, void *data)
                                          info->micd_ranges[i].key, 0);
                 input_sync(info->input);
 
-                ret = extcon_update_state(&info->edev, 0xffffffff, 0);
+                ret = extcon_update_state(info->edev, 0xffffffff, 0);
                 if (ret != 0)
                         dev_err(arizona->dev, "Removal report failed: %d\n",
                                 ret);
@@ -1105,15 +1105,14 @@ static int arizona_extcon_probe(struct platform_device *pdev)
         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
         if (!info) {
                 dev_err(&pdev->dev, "Failed to allocate memory\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
 
         info->micvdd = devm_regulator_get(arizona->dev, "MICVDD");
         if (IS_ERR(info->micvdd)) {
                 ret = PTR_ERR(info->micvdd);
                 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
-                goto err;
+                return ret;
         }
 
         mutex_init(&info->lock);
@@ -1151,15 +1150,19 @@ static int arizona_extcon_probe(struct platform_device *pdev)
                 break;
         }
 
-        info->edev.name = "Headset Jack";
-        info->edev.dev.parent = arizona->dev;
-        info->edev.supported_cable = arizona_cable;
+        info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
+        if (IS_ERR(info->edev)) {
+                dev_err(&pdev->dev, "failed to allocate extcon device\n");
+                return -ENOMEM;
+        }
+        info->edev->name = "Headset Jack";
+        info->edev->dev.parent = arizona->dev;
 
-        ret = extcon_dev_register(&info->edev);
+        ret = devm_extcon_dev_register(&pdev->dev, info->edev);
         if (ret < 0) {
                 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
                         ret);
-                goto err;
+                return ret;
         }
 
         info->input = devm_input_allocate_device(&pdev->dev);
@@ -1410,8 +1413,6 @@ err_rise:
 err_input:
 err_register:
         pm_runtime_disable(&pdev->dev);
-        extcon_dev_unregister(&info->edev);
-err:
         return ret;
 }
 
@@ -1445,7 +1446,6 @@ static int arizona_extcon_remove(struct platform_device *pdev)
         regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
                            ARIZONA_JD1_ENA, 0);
         arizona_clk32k_disable(arizona);
-        extcon_dev_unregister(&info->edev);
 
         return 0;
 }
diff --git a/drivers/extcon/extcon-class.c b/drivers/extcon/extcon-class.c
index 7ab21aa6eaa1..18d42c0e4581 100644
--- a/drivers/extcon/extcon-class.c
+++ b/drivers/extcon/extcon-class.c
@@ -565,6 +565,100 @@ static void dummy_sysfs_dev_release(struct device *dev)
 {
 }
 
+/*
+ * extcon_dev_allocate() - Allocate the memory of extcon device.
+ * @supported_cable:    Array of supported cable names ending with NULL.
+ *                      If supported_cable is NULL, cable name related APIs
+ *                      are disabled.
+ *
+ * This function allocates the memory for extcon device without allocating
+ * memory in each extcon provider driver and initialize default setting for
+ * extcon device.
+ *
+ * Return the pointer of extcon device if success or ERR_PTR(err) if fail
+ */
+struct extcon_dev *extcon_dev_allocate(const char **supported_cable)
+{
+        struct extcon_dev *edev;
+
+        edev = kzalloc(sizeof(*edev), GFP_KERNEL);
+        if (!edev)
+                return ERR_PTR(-ENOMEM);
+
+        edev->max_supported = 0;
+        edev->supported_cable = supported_cable;
+
+        return edev;
+}
+
+/*
+ * extcon_dev_free() - Free the memory of extcon device.
+ * @edev:       the extcon device to free
+ */
+void extcon_dev_free(struct extcon_dev *edev)
+{
+        kfree(edev);
+}
+EXPORT_SYMBOL_GPL(extcon_dev_free);
+
+static int devm_extcon_dev_match(struct device *dev, void *res, void *data)
+{
+        struct extcon_dev **r = res;
+
+        if (WARN_ON(!r || !*r))
+                return 0;
+
+        return *r == data;
+}
+
+static void devm_extcon_dev_release(struct device *dev, void *res)
+{
+        extcon_dev_free(*(struct extcon_dev **)res);
+}
+
+/**
+ * devm_extcon_dev_allocate - Allocate managed extcon device
+ * @dev:                device owning the extcon device being created
+ * @supported_cable:    Array of supported cable names ending with NULL.
+ *                      If supported_cable is NULL, cable name related APIs
+ *                      are disabled.
+ *
+ * This function manages automatically the memory of extcon device using device
+ * resource management and simplify the control of freeing the memory of extcon
+ * device.
+ *
+ * Returns the pointer memory of allocated extcon_dev if success
+ * or ERR_PTR(err) if fail
+ */
+struct extcon_dev *devm_extcon_dev_allocate(struct device *dev,
+                                            const char **supported_cable)
+{
+        struct extcon_dev **ptr, *edev;
+
+        ptr = devres_alloc(devm_extcon_dev_release, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return ERR_PTR(-ENOMEM);
+
+        edev = extcon_dev_allocate(supported_cable);
+        if (IS_ERR(edev)) {
+                devres_free(ptr);
+                return edev;
+        }
+
+        *ptr = edev;
+        devres_add(dev, ptr);
+
+        return edev;
+}
+EXPORT_SYMBOL_GPL(devm_extcon_dev_allocate);
+
+void devm_extcon_dev_free(struct device *dev, struct extcon_dev *edev)
+{
+        WARN_ON(devres_release(dev, devm_extcon_dev_release,
+                               devm_extcon_dev_match, edev));
+}
+EXPORT_SYMBOL_GPL(devm_extcon_dev_free);
+
 /**
  * extcon_dev_register() - Register a new extcon device
  * @edev        : the new extcon device (should be allocated before calling)
@@ -819,6 +913,63 @@ void extcon_dev_unregister(struct extcon_dev *edev)
 }
 EXPORT_SYMBOL_GPL(extcon_dev_unregister);
 
+static void devm_extcon_dev_unreg(struct device *dev, void *res)
+{
+        extcon_dev_unregister(*(struct extcon_dev **)res);
+}
+
+/**
+ * devm_extcon_dev_register() - Resource-managed extcon_dev_register()
+ * @dev:        device to allocate extcon device
+ * @edev:       the new extcon device to register
+ *
+ * Managed extcon_dev_register() function. If extcon device is attached with
+ * this function, that extcon device is automatically unregistered on driver
+ * detach. Internally this function calls extcon_dev_register() function.
+ * To get more information, refer that function.
+ *
+ * If extcon device is registered with this function and the device needs to be
+ * unregistered separately, devm_extcon_dev_unregister() should be used.
+ *
+ * Returns 0 if success or negaive error number if failure.
+ */
+int devm_extcon_dev_register(struct device *dev, struct extcon_dev *edev)
+{
+        struct extcon_dev **ptr;
+        int ret;
+
+        ptr = devres_alloc(devm_extcon_dev_unreg, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return -ENOMEM;
+
+        ret = extcon_dev_register(edev);
+        if (ret) {
+                devres_free(ptr);
+                return ret;
+        }
+
+        *ptr = edev;
+        devres_add(dev, ptr);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(devm_extcon_dev_register);
+
+/**
+ * devm_extcon_dev_unregister() - Resource-managed extcon_dev_unregister()
+ * @dev:        device the extcon belongs to
+ * @edev:       the extcon device to unregister
+ *
+ * Unregister extcon device that is registered with devm_extcon_dev_register()
+ * function.
+ */
+void devm_extcon_dev_unregister(struct device *dev, struct extcon_dev *edev)
+{
+        WARN_ON(devres_release(dev, devm_extcon_dev_unreg,
+                               devm_extcon_dev_match, edev));
+}
+EXPORT_SYMBOL_GPL(devm_extcon_dev_unregister);
+
 #ifdef CONFIG_OF
 /*
  * extcon_get_edev_by_phandle - Get the extcon device from devicetree
diff --git a/drivers/extcon/extcon-gpio.c b/drivers/extcon/extcon-gpio.c
index 13d522255d81..645b28356819 100644
--- a/drivers/extcon/extcon-gpio.c
+++ b/drivers/extcon/extcon-gpio.c
@@ -32,7 +32,7 @@
 #include <linux/extcon/extcon-gpio.h>
 
 struct gpio_extcon_data {
-        struct extcon_dev edev;
+        struct extcon_dev *edev;
         unsigned gpio;
         bool gpio_active_low;
         const char *state_on;
@@ -53,7 +53,7 @@ static void gpio_extcon_work(struct work_struct *work)
         state = gpio_get_value(data->gpio);
         if (data->gpio_active_low)
                 state = !state;
-        extcon_set_state(&data->edev, state);
+        extcon_set_state(data->edev, state);
 }
 
 static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
@@ -67,9 +67,10 @@ static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
 
 static ssize_t extcon_gpio_print_state(struct extcon_dev *edev, char *buf)
 {
-        struct gpio_extcon_data *extcon_data =
-                container_of(edev, struct gpio_extcon_data, edev);
+        struct device *dev = edev->dev.parent;
+        struct gpio_extcon_data *extcon_data = dev_get_drvdata(dev);
         const char *state;
+
         if (extcon_get_state(edev))
                 state = extcon_data->state_on;
         else
@@ -98,15 +99,21 @@ static int gpio_extcon_probe(struct platform_device *pdev)
         if (!extcon_data)
                 return -ENOMEM;
 
-        extcon_data->edev.name = pdata->name;
-        extcon_data->edev.dev.parent = &pdev->dev;
+        extcon_data->edev = devm_extcon_dev_allocate(&pdev->dev, NULL);
+        if (IS_ERR(extcon_data->edev)) {
+                dev_err(&pdev->dev, "failed to allocate extcon device\n");
+                return -ENOMEM;
+        }
+        extcon_data->edev->name = pdata->name;
+        extcon_data->edev->dev.parent = &pdev->dev;
+
         extcon_data->gpio = pdata->gpio;
         extcon_data->gpio_active_low = pdata->gpio_active_low;
         extcon_data->state_on = pdata->state_on;
         extcon_data->state_off = pdata->state_off;
         extcon_data->check_on_resume = pdata->check_on_resume;
         if (pdata->state_on && pdata->state_off)
-                extcon_data->edev.print_state = extcon_gpio_print_state;
+                extcon_data->edev->print_state = extcon_gpio_print_state;
 
         ret = devm_gpio_request_one(&pdev->dev, extcon_data->gpio, GPIOF_DIR_IN,
                                     pdev->name);
@@ -121,34 +128,27 @@ static int gpio_extcon_probe(struct platform_device *pdev)
                                 msecs_to_jiffies(pdata->debounce);
         }
 
-        ret = extcon_dev_register(&extcon_data->edev);
+        ret = devm_extcon_dev_register(&pdev->dev, extcon_data->edev);
         if (ret < 0)
                 return ret;
 
         INIT_DELAYED_WORK(&extcon_data->work, gpio_extcon_work);
 
         extcon_data->irq = gpio_to_irq(extcon_data->gpio);
-        if (extcon_data->irq < 0) {
-                ret = extcon_data->irq;
-                goto err;
-        }
+        if (extcon_data->irq < 0)
+                return extcon_data->irq;
 
         ret = request_any_context_irq(extcon_data->irq, gpio_irq_handler,
                                       pdata->irq_flags, pdev->name,
                                       extcon_data);
         if (ret < 0)
-                goto err;
+                return ret;
 
         platform_set_drvdata(pdev, extcon_data);
         /* Perform initial detection */
         gpio_extcon_work(&extcon_data->work.work);
 
         return 0;
-
-err:
-        extcon_dev_unregister(&extcon_data->edev);
-
-        return ret;
 }
 
 static int gpio_extcon_remove(struct platform_device *pdev)
@@ -157,7 +157,6 @@ static int gpio_extcon_remove(struct platform_device *pdev)
 
         cancel_delayed_work_sync(&extcon_data->work);
         free_irq(extcon_data->irq, extcon_data);
-        extcon_dev_unregister(&extcon_data->edev);
 
         return 0;
 }
diff --git a/drivers/extcon/extcon-max14577.c b/drivers/extcon/extcon-max14577.c
index 3846941801b8..d49e891b5675 100644
--- a/drivers/extcon/extcon-max14577.c
+++ b/drivers/extcon/extcon-max14577.c
@@ -1,8 +1,9 @@
 /*
- * extcon-max14577.c - MAX14577 extcon driver to support MAX14577 MUIC
+ * extcon-max14577.c - MAX14577/77836 extcon driver to support MUIC
  *
- * Copyright (C) 2013 Samsung Electrnoics
+ * Copyright (C) 2013,2014 Samsung Electrnoics
  * Chanwoo Choi <cw00.choi@samsung.com>
+ * Krzysztof Kozlowski <k.kozlowski@samsung.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,7 +25,6 @@
 #include <linux/mfd/max14577-private.h>
 #include <linux/extcon.h>
 
-#define DEV_NAME                        "max14577-muic"
 #define DELAY_MS_DEFAULT                17000           /* unit: millisecond */
 
 enum max14577_muic_adc_debounce_time {
@@ -40,6 +40,42 @@ enum max14577_muic_status {
         MAX14577_MUIC_STATUS_END,
 };
 
+/**
+ * struct max14577_muic_irq
+ * @irq: the index of irq list of MUIC device.
+ * @name: the name of irq.
+ * @virq: the virtual irq to use irq domain
+ */
+struct max14577_muic_irq {
+        unsigned int irq;
+        const char *name;
+        unsigned int virq;
+};
+
+static struct max14577_muic_irq max14577_muic_irqs[] = {
+        { MAX14577_IRQ_INT1_ADC,        "muic-ADC" },
+        { MAX14577_IRQ_INT1_ADCLOW,     "muic-ADCLOW" },
+        { MAX14577_IRQ_INT1_ADCERR,     "muic-ADCError" },
+        { MAX14577_IRQ_INT2_CHGTYP,     "muic-CHGTYP" },
+        { MAX14577_IRQ_INT2_CHGDETRUN,  "muic-CHGDETRUN" },
+        { MAX14577_IRQ_INT2_DCDTMR,     "muic-DCDTMR" },
+        { MAX14577_IRQ_INT2_DBCHG,      "muic-DBCHG" },
+        { MAX14577_IRQ_INT2_VBVOLT,     "muic-VBVOLT" },
+};
+
+static struct max14577_muic_irq max77836_muic_irqs[] = {
+        { MAX14577_IRQ_INT1_ADC,        "muic-ADC" },
+        { MAX14577_IRQ_INT1_ADCLOW,     "muic-ADCLOW" },
+        { MAX14577_IRQ_INT1_ADCERR,     "muic-ADCError" },
+        { MAX77836_IRQ_INT1_ADC1K,      "muic-ADC1K" },
+        { MAX14577_IRQ_INT2_CHGTYP,     "muic-CHGTYP" },
+        { MAX14577_IRQ_INT2_CHGDETRUN,  "muic-CHGDETRUN" },
+        { MAX14577_IRQ_INT2_DCDTMR,     "muic-DCDTMR" },
+        { MAX14577_IRQ_INT2_DBCHG,      "muic-DBCHG" },
+        { MAX14577_IRQ_INT2_VBVOLT,     "muic-VBVOLT" },
+        { MAX77836_IRQ_INT2_VIDRM,      "muic-VIDRM" },
+};
+
 struct max14577_muic_info {
         struct device *dev;
         struct max14577 *max14577;
@@ -48,6 +84,8 @@ struct max14577_muic_info {
         int prev_chg_type;
         u8 status[MAX14577_MUIC_STATUS_END];
 
+        struct max14577_muic_irq *muic_irqs;
+        unsigned int muic_irqs_num;
         bool irq_adc;
         bool irq_chg;
         struct work_struct irq_work;
@@ -74,29 +112,6 @@ enum max14577_muic_cable_group {
         MAX14577_CABLE_GROUP_CHG,
 };
 
-/**
- * struct max14577_muic_irq
- * @irq: the index of irq list of MUIC device.
- * @name: the name of irq.
- * @virq: the virtual irq to use irq domain
- */
-struct max14577_muic_irq {
-        unsigned int irq;
-        const char *name;
-        unsigned int virq;
-};
-
-static struct max14577_muic_irq muic_irqs[] = {
-        { MAX14577_IRQ_INT1_ADC,        "muic-ADC" },
-        { MAX14577_IRQ_INT1_ADCLOW,     "muic-ADCLOW" },
-        { MAX14577_IRQ_INT1_ADCERR,     "muic-ADCError" },
-        { MAX14577_IRQ_INT2_CHGTYP,     "muic-CHGTYP" },
-        { MAX14577_IRQ_INT2_CHGDETRUN,  "muic-CHGDETRUN" },
-        { MAX14577_IRQ_INT2_DCDTMR,     "muic-DCDTMR" },
-        { MAX14577_IRQ_INT2_DBCHG,      "muic-DBCHG" },
-        { MAX14577_IRQ_INT2_VBVOLT,     "muic-VBVOLT" },
-};
-
 /* Define supported accessory type */
 enum max14577_muic_acc_type {
         MAX14577_MUIC_ADC_GROUND = 0x0,
@@ -528,21 +543,12 @@ static void max14577_muic_irq_work(struct work_struct *work)
         return;
 }
 
-static irqreturn_t max14577_muic_irq_handler(int irq, void *data)
+/*
+ * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
+ * Returns 0 if irq_type does not match registered IRQ for this device type.
+ */
+static int max14577_parse_irq(struct max14577_muic_info *info, int irq_type)
 {
-        struct max14577_muic_info *info = data;
-        int i, irq_type = -1;
-
-        /*
-         * We may be called multiple times for different nested IRQ-s.
-         * Including changes in INT1_ADC and INT2_CGHTYP at once.
-         * However we only need to know whether it was ADC, charger
-         * or both interrupts so decode IRQ and turn on proper flags.
-         */
-        for (i = 0; i < ARRAY_SIZE(muic_irqs); i++)
-                if (irq == muic_irqs[i].virq)
-                        irq_type = muic_irqs[i].irq;
-
         switch (irq_type) {
         case MAX14577_IRQ_INT1_ADC:
         case MAX14577_IRQ_INT1_ADCLOW:
@@ -550,7 +556,7 @@ static irqreturn_t max14577_muic_irq_handler(int irq, void *data)
                 /* Handle all of accessory except for
                    type of charger accessory */
                 info->irq_adc = true;
-                break;
+                return 1;
         case MAX14577_IRQ_INT2_CHGTYP:
         case MAX14577_IRQ_INT2_CHGDETRUN:
         case MAX14577_IRQ_INT2_DCDTMR:
@@ -558,8 +564,62 @@ static irqreturn_t max14577_muic_irq_handler(int irq, void *data)
         case MAX14577_IRQ_INT2_VBVOLT:
                 /* Handle charger accessory */
                 info->irq_chg = true;
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+/*
+ * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
+ * Returns 0 if irq_type does not match registered IRQ for this device type.
+ */
+static int max77836_parse_irq(struct max14577_muic_info *info, int irq_type)
+{
+        /* First check common max14577 interrupts */
+        if (max14577_parse_irq(info, irq_type))
+                return 1;
+
+        switch (irq_type) {
+        case MAX77836_IRQ_INT1_ADC1K:
+                info->irq_adc = true;
+                return 1;
+        case MAX77836_IRQ_INT2_VIDRM:
+                /* Handle charger accessory */
+                info->irq_chg = true;
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+static irqreturn_t max14577_muic_irq_handler(int irq, void *data)
+{
+        struct max14577_muic_info *info = data;
+        int i, irq_type = -1;
+        bool irq_parsed;
+
+        /*
+         * We may be called multiple times for different nested IRQ-s.
+         * Including changes in INT1_ADC and INT2_CGHTYP at once.
+         * However we only need to know whether it was ADC, charger
+         * or both interrupts so decode IRQ and turn on proper flags.
+         */
+        for (i = 0; i < info->muic_irqs_num; i++)
+                if (irq == info->muic_irqs[i].virq)
+                        irq_type = info->muic_irqs[i].irq;
+
+        switch (info->max14577->dev_type) {
+        case MAXIM_DEVICE_TYPE_MAX77836:
+                irq_parsed = max77836_parse_irq(info, irq_type);
                 break;
+        case MAXIM_DEVICE_TYPE_MAX14577:
         default:
+                irq_parsed = max14577_parse_irq(info, irq_type);
+                break;
+        }
+
+        if (!irq_parsed) {
                 dev_err(info->dev, "muic interrupt: irq %d occurred, skipped\n",
                                 irq_type);
                 return IRQ_HANDLED;
@@ -644,13 +704,24 @@ static int max14577_muic_probe(struct platform_device *pdev)
 
         INIT_WORK(&info->irq_work, max14577_muic_irq_work);
 
+        switch (max14577->dev_type) {
+        case MAXIM_DEVICE_TYPE_MAX77836:
+                info->muic_irqs = max77836_muic_irqs;
+                info->muic_irqs_num = ARRAY_SIZE(max77836_muic_irqs);
+                break;
+        case MAXIM_DEVICE_TYPE_MAX14577:
+        default:
+                info->muic_irqs = max14577_muic_irqs;
+                info->muic_irqs_num = ARRAY_SIZE(max14577_muic_irqs);
+        }
+
         /* Support irq domain for max14577 MUIC device */
-        for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) {
-                struct max14577_muic_irq *muic_irq = &muic_irqs[i];
+        for (i = 0; i < info->muic_irqs_num; i++) {
+                struct max14577_muic_irq *muic_irq = &info->muic_irqs[i];
                 unsigned int virq = 0;
 
                 virq = regmap_irq_get_virq(max14577->irq_data, muic_irq->irq);
-                if (!virq)
+                if (virq <= 0)
                         return -EINVAL;
                 muic_irq->virq = virq;
 
@@ -668,14 +739,16 @@ static int max14577_muic_probe(struct platform_device *pdev)
         }
 
         /* Initialize extcon device */
-        info->edev = devm_kzalloc(&pdev->dev, sizeof(*info->edev), GFP_KERNEL);
-        if (!info->edev) {
+        info->edev = devm_extcon_dev_allocate(&pdev->dev,
+                                              max14577_extcon_cable);
+        if (IS_ERR(info->edev)) {
                 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
                 return -ENOMEM;
         }
-        info->edev->name = DEV_NAME;
-        info->edev->supported_cable = max14577_extcon_cable;
-        ret = extcon_dev_register(info->edev);
+
+        info->edev->name = dev_name(&pdev->dev);
+
+        ret = devm_extcon_dev_register(&pdev->dev, info->edev);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register extcon device\n");
                 return ret;
@@ -694,7 +767,7 @@ static int max14577_muic_probe(struct platform_device *pdev)
                         MAX14577_REG_DEVICEID, &id);
         if (ret < 0) {
                 dev_err(&pdev->dev, "failed to read revision number\n");
-                goto err_extcon;
+                return ret;
         }
         dev_info(info->dev, "device ID : 0x%x\n", id);
 
@@ -710,19 +783,10 @@ static int max14577_muic_probe(struct platform_device *pdev)
          * driver should notify cable state to upper layer.
          */
         INIT_DELAYED_WORK(&info->wq_detcable, max14577_muic_detect_cable_wq);
-        ret = queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
+        queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
                         delay_jiffies);
-        if (ret < 0) {
-                dev_err(&pdev->dev,
-                        "failed to schedule delayed work for cable detect\n");
-                goto err_extcon;
-        }
 
         return ret;
-
-err_extcon:
-        extcon_dev_unregister(info->edev);
-        return ret;
 }
 
 static int max14577_muic_remove(struct platform_device *pdev)
@@ -730,23 +794,30 @@ static int max14577_muic_remove(struct platform_device *pdev)
         struct max14577_muic_info *info = platform_get_drvdata(pdev);
 
         cancel_work_sync(&info->irq_work);
-        extcon_dev_unregister(info->edev);
 
         return 0;
 }
 
+static const struct platform_device_id max14577_muic_id[] = {
+        { "max14577-muic", MAXIM_DEVICE_TYPE_MAX14577, },
+        { "max77836-muic", MAXIM_DEVICE_TYPE_MAX77836, },
+        { }
+};
+MODULE_DEVICE_TABLE(platform, max14577_muic_id);
+
 static struct platform_driver max14577_muic_driver = {
         .driver         = {
-                .name   = DEV_NAME,
+                .name   = "max14577-muic",
                 .owner  = THIS_MODULE,
         },
         .probe          = max14577_muic_probe,
         .remove         = max14577_muic_remove,
+        .id_table       = max14577_muic_id,
 };
 
 module_platform_driver(max14577_muic_driver);
 
-MODULE_DESCRIPTION("MAXIM 14577 Extcon driver");
-MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
+MODULE_DESCRIPTION("Maxim 14577/77836 Extcon driver");
+MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <k.kozlowski@samsung.com>");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:extcon-max14577");
diff --git a/drivers/extcon/extcon-max77693.c b/drivers/extcon/extcon-max77693.c
index da268fbc901b..2c7c3e191591 100644
--- a/drivers/extcon/extcon-max77693.c
+++ b/drivers/extcon/extcon-max77693.c
@@ -1175,25 +1175,24 @@ static int max77693_muic_probe(struct platform_device *pdev)
         }
 
         /* Initialize extcon device */
-        info->edev = devm_kzalloc(&pdev->dev, sizeof(struct extcon_dev),
-                                  GFP_KERNEL);
-        if (!info->edev) {
+        info->edev = devm_extcon_dev_allocate(&pdev->dev,
+                                              max77693_extcon_cable);
+        if (IS_ERR(info->edev)) {
                 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
                 ret = -ENOMEM;
                 goto err_irq;
         }
         info->edev->name = DEV_NAME;
         info->edev->dev.parent = &pdev->dev;
-        info->edev->supported_cable = max77693_extcon_cable;
-        ret = extcon_dev_register(info->edev);
+
+        ret = devm_extcon_dev_register(&pdev->dev, info->edev);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register extcon device\n");
                 goto err_irq;
         }
 
-
         /* Initialize MUIC register by using platform data or default data */
-        if (pdata->muic_data) {
+        if (pdata && pdata->muic_data) {
                 init_data = pdata->muic_data->init_data;
                 num_init_data = pdata->muic_data->num_init_data;
         } else {
@@ -1226,7 +1225,7 @@ static int max77693_muic_probe(struct platform_device *pdev)
                                 = init_data[i].data;
         }
 
-        if (pdata->muic_data) {
+        if (pdata && pdata->muic_data) {
                 struct max77693_muic_platform_data *muic_pdata
                                                    = pdata->muic_data;
 
@@ -1267,7 +1266,7 @@ static int max77693_muic_probe(struct platform_device *pdev)
                         MAX77693_MUIC_REG_ID, &id);
         if (ret < 0) {
                 dev_err(&pdev->dev, "failed to read revision number\n");
-                goto err_extcon;
+                goto err_irq;
         }
         dev_info(info->dev, "device ID : 0x%x\n", id);
 
@@ -1283,12 +1282,11 @@ static int max77693_muic_probe(struct platform_device *pdev)
          * driver should notify cable state to upper layer.
          */
         INIT_DELAYED_WORK(&info->wq_detcable, max77693_muic_detect_cable_wq);
-        schedule_delayed_work(&info->wq_detcable, delay_jiffies);
+        queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
+                        delay_jiffies);
 
         return ret;
 
-err_extcon:
-        extcon_dev_unregister(info->edev);
 err_irq:
         while (--i >= 0)
                 free_irq(muic_irqs[i].virq, info);
@@ -1304,7 +1302,6 @@ static int max77693_muic_remove(struct platform_device *pdev)
                 free_irq(muic_irqs[i].virq, info);
         cancel_work_sync(&info->irq_work);
         input_unregister_device(info->dock);
-        extcon_dev_unregister(info->edev);
 
         return 0;
 }
diff --git a/drivers/extcon/extcon-max8997.c b/drivers/extcon/extcon-max8997.c
index 6a00464658c5..d9f7f1baaa03 100644
--- a/drivers/extcon/extcon-max8997.c
+++ b/drivers/extcon/extcon-max8997.c
@@ -699,23 +699,22 @@ static int max8997_muic_probe(struct platform_device *pdev)
         }
 
         /* External connector */
-        info->edev = devm_kzalloc(&pdev->dev, sizeof(struct extcon_dev),
-                                  GFP_KERNEL);
-        if (!info->edev) {
+        info->edev = devm_extcon_dev_allocate(&pdev->dev, max8997_extcon_cable);
+        if (IS_ERR(info->edev)) {
                 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
                 ret = -ENOMEM;
                 goto err_irq;
         }
         info->edev->name = DEV_NAME;
         info->edev->dev.parent = &pdev->dev;
-        info->edev->supported_cable = max8997_extcon_cable;
-        ret = extcon_dev_register(info->edev);
+
+        ret = devm_extcon_dev_register(&pdev->dev, info->edev);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register extcon device\n");
                 goto err_irq;
         }
 
-        if (pdata->muic_pdata) {
+        if (pdata && pdata->muic_pdata) {
                 struct max8997_muic_platform_data *muic_pdata
                         = pdata->muic_pdata;
 
@@ -770,7 +769,8 @@ static int max8997_muic_probe(struct platform_device *pdev)
          * driver should notify cable state to upper layer.
          */
         INIT_DELAYED_WORK(&info->wq_detcable, max8997_muic_detect_cable_wq);
-        schedule_delayed_work(&info->wq_detcable, delay_jiffies);
+        queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
+                        delay_jiffies);
 
         return 0;
 
@@ -789,8 +789,6 @@ static int max8997_muic_remove(struct platform_device *pdev)
                 free_irq(muic_irqs[i].virq, info);
         cancel_work_sync(&info->irq_work);
 
-        extcon_dev_unregister(info->edev);
-
         return 0;
 }
 
diff --git a/drivers/extcon/extcon-palmas.c b/drivers/extcon/extcon-palmas.c
index ddff2b72f0a8..7417ce84eb2d 100644
--- a/drivers/extcon/extcon-palmas.c
+++ b/drivers/extcon/extcon-palmas.c
@@ -23,6 +23,7 @@
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/mfd/palmas.h>
 #include <linux/of.h>
@@ -56,7 +57,7 @@ static irqreturn_t palmas_vbus_irq_handler(int irq, void *_palmas_usb)
         if (vbus_line_state & PALMAS_INT3_LINE_STATE_VBUS) {
                 if (palmas_usb->linkstat != PALMAS_USB_STATE_VBUS) {
                         palmas_usb->linkstat = PALMAS_USB_STATE_VBUS;
-                        extcon_set_cable_state(&palmas_usb->edev, "USB", true);
+                        extcon_set_cable_state(palmas_usb->edev, "USB", true);
                         dev_info(palmas_usb->dev, "USB cable is attached\n");
                 } else {
                         dev_dbg(palmas_usb->dev,
@@ -65,7 +66,7 @@ static irqreturn_t palmas_vbus_irq_handler(int irq, void *_palmas_usb)
         } else if (!(vbus_line_state & PALMAS_INT3_LINE_STATE_VBUS)) {
                 if (palmas_usb->linkstat == PALMAS_USB_STATE_VBUS) {
                         palmas_usb->linkstat = PALMAS_USB_STATE_DISCONNECT;
-                        extcon_set_cable_state(&palmas_usb->edev, "USB", false);
+                        extcon_set_cable_state(palmas_usb->edev, "USB", false);
                         dev_info(palmas_usb->dev, "USB cable is detached\n");
                 } else {
                         dev_dbg(palmas_usb->dev,
@@ -92,7 +93,7 @@ static irqreturn_t palmas_id_irq_handler(int irq, void *_palmas_usb)
                         PALMAS_USB_ID_INT_LATCH_CLR,
                         PALMAS_USB_ID_INT_EN_HI_CLR_ID_GND);
                 palmas_usb->linkstat = PALMAS_USB_STATE_ID;
-                extcon_set_cable_state(&palmas_usb->edev, "USB-HOST", true);
+                extcon_set_cable_state(palmas_usb->edev, "USB-HOST", true);
                 dev_info(palmas_usb->dev, "USB-HOST cable is attached\n");
         } else if ((set & PALMAS_USB_ID_INT_SRC_ID_FLOAT) &&
                                 (id_src & PALMAS_USB_ID_INT_SRC_ID_FLOAT)) {
@@ -100,17 +101,17 @@ static irqreturn_t palmas_id_irq_handler(int irq, void *_palmas_usb)
                         PALMAS_USB_ID_INT_LATCH_CLR,
                         PALMAS_USB_ID_INT_EN_HI_CLR_ID_FLOAT);
                 palmas_usb->linkstat = PALMAS_USB_STATE_DISCONNECT;
-                extcon_set_cable_state(&palmas_usb->edev, "USB-HOST", false);
+                extcon_set_cable_state(palmas_usb->edev, "USB-HOST", false);
                 dev_info(palmas_usb->dev, "USB-HOST cable is detached\n");
         } else if ((palmas_usb->linkstat == PALMAS_USB_STATE_ID) &&
                                 (!(set & PALMAS_USB_ID_INT_SRC_ID_GND))) {
                 palmas_usb->linkstat = PALMAS_USB_STATE_DISCONNECT;
-                extcon_set_cable_state(&palmas_usb->edev, "USB-HOST", false);
+                extcon_set_cable_state(palmas_usb->edev, "USB-HOST", false);
                 dev_info(palmas_usb->dev, "USB-HOST cable is detached\n");
         } else if ((palmas_usb->linkstat == PALMAS_USB_STATE_DISCONNECT) &&
                                 (id_src & PALMAS_USB_ID_INT_SRC_ID_GND)) {
                 palmas_usb->linkstat = PALMAS_USB_STATE_ID;
-                extcon_set_cable_state(&palmas_usb->edev, "USB-HOST", true);
+                extcon_set_cable_state(palmas_usb->edev, "USB-HOST", true);
                 dev_info(palmas_usb->dev, " USB-HOST cable is attached\n");
         }
 
@@ -186,13 +187,20 @@ static int palmas_usb_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, palmas_usb);
 
-        palmas_usb->edev.supported_cable = palmas_extcon_cable;
-        palmas_usb->edev.dev.parent = palmas_usb->dev;
-        palmas_usb->edev.mutually_exclusive = mutually_exclusive;
+        palmas_usb->edev = devm_extcon_dev_allocate(&pdev->dev,
+                                                    palmas_extcon_cable);
+        if (IS_ERR(palmas_usb->edev)) {
+                dev_err(&pdev->dev, "failed to allocate extcon device\n");
+                return -ENOMEM;
+        }
+        palmas_usb->edev->name = kstrdup(node->name, GFP_KERNEL);
+        palmas_usb->edev->dev.parent = palmas_usb->dev;
+        palmas_usb->edev->mutually_exclusive = mutually_exclusive;
 
-        status = extcon_dev_register(&palmas_usb->edev);
+        status = devm_extcon_dev_register(&pdev->dev, palmas_usb->edev);
         if (status) {
                 dev_err(&pdev->dev, "failed to register extcon device\n");
+                kfree(palmas_usb->edev->name);
                 return status;
         }
 
@@ -206,7 +214,8 @@ static int palmas_usb_probe(struct platform_device *pdev)
                 if (status < 0) {
                         dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
                                         palmas_usb->id_irq, status);
-                        goto fail_extcon;
+                        kfree(palmas_usb->edev->name);
+                        return status;
                 }
         }
 
@@ -220,25 +229,21 @@ static int palmas_usb_probe(struct platform_device *pdev)
                 if (status < 0) {
                         dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
                                         palmas_usb->vbus_irq, status);
-                        goto fail_extcon;
+                        kfree(palmas_usb->edev->name);
+                        return status;
                 }
         }
 
         palmas_enable_irq(palmas_usb);
         device_set_wakeup_capable(&pdev->dev, true);
         return 0;
-
-fail_extcon:
-        extcon_dev_unregister(&palmas_usb->edev);
-
-        return status;
 }
 
 static int palmas_usb_remove(struct platform_device *pdev)
 {
         struct palmas_usb *palmas_usb = platform_get_drvdata(pdev);
 
-        extcon_dev_unregister(&palmas_usb->edev);
+        kfree(palmas_usb->edev->name);
 
         return 0;
 }