/*
   * Battery driver for Maxim MAX8925
   *
   * Copyright (c) 2009-2010 Marvell International Ltd.
   *	Haojian Zhuang <haojian.zhuang@marvell.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/err.h>
  #include <linux/slab.h>
  #include <linux/of.h>
  #include <linux/i2c.h>
  #include <linux/interrupt.h>
  #include <linux/platform_device.h>
  #include <linux/power_supply.h>
  #include <linux/mfd/max8925.h>
  
  /* registers in GPM */
  #define MAX8925_OUT5VEN			0x54
  #define MAX8925_OUT3VEN			0x58
  #define MAX8925_CHG_CNTL1		0x7c
  
  /* bits definition */
  #define MAX8925_CHG_STAT_VSYSLOW	(1 << 0)
  #define MAX8925_CHG_STAT_MODE_MASK	(3 << 2)
  #define MAX8925_CHG_STAT_EN_MASK	(1 << 4)
  #define MAX8925_CHG_MBDET		(1 << 1)
  #define MAX8925_CHG_AC_RANGE_MASK	(3 << 6)
  
  /* registers in ADC */
  #define MAX8925_ADC_RES_CNFG1		0x06
  #define MAX8925_ADC_AVG_CNFG1		0x07
  #define MAX8925_ADC_ACQ_CNFG1		0x08
  #define MAX8925_ADC_ACQ_CNFG2		0x09
  /* 2 bytes registers in below. MSB is 1st, LSB is 2nd. */
  #define MAX8925_ADC_AUX2		0x62
  #define MAX8925_ADC_VCHG		0x64
  #define MAX8925_ADC_VBBATT		0x66
  #define MAX8925_ADC_VMBATT		0x68
  #define MAX8925_ADC_ISNS		0x6a
  #define MAX8925_ADC_THM			0x6c
  #define MAX8925_ADC_TDIE		0x6e
  #define MAX8925_CMD_AUX2		0xc8
  #define MAX8925_CMD_VCHG		0xd0
  #define MAX8925_CMD_VBBATT		0xd8
  #define MAX8925_CMD_VMBATT		0xe0
  #define MAX8925_CMD_ISNS		0xe8
  #define MAX8925_CMD_THM			0xf0
  #define MAX8925_CMD_TDIE		0xf8
  
  enum {
  	MEASURE_AUX2,
  	MEASURE_VCHG,
  	MEASURE_VBBATT,
  	MEASURE_VMBATT,
  	MEASURE_ISNS,
  	MEASURE_THM,
  	MEASURE_TDIE,
  	MEASURE_MAX,
  };
  
  struct max8925_power_info {
  	struct max8925_chip	*chip;
  	struct i2c_client	*gpm;
  	struct i2c_client	*adc;
  
  	struct power_supply	ac;
  	struct power_supply	usb;
  	struct power_supply	battery;
  	int			irq_base;
  	unsigned		ac_online:1;
  	unsigned		usb_online:1;
  	unsigned		bat_online:1;
  	unsigned		chg_mode:2;
  	unsigned		batt_detect:1;	/* detecing MB by ID pin */
  	unsigned		topoff_threshold:2;
  	unsigned		fast_charge:3;
  	unsigned		no_temp_support:1;
  	unsigned		no_insert_detect:1;
  
  	int (*set_charger) (int);
  };
  
  static int __set_charger(struct max8925_power_info *info, int enable)
  {
  	struct max8925_chip *chip = info->chip;
  	if (enable) {
  		/* enable charger in platform */
  		if (info->set_charger)
  			info->set_charger(1);
  		/* enable charger */
  		max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 0);
  	} else {
  		/* disable charge */
  		max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
  		if (info->set_charger)
  			info->set_charger(0);
  	}
  	dev_dbg(chip->dev, "%s
  ", (enable) ? "Enable charger"
  		: "Disable charger");
  	return 0;
  }
  
  static irqreturn_t max8925_charger_handler(int irq, void *data)
  {
  	struct max8925_power_info *info = (struct max8925_power_info *)data;
  	struct max8925_chip *chip = info->chip;
  
  	switch (irq - chip->irq_base) {
  	case MAX8925_IRQ_VCHG_DC_R:
  		info->ac_online = 1;
  		__set_charger(info, 1);
  		dev_dbg(chip->dev, "Adapter inserted
  ");
  		break;
  	case MAX8925_IRQ_VCHG_DC_F:
  		info->ac_online = 0;
  		__set_charger(info, 0);
  		dev_dbg(chip->dev, "Adapter removed
  ");
  		break;
  	case MAX8925_IRQ_VCHG_THM_OK_F:
  		/* Battery is not ready yet */
  		dev_dbg(chip->dev, "Battery temperature is out of range
  ");
  	case MAX8925_IRQ_VCHG_DC_OVP:
  		dev_dbg(chip->dev, "Error detection
  ");
  		__set_charger(info, 0);
  		break;
  	case MAX8925_IRQ_VCHG_THM_OK_R:
  		/* Battery is ready now */
  		dev_dbg(chip->dev, "Battery temperature is in range
  ");
  		break;
  	case MAX8925_IRQ_VCHG_SYSLOW_R:
  		/* VSYS is low */
  		dev_info(chip->dev, "Sys power is too low
  ");
  		break;
  	case MAX8925_IRQ_VCHG_SYSLOW_F:
  		dev_dbg(chip->dev, "Sys power is above low threshold
  ");
  		break;
  	case MAX8925_IRQ_VCHG_DONE:
  		__set_charger(info, 0);
  		dev_dbg(chip->dev, "Charging is done
  ");
  		break;
  	case MAX8925_IRQ_VCHG_TOPOFF:
  		dev_dbg(chip->dev, "Charging in top-off mode
  ");
  		break;
  	case MAX8925_IRQ_VCHG_TMR_FAULT:
  		__set_charger(info, 0);
  		dev_dbg(chip->dev, "Safe timer is expired
  ");
  		break;
  	case MAX8925_IRQ_VCHG_RST:
  		__set_charger(info, 0);
  		dev_dbg(chip->dev, "Charger is reset
  ");
  		break;
  	}
  	return IRQ_HANDLED;
  }
  
  static int start_measure(struct max8925_power_info *info, int type)
  {
  	unsigned char buf[2] = {0, 0};
  	int meas_cmd;
  	int meas_reg = 0, ret;
  
  	switch (type) {
  	case MEASURE_VCHG:
  		meas_cmd = MAX8925_CMD_VCHG;
  		meas_reg = MAX8925_ADC_VCHG;
  		break;
  	case MEASURE_VBBATT:
  		meas_cmd = MAX8925_CMD_VBBATT;
  		meas_reg = MAX8925_ADC_VBBATT;
  		break;
  	case MEASURE_VMBATT:
  		meas_cmd = MAX8925_CMD_VMBATT;
  		meas_reg = MAX8925_ADC_VMBATT;
  		break;
  	case MEASURE_ISNS:
  		meas_cmd = MAX8925_CMD_ISNS;
  		meas_reg = MAX8925_ADC_ISNS;
  		break;
  	default:
  		return -EINVAL;
  	}
  
  	max8925_reg_write(info->adc, meas_cmd, 0);
  	max8925_bulk_read(info->adc, meas_reg, 2, buf);
  	ret = ((buf[0]<<8) | buf[1]) >> 4;
  
  	return ret;
  }
  
  static int max8925_ac_get_prop(struct power_supply *psy,
  			       enum power_supply_property psp,
  			       union power_supply_propval *val)
  {
  	struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent);
  	int ret = 0;
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_ONLINE:
  		val->intval = info->ac_online;
  		break;
  	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  		if (info->ac_online) {
  			ret = start_measure(info, MEASURE_VCHG);
  			if (ret >= 0) {
  				val->intval = ret * 2000;	/* unit is uV */
  				goto out;
  			}
  		}
  		ret = -ENODATA;
  		break;
  	default:
  		ret = -ENODEV;
  		break;
  	}
  out:
  	return ret;
  }
  
  static enum power_supply_property max8925_ac_props[] = {
  	POWER_SUPPLY_PROP_ONLINE,
  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
  };
  
  static int max8925_usb_get_prop(struct power_supply *psy,
  				enum power_supply_property psp,
  				union power_supply_propval *val)
  {
  	struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent);
  	int ret = 0;
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_ONLINE:
  		val->intval = info->usb_online;
  		break;
  	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  		if (info->usb_online) {
  			ret = start_measure(info, MEASURE_VCHG);
  			if (ret >= 0) {
  				val->intval = ret * 2000;	/* unit is uV */
  				goto out;
  			}
  		}
  		ret = -ENODATA;
  		break;
  	default:
  		ret = -ENODEV;
  		break;
  	}
  out:
  	return ret;
  }
  
  static enum power_supply_property max8925_usb_props[] = {
  	POWER_SUPPLY_PROP_ONLINE,
  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
  };
  
  static int max8925_bat_get_prop(struct power_supply *psy,
  				enum power_supply_property psp,
  				union power_supply_propval *val)
  {
  	struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent);
  	int ret = 0;
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_ONLINE:
  		val->intval = info->bat_online;
  		break;
  	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  		if (info->bat_online) {
  			ret = start_measure(info, MEASURE_VMBATT);
  			if (ret >= 0) {
  				val->intval = ret * 2000;	/* unit is uV */
  				ret = 0;
  				break;
  			}
  		}
  		ret = -ENODATA;
  		break;
  	case POWER_SUPPLY_PROP_CURRENT_NOW:
  		if (info->bat_online) {
  			ret = start_measure(info, MEASURE_ISNS);
  			if (ret >= 0) {
  				/* assume r_sns is 0.02 */
  				ret = ((ret * 6250) - 3125) /* uA */;
  				val->intval = 0;
  				if (ret > 0)
  					val->intval = ret; /* unit is mA */
  				ret = 0;
  				break;
  			}
  		}
  		ret = -ENODATA;
  		break;
  	case POWER_SUPPLY_PROP_CHARGE_TYPE:
  		if (!info->bat_online) {
  			ret = -ENODATA;
  			break;
  		}
  		ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
  		ret = (ret & MAX8925_CHG_STAT_MODE_MASK) >> 2;
  		switch (ret) {
  		case 1:
  			val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
  			break;
  		case 0:
  		case 2:
  			val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
  			break;
  		case 3:
  			val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
  			break;
  		}
  		ret = 0;
  		break;
  	case POWER_SUPPLY_PROP_STATUS:
  		if (!info->bat_online) {
  			ret = -ENODATA;
  			break;
  		}
  		ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
  		if (info->usb_online || info->ac_online) {
  			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
  			if (ret & MAX8925_CHG_STAT_EN_MASK)
  				val->intval = POWER_SUPPLY_STATUS_CHARGING;
  		} else
  			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  		ret = 0;
  		break;
  	default:
  		ret = -ENODEV;
  		break;
  	}
  	return ret;
  }
  
  static enum power_supply_property max8925_battery_props[] = {
  	POWER_SUPPLY_PROP_ONLINE,
  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
  	POWER_SUPPLY_PROP_CURRENT_NOW,
  	POWER_SUPPLY_PROP_CHARGE_TYPE,
  	POWER_SUPPLY_PROP_STATUS,
  };
  
  #define REQUEST_IRQ(_irq, _name)					\
  do {									\
  	ret = request_threaded_irq(chip->irq_base + _irq, NULL,		\
  				    max8925_charger_handler,		\
  				    IRQF_ONESHOT, _name, info);		\
  	if (ret)							\
  		dev_err(chip->dev, "Failed to request IRQ #%d: %d
  ",	\
  			_irq, ret);					\
  } while (0)
  
  static int max8925_init_charger(struct max8925_chip *chip,
  					  struct max8925_power_info *info)
  {
  	int ret;
  
  	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_OVP, "ac-ovp");
  	if (!info->no_insert_detect) {
  		REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_F, "ac-remove");
  		REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_R, "ac-insert");
  	}
  	if (!info->no_temp_support) {
  		REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_R, "batt-temp-in-range");
  		REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_F, "batt-temp-out-range");
  	}
  	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_F, "vsys-high");
  	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_R, "vsys-low");
  	REQUEST_IRQ(MAX8925_IRQ_VCHG_RST, "charger-reset");
  	REQUEST_IRQ(MAX8925_IRQ_VCHG_DONE, "charger-done");
  	REQUEST_IRQ(MAX8925_IRQ_VCHG_TOPOFF, "charger-topoff");
  	REQUEST_IRQ(MAX8925_IRQ_VCHG_TMR_FAULT, "charger-timer-expire");
  
  	info->usb_online = 0;
  	info->bat_online = 0;
  
  	/* check for power - can miss interrupt at boot time */
  	if (start_measure(info, MEASURE_VCHG) * 2000 > 500000)
  		info->ac_online = 1;
  	else
  		info->ac_online = 0;
  
  	ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
  	if (ret >= 0) {
  		/*
  		 * If battery detection is enabled, ID pin of battery is
  		 * connected to MBDET pin of MAX8925. It could be used to
  		 * detect battery presence.
  		 * Otherwise, we have to assume that battery is always on.
  		 */
  		if (info->batt_detect)
  			info->bat_online = (ret & MAX8925_CHG_MBDET) ? 0 : 1;
  		else
  			info->bat_online = 1;
  		if (ret & MAX8925_CHG_AC_RANGE_MASK)
  			info->ac_online = 1;
  		else
  			info->ac_online = 0;
  	}
  	/* disable charge */
  	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
  	/* set charging current in charge topoff mode */
  	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 3 << 5,
  			 info->topoff_threshold << 5);
  	/* set charing current in fast charge mode */
  	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 7, info->fast_charge);
  
  	return 0;
  }
  
  static int max8925_deinit_charger(struct max8925_power_info *info)
  {
  	struct max8925_chip *chip = info->chip;
  	int irq;
  
  	irq = chip->irq_base + MAX8925_IRQ_VCHG_DC_OVP;
  	for (; irq <= chip->irq_base + MAX8925_IRQ_VCHG_TMR_FAULT; irq++)
  		free_irq(irq, info);
  
  	return 0;
  }
  
  #ifdef CONFIG_OF
  static struct max8925_power_pdata *
  max8925_power_dt_init(struct platform_device *pdev)
  {
  	struct device_node *nproot = pdev->dev.parent->of_node;
  	struct device_node *np;
  	int batt_detect;
  	int topoff_threshold;
  	int fast_charge;
  	int no_temp_support;
  	int no_insert_detect;
  	struct max8925_power_pdata *pdata;
  
  	if (!nproot)
  		return pdev->dev.platform_data;
  
  	np = of_find_node_by_name(nproot, "charger");
  	if (!np) {
  		dev_err(&pdev->dev, "failed to find charger node
  ");
  		return NULL;
  	}
  
  	pdata = devm_kzalloc(&pdev->dev,
  			sizeof(struct max8925_power_pdata),
  			GFP_KERNEL);
  
  	of_property_read_u32(np, "topoff-threshold", &topoff_threshold);
  	of_property_read_u32(np, "batt-detect", &batt_detect);
  	of_property_read_u32(np, "fast-charge", &fast_charge);
  	of_property_read_u32(np, "no-insert-detect", &no_insert_detect);
  	of_property_read_u32(np, "no-temp-support", &no_temp_support);
  	of_node_put(np);
  
  	pdata->batt_detect = batt_detect;
  	pdata->fast_charge = fast_charge;
  	pdata->topoff_threshold = topoff_threshold;
  	pdata->no_insert_detect = no_insert_detect;
  	pdata->no_temp_support = no_temp_support;
  
  	return pdata;
  }
  #else
  static struct max8925_power_pdata *
  max8925_power_dt_init(struct platform_device *pdev)
  {
  	return pdev->dev.platform_data;
  }
  #endif
  
  static int max8925_power_probe(struct platform_device *pdev)
  {
  	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
  	struct max8925_power_pdata *pdata = NULL;
  	struct max8925_power_info *info;
  	int ret;
  
  	pdata = max8925_power_dt_init(pdev);
  	if (!pdata) {
  		dev_err(&pdev->dev, "platform data isn't assigned to "
  			"power supply
  ");
  		return -EINVAL;
  	}
  
  	info = devm_kzalloc(&pdev->dev, sizeof(struct max8925_power_info),
  				GFP_KERNEL);
  	if (!info)
  		return -ENOMEM;
  	info->chip = chip;
  	info->gpm = chip->i2c;
  	info->adc = chip->adc;
  	platform_set_drvdata(pdev, info);
  
  	info->ac.name = "max8925-ac";
  	info->ac.type = POWER_SUPPLY_TYPE_MAINS;
  	info->ac.properties = max8925_ac_props;
  	info->ac.num_properties = ARRAY_SIZE(max8925_ac_props);
  	info->ac.get_property = max8925_ac_get_prop;
  	info->ac.supplied_to = pdata->supplied_to;
  	info->ac.num_supplicants = pdata->num_supplicants;
  	ret = power_supply_register(&pdev->dev, &info->ac);
  	if (ret)
  		goto out;
  	info->ac.dev->parent = &pdev->dev;
  
  	info->usb.name = "max8925-usb";
  	info->usb.type = POWER_SUPPLY_TYPE_USB;
  	info->usb.properties = max8925_usb_props;
  	info->usb.num_properties = ARRAY_SIZE(max8925_usb_props);
  	info->usb.get_property = max8925_usb_get_prop;
  	info->usb.supplied_to = pdata->supplied_to;
  	info->usb.num_supplicants = pdata->num_supplicants;
  
  	ret = power_supply_register(&pdev->dev, &info->usb);
  	if (ret)
  		goto out_usb;
  	info->usb.dev->parent = &pdev->dev;
  
  	info->battery.name = "max8925-battery";
  	info->battery.type = POWER_SUPPLY_TYPE_BATTERY;
  	info->battery.properties = max8925_battery_props;
  	info->battery.num_properties = ARRAY_SIZE(max8925_battery_props);
  	info->battery.get_property = max8925_bat_get_prop;
  	ret = power_supply_register(&pdev->dev, &info->battery);
  	if (ret)
  		goto out_battery;
  	info->battery.dev->parent = &pdev->dev;
  
  	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->no_temp_support = pdata->no_temp_support;
  	info->no_insert_detect = pdata->no_insert_detect;
  
  	max8925_init_charger(chip, info);
  	return 0;
  out_battery:
  	power_supply_unregister(&info->battery);
  out_usb:
  	power_supply_unregister(&info->ac);
  out:
  	return ret;
  }
  
  static int max8925_power_remove(struct platform_device *pdev)
  {
  	struct max8925_power_info *info = platform_get_drvdata(pdev);
  
  	if (info) {
  		power_supply_unregister(&info->ac);
  		power_supply_unregister(&info->usb);
  		power_supply_unregister(&info->battery);
  		max8925_deinit_charger(info);
  	}
  	return 0;
  }
  
  static struct platform_driver max8925_power_driver = {
  	.probe	= max8925_power_probe,
  	.remove	= max8925_power_remove,
  	.driver	= {
  		.name	= "max8925-power",
  	},
  };
  
  module_platform_driver(max8925_power_driver);
  
  MODULE_LICENSE("GPL");
  MODULE_DESCRIPTION("Power supply driver for MAX8925");
  MODULE_ALIAS("platform:max8925-power");