xref: /openbmc/linux/drivers/auxdisplay/ht16k33.c (revision 64dc362d)
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 
map_seg_show(struct device * dev,struct device_attribute * attr,char * buf)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 
map_seg_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t cnt)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 
ht16k33_display_on(struct ht16k33_priv * priv)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(priv->client, data);
170 }
171 
ht16k33_display_off(struct ht16k33_priv * priv)172 static int ht16k33_display_off(struct ht16k33_priv *priv)
173 {
174 	return i2c_smbus_write_byte(priv->client, REG_DISPLAY_SETUP);
175 }
176 
ht16k33_brightness_set(struct ht16k33_priv * priv,unsigned int brightness)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(priv->client,
192 				    REG_BRIGHTNESS | (brightness - 1));
193 }
194 
ht16k33_brightness_set_blocking(struct led_classdev * led_cdev,enum led_brightness brightness)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 
ht16k33_blink_set(struct led_classdev * led_cdev,unsigned long * delay_on,unsigned long * delay_off)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(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 
ht16k33_fb_queue(struct ht16k33_priv * priv)238 static void ht16k33_fb_queue(struct ht16k33_priv *priv)
239 {
240 	struct ht16k33_fbdev *fbdev = &priv->fbdev;
241 
242 	schedule_delayed_work(&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  */
ht16k33_fb_update(struct work_struct * work)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(priv->client, first, len, p2))
285 		memcpy(p1, p2, len);
286 requeue:
287 	ht16k33_fb_queue(priv);
288 }
289 
ht16k33_initialize(struct ht16k33_priv * priv)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(priv->client, 0, sizeof(data), 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(priv->client, 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(priv->client, byte);
313 }
314 
ht16k33_bl_update_status(struct backlight_device * bl)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);
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 
ht16k33_bl_check_fb(struct backlight_device * bl,struct fb_info * fi)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);
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  */
ht16k33_blank(int blank,struct fb_info * info)344 static int ht16k33_blank(int blank, struct fb_info *info)
345 {
346 	return 0;
347 }
348 
ht16k33_mmap(struct fb_info * info,struct vm_area_struct * vma)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, 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  */
ht16k33_keypad_scan(struct ht16k33_keypad * keypad)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(keypad->client, 0x40,
383 					   sizeof(data), (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(keypad->dev, EV_MSC, MSC_SCAN, code);
399 			input_report_key(keypad->dev, keycodes[code],
400 					 new_state[col] & BIT(row));
401 		}
402 	}
403 	input_sync(keypad->dev);
404 	memcpy(keypad->last_key_state, new_state, sizeof(u16) * keypad->cols);
405 
406 	return pressed;
407 }
408 
ht16k33_keypad_irq_thread(int irq,void * dev)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 
ht16k33_keypad_start(struct input_dev * dev)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(keypad->client->irq);
430 
431 	return 0;
432 }
433 
ht16k33_keypad_stop(struct input_dev * dev)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(keypad->client->irq);
442 }
443 
ht16k33_linedisp_update(struct linedisp * linedisp)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(&priv->work, 0);
450 }
451 
ht16k33_seg7_update(struct work_struct * work)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(&seg->map.seg7, *s++);
461 	buf[1] = 0;
462 	buf[2] = map_to_seg7(&seg->map.seg7, *s++);
463 	buf[3] = 0;
464 	buf[4] = 0;
465 	buf[5] = 0;
466 	buf[6] = map_to_seg7(&seg->map.seg7, *s++);
467 	buf[7] = 0;
468 	buf[8] = map_to_seg7(&seg->map.seg7, *s++);
469 
470 	i2c_smbus_write_i2c_block_data(priv->client, 0, ARRAY_SIZE(buf), buf);
471 }
472 
ht16k33_seg14_update(struct work_struct * work)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(map_to_seg14(&seg->map.seg14, *s++), buf);
482 	put_unaligned_le16(map_to_seg14(&seg->map.seg14, *s++), buf + 2);
483 	put_unaligned_le16(map_to_seg14(&seg->map.seg14, *s++), buf + 4);
484 	put_unaligned_le16(map_to_seg14(&seg->map.seg14, *s++), buf + 6);
485 
486 	i2c_smbus_write_i2c_block_data(priv->client, 0, ARRAY_SIZE(buf), buf);
487 }
488 
ht16k33_led_probe(struct device * dev,struct led_classdev * led,unsigned int brightness)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, "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(dev, led, &init_data);
510 	fwnode_handle_put(init_data.fwnode);
511 	if (err)
512 		dev_err(dev, "Failed to register LED\n");
513 
514 	return err;
515 }
516 
ht16k33_keypad_probe(struct i2c_client * client,struct ht16k33_keypad * keypad)517 static int ht16k33_keypad_probe(struct i2c_client *client,
518 				struct ht16k33_keypad *keypad)
519 {
520 	struct device *dev = &client->dev;
521 	u32 rows = HT16K33_MATRIX_KEYPAD_MAX_ROWS;
522 	u32 cols = HT16K33_MATRIX_KEYPAD_MAX_COLS;
523 	int err;
524 
525 	keypad->client = client;
526 	init_waitqueue_head(&keypad->wait);
527 
528 	keypad->dev = devm_input_allocate_device(dev);
529 	if (!keypad->dev)
530 		return -ENOMEM;
531 
532 	input_set_drvdata(keypad->dev, keypad);
533 
534 	keypad->dev->name = DRIVER_NAME"-keypad";
535 	keypad->dev->id.bustype = BUS_I2C;
536 	keypad->dev->open = ht16k33_keypad_start;
537 	keypad->dev->close = ht16k33_keypad_stop;
538 
539 	if (!device_property_read_bool(dev, "linux,no-autorepeat"))
540 		__set_bit(EV_REP, keypad->dev->evbit);
541 
542 	err = device_property_read_u32(dev, "debounce-delay-ms",
543 				       &keypad->debounce_ms);
544 	if (err) {
545 		dev_err(dev, "key debounce delay not specified\n");
546 		return err;
547 	}
548 
549 	err = matrix_keypad_parse_properties(dev, &rows, &cols);
550 	if (err)
551 		return err;
552 	if (rows > HT16K33_MATRIX_KEYPAD_MAX_ROWS ||
553 	    cols > HT16K33_MATRIX_KEYPAD_MAX_COLS) {
554 		dev_err(dev, "%u rows or %u cols out of range in DT\n", rows,
555 			cols);
556 		return -ERANGE;
557 	}
558 
559 	keypad->rows = rows;
560 	keypad->cols = cols;
561 	keypad->row_shift = get_count_order(cols);
562 
563 	err = matrix_keypad_build_keymap(NULL, NULL, rows, cols, NULL,
564 					 keypad->dev);
565 	if (err) {
566 		dev_err(dev, "failed to build keymap\n");
567 		return err;
568 	}
569 
570 	err = devm_request_threaded_irq(dev, client->irq, NULL,
571 					ht16k33_keypad_irq_thread,
572 					IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
573 					DRIVER_NAME, keypad);
574 	if (err) {
575 		dev_err(dev, "irq request failed %d, error %d\n", client->irq,
576 			err);
577 		return err;
578 	}
579 
580 	ht16k33_keypad_stop(keypad->dev);
581 
582 	return input_register_device(keypad->dev);
583 }
584 
ht16k33_fbdev_probe(struct device * dev,struct ht16k33_priv * priv,uint32_t brightness)585 static int ht16k33_fbdev_probe(struct device *dev, struct ht16k33_priv *priv,
586 			       uint32_t brightness)
587 {
588 	struct ht16k33_fbdev *fbdev = &priv->fbdev;
589 	struct backlight_device *bl = NULL;
590 	int err;
591 
592 	if (priv->led.dev) {
593 		err = ht16k33_brightness_set(priv, brightness);
594 		if (err)
595 			return err;
596 	} else {
597 		/* backwards compatibility with DT lacking an led subnode */
598 		struct backlight_properties bl_props;
599 
600 		memset(&bl_props, 0, sizeof(struct backlight_properties));
601 		bl_props.type = BACKLIGHT_RAW;
602 		bl_props.max_brightness = MAX_BRIGHTNESS;
603 
604 		bl = devm_backlight_device_register(dev, DRIVER_NAME"-bl", dev,
605 						    priv, &ht16k33_bl_ops,
606 						    &bl_props);
607 		if (IS_ERR(bl)) {
608 			dev_err(dev, "failed to register backlight\n");
609 			return PTR_ERR(bl);
610 		}
611 
612 		bl->props.brightness = brightness;
613 		ht16k33_bl_update_status(bl);
614 	}
615 
616 	/* Framebuffer (2 bytes per column) */
617 	BUILD_BUG_ON(PAGE_SIZE < HT16K33_FB_SIZE);
618 	fbdev->buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL);
619 	if (!fbdev->buffer)
620 		return -ENOMEM;
621 
622 	fbdev->cache = devm_kmalloc(dev, HT16K33_FB_SIZE, GFP_KERNEL);
623 	if (!fbdev->cache) {
624 		err = -ENOMEM;
625 		goto err_fbdev_buffer;
626 	}
627 
628 	fbdev->info = framebuffer_alloc(0, dev);
629 	if (!fbdev->info) {
630 		err = -ENOMEM;
631 		goto err_fbdev_buffer;
632 	}
633 
634 	err = device_property_read_u32(dev, "refresh-rate-hz",
635 				       &fbdev->refresh_rate);
636 	if (err) {
637 		dev_err(dev, "refresh rate not specified\n");
638 		goto err_fbdev_info;
639 	}
640 	fb_bl_default_curve(fbdev->info, 0, MIN_BRIGHTNESS, MAX_BRIGHTNESS);
641 
642 	INIT_DELAYED_WORK(&priv->work, ht16k33_fb_update);
643 	fbdev->info->fbops = &ht16k33_fb_ops;
644 	fbdev->info->screen_buffer = fbdev->buffer;
645 	fbdev->info->screen_size = HT16K33_FB_SIZE;
646 	fbdev->info->fix = ht16k33_fb_fix;
647 	fbdev->info->var = ht16k33_fb_var;
648 	fbdev->info->bl_dev = bl;
649 	fbdev->info->pseudo_palette = NULL;
650 	fbdev->info->par = priv;
651 
652 	err = register_framebuffer(fbdev->info);
653 	if (err)
654 		goto err_fbdev_info;
655 
656 	ht16k33_fb_queue(priv);
657 	return 0;
658 
659 err_fbdev_info:
660 	framebuffer_release(fbdev->info);
661 err_fbdev_buffer:
662 	free_page((unsigned long) fbdev->buffer);
663 
664 	return err;
665 }
666 
ht16k33_seg_probe(struct device * dev,struct ht16k33_priv * priv,uint32_t brightness)667 static int ht16k33_seg_probe(struct device *dev, struct ht16k33_priv *priv,
668 			     uint32_t brightness)
669 {
670 	struct ht16k33_seg *seg = &priv->seg;
671 	int err;
672 
673 	err = ht16k33_brightness_set(priv, brightness);
674 	if (err)
675 		return err;
676 
677 	switch (priv->type) {
678 	case DISP_MATRIX:
679 		/* not handled here */
680 		err = -EINVAL;
681 		break;
682 
683 	case DISP_QUAD_7SEG:
684 		INIT_DELAYED_WORK(&priv->work, ht16k33_seg7_update);
685 		seg->map.seg7 = initial_map_seg7;
686 		seg->map_size = sizeof(seg->map.seg7);
687 		err = device_create_file(dev, &dev_attr_map_seg7);
688 		break;
689 
690 	case DISP_QUAD_14SEG:
691 		INIT_DELAYED_WORK(&priv->work, ht16k33_seg14_update);
692 		seg->map.seg14 = initial_map_seg14;
693 		seg->map_size = sizeof(seg->map.seg14);
694 		err = device_create_file(dev, &dev_attr_map_seg14);
695 		break;
696 	}
697 	if (err)
698 		return err;
699 
700 	err = linedisp_register(&seg->linedisp, dev, 4, seg->curr,
701 				ht16k33_linedisp_update);
702 	if (err)
703 		goto err_remove_map_file;
704 
705 	return 0;
706 
707 err_remove_map_file:
708 	device_remove_file(dev, &dev_attr_map_seg7);
709 	device_remove_file(dev, &dev_attr_map_seg14);
710 	return err;
711 }
712 
ht16k33_probe(struct i2c_client * client)713 static int ht16k33_probe(struct i2c_client *client)
714 {
715 	struct device *dev = &client->dev;
716 	const struct of_device_id *id;
717 	struct ht16k33_priv *priv;
718 	uint32_t dft_brightness;
719 	int err;
720 
721 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
722 		dev_err(dev, "i2c_check_functionality error\n");
723 		return -EIO;
724 	}
725 
726 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
727 	if (!priv)
728 		return -ENOMEM;
729 
730 	priv->client = client;
731 	id = i2c_of_match_device(dev->driver->of_match_table, client);
732 	if (id)
733 		priv->type = (uintptr_t)id->data;
734 	i2c_set_clientdata(client, priv);
735 
736 	err = ht16k33_initialize(priv);
737 	if (err)
738 		return err;
739 
740 	err = device_property_read_u32(dev, "default-brightness-level",
741 				       &dft_brightness);
742 	if (err) {
743 		dft_brightness = MAX_BRIGHTNESS;
744 	} else if (dft_brightness > MAX_BRIGHTNESS) {
745 		dev_warn(dev,
746 			 "invalid default brightness level: %u, using %u\n",
747 			 dft_brightness, MAX_BRIGHTNESS);
748 		dft_brightness = MAX_BRIGHTNESS;
749 	}
750 
751 	/* LED */
752 	err = ht16k33_led_probe(dev, &priv->led, dft_brightness);
753 	if (err)
754 		return err;
755 
756 	/* Keypad */
757 	if (client->irq > 0) {
758 		err = ht16k33_keypad_probe(client, &priv->keypad);
759 		if (err)
760 			return err;
761 	}
762 
763 	switch (priv->type) {
764 	case DISP_MATRIX:
765 		/* Frame Buffer Display */
766 		err = ht16k33_fbdev_probe(dev, priv, dft_brightness);
767 		break;
768 
769 	case DISP_QUAD_7SEG:
770 	case DISP_QUAD_14SEG:
771 		/* Segment Display */
772 		err = ht16k33_seg_probe(dev, priv, dft_brightness);
773 		break;
774 	}
775 	return err;
776 }
777 
ht16k33_remove(struct i2c_client * client)778 static void ht16k33_remove(struct i2c_client *client)
779 {
780 	struct ht16k33_priv *priv = i2c_get_clientdata(client);
781 	struct ht16k33_fbdev *fbdev = &priv->fbdev;
782 
783 	cancel_delayed_work_sync(&priv->work);
784 
785 	switch (priv->type) {
786 	case DISP_MATRIX:
787 		unregister_framebuffer(fbdev->info);
788 		framebuffer_release(fbdev->info);
789 		free_page((unsigned long)fbdev->buffer);
790 		break;
791 
792 	case DISP_QUAD_7SEG:
793 	case DISP_QUAD_14SEG:
794 		linedisp_unregister(&priv->seg.linedisp);
795 		device_remove_file(&client->dev, &dev_attr_map_seg7);
796 		device_remove_file(&client->dev, &dev_attr_map_seg14);
797 		break;
798 	}
799 }
800 
801 static const struct i2c_device_id ht16k33_i2c_match[] = {
802 	{ "ht16k33", 0 },
803 	{ }
804 };
805 MODULE_DEVICE_TABLE(i2c, ht16k33_i2c_match);
806 
807 static const struct of_device_id ht16k33_of_match[] = {
808 	{
809 		/* 0.56" 4-Digit 7-Segment FeatherWing Display (Red) */
810 		.compatible = "adafruit,3108", .data = (void *)DISP_QUAD_7SEG,
811 	}, {
812 		/* 0.54" Quad Alphanumeric FeatherWing Display (Red) */
813 		.compatible = "adafruit,3130", .data = (void *)DISP_QUAD_14SEG,
814 	}, {
815 		/* Generic, assumed Dot-Matrix Display */
816 		.compatible = "holtek,ht16k33", .data = (void *)DISP_MATRIX,
817 	},
818 	{ }
819 };
820 MODULE_DEVICE_TABLE(of, ht16k33_of_match);
821 
822 static struct i2c_driver ht16k33_driver = {
823 	.probe		= ht16k33_probe,
824 	.remove		= ht16k33_remove,
825 	.driver		= {
826 		.name		= DRIVER_NAME,
827 		.of_match_table	= ht16k33_of_match,
828 	},
829 	.id_table = ht16k33_i2c_match,
830 };
831 module_i2c_driver(ht16k33_driver);
832 
833 MODULE_DESCRIPTION("Holtek HT16K33 driver");
834 MODULE_LICENSE("GPL");
835 MODULE_AUTHOR("Robin van der Gracht <robin@protonic.nl>");
836