Lines Matching +full:current +full:- +full:boost +full:- +full:microamp
1 // SPDX-License-Identifier: GPL-2.0-only
10 * Copyright (C) 2009-2010 Motorola, Inc.
31 #include <linux/mfd/motorola-cpcap.h>
38 * similar. Also see the Motorola Linux kernel cpcap-regbits.h. CPCAP_REG_CHRGR_1
45 #define CPCAP_REG_CRM_ICHRG_TR1 BIT(11) /* Trickle charge current */
53 #define CPCAP_REG_CRM_ICHRG3 BIT(3) /* Charge current bits */
90 * values in "Table 8-3. Charge Path Regulator Current Limit
114 #define CPCAP_BIT_VBUS_SWITCH BIT(0) /* VBUS boost to 5V */
181 channel = ddata->channels[CPCAP_CHARGER_IIO_VOLTAGE];
184 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
197 channel = ddata->channels[CPCAP_CHARGER_IIO_CHRG_CURRENT];
200 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
212 struct cpcap_charger_ddata *ddata = dev_get_drvdata(psy->dev.parent);
216 val->intval = ddata->status;
219 val->intval = ddata->limit_current;
222 val->intval = ddata->voltage;
225 if (ddata->status == POWER_SUPPLY_STATUS_CHARGING)
226 val->intval = cpcap_charger_get_charge_voltage(ddata) *
229 val->intval = 0;
232 if (ddata->status == POWER_SUPPLY_STATUS_CHARGING)
233 val->intval = cpcap_charger_get_charge_current(ddata) *
236 val->intval = 0;
239 val->intval = ddata->status == POWER_SUPPLY_STATUS_CHARGING;
242 return -EINVAL;
251 case 0 ... 4100000 - 1: return 3800000;
252 case 4100000 ... 4120000 - 1: return 4100000;
253 case 4120000 ... 4150000 - 1: return 4120000;
254 case 4150000 ... 4170000 - 1: return 4150000;
255 case 4170000 ... 4200000 - 1: return 4170000;
256 case 4200000 ... 4230000 - 1: return 4200000;
257 case 4230000 ... 4250000 - 1: return 4230000;
258 case 4250000 ... 4270000 - 1: return 4250000;
259 case 4270000 ... 4300000 - 1: return 4270000;
260 case 4300000 ... 4330000 - 1: return 4300000;
261 case 4330000 ... 4350000 - 1: return 4330000;
262 case 4350000 ... 4380000 - 1: return 4350000;
263 case 4380000 ... 4400000 - 1: return 4380000;
264 case 4400000 ... 4420000 - 1: return 4400000;
265 case 4420000 ... 4440000 - 1: return 4420000;
276 int voltage = ddata->voltage;
293 static int cpcap_charger_current_to_regval(int microamp)
295 int miliamp = microamp / 1000;
299 return -EINVAL;
307 res = microamp / 88666;
317 struct cpcap_charger_ddata *ddata = dev_get_drvdata(psy->dev.parent);
322 if (cpcap_charger_current_to_regval(val->intval) < 0)
323 return -EINVAL;
324 ddata->limit_current = val->intval;
325 schedule_delayed_work(&ddata->detect_work, 0);
328 voltage = cpcap_charger_match_voltage(val->intval);
332 ddata->voltage = voltage;
333 schedule_delayed_work(&ddata->detect_work, 0);
336 return -EINVAL;
357 if (!ddata->gpio[0])
360 gpiod_set_value(ddata->gpio[0], enabled);
366 if (!ddata->gpio[1])
369 gpiod_set_value(ddata->gpio[1], enabled);
378 dev_warn(ddata->dev, "unknown state: %i\n", state);
383 ddata->status = state;
402 dev_dbg(ddata->dev, "state: %s\n", status);
409 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM, 0x3fff,
413 dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
425 return -EINVAL;
427 dev_dbg(ddata->dev, "enable: %i %i %i\n",
430 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM, 0x3fff,
438 dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
447 ddata->channels[CPCAP_CHARGER_IIO_VBUS];
453 dev_err(ddata->dev, "error reading VBUS: %i\n", error);
468 if (ddata->vbus_enabled) {
471 dev_dbg(ddata->dev, "VBUS already provided\n");
476 ddata->feeding_vbus = true;
487 error = regmap_update_bits(ddata->reg, CPCAP_REG_VUSBC,
493 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM,
499 error = regmap_update_bits(ddata->reg, CPCAP_REG_VUSBC,
504 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM,
511 ddata->feeding_vbus = false;
518 dev_err(ddata->dev, "%s could not %s vbus: %i\n", __func__,
519 str_enable_disable(ddata->vbus_enabled), error);
529 ddata->vbus_enabled = enabled;
530 schedule_delayed_work(&ddata->vbus_work, 0);
542 error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
546 s->chrg_det = val & BIT(13);
547 s->rvrs_chrg = val & BIT(12);
548 s->vbusov = val & BIT(11);
550 error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
554 s->chrg_se1b = val & BIT(13);
555 s->rvrs_mode = val & BIT(6);
556 s->chrgcurr2 = val & BIT(5);
557 s->chrgcurr1 = val & BIT(4);
558 s->vbusvld = val & BIT(3);
560 error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
564 s->battdetb = val & BIT(6);
574 case 0 ... 4100000 - 1:
576 case 4100000 ... 4200000 - 1:
579 case 4200000 ... 4300000 - 1:
582 case 4300000 ... 4380000 - 1:
583 offset = -1;
586 offset = -2;
592 return ((voltage - 4100000) / 20000) + offset;
604 power_supply_changed(ddata->usb);
617 power_supply_changed(ddata->usb);
618 schedule_delayed_work(&ddata->detect_work, delay);
646 if (cpcap_charger_get_charge_voltage(ddata) > ddata->voltage) {
658 switch (ddata->status) {
684 if (!ddata->feeding_vbus && cpcap_charger_vbus_valid(ddata) &&
693 dev_err(ddata->dev, "battery power_supply not available %li\n",
706 dev_info(ddata->dev, "battery not inserted, charging disabled\n");
710 if (max_current > ddata->limit_current)
711 max_current = ddata->limit_current;
714 vchrg = cpcap_charger_voltage_to_regval(ddata->voltage);
730 power_supply_changed(ddata->usb);
735 dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
742 if (!atomic_read(&ddata->active))
745 schedule_delayed_work(&ddata->detect_work, 0);
759 return -ENODEV;
761 error = devm_request_threaded_irq(ddata->dev, irq, NULL,
766 dev_err(ddata->dev, "could not get irq %s: %i\n",
772 d = devm_kzalloc(ddata->dev, sizeof(*d), GFP_KERNEL);
774 return -ENOMEM;
776 d->name = name;
777 d->irq = irq;
778 list_add(&d->node, &ddata->irq_list);
813 ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
815 if (IS_ERR(ddata->gpio[i])) {
816 dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
817 i, PTR_ERR(ddata->gpio[i]));
818 ddata->gpio[i] = NULL;
831 ddata->channels[i] = devm_iio_channel_get(ddata->dev,
833 if (IS_ERR(ddata->channels[i])) {
834 error = PTR_ERR(ddata->channels[i]);
838 if (!ddata->channels[i]->indio_dev) {
839 error = -ENXIO;
847 if (error != -EPROBE_DEFER)
848 dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
870 .compatible = "motorola,mapphone-cpcap-charger",
882 ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
884 return -ENOMEM;
886 ddata->dev = &pdev->dev;
887 ddata->voltage = 4200000;
888 ddata->limit_current = 532000;
890 ddata->reg = dev_get_regmap(ddata->dev->parent, NULL);
891 if (!ddata->reg)
892 return -ENODEV;
894 INIT_LIST_HEAD(&ddata->irq_list);
895 INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
896 INIT_DELAYED_WORK(&ddata->vbus_work, cpcap_charger_vbus_work);
903 atomic_set(&ddata->active, 1);
905 psy_cfg.fwnode = dev_fwnode(&pdev->dev);
910 ddata->usb = devm_power_supply_register(ddata->dev,
913 if (IS_ERR(ddata->usb)) {
914 error = PTR_ERR(ddata->usb);
915 dev_err(ddata->dev, "failed to register USB charger: %i\n",
925 ddata->comparator.set_vbus = cpcap_charger_set_vbus;
926 error = omap_usb2_set_comparator(&ddata->comparator);
927 if (error == -ENODEV) {
928 dev_info(ddata->dev, "charger needs phy, deferring probe\n");
929 return -EPROBE_DEFER;
934 schedule_delayed_work(&ddata->detect_work, 0);
944 atomic_set(&ddata->active, 0);
947 dev_warn(ddata->dev, "could not clear USB comparator: %i\n",
953 dev_warn(ddata->dev, "could not clear charger: %i\n",
957 cancel_delayed_work_sync(&ddata->vbus_work);
958 cancel_delayed_work_sync(&ddata->detect_work);
969 .name = "cpcap-charger",
980 MODULE_ALIAS("platform:cpcap-charger");