github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-27 09:36:22 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

backlight: Add max25014atg backlight

Browse Source 
The Maxim MAX25014 is a 4-channel automotive grade backlight driver IC
with integrated boost controller.

Signed-off-by: Maud Spierings <maudspierings@gocontroll.com>
Reviewed-by: Daniel Thompson (RISCstar) <danielt@kernel.org>
Link: https://patch.msgid.link/20260407-max25014-v8-2-14eac7ed673a@gocontroll.com
Signed-off-by: Lee Jones <lee@kernel.org>
This commit is contained in:
Maud Spierings 2026-04-07 16:41:43 +02:00 committed by Lee Jones
parent 5fcbbedec9
commit 3014ad47cf
4 changed files with 386 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
MAINTAINERS
View File

@ -15677,6 +15677,7 @@ MAX25014 BACKLIGHT DRIVER
M: Maud Spierings <maudspierings@gocontroll.com>
S: Maintained
F: Documentation/devicetree/bindings/leds/backlight/maxim,max25014.yaml
F: drivers/video/backlight/max25014.c
MAX31335 RTC DRIVER
M: Antoniu Miclaus <antoniu.miclaus@analog.com>

7
drivers/video/backlight/Kconfig
View File

@ -282,6 +282,13 @@ config BACKLIGHT_DA9052
help
Enable the Backlight Driver for DA9052-BC and DA9053-AA/Bx PMICs.
config BACKLIGHT_MAX25014
tristate "Backlight driver for Maxim MAX25014"
depends on I2C
select REGMAP_I2C
help
If you are using a MAX25014 chip as a backlight driver say Y to enable it.
config BACKLIGHT_MAX8925
tristate "Backlight driver for MAX8925"
depends on MFD_MAX8925

1
drivers/video/backlight/Makefile
View File

@ -47,6 +47,7 @@ obj-$(CONFIG_BACKLIGHT_LOCOMO) += locomolcd.o
obj-$(CONFIG_BACKLIGHT_LP855X) += lp855x_bl.o
obj-$(CONFIG_BACKLIGHT_LP8788) += lp8788_bl.o
obj-$(CONFIG_BACKLIGHT_LV5207LP) += lv5207lp.o
obj-$(CONFIG_BACKLIGHT_MAX25014) += max25014.o
obj-$(CONFIG_BACKLIGHT_MAX8925) += max8925_bl.o
obj-$(CONFIG_BACKLIGHT_MP3309C) += mp3309c.o
obj-$(CONFIG_BACKLIGHT_MT6370) += mt6370-backlight.o

377
drivers/video/backlight/max25014.c Normal file
View File

