Hi Hans On 16/06/2021 18:58, Hans de Goede wrote: > Hi, > > On 6/4/21 12:40 AM, Daniel Scally wrote: >> ACPI devices with _HID INT3472 are currently matched to the tps68470 >> driver, however this does not cover all situations in which that _HID >> occurs. We've encountered three possibilities: >> >> 1. On Chrome OS devices, an ACPI device with _HID INT3472 (representing >> a physical TPS68470 device) that requires a GPIO and OpRegion driver >> 2. On devices designed for Windows, an ACPI device with _HID INT3472 >> (again representing a physical TPS68470 device) which requires GPIO, >> Clock and Regulator drivers. >> 3. On other devices designed for Windows, an ACPI device with _HID >> INT3472 which does **not** represent a physical TPS68470, and is instead >> used as a dummy device to group some system GPIO lines which are meant >> to be consumed by the sensor that is dependent on this entry. >> >> This commit adds a new module, registering a platform driver to deal >> with the 3rd scenario plus an i2c driver to deal with #1 and #2, by >> querying the CLDB buffer found against INT3472 entries to determine >> which is most appropriate. >> >> Suggested-by: Laurent Pinchart <laurent.pinchart@xxxxxxxxxxxxxxxx> >> Signed-off-by: Daniel Scally <djrscally@xxxxxxxxx> > Thank you for your patch, I've applied this patch to my review-hans > branch: > https://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git/log/?h=review-hans > > I've fixed up the missing static marking of skl_int3472_tps68470_calc_type() > spotted by lkp@xxxxxxxxx while applying the patch to my tree. Fantastic, thanks very much. > > Once I've run some tests on this branch the patches there will be > added to the platform-drivers-x86/for-next branch and eventually > will be included in the pdx86 pull-request to Linus for the next > merge-window. Excellent :) > > Regards, > > Hans > > > > >> --- >> Changes since v4: >> - Some formatting and commenting tidy up >> - Cleared up some function exit paths to avoid gotos >> - Refactored skl_int3472_get_sensor_module_config() and also >> skl_int3472_tps68470_probe(), which involved adding a new function. >> >> Andy - I didn't look at the reg-fixed-voltage suggestion yet, but I think I >> covered the rest of your suggestions from v4. >> >> MAINTAINERS | 5 + >> drivers/platform/x86/Kconfig | 2 + >> drivers/platform/x86/Makefile | 1 + >> drivers/platform/x86/intel-int3472/Kconfig | 30 ++ >> drivers/platform/x86/intel-int3472/Makefile | 5 + >> .../intel_skl_int3472_clk_and_regulator.c | 196 ++++++++ >> .../intel-int3472/intel_skl_int3472_common.c | 106 +++++ >> .../intel-int3472/intel_skl_int3472_common.h | 118 +++++ >> .../intel_skl_int3472_discrete.c | 417 ++++++++++++++++++ >> .../intel_skl_int3472_tps68470.c | 137 ++++++ >> 10 files changed, 1017 insertions(+) >> create mode 100644 drivers/platform/x86/intel-int3472/Kconfig >> create mode 100644 drivers/platform/x86/intel-int3472/Makefile >> create mode 100644 drivers/platform/x86/intel-int3472/intel_skl_int3472_clk_and_regulator.c >> create mode 100644 drivers/platform/x86/intel-int3472/intel_skl_int3472_common.c >> create mode 100644 drivers/platform/x86/intel-int3472/intel_skl_int3472_common.h >> create mode 100644 drivers/platform/x86/intel-int3472/intel_skl_int3472_discrete.c >> create mode 100644 drivers/platform/x86/intel-int3472/intel_skl_int3472_tps68470.c >> >> diff --git a/MAINTAINERS b/MAINTAINERS >> index 008fcad7ac00..8dcc7e005ace 100644 >> --- a/MAINTAINERS >> +++ b/MAINTAINERS >> @@ -9378,6 +9378,11 @@ S: Maintained >> F: arch/x86/include/asm/intel_scu_ipc.h >> F: drivers/platform/x86/intel_scu_* >> >> +INTEL SKYLAKE INT3472 ACPI DEVICE DRIVER >> +M: Daniel Scally <djrscally@xxxxxxxxx> >> +S: Maintained >> +F: drivers/platform/x86/intel-int3472/ >> + >> INTEL SPEED SELECT TECHNOLOGY >> M: Srinivas Pandruvada <srinivas.pandruvada@xxxxxxxxxxxxxxx> >> L: platform-driver-x86@xxxxxxxxxxxxxxx >> diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig >> index 2714f7c3843e..1263b8efcd50 100644 >> --- a/drivers/platform/x86/Kconfig >> +++ b/drivers/platform/x86/Kconfig >> @@ -697,6 +697,8 @@ config INTEL_CHT_INT33FE >> device and CONFIG_TYPEC_FUSB302=m and CONFIG_BATTERY_MAX17042=m >> for Type-C device. >> >> +source "drivers/platform/x86/intel-int3472/Kconfig" >> + >> config INTEL_HID_EVENT >> tristate "INTEL HID Event" >> depends on ACPI >> diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile >> index dcc8cdb95b4d..c0612c02d037 100644 >> --- a/drivers/platform/x86/Makefile >> +++ b/drivers/platform/x86/Makefile >> @@ -76,6 +76,7 @@ obj-$(CONFIG_INTEL_HID_EVENT) += intel-hid.o >> obj-$(CONFIG_INTEL_INT0002_VGPIO) += intel_int0002_vgpio.o >> obj-$(CONFIG_INTEL_MENLOW) += intel_menlow.o >> obj-$(CONFIG_INTEL_OAKTRAIL) += intel_oaktrail.o >> +obj-$(CONFIG_INTEL_SKL_INT3472) += intel-int3472/ >> obj-$(CONFIG_INTEL_VBTN) += intel-vbtn.o >> >> # MSI >> diff --git a/drivers/platform/x86/intel-int3472/Kconfig b/drivers/platform/x86/intel-int3472/Kconfig >> new file mode 100644 >> index 000000000000..c112878e833b >> --- /dev/null >> +++ b/drivers/platform/x86/intel-int3472/Kconfig >> @@ -0,0 +1,30 @@ >> +config INTEL_SKL_INT3472 >> + tristate "Intel SkyLake ACPI INT3472 Driver" >> + depends on ACPI >> + depends on COMMON_CLK && CLKDEV_LOOKUP >> + depends on I2C >> + depends on GPIOLIB >> + depends on REGULATOR >> + select MFD_CORE >> + select REGMAP_I2C >> + help >> + This driver adds power controller support for the Intel SkyCam >> + devices found on the Intel SkyLake platforms. >> + >> + The INT3472 is a camera power controller, a logical device found on >> + Intel Skylake-based systems that can map to different hardware >> + devices depending on the platform. On machines designed for Chrome OS >> + it maps to a TPS68470 camera PMIC. On machines designed for Windows, >> + it maps to either a TP68470 camera PMIC, a uP6641Q sensor PMIC, or a >> + set of discrete GPIOs and power gates. >> + >> + If your device was designed for Chrome OS, this driver will provide >> + an ACPI OpRegion, which must be available before any of the devices >> + using it are probed. For this reason, you should select Y if your >> + device was designed for ChromeOS. For the same reason the >> + I2C_DESIGNWARE_PLATFORM option must be set to Y too. >> + >> + Say Y or M here if you have a SkyLake device designed for use >> + with Windows or ChromeOS. Say N here if you are not sure. >> + >> + The module will be named "intel-skl-int3472". >> diff --git a/drivers/platform/x86/intel-int3472/Makefile b/drivers/platform/x86/intel-int3472/Makefile >> new file mode 100644 >> index 000000000000..48bd97f0a04e >> --- /dev/null >> +++ b/drivers/platform/x86/intel-int3472/Makefile >> @@ -0,0 +1,5 @@ >> +obj-$(CONFIG_INTEL_SKL_INT3472) += intel_skl_int3472.o >> +intel_skl_int3472-objs := intel_skl_int3472_common.o \ >> + intel_skl_int3472_discrete.o \ >> + intel_skl_int3472_tps68470.o \ >> + intel_skl_int3472_clk_and_regulator.o >> diff --git a/drivers/platform/x86/intel-int3472/intel_skl_int3472_clk_and_regulator.c b/drivers/platform/x86/intel-int3472/intel_skl_int3472_clk_and_regulator.c >> new file mode 100644 >> index 000000000000..ceee860e2c07 >> --- /dev/null >> +++ b/drivers/platform/x86/intel-int3472/intel_skl_int3472_clk_and_regulator.c >> @@ -0,0 +1,196 @@ >> +// SPDX-License-Identifier: GPL-2.0 >> +/* Author: Dan Scally <djrscally@xxxxxxxxx> */ >> + >> +#include <linux/acpi.h> >> +#include <linux/clkdev.h> >> +#include <linux/clk-provider.h> >> +#include <linux/device.h> >> +#include <linux/gpio/consumer.h> >> +#include <linux/regulator/driver.h> >> +#include <linux/slab.h> >> + >> +#include "intel_skl_int3472_common.h" >> + >> +/* >> + * 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) >> +{ >> + struct int3472_gpio_clock *clk = to_int3472_clk(hw); >> + >> + gpiod_set_value_cansleep(clk->ena_gpio, 1); >> + gpiod_set_value_cansleep(clk->led_gpio, 1); >> + >> + return 0; >> +} >> + >> +static void skl_int3472_clk_unprepare(struct clk_hw *hw) >> +{ >> + struct int3472_gpio_clock *clk = to_int3472_clk(hw); >> + >> + gpiod_set_value_cansleep(clk->ena_gpio, 0); >> + gpiod_set_value_cansleep(clk->led_gpio, 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_gpio_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_clock(struct int3472_discrete_device *int3472) >> +{ >> + struct clk_init_data init = { >> + .ops = &skl_int3472_clock_ops, >> + .flags = CLK_GET_RATE_NOCACHE, >> + }; >> + int ret; >> + >> + 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; >> +} >> + >> +int skl_int3472_register_regulator(struct int3472_discrete_device *int3472, >> + struct acpi_resource *ares) >> +{ >> + char *path = ares->data.gpio.resource_source.string_ptr; >> + const struct int3472_sensor_config *sensor_config; >> + struct regulator_consumer_supply supply_map; >> + struct regulator_init_data init_data = { }; >> + struct regulator_config cfg = { }; >> + int ret; >> + >> + sensor_config = int3472->sensor_config; >> + if (IS_ERR(sensor_config)) { >> + dev_err(int3472->dev, "No sensor module config\n"); >> + return PTR_ERR(sensor_config); >> + } >> + >> + if (!sensor_config->supply_map.supply) { >> + dev_err(int3472->dev, "No supply name defined\n"); >> + return -ENODEV; >> + } >> + >> + init_data.constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS; >> + init_data.num_consumer_supplies = 1; >> + supply_map = sensor_config->supply_map; >> + supply_map.dev_name = int3472->sensor_name; >> + init_data.consumer_supplies = &supply_map; >> + >> + 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 = acpi_get_and_request_gpiod(path, >> + ares->data.gpio.pin_table[0], >> + "int3472,regulator"); >> + if (IS_ERR(int3472->regulator.gpio)) { >> + dev_err(int3472->dev, "Failed to get regulator GPIO line\n"); >> + return PTR_ERR(int3472->regulator.gpio); >> + } >> + >> + cfg.dev = &int3472->adev->dev; >> + cfg.init_data = &init_data; >> + cfg.ena_gpiod = int3472->regulator.gpio; >> + >> + int3472->regulator.rdev = regulator_register(&int3472->regulator.rdesc, >> + &cfg); >> + if (IS_ERR(int3472->regulator.rdev)) { >> + ret = PTR_ERR(int3472->regulator.rdev); >> + goto err_free_gpio; >> + } >> + >> + return 0; >> + >> +err_free_gpio: >> + gpiod_put(int3472->regulator.gpio); >> + >> + return ret; >> +} >> diff --git a/drivers/platform/x86/intel-int3472/intel_skl_int3472_common.c b/drivers/platform/x86/intel-int3472/intel_skl_int3472_common.c >> new file mode 100644 >> index 000000000000..497e74fba75f >> --- /dev/null >> +++ b/drivers/platform/x86/intel-int3472/intel_skl_int3472_common.c >> @@ -0,0 +1,106 @@ >> +// SPDX-License-Identifier: GPL-2.0 >> +/* Author: Dan Scally <djrscally@xxxxxxxxx> */ >> + >> +#include <linux/acpi.h> >> +#include <linux/i2c.h> >> +#include <linux/platform_device.h> >> +#include <linux/slab.h> >> + >> +#include "intel_skl_int3472_common.h" >> + >> +union acpi_object *skl_int3472_get_acpi_buffer(struct acpi_device *adev, char *id) >> +{ >> + struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; >> + acpi_handle handle = adev->handle; >> + union acpi_object *obj; >> + acpi_status status; >> + >> + status = acpi_evaluate_object(handle, id, NULL, &buffer); >> + if (ACPI_FAILURE(status)) >> + return ERR_PTR(-ENODEV); >> + >> + obj = buffer.pointer; >> + if (!obj) >> + return ERR_PTR(-ENODEV); >> + >> + if (obj->type != ACPI_TYPE_BUFFER) { >> + acpi_handle_err(handle, "%s object is not an ACPI buffer\n", id); >> + kfree(obj); >> + return ERR_PTR(-EINVAL); >> + } >> + >> + return obj; >> +} >> + >> +int skl_int3472_fill_cldb(struct acpi_device *adev, struct int3472_cldb *cldb) >> +{ >> + union acpi_object *obj; >> + int ret; >> + >> + obj = skl_int3472_get_acpi_buffer(adev, "CLDB"); >> + if (IS_ERR(obj)) >> + return PTR_ERR(obj); >> + >> + if (obj->buffer.length > sizeof(*cldb)) { >> + acpi_handle_err(adev->handle, "The CLDB buffer is too large\n"); >> + ret = -EINVAL; >> + goto out_free_obj; >> + } >> + >> + memcpy(cldb, obj->buffer.pointer, obj->buffer.length); >> + ret = 0; >> + >> +out_free_obj: >> + kfree(obj); >> + return ret; >> +} >> + >> +static const struct acpi_device_id int3472_device_id[] = { >> + { "INT3472", 0 }, >> + { } >> +}; >> +MODULE_DEVICE_TABLE(acpi, int3472_device_id); >> + >> +static struct platform_driver int3472_discrete = { >> + .driver = { >> + .name = "int3472-discrete", >> + .acpi_match_table = int3472_device_id, >> + }, >> + .probe = skl_int3472_discrete_probe, >> + .remove = skl_int3472_discrete_remove, >> +}; >> + >> +static struct i2c_driver int3472_tps68470 = { >> + .driver = { >> + .name = "int3472-tps68470", >> + .acpi_match_table = int3472_device_id, >> + }, >> + .probe_new = skl_int3472_tps68470_probe, >> +}; >> + >> +static int skl_int3472_init(void) >> +{ >> + int ret; >> + >> + ret = platform_driver_register(&int3472_discrete); >> + if (ret) >> + return ret; >> + >> + ret = i2c_register_driver(THIS_MODULE, &int3472_tps68470); >> + if (ret) >> + platform_driver_unregister(&int3472_discrete); >> + >> + return ret; >> +} >> +module_init(skl_int3472_init); >> + >> +static void skl_int3472_exit(void) >> +{ >> + platform_driver_unregister(&int3472_discrete); >> + i2c_del_driver(&int3472_tps68470); >> +} >> +module_exit(skl_int3472_exit); >> + >> +MODULE_DESCRIPTION("Intel SkyLake INT3472 ACPI Device Driver"); >> +MODULE_AUTHOR("Daniel Scally <djrscally@xxxxxxxxx>"); >> +MODULE_LICENSE("GPL v2"); >> diff --git a/drivers/platform/x86/intel-int3472/intel_skl_int3472_common.h b/drivers/platform/x86/intel-int3472/intel_skl_int3472_common.h >> new file mode 100644 >> index 000000000000..6fdf78584219 >> --- /dev/null >> +++ b/drivers/platform/x86/intel-int3472/intel_skl_int3472_common.h >> @@ -0,0 +1,118 @@ >> +/* SPDX-License-Identifier: GPL-2.0 */ >> +/* Author: Dan Scally <djrscally@xxxxxxxxx> */ >> + >> +#ifndef _INTEL_SKL_INT3472_H >> +#define _INTEL_SKL_INT3472_H >> + >> +#include <linux/clk-provider.h> >> +#include <linux/gpio/machine.h> >> +#include <linux/regulator/driver.h> >> +#include <linux/regulator/machine.h> >> +#include <linux/types.h> >> + >> +/* FIXME drop this once the I2C_DEV_NAME_FORMAT macro has been added to include/linux/i2c.h */ >> +#ifndef I2C_DEV_NAME_FORMAT >> +#define I2C_DEV_NAME_FORMAT "i2c-%s" >> +#endif >> + >> +/* PMIC GPIO Types */ >> +#define INT3472_GPIO_TYPE_RESET 0x00 >> +#define INT3472_GPIO_TYPE_POWERDOWN 0x01 >> +#define INT3472_GPIO_TYPE_POWER_ENABLE 0x0b >> +#define INT3472_GPIO_TYPE_CLK_ENABLE 0x0c >> +#define INT3472_GPIO_TYPE_PRIVACY_LED 0x0d >> + >> +#define INT3472_PDEV_MAX_NAME_LEN 23 >> +#define INT3472_MAX_SENSOR_GPIOS 3 >> + >> +#define GPIO_REGULATOR_NAME_LENGTH 21 >> +#define GPIO_REGULATOR_SUPPLY_NAME_LENGTH 9 >> + >> +#define CIO2_SENSOR_SSDB_MCLKSPEED_OFFSET 86 >> + >> +#define INT3472_REGULATOR(_name, _supply, _ops) \ >> + (const struct regulator_desc) { \ >> + .name = _name, \ >> + .supply_name = _supply, \ >> + .type = REGULATOR_VOLTAGE, \ >> + .ops = _ops, \ >> + .owner = THIS_MODULE, \ >> + } >> + >> +#define to_int3472_clk(hw) \ >> + container_of(hw, struct int3472_gpio_clock, clk_hw) >> + >> +#define to_int3472_device(clk) \ >> + container_of(clk, struct int3472_discrete_device, clock) >> + >> +struct acpi_device; >> +struct i2c_client; >> +struct platform_device; >> + >> +struct int3472_cldb { >> + u8 version; >> + /* >> + * control logic type >> + * 0: UNKNOWN >> + * 1: DISCRETE(CRD-D) >> + * 2: PMIC TPS68470 >> + * 3: PMIC uP6641 >> + */ >> + u8 control_logic_type; >> + u8 control_logic_id; >> + u8 sensor_card_sku; >> + u8 reserved[28]; >> +}; >> + >> +struct int3472_gpio_function_remap { >> + const char *documented; >> + const char *actual; >> +}; >> + >> +struct int3472_sensor_config { >> + const char *sensor_module_name; >> + struct regulator_consumer_supply supply_map; >> + const struct int3472_gpio_function_remap *function_maps; >> +}; >> + >> +struct int3472_discrete_device { >> + struct acpi_device *adev; >> + struct device *dev; >> + struct acpi_device *sensor; >> + const char *sensor_name; >> + >> + const struct int3472_sensor_config *sensor_config; >> + >> + struct int3472_gpio_regulator { >> + char regulator_name[GPIO_REGULATOR_NAME_LENGTH]; >> + char supply_name[GPIO_REGULATOR_SUPPLY_NAME_LENGTH]; >> + struct gpio_desc *gpio; >> + struct regulator_dev *rdev; >> + struct regulator_desc rdesc; >> + } regulator; >> + >> + struct int3472_gpio_clock { >> + struct clk *clk; >> + struct clk_hw clk_hw; >> + struct clk_lookup *cl; >> + struct gpio_desc *ena_gpio; >> + struct gpio_desc *led_gpio; >> + u32 frequency; >> + } clock; >> + >> + unsigned int ngpios; /* how many GPIOs have we seen */ >> + unsigned int n_sensor_gpios; /* how many have we mapped to sensor */ >> + struct gpiod_lookup_table gpios; >> +}; >> + >> +int skl_int3472_discrete_probe(struct platform_device *pdev); >> +int skl_int3472_discrete_remove(struct platform_device *pdev); >> +int skl_int3472_tps68470_probe(struct i2c_client *client); >> +union acpi_object *skl_int3472_get_acpi_buffer(struct acpi_device *adev, >> + char *id); >> +int skl_int3472_fill_cldb(struct acpi_device *adev, struct int3472_cldb *cldb); >> +int skl_int3472_register_clock(struct int3472_discrete_device *int3472); >> +int skl_int3472_register_regulator(struct int3472_discrete_device *int3472, >> + struct acpi_resource *ares); >> + >> +#endif >> diff --git a/drivers/platform/x86/intel-int3472/intel_skl_int3472_discrete.c b/drivers/platform/x86/intel-int3472/intel_skl_int3472_discrete.c >> new file mode 100644 >> index 000000000000..8c18dbff1c43 >> --- /dev/null >> +++ b/drivers/platform/x86/intel-int3472/intel_skl_int3472_discrete.c >> @@ -0,0 +1,417 @@ >> +// SPDX-License-Identifier: GPL-2.0 >> +/* Author: Dan Scally <djrscally@xxxxxxxxx> */ >> + >> +#include <linux/acpi.h> >> +#include <linux/clkdev.h> >> +#include <linux/clk-provider.h> >> +#include <linux/device.h> >> +#include <linux/gpio/consumer.h> >> +#include <linux/gpio/machine.h> >> +#include <linux/i2c.h> >> +#include <linux/kernel.h> >> +#include <linux/module.h> >> +#include <linux/overflow.h> >> +#include <linux/platform_device.h> >> +#include <linux/uuid.h> >> + >> +#include "intel_skl_int3472_common.h" >> + >> +/* >> + * 79234640-9e10-4fea-a5c1-b5aa8b19756f >> + * This _DSM GUID returns information about the GPIO lines mapped to a >> + * discrete INT3472 device. Function number 1 returns a count of the GPIO >> + * lines that are mapped. Subsequent functions return 32 bit ints encoding >> + * information about the GPIO line, including its purpose. >> + */ >> +static const guid_t int3472_gpio_guid = >> + GUID_INIT(0x79234640, 0x9e10, 0x4fea, >> + 0xa5, 0xc1, 0xb5, 0xaa, 0x8b, 0x19, 0x75, 0x6f); >> + >> +/* >> + * 822ace8f-2814-4174-a56b-5f029fe079ee >> + * This _DSM GUID returns a string from the sensor device, which acts as a >> + * module identifier. >> + */ >> +static const guid_t cio2_sensor_module_guid = >> + GUID_INIT(0x822ace8f, 0x2814, 0x4174, >> + 0xa5, 0x6b, 0x5f, 0x02, 0x9f, 0xe0, 0x79, 0xee); >> + >> +/* >> + * Here follows platform specific mapping information that we can pass to >> + * the functions mapping resources to the sensors. Where the sensors have >> + * a power enable pin defined in DSDT we need to provide a supply name so >> + * the sensor drivers can find the regulator. The device name will be derived >> + * from the sensor's ACPI device within the code. Optionally, we can provide a >> + * NULL terminated array of function name mappings to deal with any platform >> + * specific deviations from the documented behaviour of GPIOs. >> + * >> + * Map a GPIO function name to NULL to prevent the driver from mapping that >> + * GPIO at all. >> + */ >> + >> +static const struct int3472_gpio_function_remap ov2680_gpio_function_remaps[] = { >> + { "reset", NULL }, >> + { "powerdown", "reset" }, >> + { } >> +}; >> + >> +static const struct int3472_sensor_config int3472_sensor_configs[] = { >> + /* Lenovo Miix 510-12ISK - OV2680, Front */ >> + { "GNDF140809R", { 0 }, ov2680_gpio_function_remaps }, >> + /* Lenovo Miix 510-12ISK - OV5648, Rear */ >> + { "GEFF150023R", REGULATOR_SUPPLY("avdd", NULL), NULL }, >> + /* Surface Go 1&2 - OV5693, Front */ >> + { "YHCU", REGULATOR_SUPPLY("avdd", NULL), NULL }, >> +}; >> + >> +static const struct int3472_sensor_config * >> +skl_int3472_get_sensor_module_config(struct int3472_discrete_device *int3472) >> +{ >> + union acpi_object *obj; >> + unsigned int i; >> + >> + obj = acpi_evaluate_dsm_typed(int3472->sensor->handle, >> + &cio2_sensor_module_guid, 0x00, >> + 0x01, NULL, ACPI_TYPE_STRING); >> + >> + if (!obj) { >> + dev_err(int3472->dev, >> + "Failed to get sensor module string from _DSM\n"); >> + return ERR_PTR(-ENODEV); >> + } >> + >> + if (obj->string.type != ACPI_TYPE_STRING) { >> + dev_err(int3472->dev, >> + "Sensor _DSM returned a non-string value\n"); >> + >> + ACPI_FREE(obj); >> + return ERR_PTR(-EINVAL); >> + } >> + >> + for (i = 0; i < ARRAY_SIZE(int3472_sensor_configs); i++) { >> + if (!strcmp(int3472_sensor_configs[i].sensor_module_name, >> + obj->string.pointer)) >> + break; >> + } >> + >> + ACPI_FREE(obj); >> + >> + if (i >= ARRAY_SIZE(int3472_sensor_configs)) >> + return ERR_PTR(-EINVAL); >> + >> + return &int3472_sensor_configs[i]; >> +} >> + >> +static int skl_int3472_map_gpio_to_sensor(struct int3472_discrete_device *int3472, >> + struct acpi_resource *ares, >> + const char *func, u32 polarity) >> +{ >> + char *path = ares->data.gpio.resource_source.string_ptr; >> + const struct int3472_sensor_config *sensor_config; >> + struct gpiod_lookup *table_entry; >> + struct acpi_device *adev; >> + acpi_handle handle; >> + acpi_status status; >> + int ret; >> + >> + if (int3472->n_sensor_gpios >= INT3472_MAX_SENSOR_GPIOS) { >> + dev_warn(int3472->dev, "Too many GPIOs mapped\n"); >> + return -EINVAL; >> + } >> + >> + sensor_config = int3472->sensor_config; >> + if (!IS_ERR(sensor_config) && sensor_config->function_maps) { >> + const struct int3472_gpio_function_remap *remap; >> + >> + for (remap = sensor_config->function_maps; remap->documented; remap++) { >> + if (!strcmp(func, remap->documented)) { >> + func = remap->actual; >> + break; >> + } >> + } >> + } >> + >> + /* Functions mapped to NULL should not be mapped to the sensor */ >> + if (!func) >> + return 0; >> + >> + status = acpi_get_handle(NULL, path, &handle); >> + if (ACPI_FAILURE(status)) >> + return -EINVAL; >> + >> + ret = acpi_bus_get_device(handle, &adev); >> + if (ret) >> + return -ENODEV; >> + >> + table_entry = &int3472->gpios.table[int3472->n_sensor_gpios]; >> + table_entry->key = acpi_dev_name(adev); >> + table_entry->chip_hwnum = ares->data.gpio.pin_table[0]; >> + table_entry->con_id = func; >> + table_entry->idx = 0; >> + table_entry->flags = polarity; >> + >> + int3472->n_sensor_gpios++; >> + >> + return 0; >> +} >> + >> +static int skl_int3472_map_gpio_to_clk(struct int3472_discrete_device *int3472, >> + struct acpi_resource *ares, u8 type) >> +{ >> + char *path = ares->data.gpio.resource_source.string_ptr; >> + struct gpio_desc *gpio; >> + >> + switch (type) { >> + case INT3472_GPIO_TYPE_CLK_ENABLE: >> + gpio = acpi_get_and_request_gpiod(path, ares->data.gpio.pin_table[0], >> + "int3472,clk-enable"); >> + if (IS_ERR(gpio)) >> + return (PTR_ERR(gpio)); >> + >> + int3472->clock.ena_gpio = gpio; >> + break; >> + case INT3472_GPIO_TYPE_PRIVACY_LED: >> + gpio = acpi_get_and_request_gpiod(path, ares->data.gpio.pin_table[0], >> + "int3472,privacy-led"); >> + if (IS_ERR(gpio)) >> + return (PTR_ERR(gpio)); >> + >> + int3472->clock.led_gpio = gpio; >> + break; >> + default: >> + dev_err(int3472->dev, "Invalid GPIO type 0x%02x for clock\n", type); >> + break; >> + } >> + >> + return 0; >> +} >> + >> +/** >> + * skl_int3472_handle_gpio_resources: Map PMIC resources to consuming sensor >> + * @ares: A pointer to a &struct acpi_resource >> + * @data: A pointer to a &struct int3472_discrete_device >> + * >> + * This function handles GPIO resources that are against an INT3472 >> + * ACPI device, by checking the value of the corresponding _DSM entry. >> + * This will return a 32bit int, where the lowest byte represents the >> + * function of the GPIO pin: >> + * >> + * 0x00 Reset >> + * 0x01 Power down >> + * 0x0b Power enable >> + * 0x0c Clock enable >> + * 0x0d Privacy LED >> + * >> + * There are some known platform specific quirks where that does not quite >> + * hold up; for example where a pin with type 0x01 (Power down) is mapped to >> + * a sensor pin that performs a reset function or entries in _CRS and _DSM that >> + * do not actually correspond to a physical connection. These will be handled >> + * by the mapping sub-functions. >> + * >> + * GPIOs will either be mapped directly to the sensor device or else used >> + * to create clocks and regulators via the usual frameworks. >> + * >> + * Return: >> + * * 1 - To continue the loop >> + * * 0 - When all resources found are handled properly. >> + * * -EINVAL - If the resource is not a GPIO IO resource >> + * * -ENODEV - If the resource has no corresponding _DSM entry >> + * * -Other - Errors propagated from one of the sub-functions. >> + */ >> +static int skl_int3472_handle_gpio_resources(struct acpi_resource *ares, >> + void *data) >> +{ >> + struct int3472_discrete_device *int3472 = data; >> + struct acpi_resource_gpio *agpio; >> + union acpi_object *obj; >> + const char *err_msg; >> + int ret; >> + u8 type; >> + >> + if (!acpi_gpio_get_io_resource(ares, &agpio)) >> + return 1; >> + >> + /* >> + * ngpios + 2 because the index of this _DSM function is 1-based and >> + * the first function is just a count. >> + */ >> + obj = acpi_evaluate_dsm_typed(int3472->adev->handle, >> + &int3472_gpio_guid, 0x00, >> + int3472->ngpios + 2, >> + NULL, ACPI_TYPE_INTEGER); >> + >> + if (!obj) { >> + dev_warn(int3472->dev, "No _DSM entry for GPIO pin %u\n", >> + ares->data.gpio.pin_table[0]); >> + return 1; >> + } >> + >> + type = obj->integer.value & 0xff; >> + >> + switch (type) { >> + case INT3472_GPIO_TYPE_RESET: >> + ret = skl_int3472_map_gpio_to_sensor(int3472, ares, "reset", >> + GPIO_ACTIVE_LOW); >> + if (ret) >> + err_msg = "Failed to map reset pin to sensor\n"; >> + >> + break; >> + case INT3472_GPIO_TYPE_POWERDOWN: >> + ret = skl_int3472_map_gpio_to_sensor(int3472, ares, >> + "powerdown", >> + GPIO_ACTIVE_LOW); >> + if (ret) >> + err_msg = "Failed to map powerdown pin to sensor\n"; >> + >> + break; >> + case INT3472_GPIO_TYPE_CLK_ENABLE: >> + case INT3472_GPIO_TYPE_PRIVACY_LED: >> + ret = skl_int3472_map_gpio_to_clk(int3472, ares, type); >> + if (ret) >> + err_msg = "Failed to map GPIO to clock\n"; >> + >> + break; >> + case INT3472_GPIO_TYPE_POWER_ENABLE: >> + ret = skl_int3472_register_regulator(int3472, ares); >> + if (ret) >> + err_msg = "Failed to map regulator to sensor\n"; >> + >> + break; >> + default: >> + dev_warn(int3472->dev, >> + "GPIO type 0x%02x unknown; the sensor may not work\n", >> + type); >> + ret = 1; >> + break; >> + } >> + >> + int3472->ngpios++; >> + ACPI_FREE(obj); >> + >> + if (ret) >> + return dev_err_probe(int3472->dev, ret, err_msg); >> + >> + return 0; >> +} >> + >> +static int skl_int3472_parse_crs(struct int3472_discrete_device *int3472) >> +{ >> + LIST_HEAD(resource_list); >> + int ret; >> + >> + /* >> + * No error check, because not having a sensor config is not necessarily >> + * a failure mode. >> + */ >> + int3472->sensor_config = skl_int3472_get_sensor_module_config(int3472); >> + >> + ret = acpi_dev_get_resources(int3472->adev, &resource_list, >> + skl_int3472_handle_gpio_resources, >> + int3472); >> + if (ret) >> + goto out_free_res_list; >> + >> + /* >> + * If we find no clock enable GPIO pin then the privacy LED won't work. >> + * We've never seen that situation, but it's possible. Warn the user so >> + * it's clear what's happened. >> + */ >> + if (int3472->clock.ena_gpio) { >> + ret = skl_int3472_register_clock(int3472); >> + if (ret) >> + goto out_free_res_list; >> + } else { >> + if (int3472->clock.led_gpio) >> + dev_warn(int3472->dev, >> + "No clk GPIO. The privacy LED won't work\n"); >> + } >> + >> + int3472->gpios.dev_id = int3472->sensor_name; >> + gpiod_add_lookup_table(&int3472->gpios); >> + >> +out_free_res_list: >> + acpi_dev_free_resource_list(&resource_list); >> + >> + return ret; >> +} >> + >> +int skl_int3472_discrete_probe(struct platform_device *pdev) >> +{ >> + struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); >> + struct int3472_discrete_device *int3472; >> + struct int3472_cldb cldb; >> + int ret; >> + >> + ret = skl_int3472_fill_cldb(adev, &cldb); >> + if (ret) { >> + dev_err(&pdev->dev, "Couldn't fill CLDB structure\n"); >> + return ret; >> + } >> + >> + if (cldb.control_logic_type != 1) { >> + dev_err(&pdev->dev, "Unsupported control logic type %u\n", >> + cldb.control_logic_type); >> + return -EINVAL; >> + } >> + >> + /* Max num GPIOs we've seen plus a terminator */ >> + int3472 = devm_kzalloc(&pdev->dev, struct_size(int3472, gpios.table, >> + INT3472_MAX_SENSOR_GPIOS + 1), GFP_KERNEL); >> + if (!int3472) >> + return -ENOMEM; >> + >> + int3472->adev = adev; >> + int3472->dev = &pdev->dev; >> + platform_set_drvdata(pdev, int3472); >> + >> + int3472->sensor = acpi_dev_get_first_consumer_dev(adev); >> + if (!int3472->sensor) { >> + dev_err(&pdev->dev, "INT3472 seems to have no dependents.\n"); >> + return -ENODEV; >> + } >> + >> + int3472->sensor_name = devm_kasprintf(int3472->dev, GFP_KERNEL, >> + I2C_DEV_NAME_FORMAT, >> + acpi_dev_name(int3472->sensor)); >> + if (!int3472->sensor_name) { >> + ret = -ENOMEM; >> + goto err_put_sensor; >> + } >> + >> + /* >> + * Initialising this list means we can call gpiod_remove_lookup_table() >> + * in failure paths without issue. >> + */ >> + INIT_LIST_HEAD(&int3472->gpios.list); >> + >> + ret = skl_int3472_parse_crs(int3472); >> + if (ret) { >> + skl_int3472_discrete_remove(pdev); >> + return ret; >> + } >> + >> + return 0; >> + >> +err_put_sensor: >> + acpi_dev_put(int3472->sensor); >> + >> + return ret; >> +} >> + >> +int skl_int3472_discrete_remove(struct platform_device *pdev) >> +{ >> + struct int3472_discrete_device *int3472 = platform_get_drvdata(pdev); >> + >> + gpiod_remove_lookup_table(&int3472->gpios); >> + regulator_unregister(int3472->regulator.rdev); >> + clk_unregister(int3472->clock.clk); >> + >> + if (int3472->clock.cl) >> + clkdev_drop(int3472->clock.cl); >> + >> + gpiod_put(int3472->regulator.gpio); >> + gpiod_put(int3472->clock.ena_gpio); >> + gpiod_put(int3472->clock.led_gpio); >> + >> + return 0; >> +} >> diff --git a/drivers/platform/x86/intel-int3472/intel_skl_int3472_tps68470.c b/drivers/platform/x86/intel-int3472/intel_skl_int3472_tps68470.c >> new file mode 100644 >> index 000000000000..6306ba24e0bc >> --- /dev/null >> +++ b/drivers/platform/x86/intel-int3472/intel_skl_int3472_tps68470.c >> @@ -0,0 +1,137 @@ >> +// SPDX-License-Identifier: GPL-2.0 >> +/* Author: Dan Scally <djrscally@xxxxxxxxx> */ >> + >> +#include <linux/i2c.h> >> +#include <linux/mfd/core.h> >> +#include <linux/mfd/tps68470.h> >> +#include <linux/platform_device.h> >> +#include <linux/regmap.h> >> + >> +#include "intel_skl_int3472_common.h" >> + >> +#define DESIGNED_FOR_CHROMEOS 1 >> +#define DESIGNED_FOR_WINDOWS 2 >> + >> +static const struct mfd_cell tps68470_cros[] = { >> + { .name = "tps68470-gpio" }, >> + { .name = "tps68470_pmic_opregion" }, >> +}; >> + >> +static const struct mfd_cell tps68470_win[] = { >> + { .name = "tps68470-gpio" }, >> + { .name = "tps68470-clk" }, >> + { .name = "tps68470-regulator" }, >> +}; >> + >> +static const struct regmap_config tps68470_regmap_config = { >> + .reg_bits = 8, >> + .val_bits = 8, >> + .max_register = TPS68470_REG_MAX, >> +}; >> + >> +static int tps68470_chip_init(struct device *dev, struct regmap *regmap) >> +{ >> + unsigned int version; >> + int ret; >> + >> + /* Force software reset */ >> + ret = regmap_write(regmap, TPS68470_REG_RESET, TPS68470_REG_RESET_MASK); >> + if (ret) >> + return ret; >> + >> + ret = regmap_read(regmap, TPS68470_REG_REVID, &version); >> + if (ret) { >> + dev_err(dev, "Failed to read revision register: %d\n", ret); >> + return ret; >> + } >> + >> + dev_info(dev, "TPS68470 REVID: 0x%02x\n", version); >> + >> + return 0; >> +} >> + >> +/** skl_int3472_tps68470_calc_type: Check what platform a device is designed for >> + * @adev: A pointer to a &struct acpi_device >> + * >> + * Check CLDB buffer against the PMIC's adev. If present, then we check >> + * the value of control_logic_type field and follow one of the >> + * following scenarios: >> + * >> + * 1. No CLDB - likely ACPI tables designed for ChromeOS. We >> + * create platform devices for the GPIOs and OpRegion drivers. >> + * >> + * 2. CLDB, with control_logic_type = 2 - probably ACPI tables >> + * made for Windows 2-in-1 platforms. Register pdevs for GPIO, >> + * Clock and Regulator drivers to bind to. >> + * >> + * 3. Any other value in control_logic_type, we should never have >> + * gotten to this point; fail probe and return. >> + * >> + * Return: >> + * * 1 Device intended for ChromeOS >> + * * 2 Device intended for Windows >> + * * -EINVAL Where @adev has an object named CLDB but it does not conform to >> + * our expectations >> + */ >> +int skl_int3472_tps68470_calc_type(struct acpi_device *adev) >> +{ >> + struct int3472_cldb cldb = { 0 }; >> + int ret; >> + >> + /* >> + * A CLDB buffer that exists, but which does not match our expectations >> + * should trigger an error so we don't blindly continue. >> + */ >> + ret = skl_int3472_fill_cldb(adev, &cldb); >> + if (ret && ret != -ENODEV) >> + return ret; >> + >> + if (ret) >> + return DESIGNED_FOR_CHROMEOS; >> + >> + if (cldb.control_logic_type != 2) >> + return -EINVAL; >> + >> + return DESIGNED_FOR_WINDOWS; >> +} >> + >> +int skl_int3472_tps68470_probe(struct i2c_client *client) >> +{ >> + struct acpi_device *adev = ACPI_COMPANION(&client->dev); >> + struct regmap *regmap; >> + int device_type; >> + int ret; >> + >> + regmap = devm_regmap_init_i2c(client, &tps68470_regmap_config); >> + if (IS_ERR(regmap)) { >> + dev_err(&client->dev, "Failed to create regmap: %ld\n", PTR_ERR(regmap)); >> + return PTR_ERR(regmap); >> + } >> + >> + i2c_set_clientdata(client, regmap); >> + >> + ret = tps68470_chip_init(&client->dev, regmap); >> + if (ret < 0) { >> + dev_err(&client->dev, "TPS68470 init error %d\n", ret); >> + return ret; >> + } >> + >> + device_type = skl_int3472_tps68470_calc_type(adev); >> + switch (device_type) { >> + case DESIGNED_FOR_WINDOWS: >> + ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE, >> + tps68470_win, ARRAY_SIZE(tps68470_win), >> + NULL, 0, NULL); >> + break; >> + case DESIGNED_FOR_CHROMEOS: >> + ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE, >> + tps68470_cros, ARRAY_SIZE(tps68470_cros), >> + NULL, 0, NULL); >> + break; >> + default: >> + dev_err(&client->dev, "Failed to add MFD devices\n"); >> + return device_type; >> + } >> + >> + return ret; >> +} >>
