Merge tag 'for-v4.14' of git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power-supply

+51

Documentation/devicetree/bindings/power/supply/bq24190.txt

··· 1 + TI BQ24190 Li-Ion Battery Charger 2 + 3 + Required properties: 4 + - compatible: contains one of the following: 5 + * "ti,bq24190" 6 + * "ti,bq24192i" 7 + - reg: integer, I2C address of the charger. 8 + - interrupts[-extended]: configuration for charger INT pin. 9 + 10 + Optional properties: 11 + - monitored-battery: phandle of battery characteristics devicetree node 12 + The charger uses the following battery properties: 13 + + precharge-current-microamp: maximum charge current during precharge 14 + phase (typically 20% of battery capacity). 15 + + charge-term-current-microamp: a charge cycle terminates when the 16 + battery voltage is above recharge threshold, and the current is below 17 + this setting (typically 10% of battery capacity). 18 + See also Documentation/devicetree/bindings/power/supply/battery.txt 19 + - ti,system-minimum-microvolt: when power is connected and the battery is below 20 + minimum system voltage, the system will be regulated above this setting. 21 + 22 + Notes: 23 + - Some circuit boards wire the chip's "OTG" pin high (enabling 500mA default 24 + charge current on USB SDP ports, among other features). To simulate this on 25 + boards that wire the pin to a GPIO, set a gpio-hog. 26 + 27 + Example: 28 + 29 + bat: battery { 30 + compatible = "simple-battery"; 31 + precharge-current-microamp = <256000>; 32 + charge-term-current-microamp = <128000>; 33 + // etc. 34 + }; 35 + 36 + bq24190: charger@6a { 37 + compatible = "ti,bq24190"; 38 + reg = <0x6a>; 39 + interrupts-extended = <&gpiochip 10 IRQ_TYPE_EDGE_FALLING>; 40 + monitored-battery = <&bat>; 41 + ti,system-minimum-microvolt = <3200000>; 42 + }; 43 + 44 + &twl_gpio { 45 + otg { 46 + gpio-hog; 47 + gpios = <6 0>; 48 + output-high; 49 + line-name = "otg-gpio"; 50 + }; 51 + };

+8 -7

Documentation/devicetree/bindings/power/supply/ltc2941.txt

··· 1 - binding for LTC2941 and LTC2943 battery gauges 1 + binding for LTC2941, LTC2942, LTC2943 and LTC2944 battery gauges 2 2 3 - Both the LTC2941 and LTC2943 measure battery capacity. 4 - The LTC2943 is compatible with the LTC2941, it adds voltage and 5 - temperature monitoring, and uses a slightly different conversion 6 - formula for the charge counter. 3 + All chips measure battery capacity. 4 + The LTC2942 is pin compatible with the LTC2941, it adds voltage and 5 + temperature monitoring, and is runtime detected. LTC2943 and LTC2944 6 + is software compatible, uses a slightly different conversion formula 7 + for the charge counter and adds voltage, current and temperature monitoring. 7 8 8 9 Required properties: 9 - - compatible: Should contain "lltc,ltc2941" or "lltc,ltc2943" which also 10 - indicates the type of I2C chip attached. 10 + - compatible: Should contain "lltc,ltc2941", "lltc,ltc2942", "lltc,ltc2943" 11 + or "lltc,ltc2944" which also indicates the type of I2C chip attached. 11 12 - reg: The 7-bit I2C address. 12 13 - lltc,resistor-sense: The sense resistor value in milli-ohms. Can be a 32-bit 13 14 negative value when the battery has been connected to the wrong end of the

+2 -2

drivers/power/reset/at91-sama5d2_shdwc.c

