drivers/platform/x86/intel/int3472/discrete.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Author: Dan Scally <[email protected]> */
   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/gpio/consumer.h>
   9 #include <linux/gpio/machine.h>
  10 #include <linux/i2c.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/overflow.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/uuid.h>
  16
  17 #include "common.h"
  18
  19 /*
  20  * 79234640-9e10-4fea-a5c1-b5aa8b19756f
  21  * This _DSM GUID returns information about the GPIO lines mapped to a
  22  * discrete INT3472 device. Function number 1 returns a count of the GPIO
  23  * lines that are mapped. Subsequent functions return 32 bit ints encoding
  24  * information about the GPIO line, including its purpose.
  25  */
  26 static const guid_t int3472_gpio_guid =
  27         GUID_INIT(0x79234640, 0x9e10, 0x4fea,
  28                   0xa5, 0xc1, 0xb5, 0xaa, 0x8b, 0x19, 0x75, 0x6f);
  29
  30 /*
  31  * 822ace8f-2814-4174-a56b-5f029fe079ee
  32  * This _DSM GUID returns a string from the sensor device, which acts as a
  33  * module identifier.
  34  */
  35 static const guid_t cio2_sensor_module_guid =
  36         GUID_INIT(0x822ace8f, 0x2814, 0x4174,
  37                   0xa5, 0x6b, 0x5f, 0x02, 0x9f, 0xe0, 0x79, 0xee);
  38
  39 /*
  40  * Here follows platform specific mapping information that we can pass to
  41  * the functions mapping resources to the sensors. Where the sensors have
  42  * a power enable pin defined in DSDT we need to provide a supply name so
  43  * the sensor drivers can find the regulator. The device name will be derived
  44  * from the sensor's ACPI device within the code. Optionally, we can provide a
  45  * NULL terminated array of function name mappings to deal with any platform
  46  * specific deviations from the documented behaviour of GPIOs.
  47  *
  48  * Map a GPIO function name to NULL to prevent the driver from mapping that
  49  * GPIO at all.
  50  */
  51
  52 static const struct int3472_gpio_function_remap ov2680_gpio_function_remaps[] = {
  53         { "reset", NULL },
  54         { "powerdown", "reset" },
  55         { }
  56 };
  57
  58 static const struct int3472_sensor_config int3472_sensor_configs[] = {
  59         /* Lenovo Miix 510-12ISK - OV2680, Front */
  60         { "GNDF140809R", { 0 }, ov2680_gpio_function_remaps },
  61         /* Lenovo Miix 510-12ISK - OV5648, Rear */
  62         { "GEFF150023R", REGULATOR_SUPPLY("avdd", NULL), NULL },
  63         /* Surface Go 1&2 - OV5693, Front */
  64         { "YHCU", REGULATOR_SUPPLY("avdd", NULL), NULL },
  65 };
  66
  67 static const struct int3472_sensor_config *
  68 skl_int3472_get_sensor_module_config(struct int3472_discrete_device *int3472)
  69 {
  70         union acpi_object *obj;
  71         unsigned int i;
  72
  73         obj = acpi_evaluate_dsm_typed(int3472->sensor->handle,
  74                                       &cio2_sensor_module_guid, 0x00,
  75                                       0x01, NULL, ACPI_TYPE_STRING);
  76
  77         if (!obj) {
  78                 dev_err(int3472->dev,
  79                         "Failed to get sensor module string from _DSM\n");
  80                 return ERR_PTR(-ENODEV);
  81         }
  82
  83         if (obj->string.type != ACPI_TYPE_STRING) {
  84                 dev_err(int3472->dev,
  85                         "Sensor _DSM returned a non-string value\n");
  86
  87                 ACPI_FREE(obj);
  88                 return ERR_PTR(-EINVAL);
  89         }
  90
  91         for (i = 0; i < ARRAY_SIZE(int3472_sensor_configs); i++) {
  92                 if (!strcmp(int3472_sensor_configs[i].sensor_module_name,
  93                             obj->string.pointer))
  94                         break;
  95         }
  96
  97         ACPI_FREE(obj);
  98
  99         if (i >= ARRAY_SIZE(int3472_sensor_configs))
 100                 return ERR_PTR(-EINVAL);
 101
 102         return &int3472_sensor_configs[i];
 103 }
 104
 105 static int skl_int3472_map_gpio_to_sensor(struct int3472_discrete_device *int3472,
 106                                           struct acpi_resource_gpio *agpio,
 107                                           const char *func, u32 polarity)
 108 {
 109         const struct int3472_sensor_config *sensor_config;
 110         char *path = agpio->resource_source.string_ptr;
 111         struct gpiod_lookup *table_entry;
 112         struct acpi_device *adev;
 113         acpi_handle handle;
 114         acpi_status status;
 115
 116         if (int3472->n_sensor_gpios >= INT3472_MAX_SENSOR_GPIOS) {
 117                 dev_warn(int3472->dev, "Too many GPIOs mapped\n");
 118                 return -EINVAL;
 119         }
 120
 121         sensor_config = int3472->sensor_config;
 122         if (!IS_ERR(sensor_config) && sensor_config->function_maps) {
 123                 const struct int3472_gpio_function_remap *remap;
 124
 125                 for (remap = sensor_config->function_maps; remap->documented; remap++) {
 126                         if (!strcmp(func, remap->documented)) {
 127                                 func = remap->actual;
 128                                 break;
 129                         }
 130                 }
 131         }
 132
 133         /* Functions mapped to NULL should not be mapped to the sensor */
 134         if (!func)
 135                 return 0;
 136
 137         status = acpi_get_handle(NULL, path, &handle);
 138         if (ACPI_FAILURE(status))
 139                 return -EINVAL;
 140
 141         adev = acpi_fetch_acpi_dev(handle);
 142         if (!adev)
 143                 return -ENODEV;
 144
 145         table_entry = &int3472->gpios.table[int3472->n_sensor_gpios];
 146         table_entry->key = acpi_dev_name(adev);
 147         table_entry->chip_hwnum = agpio->pin_table[0];
 148         table_entry->con_id = func;
 149         table_entry->idx = 0;
 150         table_entry->flags = polarity;
 151
 152         int3472->n_sensor_gpios++;
 153
 154         return 0;
 155 }
 156
 157 static int skl_int3472_map_gpio_to_clk(struct int3472_discrete_device *int3472,
 158                                        struct acpi_resource_gpio *agpio, u8 type)
 159 {
 160         char *path = agpio->resource_source.string_ptr;
 161         u16 pin = agpio->pin_table[0];
 162         struct gpio_desc *gpio;
 163
 164         switch (type) {
 165         case INT3472_GPIO_TYPE_CLK_ENABLE:
 166                 gpio = acpi_get_and_request_gpiod(path, pin, "int3472,clk-enable");
 167                 if (IS_ERR(gpio))
 168                         return (PTR_ERR(gpio));
 169
 170                 int3472->clock.ena_gpio = gpio;
 171                 break;
 172         case INT3472_GPIO_TYPE_PRIVACY_LED:
 173                 gpio = acpi_get_and_request_gpiod(path, pin, "int3472,privacy-led");
 174                 if (IS_ERR(gpio))
 175                         return (PTR_ERR(gpio));
 176
 177                 int3472->clock.led_gpio = gpio;
 178                 break;
 179         default:
 180                 dev_err(int3472->dev, "Invalid GPIO type 0x%02x for clock\n", type);
 181                 break;
 182         }
 183
 184         return 0;
 185 }
 186
 187 /**
 188  * skl_int3472_handle_gpio_resources: Map PMIC resources to consuming sensor
 189  * @ares: A pointer to a &struct acpi_resource
 190  * @data: A pointer to a &struct int3472_discrete_device
 191  *
 192  * This function handles GPIO resources that are against an INT3472
 193  * ACPI device, by checking the value of the corresponding _DSM entry.
 194  * This will return a 32bit int, where the lowest byte represents the
 195  * function of the GPIO pin:
 196  *
 197  * 0x00 Reset
 198  * 0x01 Power down
 199  * 0x0b Power enable
 200  * 0x0c Clock enable
 201  * 0x0d Privacy LED
 202  *
 203  * There are some known platform specific quirks where that does not quite
 204  * hold up; for example where a pin with type 0x01 (Power down) is mapped to
 205  * a sensor pin that performs a reset function or entries in _CRS and _DSM that
 206  * do not actually correspond to a physical connection. These will be handled
 207  * by the mapping sub-functions.
 208  *
 209  * GPIOs will either be mapped directly to the sensor device or else used
 210  * to create clocks and regulators via the usual frameworks.
 211  *
 212  * Return:
 213  * * 1          - To continue the loop
 214  * * 0          - When all resources found are handled properly.
 215  * * -EINVAL    - If the resource is not a GPIO IO resource
 216  * * -ENODEV    - If the resource has no corresponding _DSM entry
 217  * * -Other     - Errors propagated from one of the sub-functions.
 218  */
 219 static int skl_int3472_handle_gpio_resources(struct acpi_resource *ares,
 220                                              void *data)
 221 {
 222         struct int3472_discrete_device *int3472 = data;
 223         struct acpi_resource_gpio *agpio;
 224         union acpi_object *obj;
 225         const char *err_msg;
 226         int ret;
 227         u8 type;
 228
 229         if (!acpi_gpio_get_io_resource(ares, &agpio))
 230                 return 1;
 231
 232         /*
 233          * ngpios + 2 because the index of this _DSM function is 1-based and
 234          * the first function is just a count.
 235          */
 236         obj = acpi_evaluate_dsm_typed(int3472->adev->handle,
 237                                       &int3472_gpio_guid, 0x00,
 238                                       int3472->ngpios + 2,
 239                                       NULL, ACPI_TYPE_INTEGER);
 240
 241         if (!obj) {
 242                 dev_warn(int3472->dev, "No _DSM entry for GPIO pin %u\n",
 243                          agpio->pin_table[0]);
 244                 return 1;
 245         }
 246
 247         type = obj->integer.value & 0xff;
 248
 249         switch (type) {
 250         case INT3472_GPIO_TYPE_RESET:
 251                 ret = skl_int3472_map_gpio_to_sensor(int3472, agpio, "reset",
 252                                                      GPIO_ACTIVE_LOW);
 253                 if (ret)
 254                         err_msg = "Failed to map reset pin to sensor\n";
 255
 256                 break;
 257         case INT3472_GPIO_TYPE_POWERDOWN:
 258                 ret = skl_int3472_map_gpio_to_sensor(int3472, agpio, "powerdown",
 259                                                      GPIO_ACTIVE_LOW);
 260                 if (ret)
 261                         err_msg = "Failed to map powerdown pin to sensor\n";
 262
 263                 break;
 264         case INT3472_GPIO_TYPE_CLK_ENABLE:
 265         case INT3472_GPIO_TYPE_PRIVACY_LED:
 266                 ret = skl_int3472_map_gpio_to_clk(int3472, agpio, type);
 267                 if (ret)
 268                         err_msg = "Failed to map GPIO to clock\n";
 269
 270                 break;
 271         case INT3472_GPIO_TYPE_POWER_ENABLE:
 272                 ret = skl_int3472_register_regulator(int3472, agpio);
 273                 if (ret)
 274                         err_msg = "Failed to map regulator to sensor\n";
 275
 276                 break;
 277         default:
 278                 dev_warn(int3472->dev,
 279                          "GPIO type 0x%02x unknown; the sensor may not work\n",
 280                          type);
 281                 ret = 1;
 282                 break;
 283         }
 284
 285         int3472->ngpios++;
 286         ACPI_FREE(obj);
 287
 288         if (ret < 0)
 289                 return dev_err_probe(int3472->dev, ret, err_msg);
 290
 291         return ret;
 292 }
 293
 294 static int skl_int3472_parse_crs(struct int3472_discrete_device *int3472)
 295 {
 296         LIST_HEAD(resource_list);
 297         int ret;
 298
 299         /*
 300          * No error check, because not having a sensor config is not necessarily
 301          * a failure mode.
 302          */
 303         int3472->sensor_config = skl_int3472_get_sensor_module_config(int3472);
 304
 305         ret = acpi_dev_get_resources(int3472->adev, &resource_list,
 306                                      skl_int3472_handle_gpio_resources,
 307                                      int3472);
 308         if (ret < 0)
 309                 return ret;
 310
 311         acpi_dev_free_resource_list(&resource_list);
 312
 313         /*
 314          * If we find no clock enable GPIO pin then the privacy LED won't work.
 315          * We've never seen that situation, but it's possible. Warn the user so
 316          * it's clear what's happened.
 317          */
 318         if (int3472->clock.ena_gpio) {
 319                 ret = skl_int3472_register_clock(int3472);
 320                 if (ret)
 321                         return ret;
 322         } else {
 323                 if (int3472->clock.led_gpio)
 324                         dev_warn(int3472->dev,
 325                                  "No clk GPIO. The privacy LED won't work\n");
 326         }
 327
 328         int3472->gpios.dev_id = int3472->sensor_name;
 329         gpiod_add_lookup_table(&int3472->gpios);
 330
 331         return 0;
 332 }
 333
 334 static int skl_int3472_discrete_remove(struct platform_device *pdev)
 335 {
 336         struct int3472_discrete_device *int3472 = platform_get_drvdata(pdev);
 337
 338         gpiod_remove_lookup_table(&int3472->gpios);
 339
 340         if (int3472->clock.cl)
 341                 skl_int3472_unregister_clock(int3472);
 342
 343         gpiod_put(int3472->clock.ena_gpio);
 344         gpiod_put(int3472->clock.led_gpio);
 345
 346         skl_int3472_unregister_regulator(int3472);
 347
 348         return 0;
 349 }
 350
 351 static int skl_int3472_discrete_probe(struct platform_device *pdev)
 352 {
 353         struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
 354         struct int3472_discrete_device *int3472;
 355         struct int3472_cldb cldb;
 356         int ret;
 357
 358         ret = skl_int3472_fill_cldb(adev, &cldb);
 359         if (ret) {
 360                 dev_err(&pdev->dev, "Couldn't fill CLDB structure\n");
 361                 return ret;
 362         }
 363
 364         if (cldb.control_logic_type != 1) {
 365                 dev_err(&pdev->dev, "Unsupported control logic type %u\n",
 366                         cldb.control_logic_type);
 367                 return -EINVAL;
 368         }
 369
 370         /* Max num GPIOs we've seen plus a terminator */
 371         int3472 = devm_kzalloc(&pdev->dev, struct_size(int3472, gpios.table,
 372                                INT3472_MAX_SENSOR_GPIOS + 1), GFP_KERNEL);
 373         if (!int3472)
 374                 return -ENOMEM;
 375
 376         int3472->adev = adev;
 377         int3472->dev = &pdev->dev;
 378         platform_set_drvdata(pdev, int3472);
 379
 380         ret = skl_int3472_get_sensor_adev_and_name(&pdev->dev, &int3472->sensor,
 381                                                    &int3472->sensor_name);
 382         if (ret)
 383                 return ret;
 384
 385         /*
 386          * Initialising this list means we can call gpiod_remove_lookup_table()
 387          * in failure paths without issue.
 388          */
 389         INIT_LIST_HEAD(&int3472->gpios.list);
 390
 391         ret = skl_int3472_parse_crs(int3472);
 392         if (ret) {
 393                 skl_int3472_discrete_remove(pdev);
 394                 return ret;
 395         }
 396
 397         acpi_dev_clear_dependencies(adev);
 398         return 0;
 399 }
 400
 401 static const struct acpi_device_id int3472_device_id[] = {
 402         { "INT3472", 0 },
 403         { }
 404 };
 405 MODULE_DEVICE_TABLE(acpi, int3472_device_id);
 406
 407 static struct platform_driver int3472_discrete = {
 408         .driver = {
 409                 .name = "int3472-discrete",
 410                 .acpi_match_table = int3472_device_id,
 411         },
 412         .probe = skl_int3472_discrete_probe,
 413         .remove = skl_int3472_discrete_remove,
 414 };
 415 module_platform_driver(int3472_discrete);
 416
 417 MODULE_DESCRIPTION("Intel SkyLake INT3472 ACPI Discrete Device Driver");
 418 MODULE_AUTHOR("Daniel Scally <[email protected]>");
 419 MODULE_LICENSE("GPL v2");