1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Backlight driver for ArcticSand ARC_X_C_0N_0N Devices |
4 | * |
5 | * Copyright 2016 ArcticSand, Inc. |
6 | * Author : Brian Dodge <bdodge@arcticsand.com> |
7 | */ |
8 | |
9 | #include <linux/backlight.h> |
10 | #include <linux/err.h> |
11 | #include <linux/i2c.h> |
12 | #include <linux/module.h> |
13 | #include <linux/of.h> |
14 | #include <linux/slab.h> |
15 | |
16 | enum arcxcnn_chip_id { |
17 | ARC2C0608 |
18 | }; |
19 | |
20 | /** |
21 | * struct arcxcnn_platform_data |
22 | * @name : Backlight driver name (NULL will use default) |
23 | * @initial_brightness : initial value of backlight brightness |
24 | * @leden : initial LED string enables, upper bit is global on/off |
25 | * @led_config_0 : fading speed (period between intensity steps) |
26 | * @led_config_1 : misc settings, see datasheet |
27 | * @dim_freq : pwm dimming frequency if in pwm mode |
28 | * @comp_config : misc config, see datasheet |
29 | * @filter_config : RC/PWM filter config, see datasheet |
30 | * @trim_config : full scale current trim, see datasheet |
31 | */ |
32 | struct arcxcnn_platform_data { |
33 | const char *name; |
34 | u16 initial_brightness; |
35 | u8 leden; |
36 | u8 led_config_0; |
37 | u8 led_config_1; |
38 | u8 dim_freq; |
39 | u8 comp_config; |
40 | u8 filter_config; |
41 | u8 trim_config; |
42 | }; |
43 | |
44 | #define ARCXCNN_CMD 0x00 /* Command Register */ |
45 | #define ARCXCNN_CMD_STDBY 0x80 /* I2C Standby */ |
46 | #define ARCXCNN_CMD_RESET 0x40 /* Reset */ |
47 | #define ARCXCNN_CMD_BOOST 0x10 /* Boost */ |
48 | #define ARCXCNN_CMD_OVP_MASK 0x0C /* --- Over Voltage Threshold */ |
49 | #define ARCXCNN_CMD_OVP_XXV 0x0C /* <rsvrd> Over Voltage Threshold */ |
50 | #define ARCXCNN_CMD_OVP_20V 0x08 /* 20v Over Voltage Threshold */ |
51 | #define ARCXCNN_CMD_OVP_24V 0x04 /* 24v Over Voltage Threshold */ |
52 | #define ARCXCNN_CMD_OVP_31V 0x00 /* 31.4v Over Voltage Threshold */ |
53 | #define ARCXCNN_CMD_EXT_COMP 0x01 /* part (0) or full (1) ext. comp */ |
54 | |
55 | #define ARCXCNN_CONFIG 0x01 /* Configuration */ |
56 | #define ARCXCNN_STATUS1 0x02 /* Status 1 */ |
57 | #define ARCXCNN_STATUS2 0x03 /* Status 2 */ |
58 | #define ARCXCNN_FADECTRL 0x04 /* Fading Control */ |
59 | #define ARCXCNN_ILED_CONFIG 0x05 /* ILED Configuration */ |
60 | #define ARCXCNN_ILED_DIM_PWM 0x00 /* config dim mode pwm */ |
61 | #define ARCXCNN_ILED_DIM_INT 0x04 /* config dim mode internal */ |
62 | #define ARCXCNN_LEDEN 0x06 /* LED Enable Register */ |
63 | #define ARCXCNN_LEDEN_ISETEXT 0x80 /* Full-scale current set extern */ |
64 | #define ARCXCNN_LEDEN_MASK 0x3F /* LED string enables mask */ |
65 | #define ARCXCNN_LEDEN_BITS 0x06 /* Bits of LED string enables */ |
66 | #define ARCXCNN_LEDEN_LED1 0x01 |
67 | #define ARCXCNN_LEDEN_LED2 0x02 |
68 | #define ARCXCNN_LEDEN_LED3 0x04 |
69 | #define ARCXCNN_LEDEN_LED4 0x08 |
70 | #define ARCXCNN_LEDEN_LED5 0x10 |
71 | #define ARCXCNN_LEDEN_LED6 0x20 |
72 | |
73 | #define ARCXCNN_WLED_ISET_LSB 0x07 /* LED ISET LSB (in upper nibble) */ |
74 | #define ARCXCNN_WLED_ISET_LSB_SHIFT 0x04 /* ISET LSB Left Shift */ |
75 | #define ARCXCNN_WLED_ISET_MSB 0x08 /* LED ISET MSB (8 bits) */ |
76 | |
77 | #define ARCXCNN_DIMFREQ 0x09 |
78 | #define ARCXCNN_COMP_CONFIG 0x0A |
79 | #define ARCXCNN_FILT_CONFIG 0x0B |
80 | #define ARCXCNN_IMAXTUNE 0x0C |
81 | #define ARCXCNN_ID_MSB 0x1E |
82 | #define ARCXCNN_ID_LSB 0x1F |
83 | |
84 | #define MAX_BRIGHTNESS 4095 |
85 | #define INIT_BRIGHT 60 |
86 | |
87 | struct arcxcnn { |
88 | struct i2c_client *client; |
89 | struct backlight_device *bl; |
90 | struct device *dev; |
91 | struct arcxcnn_platform_data *pdata; |
92 | }; |
93 | |
94 | static int arcxcnn_update_field(struct arcxcnn *lp, u8 reg, u8 mask, u8 data) |
95 | { |
96 | int ret; |
97 | u8 tmp; |
98 | |
99 | ret = i2c_smbus_read_byte_data(client: lp->client, command: reg); |
100 | if (ret < 0) { |
101 | dev_err(lp->dev, "failed to read 0x%.2x\n" , reg); |
102 | return ret; |
103 | } |
104 | |
105 | tmp = (u8)ret; |
106 | tmp &= ~mask; |
107 | tmp |= data & mask; |
108 | |
109 | return i2c_smbus_write_byte_data(client: lp->client, command: reg, value: tmp); |
110 | } |
111 | |
112 | static int arcxcnn_set_brightness(struct arcxcnn *lp, u32 brightness) |
113 | { |
114 | int ret; |
115 | u8 val; |
116 | |
117 | /* lower nibble of brightness goes in upper nibble of LSB register */ |
118 | val = (brightness & 0xF) << ARCXCNN_WLED_ISET_LSB_SHIFT; |
119 | ret = i2c_smbus_write_byte_data(client: lp->client, |
120 | ARCXCNN_WLED_ISET_LSB, value: val); |
121 | if (ret < 0) |
122 | return ret; |
123 | |
124 | /* remaining 8 bits of brightness go in MSB register */ |
125 | val = (brightness >> 4); |
126 | return i2c_smbus_write_byte_data(client: lp->client, |
127 | ARCXCNN_WLED_ISET_MSB, value: val); |
128 | } |
129 | |
130 | static int arcxcnn_bl_update_status(struct backlight_device *bl) |
131 | { |
132 | struct arcxcnn *lp = bl_get_data(bl_dev: bl); |
133 | u32 brightness = backlight_get_brightness(bd: bl); |
134 | int ret; |
135 | |
136 | ret = arcxcnn_set_brightness(lp, brightness); |
137 | if (ret) |
138 | return ret; |
139 | |
140 | /* set power-on/off/save modes */ |
141 | return arcxcnn_update_field(lp, ARCXCNN_CMD, ARCXCNN_CMD_STDBY, |
142 | data: (bl->props.power == 0) ? 0 : ARCXCNN_CMD_STDBY); |
143 | } |
144 | |
145 | static const struct backlight_ops arcxcnn_bl_ops = { |
146 | .options = BL_CORE_SUSPENDRESUME, |
147 | .update_status = arcxcnn_bl_update_status, |
148 | }; |
149 | |
150 | static int arcxcnn_backlight_register(struct arcxcnn *lp) |
151 | { |
152 | struct backlight_properties *props; |
153 | const char *name = lp->pdata->name ? : "arctic_bl" ; |
154 | |
155 | props = devm_kzalloc(dev: lp->dev, size: sizeof(*props), GFP_KERNEL); |
156 | if (!props) |
157 | return -ENOMEM; |
158 | |
159 | props->type = BACKLIGHT_PLATFORM; |
160 | props->max_brightness = MAX_BRIGHTNESS; |
161 | |
162 | if (lp->pdata->initial_brightness > props->max_brightness) |
163 | lp->pdata->initial_brightness = props->max_brightness; |
164 | |
165 | props->brightness = lp->pdata->initial_brightness; |
166 | |
167 | lp->bl = devm_backlight_device_register(dev: lp->dev, name, parent: lp->dev, devdata: lp, |
168 | ops: &arcxcnn_bl_ops, props); |
169 | return PTR_ERR_OR_ZERO(ptr: lp->bl); |
170 | } |
171 | |
172 | static void arcxcnn_parse_dt(struct arcxcnn *lp) |
173 | { |
174 | struct device *dev = lp->dev; |
175 | struct device_node *node = dev->of_node; |
176 | u32 prog_val, num_entry, entry, sources[ARCXCNN_LEDEN_BITS]; |
177 | int ret; |
178 | |
179 | /* device tree entry isn't required, defaults are OK */ |
180 | if (!node) |
181 | return; |
182 | |
183 | ret = of_property_read_string(np: node, propname: "label" , out_string: &lp->pdata->name); |
184 | if (ret < 0) |
185 | lp->pdata->name = NULL; |
186 | |
187 | ret = of_property_read_u32(np: node, propname: "default-brightness" , out_value: &prog_val); |
188 | if (ret == 0) |
189 | lp->pdata->initial_brightness = prog_val; |
190 | |
191 | ret = of_property_read_u32(np: node, propname: "arc,led-config-0" , out_value: &prog_val); |
192 | if (ret == 0) |
193 | lp->pdata->led_config_0 = (u8)prog_val; |
194 | |
195 | ret = of_property_read_u32(np: node, propname: "arc,led-config-1" , out_value: &prog_val); |
196 | if (ret == 0) |
197 | lp->pdata->led_config_1 = (u8)prog_val; |
198 | |
199 | ret = of_property_read_u32(np: node, propname: "arc,dim-freq" , out_value: &prog_val); |
200 | if (ret == 0) |
201 | lp->pdata->dim_freq = (u8)prog_val; |
202 | |
203 | ret = of_property_read_u32(np: node, propname: "arc,comp-config" , out_value: &prog_val); |
204 | if (ret == 0) |
205 | lp->pdata->comp_config = (u8)prog_val; |
206 | |
207 | ret = of_property_read_u32(np: node, propname: "arc,filter-config" , out_value: &prog_val); |
208 | if (ret == 0) |
209 | lp->pdata->filter_config = (u8)prog_val; |
210 | |
211 | ret = of_property_read_u32(np: node, propname: "arc,trim-config" , out_value: &prog_val); |
212 | if (ret == 0) |
213 | lp->pdata->trim_config = (u8)prog_val; |
214 | |
215 | ret = of_property_count_u32_elems(np: node, propname: "led-sources" ); |
216 | if (ret < 0) { |
217 | lp->pdata->leden = ARCXCNN_LEDEN_MASK; /* all on is default */ |
218 | } else { |
219 | num_entry = ret; |
220 | if (num_entry > ARCXCNN_LEDEN_BITS) |
221 | num_entry = ARCXCNN_LEDEN_BITS; |
222 | |
223 | ret = of_property_read_u32_array(np: node, propname: "led-sources" , out_values: sources, |
224 | sz: num_entry); |
225 | if (ret < 0) { |
226 | dev_err(dev, "led-sources node is invalid.\n" ); |
227 | return; |
228 | } |
229 | |
230 | lp->pdata->leden = 0; |
231 | |
232 | /* for each enable in source, set bit in led enable */ |
233 | for (entry = 0; entry < num_entry; entry++) { |
234 | u8 onbit = 1 << sources[entry]; |
235 | |
236 | lp->pdata->leden |= onbit; |
237 | } |
238 | } |
239 | } |
240 | |
241 | static int arcxcnn_probe(struct i2c_client *cl) |
242 | { |
243 | struct arcxcnn *lp; |
244 | int ret; |
245 | |
246 | if (!i2c_check_functionality(adap: cl->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) |
247 | return -EIO; |
248 | |
249 | lp = devm_kzalloc(dev: &cl->dev, size: sizeof(*lp), GFP_KERNEL); |
250 | if (!lp) |
251 | return -ENOMEM; |
252 | |
253 | lp->client = cl; |
254 | lp->dev = &cl->dev; |
255 | lp->pdata = dev_get_platdata(dev: &cl->dev); |
256 | |
257 | /* reset the device */ |
258 | ret = i2c_smbus_write_byte_data(client: lp->client, |
259 | ARCXCNN_CMD, ARCXCNN_CMD_RESET); |
260 | if (ret) |
261 | goto probe_err; |
262 | |
263 | if (!lp->pdata) { |
264 | lp->pdata = devm_kzalloc(dev: lp->dev, |
265 | size: sizeof(*lp->pdata), GFP_KERNEL); |
266 | if (!lp->pdata) |
267 | return -ENOMEM; |
268 | |
269 | /* Setup defaults based on power-on defaults */ |
270 | lp->pdata->name = NULL; |
271 | lp->pdata->initial_brightness = INIT_BRIGHT; |
272 | lp->pdata->leden = ARCXCNN_LEDEN_MASK; |
273 | |
274 | lp->pdata->led_config_0 = i2c_smbus_read_byte_data( |
275 | client: lp->client, ARCXCNN_FADECTRL); |
276 | |
277 | lp->pdata->led_config_1 = i2c_smbus_read_byte_data( |
278 | client: lp->client, ARCXCNN_ILED_CONFIG); |
279 | /* insure dim mode is not default pwm */ |
280 | lp->pdata->led_config_1 |= ARCXCNN_ILED_DIM_INT; |
281 | |
282 | lp->pdata->dim_freq = i2c_smbus_read_byte_data( |
283 | client: lp->client, ARCXCNN_DIMFREQ); |
284 | |
285 | lp->pdata->comp_config = i2c_smbus_read_byte_data( |
286 | client: lp->client, ARCXCNN_COMP_CONFIG); |
287 | |
288 | lp->pdata->filter_config = i2c_smbus_read_byte_data( |
289 | client: lp->client, ARCXCNN_FILT_CONFIG); |
290 | |
291 | lp->pdata->trim_config = i2c_smbus_read_byte_data( |
292 | client: lp->client, ARCXCNN_IMAXTUNE); |
293 | |
294 | if (IS_ENABLED(CONFIG_OF)) |
295 | arcxcnn_parse_dt(lp); |
296 | } |
297 | |
298 | i2c_set_clientdata(client: cl, data: lp); |
299 | |
300 | /* constrain settings to what is possible */ |
301 | if (lp->pdata->initial_brightness > MAX_BRIGHTNESS) |
302 | lp->pdata->initial_brightness = MAX_BRIGHTNESS; |
303 | |
304 | /* set initial brightness */ |
305 | ret = arcxcnn_set_brightness(lp, brightness: lp->pdata->initial_brightness); |
306 | if (ret) |
307 | goto probe_err; |
308 | |
309 | /* set other register values directly */ |
310 | ret = i2c_smbus_write_byte_data(client: lp->client, ARCXCNN_FADECTRL, |
311 | value: lp->pdata->led_config_0); |
312 | if (ret) |
313 | goto probe_err; |
314 | |
315 | ret = i2c_smbus_write_byte_data(client: lp->client, ARCXCNN_ILED_CONFIG, |
316 | value: lp->pdata->led_config_1); |
317 | if (ret) |
318 | goto probe_err; |
319 | |
320 | ret = i2c_smbus_write_byte_data(client: lp->client, ARCXCNN_DIMFREQ, |
321 | value: lp->pdata->dim_freq); |
322 | if (ret) |
323 | goto probe_err; |
324 | |
325 | ret = i2c_smbus_write_byte_data(client: lp->client, ARCXCNN_COMP_CONFIG, |
326 | value: lp->pdata->comp_config); |
327 | if (ret) |
328 | goto probe_err; |
329 | |
330 | ret = i2c_smbus_write_byte_data(client: lp->client, ARCXCNN_FILT_CONFIG, |
331 | value: lp->pdata->filter_config); |
332 | if (ret) |
333 | goto probe_err; |
334 | |
335 | ret = i2c_smbus_write_byte_data(client: lp->client, ARCXCNN_IMAXTUNE, |
336 | value: lp->pdata->trim_config); |
337 | if (ret) |
338 | goto probe_err; |
339 | |
340 | /* set initial LED Enables */ |
341 | arcxcnn_update_field(lp, ARCXCNN_LEDEN, |
342 | ARCXCNN_LEDEN_MASK, data: lp->pdata->leden); |
343 | |
344 | ret = arcxcnn_backlight_register(lp); |
345 | if (ret) |
346 | goto probe_register_err; |
347 | |
348 | backlight_update_status(bd: lp->bl); |
349 | |
350 | return 0; |
351 | |
352 | probe_register_err: |
353 | dev_err(lp->dev, |
354 | "failed to register backlight.\n" ); |
355 | |
356 | probe_err: |
357 | dev_err(lp->dev, |
358 | "failure ret: %d\n" , ret); |
359 | return ret; |
360 | } |
361 | |
362 | static void arcxcnn_remove(struct i2c_client *cl) |
363 | { |
364 | struct arcxcnn *lp = i2c_get_clientdata(client: cl); |
365 | |
366 | /* disable all strings (ignore errors) */ |
367 | i2c_smbus_write_byte_data(client: lp->client, |
368 | ARCXCNN_LEDEN, value: 0x00); |
369 | /* reset the device (ignore errors) */ |
370 | i2c_smbus_write_byte_data(client: lp->client, |
371 | ARCXCNN_CMD, ARCXCNN_CMD_RESET); |
372 | |
373 | lp->bl->props.brightness = 0; |
374 | |
375 | backlight_update_status(bd: lp->bl); |
376 | } |
377 | |
378 | static const struct of_device_id arcxcnn_dt_ids[] = { |
379 | { .compatible = "arc,arc2c0608" }, |
380 | { } |
381 | }; |
382 | MODULE_DEVICE_TABLE(of, arcxcnn_dt_ids); |
383 | |
384 | static const struct i2c_device_id arcxcnn_ids[] = { |
385 | {"arc2c0608" , ARC2C0608}, |
386 | { } |
387 | }; |
388 | MODULE_DEVICE_TABLE(i2c, arcxcnn_ids); |
389 | |
390 | static struct i2c_driver arcxcnn_driver = { |
391 | .driver = { |
392 | .name = "arcxcnn_bl" , |
393 | .of_match_table = arcxcnn_dt_ids, |
394 | }, |
395 | .probe = arcxcnn_probe, |
396 | .remove = arcxcnn_remove, |
397 | .id_table = arcxcnn_ids, |
398 | }; |
399 | module_i2c_driver(arcxcnn_driver); |
400 | |
401 | MODULE_LICENSE("GPL v2" ); |
402 | MODULE_AUTHOR("Brian Dodge <bdodge@arcticsand.com>" ); |
403 | MODULE_DESCRIPTION("ARCXCNN Backlight driver" ); |
404 | |