Lines Matching refs:bq
187 static int bq2415x_i2c_read(struct bq2415x_device *bq, u8 reg)
189 struct i2c_client *client = to_i2c_client(bq->dev);
217 static int bq2415x_i2c_read_mask(struct bq2415x_device *bq, u8 reg,
225 ret = bq2415x_i2c_read(bq, reg);
232 static int bq2415x_i2c_read_bit(struct bq2415x_device *bq, u8 reg, u8 bit)
236 return bq2415x_i2c_read_mask(bq, reg, BIT(bit), bit);
242 static int bq2415x_i2c_write(struct bq2415x_device *bq, u8 reg, u8 val)
244 struct i2c_client *client = to_i2c_client(bq->dev);
271 static int bq2415x_i2c_write_mask(struct bq2415x_device *bq, u8 reg, u8 val,
279 ret = bq2415x_i2c_read(bq, reg);
286 return bq2415x_i2c_write(bq, reg, ret);
290 static int bq2415x_i2c_write_bit(struct bq2415x_device *bq, u8 reg,
295 return bq2415x_i2c_write_mask(bq, reg, val, BIT(bit), bit);
301 static int bq2415x_exec_command(struct bq2415x_device *bq,
308 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS,
311 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
314 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
317 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS, 1,
320 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS, 0,
323 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_STATUS,
326 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
329 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_STATUS,
333 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
336 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
339 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
342 ret = bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
348 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
351 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
354 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
357 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
360 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
363 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
366 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
369 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
373 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_VOLTAGE,
376 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
379 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
382 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_VOLTAGE,
385 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
388 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
392 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
395 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
398 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
405 static enum bq2415x_chip bq2415x_detect_chip(struct bq2415x_device *bq)
407 struct i2c_client *client = to_i2c_client(bq->dev);
408 int ret = bq2415x_exec_command(bq, BQ2415X_PART_NUMBER);
417 if (bq->chip == BQ24151A)
418 return bq->chip;
421 if (bq->chip == BQ24150A ||
422 bq->chip == BQ24152 ||
423 bq->chip == BQ24155)
424 return bq->chip;
427 if (bq->chip == BQ24153A)
428 return bq->chip;
438 if (bq->chip == BQ24156A)
439 return bq->chip;
442 if (bq->chip == BQ24157S)
443 return bq->chip;
455 static int bq2415x_detect_revision(struct bq2415x_device *bq)
457 int ret = bq2415x_exec_command(bq, BQ2415X_REVISION);
458 int chip = bq2415x_detect_chip(bq);
495 static int bq2415x_get_vender_code(struct bq2415x_device *bq)
499 ret = bq2415x_exec_command(bq, BQ2415X_VENDER_CODE);
510 static void bq2415x_reset_chip(struct bq2415x_device *bq)
512 bq2415x_i2c_write(bq, BQ2415X_REG_CURRENT, BQ2415X_RESET_CURRENT);
513 bq2415x_i2c_write(bq, BQ2415X_REG_VOLTAGE, BQ2415X_RESET_VOLTAGE);
514 bq2415x_i2c_write(bq, BQ2415X_REG_CONTROL, BQ2415X_RESET_CONTROL);
515 bq2415x_i2c_write(bq, BQ2415X_REG_STATUS, BQ2415X_RESET_STATUS);
516 bq->timer_error = NULL;
522 static int bq2415x_set_current_limit(struct bq2415x_device *bq, int mA)
535 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CONTROL, val,
540 static int bq2415x_get_current_limit(struct bq2415x_device *bq)
544 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CONTROL,
560 static int bq2415x_set_weak_battery_voltage(struct bq2415x_device *bq, int mV)
574 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CONTROL, val,
579 static int bq2415x_get_weak_battery_voltage(struct bq2415x_device *bq)
583 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CONTROL,
591 static int bq2415x_set_battery_regulation_voltage(struct bq2415x_device *bq,
605 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_VOLTAGE, val,
610 static int bq2415x_get_battery_regulation_voltage(struct bq2415x_device *bq)
612 int ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_VOLTAGE,
621 static int bq2415x_set_charge_current(struct bq2415x_device *bq, int mA)
625 if (bq->init_data.resistor_sense <= 0)
628 val = (mA * bq->init_data.resistor_sense - 37400) / 6800;
634 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CURRENT, val,
640 static int bq2415x_get_charge_current(struct bq2415x_device *bq)
644 if (bq->init_data.resistor_sense <= 0)
647 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CURRENT,
651 return (37400 + 6800*ret) / bq->init_data.resistor_sense;
655 static int bq2415x_set_termination_current(struct bq2415x_device *bq, int mA)
659 if (bq->init_data.resistor_sense <= 0)
662 val = (mA * bq->init_data.resistor_sense - 3400) / 3400;
668 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CURRENT, val,
674 static int bq2415x_get_termination_current(struct bq2415x_device *bq)
678 if (bq->init_data.resistor_sense <= 0)
681 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CURRENT,
685 return (3400 + 3400*ret) / bq->init_data.resistor_sense;
689 #define bq2415x_set_default_value(bq, prop) \
692 if (bq->init_data.prop != -1) \
693 ret = bq2415x_set_##prop(bq, bq->init_data.prop); \
699 static int bq2415x_set_defaults(struct bq2415x_device *bq)
701 bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_DISABLE);
702 bq2415x_exec_command(bq, BQ2415X_CHARGER_DISABLE);
703 bq2415x_exec_command(bq, BQ2415X_CHARGE_TERMINATION_DISABLE);
705 bq2415x_set_default_value(bq, current_limit);
706 bq2415x_set_default_value(bq, weak_battery_voltage);
707 bq2415x_set_default_value(bq, battery_regulation_voltage);
709 if (bq->init_data.resistor_sense > 0) {
710 bq2415x_set_default_value(bq, charge_current);
711 bq2415x_set_default_value(bq, termination_current);
712 bq2415x_exec_command(bq, BQ2415X_CHARGE_TERMINATION_ENABLE);
715 bq2415x_exec_command(bq, BQ2415X_CHARGER_ENABLE);
722 static int bq2415x_set_mode(struct bq2415x_device *bq, enum bq2415x_mode mode)
734 ret = bq2415x_exec_command(bq, BQ2415X_CHARGER_DISABLE);
737 ret = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_DISABLE);
744 dev_dbg(bq->dev, "changing mode to: Offline\n");
745 ret = bq2415x_set_current_limit(bq, 100);
748 dev_dbg(bq->dev, "changing mode to: N/A\n");
749 ret = bq2415x_set_current_limit(bq, 100);
752 dev_dbg(bq->dev, "changing mode to: Host/HUB charger\n");
753 ret = bq2415x_set_current_limit(bq, 500);
756 dev_dbg(bq->dev, "changing mode to: Dedicated charger\n");
757 ret = bq2415x_set_current_limit(bq, 1800);
760 dev_dbg(bq->dev, "changing mode to: Boost\n");
761 ret = bq2415x_set_current_limit(bq, 100);
769 ret = bq2415x_exec_command(bq, BQ2415X_CHARGER_ENABLE);
771 ret = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_ENABLE);
776 bq2415x_set_default_value(bq, weak_battery_voltage);
777 bq2415x_set_default_value(bq, battery_regulation_voltage);
779 bq->mode = mode;
780 sysfs_notify(&bq->charger->dev.kobj, NULL, "mode");
786 static bool bq2415x_update_reported_mode(struct bq2415x_device *bq, int mA)
799 if (bq->reported_mode == mode)
802 bq->reported_mode = mode;
809 struct bq2415x_device *bq =
819 if (bq->notify_node) {
821 psy->dev.parent->of_node != bq->notify_node)
823 } else if (bq->init_data.notify_device) {
824 if (strcmp(psy->desc->name, bq->init_data.notify_device) != 0)
828 dev_dbg(bq->dev, "notifier call was called\n");
835 if (!bq2415x_update_reported_mode(bq, prop.intval))
839 if (bq->automode < 1)
842 schedule_delayed_work(&bq->work, 0);
850 static void bq2415x_set_autotimer(struct bq2415x_device *bq, int state)
854 if (bq->autotimer == state) {
859 bq->autotimer = state;
862 schedule_delayed_work(&bq->work, BQ2415X_TIMER_TIMEOUT * HZ);
863 bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
864 bq->timer_error = NULL;
866 cancel_delayed_work_sync(&bq->work);
873 static void bq2415x_timer_error(struct bq2415x_device *bq, const char *msg)
875 bq->timer_error = msg;
876 sysfs_notify(&bq->charger->dev.kobj, NULL, "timer");
877 dev_err(bq->dev, "%s\n", msg);
878 if (bq->automode > 0)
879 bq->automode = 0;
880 bq2415x_set_mode(bq, BQ2415X_MODE_OFF);
881 bq2415x_set_autotimer(bq, 0);
887 struct bq2415x_device *bq = container_of(work, struct bq2415x_device,
893 if (bq->automode > 0 && (bq->reported_mode != bq->mode)) {
894 sysfs_notify(&bq->charger->dev.kobj, NULL, "reported_mode");
895 bq2415x_set_mode(bq, bq->reported_mode);
898 if (!bq->autotimer)
901 ret = bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
903 bq2415x_timer_error(bq, "Resetting timer failed");
907 boost = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_STATUS);
909 bq2415x_timer_error(bq, "Unknown error");
913 error = bq2415x_exec_command(bq, BQ2415X_FAULT_STATUS);
915 bq2415x_timer_error(bq, "Unknown error");
925 dev_err(bq->dev, "Timer expired\n");
928 dev_err(bq->dev, "Battery voltage to low\n");
933 bq2415x_timer_error(bq,
937 bq2415x_timer_error(bq, "Overload");
940 bq2415x_timer_error(bq,
944 bq2415x_timer_error(bq,
948 bq2415x_timer_error(bq, "Unknown error");
957 dev_err(bq->dev, "Sleep mode\n");
960 dev_err(bq->dev, "Poor input source\n");
963 dev_err(bq->dev, "Timer expired\n");
966 dev_err(bq->dev, "No battery\n");
971 bq2415x_timer_error(bq,
975 bq2415x_timer_error(bq,
979 bq2415x_timer_error(bq,
985 schedule_delayed_work(&bq->work, BQ2415X_TIMER_TIMEOUT * HZ);
1001 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1006 ret = bq2415x_exec_command(bq, BQ2415X_CHARGE_STATUS);
1019 val->strval = bq->model;
1025 ret = bq2415x_exec_command(bq, BQ2415X_CHARGE_STATUS);
1036 static void bq2415x_power_supply_exit(struct bq2415x_device *bq)
1038 bq->autotimer = 0;
1039 if (bq->automode > 0)
1040 bq->automode = 0;
1041 cancel_delayed_work_sync(&bq->work);
1042 power_supply_unregister(bq->charger);
1043 kfree(bq->model);
1054 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1069 ret = bq2415x_exec_command(bq, command);
1087 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1091 bq2415x_set_autotimer(bq, 1);
1093 bq2415x_set_autotimer(bq, 0);
1095 ret = bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
1108 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1110 if (bq->timer_error)
1111 return sysfs_emit(buf, "%s\n", bq->timer_error);
1113 if (bq->autotimer)
1132 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1137 if (bq->automode < 0)
1139 bq->automode = 1;
1140 mode = bq->reported_mode;
1142 if (bq->automode > 0)
1143 bq->automode = 0;
1146 if (bq->automode > 0)
1147 bq->automode = 0;
1150 if (bq->automode > 0)
1151 bq->automode = 0;
1154 if (bq->automode > 0)
1155 bq->automode = 0;
1158 if (bq->automode > 0)
1159 bq->automode = 0;
1162 bq2415x_reset_chip(bq);
1163 bq2415x_set_defaults(bq);
1164 if (bq->automode <= 0)
1166 bq->automode = 1;
1167 mode = bq->reported_mode;
1172 ret = bq2415x_set_mode(bq, mode);
1184 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1187 if (bq->automode > 0)
1190 switch (bq->mode) {
1208 if (bq->automode > 0)
1221 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1223 if (bq->automode < 0)
1226 switch (bq->reported_mode) {
1249 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1260 ret = bq2415x_i2c_write(bq, reg, val);
1267 static ssize_t bq2415x_sysfs_print_reg(struct bq2415x_device *bq,
1271 int ret = bq2415x_i2c_read(bq, reg);
1284 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1287 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_STATUS, buf+ret);
1288 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CONTROL, buf+ret);
1289 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VOLTAGE, buf+ret);
1290 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VENDER, buf+ret);
1291 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CURRENT, buf+ret);
1302 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1310 ret = bq2415x_set_current_limit(bq, val);
1312 ret = bq2415x_set_weak_battery_voltage(bq, val);
1314 ret = bq2415x_set_battery_regulation_voltage(bq, val);
1316 ret = bq2415x_set_charge_current(bq, val);
1318 ret = bq2415x_set_termination_current(bq, val);
1333 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1337 ret = bq2415x_get_current_limit(bq);
1339 ret = bq2415x_get_weak_battery_voltage(bq);
1341 ret = bq2415x_get_battery_regulation_voltage(bq);
1343 ret = bq2415x_get_charge_current(bq);
1345 ret = bq2415x_get_termination_current(bq);
1361 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1384 ret = bq2415x_exec_command(bq, command);
1396 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1411 ret = bq2415x_exec_command(bq, command);
1483 static int bq2415x_power_supply_init(struct bq2415x_device *bq)
1489 .drv_data = bq,
1490 .of_node = bq->dev->of_node,
1494 bq->charger_desc.name = bq->name;
1495 bq->charger_desc.type = POWER_SUPPLY_TYPE_USB;
1496 bq->charger_desc.properties = bq2415x_power_supply_props;
1497 bq->charger_desc.num_properties =
1499 bq->charger_desc.get_property = bq2415x_power_supply_get_property;
1501 ret = bq2415x_detect_chip(bq);
1507 ret = bq2415x_detect_revision(bq);
1513 bq->model = kasprintf(GFP_KERNEL,
1516 bq2415x_get_vender_code(bq));
1517 if (!bq->model) {
1518 dev_err(bq->dev, "failed to allocate model name\n");
1522 bq->charger = power_supply_register(bq->dev, &bq->charger_desc,
1524 if (IS_ERR(bq->charger)) {
1525 kfree(bq->model);
1526 return PTR_ERR(bq->charger);
1539 struct bq2415x_device *bq;
1577 bq = devm_kzalloc(&client->dev, sizeof(*bq), GFP_KERNEL);
1578 if (!bq) {
1583 i2c_set_clientdata(client, bq);
1585 bq->id = num;
1586 bq->dev = &client->dev;
1588 bq->chip = id->driver_data;
1589 else if (ACPI_HANDLE(bq->dev))
1590 bq->chip = acpi_id->driver_data;
1591 bq->name = name;
1592 bq->mode = BQ2415X_MODE_OFF;
1593 bq->reported_mode = BQ2415X_MODE_OFF;
1594 bq->autotimer = 0;
1595 bq->automode = 0;
1597 if (np || ACPI_HANDLE(bq->dev)) {
1598 ret = device_property_read_u32(bq->dev,
1600 &bq->init_data.current_limit);
1603 ret = device_property_read_u32(bq->dev,
1605 &bq->init_data.weak_battery_voltage);
1608 ret = device_property_read_u32(bq->dev,
1610 &bq->init_data.battery_regulation_voltage);
1613 ret = device_property_read_u32(bq->dev,
1615 &bq->init_data.charge_current);
1618 ret = device_property_read_u32(bq->dev,
1620 &bq->init_data.termination_current);
1623 ret = device_property_read_u32(bq->dev,
1625 &bq->init_data.resistor_sense);
1629 bq->notify_node = of_parse_phandle(np,
1632 memcpy(&bq->init_data, pdata, sizeof(bq->init_data));
1635 bq2415x_reset_chip(bq);
1637 ret = bq2415x_power_supply_init(bq);
1639 dev_err(bq->dev, "failed to register power supply: %d\n", ret);
1643 ret = bq2415x_set_defaults(bq);
1645 dev_err(bq->dev, "failed to set default values: %d\n", ret);
1649 if (bq->notify_node || bq->init_data.notify_device) {
1650 bq->nb.notifier_call = bq2415x_notifier_call;
1651 ret = power_supply_reg_notifier(&bq->nb);
1653 dev_err(bq->dev, "failed to reg notifier: %d\n", ret);
1657 bq->automode = 1;
1658 dev_info(bq->dev, "automode supported, waiting for events\n");
1660 bq->automode = -1;
1661 dev_info(bq->dev, "automode not supported\n");
1665 if (bq->nb.notifier_call) {
1671 } else if (bq->init_data.notify_device) {
1673 bq->init_data.notify_device);
1682 bq2415x_update_reported_mode(bq, prop.intval);
1683 bq2415x_set_mode(bq, bq->reported_mode);
1687 INIT_DELAYED_WORK(&bq->work, bq2415x_timer_work);
1688 bq2415x_set_autotimer(bq, 1);
1690 dev_info(bq->dev, "driver registered\n");
1694 bq2415x_power_supply_exit(bq);
1696 if (bq)
1697 of_node_put(bq->notify_node);
1711 struct bq2415x_device *bq = i2c_get_clientdata(client);
1713 if (bq->nb.notifier_call)
1714 power_supply_unreg_notifier(&bq->nb);
1716 of_node_put(bq->notify_node);
1717 bq2415x_power_supply_exit(bq);
1719 bq2415x_reset_chip(bq);
1722 idr_remove(&bq2415x_id, bq->id);
1725 dev_info(bq->dev, "driver unregistered\n");
1727 kfree(bq->name);