Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * PMU driver for Wolfson Microelectronics wm831x PMICs
0004  *
0005  * Copyright 2009 Wolfson Microelectronics PLC.
0006  */
0007 
0008 #include <linux/module.h>
0009 #include <linux/err.h>
0010 #include <linux/platform_device.h>
0011 #include <linux/power_supply.h>
0012 #include <linux/slab.h>
0013 #include <linux/usb/phy.h>
0014 
0015 #include <linux/mfd/wm831x/core.h>
0016 #include <linux/mfd/wm831x/auxadc.h>
0017 #include <linux/mfd/wm831x/pmu.h>
0018 #include <linux/mfd/wm831x/pdata.h>
0019 
0020 struct wm831x_power {
0021     struct wm831x *wm831x;
0022     struct power_supply *wall;
0023     struct power_supply *usb;
0024     struct power_supply *battery;
0025     struct power_supply_desc wall_desc;
0026     struct power_supply_desc usb_desc;
0027     struct power_supply_desc battery_desc;
0028     char wall_name[20];
0029     char usb_name[20];
0030     char battery_name[20];
0031     bool have_battery;
0032     struct usb_phy *usb_phy;
0033     struct notifier_block usb_notify;
0034 };
0035 
0036 static int wm831x_power_check_online(struct wm831x *wm831x, int supply,
0037                      union power_supply_propval *val)
0038 {
0039     int ret;
0040 
0041     ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
0042     if (ret < 0)
0043         return ret;
0044 
0045     if (ret & supply)
0046         val->intval = 1;
0047     else
0048         val->intval = 0;
0049 
0050     return 0;
0051 }
0052 
0053 static int wm831x_power_read_voltage(struct wm831x *wm831x,
0054                      enum wm831x_auxadc src,
0055                      union power_supply_propval *val)
0056 {
0057     int ret;
0058 
0059     ret = wm831x_auxadc_read_uv(wm831x, src);
0060     if (ret >= 0)
0061         val->intval = ret;
0062 
0063     return ret;
0064 }
0065 
0066 /*********************************************************************
0067  *      WALL Power
0068  *********************************************************************/
0069 static int wm831x_wall_get_prop(struct power_supply *psy,
0070                 enum power_supply_property psp,
0071                 union power_supply_propval *val)
0072 {
0073     struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev.parent);
0074     struct wm831x *wm831x = wm831x_power->wm831x;
0075     int ret = 0;
0076 
0077     switch (psp) {
0078     case POWER_SUPPLY_PROP_ONLINE:
0079         ret = wm831x_power_check_online(wm831x, WM831X_PWR_WALL, val);
0080         break;
0081     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0082         ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_WALL, val);
0083         break;
0084     default:
0085         ret = -EINVAL;
0086         break;
0087     }
0088 
0089     return ret;
0090 }
0091 
0092 static enum power_supply_property wm831x_wall_props[] = {
0093     POWER_SUPPLY_PROP_ONLINE,
0094     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0095 };
0096 
0097 /*********************************************************************
0098  *      USB Power
0099  *********************************************************************/
0100 static int wm831x_usb_get_prop(struct power_supply *psy,
0101                    enum power_supply_property psp,
0102                    union power_supply_propval *val)
0103 {
0104     struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev.parent);
0105     struct wm831x *wm831x = wm831x_power->wm831x;
0106     int ret = 0;
0107 
0108     switch (psp) {
0109     case POWER_SUPPLY_PROP_ONLINE:
0110         ret = wm831x_power_check_online(wm831x, WM831X_PWR_USB, val);
0111         break;
0112     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0113         ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_USB, val);
0114         break;
0115     default:
0116         ret = -EINVAL;
0117         break;
0118     }
0119 
0120     return ret;
0121 }
0122 
0123 static enum power_supply_property wm831x_usb_props[] = {
0124     POWER_SUPPLY_PROP_ONLINE,
0125     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0126 };
0127 
0128 /* In milliamps */
0129 static const unsigned int wm831x_usb_limits[] = {
0130     0,
0131     2,
0132     100,
0133     500,
0134     900,
0135     1500,
0136     1800,
0137     550,
0138 };
0139 
0140 static int wm831x_usb_limit_change(struct notifier_block *nb,
0141                    unsigned long limit, void *data)
0142 {
0143     struct wm831x_power *wm831x_power = container_of(nb,
0144                              struct wm831x_power,
0145                              usb_notify);
0146     unsigned int i, best;
0147 
0148     /* Find the highest supported limit */
0149     best = 0;
0150     for (i = 0; i < ARRAY_SIZE(wm831x_usb_limits); i++) {
0151         if (limit >= wm831x_usb_limits[i] &&
0152             wm831x_usb_limits[best] < wm831x_usb_limits[i])
0153             best = i;
0154     }
0155 
0156     dev_dbg(wm831x_power->wm831x->dev,
0157         "Limiting USB current to %umA", wm831x_usb_limits[best]);
0158 
0159     wm831x_set_bits(wm831x_power->wm831x, WM831X_POWER_STATE,
0160                 WM831X_USB_ILIM_MASK, best);
0161 
0162     return 0;
0163 }
0164 
0165 /*********************************************************************
0166  *      Battery properties
0167  *********************************************************************/
0168 
0169 struct chg_map {
0170     int val;
0171     int reg_val;
0172 };
0173 
0174 static struct chg_map trickle_ilims[] = {
0175     {  50, 0 << WM831X_CHG_TRKL_ILIM_SHIFT },
0176     { 100, 1 << WM831X_CHG_TRKL_ILIM_SHIFT },
0177     { 150, 2 << WM831X_CHG_TRKL_ILIM_SHIFT },
0178     { 200, 3 << WM831X_CHG_TRKL_ILIM_SHIFT },
0179 };
0180 
0181 static struct chg_map vsels[] = {
0182     { 4050, 0 << WM831X_CHG_VSEL_SHIFT },
0183     { 4100, 1 << WM831X_CHG_VSEL_SHIFT },
0184     { 4150, 2 << WM831X_CHG_VSEL_SHIFT },
0185     { 4200, 3 << WM831X_CHG_VSEL_SHIFT },
0186 };
0187 
0188 static struct chg_map fast_ilims[] = {
0189     {    0,  0 << WM831X_CHG_FAST_ILIM_SHIFT },
0190     {   50,  1 << WM831X_CHG_FAST_ILIM_SHIFT },
0191     {  100,  2 << WM831X_CHG_FAST_ILIM_SHIFT },
0192     {  150,  3 << WM831X_CHG_FAST_ILIM_SHIFT },
0193     {  200,  4 << WM831X_CHG_FAST_ILIM_SHIFT },
0194     {  250,  5 << WM831X_CHG_FAST_ILIM_SHIFT },
0195     {  300,  6 << WM831X_CHG_FAST_ILIM_SHIFT },
0196     {  350,  7 << WM831X_CHG_FAST_ILIM_SHIFT },
0197     {  400,  8 << WM831X_CHG_FAST_ILIM_SHIFT },
0198     {  450,  9 << WM831X_CHG_FAST_ILIM_SHIFT },
0199     {  500, 10 << WM831X_CHG_FAST_ILIM_SHIFT },
0200     {  600, 11 << WM831X_CHG_FAST_ILIM_SHIFT },
0201     {  700, 12 << WM831X_CHG_FAST_ILIM_SHIFT },
0202     {  800, 13 << WM831X_CHG_FAST_ILIM_SHIFT },
0203     {  900, 14 << WM831X_CHG_FAST_ILIM_SHIFT },
0204     { 1000, 15 << WM831X_CHG_FAST_ILIM_SHIFT },
0205 };
0206 
0207 static struct chg_map eoc_iterms[] = {
0208     { 20, 0 << WM831X_CHG_ITERM_SHIFT },
0209     { 30, 1 << WM831X_CHG_ITERM_SHIFT },
0210     { 40, 2 << WM831X_CHG_ITERM_SHIFT },
0211     { 50, 3 << WM831X_CHG_ITERM_SHIFT },
0212     { 60, 4 << WM831X_CHG_ITERM_SHIFT },
0213     { 70, 5 << WM831X_CHG_ITERM_SHIFT },
0214     { 80, 6 << WM831X_CHG_ITERM_SHIFT },
0215     { 90, 7 << WM831X_CHG_ITERM_SHIFT },
0216 };
0217 
0218 static struct chg_map chg_times[] = {
0219     {  60,  0 << WM831X_CHG_TIME_SHIFT },
0220     {  90,  1 << WM831X_CHG_TIME_SHIFT },
0221     { 120,  2 << WM831X_CHG_TIME_SHIFT },
0222     { 150,  3 << WM831X_CHG_TIME_SHIFT },
0223     { 180,  4 << WM831X_CHG_TIME_SHIFT },
0224     { 210,  5 << WM831X_CHG_TIME_SHIFT },
0225     { 240,  6 << WM831X_CHG_TIME_SHIFT },
0226     { 270,  7 << WM831X_CHG_TIME_SHIFT },
0227     { 300,  8 << WM831X_CHG_TIME_SHIFT },
0228     { 330,  9 << WM831X_CHG_TIME_SHIFT },
0229     { 360, 10 << WM831X_CHG_TIME_SHIFT },
0230     { 390, 11 << WM831X_CHG_TIME_SHIFT },
0231     { 420, 12 << WM831X_CHG_TIME_SHIFT },
0232     { 450, 13 << WM831X_CHG_TIME_SHIFT },
0233     { 480, 14 << WM831X_CHG_TIME_SHIFT },
0234     { 510, 15 << WM831X_CHG_TIME_SHIFT },
0235 };
0236 
0237 static void wm831x_battery_apply_config(struct wm831x *wm831x,
0238                        struct chg_map *map, int count, int val,
0239                        int *reg, const char *name,
0240                        const char *units)
0241 {
0242     int i;
0243 
0244     for (i = 0; i < count; i++)
0245         if (val == map[i].val)
0246             break;
0247     if (i == count) {
0248         dev_err(wm831x->dev, "Invalid %s %d%s\n",
0249             name, val, units);
0250     } else {
0251         *reg |= map[i].reg_val;
0252         dev_dbg(wm831x->dev, "Set %s of %d%s\n", name, val, units);
0253     }
0254 }
0255 
0256 static void wm831x_config_battery(struct wm831x *wm831x)
0257 {
0258     struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
0259     struct wm831x_battery_pdata *pdata;
0260     int ret, reg1, reg2;
0261 
0262     if (!wm831x_pdata || !wm831x_pdata->battery) {
0263         dev_warn(wm831x->dev,
0264              "No battery charger configuration\n");
0265         return;
0266     }
0267 
0268     pdata = wm831x_pdata->battery;
0269 
0270     reg1 = 0;
0271     reg2 = 0;
0272 
0273     if (!pdata->enable) {
0274         dev_info(wm831x->dev, "Battery charger disabled\n");
0275         return;
0276     }
0277 
0278     reg1 |= WM831X_CHG_ENA;
0279     if (pdata->off_mask)
0280         reg2 |= WM831X_CHG_OFF_MSK;
0281     if (pdata->fast_enable)
0282         reg1 |= WM831X_CHG_FAST;
0283 
0284     wm831x_battery_apply_config(wm831x, trickle_ilims,
0285                    ARRAY_SIZE(trickle_ilims),
0286                    pdata->trickle_ilim, &reg2,
0287                    "trickle charge current limit", "mA");
0288 
0289     wm831x_battery_apply_config(wm831x, vsels, ARRAY_SIZE(vsels),
0290                    pdata->vsel, &reg2,
0291                    "target voltage", "mV");
0292 
0293     wm831x_battery_apply_config(wm831x, fast_ilims, ARRAY_SIZE(fast_ilims),
0294                    pdata->fast_ilim, &reg2,
0295                    "fast charge current limit", "mA");
0296 
0297     wm831x_battery_apply_config(wm831x, eoc_iterms, ARRAY_SIZE(eoc_iterms),
0298                    pdata->eoc_iterm, &reg1,
0299                    "end of charge current threshold", "mA");
0300 
0301     wm831x_battery_apply_config(wm831x, chg_times, ARRAY_SIZE(chg_times),
0302                    pdata->timeout, &reg2,
0303                    "charger timeout", "min");
0304 
0305     ret = wm831x_reg_unlock(wm831x);
0306     if (ret != 0) {
0307         dev_err(wm831x->dev, "Failed to unlock registers: %d\n", ret);
0308         return;
0309     }
0310 
0311     ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_1,
0312                   WM831X_CHG_ENA_MASK |
0313                   WM831X_CHG_FAST_MASK |
0314                   WM831X_CHG_ITERM_MASK,
0315                   reg1);
0316     if (ret != 0)
0317         dev_err(wm831x->dev, "Failed to set charger control 1: %d\n",
0318             ret);
0319 
0320     ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_2,
0321                   WM831X_CHG_OFF_MSK |
0322                   WM831X_CHG_TIME_MASK |
0323                   WM831X_CHG_FAST_ILIM_MASK |
0324                   WM831X_CHG_TRKL_ILIM_MASK |
0325                   WM831X_CHG_VSEL_MASK,
0326                   reg2);
0327     if (ret != 0)
0328         dev_err(wm831x->dev, "Failed to set charger control 2: %d\n",
0329             ret);
0330 
0331     wm831x_reg_lock(wm831x);
0332 }
0333 
0334 static int wm831x_bat_check_status(struct wm831x *wm831x, int *status)
0335 {
0336     int ret;
0337 
0338     ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
0339     if (ret < 0)
0340         return ret;
0341 
0342     if (ret & WM831X_PWR_SRC_BATT) {
0343         *status = POWER_SUPPLY_STATUS_DISCHARGING;
0344         return 0;
0345     }
0346 
0347     ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
0348     if (ret < 0)
0349         return ret;
0350 
0351     switch (ret & WM831X_CHG_STATE_MASK) {
0352     case WM831X_CHG_STATE_OFF:
0353         *status = POWER_SUPPLY_STATUS_NOT_CHARGING;
0354         break;
0355     case WM831X_CHG_STATE_TRICKLE:
0356     case WM831X_CHG_STATE_FAST:
0357         *status = POWER_SUPPLY_STATUS_CHARGING;
0358         break;
0359 
0360     default:
0361         *status = POWER_SUPPLY_STATUS_UNKNOWN;
0362         break;
0363     }
0364 
0365     return 0;
0366 }
0367 
0368 static int wm831x_bat_check_type(struct wm831x *wm831x, int *type)
0369 {
0370     int ret;
0371 
0372     ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
0373     if (ret < 0)
0374         return ret;
0375 
0376     switch (ret & WM831X_CHG_STATE_MASK) {
0377     case WM831X_CHG_STATE_TRICKLE:
0378     case WM831X_CHG_STATE_TRICKLE_OT:
0379         *type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
0380         break;
0381     case WM831X_CHG_STATE_FAST:
0382     case WM831X_CHG_STATE_FAST_OT:
0383         *type = POWER_SUPPLY_CHARGE_TYPE_FAST;
0384         break;
0385     default:
0386         *type = POWER_SUPPLY_CHARGE_TYPE_NONE;
0387         break;
0388     }
0389 
0390     return 0;
0391 }
0392 
0393 static int wm831x_bat_check_health(struct wm831x *wm831x, int *health)
0394 {
0395     int ret;
0396 
0397     ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
0398     if (ret < 0)
0399         return ret;
0400 
0401     if (ret & WM831X_BATT_HOT_STS) {
0402         *health = POWER_SUPPLY_HEALTH_OVERHEAT;
0403         return 0;
0404     }
0405 
0406     if (ret & WM831X_BATT_COLD_STS) {
0407         *health = POWER_SUPPLY_HEALTH_COLD;
0408         return 0;
0409     }
0410 
0411     if (ret & WM831X_BATT_OV_STS) {
0412         *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
0413         return 0;
0414     }
0415 
0416     switch (ret & WM831X_CHG_STATE_MASK) {
0417     case WM831X_CHG_STATE_TRICKLE_OT:
0418     case WM831X_CHG_STATE_FAST_OT:
0419         *health = POWER_SUPPLY_HEALTH_OVERHEAT;
0420         break;
0421     case WM831X_CHG_STATE_DEFECTIVE:
0422         *health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
0423         break;
0424     default:
0425         *health = POWER_SUPPLY_HEALTH_GOOD;
0426         break;
0427     }
0428 
0429     return 0;
0430 }
0431 
0432 static int wm831x_bat_get_prop(struct power_supply *psy,
0433                    enum power_supply_property psp,
0434                    union power_supply_propval *val)
0435 {
0436     struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev.parent);
0437     struct wm831x *wm831x = wm831x_power->wm831x;
0438     int ret = 0;
0439 
0440     switch (psp) {
0441     case POWER_SUPPLY_PROP_STATUS:
0442         ret = wm831x_bat_check_status(wm831x, &val->intval);
0443         break;
0444     case POWER_SUPPLY_PROP_ONLINE:
0445         ret = wm831x_power_check_online(wm831x, WM831X_PWR_SRC_BATT,
0446                         val);
0447         break;
0448     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0449         ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_BATT, val);
0450         break;
0451     case POWER_SUPPLY_PROP_HEALTH:
0452         ret = wm831x_bat_check_health(wm831x, &val->intval);
0453         break;
0454     case POWER_SUPPLY_PROP_CHARGE_TYPE:
0455         ret = wm831x_bat_check_type(wm831x, &val->intval);
0456         break;
0457     default:
0458         ret = -EINVAL;
0459         break;
0460     }
0461 
0462     return ret;
0463 }
0464 
0465 static enum power_supply_property wm831x_bat_props[] = {
0466     POWER_SUPPLY_PROP_STATUS,
0467     POWER_SUPPLY_PROP_ONLINE,
0468     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0469     POWER_SUPPLY_PROP_HEALTH,
0470     POWER_SUPPLY_PROP_CHARGE_TYPE,
0471 };
0472 
0473 static const char *wm831x_bat_irqs[] = {
0474     "BATT HOT",
0475     "BATT COLD",
0476     "BATT FAIL",
0477     "OV",
0478     "END",
0479     "TO",
0480     "MODE",
0481     "START",
0482 };
0483 
0484 static irqreturn_t wm831x_bat_irq(int irq, void *data)
0485 {
0486     struct wm831x_power *wm831x_power = data;
0487     struct wm831x *wm831x = wm831x_power->wm831x;
0488 
0489     dev_dbg(wm831x->dev, "Battery status changed: %d\n", irq);
0490 
0491     /* The battery charger is autonomous so we don't need to do
0492      * anything except kick user space */
0493     if (wm831x_power->have_battery)
0494         power_supply_changed(wm831x_power->battery);
0495 
0496     return IRQ_HANDLED;
0497 }
0498 
0499 
0500 /*********************************************************************
0501  *      Initialisation
0502  *********************************************************************/
0503 
0504 static irqreturn_t wm831x_syslo_irq(int irq, void *data)
0505 {
0506     struct wm831x_power *wm831x_power = data;
0507     struct wm831x *wm831x = wm831x_power->wm831x;
0508 
0509     /* Not much we can actually *do* but tell people for
0510      * posterity, we're probably about to run out of power. */
0511     dev_crit(wm831x->dev, "SYSVDD under voltage\n");
0512 
0513     return IRQ_HANDLED;
0514 }
0515 
0516 static irqreturn_t wm831x_pwr_src_irq(int irq, void *data)
0517 {
0518     struct wm831x_power *wm831x_power = data;
0519     struct wm831x *wm831x = wm831x_power->wm831x;
0520 
0521     dev_dbg(wm831x->dev, "Power source changed\n");
0522 
0523     /* Just notify for everything - little harm in overnotifying. */
0524     if (wm831x_power->have_battery)
0525         power_supply_changed(wm831x_power->battery);
0526     power_supply_changed(wm831x_power->usb);
0527     power_supply_changed(wm831x_power->wall);
0528 
0529     return IRQ_HANDLED;
0530 }
0531 
0532 static int wm831x_power_probe(struct platform_device *pdev)
0533 {
0534     struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
0535     struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
0536     struct wm831x_power *power;
0537     int ret, irq, i;
0538 
0539     power = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_power),
0540                  GFP_KERNEL);
0541     if (power == NULL)
0542         return -ENOMEM;
0543 
0544     power->wm831x = wm831x;
0545     platform_set_drvdata(pdev, power);
0546 
0547     if (wm831x_pdata && wm831x_pdata->wm831x_num) {
0548         snprintf(power->wall_name, sizeof(power->wall_name),
0549              "wm831x-wall.%d", wm831x_pdata->wm831x_num);
0550         snprintf(power->battery_name, sizeof(power->wall_name),
0551              "wm831x-battery.%d", wm831x_pdata->wm831x_num);
0552         snprintf(power->usb_name, sizeof(power->wall_name),
0553              "wm831x-usb.%d", wm831x_pdata->wm831x_num);
0554     } else {
0555         snprintf(power->wall_name, sizeof(power->wall_name),
0556              "wm831x-wall");
0557         snprintf(power->battery_name, sizeof(power->wall_name),
0558              "wm831x-battery");
0559         snprintf(power->usb_name, sizeof(power->wall_name),
0560              "wm831x-usb");
0561     }
0562 
0563     /* We ignore configuration failures since we can still read back
0564      * the status without enabling the charger.
0565      */
0566     wm831x_config_battery(wm831x);
0567 
0568     power->wall_desc.name = power->wall_name;
0569     power->wall_desc.type = POWER_SUPPLY_TYPE_MAINS;
0570     power->wall_desc.properties = wm831x_wall_props;
0571     power->wall_desc.num_properties = ARRAY_SIZE(wm831x_wall_props);
0572     power->wall_desc.get_property = wm831x_wall_get_prop;
0573     power->wall = power_supply_register(&pdev->dev, &power->wall_desc,
0574                         NULL);
0575     if (IS_ERR(power->wall)) {
0576         ret = PTR_ERR(power->wall);
0577         goto err;
0578     }
0579 
0580     power->usb_desc.name = power->usb_name,
0581     power->usb_desc.type = POWER_SUPPLY_TYPE_USB;
0582     power->usb_desc.properties = wm831x_usb_props;
0583     power->usb_desc.num_properties = ARRAY_SIZE(wm831x_usb_props);
0584     power->usb_desc.get_property = wm831x_usb_get_prop;
0585     power->usb = power_supply_register(&pdev->dev, &power->usb_desc, NULL);
0586     if (IS_ERR(power->usb)) {
0587         ret = PTR_ERR(power->usb);
0588         goto err_wall;
0589     }
0590 
0591     ret = wm831x_reg_read(wm831x, WM831X_CHARGER_CONTROL_1);
0592     if (ret < 0)
0593         goto err_wall;
0594     power->have_battery = ret & WM831X_CHG_ENA;
0595 
0596     if (power->have_battery) {
0597         power->battery_desc.name = power->battery_name;
0598         power->battery_desc.properties = wm831x_bat_props;
0599         power->battery_desc.num_properties = ARRAY_SIZE(wm831x_bat_props);
0600         power->battery_desc.get_property = wm831x_bat_get_prop;
0601         power->battery_desc.use_for_apm = 1;
0602         power->battery = power_supply_register(&pdev->dev,
0603                                &power->battery_desc,
0604                                NULL);
0605         if (IS_ERR(power->battery)) {
0606             ret = PTR_ERR(power->battery);
0607             goto err_usb;
0608         }
0609     }
0610 
0611     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO"));
0612     ret = request_threaded_irq(irq, NULL, wm831x_syslo_irq,
0613                    IRQF_TRIGGER_RISING | IRQF_ONESHOT, "System power low",
0614                    power);
0615     if (ret != 0) {
0616         dev_err(&pdev->dev, "Failed to request SYSLO IRQ %d: %d\n",
0617             irq, ret);
0618         goto err_battery;
0619     }
0620 
0621     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "PWR SRC"));
0622     ret = request_threaded_irq(irq, NULL, wm831x_pwr_src_irq,
0623                    IRQF_TRIGGER_RISING | IRQF_ONESHOT, "Power source",
0624                    power);
0625     if (ret != 0) {
0626         dev_err(&pdev->dev, "Failed to request PWR SRC IRQ %d: %d\n",
0627             irq, ret);
0628         goto err_syslo;
0629     }
0630 
0631     for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
0632         irq = wm831x_irq(wm831x,
0633                  platform_get_irq_byname(pdev,
0634                              wm831x_bat_irqs[i]));
0635         ret = request_threaded_irq(irq, NULL, wm831x_bat_irq,
0636                        IRQF_TRIGGER_RISING | IRQF_ONESHOT,
0637                        wm831x_bat_irqs[i],
0638                        power);
0639         if (ret != 0) {
0640             dev_err(&pdev->dev,
0641                 "Failed to request %s IRQ %d: %d\n",
0642                 wm831x_bat_irqs[i], irq, ret);
0643             goto err_bat_irq;
0644         }
0645     }
0646 
0647     power->usb_phy = devm_usb_get_phy_by_phandle(&pdev->dev, "phys", 0);
0648     ret = PTR_ERR_OR_ZERO(power->usb_phy);
0649 
0650     switch (ret) {
0651     case 0:
0652         power->usb_notify.notifier_call = wm831x_usb_limit_change;
0653         ret = usb_register_notifier(power->usb_phy, &power->usb_notify);
0654         if (ret) {
0655             dev_err(&pdev->dev, "Failed to register notifier: %d\n",
0656                 ret);
0657             goto err_bat_irq;
0658         }
0659         break;
0660     case -EINVAL:
0661     case -ENODEV:
0662         /* ignore missing usb-phy, it's optional */
0663         power->usb_phy = NULL;
0664         ret = 0;
0665         break;
0666     default:
0667         dev_err(&pdev->dev, "Failed to find USB phy: %d\n", ret);
0668         fallthrough;
0669     case -EPROBE_DEFER:
0670         goto err_bat_irq;
0671     }
0672 
0673     return ret;
0674 
0675 err_bat_irq:
0676     --i;
0677     for (; i >= 0; i--) {
0678         irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
0679         free_irq(irq, power);
0680     }
0681     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "PWR SRC"));
0682     free_irq(irq, power);
0683 err_syslo:
0684     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO"));
0685     free_irq(irq, power);
0686 err_battery:
0687     if (power->have_battery)
0688         power_supply_unregister(power->battery);
0689 err_usb:
0690     power_supply_unregister(power->usb);
0691 err_wall:
0692     power_supply_unregister(power->wall);
0693 err:
0694     return ret;
0695 }
0696 
0697 static int wm831x_power_remove(struct platform_device *pdev)
0698 {
0699     struct wm831x_power *wm831x_power = platform_get_drvdata(pdev);
0700     struct wm831x *wm831x = wm831x_power->wm831x;
0701     int irq, i;
0702 
0703     if (wm831x_power->usb_phy) {
0704         usb_unregister_notifier(wm831x_power->usb_phy,
0705                     &wm831x_power->usb_notify);
0706     }
0707 
0708     for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
0709         irq = wm831x_irq(wm831x, 
0710                  platform_get_irq_byname(pdev,
0711                              wm831x_bat_irqs[i]));
0712         free_irq(irq, wm831x_power);
0713     }
0714 
0715     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "PWR SRC"));
0716     free_irq(irq, wm831x_power);
0717 
0718     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO"));
0719     free_irq(irq, wm831x_power);
0720 
0721     if (wm831x_power->have_battery)
0722         power_supply_unregister(wm831x_power->battery);
0723     power_supply_unregister(wm831x_power->wall);
0724     power_supply_unregister(wm831x_power->usb);
0725     return 0;
0726 }
0727 
0728 static struct platform_driver wm831x_power_driver = {
0729     .probe = wm831x_power_probe,
0730     .remove = wm831x_power_remove,
0731     .driver = {
0732         .name = "wm831x-power",
0733     },
0734 };
0735 
0736 module_platform_driver(wm831x_power_driver);
0737 
0738 MODULE_DESCRIPTION("Power supply driver for WM831x PMICs");
0739 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
0740 MODULE_LICENSE("GPL");
0741 MODULE_ALIAS("platform:wm831x-power");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!