ap/os/linux/linux-3.4.x/drivers/power/xc5071_charger.c

/*
 * Driver for the TI zx234502 battery charger.
 *
 * Author: Mark A. Greer <mgreer@animalcreek.com>
 *
 * 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/module.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/of_irq.h>
#include <linux/of_device.h>
#include <linux/pm_runtime.h>
#include <linux/power_supply.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/irq.h>
#include <linux/kthread.h>
//#include <linux/mutex.h>
#include <linux/semaphore.h>

#include <linux/power/aw3215_charger.h>
#include <linux/mfd/zx234290.h>

#include <mach/gpio.h>
#include <mach/pcu.h>
#include <mach/zx29_usb.h>
#include <linux/workqueue.h>

#include <linux/slab.h>
#include <linux/debugfs.h>
#include <asm/uaccess.h>
#include <linux/wakelock.h>

#define USB_IN		GPIO_HIGH
#define USB_OUT		GPIO_LOW
#define IRQ_TYPE_USB_OUT	IRQ_TYPE_LEVEL_LOW
#define IRQ_TYPE_USB_IN		IRQ_TYPE_LEVEL_HIGH

#define CHG_START	GPIO_LOW
#define CHG_STOP	GPIO_HIGH

#define CHG_EN_TYPE		GPIO_HIGH
#define CHG_DISEN_TYPE	GPIO_LOW
/*
 * The FAULT register is latched by the zx234502 (except for NTC_FAULT)
 * so the first read after a fault returns the latched value and subsequent
 * reads return the current value.  In order to return the fault status
 * to the user, have the interrupt handler save the reg's value and retrieve
 * it in the appropriate health/status routine.  Each routine has its own
 * flag indicating whether it should use the value stored by the last run
 * of the interrupt handler or do an actual reg read.  That way each routine
 * can report back whatever fault may have occured.
 */
 enum chg_stop_reason{
	CHG_STOP_REASON_NO = 0,
	CHG_STOP_REASON_TEMP= 1,
	CHG_STOP_REASON_FULL = 2,
	CHG_STOP_DEFALT= 0xff
};
struct aw3215_dev_info {
	struct device			*dev;
	struct power_supply	charger;
	struct power_supply	battery;

	kernel_ulong_t		model;
	unsigned int			chgin_irq;
	unsigned int			chgstate_irq;
	struct task_struct		*chgin_irq_thread;
	struct task_struct		*chgstate_irq_thread;

	u8					watchdog;

	struct aw3215_platform_data 	*pdata;
	unsigned int					chgin_type;
	unsigned int					chgstate_type;
	bool							chg_en;
	unsigned int					chg_state;
	struct semaphore		chgin_sem;
	struct semaphore		chgstate_sem;	
	enum chg_stop_reason	stopchg_flag;
	struct timer_list		changed_timer;
	struct wake_lock		wlock_chgfull;

};

struct aw3215_dev_info *g_bdi = NULL;

/* Charger power supply property routines */

static int aw3215_charger_get_charge_type(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
	val->intval = bdi->charger.type;
	return 0;
}

static int aw3215_charger_get_status(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
#if 1
	val->intval = bdi->chg_state;
#else
	if(false==bdi->chg_en){
		val->intval=POWER_SUPPLY_STATUS_NOT_CHARGING;/*diaable chg*/
		return 0;
	}
	if (USB_IN==bdi->chgin_type) {
		if(CHG_STOP==bdi->chgstate_type)
			val->intval= POWER_SUPPLY_STATUS_FULL;
		else if (CHG_START==bdi->chgstate_type)
			val->intval= POWER_SUPPLY_STATUS_CHARGING;
		else
			val->intval=POWER_SUPPLY_STATUS_NOT_CHARGING;/*diaable chg*/
	} else {
		val->intval=POWER_SUPPLY_STATUS_DISCHARGING;/*usb not insert*/
	}
#endif
	return 0;
}

static int aw3215_charger_get_health(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
	val->intval = POWER_SUPPLY_HEALTH_GOOD;

	return 0;
}

int aw3215_charger_get_online(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
	if (USB_IN==bdi->chgin_type) {
		val->intval= 1;
	} else {
		val->intval=0;/*usb not insert*/
	}

	return 0;
}EXPORT_SYMBOL (aw3215_charger_get_online);


static int aw3215_charger_get_charger_enabled(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
	val->intval = bdi->chg_en;

	return 0;
}
static int aw3215_charger_get_voltage_max(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
	val->intval = 4200;

	return 0;
}

