/*
   * max77693_charger.c - Battery charger driver for the Maxim 77693
   *
   * Copyright (C) 2014 Samsung Electronics

   * Krzysztof Kozlowski <krzk@kernel.org>

   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   */
  
  #include <linux/module.h>
  #include <linux/platform_device.h>
  #include <linux/power_supply.h>
  #include <linux/regmap.h>
  #include <linux/mfd/max77693.h>

  #include <linux/mfd/max77693-common.h>

  #include <linux/mfd/max77693-private.h>

  #define MAX77693_CHARGER_NAME				"max77693-charger"

  static const char *max77693_charger_model		= "MAX77693";
  static const char *max77693_charger_manufacturer	= "Maxim Integrated";
  
  struct max77693_charger {
  	struct device		*dev;
  	struct max77693_dev	*max77693;

  	struct power_supply	*charger;

  
  	u32 constant_volt;
  	u32 min_system_volt;
  	u32 thermal_regulation_temp;
  	u32 batttery_overcurrent;
  	u32 charge_input_threshold_volt;
  };

  static int max77693_get_charger_state(struct regmap *regmap, int *val)

  {

  	int ret;

  	unsigned int data;

  	ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
  	if (ret < 0)
  		return ret;

  
  	data &= CHG_DETAILS_01_CHG_MASK;
  	data >>= CHG_DETAILS_01_CHG_SHIFT;
  
  	switch (data) {
  	case MAX77693_CHARGING_PREQUALIFICATION:
  	case MAX77693_CHARGING_FAST_CONST_CURRENT:
  	case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
  	case MAX77693_CHARGING_TOP_OFF:
  	/* In high temp the charging current is reduced, but still charging */
  	case MAX77693_CHARGING_HIGH_TEMP:

  		*val = POWER_SUPPLY_STATUS_CHARGING;

  		break;
  	case MAX77693_CHARGING_DONE:

  		*val = POWER_SUPPLY_STATUS_FULL;

  		break;
  	case MAX77693_CHARGING_TIMER_EXPIRED:
  	case MAX77693_CHARGING_THERMISTOR_SUSPEND:

  		*val = POWER_SUPPLY_STATUS_NOT_CHARGING;

  		break;
  	case MAX77693_CHARGING_OFF:
  	case MAX77693_CHARGING_OVER_TEMP:
  	case MAX77693_CHARGING_WATCHDOG_EXPIRED:

  		*val = POWER_SUPPLY_STATUS_DISCHARGING;

  		break;
  	case MAX77693_CHARGING_RESERVED:
  	default:

  		*val = POWER_SUPPLY_STATUS_UNKNOWN;

  	}

  	return 0;

  }

  static int max77693_get_charge_type(struct regmap *regmap, int *val)

  {

  	int ret;

  	unsigned int data;

  	ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
  	if (ret < 0)
  		return ret;

  
  	data &= CHG_DETAILS_01_CHG_MASK;
  	data >>= CHG_DETAILS_01_CHG_SHIFT;
  
  	switch (data) {
  	case MAX77693_CHARGING_PREQUALIFICATION:
  	/*
  	 * Top-off: trickle or fast? In top-off the current varies between
  	 * 100 and 250 mA. It is higher than prequalification current.
  	 */
  	case MAX77693_CHARGING_TOP_OFF:

  		*val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;

  		break;
  	case MAX77693_CHARGING_FAST_CONST_CURRENT:
  	case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
  	/* In high temp the charging current is reduced, but still charging */
  	case MAX77693_CHARGING_HIGH_TEMP:

  		*val = POWER_SUPPLY_CHARGE_TYPE_FAST;

  		break;
  	case MAX77693_CHARGING_DONE:
  	case MAX77693_CHARGING_TIMER_EXPIRED:
  	case MAX77693_CHARGING_THERMISTOR_SUSPEND:
  	case MAX77693_CHARGING_OFF:
  	case MAX77693_CHARGING_OVER_TEMP:
  	case MAX77693_CHARGING_WATCHDOG_EXPIRED:

  		*val = POWER_SUPPLY_CHARGE_TYPE_NONE;

  		break;
  	case MAX77693_CHARGING_RESERVED:
  	default:

  		*val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;

  	}

  	return 0;

  }
  
  /*
   * Supported health statuses:
   *  - POWER_SUPPLY_HEALTH_DEAD
   *  - POWER_SUPPLY_HEALTH_GOOD
   *  - POWER_SUPPLY_HEALTH_OVERVOLTAGE
   *  - POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE
   *  - POWER_SUPPLY_HEALTH_UNKNOWN
   *  - POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
   */

  static int max77693_get_battery_health(struct regmap *regmap, int *val)

  {

  	int ret;

  	unsigned int data;

  	ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
  	if (ret < 0)
  		return ret;

  
  	data &= CHG_DETAILS_01_BAT_MASK;
  	data >>= CHG_DETAILS_01_BAT_SHIFT;
  
  	switch (data) {
  	case MAX77693_BATTERY_NOBAT:

  		*val = POWER_SUPPLY_HEALTH_DEAD;

  		break;
  	case MAX77693_BATTERY_PREQUALIFICATION:
  	case MAX77693_BATTERY_GOOD:
  	case MAX77693_BATTERY_LOWVOLTAGE:

  		*val = POWER_SUPPLY_HEALTH_GOOD;

  		break;
  	case MAX77693_BATTERY_TIMER_EXPIRED:
  		/*
  		 * Took longer to charge than expected, charging suspended.
  		 * Damaged battery?
  		 */

  		*val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;

  		break;
  	case MAX77693_BATTERY_OVERVOLTAGE:

  		*val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;

  		break;
  	case MAX77693_BATTERY_OVERCURRENT:

  		*val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;

  		break;
  	case MAX77693_BATTERY_RESERVED:
  	default:

  		*val = POWER_SUPPLY_HEALTH_UNKNOWN;

  		break;
  	}

  	return 0;

  }

  static int max77693_get_present(struct regmap *regmap, int *val)

  {
  	unsigned int data;

  	int ret;

  
  	/*
  	 * Read CHG_INT_OK register. High DETBAT bit here should be
  	 * equal to value 0x0 in CHG_DETAILS_01/BAT field.
  	 */

  	ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
  	if (ret < 0)
  		return ret;
  
  	*val = (data & CHG_INT_OK_DETBAT_MASK) ? 0 : 1;
  
  	return 0;

  }

  static int max77693_get_online(struct regmap *regmap, int *val)

  {
  	unsigned int data;

  	int ret;
  
  	ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
  	if (ret < 0)
  		return ret;
  
  	*val = (data & CHG_INT_OK_CHGIN_MASK) ? 1 : 0;

  	return 0;
  }
  
  static enum power_supply_property max77693_charger_props[] = {
  	POWER_SUPPLY_PROP_STATUS,
  	POWER_SUPPLY_PROP_CHARGE_TYPE,
  	POWER_SUPPLY_PROP_HEALTH,
  	POWER_SUPPLY_PROP_PRESENT,
  	POWER_SUPPLY_PROP_ONLINE,
  	POWER_SUPPLY_PROP_MODEL_NAME,
  	POWER_SUPPLY_PROP_MANUFACTURER,
  };
  
  static int max77693_charger_get_property(struct power_supply *psy,
  			    enum power_supply_property psp,
  			    union power_supply_propval *val)
  {

  	struct max77693_charger *chg = power_supply_get_drvdata(psy);

  	struct regmap *regmap = chg->max77693->regmap;
  	int ret = 0;
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_STATUS:

  		ret = max77693_get_charger_state(regmap, &val->intval);

  		break;
  	case POWER_SUPPLY_PROP_CHARGE_TYPE:

  		ret = max77693_get_charge_type(regmap, &val->intval);

  		break;
  	case POWER_SUPPLY_PROP_HEALTH:

  		ret = max77693_get_battery_health(regmap, &val->intval);

  		break;
  	case POWER_SUPPLY_PROP_PRESENT:

  		ret = max77693_get_present(regmap, &val->intval);

  		break;
  	case POWER_SUPPLY_PROP_ONLINE:

  		ret = max77693_get_online(regmap, &val->intval);

  		break;
  	case POWER_SUPPLY_PROP_MODEL_NAME:
  		val->strval = max77693_charger_model;
  		break;
  	case POWER_SUPPLY_PROP_MANUFACTURER:
  		val->strval = max77693_charger_manufacturer;
  		break;
  	default:
  		return -EINVAL;
  	}
  
  	return ret;
  }

  static const struct power_supply_desc max77693_charger_desc = {
  	.name		= MAX77693_CHARGER_NAME,
  	.type		= POWER_SUPPLY_TYPE_BATTERY,
  	.properties	= max77693_charger_props,
  	.num_properties	= ARRAY_SIZE(max77693_charger_props),
  	.get_property	= max77693_charger_get_property,
  };

  static ssize_t device_attr_store(struct device *dev,
  		struct device_attribute *attr, const char *buf, size_t count,
  		int (*fn)(struct max77693_charger *, unsigned long))
  {
  	struct max77693_charger *chg = dev_get_drvdata(dev);
  	unsigned long val;
  	int ret;
  
  	ret = kstrtoul(buf, 10, &val);
  	if (ret)
  		return ret;
  
  	ret = fn(chg, val);
  	if (ret)
  		return ret;
  
  	return count;
  }
  
  static ssize_t fast_charge_timer_show(struct device *dev,
  		struct device_attribute *attr, char *buf)
  {
  	struct max77693_charger *chg = dev_get_drvdata(dev);
  	unsigned int data, val;
  	int ret;
  
  	ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_01,
  			&data);
  	if (ret < 0)
  		return ret;
  
  	data &= CHG_CNFG_01_FCHGTIME_MASK;
  	data >>= CHG_CNFG_01_FCHGTIME_SHIFT;
  	switch (data) {
  	case 0x1 ... 0x7:
  		/* Starting from 4 hours, step by 2 hours */
  		val = 4 + (data - 1) * 2;
  		break;
  	case 0x0:
  	default:
  		val = 0;
  		break;
  	}
  
  	return scnprintf(buf, PAGE_SIZE, "%u
  ", val);
  }
  
  static int max77693_set_fast_charge_timer(struct max77693_charger *chg,
  		unsigned long hours)
  {
  	unsigned int data;
  
  	/*
  	 * 0x00 - disable
  	 * 0x01 - 4h
  	 * 0x02 - 6h
  	 * ...
  	 * 0x07 - 16h
  	 * Round down odd values.
  	 */
  	switch (hours) {
  	case 4 ... 16:
  		data = (hours - 4) / 2 + 1;
  		break;
  	case 0:
  		/* Disable */
  		data = 0;
  		break;
  	default:
  		return -EINVAL;
  	}
  	data <<= CHG_CNFG_01_FCHGTIME_SHIFT;
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_01,
  			CHG_CNFG_01_FCHGTIME_MASK, data);
  }
  
  static ssize_t fast_charge_timer_store(struct device *dev,
  		struct device_attribute *attr, const char *buf, size_t count)
  {
  	return device_attr_store(dev, attr, buf, count,
  			max77693_set_fast_charge_timer);
  }
  
  static ssize_t top_off_threshold_current_show(struct device *dev,
  		struct device_attribute *attr, char *buf)
  {
  	struct max77693_charger *chg = dev_get_drvdata(dev);
  	unsigned int data, val;
  	int ret;
  
  	ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
  			&data);
  	if (ret < 0)
  		return ret;
  
  	data &= CHG_CNFG_03_TOITH_MASK;
  	data >>= CHG_CNFG_03_TOITH_SHIFT;
  
  	if (data <= 0x04)
  		val = 100000 + data * 25000;
  	else
  		val = data * 50000;
  
  	return scnprintf(buf, PAGE_SIZE, "%u
  ", val);
  }
  
  static int max77693_set_top_off_threshold_current(struct max77693_charger *chg,
  		unsigned long uamp)
  {
  	unsigned int data;
  
  	if (uamp < 100000 || uamp > 350000)
  		return -EINVAL;
  
  	if (uamp <= 200000)
  		data = (uamp - 100000) / 25000;
  	else
  		/* (200000, 350000> */
  		data = uamp / 50000;
  
  	data <<= CHG_CNFG_03_TOITH_SHIFT;
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_03,
  			CHG_CNFG_03_TOITH_MASK, data);
  }
  
  static ssize_t top_off_threshold_current_store(struct device *dev,
  		struct device_attribute *attr, const char *buf, size_t count)
  {
  	return device_attr_store(dev, attr, buf, count,
  			max77693_set_top_off_threshold_current);
  }
  
  static ssize_t top_off_timer_show(struct device *dev,
  		struct device_attribute *attr, char *buf)
  {
  	struct max77693_charger *chg = dev_get_drvdata(dev);
  	unsigned int data, val;
  	int ret;
  
  	ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
  			&data);
  	if (ret < 0)
  		return ret;
  
  	data &= CHG_CNFG_03_TOTIME_MASK;
  	data >>= CHG_CNFG_03_TOTIME_SHIFT;
  
  	val = data * 10;
  
  	return scnprintf(buf, PAGE_SIZE, "%u
  ", val);
  }
  
  static int max77693_set_top_off_timer(struct max77693_charger *chg,
  		unsigned long minutes)
  {
  	unsigned int data;
  
  	if (minutes > 70)
  		return -EINVAL;
  
  	data = minutes / 10;
  	data <<= CHG_CNFG_03_TOTIME_SHIFT;
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_03,
  			CHG_CNFG_03_TOTIME_MASK, data);
  }
  
  static ssize_t top_off_timer_store(struct device *dev,
  		struct device_attribute *attr, const char *buf, size_t count)
  {
  	return device_attr_store(dev, attr, buf, count,
  			max77693_set_top_off_timer);
  }
  
  static DEVICE_ATTR_RW(fast_charge_timer);
  static DEVICE_ATTR_RW(top_off_threshold_current);
  static DEVICE_ATTR_RW(top_off_timer);
  
  static int max77693_set_constant_volt(struct max77693_charger *chg,
  		unsigned int uvolt)
  {
  	unsigned int data;
  
  	/*
  	 * 0x00 - 3.650 V
  	 * 0x01 - 3.675 V
  	 * ...
  	 * 0x1b - 4.325 V
  	 * 0x1c - 4.340 V
  	 * 0x1d - 4.350 V
  	 * 0x1e - 4.375 V
  	 * 0x1f - 4.400 V
  	 */
  	if (uvolt >= 3650000 && uvolt < 4340000)
  		data = (uvolt - 3650000) / 25000;
  	else if (uvolt >= 4340000 && uvolt < 4350000)
  		data = 0x1c;
  	else if (uvolt >= 4350000 && uvolt <= 4400000)
  		data = 0x1d + (uvolt - 4350000) / 25000;
  	else {
  		dev_err(chg->dev, "Wrong value for charging constant voltage
  ");
  		return -EINVAL;
  	}
  
  	data <<= CHG_CNFG_04_CHGCVPRM_SHIFT;
  
  	dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)
  ", uvolt,
  			data);
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_04,
  			CHG_CNFG_04_CHGCVPRM_MASK, data);
  }
  
  static int max77693_set_min_system_volt(struct max77693_charger *chg,
  		unsigned int uvolt)
  {
  	unsigned int data;
  
  	if (uvolt < 3000000 || uvolt > 3700000) {
  		dev_err(chg->dev, "Wrong value for minimum system regulation voltage
  ");
  		return -EINVAL;
  	}
  
  	data = (uvolt - 3000000) / 100000;
  
  	data <<= CHG_CNFG_04_MINVSYS_SHIFT;
  
  	dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)
  ",
  			uvolt, data);
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_04,
  			CHG_CNFG_04_MINVSYS_MASK, data);
  }
  
  static int max77693_set_thermal_regulation_temp(struct max77693_charger *chg,
  		unsigned int cels)
  {
  	unsigned int data;
  
  	switch (cels) {
  	case 70:
  	case 85:
  	case 100:
  	case 115:
  		data = (cels - 70) / 15;
  		break;
  	default:
  		dev_err(chg->dev, "Wrong value for thermal regulation loop temperature
  ");
  		return -EINVAL;
  	}
  
  	data <<= CHG_CNFG_07_REGTEMP_SHIFT;
  
  	dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)
  ",
  			cels, data);
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_07,
  			CHG_CNFG_07_REGTEMP_MASK, data);
  }
  
  static int max77693_set_batttery_overcurrent(struct max77693_charger *chg,
  		unsigned int uamp)
  {
  	unsigned int data;
  
  	if (uamp && (uamp < 2000000 || uamp > 3500000)) {
  		dev_err(chg->dev, "Wrong value for battery overcurrent
  ");
  		return -EINVAL;
  	}
  
  	if (uamp)
  		data = ((uamp - 2000000) / 250000) + 1;
  	else
  		data = 0; /* disable */
  
  	data <<= CHG_CNFG_12_B2SOVRC_SHIFT;
  
  	dev_dbg(chg->dev, "Battery overcurrent: %u (0x%x)
  ", uamp, data);
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_12,
  			CHG_CNFG_12_B2SOVRC_MASK, data);
  }
  
  static int max77693_set_charge_input_threshold_volt(struct max77693_charger *chg,
  		unsigned int uvolt)
  {
  	unsigned int data;
  
  	switch (uvolt) {
  	case 4300000:
  		data = 0x0;
  		break;
  	case 4700000:
  	case 4800000:
  	case 4900000:
  		data = (uvolt - 4700000) / 100000;
  	default:
  		dev_err(chg->dev, "Wrong value for charge input voltage regulation threshold
  ");
  		return -EINVAL;
  	}
  
  	data <<= CHG_CNFG_12_VCHGINREG_SHIFT;
  
  	dev_dbg(chg->dev, "Charge input voltage regulation threshold: %u (0x%x)
  ",
  			uvolt, data);
  
  	return regmap_update_bits(chg->max77693->regmap,
  			MAX77693_CHG_REG_CHG_CNFG_12,
  			CHG_CNFG_12_VCHGINREG_MASK, data);
  }
  
  /*
   * Sets charger registers to proper and safe default values.
   */
  static int max77693_reg_init(struct max77693_charger *chg)
  {
  	int ret;
  	unsigned int data;
  
  	/* Unlock charger register protection */
  	data = (0x3 << CHG_CNFG_06_CHGPROT_SHIFT);
  	ret = regmap_update_bits(chg->max77693->regmap,
  				MAX77693_CHG_REG_CHG_CNFG_06,
  				CHG_CNFG_06_CHGPROT_MASK, data);
  	if (ret) {
  		dev_err(chg->dev, "Error unlocking registers: %d
  ", ret);
  		return ret;
  	}
  
  	ret = max77693_set_fast_charge_timer(chg, DEFAULT_FAST_CHARGE_TIMER);
  	if (ret)
  		return ret;
  
  	ret = max77693_set_top_off_threshold_current(chg,
  			DEFAULT_TOP_OFF_THRESHOLD_CURRENT);
  	if (ret)
  		return ret;
  
  	ret = max77693_set_top_off_timer(chg, DEFAULT_TOP_OFF_TIMER);
  	if (ret)
  		return ret;
  
  	ret = max77693_set_constant_volt(chg, chg->constant_volt);
  	if (ret)
  		return ret;
  
  	ret = max77693_set_min_system_volt(chg, chg->min_system_volt);
  	if (ret)
  		return ret;
  
  	ret = max77693_set_thermal_regulation_temp(chg,
  			chg->thermal_regulation_temp);
  	if (ret)
  		return ret;
  
  	ret = max77693_set_batttery_overcurrent(chg, chg->batttery_overcurrent);
  	if (ret)
  		return ret;

  	return max77693_set_charge_input_threshold_volt(chg,

  			chg->charge_input_threshold_volt);

  }
  
  #ifdef CONFIG_OF
  static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
  {
  	struct device_node *np = dev->of_node;
  
  	if (!np) {
  		dev_err(dev, "no charger OF node
  ");
  		return -EINVAL;
  	}
  
  	if (of_property_read_u32(np, "maxim,constant-microvolt",
  			&chg->constant_volt))
  		chg->constant_volt = DEFAULT_CONSTANT_VOLT;
  
  	if (of_property_read_u32(np, "maxim,min-system-microvolt",
  			&chg->min_system_volt))
  		chg->min_system_volt = DEFAULT_MIN_SYSTEM_VOLT;
  
  	if (of_property_read_u32(np, "maxim,thermal-regulation-celsius",
  			&chg->thermal_regulation_temp))
  		chg->thermal_regulation_temp = DEFAULT_THERMAL_REGULATION_TEMP;
  
  	if (of_property_read_u32(np, "maxim,battery-overcurrent-microamp",
  			&chg->batttery_overcurrent))
  		chg->batttery_overcurrent = DEFAULT_BATTERY_OVERCURRENT;
  
  	if (of_property_read_u32(np, "maxim,charge-input-threshold-microvolt",
  			&chg->charge_input_threshold_volt))
  		chg->charge_input_threshold_volt =
  			DEFAULT_CHARGER_INPUT_THRESHOLD_VOLT;
  
  	return 0;
  }
  #else /* CONFIG_OF */
  static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
  {
  	return 0;
  }
  #endif /* CONFIG_OF */
  
  static int max77693_charger_probe(struct platform_device *pdev)
  {
  	struct max77693_charger *chg;

  	struct power_supply_config psy_cfg = {};

  	struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent);
  	int ret;
  
  	chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
  	if (!chg)
  		return -ENOMEM;
  
  	platform_set_drvdata(pdev, chg);
  	chg->dev = &pdev->dev;
  	chg->max77693 = max77693;
  
  	ret = max77693_dt_init(&pdev->dev, chg);
  	if (ret)
  		return ret;
  
  	ret = max77693_reg_init(chg);
  	if (ret)
  		return ret;

  	psy_cfg.drv_data = chg;

  
  	ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer);
  	if (ret) {
  		dev_err(&pdev->dev, "failed: create fast charge timer sysfs entry
  ");
  		goto err;
  	}
  
  	ret = device_create_file(&pdev->dev,
  			&dev_attr_top_off_threshold_current);
  	if (ret) {
  		dev_err(&pdev->dev, "failed: create top off current sysfs entry
  ");
  		goto err;
  	}
  
  	ret = device_create_file(&pdev->dev, &dev_attr_top_off_timer);
  	if (ret) {
  		dev_err(&pdev->dev, "failed: create top off timer sysfs entry
  ");
  		goto err;
  	}

  	chg->charger = power_supply_register(&pdev->dev,
  						&max77693_charger_desc,
  						&psy_cfg);
  	if (IS_ERR(chg->charger)) {

  		dev_err(&pdev->dev, "failed: power supply register
  ");

  		ret = PTR_ERR(chg->charger);

  		goto err;
  	}
  
  	return 0;
  
  err:
  	device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
  	device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
  	device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
  
  	return ret;
  }
  
  static int max77693_charger_remove(struct platform_device *pdev)
  {
  	struct max77693_charger *chg = platform_get_drvdata(pdev);
  
  	device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
  	device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
  	device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);

  	power_supply_unregister(chg->charger);

  
  	return 0;
  }
  
  static const struct platform_device_id max77693_charger_id[] = {
  	{ "max77693-charger", 0, },
  	{ }
  };
  MODULE_DEVICE_TABLE(platform, max77693_charger_id);
  
  static struct platform_driver max77693_charger_driver = {
  	.driver = {

  		.name	= "max77693-charger",
  	},
  	.probe		= max77693_charger_probe,
  	.remove		= max77693_charger_remove,
  	.id_table	= max77693_charger_id,
  };
  module_platform_driver(max77693_charger_driver);

  MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");

  MODULE_DESCRIPTION("Maxim 77693 charger driver");
  MODULE_LICENSE("GPL");