| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20240621102656.GK1318296@google.com>
Date: Fri, 21 Jun 2024 11:26:56 +0100
From: Lee Jones <lee@...nel.org>
To: git@...tzsch.eu
Cc: Pavel Machek <pavel@....cz>, Rob Herring <robh@...nel.org>,
Krzysztof Kozlowski <krzysztof.kozlowski+dt@...aro.org>,
Conor Dooley <conor+dt@...nel.org>,
"Gustavo A. R. Silva" <gustavoars@...nel.org>,
Bjorn Andersson <andersson@...nel.org>,
Konrad Dybcio <konrad.dybcio@...aro.org>,
Christophe JAILLET <christophe.jaillet@...adoo.fr>,
Trilok Soni <quic_tsoni@...cinc.com>, Kees Cook <kees@...nel.org>,
linux-leds@...r.kernel.org, devicetree@...r.kernel.org,
linux-kernel@...r.kernel.org, linux-hardening@...r.kernel.org,
linux-arm-msm@...r.kernel.org,
~postmarketos/upstreaming@...ts.sr.ht, phone-devel@...r.kernel.org
Subject: Re: [PATCH v4 2/3] leds: sy7802: Add support for Silergy SY7802
flash LED controller
On Sun, 16 Jun 2024, André Apitzsch via B4 Relay wrote:
> From: André Apitzsch <git@...tzsch.eu>
>
> The SY7802 is a current-regulated charge pump which can regulate two
> current levels for Flash and Torch modes.
>
> It is a high-current synchronous boost converter with 2-channel high
> side current sources. Each channel is able to deliver 900mA current.
>
> Signed-off-by: André Apitzsch <git@...tzsch.eu>
> ---
> drivers/leds/flash/Kconfig | 11 +
> drivers/leds/flash/Makefile | 1 +
> drivers/leds/flash/leds-sy7802.c | 542 +++++++++++++++++++++++++++++++++++++++
> 3 files changed, 554 insertions(+)
Generally very nice.
Just a couple of teensy nits to fix then add my and resubmit please.
Acked-by: Lee Jones <lee@...nel.org>
> diff --git a/drivers/leds/flash/Kconfig b/drivers/leds/flash/Kconfig
> index 809b6d98bb3e..f39f0bfe6eef 100644
> --- a/drivers/leds/flash/Kconfig
> +++ b/drivers/leds/flash/Kconfig
> @@ -121,4 +121,15 @@ config LEDS_SGM3140
> This option enables support for the SGM3140 500mA Buck/Boost Charge
> Pump LED Driver.
>
> +config LEDS_SY7802
> + tristate "LED support for the Silergy SY7802"
> + depends on I2C && OF
> + depends on GPIOLIB
> + select REGMAP_I2C
> + help
> + This option enables support for the SY7802 flash LED controller.
> + SY7802 includes torch and flash functions with programmable current.
> +
> + This driver can be built as a module, it will be called "leds-sy7802".
> +
> endif # LEDS_CLASS_FLASH
> diff --git a/drivers/leds/flash/Makefile b/drivers/leds/flash/Makefile
> index 91d60a4b7952..48860eeced79 100644
> --- a/drivers/leds/flash/Makefile
> +++ b/drivers/leds/flash/Makefile
> @@ -11,3 +11,4 @@ obj-$(CONFIG_LEDS_QCOM_FLASH) += leds-qcom-flash.o
> obj-$(CONFIG_LEDS_RT4505) += leds-rt4505.o
> obj-$(CONFIG_LEDS_RT8515) += leds-rt8515.o
> obj-$(CONFIG_LEDS_SGM3140) += leds-sgm3140.o
> +obj-$(CONFIG_LEDS_SY7802) += leds-sy7802.o
> diff --git a/drivers/leds/flash/leds-sy7802.c b/drivers/leds/flash/leds-sy7802.c
> new file mode 100644
> index 000000000000..c4bea55a62d0
> --- /dev/null
> +++ b/drivers/leds/flash/leds-sy7802.c
> @@ -0,0 +1,542 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * Silergy SY7802 flash LED driver with I2C interface
"an I2C interface"
Or
"I2C interfaces"
> + * Copyright 2024 André Apitzsch <git@...tzsch.eu>
> + */
> +
> +#include <linux/gpio/consumer.h>
> +#include <linux/i2c.h>
> +#include <linux/kernel.h>
> +#include <linux/led-class-flash.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/regmap.h>
> +#include <linux/regulator/consumer.h>
> +
> +#define SY7802_MAX_LEDS 2
> +#define SY7802_LED_JOINT 2
> +
> +#define SY7802_REG_ENABLE 0x10
> +#define SY7802_REG_TORCH_BRIGHTNESS 0xa0
> +#define SY7802_REG_FLASH_BRIGHTNESS 0xb0
> +#define SY7802_REG_FLASH_DURATION 0xc0
> +#define SY7802_REG_FLAGS 0xd0
> +#define SY7802_REG_CONFIG_1 0xe0
> +#define SY7802_REG_CONFIG_2 0xf0
> +#define SY7802_REG_VIN_MONITOR 0x80
> +#define SY7802_REG_LAST_FLASH 0x81
> +#define SY7802_REG_VLED_MONITOR 0x30
> +#define SY7802_REG_ADC_DELAY 0x31
> +#define SY7802_REG_DEV_ID 0xff
> +
> +#define SY7802_MODE_OFF 0
> +#define SY7802_MODE_TORCH 2
> +#define SY7802_MODE_FLASH 3
> +#define SY7802_MODE_MASK GENMASK(1, 0)
> +
> +#define SY7802_LEDS_SHIFT 3
> +#define SY7802_LEDS_MASK(_id) (BIT(_id) << SY7802_LEDS_SHIFT)
> +#define SY7802_LEDS_MASK_ALL (SY7802_LEDS_MASK(0) | SY7802_LEDS_MASK(1))
> +
> +#define SY7802_TORCH_CURRENT_SHIFT 3
> +#define SY7802_TORCH_CURRENT_MASK(_id) \
> + (GENMASK(2, 0) << (SY7802_TORCH_CURRENT_SHIFT * (_id)))
> +#define SY7802_TORCH_CURRENT_MASK_ALL \
> + (SY7802_TORCH_CURRENT_MASK(0) | SY7802_TORCH_CURRENT_MASK(1))
> +
> +#define SY7802_FLASH_CURRENT_SHIFT 4
> +#define SY7802_FLASH_CURRENT_MASK(_id) \
> + (GENMASK(3, 0) << (SY7802_FLASH_CURRENT_SHIFT * (_id)))
> +#define SY7802_FLASH_CURRENT_MASK_ALL \
> + (SY7802_FLASH_CURRENT_MASK(0) | SY7802_FLASH_CURRENT_MASK(1))
> +
> +#define SY7802_TIMEOUT_DEFAULT_US 512000U
> +#define SY7802_TIMEOUT_MIN_US 32000U
> +#define SY7802_TIMEOUT_MAX_US 1024000U
> +#define SY7802_TIMEOUT_STEPSIZE_US 32000U
> +
> +#define SY7802_TORCH_BRIGHTNESS_MAX 8
> +
> +#define SY7802_FLASH_BRIGHTNESS_DEFAULT 14
> +#define SY7802_FLASH_BRIGHTNESS_MIN 0
> +#define SY7802_FLASH_BRIGHTNESS_MAX 15
> +#define SY7802_FLASH_BRIGHTNESS_STEP 1
> +
> +#define SY7802_FLAG_TIMEOUT BIT(0)
> +#define SY7802_FLAG_THERMAL_SHUTDOWN BIT(1)
> +#define SY7802_FLAG_LED_FAULT BIT(2)
> +#define SY7802_FLAG_TX1_INTERRUPT BIT(3)
> +#define SY7802_FLAG_TX2_INTERRUPT BIT(4)
> +#define SY7802_FLAG_LED_THERMAL_FAULT BIT(5)
> +#define SY7802_FLAG_FLASH_INPUT_VOLTAGE_LOW BIT(6)
> +#define SY7802_FLAG_INPUT_VOLTAGE_LOW BIT(7)
> +
> +#define SY7802_CHIP_ID 0x51
> +
> +static const struct reg_default sy7802_regmap_defs[] = {
> + { SY7802_REG_ENABLE, SY7802_LEDS_MASK_ALL },
> + { SY7802_REG_TORCH_BRIGHTNESS, 0x92 },
> + { SY7802_REG_FLASH_BRIGHTNESS, SY7802_FLASH_BRIGHTNESS_DEFAULT |
> + SY7802_FLASH_BRIGHTNESS_DEFAULT << SY7802_FLASH_CURRENT_SHIFT },
> + { SY7802_REG_FLASH_DURATION, 0x6f },
> + { SY7802_REG_FLAGS, 0x0 },
> + { SY7802_REG_CONFIG_1, 0x68 },
> + { SY7802_REG_CONFIG_2, 0xf0 },
Not your fault, but this interface is frustrating since we have no idea
what these register values mean. IMHO, they should be defined and ORed
together in some human readable way.
I say that it's not your fault because I see that this is the most
common usage.
> +};
> +
> +struct sy7802_led {
> + struct led_classdev_flash flash;
> + struct sy7802 *chip;
> + u8 led_id;
> +};
> +
> +struct sy7802 {
> + struct device *dev;
> + struct regmap *regmap;
> + struct mutex mutex;
> +
> + struct gpio_desc *enable_gpio;
> + struct regulator *vin_regulator;
> +
> + unsigned int fled_strobe_used;
> + unsigned int fled_torch_used;
> + unsigned int leds_active;
> + int num_leds;
> + struct sy7802_led leds[] __counted_by(num_leds);
> +};
> +
> +static int sy7802_torch_brightness_set(struct led_classdev *lcdev, enum led_brightness brightness)
> +{
> + struct sy7802_led *led = container_of(lcdev, struct sy7802_led, flash.led_cdev);
> + struct sy7802 *chip = led->chip;
> + u32 fled_torch_used_tmp;
> + u32 led_enable_mask;
> + u32 enable_mask;
> + u32 torch_mask;
> + u32 val;
> + int ret;
> +
> + mutex_lock(&chip->mutex);
> +
> + if (chip->fled_strobe_used) {
> + dev_warn(chip->dev, "Cannot set torch brightness whilst strobe is enabled\n");
> + ret = -EBUSY;
> + goto unlock;
> + }
> +
> + if (brightness)
> + fled_torch_used_tmp = chip->fled_torch_used | BIT(led->led_id);
> + else
> + fled_torch_used_tmp = chip->fled_torch_used & ~BIT(led->led_id);
> +
> + led_enable_mask = led->led_id == SY7802_LED_JOINT ?
> + SY7802_LEDS_MASK_ALL :
> + SY7802_LEDS_MASK(led->led_id);
> +
> + val = brightness ? led_enable_mask : SY7802_MODE_OFF;
> + if (fled_torch_used_tmp)
> + val |= SY7802_MODE_TORCH;
> +
> + /* Disable torch to apply brightness */
> + ret = regmap_update_bits(chip->regmap, SY7802_REG_ENABLE, SY7802_MODE_MASK,
> + SY7802_MODE_OFF);
> + if (ret)
> + goto unlock;
> +
> + torch_mask = led->led_id == SY7802_LED_JOINT ?
> + SY7802_TORCH_CURRENT_MASK_ALL :
> + SY7802_TORCH_CURRENT_MASK(led->led_id);
> +
> + /* Register expects brightness between 0 and MAX_BRIGHTNESS - 1 */
> + if (brightness)
> + brightness -= 1;
> +
> + brightness |= (brightness << SY7802_TORCH_CURRENT_SHIFT);
> +
> + ret = regmap_update_bits(chip->regmap, SY7802_REG_TORCH_BRIGHTNESS, torch_mask, brightness);
> + if (ret)
> + goto unlock;
> +
> + enable_mask = SY7802_MODE_MASK | led_enable_mask;
> + ret = regmap_update_bits(chip->regmap, SY7802_REG_ENABLE, enable_mask, val);
> + if (ret)
> + goto unlock;
> +
> + chip->fled_torch_used = fled_torch_used_tmp;
> +
> +unlock:
> + mutex_unlock(&chip->mutex);
> + return ret;
> +}
> +
> +static int sy7802_flash_brightness_set(struct led_classdev_flash *fl_cdev, u32 brightness)
> +{
> + struct sy7802_led *led = container_of(fl_cdev, struct sy7802_led, flash);
> + struct led_flash_setting *s = &fl_cdev->brightness;
> + u32 val = (brightness - s->min) / s->step;
> + struct sy7802 *chip = led->chip;
> + u32 flash_mask;
> + int ret;
> +
> + val |= (val << SY7802_FLASH_CURRENT_SHIFT);
> + flash_mask = led->led_id == SY7802_LED_JOINT ?
> + SY7802_FLASH_CURRENT_MASK_ALL :
> + SY7802_FLASH_CURRENT_MASK(led->led_id);
> +
> + mutex_lock(&chip->mutex);
> + ret = regmap_update_bits(chip->regmap, SY7802_REG_FLASH_BRIGHTNESS, flash_mask, val);
> + mutex_unlock(&chip->mutex);
> +
> + return ret;
> +}
> +
> +static int sy7802_strobe_set(struct led_classdev_flash *fl_cdev, bool state)
> +{
> + struct sy7802_led *led = container_of(fl_cdev, struct sy7802_led, flash);
> + struct sy7802 *chip = led->chip;
> + u32 fled_strobe_used_tmp;
> + u32 led_enable_mask;
> + u32 enable_mask;
> + u32 val;
> + int ret;
> +
> + mutex_lock(&chip->mutex);
> +
> + if (chip->fled_torch_used) {
> + dev_warn(chip->dev, "Cannot set strobe brightness whilst torch is enabled\n");
> + ret = -EBUSY;
> + goto unlock;
> + }
> +
> + if (state)
> + fled_strobe_used_tmp = chip->fled_strobe_used | BIT(led->led_id);
> + else
> + fled_strobe_used_tmp = chip->fled_strobe_used & ~BIT(led->led_id);
> +
> + led_enable_mask = led->led_id == SY7802_LED_JOINT ?
> + SY7802_LEDS_MASK_ALL :
> + SY7802_LEDS_MASK(led->led_id);
> +
> + val = state ? led_enable_mask : SY7802_MODE_OFF;
> + if (fled_strobe_used_tmp)
> + val |= SY7802_MODE_FLASH;
> +
> + enable_mask = SY7802_MODE_MASK | led_enable_mask;
> + ret = regmap_update_bits(chip->regmap, SY7802_REG_ENABLE, enable_mask, val);
> +
> + if (ret)
> + goto unlock;
> +
> + chip->fled_strobe_used = fled_strobe_used_tmp;
> +
> +unlock:
> + mutex_unlock(&chip->mutex);
> + return ret;
> +}
> +
> +static int sy7802_strobe_get(struct led_classdev_flash *fl_cdev, bool *state)
> +{
> + struct sy7802_led *led = container_of(fl_cdev, struct sy7802_led, flash);
> + struct sy7802 *chip = led->chip;
> +
> + mutex_lock(&chip->mutex);
> + *state = !!(chip->fled_strobe_used & BIT(led->led_id));
> + mutex_unlock(&chip->mutex);
> +
> + return 0;
> +}
> +
> +static int sy7802_timeout_set(struct led_classdev_flash *fl_cdev,
> + u32 timeout)
Nit: Unwrap.
> +{
> + struct sy7802_led *led = container_of(fl_cdev, struct sy7802_led, flash);
> + struct led_flash_setting *s = &fl_cdev->timeout;
> + u32 val = (timeout - s->min) / s->step;
> + struct sy7802 *chip = led->chip;
> +
> + return regmap_write(chip->regmap, SY7802_REG_FLASH_DURATION, val);
> +}
> +
> +static int sy7802_fault_get(struct led_classdev_flash *fl_cdev, u32 *fault)
> +{
> + struct sy7802_led *led = container_of(fl_cdev, struct sy7802_led, flash);
> + struct sy7802 *chip = led->chip;
> + u32 val, led_faults = 0;
> + int ret;
> +
> + /* NOTE: reading register clears fault status */
> + ret = regmap_read(chip->regmap, SY7802_REG_FLAGS, &val);
> + if (ret)
> + return ret;
> +
> + if (val & (SY7802_FLAG_FLASH_INPUT_VOLTAGE_LOW | SY7802_FLAG_INPUT_VOLTAGE_LOW))
> + led_faults |= LED_FAULT_INPUT_VOLTAGE;
> +
> + if (val & SY7802_FLAG_THERMAL_SHUTDOWN)
> + led_faults |= LED_FAULT_OVER_TEMPERATURE;
> +
> + if (val & SY7802_FLAG_TIMEOUT)
> + led_faults |= LED_FAULT_TIMEOUT;
> +
> + *fault = led_faults;
> + return 0;
> +}
> +
> +static const struct led_flash_ops sy7802_flash_ops = {
> + .flash_brightness_set = sy7802_flash_brightness_set,
> + .strobe_set = sy7802_strobe_set,
> + .strobe_get = sy7802_strobe_get,
> + .timeout_set = sy7802_timeout_set,
> + .fault_get = sy7802_fault_get,
> +};
> +
> +static void sy7802_init_flash_brightness(struct led_classdev_flash *fl_cdev)
> +{
> + struct led_flash_setting *s;
> +
> + /* Init flash brightness setting */
> + s = &fl_cdev->brightness;
> + s->min = SY7802_FLASH_BRIGHTNESS_MIN;
> + s->max = SY7802_FLASH_BRIGHTNESS_MAX;
> + s->step = SY7802_FLASH_BRIGHTNESS_STEP;
> + s->val = SY7802_FLASH_BRIGHTNESS_DEFAULT;
> +}
> +
> +static void sy7802_init_flash_timeout(struct led_classdev_flash *fl_cdev)
> +{
> + struct led_flash_setting *s;
> +
> + /* Init flash timeout setting */
> + s = &fl_cdev->timeout;
> + s->min = SY7802_TIMEOUT_MIN_US;
> + s->max = SY7802_TIMEOUT_MAX_US;
> + s->step = SY7802_TIMEOUT_STEPSIZE_US;
> + s->val = SY7802_TIMEOUT_DEFAULT_US;
> +}
> +
> +static int sy7802_led_register(struct device *dev, struct sy7802_led *led,
> + struct device_node *np)
> +{
> + struct led_init_data init_data = {};
> + int ret;
> +
> + init_data.fwnode = of_fwnode_handle(np);
> +
> + ret = devm_led_classdev_flash_register_ext(dev, &led->flash, &init_data);
> + if (ret) {
> + dev_err(dev, "Couldn't register flash %d\n", led->led_id);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int sy7802_init_flash_properties(struct device *dev, struct sy7802_led *led,
> + struct device_node *np)
> +{
> + struct led_classdev_flash *flash = &led->flash;
> + struct led_classdev *lcdev = &flash->led_cdev;
> + u32 sources[SY7802_MAX_LEDS];
> + int i, num, ret;
> +
> + num = of_property_count_u32_elems(np, "led-sources");
> + if (num < 1) {
> + dev_err(dev, "Not specified or wrong number of led-sources\n");
> + return -EINVAL;
> + }
> +
> + ret = of_property_read_u32_array(np, "led-sources", sources, num);
> + if (ret)
> + return ret;
> +
> + for (i = 0; i < num; i++) {
> + if (sources[i] >= SY7802_MAX_LEDS)
> + return -EINVAL;
> + if (led->chip->leds_active & BIT(sources[i]))
> + return -EINVAL;
> + led->chip->leds_active |= BIT(sources[i]);
> + }
> +
> + /* If both channels are specified in 'led-sources', joint flash output mode is used */
> + led->led_id = num == 2 ? SY7802_LED_JOINT : sources[0];
> +
> + lcdev->max_brightness = SY7802_TORCH_BRIGHTNESS_MAX;
> + lcdev->brightness_set_blocking = sy7802_torch_brightness_set;
> + lcdev->flags |= LED_DEV_CAP_FLASH;
> +
> + flash->ops = &sy7802_flash_ops;
> +
> + sy7802_init_flash_brightness(flash);
> + sy7802_init_flash_timeout(flash);
> +
> + return 0;
> +}
> +
> +static int sy7802_chip_check(struct sy7802 *chip)
> +{
> + struct device *dev = chip->dev;
> + u32 chipid;
> + int ret;
> +
> + ret = regmap_read(chip->regmap, SY7802_REG_DEV_ID, &chipid);
> + if (ret)
> + return dev_err_probe(dev, ret, "Failed to read chip ID\n");
> +
> + if (chipid != SY7802_CHIP_ID)
> + return dev_err_probe(dev, -ENODEV, "Unsupported chip detected: %x\n", chipid);
> +
> + return 0;
> +}
> +
> +static void sy7802_enable(struct sy7802 *chip)
> +{
> + gpiod_set_value_cansleep(chip->enable_gpio, 1);
> + usleep_range(200, 300);
> +}
> +
> +static void sy7802_disable(struct sy7802 *chip)
> +{
> + gpiod_set_value_cansleep(chip->enable_gpio, 0);
> +}
> +
> +static int sy7802_probe_dt(struct sy7802 *chip)
> +{
> + struct device_node *np = dev_of_node(chip->dev);
> + int child_num;
> + int ret;
> +
> + regmap_write(chip->regmap, SY7802_REG_ENABLE, SY7802_MODE_OFF);
> + regmap_write(chip->regmap, SY7802_REG_TORCH_BRIGHTNESS, LED_OFF);
> +
> + child_num = 0;
> + for_each_available_child_of_node_scoped(np, child) {
> + struct sy7802_led *led = chip->leds + child_num;
> +
> + led->chip = chip;
> + led->led_id = child_num;
> +
> + ret = sy7802_init_flash_properties(chip->dev, led, child);
> + if (ret)
> + return ret;
> +
> + ret = sy7802_led_register(chip->dev, led, child);
> + if (ret)
> + return ret;
> +
> + child_num++;
> + }
> + return 0;
> +}
> +
> +static void sy7802_chip_disable_action(void *data)
> +{
> + struct sy7802 *chip = data;
> +
> + sy7802_disable(chip);
> +}
> +
> +static void sy7802_regulator_disable_action(void *data)
> +{
> + struct sy7802 *chip = data;
> +
> + regulator_disable(chip->vin_regulator);
> +}
> +
> +static const struct regmap_config sy7802_regmap_config = {
> + .reg_bits = 8,
> + .val_bits = 8,
> + .max_register = 0xff,
> + .cache_type = REGCACHE_MAPLE,
> + .reg_defaults = sy7802_regmap_defs,
> + .num_reg_defaults = ARRAY_SIZE(sy7802_regmap_defs),
> +};
> +
> +static int sy7802_probe(struct i2c_client *client)
> +{
> + struct device *dev = &client->dev;
> + struct sy7802 *chip;
> + size_t count;
> + int ret;
> +
> + count = device_get_child_node_count(dev);
> + if (!count || count > SY7802_MAX_LEDS)
> + return dev_err_probe(dev, -EINVAL, "Invalid amount of LED nodes %zu\n", count);
> +
> + chip = devm_kzalloc(dev, struct_size(chip, leds, count), GFP_KERNEL);
> + if (!chip)
> + return -ENOMEM;
> +
> + chip->num_leds = count;
> +
> + chip->dev = dev;
> + i2c_set_clientdata(client, chip);
> +
> + chip->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
> + ret = PTR_ERR_OR_ZERO(chip->enable_gpio);
> + if (ret)
> + return dev_err_probe(dev, ret, "Failed to request enable gpio\n");
> +
> + chip->vin_regulator = devm_regulator_get(dev, "vin");
> + ret = PTR_ERR_OR_ZERO(chip->vin_regulator);
> + if (ret)
> + return dev_err_probe(dev, ret, "Failed to request regulator\n");
> +
> + ret = regulator_enable(chip->vin_regulator);
> + if (ret)
> + return dev_err_probe(dev, ret, "Failed to enable regulator\n");
> +
> + ret = devm_add_action_or_reset(dev, sy7802_regulator_disable_action, chip);
> + if (ret)
> + return ret;
> +
> + ret = devm_mutex_init(dev, &chip->mutex);
> + if (ret)
> + return ret;
> +
> + mutex_lock(&chip->mutex);
> +
> + chip->regmap = devm_regmap_init_i2c(client, &sy7802_regmap_config);
> + if (IS_ERR(chip->regmap)) {
> + ret = PTR_ERR(chip->regmap);
> + dev_err_probe(dev, ret, "Failed to allocate register map\n");
> + goto error;
> + }
> +
> + ret = sy7802_probe_dt(chip);
> + if (ret < 0)
> + goto error;
> +
> + sy7802_enable(chip);
> +
> + ret = devm_add_action_or_reset(dev, sy7802_chip_disable_action, chip);
> + if (ret)
> + goto error;
> +
> + ret = sy7802_chip_check(chip);
> +
> +error:
> + mutex_unlock(&chip->mutex);
> + return ret;
> +}
> +
> +static const struct of_device_id __maybe_unused sy7802_leds_match[] = {
> + { .compatible = "silergy,sy7802", },
> + {}
> +};
> +
Remove this line.
> +MODULE_DEVICE_TABLE(of, sy7802_leds_match);
> +
> +static struct i2c_driver sy7802_driver = {
> + .driver = {
> + .name = "sy7802",
> + .of_match_table = of_match_ptr(sy7802_leds_match),
> + },
> + .probe = sy7802_probe,
> +};
> +
Remove this line.
> +module_i2c_driver(sy7802_driver);
> +
> +MODULE_AUTHOR("André Apitzsch <git@...tzsch.eu>");
> +MODULE_DESCRIPTION("Silergy SY7802 flash LED driver");
> +MODULE_LICENSE("GPL");
>
> --
> 2.45.2
>
>
--
Lee Jones [李琼斯]
Powered by blists - more mailing lists