drivers/power/spa_ps.c - kernel/bcm - Git at Google

 /*
 * Samsung Power and Charger.
 *
 * drivers/power/spa_power.c
 *
 * Drivers for samsung battery and charger.
 * (distributed from spa.c and linear-power.c)
 *
 * Copyright (C) 2012, Samsung Electronics.
 *
 * This program is free software. You can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation
 */

 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
 #include <linux/types.h>
 #include <linux/platform_device.h>
 #include <linux/timer.h>
 #include <linux/slab.h>
 #include <linux/wakelock.h>
 #include <linux/power_supply.h>
 #include <linux/spa_power.h>

 #define BATT_TYPE "SDI_SDI"
 #define CONFIG_SEC_BATT_EXT_ATTRS

 #define SPA_MODEL_NAME_LEN 20

 struct spa_batt_status
 {
         int capacity;
         int voltage;
         int temp;
         int temp_adc;
         int present;
         int capacity_lvl;
         int status;
         int health;
         int lp_charging;
         int charging_source;


 		int ac_online;
 		int usb_online;
 };

 struct spa_ps
 {
 	struct spa_power_desc *spa_power_iter;
 	struct power_supply ac;
 	struct power_supply batt;
 	struct power_supply usb;
 	struct spa_batt_status state;
 	char model[SPA_MODEL_NAME_LEN+1];
 };

 static enum power_supply_property spa_batt_props[] = {
         POWER_SUPPLY_PROP_TECHNOLOGY,
         POWER_SUPPLY_PROP_STATUS,
         POWER_SUPPLY_PROP_PRESENT,
         POWER_SUPPLY_PROP_CAPACITY,
         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
         POWER_SUPPLY_PROP_VOLTAGE_NOW,
         POWER_SUPPLY_PROP_TEMP,
         POWER_SUPPLY_PROP_BATT_TEMP_ADC,
         POWER_SUPPLY_PROP_HEALTH,
         POWER_SUPPLY_PROP_MODEL_NAME,
 };
 static enum power_supply_property spa_charger_props[] = {
         POWER_SUPPLY_PROP_ONLINE,
 };

 static int spa_batt_get_property( struct power_supply *batt, enum power_supply_property property, union power_supply_propval *propval)
 {
 		int ret = 0;
 		struct spa_ps *spa_ps_iter =
 				container_of(batt, struct spa_ps, batt);

 		switch (property) {
 				case POWER_SUPPLY_PROP_STATUS:
 						propval->intval = spa_ps_iter->state.status;
 						break;

 				case POWER_SUPPLY_PROP_TECHNOLOGY:
 						propval->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 						break;

 				case POWER_SUPPLY_PROP_CAPACITY:
 						propval->intval = spa_ps_iter->state.capacity;
 						break;

 				case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 						propval->intval = spa_ps_iter->state.capacity_lvl;
 						break;

 				case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 						propval->intval = spa_ps_iter->state.voltage * 1000;
 						break;

 				case POWER_SUPPLY_PROP_TEMP: // Kelvin unit to Celsius (C = K - 273.15). x10ed unit
 						propval->intval = spa_ps_iter->state.temp;
 						break;

 				case POWER_SUPPLY_PROP_HEALTH:
 						propval->intval = spa_ps_iter->state.health;
 						break;

 				case POWER_SUPPLY_PROP_PRESENT:
 						propval->intval = spa_ps_iter->state.present;
 						break;

 				case POWER_SUPPLY_PROP_MODEL_NAME:
 						propval->strval = spa_ps_iter->model;
 						break;

 				case POWER_SUPPLY_PROP_BATT_TEMP_ADC:
 						propval->intval = spa_ps_iter->state.temp_adc;
 						break;
 				default:
 						ret = -EINVAL;
 						break;
 		}

 		return ret;

 }

 static int spa_batt_set_property( struct power_supply *batt, enum power_supply_property property, union power_supply_propval *propval)
 {
 		int ret = 0;
 		struct spa_ps *spa_ps_iter = container_of(batt,struct spa_ps, batt);
 		switch (property) {
 				case POWER_SUPPLY_PROP_STATUS:
 						spa_ps_iter->state.status = propval->intval;
 						break;

 				case POWER_SUPPLY_PROP_CAPACITY:
 						spa_ps_iter->state.capacity = propval->intval;
 						break;

 				case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 						spa_ps_iter->state.capacity_lvl = propval->intval;
 						break;

 				case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 						spa_ps_iter->state.voltage = propval->intval;
 						break;

 				case POWER_SUPPLY_PROP_TEMP: // Celsius to Kelvin ( K = C + 273.15). x10ed unit
 						spa_ps_iter->state.temp = propval->intval;
 						break;

 				case POWER_SUPPLY_PROP_HEALTH:
 						spa_ps_iter->state.health = propval->intval;
 						break;

 				case POWER_SUPPLY_PROP_PRESENT:
 						spa_ps_iter->state.present = propval->intval;
 						break;

 				case POWER_SUPPLY_PROP_MODEL_NAME:
 						strncpy(spa_ps_iter->model, propval->strval, SPA_MODEL_NAME_LEN);
 						break;

 				case POWER_SUPPLY_PROP_BATT_TEMP_ADC:
 						spa_ps_iter->state.temp_adc = propval->intval;
 						break;

 				default:
 						ret = -EINVAL;
 						break;
 		}
 		return ret;
 }

 static int spa_ac_get_property( struct power_supply *ac, enum power_supply_property property, union power_supply_propval *propval)
 {
 		int ret = 0;
 		struct spa_ps *spa_ps_iter = container_of(ac,struct spa_ps, ac);

 		switch(property)
 		{
 			case POWER_SUPPLY_PROP_ONLINE:
 				propval->intval = spa_ps_iter->state.ac_online;
 				break;
 			default:
 				break;
 		}

 		return ret;
 }

 static int spa_ac_set_property( struct power_supply *ac, enum power_supply_property property, union power_supply_propval *propval)
 {
 		int ret = 0;
 		struct spa_ps *spa_ps_iter = container_of(ac,struct spa_ps, ac);

 		switch(property)
 		{
 			case POWER_SUPPLY_PROP_ONLINE:
 				spa_ps_iter->state.ac_online = propval->intval;
 				break;
 			default:
 				break;
 		}

 		return ret;
 }

 static int spa_usb_get_property( struct power_supply *usb, enum power_supply_property property, union power_supply_propval *propval)
 {
 		int ret = 0;
 		struct spa_ps *spa_ps_iter = container_of(usb,struct spa_ps, usb);

 		switch(property)
 		{
 			case POWER_SUPPLY_PROP_ONLINE:
 				propval->intval = spa_ps_iter->state.usb_online;
 				break;
 			default:
 				break;
 		}

 		return ret;
 }

 static int spa_usb_set_property( struct power_supply *usb, enum power_supply_property property, union power_supply_propval *propval)
 {
 		int ret = 0;
 		struct spa_ps *spa_ps_iter = container_of(usb,struct spa_ps, usb);

 		switch(property)
 		{
 			case POWER_SUPPLY_PROP_ONLINE:
 				spa_ps_iter->state.usb_online = propval->intval;
 				break;
 			default:
 				break;
 		}

 		return ret;
 }

 #if 0 // defined(CONFIG_SEC_BATT_EXT_ATTRS)
 enum
 {
         SS_BATT_LP_CHARGING,
         SS_BATT_CHARGING_SOURCE,
         SS_BATT_TEMP_AVER,
         SS_BATT_TEMP_ADC_AVER,
         SS_BATT_TYPE,
         SS_BATT_READ_ADJ_SOC,
         SS_BATT_RESET_SOC,
 };

 static ssize_t ss_batt_ext_attrs_show(struct device *pdev, struct device_attribute *attr, char *buf);
 static ssize_t ss_batt_ext_attrs_store(struct device *pdev, struct device_attribute *attr, const char *buf, size_t count);

 static struct device_attribute ss_batt_ext_attrs[]=
 {
         __ATTR(batt_lp_charging, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
         __ATTR(batt_charging_source, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
         __ATTR(batt_temp_aver, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
         __ATTR(batt_temp_adc_aver, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
         __ATTR(batt_type, 0644, ss_batt_ext_attrs_show, NULL),
         __ATTR(batt_read_adj_soc, 0644, ss_batt_ext_attrs_show , NULL),
         __ATTR(batt_reset_soc, 0664, NULL, ss_batt_ext_attrs_store),
 };

 static ssize_t ss_batt_ext_attrs_show(struct device *pdev, struct device_attribute *attr, char *buf)
 {
 	ssize_t count=0;
 	int lp_charging=0;

 	const ptrdiff_t off = attr-ss_batt_ext_attrs;

 	struct power_supply *ps;
 	union power_supply_propval propval;
 	propval.intval=0;
 	propval.strval=0;

 	switch(off)
 	{
 		case SS_BATT_LP_CHARGING:
 			lp_charging = spa_ps_iter->state.lp_charging;
 			count+=scnprintf(buf+count, PAGE_SIZE-count, "%d\n", lp_charging);
 			break;

 	}

 	return 0;
 }

 static ssize_t ss_batt_ext_attrs_store(struct device *pdev, struct device_attribute *attr, const char *buf, size_t count)
 {
 	return 0;
 }

 unsigned int lp_boot_mode;
 static int get_boot_mode(char *str)
 {
         get_option(&str, &lp_boot_mode);

         return 1;
 }
 __setup("lpcharge=",get_boot_mode);

 #endif

 //static int spa_ps_probe(struct platform_device *pdev)
 int spa_ps_init(struct platform_device *pdev)
 {
 	int ret=0;

 	struct spa_ps *spa_ps;

 	printk("%s : spa_ps start\n", __func__);

 	spa_ps = kzalloc(sizeof(struct spa_ps), GFP_KERNEL);
 	if(spa_ps == NULL)
 	{
 		printk("%s: Failed to allocate memory\n", __func__);
 		return -ENOMEM;
 	}

 	spa_ps->model[SPA_MODEL_NAME_LEN]=0;

 	spa_ps->batt.properties= spa_batt_props;
 	spa_ps->batt.num_properties = ARRAY_SIZE(spa_batt_props);
 	spa_ps->batt.get_property = spa_batt_get_property;
 	spa_ps->batt.set_property = spa_batt_set_property;
 	spa_ps->batt.name = "battery";
 	spa_ps->batt.type = POWER_SUPPLY_TYPE_BATTERY;
 	ret = power_supply_register(&pdev->dev, &spa_ps->batt);
 	if( ret )
 	{
 		printk("%s : Failed to register ps battery\n", __func__);
 		goto LB_SPA_PS_PROBE_ERR_S3;
 	}

 	spa_ps->ac.properties= spa_charger_props;
 	spa_ps->ac.num_properties = ARRAY_SIZE(spa_charger_props);
 	spa_ps->ac.get_property = spa_ac_get_property;
 	spa_ps->ac.set_property = spa_ac_set_property;
 	spa_ps->ac.name = "ac";
 	spa_ps->ac.type = POWER_SUPPLY_TYPE_MAINS;
 	ret = power_supply_register(&pdev->dev, &spa_ps->ac);
 	if( ret )
 	{
 		printk("%s : Failed to register ps ac\n", __func__);
 		goto LB_SPA_PS_PROBE_ERR_S2;
 	}

 	spa_ps->usb.properties= spa_charger_props;
 	spa_ps->usb.num_properties = ARRAY_SIZE(spa_charger_props);
 	spa_ps->usb.get_property = spa_usb_get_property;
 	spa_ps->usb.set_property = spa_usb_set_property;
 	spa_ps->usb.name = "usb";
 	spa_ps->usb.type = POWER_SUPPLY_TYPE_USB;
 	ret = power_supply_register(&pdev->dev, &spa_ps->usb);
 	if( ret )
 	{
 		printk("%s : Failed to register ps usb\n", __func__);
 		goto LB_SPA_PS_PROBE_ERR_S1;
 	}

 	spa_ps->state.ac_online=0;
 	spa_ps->state.usb_online=0;

 	spa_ps->state.status=POWER_SUPPLY_STATUS_DISCHARGING;
 	spa_ps->state.temp=0;
 	spa_ps->state.temp_adc=0;
 	spa_ps->state.health=POWER_SUPPLY_HEALTH_GOOD;
 	spa_ps->state.voltage= 0;
 	spa_ps->state.capacity= 50;
 	spa_ps->state.present=1;
 	power_supply_changed(&spa_ps->batt);

 	printk("%s : spa_ps end\n", __func__);
 	goto LB_SPA_PS_PROBE_SUCCESS;

 LB_SPA_PS_PROBE_ERR_S1:
 	power_supply_unregister(&spa_ps->ac);
 LB_SPA_PS_PROBE_ERR_S2:
 	power_supply_unregister(&spa_ps->batt);
 LB_SPA_PS_PROBE_ERR_S3:
 	kfree(spa_ps);
 	return ret;

 LB_SPA_PS_PROBE_SUCCESS:
 	return 0;
 }
 EXPORT_SYMBOL(spa_ps_init);

 #if 0
 static int __devexit spa_ps_remove(struct platform_device *pdev)
 {
 	return 0;
 }

 static struct platform_driver spa_ps_driver = {
 		.driver = {
 				.name = "spa_ps",
 		},
 		.probe = spa_ps_probe,
 		.remove = spa_ps_remove,
 };

 static int __init spa_ps_init(void)
 {
 		return platform_driver_register(&spa_ps_driver);
 }

 static void __exit spa_ps_exit(void)
 {
 		platform_driver_unregister(&spa_ps_driver);
 }

 module_init(spa_ps_init);
 module_exit(spa_ps_exit);
 #endif

 MODULE_DESCRIPTION("SPA PS");
 MODULE_LICENSE("GPL");
	/*
	* Samsung Power and Charger.
	*
	* drivers/power/spa_power.c
	*
	* Drivers for samsung battery and charger.
	* (distributed from spa.c and linear-power.c)
	*
	* Copyright (C) 2012, Samsung Electronics.
	*
	* This program is free software. You can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation
	*/

	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/interrupt.h>
	#include <linux/workqueue.h>
	#include <linux/delay.h>
	#include <linux/types.h>
	#include <linux/platform_device.h>
	#include <linux/timer.h>
	#include <linux/slab.h>
	#include <linux/wakelock.h>
	#include <linux/power_supply.h>
	#include <linux/spa_power.h>

	#define BATT_TYPE "SDI_SDI"
	#define CONFIG_SEC_BATT_EXT_ATTRS

	#define SPA_MODEL_NAME_LEN 20

	struct spa_batt_status
	{
	int capacity;
	int voltage;
	int temp;
	int temp_adc;
	int present;
	int capacity_lvl;
	int status;
	int health;
	int lp_charging;
	int charging_source;


	int ac_online;
	int usb_online;
	};

	struct spa_ps
	{
	struct spa_power_desc *spa_power_iter;
	struct power_supply ac;
	struct power_supply batt;
	struct power_supply usb;
	struct spa_batt_status state;
	char model[SPA_MODEL_NAME_LEN+1];
	};

	static enum power_supply_property spa_batt_props[] = {
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_BATT_TEMP_ADC,
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_MODEL_NAME,
	};
	static enum power_supply_property spa_charger_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	};

	static int spa_batt_get_property( struct power_supply batt, enum power_supply_property property, union power_supply_propval propval)
	{
	int ret = 0;
	struct spa_ps *spa_ps_iter =
	container_of(batt, struct spa_ps, batt);

	switch (property) {
	case POWER_SUPPLY_PROP_STATUS:
	propval->intval = spa_ps_iter->state.status;
	break;

	case POWER_SUPPLY_PROP_TECHNOLOGY:
	propval->intval = POWER_SUPPLY_TECHNOLOGY_LION;
	break;

	case POWER_SUPPLY_PROP_CAPACITY:
	propval->intval = spa_ps_iter->state.capacity;
	break;

	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
	propval->intval = spa_ps_iter->state.capacity_lvl;
	break;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	propval->intval = spa_ps_iter->state.voltage * 1000;
	break;

	case POWER_SUPPLY_PROP_TEMP: // Kelvin unit to Celsius (C = K - 273.15). x10ed unit
	propval->intval = spa_ps_iter->state.temp;
	break;

	case POWER_SUPPLY_PROP_HEALTH:
	propval->intval = spa_ps_iter->state.health;
	break;

	case POWER_SUPPLY_PROP_PRESENT:
	propval->intval = spa_ps_iter->state.present;
	break;

	case POWER_SUPPLY_PROP_MODEL_NAME:
	propval->strval = spa_ps_iter->model;
	break;

	case POWER_SUPPLY_PROP_BATT_TEMP_ADC:
	propval->intval = spa_ps_iter->state.temp_adc;
	break;
	default:
	ret = -EINVAL;
	break;
	}

	return ret;

	}

	static int spa_batt_set_property( struct power_supply batt, enum power_supply_property property, union power_supply_propval propval)
	{
	int ret = 0;
	struct spa_ps *spa_ps_iter = container_of(batt,struct spa_ps, batt);
	switch (property) {
	case POWER_SUPPLY_PROP_STATUS:
	spa_ps_iter->state.status = propval->intval;
	break;

	case POWER_SUPPLY_PROP_CAPACITY:
	spa_ps_iter->state.capacity = propval->intval;
	break;

	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
	spa_ps_iter->state.capacity_lvl = propval->intval;
	break;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	spa_ps_iter->state.voltage = propval->intval;
	break;

	case POWER_SUPPLY_PROP_TEMP: // Celsius to Kelvin ( K = C + 273.15). x10ed unit
	spa_ps_iter->state.temp = propval->intval;
	break;

	case POWER_SUPPLY_PROP_HEALTH:
	spa_ps_iter->state.health = propval->intval;
	break;

	case POWER_SUPPLY_PROP_PRESENT:
	spa_ps_iter->state.present = propval->intval;
	break;

	case POWER_SUPPLY_PROP_MODEL_NAME:
	strncpy(spa_ps_iter->model, propval->strval, SPA_MODEL_NAME_LEN);
	break;

	case POWER_SUPPLY_PROP_BATT_TEMP_ADC:
	spa_ps_iter->state.temp_adc = propval->intval;
	break;

	default:
	ret = -EINVAL;
	break;
	}
	return ret;
	}

	static int spa_ac_get_property( struct power_supply ac, enum power_supply_property property, union power_supply_propval propval)
	{
	int ret = 0;
	struct spa_ps *spa_ps_iter = container_of(ac,struct spa_ps, ac);

	switch(property)
	{
	case POWER_SUPPLY_PROP_ONLINE:
	propval->intval = spa_ps_iter->state.ac_online;
	break;
	default:
	break;
	}

	return ret;
	}

	static int spa_ac_set_property( struct power_supply ac, enum power_supply_property property, union power_supply_propval propval)
	{
	int ret = 0;
	struct spa_ps *spa_ps_iter = container_of(ac,struct spa_ps, ac);

	switch(property)
	{
	case POWER_SUPPLY_PROP_ONLINE:
	spa_ps_iter->state.ac_online = propval->intval;
	break;
	default:
	break;
	}

	return ret;
	}

	static int spa_usb_get_property( struct power_supply usb, enum power_supply_property property, union power_supply_propval propval)
	{
	int ret = 0;
	struct spa_ps *spa_ps_iter = container_of(usb,struct spa_ps, usb);

	switch(property)
	{
	case POWER_SUPPLY_PROP_ONLINE:
	propval->intval = spa_ps_iter->state.usb_online;
	break;
	default:
	break;
	}

	return ret;
	}

	static int spa_usb_set_property( struct power_supply usb, enum power_supply_property property, union power_supply_propval propval)
	{
	int ret = 0;
	struct spa_ps *spa_ps_iter = container_of(usb,struct spa_ps, usb);

	switch(property)
	{
	case POWER_SUPPLY_PROP_ONLINE:
	spa_ps_iter->state.usb_online = propval->intval;
	break;
	default:
	break;
	}

	return ret;
	}

	#if 0 // defined(CONFIG_SEC_BATT_EXT_ATTRS)
	enum
	{
	SS_BATT_LP_CHARGING,
	SS_BATT_CHARGING_SOURCE,
	SS_BATT_TEMP_AVER,
	SS_BATT_TEMP_ADC_AVER,
	SS_BATT_TYPE,
	SS_BATT_READ_ADJ_SOC,
	SS_BATT_RESET_SOC,
	};

	static ssize_t ss_batt_ext_attrs_show(struct device pdev, struct device_attribute attr, char *buf);
	static ssize_t ss_batt_ext_attrs_store(struct device pdev, struct device_attribute attr, const char *buf, size_t count);

	static struct device_attribute ss_batt_ext_attrs[]=
	{
	__ATTR(batt_lp_charging, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
	__ATTR(batt_charging_source, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
	__ATTR(batt_temp_aver, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
	__ATTR(batt_temp_adc_aver, 0644, ss_batt_ext_attrs_show, ss_batt_ext_attrs_store),
	__ATTR(batt_type, 0644, ss_batt_ext_attrs_show, NULL),
	__ATTR(batt_read_adj_soc, 0644, ss_batt_ext_attrs_show , NULL),
	__ATTR(batt_reset_soc, 0664, NULL, ss_batt_ext_attrs_store),
	};

	static ssize_t ss_batt_ext_attrs_show(struct device pdev, struct device_attribute attr, char *buf)
	{
	ssize_t count=0;
	int lp_charging=0;

	const ptrdiff_t off = attr-ss_batt_ext_attrs;

	struct power_supply *ps;
	union power_supply_propval propval;
	propval.intval=0;
	propval.strval=0;

	switch(off)
	{
	case SS_BATT_LP_CHARGING:
	lp_charging = spa_ps_iter->state.lp_charging;
	count+=scnprintf(buf+count, PAGE_SIZE-count, "%d\n", lp_charging);
	break;

	}

	return 0;
	}

	static ssize_t ss_batt_ext_attrs_store(struct device pdev, struct device_attribute attr, const char *buf, size_t count)
	{
	return 0;
	}

	unsigned int lp_boot_mode;
	static int get_boot_mode(char *str)
	{
	get_option(&str, &lp_boot_mode);

	return 1;
	}
	__setup("lpcharge=",get_boot_mode);

	#endif

	//static int spa_ps_probe(struct platform_device *pdev)
	int spa_ps_init(struct platform_device *pdev)
	{
	int ret=0;

	struct spa_ps *spa_ps;

	printk("%s : spa_ps start\n", __func__);

	spa_ps = kzalloc(sizeof(struct spa_ps), GFP_KERNEL);
	if(spa_ps == NULL)
	{
	printk("%s: Failed to allocate memory\n", __func__);
	return -ENOMEM;
	}

	spa_ps->model[SPA_MODEL_NAME_LEN]=0;

	spa_ps->batt.properties= spa_batt_props;
	spa_ps->batt.num_properties = ARRAY_SIZE(spa_batt_props);
	spa_ps->batt.get_property = spa_batt_get_property;
	spa_ps->batt.set_property = spa_batt_set_property;
	spa_ps->batt.name = "battery";
	spa_ps->batt.type = POWER_SUPPLY_TYPE_BATTERY;
	ret = power_supply_register(&pdev->dev, &spa_ps->batt);
	if( ret )
	{
	printk("%s : Failed to register ps battery\n", __func__);
	goto LB_SPA_PS_PROBE_ERR_S3;
	}

	spa_ps->ac.properties= spa_charger_props;
	spa_ps->ac.num_properties = ARRAY_SIZE(spa_charger_props);
	spa_ps->ac.get_property = spa_ac_get_property;
	spa_ps->ac.set_property = spa_ac_set_property;
	spa_ps->ac.name = "ac";
	spa_ps->ac.type = POWER_SUPPLY_TYPE_MAINS;
	ret = power_supply_register(&pdev->dev, &spa_ps->ac);
	if( ret )
	{
	printk("%s : Failed to register ps ac\n", __func__);
	goto LB_SPA_PS_PROBE_ERR_S2;
	}

	spa_ps->usb.properties= spa_charger_props;
	spa_ps->usb.num_properties = ARRAY_SIZE(spa_charger_props);
	spa_ps->usb.get_property = spa_usb_get_property;
	spa_ps->usb.set_property = spa_usb_set_property;
	spa_ps->usb.name = "usb";
	spa_ps->usb.type = POWER_SUPPLY_TYPE_USB;
	ret = power_supply_register(&pdev->dev, &spa_ps->usb);
	if( ret )
	{
	printk("%s : Failed to register ps usb\n", __func__);
	goto LB_SPA_PS_PROBE_ERR_S1;
	}

	spa_ps->state.ac_online=0;
	spa_ps->state.usb_online=0;

	spa_ps->state.status=POWER_SUPPLY_STATUS_DISCHARGING;
	spa_ps->state.temp=0;
	spa_ps->state.temp_adc=0;
	spa_ps->state.health=POWER_SUPPLY_HEALTH_GOOD;
	spa_ps->state.voltage= 0;
	spa_ps->state.capacity= 50;
	spa_ps->state.present=1;
	power_supply_changed(&spa_ps->batt);

	printk("%s : spa_ps end\n", __func__);
	goto LB_SPA_PS_PROBE_SUCCESS;

	LB_SPA_PS_PROBE_ERR_S1:
	power_supply_unregister(&spa_ps->ac);
	LB_SPA_PS_PROBE_ERR_S2:
	power_supply_unregister(&spa_ps->batt);
	LB_SPA_PS_PROBE_ERR_S3:
	kfree(spa_ps);
	return ret;

	LB_SPA_PS_PROBE_SUCCESS:
	return 0;
	}
	EXPORT_SYMBOL(spa_ps_init);

	#if 0
	static int __devexit spa_ps_remove(struct platform_device *pdev)
	{
	return 0;
	}

	static struct platform_driver spa_ps_driver = {
	.driver = {
	.name = "spa_ps",
	},
	.probe = spa_ps_probe,
	.remove = spa_ps_remove,
	};

	static int __init spa_ps_init(void)
	{
	return platform_driver_register(&spa_ps_driver);
	}

	static void __exit spa_ps_exit(void)
	{
	platform_driver_unregister(&spa_ps_driver);
	}

	module_init(spa_ps_init);
	module_exit(spa_ps_exit);
	#endif

	MODULE_DESCRIPTION("SPA PS");
	MODULE_LICENSE("GPL");