max8903: adds requesting of gpios.

[deliverable/linux.git] / drivers / power / max8903_charger.c

diff --git a/drivers/power/max8903_charger.c b/drivers/power/max8903_charger.c
index 6ec705f7a9d9d698327d2eff962daf1a37401ab6..3f35593443b38ccf979783e76db4bb7aa2a7e7c5 100644 (file)
--- a/drivers/power/max8903_charger.c
+++ b/drivers/power/max8903_charger.c
@@ -179,39 +179,27 @@ static irqreturn_t max8903_fault(int irq, void *_data)
        return IRQ_HANDLED;
 }
 
-static int max8903_probe(struct platform_device *pdev)
+static int max8903_setup_gpios(struct platform_device *pdev)
 {
-       struct max8903_data *data;
+       struct max8903_data *data = platform_get_drvdata(pdev);
        struct device *dev = &pdev->dev;
        struct max8903_pdata *pdata = pdev->dev.platform_data;
-       struct power_supply_config psy_cfg = {};
        int ret = 0;
        int gpio;
        int ta_in = 0;
        int usb_in = 0;
 
-       if (pdata == NULL) {
-               dev_err(dev, "No platform data.\n");
-               return -EINVAL;
-       }
-
-       data = devm_kzalloc(dev, sizeof(struct max8903_data), GFP_KERNEL);
-       if (data == NULL) {
-               dev_err(dev, "Cannot allocate memory.\n");
-               return -ENOMEM;
-       }
-
-       data->pdata = pdev->dev.platform_data;
-       data->dev = dev;
-       platform_set_drvdata(pdev, data);
-
-       if (pdata->dc_valid == false && pdata->usb_valid == false) {
-               dev_err(dev, "No valid power sources.\n");
-               return -EINVAL;
-       }
-
        if (pdata->dc_valid) {
                if (pdata->dok && gpio_is_valid(pdata->dok)) {
+                       ret = devm_gpio_request(dev, pdata->dok,
+                                               data->psy_desc.name);
+                       if (ret) {
+                               dev_err(dev,
+                                       "Failed GPIO request for dok: %d err %d\n",
+                                       pdata->dok, ret);
+                               return ret;
+                       }
+
                        gpio = pdata->dok; /* PULL_UPed Interrupt */
                        ta_in = gpio_get_value(gpio) ? 0 : 1;
                } else {
@@ -222,6 +210,15 @@ static int max8903_probe(struct platform_device *pdev)
 
        if (pdata->dcm) {
                if (gpio_is_valid(pdata->dcm)) {
+                       ret = devm_gpio_request(dev, pdata->dcm,
+                                               data->psy_desc.name);
+                       if (ret) {
+                               dev_err(dev,
+                                       "Failed GPIO request for dcm: %d err %d\n",
+                                       pdata->dcm, ret);
+                               return ret;
+                       }
+
                        gpio = pdata->dcm; /* Output */
                        gpio_set_value(gpio, ta_in);
                } else {
@@ -232,6 +229,15 @@ static int max8903_probe(struct platform_device *pdev)
 
        if (pdata->usb_valid) {
                if (pdata->uok && gpio_is_valid(pdata->uok)) {
+                       ret = devm_gpio_request(dev, pdata->uok,
+                                               data->psy_desc.name);
+                       if (ret) {
+                               dev_err(dev,
+                                       "Failed GPIO request for uok: %d err %d\n",
+                                       pdata->uok, ret);
+                               return ret;
+                       }
+
                        gpio = pdata->uok;
                        usb_in = gpio_get_value(gpio) ? 0 : 1;
                } else {
@@ -243,6 +249,15 @@ static int max8903_probe(struct platform_device *pdev)
 
        if (pdata->cen) {
                if (gpio_is_valid(pdata->cen)) {
+                       ret = devm_gpio_request(dev, pdata->cen,
+                                               data->psy_desc.name);
+                       if (ret) {
+                               dev_err(dev,
+                                       "Failed GPIO request for cen: %d err %d\n",
+                                       pdata->cen, ret);
+                               return ret;
+                       }
+
                        gpio_set_value(pdata->cen, (ta_in || usb_in) ? 0 : 1);
                } else {
                        dev_err(dev, "Invalid pin: cen.\n");
@@ -251,23 +266,41 @@ static int max8903_probe(struct platform_device *pdev)
        }
 
        if (pdata->chg) {
-               if (!gpio_is_valid(pdata->chg)) {
-                       dev_err(dev, "Invalid pin: chg.\n");
-                       return -EINVAL;
+               if (gpio_is_valid(pdata->chg)) {
+                       ret = devm_gpio_request(dev, pdata->chg,
+                                               data->psy_desc.name);
+                       if (ret) {
+                               dev_err(dev,
+                                       "Failed GPIO request for chg: %d err %d\n",
+                                       pdata->chg, ret);
+                               return ret;
+                       }
                }
        }
 
        if (pdata->flt) {
-               if (!gpio_is_valid(pdata->flt)) {
-                       dev_err(dev, "Invalid pin: flt.\n");
-                       return -EINVAL;
+               if (gpio_is_valid(pdata->flt)) {
+                       ret = devm_gpio_request(dev, pdata->flt,
+                                               data->psy_desc.name);
+                       if (ret) {
+                               dev_err(dev,
+                                       "Failed GPIO request for flt: %d err %d\n",
+                                       pdata->flt, ret);
+                               return ret;
+                       }
                }
        }
 
        if (pdata->usus) {
-               if (!gpio_is_valid(pdata->usus)) {
-                       dev_err(dev, "Invalid pin: usus.\n");
-                       return -EINVAL;
+               if (gpio_is_valid(pdata->usus)) {
+                       ret = devm_gpio_request(dev, pdata->usus,
+                                               data->psy_desc.name);
+                       if (ret) {
+                               dev_err(dev,
+                                       "Failed GPIO request for usus: %d err %d\n",
+                                       pdata->usus, ret);
+                               return ret;
+                       }
                }
        }
 
@@ -275,9 +308,44 @@ static int max8903_probe(struct platform_device *pdev)
        data->ta_in = ta_in;
        data->usb_in = usb_in;
 
+       return 0;
+}
+
+static int max8903_probe(struct platform_device *pdev)
+{
+       struct max8903_data *data;
+       struct device *dev = &pdev->dev;
+       struct max8903_pdata *pdata = pdev->dev.platform_data;
+       struct power_supply_config psy_cfg = {};
+       int ret = 0;
+
+       if (pdata == NULL) {
+               dev_err(dev, "No platform data.\n");
+               return -EINVAL;
+       }
+
+       data = devm_kzalloc(dev, sizeof(struct max8903_data), GFP_KERNEL);
+       if (data == NULL) {
+               dev_err(dev, "Cannot allocate memory.\n");
+               return -ENOMEM;
+       }
+
+       data->pdata = pdev->dev.platform_data;
+       data->dev = dev;
+       platform_set_drvdata(pdev, data);
+
+       if (pdata->dc_valid == false && pdata->usb_valid == false) {
+               dev_err(dev, "No valid power sources.\n");
+               return -EINVAL;
+       }
+
+       ret = max8903_setup_gpios(pdev);
+       if (ret)
+               return ret;
+
        data->psy_desc.name = "max8903_charger";
-       data->psy_desc.type = (ta_in) ? POWER_SUPPLY_TYPE_MAINS :
-                       ((usb_in) ? POWER_SUPPLY_TYPE_USB :
+       data->psy_desc.type = (data->ta_in) ? POWER_SUPPLY_TYPE_MAINS :
+                       ((data->usb_in) ? POWER_SUPPLY_TYPE_USB :
                         POWER_SUPPLY_TYPE_BATTERY);
        data->psy_desc.get_property = max8903_get_property;
        data->psy_desc.properties = max8903_charger_props;