# \[PATCH v8 00/14\] power: bq24257: Add support for bq24250/bq24251 - Subsystems: POWER SUPPLY CLASS/SUBSYSTEM and DRIVERS, THE REST - Maintainers: Sebastian Reichel, Linus Torvalds - Series: 5 patches touching 3 files, +260/-20 - Status: PENDING ยท 3 of 14 reviewed - Pending, 3 of 14 reviewed. - Revision v8 (6 revisions archived). - List: linux-api - 8 messages, 2 authors - Page: https://ratatoskr.run/linux-api/2015/09/8112965/t ## \[PATCH v8 00/14\] power: bq24257: Add support for bq24250/bq24251 - From: Andreas Dannenberg \ - Date: 2015-09-28 22:33:48 - Message: https://ratatoskr.run/linux-api/2015/09/8112965.md ```text This patch series extends the driver to also support bq24250/bq24251. The bq24250/251/257 devices have a very similar feature set and are virtually identical from a control register point of view so it made sense to extend the existing driver rather than submitting a new driver. In addition to the new device support the driver is also extended to allow access to some device features previously hidden. Basic and potentially dangerous charger config parameters affecting the actual charging of the Li-Ion battery are only configurable through firmware rather than sysfs properties. However some newly introduced properties are exposed through sysfs properties as access to them may be desired from userspace. For example, it is now possible to manually configure the maximum current drawn from the input source to accommodate different chargers (0.5A, 1.5A, 2.0A and so on) based on system knowledge a userspace application may have rather than rely on the auto-detection mechanism that may not work in all possible scenarios. Note that most patches have dependencies on other patches in the series. v8: - Rebased onto Sebastian's "next" tree and dropped the "power: bq24257: Remove IRQ config through stat-gpios" patch from the series as it's already present - Reworded ti,current-limit DT doc description - Removed linux/gpio.h include from the platform data patch - Successfully re-tested the patch that implements the use of the managed power supply register functions regarding possible side effects and updated the patch's comment for better clarity. Also updated the description of that patch to explain the "why". - Added handling of -EPROBE_DEFER during GPIO pin probe. This error now leads to an abort of the driver probe and the Kernel will re-try to probe the driver later (successfully tested). - Added some of the previous Reviewed-by's from Laurentiu and Krzysztof (only if there were trivial changes stemming from the discussions or no changes at all) v7: - Fixed an issue that would have impacted running bisect on the series and double checked the entire series builds one by one by running a git rebase -i --exec="make ..." ... on the Kernel tree - Minor simplification of a return from a function v6: - Removed the ability to configure the IRQ through "stat-gpios" - Allow re-configuring the input_current_limit via sysfs also when charger auto-detection is enabled - Use gpiod interface for initialization as a platform device (nice GPIO setup simplification) - Document all newly introduced sysfs nodes - Streamlined/fixed/simplified charger state handling as it relates to battery removal/insertion and the associated handling of the input current limit setting - Minor simplifications/cleanup - Rebased onto git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux- power-supply.git (branch "next") and completely retested v5: - Added patch to use the managed version of power supply register which also fixes a code flow issue that was introduced - Minor fixes / consistency cleanup (Krzysztof's feedback) v4: - Removed configurability of the safety timer multiplier through DT v3: - Dropped the driver/symbol rename patch from v2 due to anticipated issues with upcoming bq2425x family additions - Reverted additional mutex coverage for I2C access due to regmap built-in mutex protection being sufficient - Removed support for trickle charging due to being a rare/uncommon use case - Fixed most checkpatch.pl --strict alignment issues (except where the line length would exceed 80 chars) - Fixed an issue with how the return value of gpio_to_desc() was handled - Fixed an issue with the definition of bq24257_of_match[] - Reordered the patch series to put the DT doc changes to the beginning v2: - Aligned DT bindings better with existing "ti,*" charger bindings - Dropped patch that improperly reported a missing battery as a dead battery - Fixed (hopefully, that is -- still waiting for my test platform) issue with how the private ACPI driver_data used to identify which bq2425x device to use - Removed boolean DT/ACPI properties mostly by replacing them with more intelligent handling in the driver - Rework/clarification of DT bindings doc - Renamed/refactored filenames/symbols from bq24257 to bq2425x to better reflect that multiple devices are covered. Despite initial hesitation I feel this is a good opportunity for some clean-up as the driver is still very new in the Kernel so the change should be low risk. This also addresses one of Andrew Davis' feedback items. Plus, it makes for a nice alignment with the existing bq2415x_charger driver. v1: - Initial submission Andreas Dannenberg (14): dt: power: bq24257-charger: Cover additional devices power: bq24257: Streamline input current limit setup power: bq24257: Use managed power supply register power: bq24257: Simplify bq24257_power_supply_init() power: bq24257: Add basic support for bq24250/bq24251 power: bq24257: Add bit definition for temp sense enable power: bq24257: Allow manual setting of input current limit power: bq24257: Add SW-based approach for Power Good determination power: bq24257: Add over voltage protection setting support power: bq24257: Add input DPM voltage threshold setting support power: bq24257: Allow input current limit sysfs access power: bq24257: Add various device-specific sysfs properties power: bq24257: Add platform data based initialization Documentation: power: bq24257: Document exported sysfs entries Documentation/ABI/testing/sysfs-class-power | 58 +++ .../devicetree/bindings/power/bq24257.txt | 53 ++- drivers/power/Kconfig | 5 +- drivers/power/bq24257_charger.c | 506 ++++++++++++++++++--- include/linux/power/bq24257_charger.h | 25 + 5 files changed, 583 insertions(+), 64 deletions(-) create mode 100644 include/linux/power/bq24257_charger.h -- 1.9.1 ``` ## \[PATCH v8 03/14\] power: bq24257: Use managed power supply register - From: Andreas Dannenberg \ - Date: 2015-09-28 22:33:51 - Message: https://ratatoskr.run/linux-api/2015/09/8112961.md ```text Use the devm_* managed version of the function to register the power supply and remove the associated unregister function. This will simplify error handling moving forward as it allows the unregister to happen automatically. It also saves a few lines of code. As this changes the order of putting the bq24257 into reset vs. unregistering the power-supply during driver remove re-tested various driver unload scenario to make sure that this doesn't cause any unintended side effects such as erroneous interrupts. Signed-off-by: Andreas Dannenberg Reviewed-by: Krzysztof Kozlowski --- drivers/power/bq24257_charger.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/drivers/power/bq24257_charger.c b/drivers/power/bq24257_charger.c index d2d077c..6757b41 100644 --- a/drivers/power/bq24257_charger.c +++ b/drivers/power/bq24257_charger.c @@ -590,8 +590,10 @@ static int bq24257_power_supply_init(struct bq24257_device *bq) psy_cfg.supplied_to = bq24257_charger_supplied_to; psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to); - bq->charger = power_supply_register(bq->dev, &bq24257_power_supply_desc, - &psy_cfg); + bq->charger = devm_power_supply_register(bq->dev, + &bq24257_power_supply_desc, + &psy_cfg); + if (IS_ERR(bq->charger)) return PTR_ERR(bq->charger); @@ -742,8 +744,6 @@ static int bq24257_remove(struct i2c_client *client) cancel_delayed_work_sync(&bq->iilimit_setup_work); - power_supply_unregister(bq->charger); - bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */ return 0; -- 1.9.1 ``` ## \[PATCH v8 05/14\] power: bq24257: Add basic support for bq24250/bq24251 - From: Andreas Dannenberg \ - Date: 2015-09-28 22:33:53 - Message: https://ratatoskr.run/linux-api/2015/09/8112971.md ```text This patch adds basic support for bq24250 and bq24251 which are very similar to the bq24257 the driver was originally written for. Basic support means the ability to select a device through Kconfig, DT and ACPI, an instance variable allowing to check which chip is active, and the reporting back of the selected device through the model_name power supply sysfs property. This patch by itself is not sufficient to actually use those two added devices in a real-world setting due to some feature differences which are addressed by other patches in this series. Signed-off-by: Andreas Dannenberg Reviewed-by: Krzysztof Kozlowski --- drivers/power/Kconfig | 5 ++-- drivers/power/bq24257_charger.c | 52 ++++++++++++++++++++++++++++++++++++++--- 2 files changed, 52 insertions(+), 5 deletions(-) diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig index eeb5776..9e68853 100644 --- a/drivers/power/Kconfig +++ b/drivers/power/Kconfig @@ -409,12 +409,13 @@ config CHARGER_BQ24190 Say Y to enable support for the TI BQ24190 battery charger. config CHARGER_BQ24257 - tristate "TI BQ24257 battery charger driver" + tristate "TI BQ24250/24251/24257 battery charger driver" depends on I2C depends on GPIOLIB || COMPILE_TEST depends on REGMAP_I2C help - Say Y to enable support for the TI BQ24257 battery charger. + Say Y to enable support for the TI BQ24250, BQ24251, and BQ24257 battery + chargers. config CHARGER_BQ24735 tristate "TI BQ24735 battery charger support" diff --git a/drivers/power/bq24257_charger.c b/drivers/power/bq24257_charger.c index 060f754..b0c8533 100644 --- a/drivers/power/bq24257_charger.c +++ b/drivers/power/bq24257_charger.c @@ -13,6 +13,10 @@ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * + * Datasheets: + * http://www.ti.com/product/bq24250 + * http://www.ti.com/product/bq24251 + * http://www.ti.com/product/bq24257 */ #include @@ -40,6 +44,22 @@ #define BQ24257_ILIM_SET_DELAY 1000 /* msec */ +/* + * When adding support for new devices make sure that enum bq2425x_chip and + * bq2425x_chip_name[] always stay in sync! + */ +enum bq2425x_chip { + BQ24250, + BQ24251, + BQ24257, +}; + +static const char *const bq2425x_chip_name[] = { + "bq24250", + "bq24251", + "bq24257", +}; + enum bq24257_fields { F_WD_FAULT, F_WD_EN, F_STAT, F_FAULT, /* REG 1 */ F_RESET, F_IILIMIT, F_EN_STAT, F_EN_TERM, F_CE, F_HZ_MODE, /* REG 2 */ @@ -70,6 +90,8 @@ struct bq24257_device { struct device *dev; struct power_supply *charger; + enum bq2425x_chip chip; + struct regmap *rmap; struct regmap_field *rmap_fields[F_MAX_FIELDS]; @@ -248,6 +270,10 @@ static int bq24257_power_supply_get_property(struct power_supply *psy, val->strval = BQ24257_MANUFACTURER; break; + case POWER_SUPPLY_PROP_MODEL_NAME: + val->strval = bq2425x_chip_name[bq->chip]; + break; + case POWER_SUPPLY_PROP_ONLINE: val->intval = state.power_good; break; @@ -561,6 +587,7 @@ static int bq24257_hw_init(struct bq24257_device *bq) static enum power_supply_property bq24257_power_supply_props[] = { POWER_SUPPLY_PROP_MANUFACTURER, + POWER_SUPPLY_PROP_MODEL_NAME, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_HEALTH, @@ -644,6 +671,7 @@ static int bq24257_probe(struct i2c_client *client, { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct device *dev = &client->dev; + const struct acpi_device_id *acpi_id; struct bq24257_device *bq; int ret; int i; @@ -660,6 +688,18 @@ static int bq24257_probe(struct i2c_client *client, bq->client = client; bq->dev = dev; + if (ACPI_HANDLE(dev)) { + acpi_id = acpi_match_device(dev->driver->acpi_match_table, + &client->dev); + if (!acpi_id) { + dev_err(dev, "Failed to match ACPI device\n"); + return -ENODEV; + } + bq->chip = (enum bq2425x_chip)acpi_id->driver_data; + } else { + bq->chip = (enum bq2425x_chip)id->driver_data; + } + mutex_init(&bq->lock); bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config); @@ -722,7 +762,7 @@ static int bq24257_probe(struct i2c_client *client, bq24257_irq_handler_thread, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, - "bq24257", bq); + bq2425x_chip_name[bq->chip], bq); if (ret) { dev_err(dev, "Failed to request IRQ #%d\n", client->irq); return ret; @@ -793,19 +833,25 @@ static const struct dev_pm_ops bq24257_pm = { }; static const struct i2c_device_id bq24257_i2c_ids[] = { - { "bq24257", 0 }, + { "bq24250", BQ24250 }, + { "bq24251", BQ24251 }, + { "bq24257", BQ24257 }, {}, }; MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids); static const struct of_device_id bq24257_of_match[] = { + { .compatible = "ti,bq24250", }, + { .compatible = "ti,bq24251", }, { .compatible = "ti,bq24257", }, { }, }; MODULE_DEVICE_TABLE(of, bq24257_of_match); static const struct acpi_device_id bq24257_acpi_match[] = { - {"BQ242570", 0}, + { "BQ242500", BQ24250 }, + { "BQ242510", BQ24251 }, + { "BQ242570", BQ24257 }, {}, }; MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match); -- 1.9.1 ``` ## \[PATCH v8 09/14\] power: bq24257: Add over voltage protection setting support - From: Andreas Dannenberg \ - Date: 2015-09-28 22:33:57 - Message: https://ratatoskr.run/linux-api/2015/09/8112968.md ```text A new optional device property called "ti,ovp-voltage" is introduced to allow configuring the input over voltage protection setting. This commit also adds the basic sysfs support for custom properties which is being used to allow userspace to read the current ovp-voltage setting. Signed-off-by: Andreas Dannenberg Reviewed-by: Laurentiu Palcu --- drivers/power/bq24257_charger.c | 67 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 64 insertions(+), 3 deletions(-) diff --git a/drivers/power/bq24257_charger.c b/drivers/power/bq24257_charger.c index 15e0e93..b617c3a 100644 --- a/drivers/power/bq24257_charger.c +++ b/drivers/power/bq24257_charger.c @@ -78,6 +78,7 @@ struct bq24257_init_data { u8 vbat; /* regulation voltage */ u8 iterm; /* termination current */ u8 iilimit; /* input current limit */ + u8 vovp; /* over voltage protection voltage */ }; struct bq24257_state { @@ -200,6 +201,13 @@ static const u32 bq24257_iilimit_map[] = { #define BQ24257_IILIMIT_MAP_SIZE ARRAY_SIZE(bq24257_iilimit_map) +static const u32 bq24257_vovp_map[] = { + 6000000, 6500000, 7000000, 8000000, 9000000, 9500000, 10000000, + 10500000 +}; + +#define BQ24257_VOVP_MAP_SIZE ARRAY_SIZE(bq24257_vovp_map) + static int bq24257_field_read(struct bq24257_device *bq, enum bq24257_fields field_id) { @@ -415,6 +423,17 @@ enum bq24257_in_ilimit { IILIMIT_NONE, }; +enum bq24257_vovp { + VOVP_6000, + VOVP_6500, + VOVP_7000, + VOVP_8000, + VOVP_9000, + VOVP_9500, + VOVP_10000, + VOVP_10500 +}; + enum bq24257_port_type { PORT_TYPE_DCP, /* Dedicated Charging Port */ PORT_TYPE_CDP, /* Charging Downstream Port */ @@ -586,7 +605,8 @@ static int bq24257_hw_init(struct bq24257_device *bq) } init_data[] = { {F_ICHG, bq->init_data.ichg}, {F_VBAT, bq->init_data.vbat}, - {F_ITERM, bq->init_data.iterm} + {F_ITERM, bq->init_data.iterm}, + {F_VOVP, bq->init_data.vovp}, }; /* @@ -656,6 +676,28 @@ static const struct power_supply_desc bq24257_power_supply_desc = { .get_property = bq24257_power_supply_get_property, }; +static ssize_t bq24257_show_ovp_voltage(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct power_supply *psy = dev_get_drvdata(dev); + struct bq24257_device *bq = power_supply_get_drvdata(psy); + + return scnprintf(buf, PAGE_SIZE, "%u\n", + bq24257_vovp_map[bq->init_data.vovp]); +} + +static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq24257_show_ovp_voltage, NULL); + +static struct attribute *bq24257_charger_attr[] = { + &dev_attr_ovp_voltage.attr, + NULL, +}; + +static const struct attribute_group bq24257_attr_group = { + .attrs = bq24257_charger_attr, +}; + static int bq24257_power_supply_init(struct bq24257_device *bq) { struct power_supply_config psy_cfg = { .drv_data = bq, }; @@ -734,6 +776,15 @@ static int bq24257_fw_probe(struct bq24257_device *bq) bq24257_iilimit_map, BQ24257_IILIMIT_MAP_SIZE); + ret = device_property_read_u32(bq->dev, "ti,ovp-voltage", + &property); + if (ret < 0) + bq->init_data.vovp = VOVP_6500; + else + bq->init_data.vovp = bq24257_find_idx(property, + bq24257_vovp_map, + BQ24257_VOVP_MAP_SIZE); + return 0; } @@ -859,10 +910,18 @@ static int bq24257_probe(struct i2c_client *client, } ret = bq24257_power_supply_init(bq); - if (ret < 0) + if (ret < 0) { dev_err(dev, "Failed to register power supply\n"); + return ret; + } - return ret; + ret = sysfs_create_group(&bq->charger->dev.kobj, &bq24257_attr_group); + if (ret < 0) { + dev_err(dev, "Can't create sysfs entries\n"); + return ret; + } + + return 0; } static int bq24257_remove(struct i2c_client *client) @@ -872,6 +931,8 @@ static int bq24257_remove(struct i2c_client *client) if (bq->iilimit_autoset_enable) cancel_delayed_work_sync(&bq->iilimit_setup_work); + sysfs_remove_group(&bq->charger->dev.kobj, &bq24257_attr_group); + bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */ return 0; -- 1.9.1 ``` ## \[PATCH v8 11/14\] power: bq24257: Allow input current limit sysfs access - From: Andreas Dannenberg \ - Date: 2015-09-28 22:33:59 - Message: https://ratatoskr.run/linux-api/2015/09/8112969.md ```text This patch allows reading and writing of the input current limit through the power supply's input_current_limit sysfs property. This allows userspace to see what charger was detected (if the D+/D- USB signal- based charger type detection is enabled) and to re-configure the maximum current drawn from the external supply at runtime based on system-level knowledge or user input. Note that upon charger disconnection and re-connection the limit configured through firmware becomes active again (or the D+/D- USB signal-based charger detection will be run again). Signed-off-by: Andreas Dannenberg --- drivers/power/bq24257_charger.c | 85 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 79 insertions(+), 6 deletions(-) diff --git a/drivers/power/bq24257_charger.c b/drivers/power/bq24257_charger.c index ebb22f3..db719bf 100644 --- a/drivers/power/bq24257_charger.c +++ b/drivers/power/bq24257_charger.c @@ -267,6 +267,47 @@ enum bq24257_fault { FAULT_INPUT_LDO_LOW, }; +static int bq24257_get_input_current_limit(struct bq24257_device *bq, + union power_supply_propval *val) +{ + int ret; + + ret = bq24257_field_read(bq, F_IILIMIT); + if (ret < 0) + return ret; + + /* + * The "External ILIM" and "Production & Test" modes are not exposed + * through this driver and not being covered by the lookup table. + * Should such a mode have become active let's return an error rather + * than exceeding the bounds of the lookup table and returning + * garbage. + */ + if (ret >= BQ24257_IILIMIT_MAP_SIZE) + return -ENODATA; + + val->intval = bq24257_iilimit_map[ret]; + + return 0; +} + +static int bq24257_set_input_current_limit(struct bq24257_device *bq, + const union power_supply_propval *val) +{ + /* + * Address the case where the user manually sets an input current limit + * while the charger auto-detection mechanism is is active. In this + * case we want to abort and go straight to the user-specified value. + */ + if (bq->iilimit_autoset_enable) + cancel_delayed_work_sync(&bq->iilimit_setup_work); + + return bq24257_field_write(bq, F_IILIMIT, + bq24257_find_idx(val->intval, + bq24257_iilimit_map, + BQ24257_IILIMIT_MAP_SIZE)); +} + static int bq24257_power_supply_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) @@ -351,6 +392,9 @@ static int bq24257_power_supply_get_property(struct power_supply *psy, val->intval = bq24257_iterm_map[bq->init_data.iterm]; break; + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: + return bq24257_get_input_current_limit(bq, val); + default: return -EINVAL; } @@ -358,6 +402,31 @@ static int bq24257_power_supply_get_property(struct power_supply *psy, return 0; } +static int bq24257_power_supply_set_property(struct power_supply *psy, + enum power_supply_property prop, + const union power_supply_propval *val) +{ + struct bq24257_device *bq = power_supply_get_drvdata(psy); + + switch (prop) { + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: + return bq24257_set_input_current_limit(bq, val); + default: + return -EINVAL; + } +} + +static int bq24257_power_supply_property_is_writeable(struct power_supply *psy, + enum power_supply_property psp) +{ + switch (psp) { + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: + return true; + default: + return false; + } +} + static int bq24257_get_chip_state(struct bq24257_device *bq, struct bq24257_state *state) { @@ -559,13 +628,14 @@ static void bq24257_handle_state_change(struct bq24257_device *bq, ret = bq24257_field_write(bq, F_DPDM_EN, 1); if (ret < 0) goto error; - - /* reset input current limit */ - ret = bq24257_field_write(bq, F_IILIMIT, - bq->init_data.iilimit); - if (ret < 0) - goto error; } + /* + * When power is removed always return to the default input + * current limit as configured during probe. + */ + ret = bq24257_field_write(bq, F_IILIMIT, bq->init_data.iilimit); + if (ret < 0) + goto error; } else if (!old_state.power_good) { dev_dbg(bq->dev, "Power inserted\n"); @@ -682,6 +752,7 @@ static enum power_supply_property bq24257_power_supply_props[] = { POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, }; static char *bq24257_charger_supplied_to[] = { @@ -694,6 +765,8 @@ static const struct power_supply_desc bq24257_power_supply_desc = { .properties = bq24257_power_supply_props, .num_properties = ARRAY_SIZE(bq24257_power_supply_props), .get_property = bq24257_power_supply_get_property, + .set_property = bq24257_power_supply_set_property, + .property_is_writeable = bq24257_power_supply_property_is_writeable, }; static ssize_t bq24257_show_ovp_voltage(struct device *dev, -- 1.9.1 ``` ## \[PATCH v8 13/14\] power: bq24257: Add platform data based initialization - From: Andreas Dannenberg \ - Date: 2015-09-28 22:34:01 - Message: https://ratatoskr.run/linux-api/2015/09/8112975.md ```text The patch adds a way to setup and initialize the device through the use of platform data with configuration options equivalent to when using device firmware (DT or ACPI) for systems where this is not available. Signed-off-by: Andreas Dannenberg --- drivers/power/bq24257_charger.c | 38 +++++++++++++++++++++++++++++++++-- include/linux/power/bq24257_charger.h | 25 +++++++++++++++++++++++ 2 files changed, 61 insertions(+), 2 deletions(-) create mode 100644 include/linux/power/bq24257_charger.h diff --git a/drivers/power/bq24257_charger.c b/drivers/power/bq24257_charger.c index 1fea2c7..c59c22b 100644 --- a/drivers/power/bq24257_charger.c +++ b/drivers/power/bq24257_charger.c @@ -31,6 +31,8 @@ #include #include +#include + #define BQ24257_REG_1 0x00 #define BQ24257_REG_2 0x01 #define BQ24257_REG_3 0x02 @@ -888,6 +890,36 @@ static void bq24257_pg_gpio_probe(struct bq24257_device *bq) dev_dbg(bq->dev, "probed PG pin = %d\n", desc_to_gpio(bq->pg)); } +static void bq24257_pdata_probe(struct bq24257_device *bq, + struct bq24257_platform_data *pdata) +{ + bq->init_data.ichg = bq24257_find_idx(pdata->ichg, + bq24257_ichg_map, + BQ24257_ICHG_MAP_SIZE); + + bq->init_data.vbat = bq24257_find_idx(pdata->vbat, + bq24257_vbat_map, + BQ24257_VBAT_MAP_SIZE); + + bq->init_data.iterm = bq24257_find_idx(pdata->iterm, + bq24257_iterm_map, + BQ24257_ITERM_MAP_SIZE); + + bq->init_data.iilimit = bq24257_find_idx(pdata->iilimit, + bq24257_iilimit_map, + BQ24257_IILIMIT_MAP_SIZE); + + bq->init_data.vovp = bq24257_find_idx(pdata->vovp, + bq24257_vovp_map, + BQ24257_VOVP_MAP_SIZE); + + bq->init_data.vindpm = bq24257_find_idx(pdata->vindpm, + bq24257_vindpm_map, + BQ24257_VINDPM_MAP_SIZE); + + bq->iilimit_autoset_enable = pdata->iilimit_autoset_enable; +} + static int bq24257_fw_probe(struct bq24257_device *bq) { int ret; @@ -963,6 +995,7 @@ static int bq24257_probe(struct i2c_client *client, struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct device *dev = &client->dev; const struct acpi_device_id *acpi_id; + struct bq24257_platform_data *pdata = client->dev.platform_data; struct bq24257_device *bq; int ret; int i; @@ -1012,14 +1045,15 @@ static int bq24257_probe(struct i2c_client *client, i2c_set_clientdata(client, bq); - if (!dev->platform_data) { + if (!pdata) { ret = bq24257_fw_probe(bq); if (ret < 0) { dev_err(dev, "Cannot read device properties.\n"); return ret; } } else { - return -ENODEV; + dev_dbg(dev, "init using platform data\n"); + bq24257_pdata_probe(bq, pdata); } /* diff --git a/include/linux/power/bq24257_charger.h b/include/linux/power/bq24257_charger.h new file mode 100644 index 0000000..c131c5d --- /dev/null +++ b/include/linux/power/bq24257_charger.h @@ -0,0 +1,25 @@ +/* + * Platform data for the TI bq24257 battery charger driver. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#ifndef _BQ24257_CHARGER_H_ +#define _BQ24257_CHARGER_H_ + +#include +#include + +struct bq24257_platform_data { + u32 ichg; /* charge current (uA) */ + u32 vbat; /* regulation voltage (uV) */ + u32 iterm; /* termination current (uA) */ + u32 iilimit; /* input current limit (uA) */ + u32 vovp; /* over voltage protection voltage (uV) */ + u32 vindpm; /* VDMP input threshold voltage (uV) */ + bool iilimit_autoset_enable; /* auto-detect of input current limit */ +}; + +#endif /* _BQ24257_CHARGER_H_ */ -- 1.9.1 ``` ## Re: \[PATCH v8 00/14\] power: bq24257: Add support for bq24250/bq24251 - From: Sebastian Reichel \ - Date: 2015-10-01 02:58:47 - Message: https://ratatoskr.run/linux-api/2015/10/8113133.md ```text Hi, On Mon, Sep 28, 2015 at 05:33:48PM -0500, Andreas Dannenberg wrote: > This patch series extends the driver to also support bq24250/bq24251. > > The bq24250/251/257 devices have a very similar feature set and are > virtually identical from a control register point of view so it made > sense to extend the existing driver rather than submitting a new driver. > In addition to the new device support the driver is also extended to > allow access to some device features previously hidden. Basic and > potentially dangerous charger config parameters affecting the actual > charging of the Li-Ion battery are only configurable through firmware > rather than sysfs properties. However some newly introduced properties > are exposed through sysfs properties as access to them may be desired > from userspace. For example, it is now possible to manually configure > the maximum current drawn from the input source to accommodate different > chargers (0.5A, 1.5A, 2.0A and so on) based on system knowledge a > userspace application may have rather than rely on the auto-detection > mechanism that may not work in all possible scenarios. Thanks, I queued all remaining patches except for > power: bq24257: Add platform data based initialization I'm still not convinced, that it should be added without any consumer in the mainline kernel. -- Sebastian ``` ## Re: \[PATCH v8 00/14\] power: bq24257: Add support for bq24250/bq24251 - From: Andreas Dannenberg \ - Date: 2015-10-01 16:53:48 - Message: https://ratatoskr.run/linux-api/2015/10/8113156.md ```text On Thu, Oct 01, 2015 at 04:58:47AM +0200, Sebastian Reichel wrote: > Hi, > > On Mon, Sep 28, 2015 at 05:33:48PM -0500, Andreas Dannenberg wrote: > > This patch series extends the driver to also support bq24250/bq24251. > > > > The bq24250/251/257 devices have a very similar feature set and are > > virtually identical from a control register point of view so it made > > sense to extend the existing driver rather than submitting a new driver. > > In addition to the new device support the driver is also extended to > > allow access to some device features previously hidden. Basic and > > potentially dangerous charger config parameters affecting the actual > > charging of the Li-Ion battery are only configurable through firmware > > rather than sysfs properties. However some newly introduced properties > > are exposed through sysfs properties as access to them may be desired > > from userspace. For example, it is now possible to manually configure > > the maximum current drawn from the input source to accommodate different > > chargers (0.5A, 1.5A, 2.0A and so on) based on system knowledge a > > userspace application may have rather than rely on the auto-detection > > mechanism that may not work in all possible scenarios. > > Thanks, I queued all remaining patches except for Sebastian, I just pulled your tree and re-ran some of my tests. Looks like everything is still working as it should. Thanks again for your help reviewing. Same goes for Krzysztof and Laurentiu -- thanks for your time and feedback too. > > power: bq24257: Add platform data based initialization > > I'm still not convinced, that it should be added without any > consumer in the mainline kernel. Well I tried to make my case (giving access to the largest audience possible). If you don't want to include it that's fine. I guess it can always get added if a specific need arises... For future reference here is the link to the latest version of that patch: http://marc.info/?l=linux-pm&m=144347973708093&w=2 -- Andreas Dannenberg Texas Instruments Inc ```