static int aw3215_charger_set_voltage(struct aw3215_dev_info *bdi,const union power_supply_propval *val)
{
	return 0;
}
static int aw3215_charger_set_charger_config(struct aw3215_dev_info *bdi,const union power_supply_propval *val)
{
	int ret = 0;
	int gpio_state = 0;

	if (val->intval==1) {
		if (bdi->chg_en)
			return 0;
		gpio_state = CHG_EN_TYPE ;/*gpio low en chg*/
		printk("mmi start chg\n");
	} else {
		if (!bdi->chg_en)
			return 0;
		gpio_state = CHG_DISEN_TYPE ;/*gpio high stop chg*/
		printk("mmi stop chg\n");
	}

	disable_irq(bdi->chgstate_irq);

	if (gpio_state == CHG_EN_TYPE) {
		bdi->chg_en = true;		/*(~gpio_state)*/
		bdi->chgstate_type = CHG_START;
		bdi->stopchg_flag = CHG_STOP_REASON_NO;
		gpio_set_value(bdi->pdata->gpio_chgen, gpio_state);

		if (bdi->chgin_type == USB_IN) {
			bdi->chg_state = POWER_SUPPLY_STATUS_CHARGING;
			/* start charging in 5.3ms after enable */
			if (gpio_get_value(bdi->pdata->gpio_chgstate))
				mdelay(7);
			if (gpio_get_value(bdi->pdata->gpio_chgstate))
				printk(KERN_INFO "chg still not chargin"); /* should not go here */

			irq_set_irq_type(bdi->chgstate_irq, IRQ_TYPE_LEVEL_HIGH);

		}
	} else {
		bdi->chg_en = false;
		bdi->chgstate_type = CHG_STOP;
		bdi->stopchg_flag = CHG_STOP_REASON_TEMP;
		if (2==val->intval){/*chg full stop*/
			bdi->stopchg_flag = CHG_STOP_REASON_FULL;
			bdi->chg_state = POWER_SUPPLY_STATUS_FULL;
			printk("mmi full stop chg\n");
	
		}
		else if (bdi->chgin_type == USB_IN)
			bdi->chg_state = POWER_SUPPLY_STATUS_NOT_CHARGING;

		gpio_set_value(bdi->pdata->gpio_chgen, gpio_state);
		/* charger state changes from 0 to 1 in 0.12ms */
		if (!gpio_get_value(bdi->pdata->gpio_chgstate))
			udelay(500);

		irq_set_irq_type(bdi->chgstate_irq, IRQ_TYPE_LEVEL_LOW);

	}

	enable_irq(bdi->chgstate_irq);

	power_supply_changed(&bdi->charger);

	return ret;
}


static int aw3215_charger_get_property(struct power_supply *psy,enum power_supply_property psp, union power_supply_propval *val)
{
	struct aw3215_dev_info *bdi = container_of(psy, struct aw3215_dev_info, charger);
	int ret;

	//dev_dbg(bdi->dev, "prop: %d\n", psp);

	//pm_runtime_get_sync(bdi->dev);

	switch (psp) {
	case POWER_SUPPLY_PROP_PC1_AC2:
		ret = aw3215_charger_get_charge_type(bdi, val);
		break;

	case POWER_SUPPLY_PROP_STATUS:
		ret = aw3215_charger_get_status(bdi, val);
		break;
	case POWER_SUPPLY_PROP_HEALTH:
		ret = aw3215_charger_get_health(bdi, val);
		break;
	case POWER_SUPPLY_PROP_ONLINE:
		ret = aw3215_charger_get_online(bdi, val);
		break;

	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
		ret = aw3215_charger_get_voltage_max(bdi, val);
		break;

	case POWER_SUPPLY_PROP_CHARGE_ENABLED:
		ret = aw3215_charger_get_charger_enabled(bdi, val);
		break;
	default:
		ret = -ENODATA;
	}

	//pm_runtime_put_sync(bdi->dev);
	return ret;
}

static int aw3215_charger_set_property(struct power_supply *psy,enum power_supply_property psp,
		const union power_supply_propval *val)
{
	struct aw3215_dev_info *bdi =
			container_of(psy, struct aw3215_dev_info, charger);
	int ret;

	//dev_dbg(bdi->dev, "prop: %d\n", psp);

	//pm_runtime_get_sync(bdi->dev);

	switch (psp) {
#if 0
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		ret = zx234502_charger_set_current(bdi, val);
		break;
#endif
	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
		ret = aw3215_charger_set_voltage(bdi, val);
		break;

    case POWER_SUPPLY_PROP_CHARGE_ENABLED:
        ret = aw3215_charger_set_charger_config(bdi, val);
        break;
	default:
		ret = -EINVAL;
	}

	//pm_runtime_put_sync(bdi->dev);
	return ret;
}

