Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Battery driver for Maxim MAX8925 |
| 3 | * |
| 4 | * Copyright (c) 2009-2010 Marvell International Ltd. |
| 5 | * Haojian Zhuang <haojian.zhuang@marvell.com> |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License version 2 as |
| 9 | * published by the Free Software Foundation. |
| 10 | */ |
| 11 | |
| 12 | #include <linux/module.h> |
| 13 | #include <linux/err.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 14 | #include <linux/slab.h> |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 15 | #include <linux/i2c.h> |
| 16 | #include <linux/interrupt.h> |
| 17 | #include <linux/platform_device.h> |
| 18 | #include <linux/power_supply.h> |
| 19 | #include <linux/mfd/max8925.h> |
| 20 | |
| 21 | /* registers in GPM */ |
| 22 | #define MAX8925_OUT5VEN 0x54 |
| 23 | #define MAX8925_OUT3VEN 0x58 |
| 24 | #define MAX8925_CHG_CNTL1 0x7c |
| 25 | |
| 26 | /* bits definition */ |
| 27 | #define MAX8925_CHG_STAT_VSYSLOW (1 << 0) |
| 28 | #define MAX8925_CHG_STAT_MODE_MASK (3 << 2) |
| 29 | #define MAX8925_CHG_STAT_EN_MASK (1 << 4) |
| 30 | #define MAX8925_CHG_MBDET (1 << 1) |
| 31 | #define MAX8925_CHG_AC_RANGE_MASK (3 << 6) |
| 32 | |
| 33 | /* registers in ADC */ |
| 34 | #define MAX8925_ADC_RES_CNFG1 0x06 |
| 35 | #define MAX8925_ADC_AVG_CNFG1 0x07 |
| 36 | #define MAX8925_ADC_ACQ_CNFG1 0x08 |
| 37 | #define MAX8925_ADC_ACQ_CNFG2 0x09 |
| 38 | /* 2 bytes registers in below. MSB is 1st, LSB is 2nd. */ |
| 39 | #define MAX8925_ADC_AUX2 0x62 |
| 40 | #define MAX8925_ADC_VCHG 0x64 |
| 41 | #define MAX8925_ADC_VBBATT 0x66 |
| 42 | #define MAX8925_ADC_VMBATT 0x68 |
| 43 | #define MAX8925_ADC_ISNS 0x6a |
| 44 | #define MAX8925_ADC_THM 0x6c |
| 45 | #define MAX8925_ADC_TDIE 0x6e |
| 46 | #define MAX8925_CMD_AUX2 0xc8 |
| 47 | #define MAX8925_CMD_VCHG 0xd0 |
| 48 | #define MAX8925_CMD_VBBATT 0xd8 |
| 49 | #define MAX8925_CMD_VMBATT 0xe0 |
| 50 | #define MAX8925_CMD_ISNS 0xe8 |
| 51 | #define MAX8925_CMD_THM 0xf0 |
| 52 | #define MAX8925_CMD_TDIE 0xf8 |
| 53 | |
| 54 | enum { |
| 55 | MEASURE_AUX2, |
| 56 | MEASURE_VCHG, |
| 57 | MEASURE_VBBATT, |
| 58 | MEASURE_VMBATT, |
| 59 | MEASURE_ISNS, |
| 60 | MEASURE_THM, |
| 61 | MEASURE_TDIE, |
| 62 | MEASURE_MAX, |
| 63 | }; |
| 64 | |
| 65 | struct max8925_power_info { |
| 66 | struct max8925_chip *chip; |
| 67 | struct i2c_client *gpm; |
| 68 | struct i2c_client *adc; |
| 69 | |
| 70 | struct power_supply ac; |
| 71 | struct power_supply usb; |
| 72 | struct power_supply battery; |
| 73 | int irq_base; |
| 74 | unsigned ac_online:1; |
| 75 | unsigned usb_online:1; |
| 76 | unsigned bat_online:1; |
| 77 | unsigned chg_mode:2; |
| 78 | unsigned batt_detect:1; /* detecing MB by ID pin */ |
| 79 | unsigned topoff_threshold:2; |
| 80 | unsigned fast_charge:3; |
Philip Rakity | 92de378 | 2011-11-25 23:19:37 +0400 | [diff] [blame] | 81 | unsigned no_temp_support:1; |
Philip Rakity | 5ba1fa0 | 2011-11-25 23:24:03 +0400 | [diff] [blame] | 82 | unsigned no_insert_detect:1; |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 83 | |
| 84 | int (*set_charger) (int); |
| 85 | }; |
| 86 | |
| 87 | static int __set_charger(struct max8925_power_info *info, int enable) |
| 88 | { |
| 89 | struct max8925_chip *chip = info->chip; |
| 90 | if (enable) { |
| 91 | /* enable charger in platform */ |
| 92 | if (info->set_charger) |
| 93 | info->set_charger(1); |
| 94 | /* enable charger */ |
| 95 | max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 0); |
| 96 | } else { |
| 97 | /* disable charge */ |
| 98 | max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7); |
| 99 | if (info->set_charger) |
| 100 | info->set_charger(0); |
| 101 | } |
| 102 | dev_dbg(chip->dev, "%s\n", (enable) ? "Enable charger" |
| 103 | : "Disable charger"); |
| 104 | return 0; |
| 105 | } |
| 106 | |
| 107 | static irqreturn_t max8925_charger_handler(int irq, void *data) |
| 108 | { |
| 109 | struct max8925_power_info *info = (struct max8925_power_info *)data; |
| 110 | struct max8925_chip *chip = info->chip; |
| 111 | |
| 112 | switch (irq - chip->irq_base) { |
| 113 | case MAX8925_IRQ_VCHG_DC_R: |
| 114 | info->ac_online = 1; |
| 115 | __set_charger(info, 1); |
| 116 | dev_dbg(chip->dev, "Adapter inserted\n"); |
| 117 | break; |
| 118 | case MAX8925_IRQ_VCHG_DC_F: |
| 119 | info->ac_online = 0; |
| 120 | __set_charger(info, 0); |
Philip Rakity | 92de378 | 2011-11-25 23:19:37 +0400 | [diff] [blame] | 121 | dev_dbg(chip->dev, "Adapter removed\n"); |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 122 | break; |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 123 | case MAX8925_IRQ_VCHG_THM_OK_F: |
| 124 | /* Battery is not ready yet */ |
| 125 | dev_dbg(chip->dev, "Battery temperature is out of range\n"); |
| 126 | case MAX8925_IRQ_VCHG_DC_OVP: |
| 127 | dev_dbg(chip->dev, "Error detection\n"); |
| 128 | __set_charger(info, 0); |
| 129 | break; |
| 130 | case MAX8925_IRQ_VCHG_THM_OK_R: |
| 131 | /* Battery is ready now */ |
| 132 | dev_dbg(chip->dev, "Battery temperature is in range\n"); |
| 133 | break; |
| 134 | case MAX8925_IRQ_VCHG_SYSLOW_R: |
| 135 | /* VSYS is low */ |
| 136 | dev_info(chip->dev, "Sys power is too low\n"); |
| 137 | break; |
| 138 | case MAX8925_IRQ_VCHG_SYSLOW_F: |
| 139 | dev_dbg(chip->dev, "Sys power is above low threshold\n"); |
| 140 | break; |
| 141 | case MAX8925_IRQ_VCHG_DONE: |
| 142 | __set_charger(info, 0); |
| 143 | dev_dbg(chip->dev, "Charging is done\n"); |
| 144 | break; |
| 145 | case MAX8925_IRQ_VCHG_TOPOFF: |
| 146 | dev_dbg(chip->dev, "Charging in top-off mode\n"); |
| 147 | break; |
| 148 | case MAX8925_IRQ_VCHG_TMR_FAULT: |
| 149 | __set_charger(info, 0); |
| 150 | dev_dbg(chip->dev, "Safe timer is expired\n"); |
| 151 | break; |
| 152 | case MAX8925_IRQ_VCHG_RST: |
| 153 | __set_charger(info, 0); |
| 154 | dev_dbg(chip->dev, "Charger is reset\n"); |
| 155 | break; |
| 156 | } |
| 157 | return IRQ_HANDLED; |
| 158 | } |
| 159 | |
| 160 | static int start_measure(struct max8925_power_info *info, int type) |
| 161 | { |
| 162 | unsigned char buf[2] = {0, 0}; |
| 163 | int meas_reg = 0, ret; |
| 164 | |
| 165 | switch (type) { |
| 166 | case MEASURE_VCHG: |
| 167 | meas_reg = MAX8925_ADC_VCHG; |
| 168 | break; |
| 169 | case MEASURE_VBBATT: |
| 170 | meas_reg = MAX8925_ADC_VBBATT; |
| 171 | break; |
| 172 | case MEASURE_VMBATT: |
| 173 | meas_reg = MAX8925_ADC_VMBATT; |
| 174 | break; |
| 175 | case MEASURE_ISNS: |
| 176 | meas_reg = MAX8925_ADC_ISNS; |
| 177 | break; |
| 178 | default: |
| 179 | return -EINVAL; |
| 180 | } |
| 181 | |
| 182 | max8925_bulk_read(info->adc, meas_reg, 2, buf); |
Philip Rakity | 9c9cf9e | 2011-11-25 21:25:23 +0400 | [diff] [blame] | 183 | ret = ((buf[0]<<8) | buf[1]) >> 4; |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 184 | |
| 185 | return ret; |
| 186 | } |
| 187 | |
| 188 | static int max8925_ac_get_prop(struct power_supply *psy, |
| 189 | enum power_supply_property psp, |
| 190 | union power_supply_propval *val) |
| 191 | { |
| 192 | struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent); |
| 193 | int ret = 0; |
| 194 | |
| 195 | switch (psp) { |
| 196 | case POWER_SUPPLY_PROP_ONLINE: |
| 197 | val->intval = info->ac_online; |
| 198 | break; |
| 199 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
| 200 | if (info->ac_online) { |
| 201 | ret = start_measure(info, MEASURE_VCHG); |
| 202 | if (ret >= 0) { |
Philip Rakity | 9c9cf9e | 2011-11-25 21:25:23 +0400 | [diff] [blame] | 203 | val->intval = ret * 2000; /* unit is uV */ |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 204 | goto out; |
| 205 | } |
| 206 | } |
| 207 | ret = -ENODATA; |
| 208 | break; |
| 209 | default: |
| 210 | ret = -ENODEV; |
| 211 | break; |
| 212 | } |
| 213 | out: |
| 214 | return ret; |
| 215 | } |
| 216 | |
| 217 | static enum power_supply_property max8925_ac_props[] = { |
| 218 | POWER_SUPPLY_PROP_ONLINE, |
| 219 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
| 220 | }; |
| 221 | |
| 222 | static int max8925_usb_get_prop(struct power_supply *psy, |
| 223 | enum power_supply_property psp, |
| 224 | union power_supply_propval *val) |
| 225 | { |
| 226 | struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent); |
| 227 | int ret = 0; |
| 228 | |
| 229 | switch (psp) { |
| 230 | case POWER_SUPPLY_PROP_ONLINE: |
| 231 | val->intval = info->usb_online; |
| 232 | break; |
| 233 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
| 234 | if (info->usb_online) { |
| 235 | ret = start_measure(info, MEASURE_VCHG); |
| 236 | if (ret >= 0) { |
Philip Rakity | 9c9cf9e | 2011-11-25 21:25:23 +0400 | [diff] [blame] | 237 | val->intval = ret * 2000; /* unit is uV */ |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 238 | goto out; |
| 239 | } |
| 240 | } |
| 241 | ret = -ENODATA; |
| 242 | break; |
| 243 | default: |
| 244 | ret = -ENODEV; |
| 245 | break; |
| 246 | } |
| 247 | out: |
| 248 | return ret; |
| 249 | } |
| 250 | |
| 251 | static enum power_supply_property max8925_usb_props[] = { |
| 252 | POWER_SUPPLY_PROP_ONLINE, |
| 253 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
| 254 | }; |
| 255 | |
| 256 | static int max8925_bat_get_prop(struct power_supply *psy, |
| 257 | enum power_supply_property psp, |
| 258 | union power_supply_propval *val) |
| 259 | { |
| 260 | struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent); |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 261 | int ret = 0; |
| 262 | |
| 263 | switch (psp) { |
| 264 | case POWER_SUPPLY_PROP_ONLINE: |
| 265 | val->intval = info->bat_online; |
| 266 | break; |
| 267 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
| 268 | if (info->bat_online) { |
| 269 | ret = start_measure(info, MEASURE_VMBATT); |
| 270 | if (ret >= 0) { |
Philip Rakity | 9c9cf9e | 2011-11-25 21:25:23 +0400 | [diff] [blame] | 271 | val->intval = ret * 2000; /* unit is uV */ |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 272 | ret = 0; |
| 273 | break; |
| 274 | } |
| 275 | } |
| 276 | ret = -ENODATA; |
| 277 | break; |
| 278 | case POWER_SUPPLY_PROP_CURRENT_NOW: |
| 279 | if (info->bat_online) { |
| 280 | ret = start_measure(info, MEASURE_ISNS); |
| 281 | if (ret >= 0) { |
Philip Rakity | 9c9cf9e | 2011-11-25 21:25:23 +0400 | [diff] [blame] | 282 | /* assume r_sns is 0.02 */ |
| 283 | ret = ((ret * 6250) - 3125) /* uA */; |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 284 | val->intval = 0; |
| 285 | if (ret > 0) |
| 286 | val->intval = ret; /* unit is mA */ |
| 287 | ret = 0; |
| 288 | break; |
| 289 | } |
| 290 | } |
| 291 | ret = -ENODATA; |
| 292 | break; |
| 293 | case POWER_SUPPLY_PROP_CHARGE_TYPE: |
| 294 | if (!info->bat_online) { |
| 295 | ret = -ENODATA; |
| 296 | break; |
| 297 | } |
| 298 | ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS); |
| 299 | ret = (ret & MAX8925_CHG_STAT_MODE_MASK) >> 2; |
| 300 | switch (ret) { |
| 301 | case 1: |
| 302 | val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; |
| 303 | break; |
| 304 | case 0: |
| 305 | case 2: |
| 306 | val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; |
| 307 | break; |
| 308 | case 3: |
| 309 | val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; |
| 310 | break; |
| 311 | } |
| 312 | ret = 0; |
| 313 | break; |
| 314 | case POWER_SUPPLY_PROP_STATUS: |
| 315 | if (!info->bat_online) { |
| 316 | ret = -ENODATA; |
| 317 | break; |
| 318 | } |
| 319 | ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS); |
| 320 | if (info->usb_online || info->ac_online) { |
| 321 | val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; |
| 322 | if (ret & MAX8925_CHG_STAT_EN_MASK) |
| 323 | val->intval = POWER_SUPPLY_STATUS_CHARGING; |
| 324 | } else |
| 325 | val->intval = POWER_SUPPLY_STATUS_DISCHARGING; |
| 326 | ret = 0; |
| 327 | break; |
| 328 | default: |
| 329 | ret = -ENODEV; |
| 330 | break; |
| 331 | } |
| 332 | return ret; |
| 333 | } |
| 334 | |
| 335 | static enum power_supply_property max8925_battery_props[] = { |
| 336 | POWER_SUPPLY_PROP_ONLINE, |
| 337 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
| 338 | POWER_SUPPLY_PROP_CURRENT_NOW, |
| 339 | POWER_SUPPLY_PROP_CHARGE_TYPE, |
| 340 | POWER_SUPPLY_PROP_STATUS, |
| 341 | }; |
| 342 | |
| 343 | #define REQUEST_IRQ(_irq, _name) \ |
| 344 | do { \ |
| 345 | ret = request_threaded_irq(chip->irq_base + _irq, NULL, \ |
| 346 | max8925_charger_handler, \ |
| 347 | IRQF_ONESHOT, _name, info); \ |
| 348 | if (ret) \ |
| 349 | dev_err(chip->dev, "Failed to request IRQ #%d: %d\n", \ |
| 350 | _irq, ret); \ |
| 351 | } while (0) |
| 352 | |
| 353 | static __devinit int max8925_init_charger(struct max8925_chip *chip, |
| 354 | struct max8925_power_info *info) |
| 355 | { |
| 356 | int ret; |
| 357 | |
| 358 | REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_OVP, "ac-ovp"); |
Philip Rakity | 5ba1fa0 | 2011-11-25 23:24:03 +0400 | [diff] [blame] | 359 | if (!info->no_insert_detect) { |
| 360 | REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_F, "ac-remove"); |
| 361 | REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_R, "ac-insert"); |
| 362 | } |
Philip Rakity | 92de378 | 2011-11-25 23:19:37 +0400 | [diff] [blame] | 363 | if (!info->no_temp_support) { |
| 364 | REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_R, "batt-temp-in-range"); |
| 365 | REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_F, "batt-temp-out-range"); |
| 366 | } |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 367 | REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_F, "vsys-high"); |
| 368 | REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_R, "vsys-low"); |
| 369 | REQUEST_IRQ(MAX8925_IRQ_VCHG_RST, "charger-reset"); |
| 370 | REQUEST_IRQ(MAX8925_IRQ_VCHG_DONE, "charger-done"); |
| 371 | REQUEST_IRQ(MAX8925_IRQ_VCHG_TOPOFF, "charger-topoff"); |
| 372 | REQUEST_IRQ(MAX8925_IRQ_VCHG_TMR_FAULT, "charger-timer-expire"); |
| 373 | |
| 374 | info->ac_online = 0; |
| 375 | info->usb_online = 0; |
| 376 | info->bat_online = 0; |
| 377 | ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS); |
| 378 | if (ret >= 0) { |
| 379 | /* |
| 380 | * If battery detection is enabled, ID pin of battery is |
| 381 | * connected to MBDET pin of MAX8925. It could be used to |
| 382 | * detect battery presence. |
| 383 | * Otherwise, we have to assume that battery is always on. |
| 384 | */ |
| 385 | if (info->batt_detect) |
| 386 | info->bat_online = (ret & MAX8925_CHG_MBDET) ? 0 : 1; |
| 387 | else |
| 388 | info->bat_online = 1; |
| 389 | if (ret & MAX8925_CHG_AC_RANGE_MASK) |
| 390 | info->ac_online = 1; |
| 391 | else |
| 392 | info->ac_online = 0; |
| 393 | } |
| 394 | /* disable charge */ |
| 395 | max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7); |
| 396 | /* set charging current in charge topoff mode */ |
| 397 | max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 3 << 5, |
| 398 | info->topoff_threshold << 5); |
| 399 | /* set charing current in fast charge mode */ |
| 400 | max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 7, info->fast_charge); |
| 401 | |
| 402 | return 0; |
| 403 | } |
| 404 | |
| 405 | static __devexit int max8925_deinit_charger(struct max8925_power_info *info) |
| 406 | { |
| 407 | struct max8925_chip *chip = info->chip; |
| 408 | int irq; |
| 409 | |
| 410 | irq = chip->irq_base + MAX8925_IRQ_VCHG_DC_OVP; |
| 411 | for (; irq <= chip->irq_base + MAX8925_IRQ_VCHG_TMR_FAULT; irq++) |
| 412 | free_irq(irq, info); |
| 413 | |
| 414 | return 0; |
| 415 | } |
| 416 | |
| 417 | static __devinit int max8925_power_probe(struct platform_device *pdev) |
| 418 | { |
| 419 | struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent); |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 420 | struct max8925_power_pdata *pdata = NULL; |
| 421 | struct max8925_power_info *info; |
| 422 | int ret; |
| 423 | |
Haojian Zhuang | 2402ca5 | 2011-04-18 22:04:08 +0800 | [diff] [blame] | 424 | pdata = pdev->dev.platform_data; |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 425 | if (!pdata) { |
| 426 | dev_err(&pdev->dev, "platform data isn't assigned to " |
| 427 | "power supply\n"); |
| 428 | return -EINVAL; |
| 429 | } |
| 430 | |
| 431 | info = kzalloc(sizeof(struct max8925_power_info), GFP_KERNEL); |
| 432 | if (!info) |
| 433 | return -ENOMEM; |
| 434 | info->chip = chip; |
| 435 | info->gpm = chip->i2c; |
| 436 | info->adc = chip->adc; |
Haojian Zhuang | 2402ca5 | 2011-04-18 22:04:08 +0800 | [diff] [blame] | 437 | platform_set_drvdata(pdev, info); |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 438 | |
| 439 | info->ac.name = "max8925-ac"; |
| 440 | info->ac.type = POWER_SUPPLY_TYPE_MAINS; |
| 441 | info->ac.properties = max8925_ac_props; |
| 442 | info->ac.num_properties = ARRAY_SIZE(max8925_ac_props); |
| 443 | info->ac.get_property = max8925_ac_get_prop; |
Philip Rakity | e7a5f6d | 2011-08-29 09:32:04 -0700 | [diff] [blame^] | 444 | info->ac.supplied_to = pdata->supplied_to; |
| 445 | info->ac.num_supplicants = pdata->num_supplicants; |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 446 | ret = power_supply_register(&pdev->dev, &info->ac); |
| 447 | if (ret) |
| 448 | goto out; |
| 449 | info->ac.dev->parent = &pdev->dev; |
| 450 | |
| 451 | info->usb.name = "max8925-usb"; |
| 452 | info->usb.type = POWER_SUPPLY_TYPE_USB; |
| 453 | info->usb.properties = max8925_usb_props; |
| 454 | info->usb.num_properties = ARRAY_SIZE(max8925_usb_props); |
| 455 | info->usb.get_property = max8925_usb_get_prop; |
Philip Rakity | e7a5f6d | 2011-08-29 09:32:04 -0700 | [diff] [blame^] | 456 | info->usb.supplied_to = pdata->supplied_to; |
| 457 | info->usb.num_supplicants = pdata->num_supplicants; |
| 458 | |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 459 | ret = power_supply_register(&pdev->dev, &info->usb); |
| 460 | if (ret) |
| 461 | goto out_usb; |
| 462 | info->usb.dev->parent = &pdev->dev; |
| 463 | |
| 464 | info->battery.name = "max8925-battery"; |
| 465 | info->battery.type = POWER_SUPPLY_TYPE_BATTERY; |
| 466 | info->battery.properties = max8925_battery_props; |
| 467 | info->battery.num_properties = ARRAY_SIZE(max8925_battery_props); |
| 468 | info->battery.get_property = max8925_bat_get_prop; |
| 469 | ret = power_supply_register(&pdev->dev, &info->battery); |
| 470 | if (ret) |
| 471 | goto out_battery; |
| 472 | info->battery.dev->parent = &pdev->dev; |
| 473 | |
| 474 | info->batt_detect = pdata->batt_detect; |
| 475 | info->topoff_threshold = pdata->topoff_threshold; |
| 476 | info->fast_charge = pdata->fast_charge; |
| 477 | info->set_charger = pdata->set_charger; |
Philip Rakity | 92de378 | 2011-11-25 23:19:37 +0400 | [diff] [blame] | 478 | info->no_temp_support = pdata->no_temp_support; |
Philip Rakity | 5ba1fa0 | 2011-11-25 23:24:03 +0400 | [diff] [blame] | 479 | info->no_insert_detect = pdata->no_insert_detect; |
Haojian Zhuang | 28db388 | 2010-01-25 10:38:35 -0500 | [diff] [blame] | 480 | |
| 481 | max8925_init_charger(chip, info); |
| 482 | return 0; |
| 483 | out_battery: |
| 484 | power_supply_unregister(&info->battery); |
| 485 | out_usb: |
| 486 | power_supply_unregister(&info->ac); |
| 487 | out: |
| 488 | kfree(info); |
| 489 | return ret; |
| 490 | } |
| 491 | |
| 492 | static __devexit int max8925_power_remove(struct platform_device *pdev) |
| 493 | { |
| 494 | struct max8925_power_info *info = platform_get_drvdata(pdev); |
| 495 | |
| 496 | if (info) { |
| 497 | power_supply_unregister(&info->ac); |
| 498 | power_supply_unregister(&info->usb); |
| 499 | power_supply_unregister(&info->battery); |
| 500 | max8925_deinit_charger(info); |
| 501 | kfree(info); |
| 502 | } |
| 503 | return 0; |
| 504 | } |
| 505 | |
| 506 | static struct platform_driver max8925_power_driver = { |
| 507 | .probe = max8925_power_probe, |
| 508 | .remove = __devexit_p(max8925_power_remove), |
| 509 | .driver = { |
| 510 | .name = "max8925-power", |
| 511 | }, |
| 512 | }; |
| 513 | |
| 514 | static int __init max8925_power_init(void) |
| 515 | { |
| 516 | return platform_driver_register(&max8925_power_driver); |
| 517 | } |
| 518 | module_init(max8925_power_init); |
| 519 | |
| 520 | static void __exit max8925_power_exit(void) |
| 521 | { |
| 522 | platform_driver_unregister(&max8925_power_driver); |
| 523 | } |
| 524 | module_exit(max8925_power_exit); |
| 525 | |
| 526 | MODULE_LICENSE("GPL"); |
| 527 | MODULE_DESCRIPTION("Power supply driver for MAX8925"); |
| 528 | MODULE_ALIAS("platform:max8925-power"); |