@ -0,0 +1,377 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Backlight driver for Maxim MAX25014
*
* Copyright (C) 2025 GOcontroll B.V.
* Author: Maud Spierings <maudspierings@gocontroll.com>
*/
#include <linux/backlight.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#define MAX25014_ISET_DEFAULT_100 11
#define MAX_BRIGHTNESS 100
#define MIN_BRIGHTNESS 0
#define TON_MAX 130720 /* @153Hz */
#define TON_STEP 1307 /* @153Hz */
#define TON_MIN 0
#define MAX25014_DEV_ID 0x00
#define MAX25014_REV_ID 0x01
#define MAX25014_ISET 0x02
#define MAX25014_IMODE 0x03
#define MAX25014_TON1H 0x04
#define MAX25014_TON1L 0x05
#define MAX25014_TON2H 0x06
#define MAX25014_TON2L 0x07
#define MAX25014_TON3H 0x08
#define MAX25014_TON3L 0x09
#define MAX25014_TON4H 0x0A
#define MAX25014_TON4L 0x0B
#define MAX25014_TON_1_4_LSB 0x0C
#define MAX25014_SETTING 0x12
#define MAX25014_DISABLE 0x13
#define MAX25014_BSTMON 0x14
#define MAX25014_IOUT1 0x15
#define MAX25014_IOUT2 0x16
#define MAX25014_IOUT3 0x17
#define MAX25014_IOUT4 0x18
#define MAX25014_OPEN 0x1B
#define MAX25014_SHORTGND 0x1C
#define MAX25014_SHORTED_LED 0x1D
#define MAX25014_MASK 0x1E
#define MAX25014_DIAG 0x1F
#define MAX25014_ISET_ENA BIT(5)
#define MAX25014_ISET_PSEN BIT(4)
#define MAX25014_IMODE_HDIM BIT(2)
#define MAX25014_SETTING_FPWM GENMASK(6, 4)
#define MAX25014_DISABLE_DIS_MASK GENMASK(3, 0)
#define MAX25014_DIAG_OT BIT(0)
#define MAX25014_DIAG_OTW BIT(1)
#define MAX25014_DIAG_HW_RST BIT(2)
#define MAX25014_DIAG_BSTOV BIT(3)
#define MAX25014_DIAG_BSTUV BIT(4)
#define MAX25014_DIAG_IREFOOR BIT(5)
struct max25014 {
struct i2c_client *client;
struct backlight_device *bl;
struct regmap *regmap;
struct gpio_desc *enable;
uint32_t iset;
uint8_t strings_mask;
};
static const struct regmap_config max25014_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = MAX25014_DIAG,
};
static int max25014_initial_power_state(struct max25014 *maxim)
{
uint32_t val;
int ret;
ret = regmap_read(maxim->regmap, MAX25014_ISET, &val);
if (ret)
return ret;
return val & MAX25014_ISET_ENA ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF;
}
static int max25014_check_errors(struct max25014 *maxim)
{
uint32_t val;
uint8_t i;
int ret;
ret = regmap_read(maxim->regmap, MAX25014_OPEN, &val);
if (ret)
return ret;
if (val) {
dev_err(&maxim->client->dev, "Open led strings detected on:\n");
for (i = 0; i < 4; i++) {
if (val & 1 << i)
dev_err(&maxim->client->dev, "string %d\n", i + 1);
}
return -EIO;
}
ret = regmap_read(maxim->regmap, MAX25014_SHORTGND, &val);
if (ret)
return ret;
if (val) {
dev_err(&maxim->client->dev, "Short to ground detected on:\n");
for (i = 0; i < 4; i++) {
if (val & 1 << i)
dev_err(&maxim->client->dev, "string %d\n", i + 1);
}
return -EIO;
}
ret = regmap_read(maxim->regmap, MAX25014_SHORTED_LED, &val);
if (ret)
return ret;
if (val) {
dev_err(&maxim->client->dev, "Shorted led detected on:\n");
for (i = 0; i < 4; i++) {
if (val & 1 << i)
dev_err(&maxim->client->dev, "string %d\n", i + 1);
}
return -EIO;
}
ret = regmap_read(maxim->regmap, MAX25014_DIAG, &val);
if (ret)
return ret;
/*
* The HW_RST bit always starts at 1 after power up.
* It is reset on first read, does not indicate an error.
*/
if (val && val != MAX25014_DIAG_HW_RST) {
if (val & MAX25014_DIAG_OT)
dev_err(&maxim->client->dev,
"Overtemperature shutdown\n");
if (val & MAX25014_DIAG_OTW)
dev_err(&maxim->client->dev,
"Chip is getting too hot (>125C)\n");
if (val & MAX25014_DIAG_BSTOV)
dev_err(&maxim->client->dev,
"Boost converter overvoltage\n");
if (val & MAX25014_DIAG_BSTUV)
dev_err(&maxim->client->dev,
"Boost converter undervoltage\n");
if (val & MAX25014_DIAG_IREFOOR)
dev_err(&maxim->client->dev, "IREF out of range\n");
return -EIO;
}
return 0;
}
/*
* 1. disable unused strings
* 2. set dim mode
* 3. set setting register
* 4. enable the backlight
*/
static int max25014_configure(struct max25014 *maxim, int initial_state)
{
uint32_t val;
int ret;
ret = regmap_read(maxim->regmap, MAX25014_DISABLE, &val);
if (ret)
return ret;
/*
* Strings can only be disabled when MAX25014_ISET_ENA == 0, check if
* it needs to be changed at all to prevent the backlight flashing when
* it is configured correctly by the bootloader
*/
if (!((val & MAX25014_DISABLE_DIS_MASK) == maxim->strings_mask)) {
if (initial_state == BACKLIGHT_POWER_ON) {
ret = regmap_write(maxim->regmap, MAX25014_ISET, 0);
if (ret)
return ret;
}
ret = regmap_write(maxim->regmap, MAX25014_DISABLE, maxim->strings_mask);
if (ret)
return ret;
}
ret = regmap_write(maxim->regmap, MAX25014_IMODE, MAX25014_IMODE_HDIM);
if (ret)
return ret;
ret = regmap_read(maxim->regmap, MAX25014_SETTING, &val);
if (ret)
return ret;
ret = regmap_write(maxim->regmap, MAX25014_SETTING,
val & ~MAX25014_SETTING_FPWM);
if (ret)
return ret;
return regmap_write(maxim->regmap, MAX25014_ISET,
maxim->iset | MAX25014_ISET_ENA |
MAX25014_ISET_PSEN);
}
static int max25014_update_status(struct backlight_device *bl_dev)
{
struct max25014 *maxim = bl_get_data(bl_dev);
uint32_t reg;
int ret;
reg = TON_STEP * backlight_get_brightness(bl_dev);
/*
* 18 bit number lowest, 2 bits in first register,
* next lowest 8 in the L register, next 8 in the H register
* Seemingly setting the strength of only one string controls all of
* them, individual settings don't affect the outcome.
*/
ret = regmap_write(maxim->regmap, MAX25014_TON_1_4_LSB, reg & 0b00000011);
if (ret != 0)
return ret;
ret = regmap_write(maxim->regmap, MAX25014_TON1L, (reg >> 2) & 0b11111111);
if (ret != 0)
return ret;
return regmap_write(maxim->regmap, MAX25014_TON1H, (reg >> 10) & 0b11111111);
}
static const struct backlight_ops max25014_bl_ops = {
.options = BL_CORE_SUSPENDRESUME,
.update_status = max25014_update_status,
};
static int max25014_parse_dt(struct max25014 *maxim,
uint32_t *initial_brightness)
{
struct device *dev = &maxim->client->dev;
struct device_node *node = dev->of_node;
uint32_t strings[4];
int res, i;
res = of_property_count_u32_elems(node, "maxim,strings");
if (res == 4) {
of_property_read_u32_array(node, "maxim,strings", strings, 4);
for (i = 0; i < 4; i++) {
if (strings[i] == 0)
maxim->strings_mask |= 1 << i;
}
} else {
maxim->strings_mask = 0;
}
*initial_brightness = 50U;
of_property_read_u32(node, "default-brightness", initial_brightness);
maxim->iset = MAX25014_ISET_DEFAULT_100;
of_property_read_u32(node, "maxim,iset", &maxim->iset);
if (maxim->iset > 15)
return dev_err_probe(dev, -EINVAL,
"Invalid iset, should be a value from 0-15, entered was %d\n",
maxim->iset);
if (*initial_brightness > 100)
return dev_err_probe(dev, -EINVAL,
"Invalid initial brightness, should be a value from 0-100, entered was %d\n",
*initial_brightness);
return 0;
}
static int max25014_probe(struct i2c_client *cl)
{
const struct i2c_device_id *id = i2c_client_get_device_id(cl);
struct backlight_properties props;
uint32_t initial_brightness = 50;
struct backlight_device *bl;
struct max25014 *maxim;
int ret;
maxim = devm_kzalloc(&cl->dev, sizeof(struct max25014), GFP_KERNEL);
if (!maxim)
return -ENOMEM;
maxim->client = cl;
ret = max25014_parse_dt(maxim, &initial_brightness);
if (ret)
return ret;
ret = devm_regulator_get_enable(&maxim->client->dev, "power");
if (ret)
return dev_err_probe(&maxim->client->dev, ret,
"failed to get power-supply");
maxim->enable = devm_gpiod_get_optional(&maxim->client->dev, "enable",
GPIOD_OUT_HIGH);
if (IS_ERR(maxim->enable))
return dev_err_probe(&maxim->client->dev, PTR_ERR(maxim->enable),
"failed to get enable gpio\n");
/* Datasheet Electrical Characteristics tSTARTUP 2ms */
fsleep(2000);
maxim->regmap = devm_regmap_init_i2c(cl, &max25014_regmap_config);
if (IS_ERR(maxim->regmap))
return dev_err_probe(&maxim->client->dev, PTR_ERR(maxim->regmap),
"failed to initialize the i2c regmap\n");
i2c_set_clientdata(cl, maxim);
ret = max25014_check_errors(maxim);
if (ret) /* error is already reported in the above function */
return ret;
ret = max25014_initial_power_state(maxim);
if (ret < 0)
return dev_err_probe(&maxim->client->dev, ret, "Could not get enabled state\n");
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_PLATFORM;
props.max_brightness = MAX_BRIGHTNESS;
props.brightness = initial_brightness;
props.scale = BACKLIGHT_SCALE_LINEAR;
props.power = ret;
ret = max25014_configure(maxim, ret);
if (ret)
return dev_err_probe(&maxim->client->dev, ret, "device config error");
bl = devm_backlight_device_register(&maxim->client->dev, id->name,
&maxim->client->dev, maxim,
&max25014_bl_ops, &props);
if (IS_ERR(bl))
return dev_err_probe(&maxim->client->dev, PTR_ERR(bl),
"failed to register backlight\n");
maxim->bl = bl;
backlight_update_status(maxim->bl);
return 0;
}
static void max25014_remove(struct i2c_client *cl)
{
struct max25014 *maxim = i2c_get_clientdata(cl);
backlight_device_set_brightness(maxim->bl, 0);
gpiod_set_value_cansleep(maxim->enable, 0);
}
static const struct of_device_id max25014_dt_ids[] = {
{ .compatible = "maxim,max25014", },
{ }
};
MODULE_DEVICE_TABLE(of, max25014_dt_ids);
static const struct i2c_device_id max25014_ids[] = {
{ "max25014" },
{ }
};
MODULE_DEVICE_TABLE(i2c, max25014_ids);
static struct i2c_driver max25014_driver = {
.driver = {
.name = KBUILD_MODNAME,
.of_match_table = of_match_ptr(max25014_dt_ids),
},
.probe = max25014_probe,
.remove = max25014_remove,
.id_table = max25014_ids,
};
module_i2c_driver(max25014_driver);
MODULE_DESCRIPTION("Maxim MAX25014 backlight driver");
MODULE_AUTHOR("Maud Spierings <maudspierings@gocontroll.com>");
MODULE_LICENSE("GPL");