static int aw3215_charger_property_is_writeable(struct power_supply *psy,enum power_supply_property psp)
{
	int ret;

	switch (psp)
	{
    	//case POWER_SUPPLY_PROP_CURRENT_NOW:
    	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
	case POWER_SUPPLY_PROP_CHARGE_ENABLED:
    		ret = 1;
    		break;
	default:
		ret = 0;
		break;
	}

	return ret;
}

static enum power_supply_property aw3215_charger_properties[] = {
	POWER_SUPPLY_PROP_PC1_AC2,
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_ONLINE,
	//POWER_SUPPLY_PROP_CURRENT_NOW,
	//POWER_SUPPLY_PROP_CURRENT_MAX,
	//POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_VOLTAGE_MAX,
	POWER_SUPPLY_PROP_CHARGE_ENABLED,
};

static char *aw3215_charger_supplied_to[] = {
	"main-battery",
};

static void aw3215_charger_init(struct power_supply *charger)
{
	charger->name = "charger";
	charger->type = POWER_SUPPLY_PCAC_UNKNOWN;
	charger->properties = aw3215_charger_properties;
	charger->num_properties = ARRAY_SIZE(aw3215_charger_properties);
	charger->supplied_to = aw3215_charger_supplied_to;
	//charger->num_supplies = ARRAY_SIZE(aw3215_charger_supplied_to);
	charger->get_property = aw3215_charger_get_property;
	charger->set_property = aw3215_charger_set_property;
	charger->property_is_writeable = aw3215_charger_property_is_writeable;
}

/* Battery power supply property routines */

static int aw3215_battery_get_health(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
	val->intval = POWER_SUPPLY_HEALTH_GOOD;

	return 0;
}

static int aw3215_battery_get_online(struct aw3215_dev_info *bdi,union power_supply_propval *val)
{
	val->intval = 1;/*bat on*/

	return 0;
}

static int aw3215_battery_set_online(struct aw3215_dev_info *bdi,const union power_supply_propval *val)
{
	return 0;
}


static int aw3215_battery_get_property(struct power_supply *psy,enum power_supply_property psp,
		union power_supply_propval *val)
{
	struct aw3215_dev_info *bdi =
			container_of(psy, struct aw3215_dev_info, battery);
	int ret;

	//dev_dbg(bdi->dev, "prop: %d\n", psp);

	//pm_runtime_get_sync(bdi->dev);

	switch (psp) {

	case POWER_SUPPLY_PROP_HEALTH:
		ret = aw3215_battery_get_health(bdi, val);
		break;
	case POWER_SUPPLY_PROP_ONLINE:
		ret = aw3215_battery_get_online(bdi, val);
		break;

	case POWER_SUPPLY_PROP_TEMP:
		val->intval = get_adc2_voltage();
		ret = 0;
		break;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		//#ifdef CONFIG_ZX234290_ADC
		val->intval = get_adc1_voltage() - 15;
		ret = 0;
		break;
	default:
		ret = -ENODATA;
	}

	//pm_runtime_put_sync(bdi->dev);
	return ret;
}

static int aw3215_battery_set_property(struct power_supply *psy,enum power_supply_property psp,
		const union power_supply_propval *val)
{
	struct aw3215_dev_info *bdi =
			container_of(psy, struct aw3215_dev_info, battery);
	int ret;

	//dev_dbg(bdi->dev, "prop: %d\n", psp);

	//pm_runtime_put_sync(bdi->dev);

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		ret = aw3215_battery_set_online(bdi, val);
		break;
	default:
		ret = -EINVAL;
	}

	//pm_runtime_put_sync(bdi->dev);
	return ret;
}

static int aw3215_battery_property_is_writeable(struct power_supply *psy,enum power_supply_property psp)
{
	int ret;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		ret = 1;
		break;
	default:
		ret = 0;
	}

	return ret;
}

static enum power_supply_property aw3215_battery_properties[] = {
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	//POWER_SUPPLY_PROP_CAPACITY,
};

