drivers/platform/x86/intel/int3472/clk_and_regulator.c - pub/scm/linux/kernel/git/pdx86/platform-drivers-x86 - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /* Author: Dan Scally <djrscally@gmail.com> */

 #include <linux/acpi.h>
 #include <linux/clkdev.h>
 #include <linux/clk-provider.h>
 #include <linux/device.h>
 #include <linux/dmi.h>
 #include <linux/gpio/consumer.h>
 #include <linux/regulator/driver.h>
 #include <linux/slab.h>

 #include "common.h"

 /*
  * 82c0d13a-78c5-4244-9bb1-eb8b539a8d11
  * This _DSM GUID allows controlling the sensor clk when it is not controlled
  * through a GPIO.
  */
 static const guid_t img_clk_guid =
 	GUID_INIT(0x82c0d13a, 0x78c5, 0x4244,
 		  0x9b, 0xb1, 0xeb, 0x8b, 0x53, 0x9a, 0x8d, 0x11);

 static void skl_int3472_enable_clk(struct int3472_clock *clk, int enable)
 {
 	struct int3472_discrete_device *int3472 = to_int3472_device(clk);
 	union acpi_object args[3];
 	union acpi_object argv4;

 	if (clk->ena_gpio) {
 		gpiod_set_value_cansleep(clk->ena_gpio, enable);
 		return;
 	}

 	args[0].integer.type = ACPI_TYPE_INTEGER;
 	args[0].integer.value = clk->imgclk_index;
 	args[1].integer.type = ACPI_TYPE_INTEGER;
 	args[1].integer.value = enable;
 	args[2].integer.type = ACPI_TYPE_INTEGER;
 	args[2].integer.value = 1;

 	argv4.type = ACPI_TYPE_PACKAGE;
 	argv4.package.count = 3;
 	argv4.package.elements = args;

 	acpi_evaluate_dsm(acpi_device_handle(int3472->adev), &img_clk_guid,
 			  0, 1, &argv4);
 }

 /*
  * The regulators have to have .ops to be valid, but the only ops we actually
  * support are .enable and .disable which are handled via .ena_gpiod. Pass an
  * empty struct to clear the check without lying about capabilities.
  */
 static const struct regulator_ops int3472_gpio_regulator_ops;

 static int skl_int3472_clk_prepare(struct clk_hw *hw)
 {
 	skl_int3472_enable_clk(to_int3472_clk(hw), 1);
 	return 0;
 }

 static void skl_int3472_clk_unprepare(struct clk_hw *hw)
 {
 	skl_int3472_enable_clk(to_int3472_clk(hw), 0);
 }

 static int skl_int3472_clk_enable(struct clk_hw *hw)
 {
 	/*
 	 * We're just turning a GPIO on to enable the clock, which operation
 	 * has the potential to sleep. Given .enable() cannot sleep, but
 	 * .prepare() can, we toggle the GPIO in .prepare() instead. Thus,
 	 * nothing to do here.
 	 */
 	return 0;
 }

 static void skl_int3472_clk_disable(struct clk_hw *hw)
 {
 	/* Likewise, nothing to do here... */
 }

 static unsigned int skl_int3472_get_clk_frequency(struct int3472_discrete_device *int3472)
 {
 	union acpi_object *obj;
 	unsigned int freq;

 	obj = skl_int3472_get_acpi_buffer(int3472->sensor, "SSDB");
 	if (IS_ERR(obj))
 		return 0; /* report rate as 0 on error */

 	if (obj->buffer.length < CIO2_SENSOR_SSDB_MCLKSPEED_OFFSET + sizeof(u32)) {
 		dev_err(int3472->dev, "The buffer is too small\n");
 		kfree(obj);
 		return 0;
 	}

 	freq = *(u32 *)(obj->buffer.pointer + CIO2_SENSOR_SSDB_MCLKSPEED_OFFSET);

 	kfree(obj);
 	return freq;
 }

 static unsigned long skl_int3472_clk_recalc_rate(struct clk_hw *hw,
 						 unsigned long parent_rate)
 {
 	struct int3472_clock *clk = to_int3472_clk(hw);

 	return clk->frequency;
 }

 static const struct clk_ops skl_int3472_clock_ops = {
 	.prepare = skl_int3472_clk_prepare,
 	.unprepare = skl_int3472_clk_unprepare,
 	.enable = skl_int3472_clk_enable,
 	.disable = skl_int3472_clk_disable,
 	.recalc_rate = skl_int3472_clk_recalc_rate,
 };

 int skl_int3472_register_dsm_clock(struct int3472_discrete_device *int3472)
 {
 	struct acpi_device *adev = int3472->adev;
 	struct clk_init_data init = {
 		.ops = &skl_int3472_clock_ops,
 		.flags = CLK_GET_RATE_NOCACHE,
 	};
 	int ret;

 	if (int3472->clock.cl)
 		return 0; /* A GPIO controlled clk has already been registered */

 	if (!acpi_check_dsm(adev->handle, &img_clk_guid, 0, BIT(1)))
 		return 0; /* DSM clock control is not available */

 	init.name = kasprintf(GFP_KERNEL, "%s-clk", acpi_dev_name(adev));
 	if (!init.name)
 		return -ENOMEM;

 	int3472->clock.frequency = skl_int3472_get_clk_frequency(int3472);
 	int3472->clock.clk_hw.init = &init;
 	int3472->clock.clk = clk_register(&adev->dev, &int3472->clock.clk_hw);
 	if (IS_ERR(int3472->clock.clk)) {
 		ret = PTR_ERR(int3472->clock.clk);
 		goto out_free_init_name;
 	}

 	int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL, int3472->sensor_name);
 	if (!int3472->clock.cl) {
 		ret = -ENOMEM;
 		goto err_unregister_clk;
 	}

 	kfree(init.name);
 	return 0;

 err_unregister_clk:
 	clk_unregister(int3472->clock.clk);
 out_free_init_name:
 	kfree(init.name);
 	return ret;
 }

 int skl_int3472_register_gpio_clock(struct int3472_discrete_device *int3472,
 				    struct gpio_desc *gpio)
 {
 	struct clk_init_data init = {
 		.ops = &skl_int3472_clock_ops,
 		.flags = CLK_GET_RATE_NOCACHE,
 	};
 	int ret;

 	if (int3472->clock.cl)
 		return -EBUSY;

 	int3472->clock.ena_gpio = gpio;

 	init.name = kasprintf(GFP_KERNEL, "%s-clk",
 			      acpi_dev_name(int3472->adev));
 	if (!init.name)
 		return -ENOMEM;

 	int3472->clock.frequency = skl_int3472_get_clk_frequency(int3472);

 	int3472->clock.clk_hw.init = &init;
 	int3472->clock.clk = clk_register(&int3472->adev->dev,
 					  &int3472->clock.clk_hw);
 	if (IS_ERR(int3472->clock.clk)) {
 		ret = PTR_ERR(int3472->clock.clk);
 		goto out_free_init_name;
 	}

 	int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL,
 					  int3472->sensor_name);
 	if (!int3472->clock.cl) {
 		ret = -ENOMEM;
 		goto err_unregister_clk;
 	}

 	kfree(init.name);
 	return 0;

 err_unregister_clk:
 	clk_unregister(int3472->clock.clk);
 out_free_init_name:
 	kfree(init.name);

 	return ret;
 }

 void skl_int3472_unregister_clock(struct int3472_discrete_device *int3472)
 {
 	if (!int3472->clock.cl)
 		return;

 	clkdev_drop(int3472->clock.cl);
 	clk_unregister(int3472->clock.clk);
 }

 /*
  * The INT3472 device is going to be the only supplier of a regulator for
  * the sensor device. But unlike the clk framework the regulator framework
  * does not allow matching by consumer-device-name only.
  *
  * Ideally all sensor drivers would use "avdd" as supply-id. But for drivers
  * where this cannot be changed because another supply-id is already used in
  * e.g. DeviceTree files an alias for the other supply-id can be added here.
  *
  * Do not forget to update GPIO_REGULATOR_SUPPLY_MAP_COUNT when changing this.
  */
 static const char * const skl_int3472_regulator_map_supplies[] = {
 	"avdd",
 	"AVDD",
 };

 static_assert(ARRAY_SIZE(skl_int3472_regulator_map_supplies) ==
 	      GPIO_REGULATOR_SUPPLY_MAP_COUNT);

 /*
  * On some models there is a single GPIO regulator which is shared between
  * sensors and only listed in the ACPI resources of one sensor.
  * This DMI table contains the name of the second sensor. This is used to add
  * entries for the second sensor to the supply_map.
  */
 static const struct dmi_system_id skl_int3472_regulator_second_sensor[] = {
 	{
 		/* Lenovo Miix 510-12IKB */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 			DMI_MATCH(DMI_PRODUCT_VERSION, "MIIX 510-12IKB"),
 		},
 		.driver_data = "i2c-OVTI2680:00",
 	},
 	{ }
 };

 int skl_int3472_register_regulator(struct int3472_discrete_device *int3472,
 				   struct gpio_desc *gpio)
 {
 	struct regulator_init_data init_data = { };
 	struct regulator_config cfg = { };
 	const char *second_sensor = NULL;
 	const struct dmi_system_id *id;
 	int i, j;

 	id = dmi_first_match(skl_int3472_regulator_second_sensor);
 	if (id)
 		second_sensor = id->driver_data;

 	for (i = 0, j = 0; i < ARRAY_SIZE(skl_int3472_regulator_map_supplies); i++) {
 		int3472->regulator.supply_map[j].supply = skl_int3472_regulator_map_supplies[i];
 		int3472->regulator.supply_map[j].dev_name = int3472->sensor_name;
 		j++;

 		if (second_sensor) {
 			int3472->regulator.supply_map[j].supply =
 				skl_int3472_regulator_map_supplies[i];
 			int3472->regulator.supply_map[j].dev_name = second_sensor;
 			j++;
 		}
 	}

 	init_data.constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS;
 	init_data.consumer_supplies = int3472->regulator.supply_map;
 	init_data.num_consumer_supplies = j;

 	snprintf(int3472->regulator.regulator_name,
 		 sizeof(int3472->regulator.regulator_name), "%s-regulator",
 		 acpi_dev_name(int3472->adev));
 	snprintf(int3472->regulator.supply_name,
 		 GPIO_REGULATOR_SUPPLY_NAME_LENGTH, "supply-0");

 	int3472->regulator.rdesc = INT3472_REGULATOR(
 						int3472->regulator.regulator_name,
 						int3472->regulator.supply_name,
 						&int3472_gpio_regulator_ops);

 	int3472->regulator.gpio = gpio;

 	cfg.dev = &int3472->adev->dev;
 	cfg.init_data = &init_data;
 	cfg.ena_gpiod = int3472->regulator.gpio;

 	int3472->regulator.rdev = regulator_register(int3472->dev,
 						     &int3472->regulator.rdesc,
 						     &cfg);

 	return PTR_ERR_OR_ZERO(int3472->regulator.rdev);
 }

 void skl_int3472_unregister_regulator(struct int3472_discrete_device *int3472)
 {
 	regulator_unregister(int3472->regulator.rdev);
 }
	// SPDX-License-Identifier: GPL-2.0
	/* Author: Dan Scally <djrscally@gmail.com> */

	#include <linux/acpi.h>
	#include <linux/clkdev.h>
	#include <linux/clk-provider.h>
	#include <linux/device.h>
	#include <linux/dmi.h>
	#include <linux/gpio/consumer.h>
	#include <linux/regulator/driver.h>
	#include <linux/slab.h>

	#include "common.h"

	/*
	* 82c0d13a-78c5-4244-9bb1-eb8b539a8d11
	* This _DSM GUID allows controlling the sensor clk when it is not controlled
	* through a GPIO.
	*/
	static const guid_t img_clk_guid =
	GUID_INIT(0x82c0d13a, 0x78c5, 0x4244,
	0x9b, 0xb1, 0xeb, 0x8b, 0x53, 0x9a, 0x8d, 0x11);

	static void skl_int3472_enable_clk(struct int3472_clock *clk, int enable)
	{
	struct int3472_discrete_device *int3472 = to_int3472_device(clk);
	union acpi_object args[3];
	union acpi_object argv4;

	if (clk->ena_gpio) {
	gpiod_set_value_cansleep(clk->ena_gpio, enable);
	return;
	}

	args[0].integer.type = ACPI_TYPE_INTEGER;
	args[0].integer.value = clk->imgclk_index;
	args[1].integer.type = ACPI_TYPE_INTEGER;
	args[1].integer.value = enable;
	args[2].integer.type = ACPI_TYPE_INTEGER;
	args[2].integer.value = 1;

	argv4.type = ACPI_TYPE_PACKAGE;
	argv4.package.count = 3;
	argv4.package.elements = args;

	acpi_evaluate_dsm(acpi_device_handle(int3472->adev), &img_clk_guid,
	0, 1, &argv4);
	}

	/*
	* The regulators have to have .ops to be valid, but the only ops we actually
	* support are .enable and .disable which are handled via .ena_gpiod. Pass an
	* empty struct to clear the check without lying about capabilities.
	*/
	static const struct regulator_ops int3472_gpio_regulator_ops;

	static int skl_int3472_clk_prepare(struct clk_hw *hw)
	{
	skl_int3472_enable_clk(to_int3472_clk(hw), 1);
	return 0;
	}

	static void skl_int3472_clk_unprepare(struct clk_hw *hw)
	{
	skl_int3472_enable_clk(to_int3472_clk(hw), 0);
	}

	static int skl_int3472_clk_enable(struct clk_hw *hw)
	{
	/*
	* We're just turning a GPIO on to enable the clock, which operation
	* has the potential to sleep. Given .enable() cannot sleep, but
	* .prepare() can, we toggle the GPIO in .prepare() instead. Thus,
	* nothing to do here.
	*/
	return 0;
	}

	static void skl_int3472_clk_disable(struct clk_hw *hw)
	{
	/* Likewise, nothing to do here... */
	}

	static unsigned int skl_int3472_get_clk_frequency(struct int3472_discrete_device *int3472)
	{
	union acpi_object *obj;
	unsigned int freq;

	obj = skl_int3472_get_acpi_buffer(int3472->sensor, "SSDB");
	if (IS_ERR(obj))
	return 0; /* report rate as 0 on error */

	if (obj->buffer.length < CIO2_SENSOR_SSDB_MCLKSPEED_OFFSET + sizeof(u32)) {
	dev_err(int3472->dev, "The buffer is too small\n");
	kfree(obj);
	return 0;
	}

	freq = (u32 )(obj->buffer.pointer + CIO2_SENSOR_SSDB_MCLKSPEED_OFFSET);

	kfree(obj);
	return freq;
	}

	static unsigned long skl_int3472_clk_recalc_rate(struct clk_hw *hw,
	unsigned long parent_rate)
	{
	struct int3472_clock *clk = to_int3472_clk(hw);

	return clk->frequency;
	}

	static const struct clk_ops skl_int3472_clock_ops = {
	.prepare = skl_int3472_clk_prepare,
	.unprepare = skl_int3472_clk_unprepare,
	.enable = skl_int3472_clk_enable,
	.disable = skl_int3472_clk_disable,
	.recalc_rate = skl_int3472_clk_recalc_rate,
	};

	int skl_int3472_register_dsm_clock(struct int3472_discrete_device *int3472)
	{
	struct acpi_device *adev = int3472->adev;
	struct clk_init_data init = {
	.ops = &skl_int3472_clock_ops,
	.flags = CLK_GET_RATE_NOCACHE,
	};
	int ret;

	if (int3472->clock.cl)
	return 0; /* A GPIO controlled clk has already been registered */

	if (!acpi_check_dsm(adev->handle, &img_clk_guid, 0, BIT(1)))
	return 0; /* DSM clock control is not available */

	init.name = kasprintf(GFP_KERNEL, "%s-clk", acpi_dev_name(adev));
	if (!init.name)
	return -ENOMEM;

	int3472->clock.frequency = skl_int3472_get_clk_frequency(int3472);
	int3472->clock.clk_hw.init = &init;
	int3472->clock.clk = clk_register(&adev->dev, &int3472->clock.clk_hw);
	if (IS_ERR(int3472->clock.clk)) {
	ret = PTR_ERR(int3472->clock.clk);
	goto out_free_init_name;
	}

	int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL, int3472->sensor_name);
	if (!int3472->clock.cl) {
	ret = -ENOMEM;
	goto err_unregister_clk;
	}

	kfree(init.name);
	return 0;

	err_unregister_clk:
	clk_unregister(int3472->clock.clk);
	out_free_init_name:
	kfree(init.name);
	return ret;
	}

	int skl_int3472_register_gpio_clock(struct int3472_discrete_device *int3472,
	struct gpio_desc *gpio)
	{
	struct clk_init_data init = {
	.ops = &skl_int3472_clock_ops,
	.flags = CLK_GET_RATE_NOCACHE,
	};
	int ret;

	if (int3472->clock.cl)
	return -EBUSY;

	int3472->clock.ena_gpio = gpio;

	init.name = kasprintf(GFP_KERNEL, "%s-clk",
	acpi_dev_name(int3472->adev));
	if (!init.name)
	return -ENOMEM;

	int3472->clock.frequency = skl_int3472_get_clk_frequency(int3472);

	int3472->clock.clk_hw.init = &init;
	int3472->clock.clk = clk_register(&int3472->adev->dev,
	&int3472->clock.clk_hw);
	if (IS_ERR(int3472->clock.clk)) {
	ret = PTR_ERR(int3472->clock.clk);
	goto out_free_init_name;
	}

	int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL,
	int3472->sensor_name);
	if (!int3472->clock.cl) {
	ret = -ENOMEM;
	goto err_unregister_clk;
	}

	kfree(init.name);
	return 0;

	err_unregister_clk:
	clk_unregister(int3472->clock.clk);
	out_free_init_name:
	kfree(init.name);

	return ret;
	}

	void skl_int3472_unregister_clock(struct int3472_discrete_device *int3472)
	{
	if (!int3472->clock.cl)
	return;

	clkdev_drop(int3472->clock.cl);
	clk_unregister(int3472->clock.clk);
	}

	/*
	* The INT3472 device is going to be the only supplier of a regulator for
	* the sensor device. But unlike the clk framework the regulator framework
	* does not allow matching by consumer-device-name only.
	*
	* Ideally all sensor drivers would use "avdd" as supply-id. But for drivers
	* where this cannot be changed because another supply-id is already used in
	* e.g. DeviceTree files an alias for the other supply-id can be added here.
	*
	* Do not forget to update GPIO_REGULATOR_SUPPLY_MAP_COUNT when changing this.
	*/
	static const char * const skl_int3472_regulator_map_supplies[] = {
	"avdd",
	"AVDD",
	};

	static_assert(ARRAY_SIZE(skl_int3472_regulator_map_supplies) ==
	GPIO_REGULATOR_SUPPLY_MAP_COUNT);

	/*
	* On some models there is a single GPIO regulator which is shared between
	* sensors and only listed in the ACPI resources of one sensor.
	* This DMI table contains the name of the second sensor. This is used to add
	* entries for the second sensor to the supply_map.
	*/
	static const struct dmi_system_id skl_int3472_regulator_second_sensor[] = {
	{
	/* Lenovo Miix 510-12IKB */
	.matches = {
	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	DMI_MATCH(DMI_PRODUCT_VERSION, "MIIX 510-12IKB"),
	},
	.driver_data = "i2c-OVTI2680:00",
	},
	{ }
	};

	int skl_int3472_register_regulator(struct int3472_discrete_device *int3472,
	struct gpio_desc *gpio)
	{
	struct regulator_init_data init_data = { };
	struct regulator_config cfg = { };
	const char *second_sensor = NULL;
	const struct dmi_system_id *id;
	int i, j;

	id = dmi_first_match(skl_int3472_regulator_second_sensor);
	if (id)
	second_sensor = id->driver_data;

	for (i = 0, j = 0; i < ARRAY_SIZE(skl_int3472_regulator_map_supplies); i++) {
	int3472->regulator.supply_map[j].supply = skl_int3472_regulator_map_supplies[i];
	int3472->regulator.supply_map[j].dev_name = int3472->sensor_name;
	j++;

	if (second_sensor) {
	int3472->regulator.supply_map[j].supply =
	skl_int3472_regulator_map_supplies[i];
	int3472->regulator.supply_map[j].dev_name = second_sensor;
	j++;
	}
	}

	init_data.constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS;
	init_data.consumer_supplies = int3472->regulator.supply_map;
	init_data.num_consumer_supplies = j;

	snprintf(int3472->regulator.regulator_name,
	sizeof(int3472->regulator.regulator_name), "%s-regulator",
	acpi_dev_name(int3472->adev));
	snprintf(int3472->regulator.supply_name,
	GPIO_REGULATOR_SUPPLY_NAME_LENGTH, "supply-0");

	int3472->regulator.rdesc = INT3472_REGULATOR(
	int3472->regulator.regulator_name,
	int3472->regulator.supply_name,
	&int3472_gpio_regulator_ops);

	int3472->regulator.gpio = gpio;

	cfg.dev = &int3472->adev->dev;
	cfg.init_data = &init_data;
	cfg.ena_gpiod = int3472->regulator.gpio;

	int3472->regulator.rdev = regulator_register(int3472->dev,
	&int3472->regulator.rdesc,
	&cfg);

	return PTR_ERR_OR_ZERO(int3472->regulator.rdev);
	}

	void skl_int3472_unregister_regulator(struct int3472_discrete_device *int3472)
	{
	regulator_unregister(int3472->regulator.rdev);
	}