xref: /openbmc/linux/drivers/leds/leds-cr0014114.c (revision 3192f141)
1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2018 Crane Merchandising Systems. All rights reserved.
3 // Copyright (C) 2018 Oleh Kravchenko <oleg@kaa.org.ua>
4 
5 #include <linux/delay.h>
6 #include <linux/leds.h>
7 #include <linux/mod_devicetable.h>
8 #include <linux/module.h>
9 #include <linux/spi/spi.h>
10 #include <linux/workqueue.h>
11 
12 /*
13  *  CR0014114 SPI protocol descrtiption:
14  *  +----+-----------------------------------+----+
15  *  | CMD|             BRIGHTNESS            |CRC |
16  *  +----+-----------------------------------+----+
17  *  |    | LED0| LED1| LED2| LED3| LED4| LED5|    |
18  *  |    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+    |
19  *  |    |R|G|B|R|G|B|R|G|B|R|G|B|R|G|B|R|G|B|    |
20  *  | 1  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 1  |
21  *  |    |1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|    |
22  *  |    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+    |
23  *  |    |               18                  |    |
24  *  +----+-----------------------------------+----+
25  *  |                    20                       |
26  *  +---------------------------------------------+
27  *
28  *  PS: Boards can be connected to the chain:
29  *      SPI -> board0 -> board1 -> board2 ..
30  */
31 
32 /* CR0014114 SPI commands */
33 #define CR_SET_BRIGHTNESS	0x80
34 #define CR_INIT_REENUMERATE	0x81
35 #define CR_NEXT_REENUMERATE	0x82
36 
37 /* CR0014114 default settings */
38 #define CR_MAX_BRIGHTNESS	GENMASK(6, 0)
39 #define CR_FW_DELAY_MSEC	10
40 #define CR_RECOUNT_DELAY	(HZ * 3600)
41 
42 #define CR_DEV_NAME		"cr0014114"
43 
44 struct cr0014114_led {
45 	struct cr0014114	*priv;
46 	struct led_classdev	ldev;
47 	u8			brightness;
48 };
49 
50 struct cr0014114 {
51 	bool			do_recount;
52 	size_t			count;
53 	struct delayed_work	work;
54 	struct device		*dev;
55 	struct mutex		lock;
56 	struct spi_device	*spi;
57 	u8			*buf;
58 	unsigned long		delay;
59 	struct cr0014114_led	leds[];
60 };
61 
cr0014114_calc_crc(u8 * buf,const size_t len)62 static void cr0014114_calc_crc(u8 *buf, const size_t len)
63 {
64 	size_t	i;
65 	u8	crc;
66 
67 	for (i = 1, crc = 1; i < len - 1; i++)
68 		crc += buf[i];
69 	crc |= BIT(7);
70 
71 	/* special case when CRC matches the SPI commands */
72 	if (crc == CR_SET_BRIGHTNESS ||
73 	    crc == CR_INIT_REENUMERATE ||
74 	    crc == CR_NEXT_REENUMERATE)
75 		crc = 0xfe;
76 
77 	buf[len - 1] = crc;
78 }
79 
cr0014114_recount(struct cr0014114 * priv)80 static int cr0014114_recount(struct cr0014114 *priv)
81 {
82 	int	ret;
83 	size_t	i;
84 	u8	cmd;
85 
86 	dev_dbg(priv->dev, "LEDs recount is started\n");
87 
88 	cmd = CR_INIT_REENUMERATE;
89 	ret = spi_write(priv->spi, &cmd, sizeof(cmd));
90 	if (ret)
91 		goto err;
92 
93 	cmd = CR_NEXT_REENUMERATE;
94 	for (i = 0; i < priv->count; i++) {
95 		msleep(CR_FW_DELAY_MSEC);
96 
97 		ret = spi_write(priv->spi, &cmd, sizeof(cmd));
98 		if (ret)
99 			goto err;
100 	}
101 
102 err:
103 	dev_dbg(priv->dev, "LEDs recount is finished\n");
104 
105 	if (ret)
106 		dev_err(priv->dev, "with error %d", ret);
107 
108 	return ret;
109 }
110 
cr0014114_sync(struct cr0014114 * priv)111 static int cr0014114_sync(struct cr0014114 *priv)
112 {
113 	int		ret;
114 	size_t		i;
115 	unsigned long	udelay, now = jiffies;
116 
117 	/* to avoid SPI mistiming with firmware we should wait some time */
118 	if (time_after(priv->delay, now)) {
119 		udelay = jiffies_to_usecs(priv->delay - now);
120 		usleep_range(udelay, udelay + 1);
121 	}
122 
123 	if (unlikely(priv->do_recount)) {
124 		ret = cr0014114_recount(priv);
125 		if (ret)
126 			goto err;
127 
128 		priv->do_recount = false;
129 		msleep(CR_FW_DELAY_MSEC);
130 	}
131 
132 	priv->buf[0] = CR_SET_BRIGHTNESS;
133 	for (i = 0; i < priv->count; i++)
134 		priv->buf[i + 1] = priv->leds[i].brightness;
135 	cr0014114_calc_crc(priv->buf, priv->count + 2);
136 	ret = spi_write(priv->spi, priv->buf, priv->count + 2);
137 
138 err:
139 	priv->delay = jiffies + msecs_to_jiffies(CR_FW_DELAY_MSEC);
140 
141 	return ret;
142 }
143 
cr0014114_recount_work(struct work_struct * work)144 static void cr0014114_recount_work(struct work_struct *work)
145 {
146 	int			ret;
147 	struct cr0014114	*priv = container_of(work,
148 						     struct cr0014114,
149 						     work.work);
150 
151 	mutex_lock(&priv->lock);
152 	priv->do_recount = true;
153 	ret = cr0014114_sync(priv);
154 	mutex_unlock(&priv->lock);
155 
156 	if (ret)
157 		dev_warn(priv->dev, "sync of LEDs failed %d\n", ret);
158 
159 	schedule_delayed_work(&priv->work, CR_RECOUNT_DELAY);
160 }
161 
cr0014114_set_sync(struct led_classdev * ldev,enum led_brightness brightness)162 static int cr0014114_set_sync(struct led_classdev *ldev,
163 			      enum led_brightness brightness)
164 {
165 	int			ret;
166 	struct cr0014114_led    *led = container_of(ldev,
167 						    struct cr0014114_led,
168 						    ldev);
169 
170 	dev_dbg(led->priv->dev, "Set brightness to %d\n", brightness);
171 
172 	mutex_lock(&led->priv->lock);
173 	led->brightness = (u8)brightness;
174 	ret = cr0014114_sync(led->priv);
175 	mutex_unlock(&led->priv->lock);
176 
177 	return ret;
178 }
179 
cr0014114_probe_dt(struct cr0014114 * priv)180 static int cr0014114_probe_dt(struct cr0014114 *priv)
181 {
182 	size_t			i = 0;
183 	struct cr0014114_led	*led;
184 	struct fwnode_handle	*child;
185 	struct led_init_data	init_data = {};
186 	int			ret;
187 
188 	device_for_each_child_node(priv->dev, child) {
189 		led = &priv->leds[i];
190 
191 		led->priv			  = priv;
192 		led->ldev.max_brightness	  = CR_MAX_BRIGHTNESS;
193 		led->ldev.brightness_set_blocking = cr0014114_set_sync;
194 
195 		init_data.fwnode = child;
196 		init_data.devicename = CR_DEV_NAME;
197 		init_data.default_label = ":";
198 
199 		ret = devm_led_classdev_register_ext(priv->dev, &led->ldev,
200 						     &init_data);
201 		if (ret) {
202 			dev_err(priv->dev,
203 				"failed to register LED device, err %d", ret);
204 			fwnode_handle_put(child);
205 			return ret;
206 		}
207 
208 		i++;
209 	}
210 
211 	return 0;
212 }
213 
cr0014114_probe(struct spi_device * spi)214 static int cr0014114_probe(struct spi_device *spi)
215 {
216 	struct cr0014114	*priv;
217 	size_t			count;
218 	int			ret;
219 
220 	count = device_get_child_node_count(&spi->dev);
221 	if (!count) {
222 		dev_err(&spi->dev, "LEDs are not defined in device tree!");
223 		return -ENODEV;
224 	}
225 
226 	priv = devm_kzalloc(&spi->dev, struct_size(priv, leds, count),
227 			    GFP_KERNEL);
228 	if (!priv)
229 		return -ENOMEM;
230 
231 	priv->buf = devm_kzalloc(&spi->dev, count + 2, GFP_KERNEL);
232 	if (!priv->buf)
233 		return -ENOMEM;
234 
235 	mutex_init(&priv->lock);
236 	INIT_DELAYED_WORK(&priv->work, cr0014114_recount_work);
237 	priv->count	= count;
238 	priv->dev	= &spi->dev;
239 	priv->spi	= spi;
240 	priv->delay	= jiffies -
241 			  msecs_to_jiffies(CR_FW_DELAY_MSEC);
242 
243 	priv->do_recount = true;
244 	ret = cr0014114_sync(priv);
245 	if (ret) {
246 		dev_err(priv->dev, "first recount failed %d\n", ret);
247 		return ret;
248 	}
249 
250 	priv->do_recount = true;
251 	ret = cr0014114_sync(priv);
252 	if (ret) {
253 		dev_err(priv->dev, "second recount failed %d\n", ret);
254 		return ret;
255 	}
256 
257 	ret = cr0014114_probe_dt(priv);
258 	if (ret)
259 		return ret;
260 
261 	/* setup recount work to workaround buggy firmware */
262 	schedule_delayed_work(&priv->work, CR_RECOUNT_DELAY);
263 
264 	spi_set_drvdata(spi, priv);
265 
266 	return 0;
267 }
268 
cr0014114_remove(struct spi_device * spi)269 static void cr0014114_remove(struct spi_device *spi)
270 {
271 	struct cr0014114 *priv = spi_get_drvdata(spi);
272 
273 	cancel_delayed_work_sync(&priv->work);
274 	mutex_destroy(&priv->lock);
275 }
276 
277 static const struct of_device_id cr0014114_dt_ids[] = {
278 	{ .compatible = "crane,cr0014114", },
279 	{},
280 };
281 
282 MODULE_DEVICE_TABLE(of, cr0014114_dt_ids);
283 
284 static struct spi_driver cr0014114_driver = {
285 	.probe		= cr0014114_probe,
286 	.remove		= cr0014114_remove,
287 	.driver = {
288 		.name		= KBUILD_MODNAME,
289 		.of_match_table	= cr0014114_dt_ids,
290 	},
291 };
292 
293 module_spi_driver(cr0014114_driver);
294 
295 MODULE_AUTHOR("Oleh Kravchenko <oleg@kaa.org.ua>");
296 MODULE_DESCRIPTION("cr0014114 LED driver");
297 MODULE_LICENSE("GPL v2");
298 MODULE_ALIAS("spi:cr0014114");
299