static void aw3215_battery_init(struct power_supply *battery)
{
	battery->name = "battery";
	battery->type = POWER_SUPPLY_PCAC_UNKNOWN;
	battery->properties = aw3215_battery_properties;
	battery->num_properties = ARRAY_SIZE(aw3215_battery_properties);
	battery->get_property = aw3215_battery_get_property;
	battery->set_property = aw3215_battery_set_property;
	battery->property_is_writeable = aw3215_battery_property_is_writeable;
}

#if 1
static irqreturn_t aw3215_charger_in_irq_primary_handler(int irq, struct aw3215_dev_info * bdi)
{
	disable_irq_nosync(irq);
	//pcu_int_clear(irq);
	pcu_clr_irq_pending(irq);
	up(&bdi->chgin_sem);
	
	return IRQ_HANDLED;
}
static irqreturn_t aw3215_charger_state_irq_primary_handler(int irq, struct aw3215_dev_info * bdi)
{
	disable_irq_nosync(irq);
	//pcu_int_clear(irq);
	pcu_clr_irq_pending(irq);
	up(&bdi->chgstate_sem);
	
	return IRQ_HANDLED;
}

#endif

static irqreturn_t aw3215_chgin_irq_handler_thread(void *data)
{
	struct aw3215_dev_info *bdi = data;
	struct aw3215_platform_data *pdata = bdi->pdata;
	int g_gpio_in =0;
	struct sched_param param = { .sched_priority = 2 };

	param.sched_priority= 31;
	sched_setscheduler(current, SCHED_FIFO, &param);

	while(1)
	{
		down(&bdi->chgin_sem);

		g_gpio_in = gpio_get_value(pdata->gpio_chgin);

		/*charging status*/
		if (g_gpio_in == USB_IN) {
			if (bdi->chgin_type == USB_IN) {
				printk(KERN_INFO"chg usb in err\n");
			} 
			else if (bdi->stopchg_flag == CHG_STOP_REASON_TEMP){
				bdi->chgin_type = USB_IN;
				printk(KERN_INFO"chg usb in temp err\n");
				bdi->chg_state = POWER_SUPPLY_STATUS_NOT_CHARGING;
				dwc_otg_chg_inform(0);/*usb in*/
			}
			else{
				bdi->chgin_type = USB_IN;

				disable_irq(bdi->chgstate_irq);
				//gpio_set_value(pdata->gpio_chgen, CHG_EN_TYPE);
				//bdi->chg_en = true;
				//bdi->chgstate_type = CHG_START;

				/* start charging in 5.3ms after enable */
				if (gpio_get_value(pdata->gpio_chgstate))
					mdelay(7);
				if (bdi->chgstate_type == gpio_get_value(pdata->gpio_chgstate))
					printk(KERN_INFO "chg still not chargin"); /* should not go here */

				bdi->chg_state = POWER_SUPPLY_STATUS_CHARGING;

				irq_set_irq_type(bdi->chgstate_irq, IRQ_TYPE_LEVEL_HIGH);

				enable_irq(bdi->chgstate_irq);

				printk(KERN_INFO"chg usb in\n");
				dwc_otg_chg_inform(0);/*usb in*/

				//irq_set_irq_type(bdi->chgin_irq, IRQ_TYPE_LEVEL_HIGH);		
			}
			irq_set_irq_type(bdi->chgin_irq, IRQ_TYPE_USB_OUT/*IRQ_TYPE_LEVEL_HIGH*/);
		} else {
			bdi->chg_state = POWER_SUPPLY_STATUS_DISCHARGING;
			if (bdi->chgin_type == USB_OUT) {
				printk(KERN_INFO"chg usb out err\n");
			} else {
				bdi->chgin_type = USB_OUT;
				//SINT32 Usb_plug = DISCONNECTED_FROM_HOST;
				printk(KERN_INFO"chg usb out\n");
				dwc_otg_chg_inform(1);/*usb out*/
				//irq_set_irq_type(bdi->chgin_irq, IRQ_TYPE_LEVEL_LOW);
			}
			
			irq_set_irq_type(bdi->chgin_irq, IRQ_TYPE_USB_IN/*IRQ_TYPE_LEVEL_LOW*/);
		}

		power_supply_changed(&bdi->charger);
		power_supply_changed(&bdi->battery);
		enable_irq(bdi->chgin_irq);

	}
	return 0;
}

