Lines Matching defs: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);
1000 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1005 ret = bq2415x_exec_command(bq, BQ2415X_CHARGE_STATUS);
1018 val->strval = bq->model;
1026 static void bq2415x_power_supply_exit(struct bq2415x_device *bq)
1028 bq->autotimer = 0;
1029 if (bq->automode > 0)
1030 bq->automode = 0;
1031 cancel_delayed_work_sync(&bq->work);
1032 power_supply_unregister(bq->charger);
1033 kfree(bq->model);
1044 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1059 ret = bq2415x_exec_command(bq, command);
1077 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1081 bq2415x_set_autotimer(bq, 1);
1083 bq2415x_set_autotimer(bq, 0);
1085 ret = bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
1098 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1100 if (bq->timer_error)
1101 return sysfs_emit(buf, "%s\n", bq->timer_error);
1103 if (bq->autotimer)
1122 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1127 if (bq->automode < 0)
1129 bq->automode = 1;
1130 mode = bq->reported_mode;
1132 if (bq->automode > 0)
1133 bq->automode = 0;
1136 if (bq->automode > 0)
1137 bq->automode = 0;
1140 if (bq->automode > 0)
1141 bq->automode = 0;
1144 if (bq->automode > 0)
1145 bq->automode = 0;
1148 if (bq->automode > 0)
1149 bq->automode = 0;
1152 bq2415x_reset_chip(bq);
1153 bq2415x_set_defaults(bq);
1154 if (bq->automode <= 0)
1156 bq->automode = 1;
1157 mode = bq->reported_mode;
1162 ret = bq2415x_set_mode(bq, mode);
1174 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1177 if (bq->automode > 0)
1180 switch (bq->mode) {
1198 if (bq->automode > 0)
1211 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1213 if (bq->automode < 0)
1216 switch (bq->reported_mode) {
1239 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1250 ret = bq2415x_i2c_write(bq, reg, val);
1257 static ssize_t bq2415x_sysfs_print_reg(struct bq2415x_device *bq,
1261 int ret = bq2415x_i2c_read(bq, reg);
1274 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1277 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_STATUS, buf+ret);
1278 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CONTROL, buf+ret);
1279 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VOLTAGE, buf+ret);
1280 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VENDER, buf+ret);
1281 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CURRENT, buf+ret);
1292 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1300 ret = bq2415x_set_current_limit(bq, val);
1302 ret = bq2415x_set_weak_battery_voltage(bq, val);
1304 ret = bq2415x_set_battery_regulation_voltage(bq, val);
1306 ret = bq2415x_set_charge_current(bq, val);
1308 ret = bq2415x_set_termination_current(bq, val);
1323 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1327 ret = bq2415x_get_current_limit(bq);
1329 ret = bq2415x_get_weak_battery_voltage(bq);
1331 ret = bq2415x_get_battery_regulation_voltage(bq);
1333 ret = bq2415x_get_charge_current(bq);
1335 ret = bq2415x_get_termination_current(bq);
1351 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1374 ret = bq2415x_exec_command(bq, command);
1386 struct bq2415x_device *bq = power_supply_get_drvdata(psy);
1401 ret = bq2415x_exec_command(bq, command);
1473 static int bq2415x_power_supply_init(struct bq2415x_device *bq)
1479 .drv_data = bq,
1480 .of_node = bq->dev->of_node,
1484 bq->charger_desc.name = bq->name;
1485 bq->charger_desc.type = POWER_SUPPLY_TYPE_USB;
1486 bq->charger_desc.properties = bq2415x_power_supply_props;
1487 bq->charger_desc.num_properties =
1489 bq->charger_desc.get_property = bq2415x_power_supply_get_property;
1491 ret = bq2415x_detect_chip(bq);
1497 ret = bq2415x_detect_revision(bq);
1503 bq->model = kasprintf(GFP_KERNEL,
1506 bq2415x_get_vender_code(bq));
1507 if (!bq->model) {
1508 dev_err(bq->dev, "failed to allocate model name\n");
1512 bq->charger = power_supply_register(bq->dev, &bq->charger_desc,
1514 if (IS_ERR(bq->charger)) {
1515 kfree(bq->model);
1516 return PTR_ERR(bq->charger);
1529 struct bq2415x_device *bq;
1567 bq = devm_kzalloc(&client->dev, sizeof(*bq), GFP_KERNEL);
1568 if (!bq) {
1573 i2c_set_clientdata(client, bq);
1575 bq->id = num;
1576 bq->dev = &client->dev;
1578 bq->chip = id->driver_data;
1579 else if (ACPI_HANDLE(bq->dev))
1580 bq->chip = acpi_id->driver_data;
1581 bq->name = name;
1582 bq->mode = BQ2415X_MODE_OFF;
1583 bq->reported_mode = BQ2415X_MODE_OFF;
1584 bq->autotimer = 0;
1585 bq->automode = 0;
1587 if (np || ACPI_HANDLE(bq->dev)) {
1588 ret = device_property_read_u32(bq->dev,
1590 &bq->init_data.current_limit);
1593 ret = device_property_read_u32(bq->dev,
1595 &bq->init_data.weak_battery_voltage);
1598 ret = device_property_read_u32(bq->dev,
1600 &bq->init_data.battery_regulation_voltage);
1603 ret = device_property_read_u32(bq->dev,
1605 &bq->init_data.charge_current);
1608 ret = device_property_read_u32(bq->dev,
1610 &bq->init_data.termination_current);
1613 ret = device_property_read_u32(bq->dev,
1615 &bq->init_data.resistor_sense);
1619 bq->notify_node = of_parse_phandle(np,
1622 memcpy(&bq->init_data, pdata, sizeof(bq->init_data));
1625 bq2415x_reset_chip(bq);
1627 ret = bq2415x_power_supply_init(bq);
1629 dev_err(bq->dev, "failed to register power supply: %d\n", ret);
1633 ret = bq2415x_set_defaults(bq);
1635 dev_err(bq->dev, "failed to set default values: %d\n", ret);
1639 if (bq->notify_node || bq->init_data.notify_device) {
1640 bq->nb.notifier_call = bq2415x_notifier_call;
1641 ret = power_supply_reg_notifier(&bq->nb);
1643 dev_err(bq->dev, "failed to reg notifier: %d\n", ret);
1647 bq->automode = 1;
1648 dev_info(bq->dev, "automode supported, waiting for events\n");
1650 bq->automode = -1;
1651 dev_info(bq->dev, "automode not supported\n");
1655 if (bq->nb.notifier_call) {
1661 } else if (bq->init_data.notify_device) {
1663 bq->init_data.notify_device);
1672 bq2415x_update_reported_mode(bq, prop.intval);
1673 bq2415x_set_mode(bq, bq->reported_mode);
1677 INIT_DELAYED_WORK(&bq->work, bq2415x_timer_work);
1678 bq2415x_set_autotimer(bq, 1);
1680 dev_info(bq->dev, "driver registered\n");
1684 bq2415x_power_supply_exit(bq);
1686 if (bq)
1687 of_node_put(bq->notify_node);
1701 struct bq2415x_device *bq = i2c_get_clientdata(client);
1703 if (bq->nb.notifier_call)
1704 power_supply_unreg_notifier(&bq->nb);
1706 of_node_put(bq->notify_node);
1707 bq2415x_power_supply_exit(bq);
1709 bq2415x_reset_chip(bq);
1712 idr_remove(&bq2415x_id, bq->id);
1715 dev_info(bq->dev, "driver unregistered\n");
1717 kfree(bq->name);