static int __init pm8941_charger_init(void) { int err; printk("pm8941_charger_init +\n"); err = power_supply_register(NULL, &usb_psy); if (err < 0) { printk("power_supply_register usb failed rc = %d\n", err); } err = power_supply_register(NULL, &main_psy); if (err < 0) { printk("power_supply_register ac failed rc = %d\n", err); } //Eason: AICL work around +++ INIT_DELAYED_WORK(&AICLWorker,checkAICL); //Eason: AICL work around --- create_pm8941_proc_file(); return err; }
static int pcf50633_mbc_probe(struct platform_device *pdev) { struct power_supply_config psy_cfg = {}; struct pcf50633_mbc *mbc; int i; u8 mbcs1; mbc = devm_kzalloc(&pdev->dev, sizeof(*mbc), GFP_KERNEL); if (!mbc) return -ENOMEM; platform_set_drvdata(pdev, mbc); mbc->pcf = dev_to_pcf50633(pdev->dev.parent); /* Set up IRQ handlers */ for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++) pcf50633_register_irq(mbc->pcf, mbc_irq_handlers[i], pcf50633_mbc_irq_handler, mbc); psy_cfg.supplied_to = mbc->pcf->pdata->batteries; psy_cfg.num_supplicants = mbc->pcf->pdata->num_batteries; psy_cfg.drv_data = mbc; /* Create power supplies */ mbc->adapter = power_supply_register(&pdev->dev, &pcf50633_mbc_adapter_desc, &psy_cfg); if (IS_ERR(mbc->adapter)) { dev_err(mbc->pcf->dev, "failed to register adapter\n"); return PTR_ERR(mbc->adapter); } mbc->usb = power_supply_register(&pdev->dev, &pcf50633_mbc_usb_desc, &psy_cfg); if (IS_ERR(mbc->usb)) { dev_err(mbc->pcf->dev, "failed to register usb\n"); power_supply_unregister(mbc->adapter); return PTR_ERR(mbc->usb); } mbc->ac = power_supply_register(&pdev->dev, &pcf50633_mbc_ac_desc, &psy_cfg); if (IS_ERR(mbc->ac)) { dev_err(mbc->pcf->dev, "failed to register ac\n"); power_supply_unregister(mbc->adapter); power_supply_unregister(mbc->usb); return PTR_ERR(mbc->ac); } if (sysfs_create_group(&pdev->dev.kobj, &mbc_attr_group)) dev_err(mbc->pcf->dev, "failed to create sysfs entries\n"); mbcs1 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS1); if (mbcs1 & PCF50633_MBCS1_USBPRES) pcf50633_mbc_irq_handler(PCF50633_IRQ_USBINS, mbc); if (mbcs1 & PCF50633_MBCS1_ADAPTPRES) pcf50633_mbc_irq_handler(PCF50633_IRQ_ADPINS, mbc); return 0; }
static int __devinit battery_probe(struct platform_device *dev) { int ret; printk("%s:\n",__FUNCTION__); ret = power_supply_register(&dev->dev, &psy_ac); if (ret) goto err_psy_reg_ac; ret = power_supply_register(&dev->dev, &psy_usb); if (ret) goto err_psy_reg_usb; ret = power_supply_register(&dev->dev, &psy_battery); if (ret) goto err_psy_reg_battery; printk("%s: return 0\n",__FUNCTION__); return 0; err_psy_reg_battery: power_supply_unregister(&psy_usb); err_psy_reg_usb: power_supply_unregister(&psy_ac); err_psy_reg_ac: printk("%s: return %d\n",__FUNCTION__, ret); return ret; }
static int lp8788_psy_register(struct platform_device *pdev, struct lp8788_charger *pchg) { pchg->charger.name = LP8788_CHARGER_NAME; pchg->charger.type = POWER_SUPPLY_TYPE_MAINS; pchg->charger.properties = lp8788_charger_prop; pchg->charger.num_properties = ARRAY_SIZE(lp8788_charger_prop); pchg->charger.get_property = lp8788_charger_get_property; pchg->charger.supplied_to = battery_supplied_to; pchg->charger.num_supplicants = ARRAY_SIZE(battery_supplied_to); if (power_supply_register(&pdev->dev, &pchg->charger)) return -EPERM; pchg->battery.name = LP8788_BATTERY_NAME; pchg->battery.type = POWER_SUPPLY_TYPE_BATTERY; pchg->battery.properties = lp8788_battery_prop; pchg->battery.num_properties = ARRAY_SIZE(lp8788_battery_prop); pchg->battery.get_property = lp8788_battery_get_property; if (power_supply_register(&pdev->dev, &pchg->battery)) { power_supply_unregister(&pchg->charger); return -EPERM; } return 0; }
static int __init android_bat_init(void) { int ret = 0; bat_pdev = platform_device_register_simple("battery", 0, NULL, 0); ret = power_supply_register(&bat_pdev->dev, &android_ac); if (ret) goto ac_failed; android_bat.name = bat_pdev->name; ret = power_supply_register(&bat_pdev->dev, &android_bat); if (ret) goto battery_failed; goto success; power_supply_unregister(&android_bat); battery_failed: power_supply_unregister(&android_ac); ac_failed: platform_device_unregister(bat_pdev); success: return ret; }
static int htc_battery_probe(struct platform_device *pdev) { struct rpc_request_hdr req; struct htc_get_batt_info_rep { struct rpc_reply_hdr hdr; struct battery_info_reply info; } rep; int rc; endpoint = msm_rpc_connect(APP_BATT_PROG, APP_BATT_VER, 0); if (IS_ERR(endpoint)) { printk(KERN_ERR "%s: init rpc failed! rc = %ld\n", __FUNCTION__, PTR_ERR(endpoint)); return PTR_ERR(endpoint); } /* must do this or we won't get cable status updates */ rc = msm_rpc_call_reply(endpoint, HTC_PROCEDURE_GET_BATT_INFO, &req, sizeof(req), &rep, sizeof(rep), 5 * HZ); if (rc < 0) printk(KERN_ERR "%s: get info failed\n", __FUNCTION__); power_supply_register(&pdev->dev, &ac_supply); power_supply_register(&pdev->dev, &usb_supply); return 0; }
static int __init adbattery_init(void) { int ret = 0; adbattery_pdev = platform_device_register_simple("battery", 0, NULL, 0); if (IS_ERR(adbattery_pdev)) return PTR_ERR(adbattery_pdev); ret = power_supply_register(&adbattery_pdev->dev, &adbattery_bat); if (ret) goto bat_failed; ret = power_supply_register(&adbattery_pdev->dev, &adbattery_ac); if (ret) goto ac_failed; ret = power_supply_register(&adbattery_pdev->dev, &adbattery_usb); if (ret) goto usb_failed; printk(KERN_INFO "adbattery: android dummy battery driver loaded\n"); goto success; bat_failed: power_supply_unregister(&adbattery_bat); ac_failed: power_supply_unregister(&adbattery_ac); usb_failed: power_supply_unregister(&adbattery_usb); platform_device_unregister(adbattery_pdev); success: return ret; }
static int __init olpc_bat_init(void) { int ret = 0; uint8_t status; if (!olpc_platform_info.ecver) return -ENXIO; /* * We've seen a number of EC protocol changes; this driver requires * the latest EC protocol, supported by 0x44 and above. */ if (olpc_platform_info.ecver < 0x44) { printk(KERN_NOTICE "OLPC EC version 0x%02x too old for " "battery driver.\n", olpc_platform_info.ecver); return -ENXIO; } ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1); if (ret) return ret; /* Ignore the status. It doesn't actually matter */ bat_pdev = platform_device_register_simple("olpc-battery", 0, NULL, 0); if (IS_ERR(bat_pdev)) return PTR_ERR(bat_pdev); ret = power_supply_register(&bat_pdev->dev, &olpc_ac); if (ret) goto ac_failed; olpc_bat.name = bat_pdev->name; ret = power_supply_register(&bat_pdev->dev, &olpc_bat); if (ret) goto battery_failed; ret = device_create_bin_file(olpc_bat.dev, &olpc_bat_eeprom); if (ret) goto eeprom_failed; ret = device_create_file(olpc_bat.dev, &olpc_bat_error); if (ret) goto error_failed; goto success; error_failed: device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom); eeprom_failed: power_supply_unregister(&olpc_bat); battery_failed: power_supply_unregister(&olpc_ac); ac_failed: platform_device_unregister(bat_pdev); success: return ret; }
static int zeus_power_probe(struct platform_device *pdev) { power_supply_register(&pdev->dev, &ac_supply); power_supply_register(&pdev->dev, &usb_supply); return 0; }
static __devinit int wm8350_power_probe(struct platform_device *pdev) { struct wm8350 *wm8350 = platform_get_drvdata(pdev); struct wm8350_power *power = &wm8350->power; struct wm8350_charger_policy *policy = power->policy; struct power_supply *usb = &power->usb; struct power_supply *battery = &power->battery; struct power_supply *ac = &power->ac; int ret; ac->name = "wm8350-ac"; ac->type = POWER_SUPPLY_TYPE_MAINS; ac->properties = wm8350_ac_props; ac->num_properties = ARRAY_SIZE(wm8350_ac_props); ac->get_property = wm8350_ac_get_prop; ret = power_supply_register(&pdev->dev, ac); if (ret) return ret; battery->name = "wm8350-battery"; battery->properties = wm8350_bat_props; battery->num_properties = ARRAY_SIZE(wm8350_bat_props); battery->get_property = wm8350_bat_get_property; battery->use_for_apm = 1; ret = power_supply_register(&pdev->dev, battery); if (ret) goto battery_failed; usb->name = "wm8350-usb", usb->type = POWER_SUPPLY_TYPE_USB; usb->properties = wm8350_usb_props; usb->num_properties = ARRAY_SIZE(wm8350_usb_props); usb->get_property = wm8350_usb_get_prop; ret = power_supply_register(&pdev->dev, usb); if (ret) goto usb_failed; ret = device_create_file(&pdev->dev, &dev_attr_charger_state); if (ret < 0) dev_warn(wm8350->dev, "failed to add charge sysfs: %d\n", ret); ret = 0; wm8350_init_charger(wm8350); if (wm8350_charger_config(wm8350, policy) == 0) { wm8350_reg_unlock(wm8350); wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CHG_ENA); wm8350_reg_lock(wm8350); } return ret; usb_failed: power_supply_unregister(battery); battery_failed: power_supply_unregister(ac); return ret; }
static int acpower_battery_probe(struct platform_device *pdev) { int ret; struct acpower_battery_data *data; data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) { ret = -ENOMEM; goto err_data_alloc_failed; } spin_lock_init(&data->lock); data->battery.properties = acpower_battery_props; data->battery.num_properties = ARRAY_SIZE(acpower_battery_props); data->battery.get_property = acpower_battery_get_property; data->battery.name = "battery"; data->battery.type = POWER_SUPPLY_TYPE_BATTERY; data->ac.properties = acpower_ac_props; data->ac.num_properties = ARRAY_SIZE(acpower_ac_props); data->ac.get_property = acpower_ac_get_property; data->ac.name = "ac"; data->ac.type = POWER_SUPPLY_TYPE_MAINS; data->usb.properties = acpower_usb_props; data->usb.num_properties = ARRAY_SIZE(acpower_usb_props); data->usb.get_property = acpower_usb_get_property; data->usb.name = "usb"; data->usb.type = POWER_SUPPLY_TYPE_USB; ret = power_supply_register(&pdev->dev, &data->ac); if (ret) goto err_ac_failed; ret = power_supply_register(&pdev->dev, &data->battery); if (ret) goto err_battery_failed; ret = power_supply_register(&pdev->dev, &data->usb); if (ret) goto err_usb_failed; platform_set_drvdata(pdev, data); battery_data = data; return 0; err_usb_failed: power_supply_unregister(&data->usb); err_battery_failed: power_supply_unregister(&data->ac); err_ac_failed: kfree(data); err_data_alloc_failed: return ret; }
static int bq3060_battery_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct bq3060_device_info *di; int retval = 0; u8 buf[2]; di = kzalloc(sizeof(*di), GFP_KERNEL); if (!di) { dev_err(&client->dev, "failed to allocate device info data\n"); retval = -ENOMEM; goto batt_failed_2; } i2c_set_clientdata(client, di); di->dev = &client->dev; di->bat.name = "bq3060-battery"; di->client = client; /* 4 seconds between monotor runs interval */ di->interval = msecs_to_jiffies(1 * 1000); gpio_request(DC_CHECK_PIN,"dc_check"); gpio_direction_input(DC_CHECK_PIN); bq3060_powersupply_init(di); buf[0] = 0x41; buf[1] = 0x00; bq3060_write(di->client,0x00,buf,2); buf[0] = 0x21; buf[1] = 0x00; bq3060_write(di->client,0x00,buf,2); retval = power_supply_register(&client->dev, &di->bat); if (retval) { dev_err(&client->dev, "failed to register battery\n"); goto batt_failed_4; } //retval = power_supply_register(&client->dev, &di->usb); if (retval) { dev_err(&client->dev, "failed to register usb battery\n"); goto batt_failed_4; } retval = power_supply_register(&client->dev, &di->ac); if (retval) { dev_err(&client->dev, "failed to register ac adapter\n"); goto batt_failed_4; } INIT_DELAYED_WORK(&di->work, bq3060_battery_work); schedule_delayed_work(&di->work, di->interval); dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION); return 0; batt_failed_4: kfree(di); batt_failed_2: return retval; }
static int __init olpc_bat_init(void) { int ret = 0; uint8_t status; if (!olpc_platform_info.ecver) return -ENXIO; if (olpc_platform_info.ecver < 0x44) { printk(KERN_NOTICE "OLPC EC version 0x%02x too old for " "battery driver.\n", olpc_platform_info.ecver); return -ENXIO; } ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1); if (ret) return ret; bat_pdev = platform_device_register_simple("olpc-battery", 0, NULL, 0); if (IS_ERR(bat_pdev)) return PTR_ERR(bat_pdev); ret = power_supply_register(&bat_pdev->dev, &olpc_ac); if (ret) goto ac_failed; olpc_bat.name = bat_pdev->name; ret = power_supply_register(&bat_pdev->dev, &olpc_bat); if (ret) goto battery_failed; ret = device_create_bin_file(olpc_bat.dev, &olpc_bat_eeprom); if (ret) goto eeprom_failed; ret = device_create_file(olpc_bat.dev, &olpc_bat_error); if (ret) goto error_failed; goto success; error_failed: device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom); eeprom_failed: power_supply_unregister(&olpc_bat); battery_failed: power_supply_unregister(&olpc_ac); ac_failed: platform_device_unregister(bat_pdev); success: return ret; }
static int goldfish_battery_probe(struct platform_device *pdev) { int ret; struct resource *r; struct goldfish_battery_data *data; struct power_supply_config psy_cfg = {}; data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; spin_lock_init(&data->lock); r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (r == NULL) { dev_err(&pdev->dev, "platform_get_resource failed\n"); return -ENODEV; } data->reg_base = devm_ioremap(&pdev->dev, r->start, resource_size(r)); if (data->reg_base == NULL) { dev_err(&pdev->dev, "unable to remap MMIO\n"); return -ENOMEM; } data->irq = platform_get_irq(pdev, 0); if (data->irq < 0) { dev_err(&pdev->dev, "platform_get_irq failed\n"); return -ENODEV; } ret = devm_request_irq(&pdev->dev, data->irq, goldfish_battery_interrupt, IRQF_SHARED, pdev->name, data); if (ret) return ret; psy_cfg.drv_data = data; data->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg); if (IS_ERR(data->ac)) return PTR_ERR(data->ac); data->battery = power_supply_register(&pdev->dev, &battery_desc, &psy_cfg); if (IS_ERR(data->battery)) { power_supply_unregister(data->ac); return PTR_ERR(data->battery); } platform_set_drvdata(pdev, data); GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK); return 0; }
static int __init pmu_bat_init(void) { int ret; int i; bat_pdev = platform_device_register_simple("pmu-battery", 0, NULL, 0); if (IS_ERR(bat_pdev)) { ret = PTR_ERR(bat_pdev); goto pdev_register_failed; } ret = power_supply_register(&bat_pdev->dev, &pmu_ac); if (ret) goto ac_register_failed; for (i = 0; i < pmu_battery_count; i++) { struct pmu_battery_dev *pbat = kzalloc(sizeof(*pbat), GFP_KERNEL); if (!pbat) break; sprintf(pbat->name, "PMU_battery_%d", i); pbat->bat.name = pbat->name; pbat->bat.properties = pmu_bat_props; pbat->bat.num_properties = ARRAY_SIZE(pmu_bat_props); pbat->bat.get_property = pmu_bat_get_property; pbat->pbi = &pmu_batteries[i]; ret = power_supply_register(&bat_pdev->dev, &pbat->bat); if (ret) { kfree(pbat); goto battery_register_failed; } pbats[i] = pbat; } goto success; battery_register_failed: while (i--) { if (!pbats[i]) continue; power_supply_unregister(&pbats[i]->bat); kfree(pbats[i]); } power_supply_unregister(&pmu_ac); ac_register_failed: platform_device_unregister(bat_pdev); pdev_register_failed: success: return ret; }
static int lp8727_register_psy(struct lp8727_chg *pchg) { struct lp8727_psy *psy; psy = devm_kzalloc(pchg->dev, sizeof(*psy), GFP_KERNEL); if (!psy) return -ENOMEM; pchg->psy = psy; psy->ac.name = "ac"; psy->ac.type = POWER_SUPPLY_TYPE_MAINS; psy->ac.properties = lp8727_charger_prop; psy->ac.num_properties = ARRAY_SIZE(lp8727_charger_prop); psy->ac.get_property = lp8727_charger_get_property; psy->ac.supplied_to = battery_supplied_to; psy->ac.num_supplicants = ARRAY_SIZE(battery_supplied_to); if (power_supply_register(pchg->dev, &psy->ac)) goto err_psy_ac; psy->usb.name = "usb"; psy->usb.type = POWER_SUPPLY_TYPE_USB; psy->usb.properties = lp8727_charger_prop; psy->usb.num_properties = ARRAY_SIZE(lp8727_charger_prop); psy->usb.get_property = lp8727_charger_get_property; psy->usb.supplied_to = battery_supplied_to; psy->usb.num_supplicants = ARRAY_SIZE(battery_supplied_to); if (power_supply_register(pchg->dev, &psy->usb)) goto err_psy_usb; psy->batt.name = "main_batt"; psy->batt.type = POWER_SUPPLY_TYPE_BATTERY; psy->batt.properties = lp8727_battery_prop; psy->batt.num_properties = ARRAY_SIZE(lp8727_battery_prop); psy->batt.get_property = lp8727_battery_get_property; psy->batt.external_power_changed = lp8727_charger_changed; if (power_supply_register(pchg->dev, &psy->batt)) goto err_psy_batt; return 0; err_psy_batt: power_supply_unregister(&psy->usb); err_psy_usb: power_supply_unregister(&psy->ac); err_psy_ac: return -EPERM; }
static int ec_battery_probe(struct platform_device *pdev) { struct ec_battery_info *chip; int ret; chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (!chip) { dev_err(&pdev->dev, "mem alloc failed\n"); return -ENOMEM; } chip->pdev = pdev; platform_set_drvdata(pdev, chip); mutex_init(&chip->lock); chip->bat.name = "byt_battery"; chip->bat.type = POWER_SUPPLY_TYPE_BATTERY; chip->bat.properties = ec_battery_props; chip->bat.num_properties = ARRAY_SIZE(ec_battery_props); chip->bat.get_property = ec_get_battery_property; ret = power_supply_register(&pdev->dev, &chip->bat); if (ret) { dev_err(&pdev->dev, "failed to register battery: %d\n", ret); goto probe_failed_1; } chip->chrg.name = "byt_charger"; chip->chrg.type = POWER_SUPPLY_TYPE_MAINS; chip->chrg.properties = ec_charger_properties; chip->chrg.num_properties = ARRAY_SIZE(ec_charger_properties); chip->chrg.get_property = ec_get_charger_property; ret = power_supply_register(&pdev->dev, &chip->chrg); if (ret) { dev_err(&pdev->dev, "failed to register charger: %d\n", ret); goto probe_failed_2; } /* register for EC SCI events */ chip->nb.notifier_call = &byt_ec_evt_batt_callback; byt_ec_evt_register_notify(&chip->nb); return 0; probe_failed_2: power_supply_unregister(&chip->bat); probe_failed_1: kfree(chip); return ret; }
static int tegra_battery_probe(struct platform_device *pdev) { int i, rc; NvBool result; batt_dev = kzalloc(sizeof(*batt_dev), GFP_KERNEL); if (!batt_dev) { return -ENOMEM; } memset(batt_dev, 0, sizeof(*batt_dev)); /* Assume battery is present at start */ batt_dev->present = 1; batt_dev->batt_id = 0; batt_dev->charging_source = NvCharger_Type_AC; batt_dev->charging_enabled = NvCharge_Control_Charging_Enable; result = NvOdmBatteryDeviceOpen(&(batt_dev->hOdmBattDev), NULL); if (!result) { pr_err("NvOdmBatteryDeviceOpen FAILED\n"); goto err; } for (i = 0; i < ARRAY_SIZE(tegra_supplies); i++) { rc = power_supply_register(&pdev->dev, &tegra_supplies[i]); if (rc) { printk(KERN_ERR "Failed to register power supply\n"); while (i--) power_supply_unregister(&tegra_supplies[i]); kfree(batt_dev); return rc; } } printk(KERN_INFO "%s: battery driver registered\n", pdev->name); batt_dev->batt_status_poll_period = NVBATTERY_POLLING_INTERVAL; setup_timer(&(batt_dev->battery_poll_timer), tegra_battery_poll_timer_func, 0); mod_timer(&(batt_dev->battery_poll_timer), jiffies + msecs_to_jiffies(batt_dev->batt_status_poll_period)); rc = device_create_file(&pdev->dev, &tegra_battery_attr); if (rc) { for (i = 0; i < ARRAY_SIZE(tegra_supplies); i++) { power_supply_unregister(&tegra_supplies[i]); } del_timer_sync(&(batt_dev->battery_poll_timer)); pr_err("tegra_battery_probe:device_create_file FAILED"); return rc; } return 0; err: if (batt_dev) { kfree(batt_dev); batt_dev = NULL; } return -1; }
static int __init exynos5_manta_battery_late_init(void) { int ret; struct usb_phy *usb_xceiv; ret = power_supply_register(NULL, &manta_battery_psy); if (ret) pr_err("%s: failed to register power_supply\n", __func__); ret = request_threaded_irq(gpio_to_irq(GPIO_OTG_VBUS_SENSE), NULL, ta_int_intr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "usb_vbus", NULL); if (ret) { pr_err("%s: usb_vbus irq register failed, ret=%d\n", __func__, ret); } else { ret = enable_irq_wake(gpio_to_irq(GPIO_OTG_VBUS_SENSE)); if (ret) pr_warn("%s: failed to enable irq_wake for usb_vbus\n", __func__); } ret = request_threaded_irq(gpio_to_irq(GPIO_VBUS_POGO_5V), NULL, ta_int_intr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "pogo_vbus", NULL); if (ret) { pr_err("%s: pogo_vbus irq register failed, ret=%d\n", __func__, ret); } else { ret = enable_irq_wake(gpio_to_irq(GPIO_VBUS_POGO_5V)); if (ret) pr_warn("%s: failed to enable irq_wake for pogo_vbus\n", __func__); } ret = register_pm_notifier(&exynos5_manta_battery_pm_notifier_block); if (ret) pr_warn("%s: failed to register PM notifier; ret=%d\n", __func__, ret); usb_xceiv = usb_get_transceiver(); if (!usb_xceiv) { pr_err("%s: No USB transceiver found\n", __func__); } else { ret = usb_register_notifier(usb_xceiv, &manta_bat_usb_nb); if (ret) { pr_err("%s: usb_register_notifier on transceiver %s failed\n", __func__, dev_name(usb_xceiv->dev)); } } /* get initial charger status */ change_charger_status(false, false); return 0; }
int sample_battery_init(void) { int ret; memset(&sample_battery_psy, 0, sizeof(sample_battery_psy)); sample_battery_psy.name = "sample_battery"; sample_battery_psy.type = POWER_SUPPLY_TYPE_BATTERY; sample_battery_psy.properties = sample_battery_props; sample_battery_psy.num_properties = ARRAY_SIZE(sample_battery_props); sample_battery_psy.get_property = sample_battery_get_property; sample_battery_psy.external_power_changed = sample_battery_ext_power_changed; ret = power_supply_register(NULL, &sample_battery_psy); if (ret) { printk("ERROR: power_supply_register failed (ret=%d)\n", ret); return ret; } printk("Sample battery registered\n"); init_timer(&sample_battery_timer); sample_battery_timer.function = sample_battery_timer_func; sample_battery_timer.expires = jiffies + msecs_to_jiffies(interval); add_timer(&sample_battery_timer); return 0; }
static int micro_batt_probe (struct platform_device *pdev) { if (1) printk(KERN_ERR "micro battery probe : begin\n"); power_supply_register(&pdev->dev, &h3600_battery); { /*--- callback ---*/ p_micro = platform_get_drvdata(pdev); spin_lock(p_micro->lock); p_micro->h_batt = micro_battery_receive; p_micro->h_temp = micro_temperature_receive; spin_unlock(p_micro->lock); } { /*--- timer ---*/ init_timer(&batt_timer); batt_timer.expires = jiffies + BATT_PERIOD; batt_timer.data = 0; batt_timer.function = h3600_battery_read_status; add_timer(&batt_timer); } if (1) printk(KERN_ERR "micro battery probe : end\n"); return 0; }
static int twl4030_madc_battery_probe(struct platform_device *pdev) { struct twl4030_madc_battery *twl4030_madc_bat; struct twl4030_madc_bat_platform_data *pdata = pdev->dev.platform_data; struct power_supply_config psy_cfg = {}; int ret = 0; twl4030_madc_bat = devm_kzalloc(&pdev->dev, sizeof(*twl4030_madc_bat), GFP_KERNEL); if (!twl4030_madc_bat) return -ENOMEM; twl4030_madc_bat->channel_temp = iio_channel_get(&pdev->dev, "temp"); if (IS_ERR(twl4030_madc_bat->channel_temp)) { ret = PTR_ERR(twl4030_madc_bat->channel_temp); goto err; } twl4030_madc_bat->channel_ichg = iio_channel_get(&pdev->dev, "ichg"); if (IS_ERR(twl4030_madc_bat->channel_ichg)) { ret = PTR_ERR(twl4030_madc_bat->channel_ichg); goto err_temp; } twl4030_madc_bat->channel_vbat = iio_channel_get(&pdev->dev, "vbat"); if (IS_ERR(twl4030_madc_bat->channel_vbat)) { ret = PTR_ERR(twl4030_madc_bat->channel_vbat); goto err_ichg; } /* sort charging and discharging calibration data */ sort(pdata->charging, pdata->charging_size, sizeof(struct twl4030_madc_bat_calibration), twl4030_cmp, NULL); sort(pdata->discharging, pdata->discharging_size, sizeof(struct twl4030_madc_bat_calibration), twl4030_cmp, NULL); twl4030_madc_bat->pdata = pdata; platform_set_drvdata(pdev, twl4030_madc_bat); psy_cfg.drv_data = twl4030_madc_bat; twl4030_madc_bat->psy = power_supply_register(&pdev->dev, &twl4030_madc_bat_desc, &psy_cfg); if (IS_ERR(twl4030_madc_bat->psy)) { ret = PTR_ERR(twl4030_madc_bat->psy); goto err_vbat; } return 0; err_vbat: iio_channel_release(twl4030_madc_bat->channel_vbat); err_ichg: iio_channel_release(twl4030_madc_bat->channel_ichg); err_temp: iio_channel_release(twl4030_madc_bat->channel_temp); err: return ret; }
static int rt_battery_probe(struct platform_device *pdev) { struct rt_battery_info *rbi; int ret; rbi = devm_kzalloc(&pdev->dev, sizeof(*rbi), GFP_KERNEL); if (!rbi) return -ENOMEM; rbi->dev = &pdev->dev; rbi->chg_status = POWER_SUPPLY_STATUS_DISCHARGING; rbi->batt_present = 1; platform_set_drvdata(pdev, rbi); rbi->psy.name = RT_BATT_NAME; rbi->psy.type = POWER_SUPPLY_TYPE_BATTERY; rbi->psy.set_property = rt_battery_set_property; rbi->psy.get_property = rt_battery_get_property; rbi->psy.properties = rt_battery_props; rbi->psy.num_properties = ARRAY_SIZE(rt_battery_props); ret = power_supply_register(&pdev->dev, &rbi->psy); if (ret < 0) { dev_err(&pdev->dev, "battery supply registered fail\n"); goto out_dev; } dev_info(&pdev->dev, "driver successfully loaded\n"); return 0; out_dev: return ret; }
static int __init test_power_init(void) { int i; int ret; struct device_node *dev_node; dev_node = of_find_node_by_name(NULL, "test-power"); if (IS_ERR_OR_NULL(dev_node)) { pr_info("not find %s dev node\n", __func__); return 0; } if (!of_device_is_available(dev_node)) { pr_info("test power disabled\n"); return 0; } for (i = 0; i < ARRAY_SIZE(test_power_supplies); i++) { ret = power_supply_register(NULL, &test_power_supplies[i]); if (ret) { pr_err("%s: failed to register %s\n", __func__, test_power_supplies[i].name); goto failed; } } module_initialized = true; return 0; failed: while (--i >= 0) power_supply_unregister(&test_power_supplies[i]); return ret; }
static int twl4030_madc_battery_probe(struct platform_device *pdev) { struct twl4030_madc_battery *twl4030_madc_bat; struct twl4030_madc_bat_platform_data *pdata = pdev->dev.platform_data; twl4030_madc_bat = kzalloc(sizeof(*twl4030_madc_bat), GFP_KERNEL); if (!twl4030_madc_bat) return -ENOMEM; twl4030_madc_bat->psy.name = "twl4030_battery"; twl4030_madc_bat->psy.type = POWER_SUPPLY_TYPE_BATTERY; twl4030_madc_bat->psy.properties = twl4030_madc_bat_props; twl4030_madc_bat->psy.num_properties = ARRAY_SIZE(twl4030_madc_bat_props); twl4030_madc_bat->psy.get_property = twl4030_madc_bat_get_property; twl4030_madc_bat->psy.external_power_changed = twl4030_madc_bat_ext_changed; /* sort charging and discharging calibration data */ sort(pdata->charging, pdata->charging_size, sizeof(struct twl4030_madc_bat_calibration), twl4030_cmp, NULL); sort(pdata->discharging, pdata->discharging_size, sizeof(struct twl4030_madc_bat_calibration), twl4030_cmp, NULL); twl4030_madc_bat->pdata = pdata; platform_set_drvdata(pdev, twl4030_madc_bat); power_supply_register(&pdev->dev, &twl4030_madc_bat->psy); return 0; }
static int bq27x00_powersupply_init(struct bq27x00_device_info *di) { int ret; di->bat.type = POWER_SUPPLY_TYPE_BATTERY; di->chip = BQ27425; if (di->chip == BQ27425) { di->bat.properties = bq27425_battery_props; di->bat.num_properties = ARRAY_SIZE(bq27425_battery_props); } else { di->bat.properties = bq27x00_battery_props; di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props); } di->bat.get_property = bq27x00_battery_get_property; di->bat.external_power_changed = bq27x00_external_power_changed; INIT_DELAYED_WORK(&di->work, bq27x00_battery_poll); mutex_init(&di->lock); ret = power_supply_register(di->dev, &di->bat); if (ret) { dev_err(di->dev, "failed to register battery: %d\n", ret); return ret; } dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION); bq27x00_update(di); return 0; }
static int rx51_battery_probe(struct platform_device *pdev) { struct rx51_device_info *di; int ret; di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL); if (!di) return -ENOMEM; platform_set_drvdata(pdev, di); di->bat.name = dev_name(&pdev->dev); di->bat.type = POWER_SUPPLY_TYPE_BATTERY; di->bat.properties = rx51_battery_props; di->bat.num_properties = ARRAY_SIZE(rx51_battery_props); di->bat.get_property = rx51_battery_get_property; ret = power_supply_register(di->dev, &di->bat); if (ret) { platform_set_drvdata(pdev, NULL); return ret; } return 0; }
/* * imx6_usb_create_charger - create a USB charger * @charger: the charger to be initialized * @name: name for the power supply * Registers a power supply for the charger. The USB Controller * driver will call this after filling struct usb_charger. */ int imx6_usb_create_charger(struct usb_charger *charger, const char *name) { struct power_supply *psy = &charger->psy; if (!charger->dev) return -EINVAL; if (name) psy->name = name; else psy->name = "imx6_usb_charger"; charger->bc = BATTERY_CHARGING_SPEC_1_2; mutex_init(&charger->lock); psy->type = POWER_SUPPLY_TYPE_MAINS; psy->properties = imx6_usb_charger_power_props; psy->num_properties = ARRAY_SIZE(imx6_usb_charger_power_props); psy->get_property = imx6_usb_charger_get_property; psy->supplied_to = imx6_usb_charger_supplied_to; psy->num_supplicants = sizeof(imx6_usb_charger_supplied_to) / sizeof(char *); return power_supply_register(charger->dev, psy); }
static int __init test_power_init(void) { int i; int ret; BUILD_BUG_ON(TEST_POWER_NUM != ARRAY_SIZE(test_power_supplies)); BUILD_BUG_ON(TEST_POWER_NUM != ARRAY_SIZE(test_power_configs)); for (i = 0; i < ARRAY_SIZE(test_power_supplies); i++) { test_power_supplies[i] = power_supply_register(NULL, &test_power_desc[i], &test_power_configs[i]); if (IS_ERR(test_power_supplies[i])) { pr_err("%s: failed to register %s\n", __func__, test_power_desc[i].name); ret = PTR_ERR(test_power_supplies[i]); goto failed; } } module_initialized = true; return 0; failed: while (--i >= 0) power_supply_unregister(test_power_supplies[i]); return ret; }
static __devinit int max8998_power_probe(struct platform_device *pdev) { struct max8998_dev *chip = dev_get_drvdata(pdev->dev.parent); struct max8998_platform_data *max8998_pdata; struct max8998_power_data *pdata = NULL; struct max8998_power_info *info; int ret, i; if (pdev->dev.parent->platform_data) { max8998_pdata = pdev->dev.parent->platform_data; pdata = max8998_pdata->power; } if (!pdata) { dev_err(&pdev->dev, "platform data isn't assigned to " "power supply\n"); return -EINVAL; } info = kzalloc(sizeof(struct max8998_power_info), GFP_KERNEL); if (!info) return -ENOMEM; info->chip = chip; info->i2c = chip->i2c; info->batt_detect = pdata->batt_detect; info->topoff_threshold = pdata->topoff_threshold; info->fast_charge = pdata->fast_charge; info->set_charger = pdata->set_charger; info->ac_online = 0; info->usb_online = 0; info->bat_online = 0; wake_lock_init(&info->vbus_wake_lock, WAKE_LOCK_SUSPEND, "vbus_present"); dev_set_drvdata(&pdev->dev, info); platform_set_drvdata(pdev, info); /* init power supplier framework */ for (i = 0; i < ARRAY_SIZE(max8998_power_supplies); i++) { ret = power_supply_register(&pdev->dev, &max8998_power_supplies[i]); if (ret) { dev_err(&pdev->dev, "Failed to register" "power supply %d,%d\n", i, ret); goto __end__; } max8998_power_supplies[i].dev->parent = &pdev->dev; } max8998_check_charger(info); REQUEST_IRQ(MAX8998_IRQ_DCINF, "DCIN falling"); REQUEST_IRQ(MAX8998_IRQ_DCINR, "DCIN rising"); REQUEST_IRQ(MAX8998_IRQ_JIGF, "JIG falling"); REQUEST_IRQ(MAX8998_IRQ_JIGR, "JIG rising"); __end__: return ret; }