static irqreturn_t aw3215_chgstate_irq_handler_thread(void *data)
{
	struct aw3215_dev_info *bdi = data;
	struct aw3215_platform_data *pdata = bdi->pdata;
	//unsigned int state_rcd = bdi->chg_state;
	int g_gpio_state=CHG_STOP;
	uint adc1_v= 0;
	struct sched_param param = { .sched_priority = 2 };

	param.sched_priority= 31;
	sched_setscheduler(current, SCHED_FIFO, &param);

	while(1)
	{
		down(&bdi->chgstate_sem);

		g_gpio_state = gpio_get_value(pdata->gpio_chgstate);

		/*charging status*/
		if (g_gpio_state == CHG_START) {	/*low charging*/
			bdi->chg_state = POWER_SUPPLY_STATUS_CHARGING;

			if (bdi->chgstate_type == CHG_START) {
				printk(KERN_INFO"chg chging err!\n");
			} else {
				bdi->chgstate_type = CHG_START;

				//irq_set_irq_type(bdi->chgstate_irq, IRQ_TYPE_LEVEL_HIGH);
					power_supply_changed(&bdi->charger);
					power_supply_changed(&bdi->battery);
				printk(KERN_INFO"chg charging\n");
			}
			irq_set_irq_type(bdi->chgstate_irq, IRQ_TYPE_LEVEL_HIGH);
		} else {/*high stop charging*/
			if (bdi->chgstate_type == CHG_STOP) {
				printk(KERN_INFO"chg full err!\n");
			} else {
				if ((bdi->chgin_type == USB_IN)&&(bdi->stopchg_flag == CHG_STOP_REASON_TEMP)){
					bdi->chg_state = POWER_SUPPLY_STATUS_NOT_CHARGING;	
					power_supply_changed(&bdi->charger);
					power_supply_changed(&bdi->battery);
				}
				else if(bdi->chgin_type == USB_IN){
					bdi->chg_state = POWER_SUPPLY_STATUS_FULL;
					wake_lock(&(bdi->wlock_chgfull)); 
					mod_timer(&bdi->changed_timer, jiffies + msecs_to_jiffies(200));			
				}
				else{
					bdi->chg_state = POWER_SUPPLY_STATUS_DISCHARGING;
						power_supply_changed(&bdi->charger);
						power_supply_changed(&bdi->battery);
					}
					
				bdi->chgstate_type = CHG_STOP;

				printk(KERN_INFO "chg %s %s stop\n",
				(bdi->chg_state == POWER_SUPPLY_STATUS_FULL) ? "full" : " ",
				(bdi->chg_state == POWER_SUPPLY_STATUS_NOT_CHARGING) ? "temp error":"discharging");

			}
			irq_set_irq_type(bdi->chgstate_irq, IRQ_TYPE_LEVEL_LOW);

		}
		enable_irq(bdi->chgstate_irq);

	}
	return 0;
}


static int aw3215_setup_pdata(struct aw3215_dev_info *bdi,
		struct aw3215_platform_data *pdata)
{
	int ret;

	  //chg en
	if (!gpio_is_valid(pdata->gpio_chgen))
		return -1;

	ret = gpio_request(pdata->gpio_chgen, "chg_en");
	if (ret < 0)
		goto out;
	ret = zx29_gpio_config(pdata->gpio_chgen, pdata->gpio_chgen_gpio_sel);
	ret = gpio_direction_output(pdata->gpio_chgen, CHG_EN_TYPE);
	bdi->chg_en =true;
	bdi->stopchg_flag=CHG_STOP_DEFALT;

    //chg termination current ctrl
	if (!gpio_is_valid(pdata->gpio_chgctrl)){
		printk("chg chgctrl gpio undifined\n");
		return 0;
	}

	ret = gpio_request(pdata->gpio_chgctrl, "chg_ctrl");
	if (ret < 0)
		goto out;
	ret = zx29_gpio_config(pdata->gpio_chgctrl, pdata->gpio_chgctrl_gpio_sel);
	if (ret < 0)
		goto out;
	ret = gpio_direction_output(pdata->gpio_chgctrl, 0);
	if (ret < 0)
		goto out;

	return 0;
out:
	//gpio_free(pdata->gpio_int);
	return -1;
}


