regulator: fixed: Use core GPIO enable support (25a53dfb) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/regulator/fixed.c

+18 −88

Original line number	Original line	Diff line number	Diff line
	@@ -35,9 +35,6 @@ struct fixed_voltage_data {
	struct regulator_desc desc;		struct regulator_desc desc;
	struct regulator_dev *dev;		struct regulator_dev *dev;
	int microvolts;		int microvolts;
	int gpio;
	bool enable_high;
	bool is_enabled;
	};		};


	@@ -108,33 +105,6 @@ of_get_fixed_voltage_config(struct device *dev)
	return config;		return config;
	}		}

	static int fixed_voltage_is_enabled(struct regulator_dev *dev)
	{
	struct fixed_voltage_data *data = rdev_get_drvdata(dev);

	return data->is_enabled;
	}

	static int fixed_voltage_enable(struct regulator_dev *dev)
	{
	struct fixed_voltage_data *data = rdev_get_drvdata(dev);

	gpio_set_value_cansleep(data->gpio, data->enable_high);
	data->is_enabled = true;

	return 0;
	}

	static int fixed_voltage_disable(struct regulator_dev *dev)
	{
	struct fixed_voltage_data *data = rdev_get_drvdata(dev);

	gpio_set_value_cansleep(data->gpio, !data->enable_high);
	data->is_enabled = false;

	return 0;
	}

	static int fixed_voltage_get_voltage(struct regulator_dev *dev)		static int fixed_voltage_get_voltage(struct regulator_dev *dev)
	{		{
	struct fixed_voltage_data *data = rdev_get_drvdata(dev);		struct fixed_voltage_data *data = rdev_get_drvdata(dev);
	@@ -156,14 +126,6 @@ static int fixed_voltage_list_voltage(struct regulator_dev *dev,
	return data->microvolts;		return data->microvolts;
	}		}

	static struct regulator_ops fixed_voltage_gpio_ops = {
	.is_enabled = fixed_voltage_is_enabled,
	.enable = fixed_voltage_enable,
	.disable = fixed_voltage_disable,
	.get_voltage = fixed_voltage_get_voltage,
	.list_voltage = fixed_voltage_list_voltage,
	};

	static struct regulator_ops fixed_voltage_ops = {		static struct regulator_ops fixed_voltage_ops = {
	.get_voltage = fixed_voltage_get_voltage,		.get_voltage = fixed_voltage_get_voltage,
	.list_voltage = fixed_voltage_list_voltage,		.list_voltage = fixed_voltage_list_voltage,
	@@ -203,6 +165,7 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
	}		}
	drvdata->desc.type = REGULATOR_VOLTAGE;		drvdata->desc.type = REGULATOR_VOLTAGE;
	drvdata->desc.owner = THIS_MODULE;		drvdata->desc.owner = THIS_MODULE;
			drvdata->desc.ops = &fixed_voltage_ops;

	drvdata->desc.enable_time = config->startup_delay;		drvdata->desc.enable_time = config->startup_delay;

	@@ -210,53 +173,25 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
	drvdata->desc.n_voltages = 1;		drvdata->desc.n_voltages = 1;

	drvdata->microvolts = config->microvolts;		drvdata->microvolts = config->microvolts;
	drvdata->gpio = config->gpio;

	if (gpio_is_valid(config->gpio)) {
	int gpio_flag;
	drvdata->enable_high = config->enable_high;

	/* FIXME: Remove below print warning
	*
	* config->gpio must be set to -EINVAL by platform code if
	* GPIO control is not required. However, early adopters
	* not requiring GPIO control may forget to initialize
	* config->gpio to -EINVAL. This will cause GPIO 0 to be used
	* for GPIO control.
	*
	* This warning will be removed once there are a couple of users
	* for this driver.
	*/
	if (!config->gpio)
	dev_warn(&pdev->dev,
	"using GPIO 0 for regulator enable control\n");

	/*
	* set output direction without changing state
	* to prevent glitch
	*/
	drvdata->is_enabled = config->enabled_at_boot;
	ret = drvdata->is_enabled ?
	config->enable_high : !config->enable_high;
	gpio_flag = ret ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;

	if (config->gpio_is_open_drain)		if (config->gpio >= 0)
	gpio_flag \|= GPIOF_OPEN_DRAIN;		cfg.ena_gpio = config->gpio;
			cfg.ena_gpio_invert = !config->enable_high;
	ret = gpio_request_one(config->gpio, gpio_flag,		if (config->enabled_at_boot) {
	config->supply_name);		if (config->enable_high) {
	if (ret) {		cfg.ena_gpio_flags \|= GPIOF_OUT_INIT_HIGH;
	dev_err(&pdev->dev,		} else {
	"Could not obtain regulator enable GPIO %d: %d\n",		cfg.ena_gpio_flags \|= GPIOF_OUT_INIT_LOW;
	config->gpio, ret);
	goto err_name;
	}		}

	drvdata->desc.ops = &fixed_voltage_gpio_ops;

	} else {		} else {
	drvdata->desc.ops = &fixed_voltage_ops;		if (config->enable_high) {
			cfg.ena_gpio_flags \|= GPIOF_OUT_INIT_LOW;
			} else {
			cfg.ena_gpio_flags \|= GPIOF_OUT_INIT_HIGH;
			}
	}		}
			if (config->gpio_is_open_drain)
			cfg.ena_gpio_flags \|= GPIOF_OPEN_DRAIN;

	cfg.dev = &pdev->dev;		cfg.dev = &pdev->dev;
	cfg.init_data = config->init_data;		cfg.init_data = config->init_data;
	@@ -267,7 +202,7 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
	if (IS_ERR(drvdata->dev)) {		if (IS_ERR(drvdata->dev)) {
	ret = PTR_ERR(drvdata->dev);		ret = PTR_ERR(drvdata->dev);
	dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);		dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
	goto err_gpio;		goto err_name;
	}		}

	platform_set_drvdata(pdev, drvdata);		platform_set_drvdata(pdev, drvdata);
	@@ -277,9 +212,6 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)

	return 0;		return 0;

	err_gpio:
	if (gpio_is_valid(config->gpio))
	gpio_free(config->gpio);
	err_name:		err_name:
	kfree(drvdata->desc.name);		kfree(drvdata->desc.name);
	err:		err:
	@@ -291,8 +223,6 @@ static int __devexit reg_fixed_voltage_remove(struct platform_device *pdev)
	struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev);		struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev);

	regulator_unregister(drvdata->dev);		regulator_unregister(drvdata->dev);
	if (gpio_is_valid(drvdata->gpio))
	gpio_free(drvdata->gpio);
	kfree(drvdata->desc.name);		kfree(drvdata->desc.name);

	return 0;		return 0;