··· 171 171 172 172 for_each_child_of_node(np, cnp) { 173 173 if (of_property_read_u32(cnp, "reg", &wk_input)) { 174 - dev_warn(&pdev->dev, "reg property is missing for %s\n", 175 - cnp->full_name); 174 + dev_warn(&pdev->dev, "reg property is missing for %pOF\n", 175 + cnp); 176 176 continue; 177 177 } 178 178

+23

drivers/power/supply/Kconfig

··· 198 198 Say Y here to enable support for batteries with BQ27xxx chips 199 199 connected over an I2C bus. 200 200 201 + config BATTERY_BQ27XXX_HDQ 202 + tristate "BQ27xxx HDQ support" 203 + depends on BATTERY_BQ27XXX 204 + depends on W1 205 + default y 206 + help 207 + Say Y here to enable support for batteries with BQ27xxx chips 208 + connected over an HDQ bus. 209 + 201 210 config BATTERY_BQ27XXX_DT_UPDATES_NVM 202 211 bool "BQ27xxx support for update of NVM/flash data memory" 203 212 depends on BATTERY_BQ27XXX_I2C ··· 322 313 with MAX17042. This driver also supports max17047/50 chips which are 323 314 improved version of max17042. 324 315 316 + config BATTERY_MAX1721X 317 + tristate "MAX17211/MAX17215 standalone gas-gauge" 318 + depends on W1 319 + select REGMAP_W1 320 + help 321 + MAX1721x is fuel-gauge systems for lithium-ion (Li+) batteries 322 + in handheld and portable equipment. MAX17211 used with single cell 323 + battery. MAX17215 designed for muticell battery. Both them have 324 + OneWire (W1) host interface. 325 + 326 + Say Y here to enable support for the MAX17211/MAX17215 standalone 327 + battery gas-gauge. 328 + 325 329 config BATTERY_Z2 326 330 tristate "Z2 battery driver" 327 331 depends on I2C && MACH_ZIPIT2 ··· 387 365 config CHARGER_CPCAP 388 366 tristate "CPCAP PMIC Charger Driver" 389 367 depends on MFD_CPCAP && IIO 368 + depends on OMAP_USB2 || (!OMAP_USB2 && COMPILE_TEST) 390 369 default MFD_CPCAP 391 370 help 392 371 Say Y to enable support for CPCAP PMIC charger driver for Motorola

+2

drivers/power/supply/Makefile

··· 38 38 obj-$(CONFIG_CHARGER_SBS) += sbs-charger.o 39 39 obj-$(CONFIG_BATTERY_BQ27XXX) += bq27xxx_battery.o 40 40 obj-$(CONFIG_BATTERY_BQ27XXX_I2C) += bq27xxx_battery_i2c.o 41 + obj-$(CONFIG_BATTERY_BQ27XXX_HDQ) += bq27xxx_battery_hdq.o 41 42 obj-$(CONFIG_BATTERY_DA9030) += da9030_battery.o 42 43 obj-$(CONFIG_BATTERY_DA9052) += da9052-battery.o 43 44 obj-$(CONFIG_CHARGER_DA9150) += da9150-charger.o 44 45 obj-$(CONFIG_BATTERY_DA9150) += da9150-fg.o 45 46 obj-$(CONFIG_BATTERY_MAX17040) += max17040_battery.o 46 47 obj-$(CONFIG_BATTERY_MAX17042) += max17042_battery.o 48 + obj-$(CONFIG_BATTERY_MAX1721X) += max1721x_battery.o 47 49 obj-$(CONFIG_BATTERY_Z2) += z2_battery.o 48 50 obj-$(CONFIG_BATTERY_RT5033) += rt5033_battery.o 49 51 obj-$(CONFIG_CHARGER_RT9455) += rt9455_charger.o

+2 -2

drivers/power/supply/act8945a_charger.c

··· 596 596 return ret; 597 597 598 598 irq = of_irq_get(pdev->dev.of_node, 0); 599 - if (irq == -EPROBE_DEFER) { 599 + if (irq <= 0) { 600 600 dev_err(&pdev->dev, "failed to find IRQ number\n"); 601 - return -EPROBE_DEFER; 601 + return irq ?: -ENXIO; 602 602 } 603 603 604 604 ret = devm_request_irq(&pdev->dev, irq, act8945a_status_changed,

+326 -20

drivers/power/supply/bq24190_charger.c

··· 16 16 #include <linux/of_device.h> 17 17 #include <linux/pm_runtime.h> 18 18 #include <linux/power_supply.h> 19 + #include <linux/power/bq24190_charger.h> 20 + #include <linux/regulator/driver.h> 21 + #include <linux/regulator/machine.h> 19 22 #include <linux/workqueue.h> 20 23 #include <linux/gpio.h> 21 24 #include <linux/i2c.h> ··· 46 43 #define BQ24190_REG_POC_CHG_CONFIG_OTG 0x2 47 44 #define BQ24190_REG_POC_SYS_MIN_MASK (BIT(3) | BIT(2) | BIT(1)) 48 45 #define BQ24190_REG_POC_SYS_MIN_SHIFT 1 46 + #define BQ24190_REG_POC_SYS_MIN_MIN 3000 47 + #define BQ24190_REG_POC_SYS_MIN_MAX 3700 49 48 #define BQ24190_REG_POC_BOOST_LIM_MASK BIT(0) 50 49 #define BQ24190_REG_POC_BOOST_LIM_SHIFT 0 51 50 ··· 62 57 #define BQ24190_REG_PCTCC_IPRECHG_MASK (BIT(7) | BIT(6) | BIT(5) | \ 63 58 BIT(4)) 64 59 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT 4 60 + #define BQ24190_REG_PCTCC_IPRECHG_MIN 128 61 + #define BQ24190_REG_PCTCC_IPRECHG_MAX 2048 65 62 #define BQ24190_REG_PCTCC_ITERM_MASK (BIT(3) | BIT(2) | BIT(1) | \ 66 63 BIT(0)) 67 64 #define BQ24190_REG_PCTCC_ITERM_SHIFT 0 65 + #define BQ24190_REG_PCTCC_ITERM_MIN 128 66 + #define BQ24190_REG_PCTCC_ITERM_MAX 2048 68 67 69 68 #define BQ24190_REG_CVC 0x04 /* Charge Voltage Control */ 70 69 #define BQ24190_REG_CVC_VREG_MASK (BIT(7) | BIT(6) | BIT(5) | \ ··· 165 156 struct extcon_dev *extcon; 166 157 struct notifier_block extcon_nb; 167 158 struct delayed_work extcon_work; 159 + struct delayed_work input_current_limit_work; 168 160 char model_name[I2C_NAME_SIZE]; 169 161 bool initialized; 170 162 bool irq_event; 163 + u16 sys_min; 164 + u16 iprechg; 165 + u16 iterm; 171 166 struct mutex f_reg_lock; 172 167 u8 f_reg; 173 168 u8 ss_reg; ··· 517 504 static inline void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi) {} 518 505 #endif 519 506 520 - /* 521 - * According to the "Host Mode and default Mode" section of the 522 - * manual, a write to any register causes the bq24190 to switch 523 - * from default mode to host mode. It will switch back to default 524 - * mode after a WDT timeout unless the WDT is turned off as well. 525 - * So, by simply turning off the WDT, we accomplish both with the 526 - * same write. 527 - */ 528 - static int bq24190_set_mode_host(struct bq24190_dev_info *bdi) 507 + #ifdef CONFIG_REGULATOR 508 + static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val) 509 + { 510 + struct bq24190_dev_info *bdi = rdev_get_drvdata(dev); 511 + int ret; 512 + 513 + ret = pm_runtime_get_sync(bdi->dev); 514 + if (ret < 0) { 515 + dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret); 516 + pm_runtime_put_noidle(bdi->dev); 517 + return ret; 518 + } 519 + 520 + ret = bq24190_write_mask(bdi, BQ24190_REG_POC, 521 + BQ24190_REG_POC_CHG_CONFIG_MASK, 522 + BQ24190_REG_POC_CHG_CONFIG_SHIFT, val); 523 + 524 + pm_runtime_mark_last_busy(bdi->dev); 525 + pm_runtime_put_autosuspend(bdi->dev); 526 + 527 + return ret; 528 + } 529 + 530 + static int bq24190_vbus_enable(struct regulator_dev *dev) 531 + { 532 + return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG); 533 + } 534 + 535 + static int bq24190_vbus_disable(struct regulator_dev *dev) 536 + { 537 + return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE); 538 + } 539 + 540 + static int bq24190_vbus_is_enabled(struct regulator_dev *dev) 541 + { 542 + struct bq24190_dev_info *bdi = rdev_get_drvdata(dev); 543 + int ret; 544 + u8 val; 545 + 546 + ret = pm_runtime_get_sync(bdi->dev); 547 + if (ret < 0) { 548 + dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret); 549 + pm_runtime_put_noidle(bdi->dev); 550 + return ret; 551 + } 552 + 553 + ret = bq24190_read_mask(bdi, BQ24190_REG_POC, 554 + BQ24190_REG_POC_CHG_CONFIG_MASK, 555 + BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val); 556 + 557 + pm_runtime_mark_last_busy(bdi->dev); 558 + pm_runtime_put_autosuspend(bdi->dev); 559 + 560 + return ret ? ret : val == BQ24190_REG_POC_CHG_CONFIG_OTG; 561 + } 562 + 563 + static const struct regulator_ops bq24190_vbus_ops = { 564 + .enable = bq24190_vbus_enable, 565 + .disable = bq24190_vbus_disable, 566 + .is_enabled = bq24190_vbus_is_enabled, 567 + }; 568 + 569 + static const struct regulator_desc bq24190_vbus_desc = { 570 + .name = "usb_otg_vbus", 571 + .type = REGULATOR_VOLTAGE, 572 + .owner = THIS_MODULE, 573 + .ops = &bq24190_vbus_ops, 574 + .fixed_uV = 5000000, 575 + .n_voltages = 1, 576 + }; 577 + 578 + static const struct regulator_init_data bq24190_vbus_init_data = { 579 + .constraints = { 580 + .valid_ops_mask = REGULATOR_CHANGE_STATUS, 581 + }, 582 + }; 583 + 584 + static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi) 585 + { 586 + struct bq24190_platform_data *pdata = bdi->dev->platform_data; 587 + struct regulator_config cfg = { }; 588 + struct regulator_dev *reg; 589 + int ret = 0; 590 + 591 + cfg.dev = bdi->dev; 592 + if (pdata && pdata->regulator_init_data) 593 + cfg.init_data = pdata->regulator_init_data; 594 + else 595 + cfg.init_data = &bq24190_vbus_init_data; 596 + cfg.driver_data = bdi; 597 + reg = devm_regulator_register(bdi->dev, &bq24190_vbus_desc, &cfg); 598 + if (IS_ERR(reg)) { 599 + ret = PTR_ERR(reg); 600 + dev_err(bdi->dev, "Can't register regulator: %d\n", ret); 601 + } 602 + 603 + return ret; 604 + } 605 + #else 606 + static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi) 607 + { 608 + return 0; 609 + } 610 + #endif 611 + 612 + static int bq24190_set_config(struct bq24190_dev_info *bdi) 529 613 { 530 614 int ret; 531 615 u8 v; ··· 633 523 634 524 bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >> 635 525 BQ24190_REG_CTTC_WATCHDOG_SHIFT); 526 + 527 + /* 528 + * According to the "Host Mode and default Mode" section of the 529 + * manual, a write to any register causes the bq24190 to switch 530 + * from default mode to host mode. It will switch back to default 531 + * mode after a WDT timeout unless the WDT is turned off as well. 532 + * So, by simply turning off the WDT, we accomplish both with the 533 + * same write. 534 + */ 636 535 v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK; 637 536 638 - return bq24190_write(bdi, BQ24190_REG_CTTC, v); 537 + ret = bq24190_write(bdi, BQ24190_REG_CTTC, v); 538 + if (ret < 0) 539 + return ret; 540 + 541 + if (bdi->sys_min) { 542 + v = bdi->sys_min / 100 - 30; // manual section 9.5.1.2, table 9 543 + ret = bq24190_write_mask(bdi, BQ24190_REG_POC, 544 + BQ24190_REG_POC_SYS_MIN_MASK, 545 + BQ24190_REG_POC_SYS_MIN_SHIFT, 546 + v); 547 + if (ret < 0) 548 + return ret; 549 + } 550 + 551 + if (bdi->iprechg) { 552 + v = bdi->iprechg / 128 - 1; // manual section 9.5.1.4, table 11 553 + ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC, 554 + BQ24190_REG_PCTCC_IPRECHG_MASK, 555 + BQ24190_REG_PCTCC_IPRECHG_SHIFT, 556 + v); 557 + if (ret < 0) 558 + return ret; 559 + } 560 + 561 + if (bdi->iterm) { 562 + v = bdi->iterm / 128 - 1; // manual section 9.5.1.4, table 11 563 + ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC, 564 + BQ24190_REG_PCTCC_ITERM_MASK, 565 + BQ24190_REG_PCTCC_ITERM_SHIFT, 566 + v); 567 + if (ret < 0) 568 + return ret; 569 + } 570 + 571 + return 0; 639 572 } 640 573 641 574 static int bq24190_register_reset(struct bq24190_dev_info *bdi) ··· 926 773 return bq24190_battery_set_temp_alert_max(bdi, val); 927 774 } 928 775 776 + static int bq24190_charger_get_precharge(struct bq24190_dev_info *bdi, 777 + union power_supply_propval *val) 778 + { 779 + u8 v; 780 + int ret; 781 + 782 + ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC, 783 + BQ24190_REG_PCTCC_IPRECHG_MASK, 784 + BQ24190_REG_PCTCC_IPRECHG_SHIFT, &v); 785 + if (ret < 0) 786 + return ret; 787 + 788 + val->intval = ++v * 128 * 1000; 789 + return 0; 790 + } 791 + 792 + static int bq24190_charger_get_charge_term(struct bq24190_dev_info *bdi, 793 + union power_supply_propval *val) 794 + { 795 + u8 v; 796 + int ret; 797 + 798 + ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC, 799 + BQ24190_REG_PCTCC_ITERM_MASK, 800 + BQ24190_REG_PCTCC_ITERM_SHIFT, &v); 801 + if (ret < 0) 802 + return ret; 803 + 804 + val->intval = ++v * 128 * 1000; 805 + return 0; 806 + } 807 + 929 808 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi, 930 809 union power_supply_propval *val) 931 810 { ··· 1050 865 ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval); 1051 866 } 1052 867 868 + static int bq24190_charger_get_iinlimit(struct bq24190_dev_info *bdi, 869 + union power_supply_propval *val) 870 + { 871 + int iinlimit, ret; 872 + 873 + ret = bq24190_get_field_val(bdi, BQ24190_REG_ISC, 874 + BQ24190_REG_ISC_IINLIM_MASK, 875 + BQ24190_REG_ISC_IINLIM_SHIFT, 876 + bq24190_isc_iinlim_values, 877 + ARRAY_SIZE(bq24190_isc_iinlim_values), &iinlimit); 878 + if (ret < 0) 879 + return ret; 880 + 881 + val->intval = iinlimit; 882 + return 0; 883 + } 884 + 885 + static int bq24190_charger_set_iinlimit(struct bq24190_dev_info *bdi, 886 + const union power_supply_propval *val) 887 + { 888 + return bq24190_set_field_val(bdi, BQ24190_REG_ISC, 889 + BQ24190_REG_ISC_IINLIM_MASK, 890 + BQ24190_REG_ISC_IINLIM_SHIFT, 891 + bq24190_isc_iinlim_values, 892 + ARRAY_SIZE(bq24190_isc_iinlim_values), val->intval); 893 + } 894 + 1053 895 static int bq24190_charger_get_property(struct power_supply *psy, 1054 896 enum power_supply_property psp, union power_supply_propval *val) 1055 897 { ··· 1105 893 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX: 1106 894 ret = bq24190_charger_get_temp_alert_max(bdi, val); 1107 895 break; 896 + case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 897 + ret = bq24190_charger_get_precharge(bdi, val); 898 + break; 899 + case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 900 + ret = bq24190_charger_get_charge_term(bdi, val); 901 + break; 1108 902 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 1109 903 ret = bq24190_charger_get_current(bdi, val); 1110 904 break; ··· 1122 904 break; 1123 905 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 1124 906 ret = bq24190_charger_get_voltage_max(bdi, val); 907 + break; 908 + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 909 + ret = bq24190_charger_get_iinlimit(bdi, val); 1125 910 break; 1126 911 case POWER_SUPPLY_PROP_SCOPE: 1127 912 val->intval = POWER_SUPPLY_SCOPE_SYSTEM; ··· 1177 956 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 1178 957 ret = bq24190_charger_set_voltage(bdi, val); 1179 958 break; 959 + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 960 + ret = bq24190_charger_set_iinlimit(bdi, val); 961 + break; 1180 962 default: 1181 963 ret = -EINVAL; 1182 964 } ··· 1201 977 case POWER_SUPPLY_PROP_CHARGE_TYPE: 1202 978 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 1203 979 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 980 + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 1204 981 ret = 1; 1205 982 break; 1206 983 default: ··· 1211 986 return ret; 1212 987 } 1213 988 989 + static void bq24190_input_current_limit_work(struct work_struct *work) 990 + { 991 + struct bq24190_dev_info *bdi = 992 + container_of(work, struct bq24190_dev_info, 993 + input_current_limit_work.work); 994 + 995 + power_supply_set_input_current_limit_from_supplier(bdi->charger); 996 + } 997 + 998 + /* Sync the input-current-limit with our parent supply (if we have one) */ 999 + static void bq24190_charger_external_power_changed(struct power_supply *psy) 1000 + { 1001 + struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy); 1002 + 1003 + /* 1004 + * The Power-Good detection may take up to 220ms, sometimes 1005 + * the external charger detection is quicker, and the bq24190 will 1006 + * reset to iinlim based on its own charger detection (which is not 1007 + * hooked up when using external charger detection) resulting in a 1008 + * too low default 500mA iinlim. Delay setting the input-current-limit 1009 + * for 300ms to avoid this. 1010 + */ 1011 + queue_delayed_work(system_wq, &bdi->input_current_limit_work, 1012 + msecs_to_jiffies(300)); 1013 + } 1014 + 1214 1015 static enum power_supply_property bq24190_charger_properties[] = { 1215 1016 POWER_SUPPLY_PROP_CHARGE_TYPE, 1216 1017 POWER_SUPPLY_PROP_HEALTH, 1217 1018 POWER_SUPPLY_PROP_ONLINE, 1218 1019 POWER_SUPPLY_PROP_STATUS, 1219 1020 POWER_SUPPLY_PROP_TEMP_ALERT_MAX, 1021 + POWER_SUPPLY_PROP_PRECHARGE_CURRENT, 1022 + POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, 1220 1023 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 1221 1024 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 1222 1025 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 1223 1026 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 1027 + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 1224 1028 POWER_SUPPLY_PROP_SCOPE, 1225 1029 POWER_SUPPLY_PROP_MODEL_NAME, 1226 1030 POWER_SUPPLY_PROP_MANUFACTURER, ··· 1267 1013 .get_property = bq24190_charger_get_property, 1268 1014 .set_property = bq24190_charger_set_property, 1269 1015 .property_is_writeable = bq24190_charger_property_is_writeable, 1016 + .external_power_changed = bq24190_charger_external_power_changed, 1270 1017 }; 1271 1018 1272 1019 /* Battery power supply property routines */ ··· 1715 1460 if (ret < 0) 1716 1461 return ret; 1717 1462 1718 - ret = bq24190_set_mode_host(bdi); 1463 + ret = bq24190_set_config(bdi); 1719 1464 if (ret < 0) 1720 1465 return ret; 1721 1466 1722 1467 return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg); 1468 + } 1469 + 1470 + static int bq24190_get_config(struct bq24190_dev_info *bdi) 1471 + { 1472 + const char * const s = "ti,system-minimum-microvolt"; 1473 + struct power_supply_battery_info info = {}; 1474 + int v; 1475 + 1476 + if (device_property_read_u32(bdi->dev, s, &v) == 0) { 1477 + v /= 1000; 1478 + if (v >= BQ24190_REG_POC_SYS_MIN_MIN 1479 + && v <= BQ24190_REG_POC_SYS_MIN_MAX) 1480 + bdi->sys_min = v; 1481 + else 1482 + dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v); 1483 + } 1484 + 1485 + if (bdi->dev->of_node && 1486 + !power_supply_get_battery_info(bdi->charger, &info)) { 1487 + v = info.precharge_current_ua / 1000; 1488 + if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN 1489 + && v <= BQ24190_REG_PCTCC_IPRECHG_MAX) 1490 + bdi->iprechg = v; 1491 + else 1492 + dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n", 1493 + v); 1494 + 1495 + v = info.charge_term_current_ua / 1000; 1496 + if (v >= BQ24190_REG_PCTCC_ITERM_MIN 1497 + && v <= BQ24190_REG_PCTCC_ITERM_MAX) 1498 + bdi->iterm = v; 1499 + else 1500 + dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n", 1501 + v); 1502 + } 1503 + 1504 + return 0; 1723 1505 } 1724 1506 1725 1507 static int bq24190_probe(struct i2c_client *client, ··· 1786 1494 mutex_init(&bdi->f_reg_lock); 1787 1495 bdi->f_reg = 0; 1788 1496 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */ 1497 + INIT_DELAYED_WORK(&bdi->input_current_limit_work, 1498 + bq24190_input_current_limit_work); 1789 1499 1790 1500 i2c_set_clientdata(client, bdi); 1791 1501 1792 - if (!client->irq) { 1502 + if (client->irq <= 0) { 1793 1503 dev_err(dev, "Can't get irq info\n"); 1794 1504 return -EINVAL; 1795 1505 } ··· 1824 1530 goto out_pmrt; 1825 1531 } 1826 1532 1827 - ret = bq24190_hw_init(bdi); 1828 - if (ret < 0) { 1829 - dev_err(dev, "Hardware init failed\n"); 1830 - goto out_pmrt; 1831 - } 1832 - 1833 1533 charger_cfg.drv_data = bdi; 1534 + charger_cfg.of_node = dev->of_node; 1834 1535 charger_cfg.supplied_to = bq24190_charger_supplied_to; 1835 1536 charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to), 1836 1537 bdi->charger = power_supply_register(dev, &bq24190_charger_desc, ··· 1849 1560 } 1850 1561 } 1851 1562 1563 + ret = bq24190_get_config(bdi); 1564 + if (ret < 0) { 1565 + dev_err(dev, "Can't get devicetree config\n"); 1566 + goto out_charger; 1567 + } 1568 + 1569 + ret = bq24190_hw_init(bdi); 1570 + if (ret < 0) { 1571 + dev_err(dev, "Hardware init failed\n"); 1572 + goto out_charger; 1573 + } 1574 + 1852 1575 ret = bq24190_sysfs_create_group(bdi); 1853 - if (ret) { 1576 + if (ret < 0) { 1854 1577 dev_err(dev, "Can't create sysfs entries\n"); 1855 1578 goto out_charger; 1856 1579 } ··· 1877 1576 dev_err(dev, "Can't set up irq handler\n"); 1878 1577 goto out_sysfs; 1879 1578 } 1579 + 1580 + ret = bq24190_register_vbus_regulator(bdi); 1581 + if (ret < 0) 1582 + goto out_sysfs; 1880 1583 1881 1584 if (bdi->extcon) { 1882 1585 INIT_DELAYED_WORK(&bdi->extcon_work, bq24190_extcon_work); ··· 2009 1704 } 2010 1705 2011 1706 bq24190_register_reset(bdi); 2012 - bq24190_set_mode_host(bdi); 1707 + bq24190_set_config(bdi); 2013 1708 bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg); 2014 1709 2015 1710 if (error >= 0) { ··· 2041 1736 #ifdef CONFIG_OF 2042 1737 static const struct of_device_id bq24190_of_match[] = { 2043 1738 { .compatible = "ti,bq24190", }, 1739 + { .compatible = "ti,bq24192i", }, 2044 1740 { }, 2045 1741 }; 2046 1742 MODULE_DEVICE_TABLE(of, bq24190_of_match);

+207 -370

drivers/power/supply/bq27xxx_battery.c

··· 58 58 59 59 #include <linux/power/bq27xxx_battery.h> 60 60 61 - #define DRIVER_VERSION "1.2.0" 62 - 63 61 #define BQ27XXX_MANUFACTURER "Texas Instruments" 64 62 65 63 /* BQ27XXX Flags */ ··· 130 132 [BQ27XXX_DM_CKSUM] = 0x60 131 133 132 134 /* Register mappings */ 133 - static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = { 134 - [BQ27000] = { 135 + static u8 136 + bq27000_regs[BQ27XXX_REG_MAX] = { 135 137 [BQ27XXX_REG_CTRL] = 0x00, 136 138 [BQ27XXX_REG_TEMP] = 0x06, 137 139 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, ··· 155 157 [BQ27XXX_DM_DATA] = INVALID_REG_ADDR, 156 158 [BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR, 157 159 }, 158 - [BQ27010] = { 160 + bq27010_regs[BQ27XXX_REG_MAX] = { 159 161 [BQ27XXX_REG_CTRL] = 0x00, 160 162 [BQ27XXX_REG_TEMP] = 0x06, 161 163 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, ··· 179 181 [BQ27XXX_DM_DATA] = INVALID_REG_ADDR, 180 182 [BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR, 181 183 }, 182 - [BQ2750X] = { 184 + bq2750x_regs[BQ27XXX_REG_MAX] = { 183 185 [BQ27XXX_REG_CTRL] = 0x00, 184 186 [BQ27XXX_REG_TEMP] = 0x06, 185 187 [BQ27XXX_REG_INT_TEMP] = 0x28, ··· 199 201 [BQ27XXX_REG_AP] = INVALID_REG_ADDR, 200 202 BQ27XXX_DM_REG_ROWS, 201 203 }, 202 - [BQ2751X] = { 203 - [BQ27XXX_REG_CTRL] = 0x00, 204 - [BQ27XXX_REG_TEMP] = 0x06, 205 - [BQ27XXX_REG_INT_TEMP] = 0x28, 206 - [BQ27XXX_REG_VOLT] = 0x08, 207 - [BQ27XXX_REG_AI] = 0x14, 208 - [BQ27XXX_REG_FLAGS] = 0x0a, 209 - [BQ27XXX_REG_TTE] = 0x16, 210 - [BQ27XXX_REG_TTF] = INVALID_REG_ADDR, 211 - [BQ27XXX_REG_TTES] = 0x1a, 212 - [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR, 213 - [BQ27XXX_REG_NAC] = 0x0c, 214 - [BQ27XXX_REG_FCC] = 0x12, 215 - [BQ27XXX_REG_CYCT] = 0x1e, 216 - [BQ27XXX_REG_AE] = INVALID_REG_ADDR, 217 - [BQ27XXX_REG_SOC] = 0x20, 218 - [BQ27XXX_REG_DCAP] = 0x2e, 219 - [BQ27XXX_REG_AP] = INVALID_REG_ADDR, 220 - BQ27XXX_DM_REG_ROWS, 221 - }, 222 - [BQ27500] = { 204 + #define bq2751x_regs bq27510g3_regs 205 + #define bq2752x_regs bq27510g3_regs 206 + bq27500_regs[BQ27XXX_REG_MAX] = { 223 207 [BQ27XXX_REG_CTRL] = 0x00, 224 208 [BQ27XXX_REG_TEMP] = 0x06, 225 209 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, ··· 221 241 [BQ27XXX_REG_AP] = 0x24, 222 242 BQ27XXX_DM_REG_ROWS, 223 243 }, 224 - [BQ27510G1] = { 225 - [BQ27XXX_REG_CTRL] = 0x00, 226 - [BQ27XXX_REG_TEMP] = 0x06, 227 - [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, 228 - [BQ27XXX_REG_VOLT] = 0x08, 229 - [BQ27XXX_REG_AI] = 0x14, 230 - [BQ27XXX_REG_FLAGS] = 0x0a, 231 - [BQ27XXX_REG_TTE] = 0x16, 232 - [BQ27XXX_REG_TTF] = 0x18, 233 - [BQ27XXX_REG_TTES] = 0x1c, 234 - [BQ27XXX_REG_TTECP] = 0x26, 235 - [BQ27XXX_REG_NAC] = 0x0c, 236 - [BQ27XXX_REG_FCC] = 0x12, 237 - [BQ27XXX_REG_CYCT] = 0x2a, 238 - [BQ27XXX_REG_AE] = 0x22, 239 - [BQ27XXX_REG_SOC] = 0x2c, 240 - [BQ27XXX_REG_DCAP] = 0x3c, 241 - [BQ27XXX_REG_AP] = 0x24, 242 - BQ27XXX_DM_REG_ROWS, 243 - }, 244 - [BQ27510G2] = { 245 - [BQ27XXX_REG_CTRL] = 0x00, 246 - [BQ27XXX_REG_TEMP] = 0x06, 247 - [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, 248 - [BQ27XXX_REG_VOLT] = 0x08, 249 - [BQ27XXX_REG_AI] = 0x14, 250 - [BQ27XXX_REG_FLAGS] = 0x0a, 251 - [BQ27XXX_REG_TTE] = 0x16, 252 - [BQ27XXX_REG_TTF] = 0x18, 253 - [BQ27XXX_REG_TTES] = 0x1c, 254 - [BQ27XXX_REG_TTECP] = 0x26, 255 - [BQ27XXX_REG_NAC] = 0x0c, 256 - [BQ27XXX_REG_FCC] = 0x12, 257 - [BQ27XXX_REG_CYCT] = 0x2a, 258 - [BQ27XXX_REG_AE] = 0x22, 259 - [BQ27XXX_REG_SOC] = 0x2c, 260 - [BQ27XXX_REG_DCAP] = 0x3c, 261 - [BQ27XXX_REG_AP] = 0x24, 262 - BQ27XXX_DM_REG_ROWS, 263 - }, 264 - [BQ27510G3] = { 244 + #define bq27510g1_regs bq27500_regs 245 + #define bq27510g2_regs bq27500_regs 246 + bq27510g3_regs[BQ27XXX_REG_MAX] = { 265 247 [BQ27XXX_REG_CTRL] = 0x00, 266 248 [BQ27XXX_REG_TEMP] = 0x06, 267 249 [BQ27XXX_REG_INT_TEMP] = 0x28, ··· 243 301 [BQ27XXX_REG_AP] = INVALID_REG_ADDR, 244 302 BQ27XXX_DM_REG_ROWS, 245 303 }, 246 - [BQ27520G1] = { 304 + bq27520g1_regs[BQ27XXX_REG_MAX] = { 247 305 [BQ27XXX_REG_CTRL] = 0x00, 248 306 [BQ27XXX_REG_TEMP] = 0x06, 249 307 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, ··· 263 321 [BQ27XXX_REG_AP] = 0x24, 264 322 BQ27XXX_DM_REG_ROWS, 265 323 }, 266 - [BQ27520G2] = { 324 + bq27520g2_regs[BQ27XXX_REG_MAX] = { 267 325 [BQ27XXX_REG_CTRL] = 0x00, 268 326 [BQ27XXX_REG_TEMP] = 0x06, 269 327 [BQ27XXX_REG_INT_TEMP] = 0x36, ··· 283 341 [BQ27XXX_REG_AP] = 0x24, 284 342 BQ27XXX_DM_REG_ROWS, 285 343 }, 286 - [BQ27520G3] = { 344 + bq27520g3_regs[BQ27XXX_REG_MAX] = { 287 345 [BQ27XXX_REG_CTRL] = 0x00, 288 346 [BQ27XXX_REG_TEMP] = 0x06, 289 347 [BQ27XXX_REG_INT_TEMP] = 0x36, ··· 303 361 [BQ27XXX_REG_AP] = 0x24, 304 362 BQ27XXX_DM_REG_ROWS, 305 363 }, 306 - [BQ27520G4] = { 364 + bq27520g4_regs[BQ27XXX_REG_MAX] = { 307 365 [BQ27XXX_REG_CTRL] = 0x00, 308 366 [BQ27XXX_REG_TEMP] = 0x06, 309 367 [BQ27XXX_REG_INT_TEMP] = 0x28, ··· 323 381 [BQ27XXX_REG_AP] = INVALID_REG_ADDR, 324 382 BQ27XXX_DM_REG_ROWS, 325 383 }, 326 - [BQ27530] = { 384 + bq27530_regs[BQ27XXX_REG_MAX] = { 327 385 [BQ27XXX_REG_CTRL] = 0x00, 328 386 [BQ27XXX_REG_TEMP] = 0x06, 329 387 [BQ27XXX_REG_INT_TEMP] = 0x32, ··· 343 401 [BQ27XXX_REG_AP] = 0x24, 344 402 BQ27XXX_DM_REG_ROWS, 345 403 }, 346 - [BQ27541] = { 404 + #define bq27531_regs bq27530_regs 405 + bq27541_regs[BQ27XXX_REG_MAX] = { 347 406 [BQ27XXX_REG_CTRL] = 0x00, 348 407 [BQ27XXX_REG_TEMP] = 0x06, 349 408 [BQ27XXX_REG_INT_TEMP] = 0x28, ··· 364 421 [BQ27XXX_REG_AP] = 0x24, 365 422 BQ27XXX_DM_REG_ROWS, 366 423 }, 367 - [BQ27545] = { 424 + #define bq27542_regs bq27541_regs 425 + #define bq27546_regs bq27541_regs 426 + #define bq27742_regs bq27541_regs 427 + bq27545_regs[BQ27XXX_REG_MAX] = { 368 428 [BQ27XXX_REG_CTRL] = 0x00, 369 429 [BQ27XXX_REG_TEMP] = 0x06, 370 430 [BQ27XXX_REG_INT_TEMP] = 0x28, ··· 387 441 [BQ27XXX_REG_AP] = 0x24, 388 442 BQ27XXX_DM_REG_ROWS, 389 443 }, 390 - [BQ27421] = { 444 + bq27421_regs[BQ27XXX_REG_MAX] = { 391 445 [BQ27XXX_REG_CTRL] = 0x00, 392 446 [BQ27XXX_REG_TEMP] = 0x02, 393 447 [BQ27XXX_REG_INT_TEMP] = 0x1e, ··· 406 460 [BQ27XXX_REG_DCAP] = 0x3c, 407 461 [BQ27XXX_REG_AP] = 0x18, 408 462 BQ27XXX_DM_REG_ROWS, 409 - }, 410 - }; 463 + }; 464 + #define bq27425_regs bq27421_regs 465 + #define bq27441_regs bq27421_regs 466 + #define bq27621_regs bq27421_regs 411 467 412 - static enum power_supply_property bq27000_battery_props[] = { 468 + static enum power_supply_property bq27000_props[] = { 413 469 POWER_SUPPLY_PROP_STATUS, 414 470 POWER_SUPPLY_PROP_PRESENT, 415 471 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 433 485 POWER_SUPPLY_PROP_MANUFACTURER, 434 486 }; 435 487 436 - static enum power_supply_property bq27010_battery_props[] = { 488 + static enum power_supply_property bq27010_props[] = { 437 489 POWER_SUPPLY_PROP_STATUS, 438 490 POWER_SUPPLY_PROP_PRESENT, 439 491 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 453 505 POWER_SUPPLY_PROP_MANUFACTURER, 454 506 }; 455 507 456 - static enum power_supply_property bq2750x_battery_props[] = { 457 - POWER_SUPPLY_PROP_STATUS, 458 - POWER_SUPPLY_PROP_PRESENT, 459 - POWER_SUPPLY_PROP_VOLTAGE_NOW, 460 - POWER_SUPPLY_PROP_CURRENT_NOW, 461 - POWER_SUPPLY_PROP_CAPACITY, 462 - POWER_SUPPLY_PROP_CAPACITY_LEVEL, 463 - POWER_SUPPLY_PROP_TEMP, 464 - POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 465 - POWER_SUPPLY_PROP_TECHNOLOGY, 466 - POWER_SUPPLY_PROP_CHARGE_FULL, 467 - POWER_SUPPLY_PROP_CHARGE_NOW, 468 - POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 469 - POWER_SUPPLY_PROP_CYCLE_COUNT, 470 - POWER_SUPPLY_PROP_HEALTH, 471 - POWER_SUPPLY_PROP_MANUFACTURER, 472 - }; 508 + #define bq2750x_props bq27510g3_props 509 + #define bq2751x_props bq27510g3_props 510 + #define bq2752x_props bq27510g3_props 473 511 474 - static enum power_supply_property bq2751x_battery_props[] = { 475 - POWER_SUPPLY_PROP_STATUS, 476 - POWER_SUPPLY_PROP_PRESENT, 477 - POWER_SUPPLY_PROP_VOLTAGE_NOW, 478 - POWER_SUPPLY_PROP_CURRENT_NOW, 479 - POWER_SUPPLY_PROP_CAPACITY, 480 - POWER_SUPPLY_PROP_CAPACITY_LEVEL, 481 - POWER_SUPPLY_PROP_TEMP, 482 - POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 483 - POWER_SUPPLY_PROP_TECHNOLOGY, 484 - POWER_SUPPLY_PROP_CHARGE_FULL, 485 - POWER_SUPPLY_PROP_CHARGE_NOW, 486 - POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 487 - POWER_SUPPLY_PROP_CYCLE_COUNT, 488 - POWER_SUPPLY_PROP_HEALTH, 489 - POWER_SUPPLY_PROP_MANUFACTURER, 490 - }; 491 - 492 - static enum power_supply_property bq27500_battery_props[] = { 512 + static enum power_supply_property bq27500_props[] = { 493 513 POWER_SUPPLY_PROP_STATUS, 494 514 POWER_SUPPLY_PROP_PRESENT, 495 515 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 477 561 POWER_SUPPLY_PROP_HEALTH, 478 562 POWER_SUPPLY_PROP_MANUFACTURER, 479 563 }; 564 + #define bq27510g1_props bq27500_props 565 + #define bq27510g2_props bq27500_props 480 566 481 - static enum power_supply_property bq27510g1_battery_props[] = { 482 - POWER_SUPPLY_PROP_STATUS, 483 - POWER_SUPPLY_PROP_PRESENT, 484 - POWER_SUPPLY_PROP_VOLTAGE_NOW, 485 - POWER_SUPPLY_PROP_CURRENT_NOW, 486 - POWER_SUPPLY_PROP_CAPACITY, 487 - POWER_SUPPLY_PROP_CAPACITY_LEVEL, 488 - POWER_SUPPLY_PROP_TEMP, 489 - POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 490 - POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, 491 - POWER_SUPPLY_PROP_TECHNOLOGY, 492 - POWER_SUPPLY_PROP_CHARGE_FULL, 493 - POWER_SUPPLY_PROP_CHARGE_NOW, 494 - POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 495 - POWER_SUPPLY_PROP_CYCLE_COUNT, 496 - POWER_SUPPLY_PROP_ENERGY_NOW, 497 - POWER_SUPPLY_PROP_POWER_AVG, 498 - POWER_SUPPLY_PROP_HEALTH, 499 - POWER_SUPPLY_PROP_MANUFACTURER, 500 - }; 501 - 502 - static enum power_supply_property bq27510g2_battery_props[] = { 503 - POWER_SUPPLY_PROP_STATUS, 504 - POWER_SUPPLY_PROP_PRESENT, 505 - POWER_SUPPLY_PROP_VOLTAGE_NOW, 506 - POWER_SUPPLY_PROP_CURRENT_NOW, 507 - POWER_SUPPLY_PROP_CAPACITY, 508 - POWER_SUPPLY_PROP_CAPACITY_LEVEL, 509 - POWER_SUPPLY_PROP_TEMP, 510 - POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 511 - POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, 512 - POWER_SUPPLY_PROP_TECHNOLOGY, 513 - POWER_SUPPLY_PROP_CHARGE_FULL, 514 - POWER_SUPPLY_PROP_CHARGE_NOW, 515 - POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 516 - POWER_SUPPLY_PROP_CYCLE_COUNT, 517 - POWER_SUPPLY_PROP_ENERGY_NOW, 518 - POWER_SUPPLY_PROP_POWER_AVG, 519 - POWER_SUPPLY_PROP_HEALTH, 520 - POWER_SUPPLY_PROP_MANUFACTURER, 521 - }; 522 - 523 - static enum power_supply_property bq27510g3_battery_props[] = { 567 + static enum power_supply_property bq27510g3_props[] = { 524 568 POWER_SUPPLY_PROP_STATUS, 525 569 POWER_SUPPLY_PROP_PRESENT, 526 570 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 498 622 POWER_SUPPLY_PROP_MANUFACTURER, 499 623 }; 500 624 501 - static enum power_supply_property bq27520g1_battery_props[] = { 625 + static enum power_supply_property bq27520g1_props[] = { 502 626 POWER_SUPPLY_PROP_STATUS, 503 627 POWER_SUPPLY_PROP_PRESENT, 504 628 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 518 642 POWER_SUPPLY_PROP_MANUFACTURER, 519 643 }; 520 644 521 - static enum power_supply_property bq27520g2_battery_props[] = { 522 - POWER_SUPPLY_PROP_STATUS, 523 - POWER_SUPPLY_PROP_PRESENT, 524 - POWER_SUPPLY_PROP_VOLTAGE_NOW, 525 - POWER_SUPPLY_PROP_CURRENT_NOW, 526 - POWER_SUPPLY_PROP_CAPACITY, 527 - POWER_SUPPLY_PROP_CAPACITY_LEVEL, 528 - POWER_SUPPLY_PROP_TEMP, 529 - POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 530 - POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, 531 - POWER_SUPPLY_PROP_TECHNOLOGY, 532 - POWER_SUPPLY_PROP_CHARGE_FULL, 533 - POWER_SUPPLY_PROP_CHARGE_NOW, 534 - POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 535 - POWER_SUPPLY_PROP_CYCLE_COUNT, 536 - POWER_SUPPLY_PROP_ENERGY_NOW, 537 - POWER_SUPPLY_PROP_POWER_AVG, 538 - POWER_SUPPLY_PROP_HEALTH, 539 - POWER_SUPPLY_PROP_MANUFACTURER, 540 - }; 645 + #define bq27520g2_props bq27500_props 541 646 542 - static enum power_supply_property bq27520g3_battery_props[] = { 647 + static enum power_supply_property bq27520g3_props[] = { 543 648 POWER_SUPPLY_PROP_STATUS, 544 649 POWER_SUPPLY_PROP_PRESENT, 545 650 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 540 683 POWER_SUPPLY_PROP_MANUFACTURER, 541 684 }; 542 685 543 - static enum power_supply_property bq27520g4_battery_props[] = { 686 + static enum power_supply_property bq27520g4_props[] = { 544 687 POWER_SUPPLY_PROP_STATUS, 545 688 POWER_SUPPLY_PROP_PRESENT, 546 689 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 557 700 POWER_SUPPLY_PROP_MANUFACTURER, 558 701 }; 559 702 560 - static enum power_supply_property bq27530_battery_props[] = { 703 + static enum power_supply_property bq27530_props[] = { 561 704 POWER_SUPPLY_PROP_STATUS, 562 705 POWER_SUPPLY_PROP_PRESENT, 563 706 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 574 717 POWER_SUPPLY_PROP_CYCLE_COUNT, 575 718 POWER_SUPPLY_PROP_MANUFACTURER, 576 719 }; 720 + #define bq27531_props bq27530_props 577 721 578 - static enum power_supply_property bq27541_battery_props[] = { 722 + static enum power_supply_property bq27541_props[] = { 579 723 POWER_SUPPLY_PROP_STATUS, 580 724 POWER_SUPPLY_PROP_PRESENT, 581 725 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 594 736 POWER_SUPPLY_PROP_HEALTH, 595 737 POWER_SUPPLY_PROP_MANUFACTURER, 596 738 }; 739 + #define bq27542_props bq27541_props 740 + #define bq27546_props bq27541_props 741 + #define bq27742_props bq27541_props 597 742 598 - static enum power_supply_property bq27545_battery_props[] = { 743 + static enum power_supply_property bq27545_props[] = { 599 744 POWER_SUPPLY_PROP_STATUS, 600 745 POWER_SUPPLY_PROP_PRESENT, 601 746 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 616 755 POWER_SUPPLY_PROP_MANUFACTURER, 617 756 }; 618 757 619 - static enum power_supply_property bq27421_battery_props[] = { 758 + static enum power_supply_property bq27421_props[] = { 620 759 POWER_SUPPLY_PROP_STATUS, 621 760 POWER_SUPPLY_PROP_PRESENT, 622 761 POWER_SUPPLY_PROP_VOLTAGE_NOW, ··· 630 769 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 631 770 POWER_SUPPLY_PROP_MANUFACTURER, 632 771 }; 772 + #define bq27425_props bq27421_props 773 + #define bq27441_props bq27421_props 774 + #define bq27621_props bq27421_props 633 775 634 - #define BQ27XXX_PROP(_id, _prop) \ 635 - [_id] = { \ 636 - .props = _prop, \ 637 - .size = ARRAY_SIZE(_prop), \ 638 - } 776 + struct bq27xxx_dm_reg { 777 + u8 subclass_id; 778 + u8 offset; 779 + u8 bytes; 780 + u16 min, max; 781 + }; 782 + 783 + enum bq27xxx_dm_reg_id { 784 + BQ27XXX_DM_DESIGN_CAPACITY = 0, 785 + BQ27XXX_DM_DESIGN_ENERGY, 786 + BQ27XXX_DM_TERMINATE_VOLTAGE, 787 + }; 788 + 789 + #define bq27000_dm_regs 0 790 + #define bq27010_dm_regs 0 791 + #define bq2750x_dm_regs 0 792 + #define bq2751x_dm_regs 0 793 + #define bq2752x_dm_regs 0 794 + 795 + #if 0 /* not yet tested */ 796 + static struct bq27xxx_dm_reg bq27500_dm_regs[] = { 797 + [BQ27XXX_DM_DESIGN_CAPACITY] = { 48, 10, 2, 0, 65535 }, 798 + [BQ27XXX_DM_DESIGN_ENERGY] = { }, /* missing on chip */ 799 + [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 }, 800 + }; 801 + #else 802 + #define bq27500_dm_regs 0 803 + #endif 804 + 805 + /* todo create data memory definitions from datasheets and test on chips */ 806 + #define bq27510g1_dm_regs 0 807 + #define bq27510g2_dm_regs 0 808 + #define bq27510g3_dm_regs 0 809 + #define bq27520g1_dm_regs 0 810 + #define bq27520g2_dm_regs 0 811 + #define bq27520g3_dm_regs 0 812 + #define bq27520g4_dm_regs 0 813 + #define bq27530_dm_regs 0 814 + #define bq27531_dm_regs 0 815 + #define bq27541_dm_regs 0 816 + #define bq27542_dm_regs 0 817 + #define bq27546_dm_regs 0 818 + #define bq27742_dm_regs 0 819 + 820 + #if 0 /* not yet tested */ 821 + static struct bq27xxx_dm_reg bq27545_dm_regs[] = { 822 + [BQ27XXX_DM_DESIGN_CAPACITY] = { 48, 23, 2, 0, 32767 }, 823 + [BQ27XXX_DM_DESIGN_ENERGY] = { 48, 25, 2, 0, 32767 }, 824 + [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800, 3700 }, 825 + }; 826 + #else 827 + #define bq27545_dm_regs 0 828 + #endif 829 + 830 + static struct bq27xxx_dm_reg bq27421_dm_regs[] = { 831 + [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 10, 2, 0, 8000 }, 832 + [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 12, 2, 0, 32767 }, 833 + [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500, 3700 }, 834 + }; 835 + 836 + static struct bq27xxx_dm_reg bq27425_dm_regs[] = { 837 + [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 12, 2, 0, 32767 }, 838 + [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 14, 2, 0, 32767 }, 839 + [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800, 3700 }, 840 + }; 841 + 842 + #if 0 /* not yet tested */ 843 + #define bq27441_dm_regs bq27421_dm_regs 844 + #else 845 + #define bq27441_dm_regs 0 846 + #endif 847 + 848 + #if 0 /* not yet tested */ 849 + static struct bq27xxx_dm_reg bq27621_dm_regs[] = { 850 + [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 3, 2, 0, 8000 }, 851 + [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 5, 2, 0, 32767 }, 852 + [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500, 3700 }, 853 + }; 854 + #else 855 + #define bq27621_dm_regs 0 856 + #endif 857 + 858 + #define BQ27XXX_O_ZERO 0x00000001 859 + #define BQ27XXX_O_OTDC 0x00000002 860 + #define BQ27XXX_O_UTOT 0x00000004 861 + #define BQ27XXX_O_CFGUP 0x00000008 862 + #define BQ27XXX_O_RAM 0x00000010 863 + 864 + #define BQ27XXX_DATA(ref, key, opt) { \ 865 + .opts = (opt), \ 866 + .unseal_key = key, \ 867 + .regs = ref##_regs, \ 868 + .dm_regs = ref##_dm_regs, \ 869 + .props = ref##_props, \ 870 + .props_size = ARRAY_SIZE(ref##_props) } 639 871 640 872 static struct { 873 + u32 opts; 874 + u32 unseal_key; 875 + u8 *regs; 876 + struct bq27xxx_dm_reg *dm_regs; 641 877 enum power_supply_property *props; 642 - size_t size; 643 - } bq27xxx_battery_props[] = { 644 - BQ27XXX_PROP(BQ27000, bq27000_battery_props), 645 - BQ27XXX_PROP(BQ27010, bq27010_battery_props), 646 - BQ27XXX_PROP(BQ2750X, bq2750x_battery_props), 647 - BQ27XXX_PROP(BQ2751X, bq2751x_battery_props), 648 - BQ27XXX_PROP(BQ27500, bq27500_battery_props), 649 - BQ27XXX_PROP(BQ27510G1, bq27510g1_battery_props), 650 - BQ27XXX_PROP(BQ27510G2, bq27510g2_battery_props), 651 - BQ27XXX_PROP(BQ27510G3, bq27510g3_battery_props), 652 - BQ27XXX_PROP(BQ27520G1, bq27520g1_battery_props), 653 - BQ27XXX_PROP(BQ27520G2, bq27520g2_battery_props), 654 - BQ27XXX_PROP(BQ27520G3, bq27520g3_battery_props), 655 - BQ27XXX_PROP(BQ27520G4, bq27520g4_battery_props), 656 - BQ27XXX_PROP(BQ27530, bq27530_battery_props), 657 - BQ27XXX_PROP(BQ27541, bq27541_battery_props), 658 - BQ27XXX_PROP(BQ27545, bq27545_battery_props), 659 - BQ27XXX_PROP(BQ27421, bq27421_battery_props), 878 + size_t props_size; 879 + } bq27xxx_chip_data[] = { 880 + [BQ27000] = BQ27XXX_DATA(bq27000, 0 , BQ27XXX_O_ZERO), 881 + [BQ27010] = BQ27XXX_DATA(bq27010, 0 , BQ27XXX_O_ZERO), 882 + [BQ2750X] = BQ27XXX_DATA(bq2750x, 0 , BQ27XXX_O_OTDC), 883 + [BQ2751X] = BQ27XXX_DATA(bq2751x, 0 , BQ27XXX_O_OTDC), 884 + [BQ2752X] = BQ27XXX_DATA(bq2752x, 0 , BQ27XXX_O_OTDC), 885 + [BQ27500] = BQ27XXX_DATA(bq27500, 0x04143672, BQ27XXX_O_OTDC), 886 + [BQ27510G1] = BQ27XXX_DATA(bq27510g1, 0 , BQ27XXX_O_OTDC), 887 + [BQ27510G2] = BQ27XXX_DATA(bq27510g2, 0 , BQ27XXX_O_OTDC), 888 + [BQ27510G3] = BQ27XXX_DATA(bq27510g3, 0 , BQ27XXX_O_OTDC), 889 + [BQ27520G1] = BQ27XXX_DATA(bq27520g1, 0 , BQ27XXX_O_OTDC), 890 + [BQ27520G2] = BQ27XXX_DATA(bq27520g2, 0 , BQ27XXX_O_OTDC), 891 + [BQ27520G3] = BQ27XXX_DATA(bq27520g3, 0 , BQ27XXX_O_OTDC), 892 + [BQ27520G4] = BQ27XXX_DATA(bq27520g4, 0 , BQ27XXX_O_OTDC), 893 + [BQ27530] = BQ27XXX_DATA(bq27530, 0 , BQ27XXX_O_UTOT), 894 + [BQ27531] = BQ27XXX_DATA(bq27531, 0 , BQ27XXX_O_UTOT), 895 + [BQ27541] = BQ27XXX_DATA(bq27541, 0 , BQ27XXX_O_OTDC), 896 + [BQ27542] = BQ27XXX_DATA(bq27542, 0 , BQ27XXX_O_OTDC), 897 + [BQ27546] = BQ27XXX_DATA(bq27546, 0 , BQ27XXX_O_OTDC), 898 + [BQ27742] = BQ27XXX_DATA(bq27742, 0 , BQ27XXX_O_OTDC), 899 + [BQ27545] = BQ27XXX_DATA(bq27545, 0x04143672, BQ27XXX_O_OTDC), 900 + [BQ27421] = BQ27XXX_DATA(bq27421, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM), 901 + [BQ27425] = BQ27XXX_DATA(bq27425, 0x04143672, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP), 902 + [BQ27441] = BQ27XXX_DATA(bq27441, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM), 903 + [BQ27621] = BQ27XXX_DATA(bq27621, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM), 660 904 }; 661 905 662 906 static DEFINE_MUTEX(bq27xxx_list_lock); ··· 770 804 #define BQ27XXX_MSLEEP(i) usleep_range((i)*1000, (i)*1000+500) 771 805 772 806 #define BQ27XXX_DM_SZ 32 773 - 774 - struct bq27xxx_dm_reg { 775 - u8 subclass_id; 776 - u8 offset; 777 - u8 bytes; 778 - u16 min, max; 779 - }; 780 807 781 808 /** 782 809 * struct bq27xxx_dm_buf - chip data memory buffer ··· 802 843 803 844 return NULL; 804 845 } 805 - 806 - enum bq27xxx_dm_reg_id { 807 - BQ27XXX_DM_DESIGN_CAPACITY = 0, 808 - BQ27XXX_DM_DESIGN_ENERGY, 809 - BQ27XXX_DM_TERMINATE_VOLTAGE, 810 - }; 811 846 812 847 static const char * const bq27xxx_dm_reg_name[] = { 813 848 [BQ27XXX_DM_DESIGN_CAPACITY] = "design-capacity", ··· 1045 1092 } 1046 1093 1047 1094 #ifdef CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM 1048 - if (!di->ram_chip && !bq27xxx_dt_to_nvm) { 1095 + if (!(di->opts & BQ27XXX_O_RAM) && !bq27xxx_dt_to_nvm) { 1049 1096 #else 1050 - if (!di->ram_chip) { 1097 + if (!(di->opts & BQ27XXX_O_RAM)) { 1051 1098 #endif 1052 1099 /* devicetree and NVM differ; defer to NVM */ 1053 1100 dev_warn(di->dev, "%s has %u; update to %u disallowed " ··· 1083 1130 return ret; 1084 1131 } while (!!(ret & BQ27XXX_FLAG_CFGUP) != active && --try); 1085 1132 1086 - if (!try) { 1133 + if (!try && di->chip != BQ27425) { // 425 has a bug 1087 1134 dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", active); 1088 1135 return -EINVAL; 1089 1136 } ··· 1115 1162 static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di, 1116 1163 struct bq27xxx_dm_buf *buf) 1117 1164 { 1118 - bool cfgup = di->chip == BQ27421; /* assume related chips need cfgupdate */ 1165 + bool cfgup = di->opts & BQ27XXX_O_CFGUP; 1119 1166 int ret; 1120 1167 1121 1168 if (!buf->dirty) ··· 1214 1261 1215 1262 bq27xxx_battery_seal(di); 1216 1263 1217 - if (updated && di->chip != BQ27421) { /* not a cfgupdate chip, so reset */ 1264 + if (updated && !(di->opts & BQ27XXX_O_CFGUP)) { 1218 1265 bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_RESET, false); 1219 1266 BQ27XXX_MSLEEP(300); /* reset time is not documented */ 1220 1267 } ··· 1281 1328 { 1282 1329 int soc; 1283 1330 1284 - if (di->chip == BQ27000 || di->chip == BQ27010) 1331 + if (di->opts & BQ27XXX_O_ZERO) 1285 1332 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, true); 1286 1333 else 1287 1334 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false); ··· 1307 1354 return charge; 1308 1355 } 1309 1356 1310 - if (di->chip == BQ27000 || di->chip == BQ27010) 1357 + if (di->opts & BQ27XXX_O_ZERO) 1311 1358 charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS; 1312 1359 else 1313 1360 charge *= 1000; ··· 1323 1370 { 1324 1371 int flags; 1325 1372 1326 - if (di->chip == BQ27000 || di->chip == BQ27010) { 1373 + if (di->opts & BQ27XXX_O_ZERO) { 1327 1374 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true); 1328 1375 if (flags >= 0 && (flags & BQ27000_FLAG_CI)) 1329 1376 return -ENODATA; ··· 1349 1396 { 1350 1397 int dcap; 1351 1398 1352 - if (di->chip == BQ27000 || di->chip == BQ27010) 1399 + if (di->opts & BQ27XXX_O_ZERO) 1353 1400 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true); 1354 1401 else 1355 1402 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false); ··· 1359 1406 return dcap; 1360 1407 } 1361 1408 1362 - if (di->chip == BQ27000 || di->chip == BQ27010) 1409 + if (di->opts & BQ27XXX_O_ZERO) 1363 1410 dcap = (dcap << 8) * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS; 1364 1411 else 1365 1412 dcap *= 1000; ··· 1381 1428 return ae; 1382 1429 } 1383 1430 1384 - if (di->chip == BQ27000 || di->chip == BQ27010) 1431 + if (di->opts & BQ27XXX_O_ZERO) 1385 1432 ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS; 1386 1433 else 1387 1434 ae *= 1000; ··· 1403 1450 return temp; 1404 1451 } 1405 1452 1406 - if (di->chip == BQ27000 || di->chip == BQ27010) 1453 + if (di->opts & BQ27XXX_O_ZERO) 1407 1454 temp = 5 * temp / 2; 1408 1455 1409 1456 return temp; ··· 1460 1507 return tval; 1461 1508 } 1462 1509 1463 - if (di->chip == BQ27000 || di->chip == BQ27010) 1510 + if (di->opts & BQ27XXX_O_ZERO) 1464 1511 return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS; 1465 1512 else 1466 1513 return tval; ··· 1471 1518 */ 1472 1519 static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags) 1473 1520 { 1474 - switch (di->chip) { 1475 - case BQ2750X: 1476 - case BQ2751X: 1477 - case BQ27500: 1478 - case BQ27510G1: 1479 - case BQ27510G2: 1480 - case BQ27510G3: 1481 - case BQ27520G1: 1482 - case BQ27520G2: 1483 - case BQ27520G3: 1484 - case BQ27520G4: 1485 - case BQ27541: 1486 - case BQ27545: 1521 + if (di->opts & BQ27XXX_O_OTDC) 1487 1522 return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD); 1488 - case BQ27530: 1489 - case BQ27421: 1523 + if (di->opts & BQ27XXX_O_UTOT) 1490 1524 return flags & BQ27XXX_FLAG_OT; 1491 - default: 1492 - return false; 1493 - } 1525 + 1526 + return false; 1494 1527 } 1495 1528 1496 1529 /* ··· 1484 1545 */ 1485 1546 static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags) 1486 1547 { 1487 - if (di->chip == BQ27530 || di->chip == BQ27421) 1548 + if (di->opts & BQ27XXX_O_UTOT) 1488 1549 return flags & BQ27XXX_FLAG_UT; 1489 1550 1490 1551 return false; ··· 1495 1556 */ 1496 1557 static bool bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags) 1497 1558 { 1498 - if (di->chip == BQ27000 || di->chip == BQ27010) 1559 + if (di->opts & BQ27XXX_O_ZERO) 1499 1560 return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF); 1500 1561 else 1501 1562 return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF); ··· 1508 1569 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di) 1509 1570 { 1510 1571 int flags; 1511 - bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010; 1572 + bool has_singe_flag = di->opts & BQ27XXX_O_ZERO; 1512 1573 1513 1574 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag); 1514 1575 if (flags < 0) { ··· 1530 1591 void bq27xxx_battery_update(struct bq27xxx_device_info *di) 1531 1592 { 1532 1593 struct bq27xxx_reg_cache cache = {0, }; 1533 - bool has_ci_flag = di->chip == BQ27000 || di->chip == BQ27010; 1534 - bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010; 1594 + bool has_ci_flag = di->opts & BQ27XXX_O_ZERO; 1595 + bool has_singe_flag = di->opts & BQ27XXX_O_ZERO; 1535 1596 1536 1597 cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag); 1537 1598 if ((cache.flags & 0xff) == 0xff) ··· 1609 1670 return curr; 1610 1671 } 1611 1672 1612 - if (di->chip == BQ27000 || di->chip == BQ27010) { 1673 + if (di->opts & BQ27XXX_O_ZERO) { 1613 1674 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true); 1614 1675 if (flags & BQ27000_FLAG_CHGS) { 1615 1676 dev_dbg(di->dev, "negative current!\n"); ··· 1630 1691 { 1631 1692 int status; 1632 1693 1633 - if (di->chip == BQ27000 || di->chip == BQ27010) { 1694 + if (di->opts & BQ27XXX_O_ZERO) { 1634 1695 if (di->cache.flags & BQ27000_FLAG_FC) 1635 1696 status = POWER_SUPPLY_STATUS_FULL; 1636 1697 else if (di->cache.flags & BQ27000_FLAG_CHGS) ··· 1658 1719 { 1659 1720 int level; 1660 1721 1661 - if (di->chip == BQ27000 || di->chip == BQ27010) { 1722 + if (di->opts & BQ27XXX_O_ZERO) { 1662 1723 if (di->cache.flags & BQ27000_FLAG_FC) 1663 1724 level = POWER_SUPPLY_CAPACITY_LEVEL_FULL; 1664 1725 else if (di->cache.flags & BQ27000_FLAG_EDV1) ··· 1823 1884 1824 1885 INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll); 1825 1886 mutex_init(&di->lock); 1826 - di->regs = bq27xxx_regs[di->chip]; 1887 + 1888 + di->regs = bq27xxx_chip_data[di->chip].regs; 1889 + di->unseal_key = bq27xxx_chip_data[di->chip].unseal_key; 1890 + di->dm_regs = bq27xxx_chip_data[di->chip].dm_regs; 1891 + di->opts = bq27xxx_chip_data[di->chip].opts; 1827 1892 1828 1893 psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL); 1829 1894 if (!psy_desc) ··· 1835 1892 1836 1893 psy_desc->name = di->name; 1837 1894 psy_desc->type = POWER_SUPPLY_TYPE_BATTERY; 1838 - psy_desc->properties = bq27xxx_battery_props[di->chip].props; 1839 - psy_desc->num_properties = bq27xxx_battery_props[di->chip].size; 1895 + psy_desc->properties = bq27xxx_chip_data[di->chip].props; 1896 + psy_desc->num_properties = bq27xxx_chip_data[di->chip].props_size; 1840 1897 psy_desc->get_property = bq27xxx_battery_get_property; 1841 1898 psy_desc->external_power_changed = bq27xxx_external_power_changed; 1842 1899 ··· 1845 1902 dev_err(di->dev, "failed to register battery\n"); 1846 1903 return PTR_ERR(di->bat); 1847 1904 } 1848 - 1849 - dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION); 1850 1905 1851 1906 bq27xxx_battery_settings(di); 1852 1907 bq27xxx_battery_update(di); ··· 1878 1937 mutex_destroy(&di->lock); 1879 1938 } 1880 1939 EXPORT_SYMBOL_GPL(bq27xxx_battery_teardown); 1881 - 1882 - static int bq27xxx_battery_platform_read(struct bq27xxx_device_info *di, u8 reg, 1883 - bool single) 1884 - { 1885 - struct device *dev = di->dev; 1886 - struct bq27xxx_platform_data *pdata = dev->platform_data; 1887 - unsigned int timeout = 3; 1888 - int upper, lower; 1889 - int temp; 1890 - 1891 - if (!single) { 1892 - /* Make sure the value has not changed in between reading the 1893 - * lower and the upper part */ 1894 - upper = pdata->read(dev, reg + 1); 1895 - do { 1896 - temp = upper; 1897 - if (upper < 0) 1898 - return upper; 1899 - 1900 - lower = pdata->read(dev, reg); 1901 - if (lower < 0) 1902 - return lower; 1903 - 1904 - upper = pdata->read(dev, reg + 1); 1905 - } while (temp != upper && --timeout); 1906 - 1907 - if (timeout == 0) 1908 - return -EIO; 1909 - 1910 - return (upper << 8) | lower; 1911 - } 1912 - 1913 - return pdata->read(dev, reg); 1914 - } 1915 - 1916 - static int bq27xxx_battery_platform_probe(struct platform_device *pdev) 1917 - { 1918 - struct bq27xxx_device_info *di; 1919 - struct bq27xxx_platform_data *pdata = pdev->dev.platform_data; 1920 - 1921 - if (!pdata) { 1922 - dev_err(&pdev->dev, "no platform_data supplied\n"); 1923 - return -EINVAL; 1924 - } 1925 - 1926 - if (!pdata->read) { 1927 - dev_err(&pdev->dev, "no hdq read callback supplied\n"); 1928 - return -EINVAL; 1929 - } 1930 - 1931 - if (!pdata->chip) { 1932 - dev_err(&pdev->dev, "no device supplied\n"); 1933 - return -EINVAL; 1934 - } 1935 - 1936 - di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL); 1937 - if (!di) 1938 - return -ENOMEM; 1939 - 1940 - platform_set_drvdata(pdev, di); 1941 - 1942 - di->dev = &pdev->dev; 1943 - di->chip = pdata->chip; 1944 - di->name = pdata->name ?: dev_name(&pdev->dev); 1945 - di->bus.read = bq27xxx_battery_platform_read; 1946 - 1947 - return bq27xxx_battery_setup(di); 1948 - } 1949 - 1950 - static int bq27xxx_battery_platform_remove(struct platform_device *pdev) 1951 - { 1952 - struct bq27xxx_device_info *di = platform_get_drvdata(pdev); 1953 - 1954 - bq27xxx_battery_teardown(di); 1955 - 1956 - return 0; 1957 - } 1958 - 1959 - static const struct platform_device_id bq27xxx_battery_platform_id_table[] = { 1960 - { "bq27000-battery", }, 1961 - { /* sentinel */ } 1962 - }; 1963 - MODULE_DEVICE_TABLE(platform, bq27xxx_battery_platform_id_table); 1964 - 1965 - #ifdef CONFIG_OF 1966 - static const struct of_device_id bq27xxx_battery_platform_of_match_table[] = { 1967 - { .compatible = "ti,bq27000" }, 1968 - {}, 1969 - }; 1970 - MODULE_DEVICE_TABLE(of, bq27xxx_battery_platform_of_match_table); 1971 - #endif 1972 - 1973 - static struct platform_driver bq27xxx_battery_platform_driver = { 1974 - .probe = bq27xxx_battery_platform_probe, 1975 - .remove = bq27xxx_battery_platform_remove, 1976 - .driver = { 1977 - .name = "bq27000-battery", 1978 - .of_match_table = of_match_ptr(bq27xxx_battery_platform_of_match_table), 1979 - }, 1980 - .id_table = bq27xxx_battery_platform_id_table, 1981 - }; 1982 - module_platform_driver(bq27xxx_battery_platform_driver); 1983 - 1984 - MODULE_ALIAS("platform:bq27000-battery"); 1985 1940 1986 1941 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); 1987 1942 MODULE_DESCRIPTION("BQ27xxx battery monitor driver");

+135

drivers/power/supply/bq27xxx_battery_hdq.c

··· 1 + /* 2 + * BQ27xxx battery monitor HDQ/1-wire driver 3 + * 4 + * Copyright (C) 2007-2017 Texas Instruments Incorporated - http://www.ti.com/ 5 + * 6 + * This program is free software; you can redistribute it and/or modify 7 + * it under the terms of the GNU General Public License version 2 as 8 + * published by the Free Software Foundation. 9 + * 10 + * This program is distributed "as is" WITHOUT ANY WARRANTY of any 11 + * kind, whether express or implied; without even the implied warranty 12 + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 + * GNU General Public License for more details. 14 + */ 15 + 16 + #include <linux/kernel.h> 17 + #include <linux/module.h> 18 + #include <linux/device.h> 19 + #include <linux/types.h> 20 + #include <linux/platform_device.h> 21 + #include <linux/mutex.h> 22 + #include <linux/power/bq27xxx_battery.h> 23 + 24 + #include <linux/w1.h> 25 + 26 + #define W1_FAMILY_BQ27000 0x01 27 + 28 + #define HDQ_CMD_READ (0 << 7) 29 + #define HDQ_CMD_WRITE (1 << 7) 30 + 31 + static int F_ID; 32 + module_param(F_ID, int, S_IRUSR); 33 + MODULE_PARM_DESC(F_ID, "1-wire slave FID for BQ27xxx device"); 34 + 35 + static int w1_bq27000_read(struct w1_slave *sl, unsigned int reg) 36 + { 37 + u8 val; 38 + 39 + mutex_lock(&sl->master->bus_mutex); 40 + w1_write_8(sl->master, HDQ_CMD_READ | reg); 41 + val = w1_read_8(sl->master); 42 + mutex_unlock(&sl->master->bus_mutex); 43 + 44 + return val; 45 + } 46 + 47 + static int bq27xxx_battery_hdq_read(struct bq27xxx_device_info *di, u8 reg, 48 + bool single) 49 + { 50 + struct w1_slave *sl = dev_to_w1_slave(di->dev); 51 + unsigned int timeout = 3; 52 + int upper, lower; 53 + int temp; 54 + 55 + if (!single) { 56 + /* 57 + * Make sure the value has not changed in between reading the 58 + * lower and the upper part 59 + */ 60 + upper = w1_bq27000_read(sl, reg + 1); 61 + do { 62 + temp = upper; 63 + if (upper < 0) 64 + return upper; 65 + 66 + lower = w1_bq27000_read(sl, reg); 67 + if (lower < 0) 68 + return lower; 69 + 70 + upper = w1_bq27000_read(sl, reg + 1); 71 + } while (temp != upper && --timeout); 72 + 73 + if (timeout == 0) 74 + return -EIO; 75 + 76 + return (upper << 8) | lower; 77 + } 78 + 79 + return w1_bq27000_read(sl, reg); 80 + } 81 + 82 + static int bq27xxx_battery_hdq_add_slave(struct w1_slave *sl) 83 + { 84 + struct bq27xxx_device_info *di; 85 + 86 + di = devm_kzalloc(&sl->dev, sizeof(*di), GFP_KERNEL); 87 + if (!di) 88 + return -ENOMEM; 89 + 90 + dev_set_drvdata(&sl->dev, di); 91 + 92 + di->dev = &sl->dev; 93 + di->chip = BQ27000; 94 + di->name = "bq27000-battery"; 95 + di->bus.read = bq27xxx_battery_hdq_read; 96 + 97 + return bq27xxx_battery_setup(di); 98 + } 99 + 100 + static void bq27xxx_battery_hdq_remove_slave(struct w1_slave *sl) 101 + { 102 + struct bq27xxx_device_info *di = dev_get_drvdata(&sl->dev); 103 + 104 + bq27xxx_battery_teardown(di); 105 + } 106 + 107 + static struct w1_family_ops bq27xxx_battery_hdq_fops = { 108 + .add_slave = bq27xxx_battery_hdq_add_slave, 109 + .remove_slave = bq27xxx_battery_hdq_remove_slave, 110 + }; 111 + 112 + static struct w1_family bq27xxx_battery_hdq_family = { 113 + .fid = W1_FAMILY_BQ27000, 114 + .fops = &bq27xxx_battery_hdq_fops, 115 + }; 116 + 117 + static int __init bq27xxx_battery_hdq_init(void) 118 + { 119 + if (F_ID) 120 + bq27xxx_battery_hdq_family.fid = F_ID; 121 + 122 + return w1_register_family(&bq27xxx_battery_hdq_family); 123 + } 124 + module_init(bq27xxx_battery_hdq_init); 125 + 126 + static void __exit bq27xxx_battery_hdq_exit(void) 127 + { 128 + w1_unregister_family(&bq27xxx_battery_hdq_family); 129 + } 130 + module_exit(bq27xxx_battery_hdq_exit); 131 + 132 + MODULE_AUTHOR("Texas Instruments Ltd"); 133 + MODULE_DESCRIPTION("BQ27xxx battery monitor HDQ/1-wire driver"); 134 + MODULE_LICENSE("GPL"); 135 + MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_BQ27000));

+8 -8

drivers/power/supply/bq27xxx_battery_i2c.c

··· 230 230 { "bq27210", BQ27010 }, 231 231 { "bq27500", BQ2750X }, 232 232 { "bq27510", BQ2751X }, 233 - { "bq27520", BQ2751X }, 233 + { "bq27520", BQ2752X }, 234 234 { "bq27500-1", BQ27500 }, 235 235 { "bq27510g1", BQ27510G1 }, 236 236 { "bq27510g2", BQ27510G2 }, ··· 240 240 { "bq27520g3", BQ27520G3 }, 241 241 { "bq27520g4", BQ27520G4 }, 242 242 { "bq27530", BQ27530 }, 243 - { "bq27531", BQ27530 }, 243 + { "bq27531", BQ27531 }, 244 244 { "bq27541", BQ27541 }, 245 - { "bq27542", BQ27541 }, 246 - { "bq27546", BQ27541 }, 247 - { "bq27742", BQ27541 }, 245 + { "bq27542", BQ27542 }, 246 + { "bq27546", BQ27546 }, 247 + { "bq27742", BQ27742 }, 248 248 { "bq27545", BQ27545 }, 249 249 { "bq27421", BQ27421 }, 250 - { "bq27425", BQ27421 }, 251 - { "bq27441", BQ27421 }, 252 - { "bq27621", BQ27421 }, 250 + { "bq27425", BQ27425 }, 251 + { "bq27441", BQ27441 }, 252 + { "bq27621", BQ27621 }, 253 253 {}, 254 254 }; 255 255 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);

+5 -4

drivers/power/supply/charger-manager.c

··· 1632 1632 return -ENODEV; 1633 1633 } 1634 1634 1635 - cm = devm_kzalloc(&pdev->dev, 1636 - sizeof(struct charger_manager), GFP_KERNEL); 1635 + cm = devm_kzalloc(&pdev->dev, sizeof(*cm), GFP_KERNEL); 1637 1636 if (!cm) 1638 1637 return -ENOMEM; 1639 1638 ··· 1644 1645 /* Initialize alarm timer */ 1645 1646 if (alarmtimer_get_rtcdev()) { 1646 1647 cm_timer = devm_kzalloc(cm->dev, sizeof(*cm_timer), GFP_KERNEL); 1648 + if (!cm_timer) 1649 + return -ENOMEM; 1647 1650 alarm_init(cm_timer, ALARM_BOOTTIME, cm_timer_func); 1648 1651 } 1649 1652 1650 1653 /* 1651 - * The following two do not need to be errors. 1652 - * Users may intentionally ignore those two features. 1654 + * Some of the following do not need to be errors. 1655 + * Users may intentionally ignore those features. 1653 1656 */ 1654 1657 if (desc->fullbatt_uV == 0) { 1655 1658 dev_info(&pdev->dev, "Ignoring full-battery voltage threshold as it is not supplied\n");

+2 -2

drivers/power/supply/ds2780_battery.c

··· 663 663 return count; 664 664 } 665 665 666 - static struct bin_attribute ds2780_param_eeprom_bin_attr = { 666 + static const struct bin_attribute ds2780_param_eeprom_bin_attr = { 667 667 .attr = { 668 668 .name = "param_eeprom", 669 669 .mode = S_IRUGO | S_IWUSR, ··· 708 708 return count; 709 709 } 710 710 711 - static struct bin_attribute ds2780_user_eeprom_bin_attr = { 711 + static const struct bin_attribute ds2780_user_eeprom_bin_attr = { 712 712 .attr = { 713 713 .name = "user_eeprom", 714 714 .mode = S_IRUGO | S_IWUSR,

+2 -2

drivers/power/supply/ds2781_battery.c

··· 665 665 return count; 666 666 } 667 667 668 - static struct bin_attribute ds2781_param_eeprom_bin_attr = { 668 + static const struct bin_attribute ds2781_param_eeprom_bin_attr = { 669 669 .attr = { 670 670 .name = "param_eeprom", 671 671 .mode = S_IRUGO | S_IWUSR, ··· 711 711 return count; 712 712 } 713 713 714 - static struct bin_attribute ds2781_user_eeprom_bin_attr = { 714 + static const struct bin_attribute ds2781_user_eeprom_bin_attr = { 715 715 .attr = { 716 716 .name = "user_eeprom", 717 717 .mode = S_IRUGO | S_IWUSR,

+12 -6

drivers/power/supply/lp8788-charger.c

··· 626 626 { 627 627 struct lp8788_charger *pchg = dev_get_drvdata(dev); 628 628 enum lp8788_charging_state state; 629 - char *desc[LP8788_MAX_CHG_STATE] = { 629 + static const char * const desc[LP8788_MAX_CHG_STATE] = { 630 630 [LP8788_OFF] = "CHARGER OFF", 631 631 [LP8788_WARM_UP] = "WARM UP", 632 632 [LP8788_LOW_INPUT] = "LOW INPUT STATE", ··· 650 650 struct device_attribute *attr, char *buf) 651 651 { 652 652 struct lp8788_charger *pchg = dev_get_drvdata(dev); 653 - char *stime[] = { "400ms", "5min", "10min", "15min", 654 - "20min", "25min", "30min", "No timeout" }; 653 + static const char * const stime[] = { 654 + "400ms", "5min", "10min", "15min", 655 + "20min", "25min", "30min", "No timeout" 656 + }; 655 657 u8 val; 656 658 657 659 lp8788_read_byte(pchg->lp, LP8788_CHG_EOC, &val); ··· 667 665 struct device_attribute *attr, char *buf) 668 666 { 669 667 struct lp8788_charger *pchg = dev_get_drvdata(dev); 670 - char *abs_level[] = { "25mA", "49mA", "75mA", "98mA" }; 671 - char *relative_level[] = { "5%", "10%", "15%", "20%" }; 672 - char *level; 668 + static const char * const abs_level[] = { 669 + "25mA", "49mA", "75mA", "98mA" 670 + }; 671 + static const char * const relative_level[] = { 672 + "5%", "10%", "15%", "20%" 673 + }; 674 + const char *level; 673 675 u8 val; 674 676 u8 mode; 675 677

+113 -43

drivers/power/supply/ltc2941-battery-gauge.c

··· 1 1 /* 2 - * I2C client/driver for the Linear Technology LTC2941 and LTC2943 3 - * Battery Gas Gauge IC 2 + * I2C client/driver for the Linear Technology LTC2941, LTC2942, LTC2943 3 + * and LTC2944 Battery Gas Gauge IC 4 4 * 5 5 * Copyright (C) 2014 Topic Embedded Systems 6 6 * ··· 34 34 LTC294X_REG_CONTROL = 0x01, 35 35 LTC294X_REG_ACC_CHARGE_MSB = 0x02, 36 36 LTC294X_REG_ACC_CHARGE_LSB = 0x03, 37 - LTC294X_REG_THRESH_HIGH_MSB = 0x04, 38 - LTC294X_REG_THRESH_HIGH_LSB = 0x05, 39 - LTC294X_REG_THRESH_LOW_MSB = 0x06, 40 - LTC294X_REG_THRESH_LOW_LSB = 0x07, 41 - LTC294X_REG_VOLTAGE_MSB = 0x08, 42 - LTC294X_REG_VOLTAGE_LSB = 0x09, 43 - LTC294X_REG_CURRENT_MSB = 0x0E, 44 - LTC294X_REG_CURRENT_LSB = 0x0F, 45 - LTC294X_REG_TEMPERATURE_MSB = 0x14, 46 - LTC294X_REG_TEMPERATURE_LSB = 0x15, 37 + LTC294X_REG_VOLTAGE_MSB = 0x08, 38 + LTC294X_REG_VOLTAGE_LSB = 0x09, 39 + LTC2942_REG_TEMPERATURE_MSB = 0x0C, 40 + LTC2942_REG_TEMPERATURE_LSB = 0x0D, 41 + LTC2943_REG_CURRENT_MSB = 0x0E, 42 + LTC2943_REG_CURRENT_LSB = 0x0F, 43 + LTC2943_REG_TEMPERATURE_MSB = 0x14, 44 + LTC2943_REG_TEMPERATURE_LSB = 0x15, 47 45 }; 48 46 49 - #define LTC2943_REG_CONTROL_MODE_MASK (BIT(7) | BIT(6)) 50 - #define LTC2943_REG_CONTROL_MODE_SCAN BIT(7) 47 + enum ltc294x_id { 48 + LTC2941_ID, 49 + LTC2942_ID, 50 + LTC2943_ID, 51 + LTC2944_ID, 52 + }; 53 + 54 + #define LTC2941_REG_STATUS_CHIP_ID BIT(7) 55 + 56 + #define LTC2942_REG_CONTROL_MODE_SCAN (BIT(7) | BIT(6)) 57 + #define LTC2943_REG_CONTROL_MODE_SCAN BIT(7) 51 58 #define LTC294X_REG_CONTROL_PRESCALER_MASK (BIT(5) | BIT(4) | BIT(3)) 52 59 #define LTC294X_REG_CONTROL_SHUTDOWN_MASK (BIT(0)) 53 60 #define LTC294X_REG_CONTROL_PRESCALER_SET(x) \ 54 61 ((x << 3) & LTC294X_REG_CONTROL_PRESCALER_MASK) 55 62 #define LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED 0 56 63 57 - #define LTC2941_NUM_REGS 0x08 58 - #define LTC2943_NUM_REGS 0x18 59 - 60 64 struct ltc294x_info { 61 65 struct i2c_client *client; /* I2C Client pointer */ 62 66 struct power_supply *supply; /* Supply pointer */ 63 67 struct power_supply_desc supply_desc; /* Supply description */ 64 68 struct delayed_work work; /* Work scheduler */ 65 - unsigned long num_regs; /* Number of registers (chip type) */ 69 + enum ltc294x_id id; /* Chip type */ 66 70 int charge; /* Last charge register content */ 67 71 int r_sense; /* mOhm */ 68 72 int Qlsb; /* nAh */ ··· 149 145 150 146 control = LTC294X_REG_CONTROL_PRESCALER_SET(prescaler_exp) | 151 147 LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED; 152 - /* Put the 2943 into "monitor" mode, so it measures every 10 sec */ 153 - if (info->num_regs == LTC2943_NUM_REGS) 148 + /* Put device into "monitor" mode */ 149 + switch (info->id) { 150 + case LTC2942_ID: /* 2942 measures every 2 sec */ 151 + control |= LTC2942_REG_CONTROL_MODE_SCAN; 152 + break; 153 + case LTC2943_ID: 154 + case LTC2944_ID: /* 2943 and 2944 measure every 10 sec */ 154 155 control |= LTC2943_REG_CONTROL_MODE_SCAN; 156 + break; 157 + default: 158 + break; 159 + } 155 160 156 161 if (value != control) { 157 162 ret = ltc294x_write_regs(info->client, ··· 265 252 ret = ltc294x_read_regs(info->client, 266 253 LTC294X_REG_VOLTAGE_MSB, &datar[0], 2); 267 254 value = (datar[0] << 8) | datar[1]; 268 - *val = ((value * 23600) / 0xFFFF) * 1000; /* in uV */ 255 + switch (info->id) { 256 + case LTC2943_ID: 257 + value *= 23600 * 2; 258 + value /= 0xFFFF; 259 + value *= 1000 / 2; 260 + break; 261 + case LTC2944_ID: 262 + value *= 70800 / 5*4; 263 + value /= 0xFFFF; 264 + value *= 1000 * 5/4; 265 + break; 266 + default: 267 + value *= 6000 * 10; 268 + value /= 0xFFFF; 269 + value *= 1000 / 10; 270 + break; 271 + } 272 + *val = value; 269 273 return ret; 270 274 } 271 275 ··· 293 263 s32 value; 294 264 295 265 ret = ltc294x_read_regs(info->client, 296 - LTC294X_REG_CURRENT_MSB, &datar[0], 2); 266 + LTC2943_REG_CURRENT_MSB, &datar[0], 2); 297 267 value = (datar[0] << 8) | datar[1]; 298 268 value -= 0x7FFF; 269 + if (info->id == LTC2944_ID) 270 + value *= 64000; 271 + else 272 + value *= 60000; 299 273 /* Value is in range -32k..+32k, r_sense is usually 10..50 mOhm, 300 274 * the formula below keeps everything in s32 range while preserving 301 275 * enough digits */ 302 - *val = 1000 * ((60000 * value) / (info->r_sense * 0x7FFF)); /* in uA */ 276 + *val = 1000 * (value / (info->r_sense * 0x7FFF)); /* in uA */ 303 277 return ret; 304 278 } 305 279 306 280 static int ltc294x_get_temperature(const struct ltc294x_info *info, int *val) 307 281 { 282 + enum ltc294x_reg reg; 308 283 int ret; 309 284 u8 datar[2]; 310 285 u32 value; 311 286 312 - ret = ltc294x_read_regs(info->client, 313 - LTC294X_REG_TEMPERATURE_MSB, &datar[0], 2); 314 - value = (datar[0] << 8) | datar[1]; 315 - /* Full-scale is 510 Kelvin, convert to centidegrees */ 316 - *val = (((51000 * value) / 0xFFFF) - 27215); 287 + if (info->id == LTC2942_ID) { 288 + reg = LTC2942_REG_TEMPERATURE_MSB; 289 + value = 60000; /* Full-scale is 600 Kelvin */ 290 + } else { 291 + reg = LTC2943_REG_TEMPERATURE_MSB; 292 + value = 51000; /* Full-scale is 510 Kelvin */ 293 + } 294 + ret = ltc294x_read_regs(info->client, reg, &datar[0], 2); 295 + value *= (datar[0] << 8) | datar[1]; 296 + /* Convert to centidegrees */ 297 + *val = value / 0xFFFF - 27215; 317 298 return ret; 318 299 } 319 300 ··· 398 357 POWER_SUPPLY_PROP_CHARGE_COUNTER, 399 358 POWER_SUPPLY_PROP_CHARGE_NOW, 400 359 POWER_SUPPLY_PROP_VOLTAGE_NOW, 401 - POWER_SUPPLY_PROP_CURRENT_NOW, 402 360 POWER_SUPPLY_PROP_TEMP, 361 + POWER_SUPPLY_PROP_CURRENT_NOW, 403 362 }; 404 363 405 364 static int ltc294x_i2c_remove(struct i2c_client *client) ··· 416 375 { 417 376 struct power_supply_config psy_cfg = {}; 418 377 struct ltc294x_info *info; 378 + struct device_node *np; 419 379 int ret; 420 380 u32 prescaler_exp; 421 381 s32 r_sense; 422 - struct device_node *np; 382 + u8 status; 423 383 424 384 info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL); 425 385 if (info == NULL) ··· 430 388 431 389 np = of_node_get(client->dev.of_node); 432 390 433 - info->num_regs = (unsigned long)of_device_get_match_data(&client->dev); 391 + info->id = (enum ltc294x_id)of_device_get_match_data(&client->dev); 434 392 info->supply_desc.name = np->name; 435 393 436 394 /* r_sense can be negative, when sense+ is connected to the battery ··· 451 409 prescaler_exp = LTC2941_MAX_PRESCALER_EXP; 452 410 } 453 411 454 - if (info->num_regs == LTC2943_NUM_REGS) { 412 + if (info->id == LTC2943_ID) { 455 413 if (prescaler_exp > LTC2943_MAX_PRESCALER_EXP) 456 414 prescaler_exp = LTC2943_MAX_PRESCALER_EXP; 457 415 info->Qlsb = ((340 * 50000) / r_sense) / ··· 463 421 (128 / (1 << prescaler_exp)); 464 422 } 465 423 424 + /* Read status register to check for LTC2942 */ 425 + if (info->id == LTC2941_ID || info->id == LTC2942_ID) { 426 + ret = ltc294x_read_regs(client, LTC294X_REG_STATUS, &status, 1); 427 + if (ret < 0) { 428 + dev_err(&client->dev, 429 + "Could not read status register\n"); 430 + return ret; 431 + } 432 + if (status & LTC2941_REG_STATUS_CHIP_ID) 433 + info->id = LTC2941_ID; 434 + else 435 + info->id = LTC2942_ID; 436 + } 437 + 466 438 info->client = client; 467 439 info->supply_desc.type = POWER_SUPPLY_TYPE_BATTERY; 468 440 info->supply_desc.properties = ltc294x_properties; 469 - if (info->num_regs >= LTC294X_REG_TEMPERATURE_LSB) 441 + switch (info->id) { 442 + case LTC2944_ID: 443 + case LTC2943_ID: 470 444 info->supply_desc.num_properties = 471 445 ARRAY_SIZE(ltc294x_properties); 472 - else if (info->num_regs >= LTC294X_REG_CURRENT_LSB) 446 + break; 447 + case LTC2942_ID: 473 448 info->supply_desc.num_properties = 474 449 ARRAY_SIZE(ltc294x_properties) - 1; 475 - else if (info->num_regs >= LTC294X_REG_VOLTAGE_LSB) 476 - info->supply_desc.num_properties = 477 - ARRAY_SIZE(ltc294x_properties) - 2; 478 - else 450 + break; 451 + case LTC2941_ID: 452 + default: 479 453 info->supply_desc.num_properties = 480 454 ARRAY_SIZE(ltc294x_properties) - 3; 455 + break; 456 + } 481 457 info->supply_desc.get_property = ltc294x_get_property; 482 458 info->supply_desc.set_property = ltc294x_set_property; 483 459 info->supply_desc.property_is_writeable = ltc294x_property_is_writeable; ··· 552 492 553 493 554 494 static const struct i2c_device_id ltc294x_i2c_id[] = { 555 - {"ltc2941", LTC2941_NUM_REGS}, 556 - {"ltc2943", LTC2943_NUM_REGS}, 495 + { "ltc2941", LTC2941_ID, }, 496 + { "ltc2942", LTC2942_ID, }, 497 + { "ltc2943", LTC2943_ID, }, 498 + { "ltc2944", LTC2944_ID, }, 557 499 { }, 558 500 }; 559 501 MODULE_DEVICE_TABLE(i2c, ltc294x_i2c_id); ··· 563 501 static const struct of_device_id ltc294x_i2c_of_match[] = { 564 502 { 565 503 .compatible = "lltc,ltc2941", 566 - .data = (void *)LTC2941_NUM_REGS 504 + .data = (void *)LTC2941_ID, 505 + }, 506 + { 507 + .compatible = "lltc,ltc2942", 508 + .data = (void *)LTC2942_ID, 567 509 }, 568 510 { 569 511 .compatible = "lltc,ltc2943", 570 - .data = (void *)LTC2943_NUM_REGS 512 + .data = (void *)LTC2943_ID, 513 + }, 514 + { 515 + .compatible = "lltc,ltc2944", 516 + .data = (void *)LTC2944_ID, 571 517 }, 572 518 { }, 573 519 }; ··· 595 525 596 526 MODULE_AUTHOR("Auryn Verwegen, Topic Embedded Systems"); 597 527 MODULE_AUTHOR("Mike Looijmans, Topic Embedded Products"); 598 - MODULE_DESCRIPTION("LTC2941/LTC2943 Battery Gas Gauge IC driver"); 528 + MODULE_DESCRIPTION("LTC2941/LTC2942/LTC2943/LTC2944 Battery Gas Gauge IC driver"); 599 529 MODULE_LICENSE("GPL");

+36 -6

drivers/power/supply/max17042_battery.c

··· 22 22 * This driver is based on max17040_battery.c 23 23 */ 24 24 25 + #include <linux/acpi.h> 25 26 #include <linux/init.h> 26 27 #include <linux/module.h> 27 28 #include <linux/slab.h> ··· 983 982 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 984 983 const struct power_supply_desc *max17042_desc = &max17042_psy_desc; 985 984 struct power_supply_config psy_cfg = {}; 985 + const struct acpi_device_id *acpi_id = NULL; 986 + struct device *dev = &client->dev; 986 987 struct max17042_chip *chip; 987 988 int ret; 988 989 int i; ··· 998 995 return -ENOMEM; 999 996 1000 997 chip->client = client; 1001 - chip->chip_type = id->driver_data; 998 + if (id) { 999 + chip->chip_type = id->driver_data; 1000 + } else { 1001 + acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev); 1002 + if (!acpi_id) 1003 + return -ENODEV; 1004 + 1005 + chip->chip_type = acpi_id->driver_data; 1006 + } 1002 1007 chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config); 1003 1008 if (IS_ERR(chip->regmap)) { 1004 1009 dev_err(&client->dev, "Failed to initialize regmap\n"); ··· 1050 1039 } 1051 1040 1052 1041 if (client->irq) { 1042 + unsigned int flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT; 1043 + 1044 + /* 1045 + * On ACPI systems the IRQ may be handled by ACPI-event code, 1046 + * so we need to share (if the ACPI code is willing to share). 1047 + */ 1048 + if (acpi_id) 1049 + flags |= IRQF_SHARED | IRQF_PROBE_SHARED; 1050 + 1053 1051 ret = devm_request_threaded_irq(&client->dev, client->irq, 1054 1052 NULL, 1055 - max17042_thread_handler, 1056 - IRQF_TRIGGER_FALLING | 1057 - IRQF_ONESHOT, 1053 + max17042_thread_handler, flags, 1058 1054 chip->battery->desc->name, 1059 1055 chip); 1060 1056 if (!ret) { ··· 1071 1053 max17042_set_soc_threshold(chip, 1); 1072 1054 } else { 1073 1055 client->irq = 0; 1074 - dev_err(&client->dev, "%s(): cannot get IRQ\n", 1075 - __func__); 1056 + if (ret != -EBUSY) 1057 + dev_err(&client->dev, "Failed to get IRQ\n"); 1076 1058 } 1077 1059 } 1060 + /* Not able to update the charge threshold when exceeded? -> disable */ 1061 + if (!client->irq) 1062 + regmap_write(chip->regmap, MAX17042_SALRT_Th, 0xff00); 1078 1063 1079 1064 regmap_read(chip->regmap, MAX17042_STATUS, &val); 1080 1065 if (val & STATUS_POR_BIT) { ··· 1125 1104 static SIMPLE_DEV_PM_OPS(max17042_pm_ops, max17042_suspend, 1126 1105 max17042_resume); 1127 1106 1107 + #ifdef CONFIG_ACPI 1108 + static const struct acpi_device_id max17042_acpi_match[] = { 1109 + { "MAX17047", MAXIM_DEVICE_TYPE_MAX17047 }, 1110 + { } 1111 + }; 1112 + MODULE_DEVICE_TABLE(acpi, max17042_acpi_match); 1113 + #endif 1114 + 1128 1115 #ifdef CONFIG_OF 1129 1116 static const struct of_device_id max17042_dt_match[] = { 1130 1117 { .compatible = "maxim,max17042" }, ··· 1154 1125 static struct i2c_driver max17042_i2c_driver = { 1155 1126 .driver = { 1156 1127 .name = "max17042", 1128 + .acpi_match_table = ACPI_PTR(max17042_acpi_match), 1157 1129 .of_match_table = of_match_ptr(max17042_dt_match), 1158 1130 .pm = &max17042_pm_ops, 1159 1131 },

+448

drivers/power/supply/max1721x_battery.c

··· 1 + /* 2 + * 1-Wire implementation for Maxim Semiconductor 3 + * MAX7211/MAX17215 stanalone fuel gauge chip 4 + * 5 + * Copyright (C) 2017 Radioavionica Corporation 6 + * Author: Alex A. Mihaylov <minimumlaw@rambler.ru> 7 + * 8 + * Use consistent with the GNU GPL is permitted, 9 + * provided that this copyright notice is 10 + * preserved in its entirety in all copies and derived works. 11 + * 12 + */ 13 + 14 + #include <linux/module.h> 15 + #include <linux/slab.h> 16 + #include <linux/w1.h> 17 + #include <linux/regmap.h> 18 + #include <linux/power_supply.h> 19 + 20 + #define W1_MAX1721X_FAMILY_ID 0x26 21 + #define DEF_DEV_NAME_MAX17211 "MAX17211" 22 + #define DEF_DEV_NAME_MAX17215 "MAX17215" 23 + #define DEF_DEV_NAME_UNKNOWN "UNKNOWN" 24 + #define DEF_MFG_NAME "MAXIM" 25 + 26 + #define PSY_MAX_NAME_LEN 32 27 + 28 + /* Number of valid register addresses in W1 mode */ 29 + #define MAX1721X_MAX_REG_NR 0x1EF 30 + 31 + /* Factory settings (nonvilatile registers) (W1 specific) */ 32 + #define MAX1721X_REG_NRSENSE 0x1CF /* RSense in 10^-5 Ohm */ 33 + /* Strings */ 34 + #define MAX1721X_REG_MFG_STR 0x1CC 35 + #define MAX1721X_REG_MFG_NUMB 3 36 + #define MAX1721X_REG_DEV_STR 0x1DB 37 + #define MAX1721X_REG_DEV_NUMB 5 38 + /* HEX Strings */ 39 + #define MAX1721X_REG_SER_HEX 0x1D8 40 + 41 + /* MAX172XX Output Registers for W1 chips */ 42 + #define MAX172XX_REG_STATUS 0x000 /* status reg */ 43 + #define MAX172XX_BAT_PRESENT (1<<4) /* battery connected bit */ 44 + #define MAX172XX_REG_DEVNAME 0x021 /* chip config */ 45 + #define MAX172XX_DEV_MASK 0x000F /* chip type mask */ 46 + #define MAX172X1_DEV 0x0001 47 + #define MAX172X5_DEV 0x0005 48 + #define MAX172XX_REG_TEMP 0x008 /* Temperature */ 49 + #define MAX172XX_REG_BATT 0x0DA /* Battery voltage */ 50 + #define MAX172XX_REG_CURRENT 0x00A /* Actual current */ 51 + #define MAX172XX_REG_AVGCURRENT 0x00B /* Average current */ 52 + #define MAX172XX_REG_REPSOC 0x006 /* Percentage of charge */ 53 + #define MAX172XX_REG_DESIGNCAP 0x018 /* Design capacity */ 54 + #define MAX172XX_REG_REPCAP 0x005 /* Average capacity */ 55 + #define MAX172XX_REG_TTE 0x011 /* Time to empty */ 56 + #define MAX172XX_REG_TTF 0x020 /* Time to full */ 57 + 58 + struct max17211_device_info { 59 + char name[PSY_MAX_NAME_LEN]; 60 + struct power_supply *bat; 61 + struct power_supply_desc bat_desc; 62 + struct device *w1_dev; 63 + struct regmap *regmap; 64 + /* battery design format */ 65 + unsigned int rsense; /* in tenths uOhm */ 66 + char DeviceName[2 * MAX1721X_REG_DEV_NUMB + 1]; 67 + char ManufacturerName[2 * MAX1721X_REG_MFG_NUMB + 1]; 68 + char SerialNumber[13]; /* see get_sn_str() later for comment */ 69 + }; 70 + 71 + /* Convert regs value to power_supply units */ 72 + 73 + static inline int max172xx_time_to_ps(unsigned int reg) 74 + { 75 + return reg * 5625 / 1000; /* in sec. */ 76 + } 77 + 78 + static inline int max172xx_percent_to_ps(unsigned int reg) 79 + { 80 + return reg / 256; /* in percent from 0 to 100 */ 81 + } 82 + 83 + static inline int max172xx_voltage_to_ps(unsigned int reg) 84 + { 85 + return reg * 1250; /* in uV */ 86 + } 87 + 88 + static inline int max172xx_capacity_to_ps(unsigned int reg) 89 + { 90 + return reg * 500; /* in uAh */ 91 + } 92 + 93 + /* 94 + * Current and temperature is signed values, so unsigned regs 95 + * value must be converted to signed type 96 + */ 97 + 98 + static inline int max172xx_temperature_to_ps(unsigned int reg) 99 + { 100 + int val = (int16_t)(reg); 101 + 102 + return val * 10 / 256; /* in tenths of deg. C */ 103 + } 104 + 105 + /* 106 + * Calculating current registers resolution: 107 + * 108 + * RSense stored in 10^-5 Ohm, so mesaurment voltage must be 109 + * in 10^-11 Volts for get current in uA. 110 + * 16 bit current reg fullscale +/-51.2mV is 102400 uV. 111 + * So: 102400 / 65535 * 10^5 = 156252 112 + */ 113 + static inline int max172xx_current_to_voltage(unsigned int reg) 114 + { 115 + int val = (int16_t)(reg); 116 + 117 + return val * 156252; 118 + } 119 + 120 + 121 + static inline struct max17211_device_info * 122 + to_device_info(struct power_supply *psy) 123 + { 124 + return power_supply_get_drvdata(psy); 125 + } 126 + 127 + static int max1721x_battery_get_property(struct power_supply *psy, 128 + enum power_supply_property psp, 129 + union power_supply_propval *val) 130 + { 131 + struct max17211_device_info *info = to_device_info(psy); 132 + unsigned int reg = 0; 133 + int ret = 0; 134 + 135 + switch (psp) { 136 + case POWER_SUPPLY_PROP_PRESENT: 137 + /* 138 + * POWER_SUPPLY_PROP_PRESENT will always readable via 139 + * sysfs interface. Value return 0 if battery not 140 + * present or unaccesable via W1. 141 + */ 142 + val->intval = 143 + regmap_read(info->regmap, MAX172XX_REG_STATUS, 144 + &reg) ? 0 : !(reg & MAX172XX_BAT_PRESENT); 145 + break; 146 + case POWER_SUPPLY_PROP_CAPACITY: 147 + ret = regmap_read(info->regmap, MAX172XX_REG_REPSOC, &reg); 148 + val->intval = max172xx_percent_to_ps(reg); 149 + break; 150 + case POWER_SUPPLY_PROP_VOLTAGE_NOW: 151 + ret = regmap_read(info->regmap, MAX172XX_REG_BATT, &reg); 152 + val->intval = max172xx_voltage_to_ps(reg); 153 + break; 154 + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 155 + ret = regmap_read(info->regmap, MAX172XX_REG_DESIGNCAP, &reg); 156 + val->intval = max172xx_capacity_to_ps(reg); 157 + break; 158 + case POWER_SUPPLY_PROP_CHARGE_AVG: 159 + ret = regmap_read(info->regmap, MAX172XX_REG_REPCAP, &reg); 160 + val->intval = max172xx_capacity_to_ps(reg); 161 + break; 162 + case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 163 + ret = regmap_read(info->regmap, MAX172XX_REG_TTE, &reg); 164 + val->intval = max172xx_time_to_ps(reg); 165 + break; 166 + case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 167 + ret = regmap_read(info->regmap, MAX172XX_REG_TTF, &reg); 168 + val->intval = max172xx_time_to_ps(reg); 169 + break; 170 + case POWER_SUPPLY_PROP_TEMP: 171 + ret = regmap_read(info->regmap, MAX172XX_REG_TEMP, &reg); 172 + val->intval = max172xx_temperature_to_ps(reg); 173 + break; 174 + /* We need signed current, so must cast info->rsense to signed type */ 175 + case POWER_SUPPLY_PROP_CURRENT_NOW: 176 + ret = regmap_read(info->regmap, MAX172XX_REG_CURRENT, &reg); 177 + val->intval = 178 + max172xx_current_to_voltage(reg) / (int)info->rsense; 179 + break; 180 + case POWER_SUPPLY_PROP_CURRENT_AVG: 181 + ret = regmap_read(info->regmap, MAX172XX_REG_AVGCURRENT, &reg); 182 + val->intval = 183 + max172xx_current_to_voltage(reg) / (int)info->rsense; 184 + break; 185 + /* 186 + * Strings already received and inited by probe. 187 + * We do dummy read for check battery still available. 188 + */ 189 + case POWER_SUPPLY_PROP_MODEL_NAME: 190 + ret = regmap_read(info->regmap, MAX1721X_REG_DEV_STR, &reg); 191 + val->strval = info->DeviceName; 192 + break; 193 + case POWER_SUPPLY_PROP_MANUFACTURER: 194 + ret = regmap_read(info->regmap, MAX1721X_REG_MFG_STR, &reg); 195 + val->strval = info->ManufacturerName; 196 + break; 197 + case POWER_SUPPLY_PROP_SERIAL_NUMBER: 198 + ret = regmap_read(info->regmap, MAX1721X_REG_SER_HEX, &reg); 199 + val->strval = info->SerialNumber; 200 + break; 201 + default: 202 + ret = -EINVAL; 203 + } 204 + 205 + return ret; 206 + } 207 + 208 + static enum power_supply_property max1721x_battery_props[] = { 209 + /* int */ 210 + POWER_SUPPLY_PROP_PRESENT, 211 + POWER_SUPPLY_PROP_CAPACITY, 212 + POWER_SUPPLY_PROP_VOLTAGE_NOW, 213 + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 214 + POWER_SUPPLY_PROP_CHARGE_AVG, 215 + POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 216 + POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 217 + POWER_SUPPLY_PROP_TEMP, 218 + POWER_SUPPLY_PROP_CURRENT_NOW, 219 + POWER_SUPPLY_PROP_CURRENT_AVG, 220 + /* strings */ 221 + POWER_SUPPLY_PROP_MODEL_NAME, 222 + POWER_SUPPLY_PROP_MANUFACTURER, 223 + POWER_SUPPLY_PROP_SERIAL_NUMBER, 224 + }; 225 + 226 + static int get_string(struct max17211_device_info *info, 227 + uint16_t reg, uint8_t nr, char *str) 228 + { 229 + unsigned int val; 230 + 231 + if (!str || !(reg == MAX1721X_REG_MFG_STR || 232 + reg == MAX1721X_REG_DEV_STR)) 233 + return -EFAULT; 234 + 235 + while (nr--) { 236 + if (regmap_read(info->regmap, reg++, &val)) 237 + return -EFAULT; 238 + *str++ = val>>8 & 0x00FF; 239 + *str++ = val & 0x00FF; 240 + } 241 + return 0; 242 + } 243 + 244 + /* Maxim say: Serial number is a hex string up to 12 hex characters */ 245 + static int get_sn_string(struct max17211_device_info *info, char *str) 246 + { 247 + unsigned int val[3]; 248 + 249 + if (!str) 250 + return -EFAULT; 251 + 252 + if (regmap_read(info->regmap, MAX1721X_REG_SER_HEX, &val[0])) 253 + return -EFAULT; 254 + if (regmap_read(info->regmap, MAX1721X_REG_SER_HEX + 1, &val[1])) 255 + return -EFAULT; 256 + if (regmap_read(info->regmap, MAX1721X_REG_SER_HEX + 2, &val[2])) 257 + return -EFAULT; 258 + 259 + snprintf(str, 13, "%04X%04X%04X", val[0], val[1], val[2]); 260 + return 0; 261 + } 262 + 263 + /* 264 + * MAX1721x registers description for w1-regmap 265 + */ 266 + static const struct regmap_range max1721x_allow_range[] = { 267 + regmap_reg_range(0, 0xDF), /* volatile data */ 268 + regmap_reg_range(0x180, 0x1DF), /* non-volatile memory */ 269 + regmap_reg_range(0x1E0, 0x1EF), /* non-volatile history (unused) */ 270 + }; 271 + 272 + static const struct regmap_range max1721x_deny_range[] = { 273 + /* volatile data unused registers */ 274 + regmap_reg_range(0x24, 0x26), 275 + regmap_reg_range(0x30, 0x31), 276 + regmap_reg_range(0x33, 0x34), 277 + regmap_reg_range(0x37, 0x37), 278 + regmap_reg_range(0x3B, 0x3C), 279 + regmap_reg_range(0x40, 0x41), 280 + regmap_reg_range(0x43, 0x44), 281 + regmap_reg_range(0x47, 0x49), 282 + regmap_reg_range(0x4B, 0x4C), 283 + regmap_reg_range(0x4E, 0xAF), 284 + regmap_reg_range(0xB1, 0xB3), 285 + regmap_reg_range(0xB5, 0xB7), 286 + regmap_reg_range(0xBF, 0xD0), 287 + regmap_reg_range(0xDB, 0xDB), 288 + /* hole between volatile and non-volatile registers */ 289 + regmap_reg_range(0xE0, 0x17F), 290 + }; 291 + 292 + static const struct regmap_access_table max1721x_regs = { 293 + .yes_ranges = max1721x_allow_range, 294 + .n_yes_ranges = ARRAY_SIZE(max1721x_allow_range), 295 + .no_ranges = max1721x_deny_range, 296 + .n_no_ranges = ARRAY_SIZE(max1721x_deny_range), 297 + }; 298 + 299 + /* 300 + * Model Gauge M5 Algorithm output register 301 + * Volatile data (must not be cached) 302 + */ 303 + static const struct regmap_range max1721x_volatile_allow[] = { 304 + regmap_reg_range(0, 0xDF), 305 + }; 306 + 307 + static const struct regmap_access_table max1721x_volatile_regs = { 308 + .yes_ranges = max1721x_volatile_allow, 309 + .n_yes_ranges = ARRAY_SIZE(max1721x_volatile_allow), 310 + }; 311 + 312 + /* 313 + * W1-regmap config 314 + */ 315 + static const struct regmap_config max1721x_regmap_w1_config = { 316 + .reg_bits = 16, 317 + .val_bits = 16, 318 + .rd_table = &max1721x_regs, 319 + .volatile_table = &max1721x_volatile_regs, 320 + .max_register = MAX1721X_MAX_REG_NR, 321 + }; 322 + 323 + static int devm_w1_max1721x_add_device(struct w1_slave *sl) 324 + { 325 + struct power_supply_config psy_cfg = {}; 326 + struct max17211_device_info *info; 327 + 328 + info = devm_kzalloc(&sl->dev, sizeof(*info), GFP_KERNEL); 329 + if (!info) 330 + return -ENOMEM; 331 + 332 + sl->family_data = (void *)info; 333 + info->w1_dev = &sl->dev; 334 + 335 + /* 336 + * power_supply class battery name translated from W1 slave device 337 + * unical ID (look like 26-0123456789AB) to "max1721x-0123456789AB\0" 338 + * so, 26 (device family) correcpondent to max1721x devices. 339 + * Device name still unical for any numbers connected devices. 340 + */ 341 + snprintf(info->name, sizeof(info->name), 342 + "max1721x-%012X", (unsigned int)sl->reg_num.id); 343 + info->bat_desc.name = info->name; 344 + 345 + /* 346 + * FixMe: battery device name exceed max len for thermal_zone device 347 + * name and translation to thermal_zone must be disabled. 348 + */ 349 + info->bat_desc.no_thermal = true; 350 + info->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY; 351 + info->bat_desc.properties = max1721x_battery_props; 352 + info->bat_desc.num_properties = ARRAY_SIZE(max1721x_battery_props); 353 + info->bat_desc.get_property = max1721x_battery_get_property; 354 + psy_cfg.drv_data = info; 355 + 356 + /* regmap init */ 357 + info->regmap = devm_regmap_init_w1(info->w1_dev, 358 + &max1721x_regmap_w1_config); 359 + if (IS_ERR(info->regmap)) { 360 + int err = PTR_ERR(info->regmap); 361 + 362 + dev_err(info->w1_dev, "Failed to allocate register map: %d\n", 363 + err); 364 + return err; 365 + } 366 + 367 + /* rsense init */ 368 + info->rsense = 0; 369 + if (regmap_read(info->regmap, MAX1721X_REG_NRSENSE, &info->rsense)) { 370 + dev_err(info->w1_dev, "Can't read RSense. Hardware error.\n"); 371 + return -ENODEV; 372 + } 373 + 374 + if (!info->rsense) { 375 + dev_warn(info->w1_dev, "RSenese not calibrated, set 10 mOhms!\n"); 376 + info->rsense = 1000; /* in regs in 10^-5 */ 377 + } 378 + dev_info(info->w1_dev, "RSense: %d mOhms.\n", info->rsense / 100); 379 + 380 + if (get_string(info, MAX1721X_REG_MFG_STR, 381 + MAX1721X_REG_MFG_NUMB, info->ManufacturerName)) { 382 + dev_err(info->w1_dev, "Can't read manufacturer. Hardware error.\n"); 383 + return -ENODEV; 384 + } 385 + 386 + if (!info->ManufacturerName[0]) 387 + strncpy(info->ManufacturerName, DEF_MFG_NAME, 388 + 2 * MAX1721X_REG_MFG_NUMB); 389 + 390 + if (get_string(info, MAX1721X_REG_DEV_STR, 391 + MAX1721X_REG_DEV_NUMB, info->DeviceName)) { 392 + dev_err(info->w1_dev, "Can't read device. Hardware error.\n"); 393 + return -ENODEV; 394 + } 395 + if (!info->DeviceName[0]) { 396 + unsigned int dev_name; 397 + 398 + if (regmap_read(info->regmap, 399 + MAX172XX_REG_DEVNAME, &dev_name)) { 400 + dev_err(info->w1_dev, "Can't read device name reg.\n"); 401 + return -ENODEV; 402 + } 403 + 404 + switch (dev_name & MAX172XX_DEV_MASK) { 405 + case MAX172X1_DEV: 406 + strncpy(info->DeviceName, DEF_DEV_NAME_MAX17211, 407 + 2 * MAX1721X_REG_DEV_NUMB); 408 + break; 409 + case MAX172X5_DEV: 410 + strncpy(info->DeviceName, DEF_DEV_NAME_MAX17215, 411 + 2 * MAX1721X_REG_DEV_NUMB); 412 + break; 413 + default: 414 + strncpy(info->DeviceName, DEF_DEV_NAME_UNKNOWN, 415 + 2 * MAX1721X_REG_DEV_NUMB); 416 + } 417 + } 418 + 419 + if (get_sn_string(info, info->SerialNumber)) { 420 + dev_err(info->w1_dev, "Can't read serial. Hardware error.\n"); 421 + return -ENODEV; 422 + } 423 + 424 + info->bat = devm_power_supply_register(&sl->dev, &info->bat_desc, 425 + &psy_cfg); 426 + if (IS_ERR(info->bat)) { 427 + dev_err(info->w1_dev, "failed to register battery\n"); 428 + return PTR_ERR(info->bat); 429 + } 430 + 431 + return 0; 432 + } 433 + 434 + static struct w1_family_ops w1_max1721x_fops = { 435 + .add_slave = devm_w1_max1721x_add_device, 436 + }; 437 + 438 + static struct w1_family w1_max1721x_family = { 439 + .fid = W1_MAX1721X_FAMILY_ID, 440 + .fops = &w1_max1721x_fops, 441 + }; 442 + 443 + module_w1_family(w1_max1721x_family); 444 + 445 + MODULE_LICENSE("GPL"); 446 + MODULE_AUTHOR("Alex A. Mihaylov <minimumlaw@rambler.ru>"); 447 + MODULE_DESCRIPTION("Maxim MAX17211/MAX17215 Fuel Gauage IC driver"); 448 + MODULE_ALIAS("w1-family-" __stringify(W1_MAX1721X_FAMILY_ID));

+2 -2

drivers/power/supply/olpc_battery.c

··· 535 535 return count; 536 536 } 537 537 538 - static struct bin_attribute olpc_bat_eeprom = { 538 + static const struct bin_attribute olpc_bat_eeprom = { 539 539 .attr = { 540 540 .name = "eeprom", 541 541 .mode = S_IRUGO, ··· 559 559 return sprintf(buf, "%d\n", ec_byte); 560 560 } 561 561 562 - static struct device_attribute olpc_bat_error = { 562 + static const struct device_attribute olpc_bat_error = { 563 563 .attr = { 564 564 .name = "error", 565 565 .mode = S_IRUGO,

+1 -1

drivers/power/supply/pcf50633-charger.c

··· 254 254 NULL, 255 255 }; 256 256 257 - static struct attribute_group mbc_attr_group = { 257 + static const struct attribute_group mbc_attr_group = { 258 258 .name = NULL, /* put in device directory */ 259 259 .attrs = pcf50633_mbc_sysfs_entries, 260 260 };

+46 -8

drivers/power/supply/power_supply_core.c

··· 259 259 /* All supplies found, allocate char ** array for filling */ 260 260 psy->supplied_from = devm_kzalloc(&psy->dev, sizeof(psy->supplied_from), 261 261 GFP_KERNEL); 262 - if (!psy->supplied_from) { 263 - dev_err(&psy->dev, "Couldn't allocate memory for supply list\n"); 262 + if (!psy->supplied_from) 264 263 return -ENOMEM; 265 - } 266 264 267 265 *psy->supplied_from = devm_kzalloc(&psy->dev, 268 266 sizeof(char *) * (cnt - 1), 269 267 GFP_KERNEL); 270 - if (!*psy->supplied_from) { 271 - dev_err(&psy->dev, "Couldn't allocate memory for supply list\n"); 268 + if (!*psy->supplied_from) 272 269 return -ENOMEM; 273 - } 274 270 275 271 return power_supply_populate_supplied_from(psy); 276 272 } ··· 310 314 struct power_supply *epsy = dev_get_drvdata(dev); 311 315 struct psy_am_i_supplied_data *data = _data; 312 316 313 - data->count++; 314 - if (__power_supply_is_supplied_by(epsy, data->psy)) 317 + if (__power_supply_is_supplied_by(epsy, data->psy)) { 318 + data->count++; 315 319 if (!epsy->desc->get_property(epsy, POWER_SUPPLY_PROP_ONLINE, 316 320 &ret)) 317 321 return ret.intval; 322 + } 318 323 319 324 return 0; 320 325 } ··· 370 373 return error; 371 374 } 372 375 EXPORT_SYMBOL_GPL(power_supply_is_system_supplied); 376 + 377 + static int __power_supply_get_supplier_max_current(struct device *dev, 378 + void *data) 379 + { 380 + union power_supply_propval ret = {0,}; 381 + struct power_supply *epsy = dev_get_drvdata(dev); 382 + struct power_supply *psy = data; 383 + 384 + if (__power_supply_is_supplied_by(epsy, psy)) 385 + if (!epsy->desc->get_property(epsy, 386 + POWER_SUPPLY_PROP_CURRENT_MAX, 387 + &ret)) 388 + return ret.intval; 389 + 390 + return 0; 391 + } 392 + 393 + int power_supply_set_input_current_limit_from_supplier(struct power_supply *psy) 394 + { 395 + union power_supply_propval val = {0,}; 396 + int curr; 397 + 398 + if (!psy->desc->set_property) 399 + return -EINVAL; 400 + 401 + /* 402 + * This function is not intended for use with a supply with multiple 403 + * suppliers, we simply pick the first supply to report a non 0 404 + * max-current. 405 + */ 406 + curr = class_for_each_device(power_supply_class, NULL, psy, 407 + __power_supply_get_supplier_max_current); 408 + if (curr <= 0) 409 + return (curr == 0) ? -ENODEV : curr; 410 + 411 + val.intval = curr; 412 + 413 + return psy->desc->set_property(psy, 414 + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, &val); 415 + } 416 + EXPORT_SYMBOL_GPL(power_supply_set_input_current_limit_from_supplier); 373 417 374 418 int power_supply_set_battery_charged(struct power_supply *psy) 375 419 {

+13 -15

drivers/power/supply/sbs-battery.c

··· 12 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 14 * more details. 15 - * 16 - * You should have received a copy of the GNU General Public License along 17 - * with this program; if not, write to the Free Software Foundation, Inc., 18 - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 19 15 */ 20 16 21 - #include <linux/init.h> 22 - #include <linux/module.h> 23 - #include <linux/kernel.h> 17 + #include <linux/delay.h> 24 18 #include <linux/err.h> 25 - #include <linux/power_supply.h> 26 - #include <linux/i2c.h> 27 - #include <linux/slab.h> 28 - #include <linux/interrupt.h> 29 19 #include <linux/gpio/consumer.h> 20 + #include <linux/i2c.h> 21 + #include <linux/init.h> 22 + #include <linux/interrupt.h> 23 + #include <linux/kernel.h> 24 + #include <linux/module.h> 30 25 #include <linux/of.h> 31 - #include <linux/stat.h> 32 - 33 26 #include <linux/power/sbs-battery.h> 27 + #include <linux/power_supply.h> 28 + #include <linux/slab.h> 29 + #include <linux/stat.h> 34 30 35 31 enum { 36 32 REG_MANUFACTURER_DATA, ··· 56 60 #define BATTERY_MODE_OFFSET 0x03 57 61 #define BATTERY_MODE_MASK 0x8000 58 62 enum sbs_battery_mode { 59 - BATTERY_MODE_AMPS, 60 - BATTERY_MODE_WATTS 63 + BATTERY_MODE_AMPS = 0, 64 + BATTERY_MODE_WATTS = 0x8000 61 65 }; 62 66 63 67 /* manufacturer access defines */ ··· 527 531 ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret); 528 532 if (ret < 0) 529 533 return ret; 534 + 535 + usleep_range(1000, 2000); 530 536 531 537 return original_val & BATTERY_MODE_MASK; 532 538 }

-6

drivers/w1/slaves/Kconfig

··· 148 148 149 149 If you are unsure, say N. 150 150 151 - config W1_SLAVE_BQ27000 152 - tristate "BQ27000 slave support" 153 - help 154 - Say Y here if you want to use a hdq 155 - bq27000 slave support. 156 - 157 151 endmenu

-1

drivers/w1/slaves/Makefile

··· 16 16 obj-$(CONFIG_W1_SLAVE_DS2760) += w1_ds2760.o 17 17 obj-$(CONFIG_W1_SLAVE_DS2780) += w1_ds2780.o 18 18 obj-$(CONFIG_W1_SLAVE_DS2781) += w1_ds2781.o 19 - obj-$(CONFIG_W1_SLAVE_BQ27000) += w1_bq27000.o 20 19 obj-$(CONFIG_W1_SLAVE_DS28E04) += w1_ds28e04.o

-117

drivers/w1/slaves/w1_bq27000.c

··· 1 - /* 2 - * drivers/w1/slaves/w1_bq27000.c 3 - * 4 - * Copyright (C) 2007 Texas Instruments, Inc. 5 - * 6 - * This file is licensed under the terms of the GNU General Public License 7 - * version 2. This program is licensed "as is" without any warranty of any 8 - * kind, whether express or implied. 9 - * 10 - */ 11 - 12 - #include <linux/kernel.h> 13 - #include <linux/module.h> 14 - #include <linux/device.h> 15 - #include <linux/types.h> 16 - #include <linux/platform_device.h> 17 - #include <linux/mutex.h> 18 - #include <linux/power/bq27xxx_battery.h> 19 - 20 - #include <linux/w1.h> 21 - 22 - #define W1_FAMILY_BQ27000 0x01 23 - 24 - #define HDQ_CMD_READ (0) 25 - #define HDQ_CMD_WRITE (1<<7) 26 - 27 - static int F_ID; 28 - module_param(F_ID, int, S_IRUSR); 29 - MODULE_PARM_DESC(F_ID, "1-wire slave FID for BQ device"); 30 - 31 - static int w1_bq27000_read(struct device *dev, unsigned int reg) 32 - { 33 - u8 val; 34 - struct w1_slave *sl = container_of(dev->parent, struct w1_slave, dev); 35 - 36 - mutex_lock(&sl->master->bus_mutex); 37 - w1_write_8(sl->master, HDQ_CMD_READ | reg); 38 - val = w1_read_8(sl->master); 39 - mutex_unlock(&sl->master->bus_mutex); 40 - 41 - return val; 42 - } 43 - 44 - static struct bq27xxx_platform_data bq27000_battery_info = { 45 - .read = w1_bq27000_read, 46 - .name = "bq27000-battery", 47 - .chip = BQ27000, 48 - }; 49 - 50 - static int w1_bq27000_add_slave(struct w1_slave *sl) 51 - { 52 - int ret; 53 - struct platform_device *pdev; 54 - 55 - pdev = platform_device_alloc("bq27000-battery", -1); 56 - if (!pdev) { 57 - ret = -ENOMEM; 58 - return ret; 59 - } 60 - ret = platform_device_add_data(pdev, 61 - &bq27000_battery_info, 62 - sizeof(bq27000_battery_info)); 63 - if (ret) 64 - goto pdev_add_failed; 65 - pdev->dev.parent = &sl->dev; 66 - 67 - ret = platform_device_add(pdev); 68 - if (ret) 69 - goto pdev_add_failed; 70 - 71 - dev_set_drvdata(&sl->dev, pdev); 72 - 73 - goto success; 74 - 75 - pdev_add_failed: 76 - platform_device_put(pdev); 77 - success: 78 - return ret; 79 - } 80 - 81 - static void w1_bq27000_remove_slave(struct w1_slave *sl) 82 - { 83 - struct platform_device *pdev = dev_get_drvdata(&sl->dev); 84 - 85 - platform_device_unregister(pdev); 86 - } 87 - 88 - static struct w1_family_ops w1_bq27000_fops = { 89 - .add_slave = w1_bq27000_add_slave, 90 - .remove_slave = w1_bq27000_remove_slave, 91 - }; 92 - 93 - static struct w1_family w1_bq27000_family = { 94 - .fid = W1_FAMILY_BQ27000, 95 - .fops = &w1_bq27000_fops, 96 - }; 97 - 98 - static int __init w1_bq27000_init(void) 99 - { 100 - if (F_ID) 101 - w1_bq27000_family.fid = F_ID; 102 - 103 - return w1_register_family(&w1_bq27000_family); 104 - } 105 - 106 - static void __exit w1_bq27000_exit(void) 107 - { 108 - w1_unregister_family(&w1_bq27000_family); 109 - } 110 - 111 - module_init(w1_bq27000_init); 112 - module_exit(w1_bq27000_exit); 113 - 114 - MODULE_AUTHOR("Texas Instruments Ltd"); 115 - MODULE_DESCRIPTION("HDQ/1-wire slave driver bq27000 battery monitor chip"); 116 - MODULE_LICENSE("GPL"); 117 - MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_BQ27000));

+18

include/linux/power/bq24190_charger.h

··· 1 + /* 2 + * Platform data for the TI bq24190 battery charger driver. 3 + * 4 + * This program is free software; you can redistribute it and/or modify 5 + * it under the terms of the GNU General Public License version 2 as 6 + * published by the Free Software Foundation. 7 + */ 8 + 9 + #ifndef _BQ24190_CHARGER_H_ 10 + #define _BQ24190_CHARGER_H_ 11 + 12 + #include <linux/regulator/machine.h> 13 + 14 + struct bq24190_platform_data { 15 + const struct regulator_init_data *regulator_init_data; 16 + }; 17 + 18 + #endif

+9 -18

include/linux/power/bq27xxx_battery.h

··· 6 6 BQ27010, /* bq27010, bq27210 */ 7 7 BQ2750X, /* bq27500 deprecated alias */ 8 8 BQ2751X, /* bq27510, bq27520 deprecated alias */ 9 + BQ2752X, 9 10 BQ27500, /* bq27500/1 */ 10 11 BQ27510G1, /* bq27510G1 */ 11 12 BQ27510G2, /* bq27510G2 */ ··· 16 15 BQ27520G3, /* bq27520G3 */ 17 16 BQ27520G4, /* bq27520G4 */ 18 17 BQ27530, /* bq27530, bq27531 */ 18 + BQ27531, 19 19 BQ27541, /* bq27541, bq27542, bq27546, bq27742 */ 20 + BQ27542, 21 + BQ27546, 22 + BQ27742, 20 23 BQ27545, /* bq27545 */ 21 24 BQ27421, /* bq27421, bq27425, bq27441, bq27621 */ 22 - }; 23 - 24 - /** 25 - * struct bq27xxx_plaform_data - Platform data for bq27xxx devices 26 - * @name: Name of the battery. 27 - * @chip: Chip class number of this device. 28 - * @read: HDQ read callback. 29 - * This function should provide access to the HDQ bus the battery is 30 - * connected to. 31 - * The first parameter is a pointer to the battery device, the second the 32 - * register to be read. The return value should either be the content of 33 - * the passed register or an error value. 34 - */ 35 - struct bq27xxx_platform_data { 36 - const char *name; 37 - enum bq27xxx_chip chip; 38 - int (*read)(struct device *dev, unsigned int); 25 + BQ27425, 26 + BQ27441, 27 + BQ27621, 39 28 }; 40 29 41 30 struct bq27xxx_device_info; ··· 54 63 struct device *dev; 55 64 int id; 56 65 enum bq27xxx_chip chip; 57 - bool ram_chip; 66 + u32 opts; 58 67 const char *name; 59 68 struct bq27xxx_dm_reg *dm_regs; 60 69 u32 unseal_key;

+2

include/linux/power_supply.h

··· 332 332 struct power_supply_battery_info *info); 333 333 extern void power_supply_changed(struct power_supply *psy); 334 334 extern int power_supply_am_i_supplied(struct power_supply *psy); 335 + extern int power_supply_set_input_current_limit_from_supplier( 336 + struct power_supply *psy); 335 337 extern int power_supply_set_battery_charged(struct power_supply *psy); 336 338 337 339 #ifdef CONFIG_POWER_SUPPLY

Configure Feed

Configure Feed