/*
   * Copyright (C) 2016 Texas Instruments Incorporated - http://www.ti.com/
   *	Nishanth Menon <nm@ti.com>
   *	Dave Gerlach <d-gerlach@ti.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.
   *
   * TI OPP Domain driver that provides overrides into the regulator control
   * for generic opp domains to handle devices with ABB regulator and/or
   * SmartReflex Class0.
   */
  #include <linux/clk.h>
  #include <linux/cpufreq.h>
  #include <linux/device.h>
  #include <linux/io.h>
  #include <linux/module.h>
  #include <linux/notifier.h>
  #include <linux/of_device.h>
  #include <linux/of.h>
  #include <linux/platform_device.h>
  #include <linux/pm_opp.h>
  #include <linux/pm_opp_domain.h>
  #include <linux/regulator/consumer.h>
  #include <linux/slab.h>
  
  /**
   * struct ti_oppdm_optimum_voltage_table - optimized voltage table
   * @reference_uv:	reference voltage (usually Nominal voltage)
   * @optimized_uv:	Optimized voltage from efuse
   */
  struct ti_oppdm_optimum_voltage_table {
  	unsigned int reference_uv;
  	unsigned int optimized_uv;
  };
  
  /**
   * struct ti_oppdm_data - OMAP specific opp domain data
   * @vdd_reg:	VDD regulator
   * @vbb_reg:	Body Bias regulator
   * @vdd_table:	Optimized voltage mapping table
   * @num_vdd_table: number of entries in vdd_table
   * @vdd_absolute_max_voltage_uv: absolute maximum voltage in UV for the domain
   */
  struct ti_oppdm_data {
  	struct regulator *vdd_reg;
  	struct regulator *vbb_reg;
  	struct ti_oppdm_optimum_voltage_table *vdd_table;
  	u32 num_vdd_table;
  	u32 vdd_absolute_max_voltage_uv;
  };
  
  /**
   * struct ti_oppdm_of_data - device tree match data
   * @desc:	opp domain descriptor for opp domain core
   * @flags:	specific type of opp domain
   * @efuse_voltage_mask: mask required for efuse register representing voltage
   * @efuse_voltage_uv: Are the efuse entries in micro-volts? if not, assume
   *		milli-volts.
   */
  struct ti_oppdm_of_data {
  	const struct pm_opp_domain_desc *desc;
  #define OPPDM_EFUSE_CLASS0_OPTIMIZED_VOLTAGE	BIT(1)
  #define OPPDM_HAS_NO_ABB			BIT(2)
  	const u8 flags;
  	const u32 efuse_voltage_mask;
  	const bool efuse_voltage_uv;
  };
  
  /**
   * oppdm_store_optimized_voltages() - store optimized voltages
   * @dev:	opp domain device for which we need to store info
   * @data:	data specific to the device
   *
   * Picks up efuse based optimized voltages for VDD unique per device and
   * stores it in internal data structure for use during transition requests.
   *
   * Return: If successful, 0, else appropriate error value.
   */
  static int oppdm_store_optimized_voltages(struct device *dev,
  					  struct ti_oppdm_data *data)
  {
  	void __iomem *base;
  	struct property *prop;
  	struct resource *res;
  	const __be32 *val;
  	int proplen, i;
  	int ret = 0;
  	struct ti_oppdm_optimum_voltage_table *table;
  	const struct ti_oppdm_of_data *of_data = dev_get_drvdata(dev);
  
  	/* pick up Efuse based voltages */
  	res = platform_get_resource(to_platform_device(dev), IORESOURCE_MEM, 0);
  	if (!res) {
  		dev_err(dev, "Unable to get IO resource
  ");
  		ret = -ENODEV;
  		goto out_map;
  	}
  
  	base = ioremap_nocache(res->start, resource_size(res));
  	if (!base) {
  		dev_err(dev, "Unable to map Efuse registers
  ");
  		ret = -ENOMEM;
  		goto out_map;
  	}
  
  	/* Fetch efuse-settings. */
  	prop = of_find_property(dev->of_node, "ti,efuse-settings", NULL);
  	if (!prop) {
  		dev_err(dev, "No 'ti,efuse-settings' property found
  ");
  		ret = -EINVAL;
  		goto out;
  	}
  
  	proplen = prop->length / sizeof(int);
  	data->num_vdd_table = proplen / 2;
  	/* Verify for corrupted OPP entries in dt */
  	if (data->num_vdd_table * 2 * sizeof(int) != prop->length) {
  		dev_err(dev, "Invalid 'ti,efuse-settings'
  ");
  		ret = -EINVAL;
  		goto out;
  	}
  
  	ret = of_property_read_u32(dev->of_node, "ti,absolute-max-voltage-uv",
  				   &data->vdd_absolute_max_voltage_uv);
  	if (ret) {
  		dev_err(dev, "ti,absolute-max-voltage-uv is missing
  ");
  		ret = -EINVAL;
  		goto out;
  	}
  
  	table = kzalloc(sizeof(*data->vdd_table) *
  				  data->num_vdd_table, GFP_KERNEL);
  	if (!table) {
  		ret = -ENOMEM;
  		goto out;
  	}
  	data->vdd_table = table;
  
  	val = prop->value;
  	for (i = 0; i < data->num_vdd_table; i++, table++) {
  		u32 efuse_offset;
  		u32 tmp;
  
  		table->reference_uv = be32_to_cpup(val++);
  		efuse_offset = be32_to_cpup(val++);
  
  		tmp = readl(base + efuse_offset);
  		tmp &= of_data->efuse_voltage_mask;
  		tmp >>= __ffs(of_data->efuse_voltage_mask);
  
  		table->optimized_uv = of_data->efuse_voltage_uv ? tmp :
  					tmp * 1000;
  
  		dev_dbg(dev, "[%d] efuse=0x%08x volt_table=%d vset=%d
  ",
  			i, efuse_offset, table->reference_uv,
  			table->optimized_uv);
  
  		/*
  		 * Some older samples might not have optimized efuse
  		 * Use reference voltage for those - just add debug message
  		 * for them.
  		 */
  		if (!table->optimized_uv) {
  			dev_dbg(dev, "[%d] efuse=0x%08x volt_table=%d:vset0
  ",
  				i, efuse_offset, table->reference_uv);
  			table->optimized_uv = table->reference_uv;
  		}
  	}
  out:
  	iounmap(base);
  out_map:
  	return ret;
  }
  
  /**
   * oppdm_free_optimized_voltages() - free resources for optimized voltages
   * @dev:	opp domain device for which we need to free info
   * @data:	data specific to the device
   */
  static void oppdm_free_optimized_voltages(struct device *dev,
  					  struct ti_oppdm_data *data)
  {
  	kfree(data->vdd_table);
  	data->vdd_table = NULL;
  	data->num_vdd_table = 0;
  }
  
  /**
   * oppdm_get_optimal_vdd_voltage() - Finds optimal voltage for the domain
   * @dev:	opp domain device for which we need to find info
   * @data:	data specific to the device
   * @reference_uv:	reference voltage (OPP voltage) for which we need value
   *
   * Return: if a match is found, return optimized voltage, else return
   * reference_uv, also return reference_uv if no optimization is needed.
   */
  static int oppdm_get_optimal_vdd_voltage(struct device *dev,
  					 struct ti_oppdm_data *data,
  					 int reference_uv)
  {
  	int i;
  	struct ti_oppdm_optimum_voltage_table *table;
  
  	if (!data->num_vdd_table)
  		return reference_uv;
  
  	table = data->vdd_table;
  	if (!table)
  		return -EINVAL;
  
  	/* Find a exact match - this list is usually very small */
  	for (i = 0; i < data->num_vdd_table; i++, table++)
  		if (table->reference_uv == reference_uv)
  			return table->optimized_uv;
  
  	/* IF things are screwed up, we'd make a mess on console.. ratelimit */
  	dev_err_ratelimited(dev, "%s: Failed optimized voltage match for %d
  ",
  			    __func__, reference_uv);
  	return reference_uv;
  }
  
  /**
   * ti_oppdm_do_transition() - do the opp domain transition
   * @dev:	opp domain device for which we are doing the transition
   * @oppdm_data:	data specific to the device
   * @clk_notifier_flags:	clk notifier flags for direction of transition
   * @uv:		what voltage to transition to
   * @uv_min:	minimum acceptable voltage for transition
   * @uv_max:	maximum	acceptable voltage for transition
   *
   * Return: If successful, 0, else appropriate error value.
   */
  static int ti_oppdm_do_transition(struct device *dev,
  				  void *oppdm_data,
  				  unsigned long clk_notifier_flags, int uv,
  				  int uv_min, int uv_max)
  {
  	struct ti_oppdm_data *data = (struct ti_oppdm_data *)oppdm_data;
  	int ret;
  	bool do_abb_first;
  	int vdd_uv;
  
  	if (!data)
  		return -EINVAL;
  
  	if (uv_max > data->vdd_absolute_max_voltage_uv) {
  		dev_warn(dev,
  			 "exceeding vdd_absolute_max_voltage_uv, using %d for uv_max
  ",
  			 data->vdd_absolute_max_voltage_uv);
  		uv_max = data->vdd_absolute_max_voltage_uv;
  	}
  	/*
  	 * If we do have an absolute max voltage specified, then we should
  	 * use that voltage instead to allow for cases where the voltage rails
  	 * are ganged (example if we set the max for an opp as 1.12v, and
  	 * the absolute max is 1.5v, for another rail to get 1.25v, it cannot
  	 * be achieved if the regulator is constrainted to max of 1.12v, even
  	 * if it can function at 1.25v
  	 */
  	if (data->vdd_absolute_max_voltage_uv)
  		uv_max = data->vdd_absolute_max_voltage_uv;
  
  	do_abb_first = clk_notifier_flags == PM_OPPDM_VOLT_ABORTRATE ||
  	    clk_notifier_flags == PM_OPPDM_VOLT_POSTRATE;
  
  	vdd_uv = oppdm_get_optimal_vdd_voltage(dev, data, uv);
  
  	if (vdd_uv > uv_max || vdd_uv < uv_min || uv_min > uv_max) {
  		dev_warn(dev,
  			 "Invalid range voltages [Min:%d target:%d Max:%d]
  ",
  			 uv_min, vdd_uv, uv_max);
  		return -EINVAL;
  	}
  
  	if (do_abb_first && !IS_ERR(data->vbb_reg)) {
  		dev_dbg(dev, "vbb pre %duV[min %duV max %duV]
  ", uv, uv_min,
  			uv_max);
  		ret = regulator_set_voltage_triplet(data->vbb_reg, uv_min,
  						    uv, uv_max);
  		if (ret) {
  			dev_err(dev,
  				"vbb failed for voltage %duV[min %duV max %duV]:%d
  ",
  				uv, uv_min, uv_max, ret);
  			return ret;
  		}
  	}
  
  	dev_dbg(dev, "vdd for voltage %duV(ref=%duV)[min %duV max %duV] MAX=%duV
  ",
  		vdd_uv, uv, uv_min, uv_max, data->vdd_absolute_max_voltage_uv);
  
  	ret = regulator_set_voltage_triplet(data->vdd_reg, uv_min,
  					    vdd_uv, uv_max);
  	if (ret) {
  		dev_err(dev,
  			"vdd failed for voltage %duV(ref=%duV)[min %duV max %duV]:%d
  ",
  			vdd_uv, uv, uv_min, uv_max, ret);
  		return ret;
  	}
  
  	if (!do_abb_first && !IS_ERR(data->vbb_reg)) {
  		dev_dbg(dev, "vbb post %duV[min %duV max %duV]
  ", uv, uv_min,
  			uv_max);
  		ret = regulator_set_voltage_triplet(data->vbb_reg, uv_min,
  						    uv, uv_max);
  		if (ret) {
  			dev_err(dev,
  				"vbb failed for voltage %duV[min %duV max %duV]:%d
  ",
  				uv, uv_min, uv_max, ret);
  			return ret;
  		}
  	}
  
  	return 0;
  }
  
  /**
   * ti_oppdm_latency() - provide the transition latency for the opp domain
   * @dev:	opp domain device for which we are doing the transition
   * @oppdm_data: data specific to the device
   * @old_uv: starting voltage in microvolts
   * @old_uv_min: minimum acceptable starting voltage in microvolts
   * @old_uv_max: maximum acceptable starting voltage in microvolts
   * @new_uv: target voltage in microvolts
   * @new_uv_min: minimum acceptable target voltage in microvolts
   * @new_uv_max: maximum acceptable target voltage in microvolts
   *
   * Return: If successful, the combined transition latency from min to max, else
   * returns error value
   */
  static int ti_oppdm_latency(struct device *dev, void *oppdm_data,
  			    unsigned long old_uv,
  			    unsigned long old_uv_min,
  			    unsigned long old_uv_max,
  			    unsigned long new_uv,
  			    unsigned long new_uv_min,
  			    unsigned long new_uv_max)
  {
  	struct ti_oppdm_data *data = (struct ti_oppdm_data *)oppdm_data;
  	int ret, tot_latency = 0;
  
  	if (!data)
  		return -EINVAL;
  
  	/*
  	 * NOTE: latency computations can depend on regulator involved
  	 * We just provide the best of the information we can find.
  	 */
  	ret = regulator_set_voltage_time_triplet(data->vdd_reg, old_uv,
  						 old_uv_min, old_uv_max,
  						 new_uv, new_uv_min,
  						 new_uv_max);
  	if (ret < 0) {
  		dev_dbg(dev, "vdd failed voltage latency: %d
  ", ret);
  		goto skip_vdd;
  	}
  	tot_latency += ret;
  
  skip_vdd:
  	if (IS_ERR(data->vbb_reg))
  		goto skip_vbb;
  
  	ret = regulator_set_voltage_time_triplet(data->vbb_reg, old_uv,
  						 old_uv_min, old_uv_max,
  						 new_uv, new_uv_min,
  						 new_uv_max);
  	if (ret < 0) {
  		dev_dbg(dev, "vbb failed voltage latency: %d
  ", ret);
  		goto skip_vbb;
  	}
  	tot_latency += ret;
  
  skip_vbb:
  	/* If we have No data at all.. return last error result */
  	if (!tot_latency)
  		return ret;
  
  	return tot_latency;
  }
  
  static inline void ti_oppdm_cleanup(struct ti_oppdm_data *data)
  {
  	if (!IS_ERR(data->vbb_reg))
  		regulator_put(data->vbb_reg);
  	if (!IS_ERR(data->vdd_reg))
  		regulator_put(data->vdd_reg);
  	kfree(data);
  }
  
  /**
   * ti_oppdm_get() - get the opp domain resources specific to request
   * @oppdm_dev:		opp domain device
   * @request_dev:	device for which we have been requested to get
   * @np:			unused
   * @supply:		unused
   * @oppdm_data:		returns data for the current request (freed in put)
   *
   * Return: 0 if everything went OK, else return appropriate error value.
   */
  static int ti_oppdm_get(struct device *oppdm_dev,
  			struct device *request_dev,
  			struct device_node *np,
  			const char *supply,
  			void **oppdm_data)
  {
  	struct ti_oppdm_data *data;
  	int ret = 0;
  	const struct ti_oppdm_of_data *of_data = dev_get_drvdata(oppdm_dev);
  
  	data = kzalloc(sizeof(*data), GFP_KERNEL);
  	if (!data)
  		return -ENOMEM;
  
  	/* If we need optimized voltage */
  	if (of_data->flags & OPPDM_EFUSE_CLASS0_OPTIMIZED_VOLTAGE) {
  		ret = oppdm_store_optimized_voltages(oppdm_dev, data);
  		if (ret)
  			goto out_free;
  	}
  
  	/*
  	 * Setup aliases for request device supply to let regulator framework
  	 * do multi-consumer scenario
  	 */
  	ret = regulator_register_supply_alias(request_dev, "vdd",
  					      oppdm_dev, "vdd");
  	if (ret)
  		goto out_release_optimized_voltages;
  	ret = regulator_register_supply_alias(request_dev, "vbb",
  					      oppdm_dev, "vbb");
  	if (ret)
  		goto out_unreg_vdd;
  
  	data->vdd_reg = regulator_get(request_dev, "vdd");
  	if (IS_ERR(data->vdd_reg)) {
  		ret = PTR_ERR(data->vdd_reg);
  		dev_err(oppdm_dev, "Unable to get vdd regulator:%d
  ", ret);
  		goto out_unreg;
  	}
  
  	if (of_data->flags & OPPDM_HAS_NO_ABB) {
  		data->vbb_reg = ERR_PTR(-ENODEV);
  	} else {
  		data->vbb_reg = regulator_get(request_dev, "vbb");
  		if (IS_ERR(data->vbb_reg)) {
  			ret = PTR_ERR(data->vbb_reg);
  			dev_err(oppdm_dev, "Unable to get vbb regulator:%d
  ",
  				ret);
  			goto out_vdd_reg;
  		}
  	}
  
  	*oppdm_data = data;
  	return 0;
  
  out_vdd_reg:
  	regulator_put(data->vdd_reg);
  out_unreg:
  	regulator_unregister_supply_alias(request_dev, "vbb");
  out_unreg_vdd:
  	regulator_unregister_supply_alias(request_dev, "vdd");
  out_release_optimized_voltages:
  	if (of_data->flags & OPPDM_EFUSE_CLASS0_OPTIMIZED_VOLTAGE)
  		oppdm_free_optimized_voltages(oppdm_dev, data);
  out_free:
  	kfree(data);
  
  	return ret;
  }
  
  /**
   * ti_oppdm_put() - release the resources reserved by ti_oppdm_get()
   * @oppdm_dev:		opp domain device for which we reserved resources
   * @request_dev:	device for which we have been requested to put
   * @oppdm_data:		data for the request provided by ti_oppdm_get()
   */
  static void ti_oppdm_put(struct device *oppdm_dev,
  			 struct device *request_dev, void *oppdm_data)
  {
  	struct ti_oppdm_data *data = (struct ti_oppdm_data *)oppdm_data;
  
  	if (!IS_ERR(data->vbb_reg))
  		regulator_put(data->vbb_reg);
  	regulator_put(data->vdd_reg);
  	regulator_unregister_supply_alias(request_dev, "vbb");
  	regulator_unregister_supply_alias(request_dev, "vdd");
  	kfree(data);
  }
  
  /**
   * ti_oppdm_is_supported_voltage() - return if provided voltage is supported
   * @oppdm_dev:		opp domain device for which we reserved resources
   * @oppdm_data:		data for the request provided by ti_oppdm_get()
   * @uv_min:		minimum voltage range to check if supported
   * @uv_max:		maximum voltage range to check if supported
   *
   * Checks that voltage is supported by both vdd and vbb regulators if present
   */
  static bool ti_oppdm_is_supported_voltage(struct device *oppdm_dev,
  					  void *oppdm_data,
  					  unsigned long uv_min,
  					  unsigned long uv_max)
  {
  	struct ti_oppdm_data *data = (struct ti_oppdm_data *)oppdm_data;
  
  	if (!IS_ERR(data->vdd_reg) &&
  	    !regulator_is_supported_voltage(data->vdd_reg, uv_min,
  					    uv_max))
  		return false;
  
  	if (!IS_ERR(data->vbb_reg) &&
  	    !regulator_is_supported_voltage(data->vbb_reg, uv_min,
  					    uv_max))
  		return false;
  
  	return true;
  }
  
  static const struct pm_opp_domain_ops ti_oppdm_ops = {
  	.oppdm_get = ti_oppdm_get,
  	.oppdm_put = ti_oppdm_put,
  	.oppdm_get_latency = ti_oppdm_latency,
  	.oppdm_do_transition = ti_oppdm_do_transition,
  	.oppdm_is_supported_voltage = ti_oppdm_is_supported_voltage,
  };
  
  static const struct pm_opp_domain_desc ti_oppdm_desc = {
  	.ops = &ti_oppdm_ops,
  };
  
  static const struct ti_oppdm_of_data omap_generic_of_data = {
  	.desc = &ti_oppdm_desc,
  };
  
  static const struct ti_oppdm_of_data omap_omap5_of_data = {
  	.desc = &ti_oppdm_desc,
  	.flags = OPPDM_EFUSE_CLASS0_OPTIMIZED_VOLTAGE,
  	.efuse_voltage_mask = 0xFFF,
  	.efuse_voltage_uv = false,
  };
  
  static const struct ti_oppdm_of_data omap_omap5core_of_data = {
  	.desc = &ti_oppdm_desc,
  	.flags = OPPDM_EFUSE_CLASS0_OPTIMIZED_VOLTAGE | OPPDM_HAS_NO_ABB,
  	.efuse_voltage_mask = 0xFFF,
  	.efuse_voltage_uv = false,
  };
  
  static const struct of_device_id ti_oppdm_of_match[] = {
  	{.compatible = "ti,omap-oppdm", .data = &omap_generic_of_data},
  	{.compatible = "ti,omap5-oppdm", .data = &omap_omap5_of_data},
  	{.compatible = "ti,omap5-core-oppdm", .data = &omap_omap5core_of_data},
  	{},
  };
  
  static int ti_oppdm_probe(struct platform_device *pdev)
  {
  	struct device *dev = &pdev->dev;
  	const struct of_device_id *match;
  	struct pm_opp_domain_dev *oppdm_dev;
  	int ret = 0;
  	const struct ti_oppdm_of_data *of_data;
  
  	match = of_match_device(ti_oppdm_of_match, dev);
  	if (!match) {
  		/* We do not expect this to happen */
  		dev_err(dev, "%s: Unable to match device
  ", __func__);
  		return -ENODEV;
  	}
  	if (!match->data) {
  		/* Again, unlikely.. but mistakes do happen */
  		dev_err(dev, "%s: Bad data in match
  ", __func__);
  		return -EINVAL;
  	}
  	of_data = match->data;
  
  	dev_set_drvdata(dev, (void *)of_data);
  	oppdm_dev = devm_opp_domain_register(dev, of_data->desc);
  	if (IS_ERR(oppdm_dev)) {
  		ret = PTR_ERR(oppdm_dev);
  		dev_err(dev, "Failed to register opp domain %d
  ", ret);
  	}
  
  	return ret;
  }
  
  MODULE_DEVICE_TABLE(of, ti_oppdm_of_match);
  
  static struct platform_driver ti_oppdm_driver = {
  	.probe = ti_oppdm_probe,
  	.driver = {
  		   .name = "ti_oppdm",
  		   .owner = THIS_MODULE,
  		   .of_match_table = of_match_ptr(ti_oppdm_of_match),
  		   },
  };
  module_platform_driver(ti_oppdm_driver);
  
  MODULE_DESCRIPTION("Texas Instruments OMAP OPP Domain driver");
  MODULE_AUTHOR("Texas Instruments Inc.");
  MODULE_LICENSE("GPL v2");