Lines Matching refs:ddata
181 static bool cpcap_charger_battery_found(struct cpcap_charger_ddata *ddata)
186 channel = ddata->channels[CPCAP_CHARGER_IIO_BATTDET];
189 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
197 static int cpcap_charger_get_charge_voltage(struct cpcap_charger_ddata *ddata)
202 channel = ddata->channels[CPCAP_CHARGER_IIO_VOLTAGE];
205 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
213 static int cpcap_charger_get_charge_current(struct cpcap_charger_ddata *ddata)
218 channel = ddata->channels[CPCAP_CHARGER_IIO_CHRG_CURRENT];
221 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
233 struct cpcap_charger_ddata *ddata = dev_get_drvdata(psy->dev.parent);
237 val->intval = ddata->status;
240 val->intval = ddata->voltage;
243 if (ddata->status == POWER_SUPPLY_STATUS_CHARGING)
244 val->intval = cpcap_charger_get_charge_voltage(ddata) *
250 if (ddata->status == POWER_SUPPLY_STATUS_CHARGING)
251 val->intval = cpcap_charger_get_charge_current(ddata) *
257 val->intval = ddata->status == POWER_SUPPLY_STATUS_CHARGING;
290 cpcap_charger_get_bat_const_charge_voltage(struct cpcap_charger_ddata *ddata)
294 int voltage = ddata->voltage;
315 struct cpcap_charger_ddata *ddata = dev_get_drvdata(psy->dev.parent);
321 batvolt = cpcap_charger_get_bat_const_charge_voltage(ddata);
324 ddata->voltage = voltage;
325 schedule_delayed_work(&ddata->detect_work, 0);
345 static void cpcap_charger_set_cable_path(struct cpcap_charger_ddata *ddata,
348 if (!ddata->gpio[0])
351 gpiod_set_value(ddata->gpio[0], enabled);
354 static void cpcap_charger_set_inductive_path(struct cpcap_charger_ddata *ddata,
357 if (!ddata->gpio[1])
360 gpiod_set_value(ddata->gpio[1], enabled);
363 static int cpcap_charger_set_state(struct cpcap_charger_ddata *ddata,
371 dev_dbg(ddata->dev, "%s enable: %i\n", __func__, enable);
374 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM,
379 ddata->status = POWER_SUPPLY_STATUS_UNKNOWN;
383 ddata->status = POWER_SUPPLY_STATUS_DISCHARGING;
388 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM, 0x3fff,
396 ddata->status = POWER_SUPPLY_STATUS_UNKNOWN;
400 ddata->status = POWER_SUPPLY_STATUS_CHARGING;
405 dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
410 static bool cpcap_charger_vbus_valid(struct cpcap_charger_ddata *ddata)
414 ddata->channels[CPCAP_CHARGER_IIO_VBUS];
420 dev_err(ddata->dev, "error reading VBUS: %i\n", error);
428 struct cpcap_charger_ddata *ddata;
432 ddata = container_of(work, struct cpcap_charger_ddata,
435 if (ddata->vbus_enabled) {
436 vbus = cpcap_charger_vbus_valid(ddata);
438 dev_info(ddata->dev, "VBUS already provided\n");
443 ddata->feeding_vbus = true;
444 cpcap_charger_set_cable_path(ddata, false);
445 cpcap_charger_set_inductive_path(ddata, false);
447 error = cpcap_charger_set_state(ddata, 0, 0, 0);
451 error = regmap_update_bits(ddata->reg, CPCAP_REG_VUSBC,
457 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM,
463 error = regmap_update_bits(ddata->reg, CPCAP_REG_VUSBC,
468 error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM,
473 cpcap_charger_set_cable_path(ddata, true);
474 cpcap_charger_set_inductive_path(ddata, true);
475 ddata->feeding_vbus = false;
481 dev_err(ddata->dev, "%s could not %s vbus: %i\n", __func__,
482 ddata->vbus_enabled ? "enable" : "disable", error);
488 struct cpcap_charger_ddata *ddata =
492 ddata->vbus_enabled = enabled;
493 schedule_delayed_work(&ddata->vbus_work, 0);
500 static int cpcap_charger_get_ints_state(struct cpcap_charger_ddata *ddata,
505 error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
513 error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
523 error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
532 static void cpcap_charger_update_state(struct cpcap_charger_ddata *ddata,
538 dev_warn(ddata->dev, "unknown state: %i\n", state);
543 ddata->state = state;
562 dev_dbg(ddata->dev, "state: %s\n", status);
591 static void cpcap_charger_disconnect(struct cpcap_charger_ddata *ddata,
596 error = cpcap_charger_set_state(ddata, 0, 0, 0);
600 cpcap_charger_update_state(ddata, state);
601 power_supply_changed(ddata->usb);
602 schedule_delayed_work(&ddata->detect_work, delay);
607 struct cpcap_charger_ddata *ddata;
611 ddata = container_of(work, struct cpcap_charger_ddata,
614 error = cpcap_charger_get_ints_state(ddata, &s);
620 cpcap_charger_update_state(ddata, CPCAP_CHARGER_DETECTING);
629 if (cpcap_charger_get_charge_voltage(ddata) > ddata->voltage) {
630 cpcap_charger_disconnect(ddata, CPCAP_CHARGER_DETECTING,
640 switch (ddata->state) {
645 cpcap_charger_disconnect(ddata, CPCAP_CHARGER_DONE,
653 cpcap_charger_disconnect(ddata, CPCAP_CHARGER_DETECTING,
660 if (!ddata->feeding_vbus && cpcap_charger_vbus_valid(ddata) &&
665 if (cpcap_charger_battery_found(ddata))
670 vchrg = cpcap_charger_voltage_to_regval(ddata->voltage);
671 error = cpcap_charger_set_state(ddata,
676 cpcap_charger_update_state(ddata, CPCAP_CHARGER_CHARGING);
678 error = cpcap_charger_set_state(ddata, 0, 0, 0);
681 cpcap_charger_update_state(ddata, CPCAP_CHARGER_DISCONNECTED);
684 power_supply_changed(ddata->usb);
688 dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
693 struct cpcap_charger_ddata *ddata = data;
695 if (!atomic_read(&ddata->active))
698 schedule_delayed_work(&ddata->detect_work, 0);
704 struct cpcap_charger_ddata *ddata,
714 error = devm_request_threaded_irq(ddata->dev, irq, NULL,
717 name, ddata);
719 dev_err(ddata->dev, "could not get irq %s: %i\n",
725 d = devm_kzalloc(ddata->dev, sizeof(*d), GFP_KERNEL);
731 list_add(&d->node, &ddata->irq_list);
748 struct cpcap_charger_ddata *ddata)
753 error = cpcap_usb_init_irq(pdev, ddata, cpcap_charger_irqs[i]);
761 static void cpcap_charger_init_optional_gpios(struct cpcap_charger_ddata *ddata)
766 ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
768 if (IS_ERR(ddata->gpio[i])) {
769 dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
770 i, PTR_ERR(ddata->gpio[i]));
771 ddata->gpio[i] = NULL;
776 static int cpcap_charger_init_iio(struct cpcap_charger_ddata *ddata)
784 ddata->channels[i] = devm_iio_channel_get(ddata->dev,
786 if (IS_ERR(ddata->channels[i])) {
787 error = PTR_ERR(ddata->channels[i]);
791 if (!ddata->channels[i]->indio_dev) {
801 dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
829 struct cpcap_charger_ddata *ddata;
839 ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
840 if (!ddata)
843 ddata->dev = &pdev->dev;
844 ddata->voltage = 4200000;
846 ddata->reg = dev_get_regmap(ddata->dev->parent, NULL);
847 if (!ddata->reg)
850 INIT_LIST_HEAD(&ddata->irq_list);
851 INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
852 INIT_DELAYED_WORK(&ddata->vbus_work, cpcap_charger_vbus_work);
853 platform_set_drvdata(pdev, ddata);
855 error = cpcap_charger_init_iio(ddata);
859 atomic_set(&ddata->active, 1);
862 psy_cfg.drv_data = ddata;
864 ddata->usb = devm_power_supply_register(ddata->dev,
867 if (IS_ERR(ddata->usb)) {
868 error = PTR_ERR(ddata->usb);
869 dev_err(ddata->dev, "failed to register USB charger: %i\n",
875 error = cpcap_usb_init_interrupts(pdev, ddata);
879 ddata->comparator.set_vbus = cpcap_charger_set_vbus;
880 error = omap_usb2_set_comparator(&ddata->comparator);
882 dev_info(ddata->dev, "charger needs phy, deferring probe\n");
886 cpcap_charger_init_optional_gpios(ddata);
888 schedule_delayed_work(&ddata->detect_work, 0);
895 struct cpcap_charger_ddata *ddata = platform_get_drvdata(pdev);
898 atomic_set(&ddata->active, 0);
901 dev_warn(ddata->dev, "could not clear USB comparator: %i\n",
904 error = cpcap_charger_set_state(ddata, 0, 0, 0);
906 dev_warn(ddata->dev, "could not clear charger: %i\n",
908 cancel_delayed_work_sync(&ddata->vbus_work);
909 cancel_delayed_work_sync(&ddata->detect_work);