static int aw3215_init_state(struct aw3215_dev_info *bdi)
{
	struct aw3215_platform_data *pdata;
	int ret = 0;
	unsigned int g_gpio_in,g_gpio_state;
	unsigned int chgin_irq_type=IRQ_TYPE_NONE;
	unsigned int chgstate_irq_type=IRQ_TYPE_NONE;

	pdata = bdi->pdata;
	/*chgin*/
	if (!gpio_is_valid(pdata->gpio_chgin))
		goto error;

	ret = gpio_request(pdata->gpio_chgin, "chg_usbin");
	if (ret < 0)
		goto error;

	zx29_gpio_pd_pu_set(pdata->gpio_chgin, IO_CFG_PULL_DISABLE);

	ret = gpio_direction_input(pdata->gpio_chgin);
	if (ret < 0)
		goto error;
	ret = zx29_gpio_config(pdata->gpio_chgin,pdata->gpio_chgin_fun_sel);
	if (ret < 0)
		goto error;

	bdi->chgin_irq= gpio_to_irq(pdata->gpio_chgin);

	/*chg state*/
    if (!gpio_is_valid(pdata->gpio_chgstate))
		goto error;

	ret = gpio_request(pdata->gpio_chgstate, "chg_state");
	if (ret < 0)
		goto error;

	zx29_gpio_pd_pu_set(pdata->gpio_chgstate, IO_CFG_PULL_DISABLE);
	ret = gpio_direction_input(pdata->gpio_chgstate);
	if (ret < 0)
		goto error;
	ret = zx29_gpio_config(pdata->gpio_chgstate,pdata->gpio_chgstate_fun_sel);
	if (ret < 0)
		goto error;

	bdi->chgstate_irq= gpio_to_irq(pdata->gpio_chgstate);

	mdelay(20);/*?*/
	g_gpio_in = gpio_get_value(pdata->gpio_chgin);
	g_gpio_state = gpio_get_value(pdata->gpio_chgstate);

	if ( USB_IN == g_gpio_in){
		bdi->chgin_type = USB_IN;
		chgin_irq_type=IRQ_TYPE_USB_OUT;/*IRQ_TYPE_LEVEL_HIGH*/
		if(CHG_START == g_gpio_state){
			bdi->chgstate_type=CHG_START ;
			bdi->chg_state=POWER_SUPPLY_STATUS_CHARGING;
			chgstate_irq_type=IRQ_TYPE_LEVEL_HIGH;			
		}
		else{
			bdi->chgstate_type =CHG_STOP ;	
			chgstate_irq_type = IRQ_TYPE_LEVEL_LOW;	
			bdi->chg_state=POWER_SUPPLY_STATUS_FULL;			
		}
		printk(KERN_INFO"init usb in\n");
		dwc_otg_chg_inform(0);/*usb in*/	
	}
	else{
		bdi->chgin_type = USB_OUT;
		bdi->chg_state=POWER_SUPPLY_STATUS_DISCHARGING;
		chgin_irq_type = IRQ_TYPE_USB_IN/*IRQ_TYPE_LEVEL_LOW*/;
		if(CHG_START == g_gpio_state){
			bdi->chgstate_type=CHG_START ;
			chgstate_irq_type=IRQ_TYPE_LEVEL_HIGH;		
			printk(KERN_INFO"init chg_state err\n");
		}
		else{
			bdi->chgstate_type =CHG_STOP ;	
			chgstate_irq_type = IRQ_TYPE_LEVEL_LOW;	
		}
		printk(KERN_INFO"init usb out\n");
		dwc_otg_chg_inform(1);/*usb out*/		
	}
	irq_set_irq_type(bdi->chgin_irq, chgin_irq_type);
	irq_set_irq_type(bdi->chgstate_irq, chgstate_irq_type);

	return 0;
error:
	printk(KERN_INFO"chg gpio  error ret = %d\n",ret);
	return -1;
}



static void aw3215_charge_typedet(T_TYPE_USB_DETECT chg_type)
{
	//u8 ret;
	#ifdef DBG_CHARGE
	//printk(KERN_INFO"charge type is %d in\n",chg_type);
	#endif

	if(TYPE_ADAPTER == chg_type){
		printk(KERN_INFO"chg type DC\n");
		g_bdi->charger.type = POWER_SUPPLY_PCAC__AC;
	}
	else{
		printk(KERN_INFO"chg type PC\n");
		g_bdi->charger.type = POWER_SUPPLY_PCAC__PC;
	}

}


#if defined(CONFIG_DEBUG_FS)
static ssize_t debugfs_regs_write(struct file *file, const char __user *buf,size_t nbytes, loff_t *ppos)
{
	unsigned int val1, val2;
	//u8 reg, value;
	int ret = 0;
	char *kern_buf;
	//struct seq_file	*s = file->private_data;
	//struct aw3215_dev_info *aw3215 = s->private;

	kern_buf = kzalloc(nbytes, GFP_KERNEL);

	if (!kern_buf) {
		printk(KERN_INFO "aw3215_charger: Failed to allocate buffer\n");
		return -ENOMEM;
	}

	if (copy_from_user(kern_buf, (void  __user *)buf, nbytes)) {
		kfree(kern_buf);
		return -ENOMEM;
	}
	printk(KERN_INFO "%s input str=%s,nbytes=%d \n", __func__, kern_buf,nbytes);

	ret = sscanf(kern_buf, "%x:%x", &val1, &val2);
	if (ret < 2) {
		printk(KERN_INFO "sgm40561_charger: failed to read user buf, ret=%d, input 0x%x:0x%x\n",
				ret, val1, val2);
		kfree(kern_buf);
		return -EINVAL;
	}
	kfree(kern_buf);

	return ret ? ret : nbytes;
}

