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 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 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 63 static void skl_int3472_clk_unprepare(struct clk_hw *hw) 64 { 65 skl_int3472_enable_clk(to_int3472_clk(hw), 0); 66 } 67 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 79 static void skl_int3472_clk_disable(struct clk_hw *hw) 80 { 81 /* Likewise, nothing to do here... */ 82 } 83 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 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 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 164 int skl_int3472_register_gpio_clock(struct int3472_discrete_device *int3472, 165 struct acpi_resource_gpio *agpio, u32 polarity) 166 { 167 char *path = agpio->resource_source.string_ptr; 168 struct clk_init_data init = { 169 .ops = &skl_int3472_clock_ops, 170 .flags = CLK_GET_RATE_NOCACHE, 171 }; 172 int ret; 173 174 if (int3472->clock.cl) 175 return -EBUSY; 176 177 int3472->clock.ena_gpio = acpi_get_and_request_gpiod(path, agpio->pin_table[0], 178 "int3472,clk-enable"); 179 if (IS_ERR(int3472->clock.ena_gpio)) 180 return dev_err_probe(int3472->dev, PTR_ERR(int3472->clock.ena_gpio), 181 "getting clk-enable GPIO\n"); 182 183 if (polarity == GPIO_ACTIVE_LOW) 184 gpiod_toggle_active_low(int3472->clock.ena_gpio); 185 186 /* Ensure the pin is in output mode and non-active state */ 187 gpiod_direction_output(int3472->clock.ena_gpio, 0); 188 189 init.name = kasprintf(GFP_KERNEL, "%s-clk", 190 acpi_dev_name(int3472->adev)); 191 if (!init.name) { 192 ret = -ENOMEM; 193 goto out_put_gpio; 194 } 195 196 int3472->clock.frequency = skl_int3472_get_clk_frequency(int3472); 197 198 int3472->clock.clk_hw.init = &init; 199 int3472->clock.clk = clk_register(&int3472->adev->dev, 200 &int3472->clock.clk_hw); 201 if (IS_ERR(int3472->clock.clk)) { 202 ret = PTR_ERR(int3472->clock.clk); 203 goto out_free_init_name; 204 } 205 206 int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL, 207 int3472->sensor_name); 208 if (!int3472->clock.cl) { 209 ret = -ENOMEM; 210 goto err_unregister_clk; 211 } 212 213 kfree(init.name); 214 return 0; 215 216 err_unregister_clk: 217 clk_unregister(int3472->clock.clk); 218 out_free_init_name: 219 kfree(init.name); 220 out_put_gpio: 221 gpiod_put(int3472->clock.ena_gpio); 222 223 return ret; 224 } 225 226 void skl_int3472_unregister_clock(struct int3472_discrete_device *int3472) 227 { 228 if (!int3472->clock.cl) 229 return; 230 231 clkdev_drop(int3472->clock.cl); 232 clk_unregister(int3472->clock.clk); 233 gpiod_put(int3472->clock.ena_gpio); 234 } 235 236 /* 237 * The INT3472 device is going to be the only supplier of a regulator for 238 * the sensor device. But unlike the clk framework the regulator framework 239 * does not allow matching by consumer-device-name only. 240 * 241 * Ideally all sensor drivers would use "avdd" as supply-id. But for drivers 242 * where this cannot be changed because another supply-id is already used in 243 * e.g. DeviceTree files an alias for the other supply-id can be added here. 244 * 245 * Do not forget to update GPIO_REGULATOR_SUPPLY_MAP_COUNT when changing this. 246 */ 247 static const char * const skl_int3472_regulator_map_supplies[] = { 248 "avdd", 249 "AVDD", 250 }; 251 252 static_assert(ARRAY_SIZE(skl_int3472_regulator_map_supplies) == 253 GPIO_REGULATOR_SUPPLY_MAP_COUNT); 254 255 /* 256 * On some models there is a single GPIO regulator which is shared between 257 * sensors and only listed in the ACPI resources of one sensor. 258 * This DMI table contains the name of the second sensor. This is used to add 259 * entries for the second sensor to the supply_map. 260 */ 261 const struct dmi_system_id skl_int3472_regulator_second_sensor[] = { 262 { 263 /* Lenovo Miix 510-12IKB */ 264 .matches = { 265 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 266 DMI_MATCH(DMI_PRODUCT_VERSION, "MIIX 510-12IKB"), 267 }, 268 .driver_data = "i2c-OVTI2680:00", 269 }, 270 { } 271 }; 272 273 int skl_int3472_register_regulator(struct int3472_discrete_device *int3472, 274 struct acpi_resource_gpio *agpio) 275 { 276 char *path = agpio->resource_source.string_ptr; 277 struct regulator_init_data init_data = { }; 278 struct regulator_config cfg = { }; 279 const char *second_sensor = NULL; 280 const struct dmi_system_id *id; 281 int i, j, ret; 282 283 id = dmi_first_match(skl_int3472_regulator_second_sensor); 284 if (id) 285 second_sensor = id->driver_data; 286 287 for (i = 0, j = 0; i < ARRAY_SIZE(skl_int3472_regulator_map_supplies); i++) { 288 int3472->regulator.supply_map[j].supply = skl_int3472_regulator_map_supplies[i]; 289 int3472->regulator.supply_map[j].dev_name = int3472->sensor_name; 290 j++; 291 292 if (second_sensor) { 293 int3472->regulator.supply_map[j].supply = 294 skl_int3472_regulator_map_supplies[i]; 295 int3472->regulator.supply_map[j].dev_name = second_sensor; 296 j++; 297 } 298 } 299 300 init_data.constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS; 301 init_data.consumer_supplies = int3472->regulator.supply_map; 302 init_data.num_consumer_supplies = j; 303 304 snprintf(int3472->regulator.regulator_name, 305 sizeof(int3472->regulator.regulator_name), "%s-regulator", 306 acpi_dev_name(int3472->adev)); 307 snprintf(int3472->regulator.supply_name, 308 GPIO_REGULATOR_SUPPLY_NAME_LENGTH, "supply-0"); 309 310 int3472->regulator.rdesc = INT3472_REGULATOR( 311 int3472->regulator.regulator_name, 312 int3472->regulator.supply_name, 313 &int3472_gpio_regulator_ops); 314 315 int3472->regulator.gpio = acpi_get_and_request_gpiod(path, agpio->pin_table[0], 316 "int3472,regulator"); 317 if (IS_ERR(int3472->regulator.gpio)) { 318 dev_err(int3472->dev, "Failed to get regulator GPIO line\n"); 319 return PTR_ERR(int3472->regulator.gpio); 320 } 321 322 /* Ensure the pin is in output mode and non-active state */ 323 gpiod_direction_output(int3472->regulator.gpio, 0); 324 325 cfg.dev = &int3472->adev->dev; 326 cfg.init_data = &init_data; 327 cfg.ena_gpiod = int3472->regulator.gpio; 328 329 int3472->regulator.rdev = regulator_register(int3472->dev, 330 &int3472->regulator.rdesc, 331 &cfg); 332 if (IS_ERR(int3472->regulator.rdev)) { 333 ret = PTR_ERR(int3472->regulator.rdev); 334 goto err_free_gpio; 335 } 336 337 return 0; 338 339 err_free_gpio: 340 gpiod_put(int3472->regulator.gpio); 341 342 return ret; 343 } 344 345 void skl_int3472_unregister_regulator(struct int3472_discrete_device *int3472) 346 { 347 regulator_unregister(int3472->regulator.rdev); 348 gpiod_put(int3472->regulator.gpio); 349 } 350