platform/x86: Add intel_skl_int3472 driver
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@ideasonboard.com> Signed-off-by: Daniel Scally <djrscally@gmail.com> Link: https://lore.kernel.org/r/20210603224007.120560-6-djrscally@gmail.com [hdegoede@redhat.com Make skl_int3472_tps68470_calc_type() static] Signed-off-by: Hans de Goede <hdegoede@redhat.com>
This commit is contained in:
Daniel Scally
Hans de Goede
parent
c8d9c3674c
commit
5de691bffe
|
|
@ -9385,6 +9385,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@gmail.com>
|
||||
S: Maintained
|
||||
F: drivers/platform/x86/intel-int3472/
|
||||
|
||||
INTEL SPEED SELECT TECHNOLOGY
|
||||
M: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
|
||||
L: platform-driver-x86@vger.kernel.org
|
||||
|
|
|
|||
|
|
@ -709,6 +709,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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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".
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
// 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/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;
|
||||
}
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Author: Dan Scally <djrscally@gmail.com> */
|
||||
|
||||
#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@gmail.com>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
/* Author: Dan Scally <djrscally@gmail.com> */
|
||||
|
||||
#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
|
||||
|
|
@ -0,0 +1,417 @@
|
|||
// 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/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;
|
||||
}
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Author: Dan Scally <djrscally@gmail.com> */
|
||||
|
||||
#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
|
||||
*/
|
||||
static 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;
|
||||
}
|
||||
Loading…
Reference in New Issue