static int debugfs_regs_show(struct seq_file *s, void *v)
{
	//int i;
	int ret=0;
	//int curr = 0;
	struct aw3215_dev_info *aw3215 = s->private;

	/*charger type*/
	if((int)aw3215->charger.type == POWER_SUPPLY_PCAC__PC){
		seq_printf(s, "charger type is  PC\n");
	}
	else if((int)aw3215->charger.type == POWER_SUPPLY_PCAC__AC){
		seq_printf(s, "charger type is  AC\n");
	}
	else
	seq_printf(s, "charger type is  unknow = %d\n",aw3215->charger.type);

	seq_printf(s, "mmi charger config state = %d\n",aw3215->chg_en);
	seq_printf(s, "chg in state = %s\n",(aw3215->chgin_type==USB_IN)? "USB_IN":"USB_OUT");
	seq_printf(s, "chg_state  state = %s\n",aw3215->chgstate_type ? "CHG_STOP": "CHG_START");

	return ret;
}

#define DEBUGFS_FILE_ENTRY(name) \
static int debugfs_##name##_open(struct inode *inode, struct file *file) \
{\
return single_open(file, debugfs_##name##_show, inode->i_private); \
}\
\
static const struct file_operations debugfs_##name##_fops = { \
.owner= THIS_MODULE, \
.open= debugfs_##name##_open, \
.write=debugfs_##name##_write, \
.read= seq_read, \
.llseek= seq_lseek, \
.release= single_release, \
}

DEBUGFS_FILE_ENTRY(regs);

static struct dentry *g_charger_root;

static void debugfs_charger_init(struct aw3215_dev_info  *aw3215)
{
	struct dentry *root;
	struct dentry *node;
	//int i;

	if(!aw3215)
		return;

	//create root
	root = debugfs_create_dir("charger_zx29", NULL);
	if (!root)	{
		dev_err(aw3215->dev, "debugfs_create_dir err=%ld\n", IS_ERR(root));
		goto err;
	}

	//print regs;
	node = debugfs_create_file("regs", S_IRUGO | S_IWUGO, root, aw3215,  &debugfs_regs_fops);
	if (!node){
		dev_err(aw3215->dev, "debugfs_create_dir err=%ld\n", IS_ERR(node));
		goto err;
	}

	g_charger_root = (void *)root;
	return;
err:
	dev_err(aw3215->dev, "debugfs_charger_init err\n");
}

#endif

static void aw3215_changed_timer_function(unsigned long data)
{
	struct aw3215_dev_info *bdi = (void *)data;
	power_supply_changed(&bdi->charger);
	power_supply_changed(&bdi->battery);
	//printk("chg timer callback\n");
	del_timer(&bdi->changed_timer);
	wake_unlock(&(bdi->wlock_chgfull));
	printk("chg timer callback end\n");

}

