mp3309c.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Driver for MPS MP3309C White LED driver with I2C interface
  4 *
  5 * This driver support both analog (by I2C commands) and PWM dimming control
  6 * modes.
  7 *
  8 * Copyright (C) 2023 ASEM Srl
  9 * Author: Flavio Suligoi <f.suligoi@asem.it>
 10 *
 11 * Based on pwm_bl.c
 12 */
 13
 14#include <linux/backlight.h>
 15#include <linux/delay.h>
 16#include <linux/gpio/consumer.h>
 17#include <linux/i2c.h>
 18#include <linux/mod_devicetable.h>
 19#include <linux/property.h>
 20#include <linux/pwm.h>
 21#include <linux/regmap.h>
 22
 23#define REG_I2C_0	0x00
 24#define REG_I2C_1	0x01
 25
 26#define REG_I2C_0_EN	0x80
 27#define REG_I2C_0_D0	0x40
 28#define REG_I2C_0_D1	0x20
 29#define REG_I2C_0_D2	0x10
 30#define REG_I2C_0_D3	0x08
 31#define REG_I2C_0_D4	0x04
 32#define REG_I2C_0_RSRV1	0x02
 33#define REG_I2C_0_RSRV2	0x01
 34
 35#define REG_I2C_1_RSRV1	0x80
 36#define REG_I2C_1_DIMS	0x40
 37#define REG_I2C_1_SYNC	0x20
 38#define REG_I2C_1_OVP0	0x10
 39#define REG_I2C_1_OVP1	0x08
 40#define REG_I2C_1_VOS	0x04
 41#define REG_I2C_1_LEDO	0x02
 42#define REG_I2C_1_OTP	0x01
 43
 44#define ANALOG_I2C_NUM_LEVELS	32		/* 0..31 */
 45#define ANALOG_I2C_REG_MASK	0x7c
 46
 47#define MP3309C_PWM_DEFAULT_NUM_LEVELS	256	/* 0..255 */
 48
 49enum mp3309c_status_value {
 50	FIRST_POWER_ON,
 51	BACKLIGHT_OFF,
 52	BACKLIGHT_ON,
 53};
 54
 55enum mp3309c_dimming_mode_value {
 56	DIMMING_PWM,
 57	DIMMING_ANALOG_I2C,
 58};
 59
 60struct mp3309c_platform_data {
 61	unsigned int max_brightness;
 62	unsigned int default_brightness;
 63	unsigned int *levels;
 64	u8  dimming_mode;
 65	u8  over_voltage_protection;
 66	bool sync_mode;
 67	u8 status;
 68};
 69
 70struct mp3309c_chip {
 71	struct device *dev;
 72	struct mp3309c_platform_data *pdata;
 73	struct backlight_device *bl;
 74	struct gpio_desc *enable_gpio;
 75	struct regmap *regmap;
 76	struct pwm_device *pwmd;
 77};
 78
 79static const struct regmap_config mp3309c_regmap = {
 80	.name = "mp3309c_regmap",
 81	.reg_bits = 8,
 82	.reg_stride = 1,
 83	.val_bits = 8,
 84	.max_register = REG_I2C_1,
 85};
 86
 87static int mp3309c_enable_device(struct mp3309c_chip *chip)
 88{
 89	u8 reg_val;
 90	int ret;
 91
 92	/* I2C register #0 - Device enable */
 93	ret = regmap_update_bits(chip->regmap, REG_I2C_0, REG_I2C_0_EN,
 94				 REG_I2C_0_EN);
 95	if (ret)
 96		return ret;
 97
 98	/*
 99	 * I2C register #1 - Set working mode:
100	 *  - enable/disable synchronous mode
101	 *  - set overvoltage protection (OVP)
102	 */
103	reg_val = 0x00;
104	if (chip->pdata->sync_mode)
105		reg_val |= REG_I2C_1_SYNC;
106	reg_val |= chip->pdata->over_voltage_protection;
107	ret = regmap_write(chip->regmap, REG_I2C_1, reg_val);
108	if (ret)
109		return ret;
110
111	return 0;
112}
113
114static int mp3309c_bl_update_status(struct backlight_device *bl)
115{
116	struct mp3309c_chip *chip = bl_get_data(bl);
117	int brightness = backlight_get_brightness(bl);
118	struct pwm_state pwmstate;
119	unsigned int analog_val, bits_val;
120	int i, ret;
121
122	if (chip->pdata->dimming_mode == DIMMING_PWM) {
123		/*
124		 * PWM control mode
125		 */
126		pwm_get_state(chip->pwmd, &pwmstate);
127		pwm_set_relative_duty_cycle(&pwmstate,
128					    chip->pdata->levels[brightness],
129					    chip->pdata->levels[chip->pdata->max_brightness]);
130		pwmstate.enabled = true;
131		ret = pwm_apply_might_sleep(chip->pwmd, &pwmstate);
132		if (ret)
133			return ret;
134
135		switch (chip->pdata->status) {
136		case FIRST_POWER_ON:
137		case BACKLIGHT_OFF:
138			/*
139			 * After 20ms of low pwm signal level, the chip turns
140			 * off automatically. In this case, before enabling the
141			 * chip again, we must wait about 10ms for pwm signal to
142			 * stabilize.
143			 */
144			if (brightness > 0) {
145				msleep(10);
146				mp3309c_enable_device(chip);
147				chip->pdata->status = BACKLIGHT_ON;
148			} else {
149				chip->pdata->status = BACKLIGHT_OFF;
150			}
151			break;
152		case BACKLIGHT_ON:
153			if (brightness == 0)
154				chip->pdata->status = BACKLIGHT_OFF;
155			break;
156		}
157	} else {
158		/*
159		 * Analog (by I2C command) control mode
160		 *
161		 * The first time, before setting brightness, we must enable the
162		 * device
163		 */
164		if (chip->pdata->status == FIRST_POWER_ON)
165			mp3309c_enable_device(chip);
166
167		/*
168		 * Dimming mode I2C command (fixed dimming range 0..31)
169		 *
170		 * The 5 bits of the dimming analog value D4..D0 is allocated
171		 * in the I2C register #0, in the following way:
172		 *
173		 *     +--+--+--+--+--+--+--+--+
174		 *     |EN|D0|D1|D2|D3|D4|XX|XX|
175		 *     +--+--+--+--+--+--+--+--+
176		 */
177		analog_val = brightness;
178		bits_val = 0;
179		for (i = 0; i <= 5; i++)
180			bits_val += ((analog_val >> i) & 0x01) << (6 - i);
181		ret = regmap_update_bits(chip->regmap, REG_I2C_0,
182					 ANALOG_I2C_REG_MASK, bits_val);
183		if (ret)
184			return ret;
185
186		if (brightness > 0)
187			chip->pdata->status = BACKLIGHT_ON;
188		else
189			chip->pdata->status = BACKLIGHT_OFF;
190	}
191
192	return 0;
193}
194
195static const struct backlight_ops mp3309c_bl_ops = {
196	.update_status = mp3309c_bl_update_status,
197};
198
199static int mp3309c_parse_fwnode(struct mp3309c_chip *chip,
200				struct mp3309c_platform_data *pdata)
201{
202	int ret, i;
203	unsigned int tmp_value;
204	struct device *dev = chip->dev;
205	int num_levels;
206
207	if (!dev_fwnode(dev))
208		return dev_err_probe(dev, -ENODEV, "failed to get firmware node\n");
209
210	/*
211	 * Dimming mode: the MP3309C provides two dimming control mode:
212	 *
213	 * - PWM mode
214	 * - Analog by I2C control mode (default)
215	 *
216	 * I2C control mode is assumed as default but, if the pwms property is
217	 * found in the backlight node, the mode switches to PWM mode.
218	 */
219	pdata->dimming_mode = DIMMING_ANALOG_I2C;
220	if (device_property_present(dev, "pwms")) {
221		chip->pwmd = devm_pwm_get(dev, NULL);
222		if (IS_ERR(chip->pwmd))
223			return dev_err_probe(dev, PTR_ERR(chip->pwmd), "error getting pwm data\n");
224		pdata->dimming_mode = DIMMING_PWM;
225	}
226
227	/*
228	 * In I2C control mode the dimming levels (0..31) are fixed by the
229	 * hardware, while in PWM control mode they can be chosen by the user,
230	 * to allow nonlinear mappings.
231	 */
232	if  (pdata->dimming_mode == DIMMING_ANALOG_I2C) {
233		/*
234		 * Analog (by I2C commands) control mode: fixed 0..31 brightness
235		 * levels
236		 */
237		num_levels = ANALOG_I2C_NUM_LEVELS;
238
239		/* Enable GPIO used in I2C dimming mode only */
240		chip->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_HIGH);
241		if (IS_ERR(chip->enable_gpio))
242			return dev_err_probe(dev, PTR_ERR(chip->enable_gpio),
243					     "error getting enable gpio\n");
244	} else {
245		/*
246		 * PWM control mode: check for brightness level in DT
247		 */
248		if (device_property_present(dev, "brightness-levels")) {
249			/* Read brightness levels from DT */
250			num_levels = device_property_count_u32(dev, "brightness-levels");
251			if (num_levels < 2)
252				return -EINVAL;
253		} else {
254			/* Use default brightness levels */
255			num_levels = MP3309C_PWM_DEFAULT_NUM_LEVELS;
256		}
257	}
258
259	/* Fill brightness levels array */
260	pdata->levels = devm_kcalloc(dev, num_levels, sizeof(*pdata->levels), GFP_KERNEL);
261	if (!pdata->levels)
262		return -ENOMEM;
263	if (device_property_present(dev, "brightness-levels")) {
264		ret = device_property_read_u32_array(dev, "brightness-levels",
265						     pdata->levels, num_levels);
266		if (ret < 0)
267			return ret;
268	} else {
269		for (i = 0; i < num_levels; i++)
270			pdata->levels[i] = i;
271	}
272
273	pdata->max_brightness = num_levels - 1;
274
275	ret = device_property_read_u32(dev, "default-brightness", &pdata->default_brightness);
276	if (ret)
277		pdata->default_brightness = pdata->max_brightness;
278	if (pdata->default_brightness > pdata->max_brightness) {
279		dev_err_probe(dev, -ERANGE, "default brightness exceeds max brightness\n");
280		pdata->default_brightness = pdata->max_brightness;
281	}
282
283	/*
284	 * Over-voltage protection (OVP)
285	 *
286	 * This (optional) property values are:
287	 *
288	 *  - 13.5V
289	 *  - 24V
290	 *  - 35.5V (hardware default setting)
291	 *
292	 * If missing, the default value for OVP is 35.5V
293	 */
294	pdata->over_voltage_protection = REG_I2C_1_OVP1;
295	ret = device_property_read_u32(dev, "mps,overvoltage-protection-microvolt", &tmp_value);
296	if (!ret) {
297		switch (tmp_value) {
298		case 13500000:
299			pdata->over_voltage_protection = 0x00;
300			break;
301		case 24000000:
302			pdata->over_voltage_protection = REG_I2C_1_OVP0;
303			break;
304		case 35500000:
305			pdata->over_voltage_protection = REG_I2C_1_OVP1;
306			break;
307		default:
308			return -EINVAL;
309		}
310	}
311
312	/* Synchronous (default) and non-synchronous mode */
313	pdata->sync_mode = !device_property_read_bool(dev, "mps,no-sync-mode");
314
315	return 0;
316}
317
318static int mp3309c_probe(struct i2c_client *client)
319{
320	struct device *dev = &client->dev;
321	struct mp3309c_platform_data *pdata = dev_get_platdata(dev);
322	struct mp3309c_chip *chip;
323	struct backlight_properties props;
324	struct pwm_state pwmstate;
325	int ret;
326
327	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
328		return dev_err_probe(dev, -EOPNOTSUPP, "failed to check i2c functionality\n");
329
330	chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
331	if (!chip)
332		return -ENOMEM;
333
334	chip->dev = dev;
335
336	chip->regmap = devm_regmap_init_i2c(client, &mp3309c_regmap);
337	if (IS_ERR(chip->regmap))
338		return dev_err_probe(dev, PTR_ERR(chip->regmap),
339				     "failed to allocate register map\n");
340
341	i2c_set_clientdata(client, chip);
342
343	if (!pdata) {
344		pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
345		if (!pdata)
346			return -ENOMEM;
347
348		ret = mp3309c_parse_fwnode(chip, pdata);
349		if (ret)
350			return ret;
351	}
352	chip->pdata = pdata;
353
354	/* Backlight properties */
355	props = (typeof(props)){
356		.brightness = pdata->default_brightness,
357		.max_brightness = pdata->max_brightness,
358		.scale = BACKLIGHT_SCALE_LINEAR,
359		.type = BACKLIGHT_RAW,
360		.power = BACKLIGHT_POWER_ON,
361	};
362	chip->bl = devm_backlight_device_register(dev, "mp3309c", dev, chip,
363						  &mp3309c_bl_ops, &props);
364	if (IS_ERR(chip->bl))
365		return dev_err_probe(dev, PTR_ERR(chip->bl),
366				     "error registering backlight device\n");
367
368	/* In PWM dimming mode, enable pwm device */
369	if (chip->pdata->dimming_mode == DIMMING_PWM) {
370		pwm_init_state(chip->pwmd, &pwmstate);
371		pwm_set_relative_duty_cycle(&pwmstate,
372					    chip->pdata->default_brightness,
373					    chip->pdata->max_brightness);
374		pwmstate.enabled = true;
375		ret = pwm_apply_might_sleep(chip->pwmd, &pwmstate);
376		if (ret)
377			return dev_err_probe(dev, ret, "error setting pwm device\n");
378	}
379
380	chip->pdata->status = FIRST_POWER_ON;
381	backlight_update_status(chip->bl);
382
383	return 0;
384}
385
386static void mp3309c_remove(struct i2c_client *client)
387{
388	struct mp3309c_chip *chip = i2c_get_clientdata(client);
389	struct backlight_device *bl = chip->bl;
390
391	bl->props.power = BACKLIGHT_POWER_OFF;
392	bl->props.brightness = 0;
393	backlight_update_status(chip->bl);
394}
395
396static const struct of_device_id mp3309c_match_table[] = {
397	{ .compatible = "mps,mp3309c", },
398	{ },
399};
400MODULE_DEVICE_TABLE(of, mp3309c_match_table);
401
402static const struct i2c_device_id mp3309c_id[] = {
403	{ "mp3309c" },
404	{ }
405};
406MODULE_DEVICE_TABLE(i2c, mp3309c_id);
407
408static struct i2c_driver mp3309c_i2c_driver = {
409	.driver	= {
410			.name		= KBUILD_MODNAME,
411			.of_match_table	= mp3309c_match_table,
412	},
413	.probe		= mp3309c_probe,
414	.remove		= mp3309c_remove,
415	.id_table	= mp3309c_id,
416};
417
418module_i2c_driver(mp3309c_i2c_driver);
419
420MODULE_DESCRIPTION("Backlight Driver for MPS MP3309C");
421MODULE_AUTHOR("Flavio Suligoi <f.suligoi@asem.it>");
422MODULE_LICENSE("GPL");