mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-06 02:50:43 +00:00
![Uwe Kleine-König](/assets/img/avatar_default.png)
The value returned by an i2c driver's remove function is mostly ignored. (Only an error message is printed if the value is non-zero that the error is ignored.) So change the prototype of the remove function to return no value. This way driver authors are not tempted to assume that passing an error to the upper layer is a good idea. All drivers are adapted accordingly. There is no intended change of behaviour, all callbacks were prepared to return 0 before. Reviewed-by: Peter Senna Tschudin <peter.senna@gmail.com> Reviewed-by: Jeremy Kerr <jk@codeconstruct.com.au> Reviewed-by: Benjamin Mugnier <benjamin.mugnier@foss.st.com> Reviewed-by: Javier Martinez Canillas <javierm@redhat.com> Reviewed-by: Crt Mori <cmo@melexis.com> Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com> Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> Acked-by: Marek Behún <kabel@kernel.org> # for leds-turris-omnia Acked-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Reviewed-by: Petr Machata <petrm@nvidia.com> # for mlxsw Reviewed-by: Maximilian Luz <luzmaximilian@gmail.com> # for surface3_power Acked-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com> # for bmc150-accel-i2c + kxcjk-1013 Reviewed-by: Hans Verkuil <hverkuil-cisco@xs4all.nl> # for media/* + staging/media/* Acked-by: Miguel Ojeda <ojeda@kernel.org> # for auxdisplay/ht16k33 + auxdisplay/lcd2s Reviewed-by: Luca Ceresoli <luca.ceresoli@bootlin.com> # for versaclock5 Reviewed-by: Ajay Gupta <ajayg@nvidia.com> # for ucsi_ccg Acked-by: Jonathan Cameron <Jonathan.Cameron@huawei.com> # for iio Acked-by: Peter Rosin <peda@axentia.se> # for i2c-mux-*, max9860 Acked-by: Adrien Grassein <adrien.grassein@gmail.com> # for lontium-lt8912b Reviewed-by: Jean Delvare <jdelvare@suse.de> # for hwmon, i2c-core and i2c/muxes Acked-by: Corey Minyard <cminyard@mvista.com> # for IPMI Reviewed-by: Vladimir Oltean <olteanv@gmail.com> Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com> Acked-by: Sebastian Reichel <sebastian.reichel@collabora.com> # for drivers/power Acked-by: Krzysztof Hałasa <khalasa@piap.pl> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de> Signed-off-by: Wolfram Sang <wsa@kernel.org>
433 lines
9.3 KiB
C
433 lines
9.3 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
// Driver for Awinic AW2013 3-channel LED driver
|
|
|
|
#include <linux/i2c.h>
|
|
#include <linux/leds.h>
|
|
#include <linux/module.h>
|
|
#include <linux/regulator/consumer.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/of.h>
|
|
#include <linux/regmap.h>
|
|
|
|
#define AW2013_MAX_LEDS 3
|
|
|
|
/* Reset and ID register */
|
|
#define AW2013_RSTR 0x00
|
|
#define AW2013_RSTR_RESET 0x55
|
|
#define AW2013_RSTR_CHIP_ID 0x33
|
|
|
|
/* Global control register */
|
|
#define AW2013_GCR 0x01
|
|
#define AW2013_GCR_ENABLE BIT(0)
|
|
|
|
/* LED channel enable register */
|
|
#define AW2013_LCTR 0x30
|
|
#define AW2013_LCTR_LE(x) BIT((x))
|
|
|
|
/* LED channel control registers */
|
|
#define AW2013_LCFG(x) (0x31 + (x))
|
|
#define AW2013_LCFG_IMAX_MASK (BIT(0) | BIT(1)) // Should be 0-3
|
|
#define AW2013_LCFG_MD BIT(4)
|
|
#define AW2013_LCFG_FI BIT(5)
|
|
#define AW2013_LCFG_FO BIT(6)
|
|
|
|
/* LED channel PWM registers */
|
|
#define AW2013_REG_PWM(x) (0x34 + (x))
|
|
|
|
/* LED channel timing registers */
|
|
#define AW2013_LEDT0(x) (0x37 + (x) * 3)
|
|
#define AW2013_LEDT0_T1(x) ((x) << 4) // Should be 0-7
|
|
#define AW2013_LEDT0_T2(x) (x) // Should be 0-5
|
|
|
|
#define AW2013_LEDT1(x) (0x38 + (x) * 3)
|
|
#define AW2013_LEDT1_T3(x) ((x) << 4) // Should be 0-7
|
|
#define AW2013_LEDT1_T4(x) (x) // Should be 0-7
|
|
|
|
#define AW2013_LEDT2(x) (0x39 + (x) * 3)
|
|
#define AW2013_LEDT2_T0(x) ((x) << 4) // Should be 0-8
|
|
#define AW2013_LEDT2_REPEAT(x) (x) // Should be 0-15
|
|
|
|
#define AW2013_REG_MAX 0x77
|
|
|
|
#define AW2013_TIME_STEP 130 /* ms */
|
|
|
|
struct aw2013;
|
|
|
|
struct aw2013_led {
|
|
struct aw2013 *chip;
|
|
struct led_classdev cdev;
|
|
u32 num;
|
|
unsigned int imax;
|
|
};
|
|
|
|
struct aw2013 {
|
|
struct mutex mutex; /* held when writing to registers */
|
|
struct regulator *vcc_regulator;
|
|
struct i2c_client *client;
|
|
struct aw2013_led leds[AW2013_MAX_LEDS];
|
|
struct regmap *regmap;
|
|
int num_leds;
|
|
bool enabled;
|
|
};
|
|
|
|
static int aw2013_chip_init(struct aw2013 *chip)
|
|
{
|
|
int i, ret;
|
|
|
|
ret = regmap_write(chip->regmap, AW2013_GCR, AW2013_GCR_ENABLE);
|
|
if (ret) {
|
|
dev_err(&chip->client->dev, "Failed to enable the chip: %d\n",
|
|
ret);
|
|
return ret;
|
|
}
|
|
|
|
for (i = 0; i < chip->num_leds; i++) {
|
|
ret = regmap_update_bits(chip->regmap,
|
|
AW2013_LCFG(chip->leds[i].num),
|
|
AW2013_LCFG_IMAX_MASK,
|
|
chip->leds[i].imax);
|
|
if (ret) {
|
|
dev_err(&chip->client->dev,
|
|
"Failed to set maximum current for led %d: %d\n",
|
|
chip->leds[i].num, ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aw2013_chip_disable(struct aw2013 *chip)
|
|
{
|
|
int ret;
|
|
|
|
if (!chip->enabled)
|
|
return;
|
|
|
|
regmap_write(chip->regmap, AW2013_GCR, 0);
|
|
|
|
ret = regulator_disable(chip->vcc_regulator);
|
|
if (ret) {
|
|
dev_err(&chip->client->dev,
|
|
"Failed to disable regulator: %d\n", ret);
|
|
return;
|
|
}
|
|
|
|
chip->enabled = false;
|
|
}
|
|
|
|
static int aw2013_chip_enable(struct aw2013 *chip)
|
|
{
|
|
int ret;
|
|
|
|
if (chip->enabled)
|
|
return 0;
|
|
|
|
ret = regulator_enable(chip->vcc_regulator);
|
|
if (ret) {
|
|
dev_err(&chip->client->dev,
|
|
"Failed to enable regulator: %d\n", ret);
|
|
return ret;
|
|
}
|
|
chip->enabled = true;
|
|
|
|
ret = aw2013_chip_init(chip);
|
|
if (ret)
|
|
aw2013_chip_disable(chip);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static bool aw2013_chip_in_use(struct aw2013 *chip)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < chip->num_leds; i++)
|
|
if (chip->leds[i].cdev.brightness)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static int aw2013_brightness_set(struct led_classdev *cdev,
|
|
enum led_brightness brightness)
|
|
{
|
|
struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
|
|
int ret, num;
|
|
|
|
mutex_lock(&led->chip->mutex);
|
|
|
|
if (aw2013_chip_in_use(led->chip)) {
|
|
ret = aw2013_chip_enable(led->chip);
|
|
if (ret)
|
|
goto error;
|
|
}
|
|
|
|
num = led->num;
|
|
|
|
ret = regmap_write(led->chip->regmap, AW2013_REG_PWM(num), brightness);
|
|
if (ret)
|
|
goto error;
|
|
|
|
if (brightness) {
|
|
ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
|
|
AW2013_LCTR_LE(num), 0xFF);
|
|
} else {
|
|
ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
|
|
AW2013_LCTR_LE(num), 0);
|
|
if (ret)
|
|
goto error;
|
|
ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
|
|
AW2013_LCFG_MD, 0);
|
|
}
|
|
if (ret)
|
|
goto error;
|
|
|
|
if (!aw2013_chip_in_use(led->chip))
|
|
aw2013_chip_disable(led->chip);
|
|
|
|
error:
|
|
mutex_unlock(&led->chip->mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int aw2013_blink_set(struct led_classdev *cdev,
|
|
unsigned long *delay_on, unsigned long *delay_off)
|
|
{
|
|
struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
|
|
int ret, num = led->num;
|
|
unsigned long off = 0, on = 0;
|
|
|
|
/* If no blink specified, default to 1 Hz. */
|
|
if (!*delay_off && !*delay_on) {
|
|
*delay_off = 500;
|
|
*delay_on = 500;
|
|
}
|
|
|
|
if (!led->cdev.brightness) {
|
|
led->cdev.brightness = LED_FULL;
|
|
ret = aw2013_brightness_set(&led->cdev, led->cdev.brightness);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
/* Never on - just set to off */
|
|
if (!*delay_on) {
|
|
led->cdev.brightness = LED_OFF;
|
|
return aw2013_brightness_set(&led->cdev, LED_OFF);
|
|
}
|
|
|
|
mutex_lock(&led->chip->mutex);
|
|
|
|
/* Never off - brightness is already set, disable blinking */
|
|
if (!*delay_off) {
|
|
ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
|
|
AW2013_LCFG_MD, 0);
|
|
goto out;
|
|
}
|
|
|
|
/* Convert into values the HW will understand. */
|
|
off = min(5, ilog2((*delay_off - 1) / AW2013_TIME_STEP) + 1);
|
|
on = min(7, ilog2((*delay_on - 1) / AW2013_TIME_STEP) + 1);
|
|
|
|
*delay_off = BIT(off) * AW2013_TIME_STEP;
|
|
*delay_on = BIT(on) * AW2013_TIME_STEP;
|
|
|
|
/* Set timings */
|
|
ret = regmap_write(led->chip->regmap,
|
|
AW2013_LEDT0(num), AW2013_LEDT0_T2(on));
|
|
if (ret)
|
|
goto out;
|
|
ret = regmap_write(led->chip->regmap,
|
|
AW2013_LEDT1(num), AW2013_LEDT1_T4(off));
|
|
if (ret)
|
|
goto out;
|
|
|
|
/* Finally, enable the LED */
|
|
ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
|
|
AW2013_LCFG_MD, 0xFF);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
|
|
AW2013_LCTR_LE(num), 0xFF);
|
|
|
|
out:
|
|
mutex_unlock(&led->chip->mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int aw2013_probe_dt(struct aw2013 *chip)
|
|
{
|
|
struct device_node *np = dev_of_node(&chip->client->dev), *child;
|
|
int count, ret = 0, i = 0;
|
|
struct aw2013_led *led;
|
|
|
|
count = of_get_available_child_count(np);
|
|
if (!count || count > AW2013_MAX_LEDS)
|
|
return -EINVAL;
|
|
|
|
regmap_write(chip->regmap, AW2013_RSTR, AW2013_RSTR_RESET);
|
|
|
|
for_each_available_child_of_node(np, child) {
|
|
struct led_init_data init_data = {};
|
|
u32 source;
|
|
u32 imax;
|
|
|
|
ret = of_property_read_u32(child, "reg", &source);
|
|
if (ret != 0 || source >= AW2013_MAX_LEDS) {
|
|
dev_err(&chip->client->dev,
|
|
"Couldn't read LED address: %d\n", ret);
|
|
count--;
|
|
continue;
|
|
}
|
|
|
|
led = &chip->leds[i];
|
|
led->num = source;
|
|
led->chip = chip;
|
|
init_data.fwnode = of_fwnode_handle(child);
|
|
|
|
if (!of_property_read_u32(child, "led-max-microamp", &imax)) {
|
|
led->imax = min_t(u32, imax / 5000, 3);
|
|
} else {
|
|
led->imax = 1; // 5mA
|
|
dev_info(&chip->client->dev,
|
|
"DT property led-max-microamp is missing\n");
|
|
}
|
|
|
|
led->cdev.brightness_set_blocking = aw2013_brightness_set;
|
|
led->cdev.blink_set = aw2013_blink_set;
|
|
|
|
ret = devm_led_classdev_register_ext(&chip->client->dev,
|
|
&led->cdev, &init_data);
|
|
if (ret < 0) {
|
|
of_node_put(child);
|
|
return ret;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
if (!count)
|
|
return -EINVAL;
|
|
|
|
chip->num_leds = i;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct regmap_config aw2013_regmap_config = {
|
|
.reg_bits = 8,
|
|
.val_bits = 8,
|
|
.max_register = AW2013_REG_MAX,
|
|
};
|
|
|
|
static int aw2013_probe(struct i2c_client *client)
|
|
{
|
|
struct aw2013 *chip;
|
|
int ret;
|
|
unsigned int chipid;
|
|
|
|
chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
|
|
if (!chip)
|
|
return -ENOMEM;
|
|
|
|
mutex_init(&chip->mutex);
|
|
mutex_lock(&chip->mutex);
|
|
|
|
chip->client = client;
|
|
i2c_set_clientdata(client, chip);
|
|
|
|
chip->regmap = devm_regmap_init_i2c(client, &aw2013_regmap_config);
|
|
if (IS_ERR(chip->regmap)) {
|
|
ret = PTR_ERR(chip->regmap);
|
|
dev_err(&client->dev, "Failed to allocate register map: %d\n",
|
|
ret);
|
|
goto error;
|
|
}
|
|
|
|
chip->vcc_regulator = devm_regulator_get(&client->dev, "vcc");
|
|
ret = PTR_ERR_OR_ZERO(chip->vcc_regulator);
|
|
if (ret) {
|
|
if (ret != -EPROBE_DEFER)
|
|
dev_err(&client->dev,
|
|
"Failed to request regulator: %d\n", ret);
|
|
goto error;
|
|
}
|
|
|
|
ret = regulator_enable(chip->vcc_regulator);
|
|
if (ret) {
|
|
dev_err(&client->dev,
|
|
"Failed to enable regulator: %d\n", ret);
|
|
goto error;
|
|
}
|
|
|
|
ret = regmap_read(chip->regmap, AW2013_RSTR, &chipid);
|
|
if (ret) {
|
|
dev_err(&client->dev, "Failed to read chip ID: %d\n",
|
|
ret);
|
|
goto error_reg;
|
|
}
|
|
|
|
if (chipid != AW2013_RSTR_CHIP_ID) {
|
|
dev_err(&client->dev, "Chip reported wrong ID: %x\n",
|
|
chipid);
|
|
ret = -ENODEV;
|
|
goto error_reg;
|
|
}
|
|
|
|
ret = aw2013_probe_dt(chip);
|
|
if (ret < 0)
|
|
goto error_reg;
|
|
|
|
ret = regulator_disable(chip->vcc_regulator);
|
|
if (ret) {
|
|
dev_err(&client->dev,
|
|
"Failed to disable regulator: %d\n", ret);
|
|
goto error;
|
|
}
|
|
|
|
mutex_unlock(&chip->mutex);
|
|
|
|
return 0;
|
|
|
|
error_reg:
|
|
regulator_disable(chip->vcc_regulator);
|
|
|
|
error:
|
|
mutex_destroy(&chip->mutex);
|
|
return ret;
|
|
}
|
|
|
|
static void aw2013_remove(struct i2c_client *client)
|
|
{
|
|
struct aw2013 *chip = i2c_get_clientdata(client);
|
|
|
|
aw2013_chip_disable(chip);
|
|
|
|
mutex_destroy(&chip->mutex);
|
|
}
|
|
|
|
static const struct of_device_id aw2013_match_table[] = {
|
|
{ .compatible = "awinic,aw2013", },
|
|
{ /* sentinel */ },
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, aw2013_match_table);
|
|
|
|
static struct i2c_driver aw2013_driver = {
|
|
.driver = {
|
|
.name = "leds-aw2013",
|
|
.of_match_table = of_match_ptr(aw2013_match_table),
|
|
},
|
|
.probe_new = aw2013_probe,
|
|
.remove = aw2013_remove,
|
|
};
|
|
|
|
module_i2c_driver(aw2013_driver);
|
|
|
|
MODULE_AUTHOR("Nikita Travkin <nikitos.tr@gmail.com>");
|
|
MODULE_DESCRIPTION("AW2013 LED driver");
|
|
MODULE_LICENSE("GPL v2");
|