static int __devinit aw3215_charger_probe(struct platform_device *pdev)
{
	struct aw3215_platform_data *pdata = pdev->dev.platform_data;
	struct device *dev = &pdev->dev;
	struct aw3215_dev_info *bdi;
	unsigned long flag;
	int ret;
	//int i;  /*when err try 3 times*/

	bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
	if (!bdi) {
		dev_err(dev, "Can't alloc bdi struct\n");
		return -ENOMEM;
	}
	bdi->dev = dev;
	bdi->pdata = pdata;

	//printk(KERN_INFO "charger probe.\n");

	bdi->chg_state = POWER_SUPPLY_STATUS_UNKNOWN;
	bdi->charger.type = POWER_SUPPLY_TYPE_UNKNOWN;

	g_bdi = bdi;

	ret = aw3215_setup_pdata(bdi, pdata);
	if (ret) {
		dev_err(dev, "Can't get irq info\n");
		return -EINVAL;
	}

	aw3215_charger_init(&bdi->charger);

	ret = power_supply_register(dev, &bdi->charger);
	if (ret) {
		dev_err(dev, "Can't register charger\n");
		goto out2;
	}
	//printk(KERN_INFO "aw3215_probe power_supply_register charger ok.\n");

	aw3215_battery_init(&bdi->battery);

	ret = power_supply_register(dev, &bdi->battery);
	if (ret) {
		dev_err(dev, "Can't register battery\n");
		goto out1;
	}
	//printk(KERN_INFO "aw3215_probe power_supply_register battery ok.\n");
	sema_init(&bdi->chgin_sem, 0);
	sema_init(&bdi->chgstate_sem, 0);

	dwc_chg_Regcallback(aw3215_charge_typedet);/*register for usb*/
	aw3215_init_state(bdi);
	init_timer(&bdi->changed_timer);
	bdi->changed_timer.function = aw3215_changed_timer_function;
	bdi->changed_timer.data = (unsigned long)bdi;
	wake_lock_init(&(bdi->wlock_chgfull), WAKE_LOCK_SUSPEND, "aw3215_wake_lock_chgfull");

/*chg in*/
	ret = request_irq(bdi->chgin_irq, aw3215_charger_in_irq_primary_handler,IRQF_NO_THREAD, "aw3215-chgin", bdi);
	if (ret < 0) {
		dev_err(dev, "Can't set up irq handler\n");
		if (bdi->pdata->gpio_chgin)
			gpio_free(bdi->pdata->gpio_chgin);

		goto out3;
	}
	irq_set_irq_wake(bdi->chgin_irq, 1);
	bdi->chgin_irq_thread = kthread_run(aw3215_chgin_irq_handler_thread, bdi, "aw3215-chgin");
	BUG_ON(IS_ERR(bdi->chgin_irq_thread));

/*chg state*/
	ret = request_irq(bdi->chgstate_irq, aw3215_charger_state_irq_primary_handler,IRQF_NO_THREAD, "aw3215-chgstate", bdi);
	if (ret < 0) {
		dev_err(dev, "Can't set up irq handler\n");
		if (bdi->pdata->gpio_chgstate)
			gpio_free(bdi->pdata->gpio_chgstate);

		goto out3;
	}
	irq_set_irq_wake(bdi->chgstate_irq, 1);
	bdi->chgstate_irq_thread = kthread_run(aw3215_chgstate_irq_handler_thread, bdi, "aw3215-chgstate");
	BUG_ON(IS_ERR(bdi->chgstate_irq_thread));

#if defined(CONFIG_DEBUG_FS)
	debugfs_charger_init(bdi);
#endif

#ifdef DBG_CHARGE
	//printk(KERN_INFO "aw3215_probe end.\n");
#endif

	return 0;

out1:
	power_supply_unregister(&bdi->battery);
out2:
	//pm_runtime_disable(dev);
	power_supply_unregister(&bdi->charger);
out3:

	return ret;

}

static int aw3215_charger_remove(struct platform_device *pdev)
{
	struct aw3215_platform_data *pdata = pdev->dev.platform_data;

	power_supply_unregister(&(g_bdi->battery));
	power_supply_unregister(&(g_bdi->charger));

	pm_runtime_disable(g_bdi->dev);

	if (pdata->gpio_chgctrl)
		gpio_free(pdata->gpio_chgctrl);
	if (pdata->gpio_chgen)
		gpio_free(pdata->gpio_chgen);
	if (pdata->gpio_chgin)
		gpio_free(pdata->gpio_chgin);
	if (pdata->gpio_chgstate)
		gpio_free(pdata->gpio_chgstate);


#if defined(CONFIG_DEBUG_FS)
	if(g_charger_root){
		//printk(KERN_INFO "aw3215_device_exit:debugfs_remove_recursive \n");
		debugfs_remove_recursive(g_charger_root);
	}
#endif

	return 0;
}


static struct platform_driver zx29_charger_driver = {
	.probe		= aw3215_charger_probe,
	.remove		= __devexit_p(aw3215_charger_remove),
	.driver		= {
		.name	= "aw3215-charger",
		.owner	= THIS_MODULE,
	},
};

//module_platform_driver(zx29_charger_driver);


static int __init zx29_charger_init(void)
{
	return platform_driver_register(&zx29_charger_driver);
}

static void __exit zx29_charger_exit(void)
{
	platform_driver_unregister(&zx29_charger_driver);
}

module_init(zx29_charger_init);
module_exit(zx29_charger_exit);


MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
MODULE_DESCRIPTION("AW3215 Charger Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:zx29_charger");