1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * HT16K33 driver |
4 | * |
5 | * Author: Robin van der Gracht <robin@protonic.nl> |
6 | * |
7 | * Copyright: (C) 2016 Protonic Holland. |
8 | * Copyright (C) 2021 Glider bv |
9 | */ |
10 | |
11 | #include <linux/kernel.h> |
12 | #include <linux/module.h> |
13 | #include <linux/interrupt.h> |
14 | #include <linux/i2c.h> |
15 | #include <linux/property.h> |
16 | #include <linux/fb.h> |
17 | #include <linux/backlight.h> |
18 | #include <linux/input.h> |
19 | #include <linux/input/matrix_keypad.h> |
20 | #include <linux/leds.h> |
21 | #include <linux/workqueue.h> |
22 | #include <linux/mm.h> |
23 | |
24 | #include <linux/map_to_7segment.h> |
25 | #include <linux/map_to_14segment.h> |
26 | |
27 | #include <asm/unaligned.h> |
28 | |
29 | #include "line-display.h" |
30 | |
31 | /* Registers */ |
32 | #define REG_SYSTEM_SETUP 0x20 |
33 | #define REG_SYSTEM_SETUP_OSC_ON BIT(0) |
34 | |
35 | #define REG_DISPLAY_SETUP 0x80 |
36 | #define REG_DISPLAY_SETUP_ON BIT(0) |
37 | #define REG_DISPLAY_SETUP_BLINK_OFF (0 << 1) |
38 | #define REG_DISPLAY_SETUP_BLINK_2HZ (1 << 1) |
39 | #define REG_DISPLAY_SETUP_BLINK_1HZ (2 << 1) |
40 | #define REG_DISPLAY_SETUP_BLINK_0HZ5 (3 << 1) |
41 | |
42 | #define REG_ROWINT_SET 0xA0 |
43 | #define REG_ROWINT_SET_INT_EN BIT(0) |
44 | #define REG_ROWINT_SET_INT_ACT_HIGH BIT(1) |
45 | |
46 | #define REG_BRIGHTNESS 0xE0 |
47 | |
48 | /* Defines */ |
49 | #define DRIVER_NAME "ht16k33" |
50 | |
51 | #define MIN_BRIGHTNESS 0x1 |
52 | #define MAX_BRIGHTNESS 0x10 |
53 | |
54 | #define HT16K33_MATRIX_LED_MAX_COLS 8 |
55 | #define HT16K33_MATRIX_LED_MAX_ROWS 16 |
56 | #define HT16K33_MATRIX_KEYPAD_MAX_COLS 3 |
57 | #define HT16K33_MATRIX_KEYPAD_MAX_ROWS 12 |
58 | |
59 | #define BYTES_PER_ROW (HT16K33_MATRIX_LED_MAX_ROWS / 8) |
60 | #define HT16K33_FB_SIZE (HT16K33_MATRIX_LED_MAX_COLS * BYTES_PER_ROW) |
61 | |
62 | enum display_type { |
63 | DISP_MATRIX = 0, |
64 | DISP_QUAD_7SEG, |
65 | DISP_QUAD_14SEG, |
66 | }; |
67 | |
68 | struct ht16k33_keypad { |
69 | struct i2c_client *client; |
70 | struct input_dev *dev; |
71 | uint32_t cols; |
72 | uint32_t rows; |
73 | uint32_t row_shift; |
74 | uint32_t debounce_ms; |
75 | uint16_t last_key_state[HT16K33_MATRIX_KEYPAD_MAX_COLS]; |
76 | |
77 | wait_queue_head_t wait; |
78 | bool stopped; |
79 | }; |
80 | |
81 | struct ht16k33_fbdev { |
82 | struct fb_info *info; |
83 | uint32_t refresh_rate; |
84 | uint8_t *buffer; |
85 | uint8_t *cache; |
86 | }; |
87 | |
88 | struct ht16k33_seg { |
89 | struct linedisp linedisp; |
90 | union { |
91 | struct seg7_conversion_map seg7; |
92 | struct seg14_conversion_map seg14; |
93 | } map; |
94 | unsigned int map_size; |
95 | char curr[4]; |
96 | }; |
97 | |
98 | struct ht16k33_priv { |
99 | struct i2c_client *client; |
100 | struct delayed_work work; |
101 | struct led_classdev led; |
102 | struct ht16k33_keypad keypad; |
103 | union { |
104 | struct ht16k33_fbdev fbdev; |
105 | struct ht16k33_seg seg; |
106 | }; |
107 | enum display_type type; |
108 | uint8_t blink; |
109 | }; |
110 | |
111 | static const struct fb_fix_screeninfo ht16k33_fb_fix = { |
112 | .id = DRIVER_NAME, |
113 | .type = FB_TYPE_PACKED_PIXELS, |
114 | .visual = FB_VISUAL_MONO10, |
115 | .xpanstep = 0, |
116 | .ypanstep = 0, |
117 | .ywrapstep = 0, |
118 | .line_length = HT16K33_MATRIX_LED_MAX_ROWS, |
119 | .accel = FB_ACCEL_NONE, |
120 | }; |
121 | |
122 | static const struct fb_var_screeninfo ht16k33_fb_var = { |
123 | .xres = HT16K33_MATRIX_LED_MAX_ROWS, |
124 | .yres = HT16K33_MATRIX_LED_MAX_COLS, |
125 | .xres_virtual = HT16K33_MATRIX_LED_MAX_ROWS, |
126 | .yres_virtual = HT16K33_MATRIX_LED_MAX_COLS, |
127 | .bits_per_pixel = 1, |
128 | .red = { 0, 1, 0 }, |
129 | .green = { 0, 1, 0 }, |
130 | .blue = { 0, 1, 0 }, |
131 | .left_margin = 0, |
132 | .right_margin = 0, |
133 | .upper_margin = 0, |
134 | .lower_margin = 0, |
135 | .vmode = FB_VMODE_NONINTERLACED, |
136 | }; |
137 | |
138 | static const SEG7_DEFAULT_MAP(initial_map_seg7); |
139 | static const SEG14_DEFAULT_MAP(initial_map_seg14); |
140 | |
141 | static ssize_t map_seg_show(struct device *dev, struct device_attribute *attr, |
142 | char *buf) |
143 | { |
144 | struct ht16k33_priv *priv = dev_get_drvdata(dev); |
145 | |
146 | memcpy(buf, &priv->seg.map, priv->seg.map_size); |
147 | return priv->seg.map_size; |
148 | } |
149 | |
150 | static ssize_t map_seg_store(struct device *dev, struct device_attribute *attr, |
151 | const char *buf, size_t cnt) |
152 | { |
153 | struct ht16k33_priv *priv = dev_get_drvdata(dev); |
154 | |
155 | if (cnt != priv->seg.map_size) |
156 | return -EINVAL; |
157 | |
158 | memcpy(&priv->seg.map, buf, cnt); |
159 | return cnt; |
160 | } |
161 | |
162 | static DEVICE_ATTR(map_seg7, 0644, map_seg_show, map_seg_store); |
163 | static DEVICE_ATTR(map_seg14, 0644, map_seg_show, map_seg_store); |
164 | |
165 | static int ht16k33_display_on(struct ht16k33_priv *priv) |
166 | { |
167 | uint8_t data = REG_DISPLAY_SETUP | REG_DISPLAY_SETUP_ON | priv->blink; |
168 | |
169 | return i2c_smbus_write_byte(client: priv->client, value: data); |
170 | } |
171 | |
172 | static int ht16k33_display_off(struct ht16k33_priv *priv) |
173 | { |
174 | return i2c_smbus_write_byte(client: priv->client, REG_DISPLAY_SETUP); |
175 | } |
176 | |
177 | static int ht16k33_brightness_set(struct ht16k33_priv *priv, |
178 | unsigned int brightness) |
179 | { |
180 | int err; |
181 | |
182 | if (brightness == 0) { |
183 | priv->blink = REG_DISPLAY_SETUP_BLINK_OFF; |
184 | return ht16k33_display_off(priv); |
185 | } |
186 | |
187 | err = ht16k33_display_on(priv); |
188 | if (err) |
189 | return err; |
190 | |
191 | return i2c_smbus_write_byte(client: priv->client, |
192 | REG_BRIGHTNESS | (brightness - 1)); |
193 | } |
194 | |
195 | static int ht16k33_brightness_set_blocking(struct led_classdev *led_cdev, |
196 | enum led_brightness brightness) |
197 | { |
198 | struct ht16k33_priv *priv = container_of(led_cdev, struct ht16k33_priv, |
199 | led); |
200 | |
201 | return ht16k33_brightness_set(priv, brightness); |
202 | } |
203 | |
204 | static int ht16k33_blink_set(struct led_classdev *led_cdev, |
205 | unsigned long *delay_on, unsigned long *delay_off) |
206 | { |
207 | struct ht16k33_priv *priv = container_of(led_cdev, struct ht16k33_priv, |
208 | led); |
209 | unsigned int delay; |
210 | uint8_t blink; |
211 | int err; |
212 | |
213 | if (!*delay_on && !*delay_off) { |
214 | blink = REG_DISPLAY_SETUP_BLINK_1HZ; |
215 | delay = 1000; |
216 | } else if (*delay_on <= 750) { |
217 | blink = REG_DISPLAY_SETUP_BLINK_2HZ; |
218 | delay = 500; |
219 | } else if (*delay_on <= 1500) { |
220 | blink = REG_DISPLAY_SETUP_BLINK_1HZ; |
221 | delay = 1000; |
222 | } else { |
223 | blink = REG_DISPLAY_SETUP_BLINK_0HZ5; |
224 | delay = 2000; |
225 | } |
226 | |
227 | err = i2c_smbus_write_byte(client: priv->client, |
228 | REG_DISPLAY_SETUP | REG_DISPLAY_SETUP_ON | |
229 | blink); |
230 | if (err) |
231 | return err; |
232 | |
233 | priv->blink = blink; |
234 | *delay_on = *delay_off = delay; |
235 | return 0; |
236 | } |
237 | |
238 | static void ht16k33_fb_queue(struct ht16k33_priv *priv) |
239 | { |
240 | struct ht16k33_fbdev *fbdev = &priv->fbdev; |
241 | |
242 | schedule_delayed_work(dwork: &priv->work, HZ / fbdev->refresh_rate); |
243 | } |
244 | |
245 | /* |
246 | * This gets the fb data from cache and copies it to ht16k33 display RAM |
247 | */ |
248 | static void ht16k33_fb_update(struct work_struct *work) |
249 | { |
250 | struct ht16k33_priv *priv = container_of(work, struct ht16k33_priv, |
251 | work.work); |
252 | struct ht16k33_fbdev *fbdev = &priv->fbdev; |
253 | |
254 | uint8_t *p1, *p2; |
255 | int len, pos = 0, first = -1; |
256 | |
257 | p1 = fbdev->cache; |
258 | p2 = fbdev->buffer; |
259 | |
260 | /* Search for the first byte with changes */ |
261 | while (pos < HT16K33_FB_SIZE && first < 0) { |
262 | if (*(p1++) - *(p2++)) |
263 | first = pos; |
264 | pos++; |
265 | } |
266 | |
267 | /* No changes found */ |
268 | if (first < 0) |
269 | goto requeue; |
270 | |
271 | len = HT16K33_FB_SIZE - first; |
272 | p1 = fbdev->cache + HT16K33_FB_SIZE - 1; |
273 | p2 = fbdev->buffer + HT16K33_FB_SIZE - 1; |
274 | |
275 | /* Determine i2c transfer length */ |
276 | while (len > 1) { |
277 | if (*(p1--) - *(p2--)) |
278 | break; |
279 | len--; |
280 | } |
281 | |
282 | p1 = fbdev->cache + first; |
283 | p2 = fbdev->buffer + first; |
284 | if (!i2c_smbus_write_i2c_block_data(client: priv->client, command: first, length: len, values: p2)) |
285 | memcpy(p1, p2, len); |
286 | requeue: |
287 | ht16k33_fb_queue(priv); |
288 | } |
289 | |
290 | static int ht16k33_initialize(struct ht16k33_priv *priv) |
291 | { |
292 | uint8_t data[HT16K33_FB_SIZE]; |
293 | uint8_t byte; |
294 | int err; |
295 | |
296 | /* Clear RAM (8 * 16 bits) */ |
297 | memset(data, 0, sizeof(data)); |
298 | err = i2c_smbus_write_block_data(client: priv->client, command: 0, length: sizeof(data), values: data); |
299 | if (err) |
300 | return err; |
301 | |
302 | /* Turn on internal oscillator */ |
303 | byte = REG_SYSTEM_SETUP_OSC_ON | REG_SYSTEM_SETUP; |
304 | err = i2c_smbus_write_byte(client: priv->client, value: byte); |
305 | if (err) |
306 | return err; |
307 | |
308 | /* Configure INT pin */ |
309 | byte = REG_ROWINT_SET | REG_ROWINT_SET_INT_ACT_HIGH; |
310 | if (priv->client->irq > 0) |
311 | byte |= REG_ROWINT_SET_INT_EN; |
312 | return i2c_smbus_write_byte(client: priv->client, value: byte); |
313 | } |
314 | |
315 | static int ht16k33_bl_update_status(struct backlight_device *bl) |
316 | { |
317 | int brightness = bl->props.brightness; |
318 | struct ht16k33_priv *priv = bl_get_data(bl_dev: bl); |
319 | |
320 | if (bl->props.power != FB_BLANK_UNBLANK || |
321 | bl->props.fb_blank != FB_BLANK_UNBLANK || |
322 | bl->props.state & BL_CORE_FBBLANK) |
323 | brightness = 0; |
324 | |
325 | return ht16k33_brightness_set(priv, brightness); |
326 | } |
327 | |
328 | static int ht16k33_bl_check_fb(struct backlight_device *bl, struct fb_info *fi) |
329 | { |
330 | struct ht16k33_priv *priv = bl_get_data(bl_dev: bl); |
331 | |
332 | return (fi == NULL) || (fi->par == priv); |
333 | } |
334 | |
335 | static const struct backlight_ops ht16k33_bl_ops = { |
336 | .update_status = ht16k33_bl_update_status, |
337 | .check_fb = ht16k33_bl_check_fb, |
338 | }; |
339 | |
340 | /* |
341 | * Blank events will be passed to the actual device handling the backlight when |
342 | * we return zero here. |
343 | */ |
344 | static int ht16k33_blank(int blank, struct fb_info *info) |
345 | { |
346 | return 0; |
347 | } |
348 | |
349 | static int ht16k33_mmap(struct fb_info *info, struct vm_area_struct *vma) |
350 | { |
351 | struct ht16k33_priv *priv = info->par; |
352 | struct page *pages = virt_to_page(priv->fbdev.buffer); |
353 | |
354 | return vm_map_pages_zero(vma, pages: &pages, num: 1); |
355 | } |
356 | |
357 | static const struct fb_ops ht16k33_fb_ops = { |
358 | .owner = THIS_MODULE, |
359 | .fb_read = fb_sys_read, |
360 | .fb_write = fb_sys_write, |
361 | .fb_blank = ht16k33_blank, |
362 | .fb_fillrect = sys_fillrect, |
363 | .fb_copyarea = sys_copyarea, |
364 | .fb_imageblit = sys_imageblit, |
365 | .fb_mmap = ht16k33_mmap, |
366 | }; |
367 | |
368 | /* |
369 | * This gets the keys from keypad and reports it to input subsystem. |
370 | * Returns true if a key is pressed. |
371 | */ |
372 | static bool ht16k33_keypad_scan(struct ht16k33_keypad *keypad) |
373 | { |
374 | const unsigned short *keycodes = keypad->dev->keycode; |
375 | u16 new_state[HT16K33_MATRIX_KEYPAD_MAX_COLS]; |
376 | __le16 data[HT16K33_MATRIX_KEYPAD_MAX_COLS]; |
377 | unsigned long bits_changed; |
378 | int row, col, code; |
379 | int rc; |
380 | bool pressed = false; |
381 | |
382 | rc = i2c_smbus_read_i2c_block_data(client: keypad->client, command: 0x40, |
383 | length: sizeof(data), values: (u8 *)data); |
384 | if (rc != sizeof(data)) { |
385 | dev_err(&keypad->client->dev, |
386 | "Failed to read key data, rc=%d\n" , rc); |
387 | return false; |
388 | } |
389 | |
390 | for (col = 0; col < keypad->cols; col++) { |
391 | new_state[col] = le16_to_cpu(data[col]); |
392 | if (new_state[col]) |
393 | pressed = true; |
394 | bits_changed = keypad->last_key_state[col] ^ new_state[col]; |
395 | |
396 | for_each_set_bit(row, &bits_changed, BITS_PER_LONG) { |
397 | code = MATRIX_SCAN_CODE(row, col, keypad->row_shift); |
398 | input_event(dev: keypad->dev, EV_MSC, MSC_SCAN, value: code); |
399 | input_report_key(dev: keypad->dev, code: keycodes[code], |
400 | value: new_state[col] & BIT(row)); |
401 | } |
402 | } |
403 | input_sync(dev: keypad->dev); |
404 | memcpy(keypad->last_key_state, new_state, sizeof(u16) * keypad->cols); |
405 | |
406 | return pressed; |
407 | } |
408 | |
409 | static irqreturn_t ht16k33_keypad_irq_thread(int irq, void *dev) |
410 | { |
411 | struct ht16k33_keypad *keypad = dev; |
412 | |
413 | do { |
414 | wait_event_timeout(keypad->wait, keypad->stopped, |
415 | msecs_to_jiffies(keypad->debounce_ms)); |
416 | if (keypad->stopped) |
417 | break; |
418 | } while (ht16k33_keypad_scan(keypad)); |
419 | |
420 | return IRQ_HANDLED; |
421 | } |
422 | |
423 | static int ht16k33_keypad_start(struct input_dev *dev) |
424 | { |
425 | struct ht16k33_keypad *keypad = input_get_drvdata(dev); |
426 | |
427 | keypad->stopped = false; |
428 | mb(); |
429 | enable_irq(irq: keypad->client->irq); |
430 | |
431 | return 0; |
432 | } |
433 | |
434 | static void ht16k33_keypad_stop(struct input_dev *dev) |
435 | { |
436 | struct ht16k33_keypad *keypad = input_get_drvdata(dev); |
437 | |
438 | keypad->stopped = true; |
439 | mb(); |
440 | wake_up(&keypad->wait); |
441 | disable_irq(irq: keypad->client->irq); |
442 | } |
443 | |
444 | static void ht16k33_linedisp_update(struct linedisp *linedisp) |
445 | { |
446 | struct ht16k33_priv *priv = container_of(linedisp, struct ht16k33_priv, |
447 | seg.linedisp); |
448 | |
449 | schedule_delayed_work(dwork: &priv->work, delay: 0); |
450 | } |
451 | |
452 | static void ht16k33_seg7_update(struct work_struct *work) |
453 | { |
454 | struct ht16k33_priv *priv = container_of(work, struct ht16k33_priv, |
455 | work.work); |
456 | struct ht16k33_seg *seg = &priv->seg; |
457 | char *s = seg->curr; |
458 | uint8_t buf[9]; |
459 | |
460 | buf[0] = map_to_seg7(map: &seg->map.seg7, c: *s++); |
461 | buf[1] = 0; |
462 | buf[2] = map_to_seg7(map: &seg->map.seg7, c: *s++); |
463 | buf[3] = 0; |
464 | buf[4] = 0; |
465 | buf[5] = 0; |
466 | buf[6] = map_to_seg7(map: &seg->map.seg7, c: *s++); |
467 | buf[7] = 0; |
468 | buf[8] = map_to_seg7(map: &seg->map.seg7, c: *s++); |
469 | |
470 | i2c_smbus_write_i2c_block_data(client: priv->client, command: 0, ARRAY_SIZE(buf), values: buf); |
471 | } |
472 | |
473 | static void ht16k33_seg14_update(struct work_struct *work) |
474 | { |
475 | struct ht16k33_priv *priv = container_of(work, struct ht16k33_priv, |
476 | work.work); |
477 | struct ht16k33_seg *seg = &priv->seg; |
478 | char *s = seg->curr; |
479 | uint8_t buf[8]; |
480 | |
481 | put_unaligned_le16(val: map_to_seg14(map: &seg->map.seg14, c: *s++), p: buf); |
482 | put_unaligned_le16(val: map_to_seg14(map: &seg->map.seg14, c: *s++), p: buf + 2); |
483 | put_unaligned_le16(val: map_to_seg14(map: &seg->map.seg14, c: *s++), p: buf + 4); |
484 | put_unaligned_le16(val: map_to_seg14(map: &seg->map.seg14, c: *s++), p: buf + 6); |
485 | |
486 | i2c_smbus_write_i2c_block_data(client: priv->client, command: 0, ARRAY_SIZE(buf), values: buf); |
487 | } |
488 | |
489 | static int ht16k33_led_probe(struct device *dev, struct led_classdev *led, |
490 | unsigned int brightness) |
491 | { |
492 | struct led_init_data init_data = {}; |
493 | int err; |
494 | |
495 | /* The LED is optional */ |
496 | init_data.fwnode = device_get_named_child_node(dev, childname: "led" ); |
497 | if (!init_data.fwnode) |
498 | return 0; |
499 | |
500 | init_data.devicename = "auxdisplay" ; |
501 | init_data.devname_mandatory = true; |
502 | |
503 | led->brightness_set_blocking = ht16k33_brightness_set_blocking; |
504 | led->blink_set = ht16k33_blink_set; |
505 | led->flags = LED_CORE_SUSPENDRESUME; |
506 | led->brightness = brightness; |
507 | led->max_brightness = MAX_BRIGHTNESS; |
508 | |
509 | err = devm_led_classdev_register_ext(parent: dev, led_cdev: led, init_data: &init_data); |
510 | if (err) |
511 | dev_err(dev, "Failed to register LED\n" ); |
512 | |
513 | return err; |
514 | } |
515 | |
516 | static int ht16k33_keypad_probe(struct i2c_client *client, |
517 | struct ht16k33_keypad *keypad) |
518 | { |
519 | struct device *dev = &client->dev; |
520 | u32 rows = HT16K33_MATRIX_KEYPAD_MAX_ROWS; |
521 | u32 cols = HT16K33_MATRIX_KEYPAD_MAX_COLS; |
522 | int err; |
523 | |
524 | keypad->client = client; |
525 | init_waitqueue_head(&keypad->wait); |
526 | |
527 | keypad->dev = devm_input_allocate_device(dev); |
528 | if (!keypad->dev) |
529 | return -ENOMEM; |
530 | |
531 | input_set_drvdata(dev: keypad->dev, data: keypad); |
532 | |
533 | keypad->dev->name = DRIVER_NAME"-keypad" ; |
534 | keypad->dev->id.bustype = BUS_I2C; |
535 | keypad->dev->open = ht16k33_keypad_start; |
536 | keypad->dev->close = ht16k33_keypad_stop; |
537 | |
538 | if (!device_property_read_bool(dev, propname: "linux,no-autorepeat" )) |
539 | __set_bit(EV_REP, keypad->dev->evbit); |
540 | |
541 | err = device_property_read_u32(dev, propname: "debounce-delay-ms" , |
542 | val: &keypad->debounce_ms); |
543 | if (err) { |
544 | dev_err(dev, "key debounce delay not specified\n" ); |
545 | return err; |
546 | } |
547 | |
548 | err = matrix_keypad_parse_properties(dev, rows: &rows, cols: &cols); |
549 | if (err) |
550 | return err; |
551 | if (rows > HT16K33_MATRIX_KEYPAD_MAX_ROWS || |
552 | cols > HT16K33_MATRIX_KEYPAD_MAX_COLS) { |
553 | dev_err(dev, "%u rows or %u cols out of range in DT\n" , rows, |
554 | cols); |
555 | return -ERANGE; |
556 | } |
557 | |
558 | keypad->rows = rows; |
559 | keypad->cols = cols; |
560 | keypad->row_shift = get_count_order(count: cols); |
561 | |
562 | err = matrix_keypad_build_keymap(NULL, NULL, rows, cols, NULL, |
563 | input_dev: keypad->dev); |
564 | if (err) { |
565 | dev_err(dev, "failed to build keymap\n" ); |
566 | return err; |
567 | } |
568 | |
569 | err = devm_request_threaded_irq(dev, irq: client->irq, NULL, |
570 | thread_fn: ht16k33_keypad_irq_thread, |
571 | IRQF_TRIGGER_HIGH | IRQF_ONESHOT, |
572 | DRIVER_NAME, dev_id: keypad); |
573 | if (err) { |
574 | dev_err(dev, "irq request failed %d, error %d\n" , client->irq, |
575 | err); |
576 | return err; |
577 | } |
578 | |
579 | ht16k33_keypad_stop(dev: keypad->dev); |
580 | |
581 | return input_register_device(keypad->dev); |
582 | } |
583 | |
584 | static int ht16k33_fbdev_probe(struct device *dev, struct ht16k33_priv *priv, |
585 | uint32_t brightness) |
586 | { |
587 | struct ht16k33_fbdev *fbdev = &priv->fbdev; |
588 | struct backlight_device *bl = NULL; |
589 | int err; |
590 | |
591 | if (priv->led.dev) { |
592 | err = ht16k33_brightness_set(priv, brightness); |
593 | if (err) |
594 | return err; |
595 | } else { |
596 | /* backwards compatibility with DT lacking an led subnode */ |
597 | struct backlight_properties bl_props; |
598 | |
599 | memset(&bl_props, 0, sizeof(struct backlight_properties)); |
600 | bl_props.type = BACKLIGHT_RAW; |
601 | bl_props.max_brightness = MAX_BRIGHTNESS; |
602 | |
603 | bl = devm_backlight_device_register(dev, DRIVER_NAME"-bl" , parent: dev, |
604 | devdata: priv, ops: &ht16k33_bl_ops, |
605 | props: &bl_props); |
606 | if (IS_ERR(ptr: bl)) { |
607 | dev_err(dev, "failed to register backlight\n" ); |
608 | return PTR_ERR(ptr: bl); |
609 | } |
610 | |
611 | bl->props.brightness = brightness; |
612 | ht16k33_bl_update_status(bl); |
613 | } |
614 | |
615 | /* Framebuffer (2 bytes per column) */ |
616 | BUILD_BUG_ON(PAGE_SIZE < HT16K33_FB_SIZE); |
617 | fbdev->buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL); |
618 | if (!fbdev->buffer) |
619 | return -ENOMEM; |
620 | |
621 | fbdev->cache = devm_kmalloc(dev, HT16K33_FB_SIZE, GFP_KERNEL); |
622 | if (!fbdev->cache) { |
623 | err = -ENOMEM; |
624 | goto err_fbdev_buffer; |
625 | } |
626 | |
627 | fbdev->info = framebuffer_alloc(size: 0, dev); |
628 | if (!fbdev->info) { |
629 | err = -ENOMEM; |
630 | goto err_fbdev_buffer; |
631 | } |
632 | |
633 | err = device_property_read_u32(dev, propname: "refresh-rate-hz" , |
634 | val: &fbdev->refresh_rate); |
635 | if (err) { |
636 | dev_err(dev, "refresh rate not specified\n" ); |
637 | goto err_fbdev_info; |
638 | } |
639 | fb_bl_default_curve(fb_info: fbdev->info, off: 0, MIN_BRIGHTNESS, MAX_BRIGHTNESS); |
640 | |
641 | INIT_DELAYED_WORK(&priv->work, ht16k33_fb_update); |
642 | fbdev->info->fbops = &ht16k33_fb_ops; |
643 | fbdev->info->screen_buffer = fbdev->buffer; |
644 | fbdev->info->screen_size = HT16K33_FB_SIZE; |
645 | fbdev->info->fix = ht16k33_fb_fix; |
646 | fbdev->info->var = ht16k33_fb_var; |
647 | fbdev->info->bl_dev = bl; |
648 | fbdev->info->pseudo_palette = NULL; |
649 | fbdev->info->par = priv; |
650 | |
651 | err = register_framebuffer(fb_info: fbdev->info); |
652 | if (err) |
653 | goto err_fbdev_info; |
654 | |
655 | ht16k33_fb_queue(priv); |
656 | return 0; |
657 | |
658 | err_fbdev_info: |
659 | framebuffer_release(info: fbdev->info); |
660 | err_fbdev_buffer: |
661 | free_page((unsigned long) fbdev->buffer); |
662 | |
663 | return err; |
664 | } |
665 | |
666 | static int ht16k33_seg_probe(struct device *dev, struct ht16k33_priv *priv, |
667 | uint32_t brightness) |
668 | { |
669 | struct ht16k33_seg *seg = &priv->seg; |
670 | int err; |
671 | |
672 | err = ht16k33_brightness_set(priv, brightness); |
673 | if (err) |
674 | return err; |
675 | |
676 | switch (priv->type) { |
677 | case DISP_MATRIX: |
678 | /* not handled here */ |
679 | err = -EINVAL; |
680 | break; |
681 | |
682 | case DISP_QUAD_7SEG: |
683 | INIT_DELAYED_WORK(&priv->work, ht16k33_seg7_update); |
684 | seg->map.seg7 = initial_map_seg7; |
685 | seg->map_size = sizeof(seg->map.seg7); |
686 | err = device_create_file(device: dev, entry: &dev_attr_map_seg7); |
687 | break; |
688 | |
689 | case DISP_QUAD_14SEG: |
690 | INIT_DELAYED_WORK(&priv->work, ht16k33_seg14_update); |
691 | seg->map.seg14 = initial_map_seg14; |
692 | seg->map_size = sizeof(seg->map.seg14); |
693 | err = device_create_file(device: dev, entry: &dev_attr_map_seg14); |
694 | break; |
695 | } |
696 | if (err) |
697 | return err; |
698 | |
699 | err = linedisp_register(linedisp: &seg->linedisp, parent: dev, num_chars: 4, buf: seg->curr, |
700 | update: ht16k33_linedisp_update); |
701 | if (err) |
702 | goto err_remove_map_file; |
703 | |
704 | return 0; |
705 | |
706 | err_remove_map_file: |
707 | device_remove_file(dev, attr: &dev_attr_map_seg7); |
708 | device_remove_file(dev, attr: &dev_attr_map_seg14); |
709 | return err; |
710 | } |
711 | |
712 | static int ht16k33_probe(struct i2c_client *client) |
713 | { |
714 | struct device *dev = &client->dev; |
715 | const struct of_device_id *id; |
716 | struct ht16k33_priv *priv; |
717 | uint32_t dft_brightness; |
718 | int err; |
719 | |
720 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C)) { |
721 | dev_err(dev, "i2c_check_functionality error\n" ); |
722 | return -EIO; |
723 | } |
724 | |
725 | priv = devm_kzalloc(dev, size: sizeof(*priv), GFP_KERNEL); |
726 | if (!priv) |
727 | return -ENOMEM; |
728 | |
729 | priv->client = client; |
730 | id = i2c_of_match_device(matches: dev->driver->of_match_table, client); |
731 | if (id) |
732 | priv->type = (uintptr_t)id->data; |
733 | i2c_set_clientdata(client, data: priv); |
734 | |
735 | err = ht16k33_initialize(priv); |
736 | if (err) |
737 | return err; |
738 | |
739 | err = device_property_read_u32(dev, propname: "default-brightness-level" , |
740 | val: &dft_brightness); |
741 | if (err) { |
742 | dft_brightness = MAX_BRIGHTNESS; |
743 | } else if (dft_brightness > MAX_BRIGHTNESS) { |
744 | dev_warn(dev, |
745 | "invalid default brightness level: %u, using %u\n" , |
746 | dft_brightness, MAX_BRIGHTNESS); |
747 | dft_brightness = MAX_BRIGHTNESS; |
748 | } |
749 | |
750 | /* LED */ |
751 | err = ht16k33_led_probe(dev, led: &priv->led, brightness: dft_brightness); |
752 | if (err) |
753 | return err; |
754 | |
755 | /* Keypad */ |
756 | if (client->irq > 0) { |
757 | err = ht16k33_keypad_probe(client, keypad: &priv->keypad); |
758 | if (err) |
759 | return err; |
760 | } |
761 | |
762 | switch (priv->type) { |
763 | case DISP_MATRIX: |
764 | /* Frame Buffer Display */ |
765 | err = ht16k33_fbdev_probe(dev, priv, brightness: dft_brightness); |
766 | break; |
767 | |
768 | case DISP_QUAD_7SEG: |
769 | case DISP_QUAD_14SEG: |
770 | /* Segment Display */ |
771 | err = ht16k33_seg_probe(dev, priv, brightness: dft_brightness); |
772 | break; |
773 | } |
774 | return err; |
775 | } |
776 | |
777 | static void ht16k33_remove(struct i2c_client *client) |
778 | { |
779 | struct ht16k33_priv *priv = i2c_get_clientdata(client); |
780 | struct ht16k33_fbdev *fbdev = &priv->fbdev; |
781 | |
782 | cancel_delayed_work_sync(dwork: &priv->work); |
783 | |
784 | switch (priv->type) { |
785 | case DISP_MATRIX: |
786 | unregister_framebuffer(fb_info: fbdev->info); |
787 | framebuffer_release(info: fbdev->info); |
788 | free_page((unsigned long)fbdev->buffer); |
789 | break; |
790 | |
791 | case DISP_QUAD_7SEG: |
792 | case DISP_QUAD_14SEG: |
793 | linedisp_unregister(linedisp: &priv->seg.linedisp); |
794 | device_remove_file(dev: &client->dev, attr: &dev_attr_map_seg7); |
795 | device_remove_file(dev: &client->dev, attr: &dev_attr_map_seg14); |
796 | break; |
797 | } |
798 | } |
799 | |
800 | static const struct i2c_device_id ht16k33_i2c_match[] = { |
801 | { "ht16k33" , 0 }, |
802 | { } |
803 | }; |
804 | MODULE_DEVICE_TABLE(i2c, ht16k33_i2c_match); |
805 | |
806 | static const struct of_device_id ht16k33_of_match[] = { |
807 | { |
808 | /* 0.56" 4-Digit 7-Segment FeatherWing Display (Red) */ |
809 | .compatible = "adafruit,3108" , .data = (void *)DISP_QUAD_7SEG, |
810 | }, { |
811 | /* 0.54" Quad Alphanumeric FeatherWing Display (Red) */ |
812 | .compatible = "adafruit,3130" , .data = (void *)DISP_QUAD_14SEG, |
813 | }, { |
814 | /* Generic, assumed Dot-Matrix Display */ |
815 | .compatible = "holtek,ht16k33" , .data = (void *)DISP_MATRIX, |
816 | }, |
817 | { } |
818 | }; |
819 | MODULE_DEVICE_TABLE(of, ht16k33_of_match); |
820 | |
821 | static struct i2c_driver ht16k33_driver = { |
822 | .probe = ht16k33_probe, |
823 | .remove = ht16k33_remove, |
824 | .driver = { |
825 | .name = DRIVER_NAME, |
826 | .of_match_table = ht16k33_of_match, |
827 | }, |
828 | .id_table = ht16k33_i2c_match, |
829 | }; |
830 | module_i2c_driver(ht16k33_driver); |
831 | |
832 | MODULE_DESCRIPTION("Holtek HT16K33 driver" ); |
833 | MODULE_LICENSE("GPL" ); |
834 | MODULE_AUTHOR("Robin van der Gracht <robin@protonic.nl>" ); |
835 | |