xref: /linux/drivers/platform/x86/intel/int3472/clk_and_regulator.c (revision 0ea5c948cb64bab5bc7a5516774eb8536f05aa0d)
1 // SPDX-License-Identifier: GPL-2.0
2 /* Author: Dan Scally <djrscally@gmail.com> */
3 
4 #include <linux/acpi.h>
5 #include <linux/clkdev.h>
6 #include <linux/clk-provider.h>
7 #include <linux/device.h>
8 #include <linux/dmi.h>
9 #include <linux/gpio/consumer.h>
10 #include <linux/regulator/driver.h>
11 #include <linux/slab.h>
12 
13 #include "common.h"
14 
15 /*
16  * 82c0d13a-78c5-4244-9bb1-eb8b539a8d11
17  * This _DSM GUID allows controlling the sensor clk when it is not controlled
18  * through a GPIO.
19  */
20 static const guid_t img_clk_guid =
21 	GUID_INIT(0x82c0d13a, 0x78c5, 0x4244,
22 		  0x9b, 0xb1, 0xeb, 0x8b, 0x53, 0x9a, 0x8d, 0x11);
23 
skl_int3472_enable_clk(struct int3472_clock * clk,int enable)24 static void skl_int3472_enable_clk(struct int3472_clock *clk, int enable)
25 {
26 	struct int3472_discrete_device *int3472 = to_int3472_device(clk);
27 	union acpi_object args[3];
28 	union acpi_object argv4;
29 
30 	if (clk->ena_gpio) {
31 		gpiod_set_value_cansleep(clk->ena_gpio, enable);
32 		return;
33 	}
34 
35 	args[0].integer.type = ACPI_TYPE_INTEGER;
36 	args[0].integer.value = clk->imgclk_index;
37 	args[1].integer.type = ACPI_TYPE_INTEGER;
38 	args[1].integer.value = enable;
39 	args[2].integer.type = ACPI_TYPE_INTEGER;
40 	args[2].integer.value = 1;
41 
42 	argv4.type = ACPI_TYPE_PACKAGE;
43 	argv4.package.count = 3;
44 	argv4.package.elements = args;
45 
46 	acpi_evaluate_dsm(acpi_device_handle(int3472->adev), &img_clk_guid,
47 			  0, 1, &argv4);
48 }
49 
50 /*
51  * The regulators have to have .ops to be valid, but the only ops we actually
52  * support are .enable and .disable which are handled via .ena_gpiod. Pass an
53  * empty struct to clear the check without lying about capabilities.
54  */
55 static const struct regulator_ops int3472_gpio_regulator_ops;
56 
skl_int3472_clk_prepare(struct clk_hw * hw)57 static int skl_int3472_clk_prepare(struct clk_hw *hw)
58 {
59 	skl_int3472_enable_clk(to_int3472_clk(hw), 1);
60 	return 0;
61 }
62 
skl_int3472_clk_unprepare(struct clk_hw * hw)63 static void skl_int3472_clk_unprepare(struct clk_hw *hw)
64 {
65 	skl_int3472_enable_clk(to_int3472_clk(hw), 0);
66 }
67 
skl_int3472_clk_enable(struct clk_hw * hw)68 static int skl_int3472_clk_enable(struct clk_hw *hw)
69 {
70 	/*
71 	 * We're just turning a GPIO on to enable the clock, which operation
72 	 * has the potential to sleep. Given .enable() cannot sleep, but
73 	 * .prepare() can, we toggle the GPIO in .prepare() instead. Thus,
74 	 * nothing to do here.
75 	 */
76 	return 0;
77 }
78 
skl_int3472_clk_disable(struct clk_hw * hw)79 static void skl_int3472_clk_disable(struct clk_hw *hw)
80 {
81 	/* Likewise, nothing to do here... */
82 }
83 
skl_int3472_get_clk_frequency(struct int3472_discrete_device * int3472)84 static unsigned int skl_int3472_get_clk_frequency(struct int3472_discrete_device *int3472)
85 {
86 	union acpi_object *obj;
87 	unsigned int freq;
88 
89 	obj = skl_int3472_get_acpi_buffer(int3472->sensor, "SSDB");
90 	if (IS_ERR(obj))
91 		return 0; /* report rate as 0 on error */
92 
93 	if (obj->buffer.length < CIO2_SENSOR_SSDB_MCLKSPEED_OFFSET + sizeof(u32)) {
94 		dev_err(int3472->dev, "The buffer is too small\n");
95 		kfree(obj);
96 		return 0;
97 	}
98 
99 	freq = *(u32 *)(obj->buffer.pointer + CIO2_SENSOR_SSDB_MCLKSPEED_OFFSET);
100 
101 	kfree(obj);
102 	return freq;
103 }
104 
skl_int3472_clk_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)105 static unsigned long skl_int3472_clk_recalc_rate(struct clk_hw *hw,
106 						 unsigned long parent_rate)
107 {
108 	struct int3472_clock *clk = to_int3472_clk(hw);
109 
110 	return clk->frequency;
111 }
112 
113 static const struct clk_ops skl_int3472_clock_ops = {
114 	.prepare = skl_int3472_clk_prepare,
115 	.unprepare = skl_int3472_clk_unprepare,
116 	.enable = skl_int3472_clk_enable,
117 	.disable = skl_int3472_clk_disable,
118 	.recalc_rate = skl_int3472_clk_recalc_rate,
119 };
120 
skl_int3472_register_dsm_clock(struct int3472_discrete_device * int3472)121 int skl_int3472_register_dsm_clock(struct int3472_discrete_device *int3472)
122 {
123 	struct acpi_device *adev = int3472->adev;
124 	struct clk_init_data init = {
125 		.ops = &skl_int3472_clock_ops,
126 		.flags = CLK_GET_RATE_NOCACHE,
127 	};
128 	int ret;
129 
130 	if (int3472->clock.cl)
131 		return 0; /* A GPIO controlled clk has already been registered */
132 
133 	if (!acpi_check_dsm(adev->handle, &img_clk_guid, 0, BIT(1)))
134 		return 0; /* DSM clock control is not available */
135 
136 	init.name = kasprintf(GFP_KERNEL, "%s-clk", acpi_dev_name(adev));
137 	if (!init.name)
138 		return -ENOMEM;
139 
140 	int3472->clock.frequency = skl_int3472_get_clk_frequency(int3472);
141 	int3472->clock.clk_hw.init = &init;
142 	int3472->clock.clk = clk_register(&adev->dev, &int3472->clock.clk_hw);
143 	if (IS_ERR(int3472->clock.clk)) {
144 		ret = PTR_ERR(int3472->clock.clk);
145 		goto out_free_init_name;
146 	}
147 
148 	int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL, int3472->sensor_name);
149 	if (!int3472->clock.cl) {
150 		ret = -ENOMEM;
151 		goto err_unregister_clk;
152 	}
153 
154 	kfree(init.name);
155 	return 0;
156 
157 err_unregister_clk:
158 	clk_unregister(int3472->clock.clk);
159 out_free_init_name:
160 	kfree(init.name);
161 	return ret;
162 }
163 
skl_int3472_register_gpio_clock(struct int3472_discrete_device * int3472,struct gpio_desc * gpio)164 int skl_int3472_register_gpio_clock(struct int3472_discrete_device *int3472,
165 				    struct gpio_desc *gpio)
166 {
167 	struct clk_init_data init = {
168 		.ops = &skl_int3472_clock_ops,
169 		.flags = CLK_GET_RATE_NOCACHE,
170 	};
171 	int ret;
172 
173 	if (int3472->clock.cl)
174 		return -EBUSY;
175 
176 	int3472->clock.ena_gpio = gpio;
177 
178 	init.name = kasprintf(GFP_KERNEL, "%s-clk",
179 			      acpi_dev_name(int3472->adev));
180 	if (!init.name)
181 		return -ENOMEM;
182 
183 	int3472->clock.frequency = skl_int3472_get_clk_frequency(int3472);
184 
185 	int3472->clock.clk_hw.init = &init;
186 	int3472->clock.clk = clk_register(&int3472->adev->dev,
187 					  &int3472->clock.clk_hw);
188 	if (IS_ERR(int3472->clock.clk)) {
189 		ret = PTR_ERR(int3472->clock.clk);
190 		goto out_free_init_name;
191 	}
192 
193 	int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL,
194 					  int3472->sensor_name);
195 	if (!int3472->clock.cl) {
196 		ret = -ENOMEM;
197 		goto err_unregister_clk;
198 	}
199 
200 	kfree(init.name);
201 	return 0;
202 
203 err_unregister_clk:
204 	clk_unregister(int3472->clock.clk);
205 out_free_init_name:
206 	kfree(init.name);
207 
208 	return ret;
209 }
210 
skl_int3472_unregister_clock(struct int3472_discrete_device * int3472)211 void skl_int3472_unregister_clock(struct int3472_discrete_device *int3472)
212 {
213 	if (!int3472->clock.cl)
214 		return;
215 
216 	clkdev_drop(int3472->clock.cl);
217 	clk_unregister(int3472->clock.clk);
218 }
219 
220 /*
221  * The INT3472 device is going to be the only supplier of a regulator for
222  * the sensor device. But unlike the clk framework the regulator framework
223  * does not allow matching by consumer-device-name only.
224  *
225  * Ideally all sensor drivers would use "avdd" as supply-id. But for drivers
226  * where this cannot be changed because another supply-id is already used in
227  * e.g. DeviceTree files an alias for the other supply-id can be added here.
228  *
229  * Do not forget to update GPIO_REGULATOR_SUPPLY_MAP_COUNT when changing this.
230  */
231 static const char * const skl_int3472_regulator_map_supplies[] = {
232 	"avdd",
233 	"AVDD",
234 };
235 
236 static_assert(ARRAY_SIZE(skl_int3472_regulator_map_supplies) ==
237 	      GPIO_REGULATOR_SUPPLY_MAP_COUNT);
238 
239 /*
240  * On some models there is a single GPIO regulator which is shared between
241  * sensors and only listed in the ACPI resources of one sensor.
242  * This DMI table contains the name of the second sensor. This is used to add
243  * entries for the second sensor to the supply_map.
244  */
245 static const struct dmi_system_id skl_int3472_regulator_second_sensor[] = {
246 	{
247 		/* Lenovo Miix 510-12IKB */
248 		.matches = {
249 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
250 			DMI_MATCH(DMI_PRODUCT_VERSION, "MIIX 510-12IKB"),
251 		},
252 		.driver_data = "i2c-OVTI2680:00",
253 	},
254 	{ }
255 };
256 
skl_int3472_register_regulator(struct int3472_discrete_device * int3472,struct gpio_desc * gpio)257 int skl_int3472_register_regulator(struct int3472_discrete_device *int3472,
258 				   struct gpio_desc *gpio)
259 {
260 	struct regulator_init_data init_data = { };
261 	struct regulator_config cfg = { };
262 	const char *second_sensor = NULL;
263 	const struct dmi_system_id *id;
264 	int i, j;
265 
266 	id = dmi_first_match(skl_int3472_regulator_second_sensor);
267 	if (id)
268 		second_sensor = id->driver_data;
269 
270 	for (i = 0, j = 0; i < ARRAY_SIZE(skl_int3472_regulator_map_supplies); i++) {
271 		int3472->regulator.supply_map[j].supply = skl_int3472_regulator_map_supplies[i];
272 		int3472->regulator.supply_map[j].dev_name = int3472->sensor_name;
273 		j++;
274 
275 		if (second_sensor) {
276 			int3472->regulator.supply_map[j].supply =
277 				skl_int3472_regulator_map_supplies[i];
278 			int3472->regulator.supply_map[j].dev_name = second_sensor;
279 			j++;
280 		}
281 	}
282 
283 	init_data.constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS;
284 	init_data.consumer_supplies = int3472->regulator.supply_map;
285 	init_data.num_consumer_supplies = j;
286 
287 	snprintf(int3472->regulator.regulator_name,
288 		 sizeof(int3472->regulator.regulator_name), "%s-regulator",
289 		 acpi_dev_name(int3472->adev));
290 	snprintf(int3472->regulator.supply_name,
291 		 GPIO_REGULATOR_SUPPLY_NAME_LENGTH, "supply-0");
292 
293 	int3472->regulator.rdesc = INT3472_REGULATOR(
294 						int3472->regulator.regulator_name,
295 						int3472->regulator.supply_name,
296 						&int3472_gpio_regulator_ops);
297 
298 	int3472->regulator.gpio = gpio;
299 
300 	cfg.dev = &int3472->adev->dev;
301 	cfg.init_data = &init_data;
302 	cfg.ena_gpiod = int3472->regulator.gpio;
303 
304 	int3472->regulator.rdev = regulator_register(int3472->dev,
305 						     &int3472->regulator.rdesc,
306 						     &cfg);
307 
308 	return PTR_ERR_OR_ZERO(int3472->regulator.rdev);
309 }
310 
skl_int3472_unregister_regulator(struct int3472_discrete_device * int3472)311 void skl_int3472_unregister_regulator(struct int3472_discrete_device *int3472)
312 {
313 	regulator_unregister(int3472->regulator.rdev);
314 }
315