Merge branch 'vmwgfx-fixes-5.1' of git://people.freedesktop.org/~thomash/linux into...
[sfrench/cifs-2.6.git] / drivers / auxdisplay / ht16k33.c
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  */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/interrupt.h>
13 #include <linux/i2c.h>
14 #include <linux/of.h>
15 #include <linux/fb.h>
16 #include <linux/slab.h>
17 #include <linux/backlight.h>
18 #include <linux/input.h>
19 #include <linux/input/matrix_keypad.h>
20 #include <linux/workqueue.h>
21 #include <linux/mm.h>
22
23 /* Registers */
24 #define REG_SYSTEM_SETUP                0x20
25 #define REG_SYSTEM_SETUP_OSC_ON         BIT(0)
26
27 #define REG_DISPLAY_SETUP               0x80
28 #define REG_DISPLAY_SETUP_ON            BIT(0)
29
30 #define REG_ROWINT_SET                  0xA0
31 #define REG_ROWINT_SET_INT_EN           BIT(0)
32 #define REG_ROWINT_SET_INT_ACT_HIGH     BIT(1)
33
34 #define REG_BRIGHTNESS                  0xE0
35
36 /* Defines */
37 #define DRIVER_NAME                     "ht16k33"
38
39 #define MIN_BRIGHTNESS                  0x1
40 #define MAX_BRIGHTNESS                  0x10
41
42 #define HT16K33_MATRIX_LED_MAX_COLS     8
43 #define HT16K33_MATRIX_LED_MAX_ROWS     16
44 #define HT16K33_MATRIX_KEYPAD_MAX_COLS  3
45 #define HT16K33_MATRIX_KEYPAD_MAX_ROWS  12
46
47 #define BYTES_PER_ROW           (HT16K33_MATRIX_LED_MAX_ROWS / 8)
48 #define HT16K33_FB_SIZE         (HT16K33_MATRIX_LED_MAX_COLS * BYTES_PER_ROW)
49
50 struct ht16k33_keypad {
51         struct i2c_client *client;
52         struct input_dev *dev;
53         uint32_t cols;
54         uint32_t rows;
55         uint32_t row_shift;
56         uint32_t debounce_ms;
57         uint16_t last_key_state[HT16K33_MATRIX_KEYPAD_MAX_COLS];
58
59         wait_queue_head_t wait;
60         bool stopped;
61 };
62
63 struct ht16k33_fbdev {
64         struct fb_info *info;
65         uint32_t refresh_rate;
66         uint8_t *buffer;
67         uint8_t *cache;
68         struct delayed_work work;
69 };
70
71 struct ht16k33_priv {
72         struct i2c_client *client;
73         struct ht16k33_keypad keypad;
74         struct ht16k33_fbdev fbdev;
75 };
76
77 static struct fb_fix_screeninfo ht16k33_fb_fix = {
78         .id             = DRIVER_NAME,
79         .type           = FB_TYPE_PACKED_PIXELS,
80         .visual         = FB_VISUAL_MONO10,
81         .xpanstep       = 0,
82         .ypanstep       = 0,
83         .ywrapstep      = 0,
84         .line_length    = HT16K33_MATRIX_LED_MAX_ROWS,
85         .accel          = FB_ACCEL_NONE,
86 };
87
88 static struct fb_var_screeninfo ht16k33_fb_var = {
89         .xres = HT16K33_MATRIX_LED_MAX_ROWS,
90         .yres = HT16K33_MATRIX_LED_MAX_COLS,
91         .xres_virtual = HT16K33_MATRIX_LED_MAX_ROWS,
92         .yres_virtual = HT16K33_MATRIX_LED_MAX_COLS,
93         .bits_per_pixel = 1,
94         .red = { 0, 1, 0 },
95         .green = { 0, 1, 0 },
96         .blue = { 0, 1, 0 },
97         .left_margin = 0,
98         .right_margin = 0,
99         .upper_margin = 0,
100         .lower_margin = 0,
101         .vmode = FB_VMODE_NONINTERLACED,
102 };
103
104 static int ht16k33_display_on(struct ht16k33_priv *priv)
105 {
106         uint8_t data = REG_DISPLAY_SETUP | REG_DISPLAY_SETUP_ON;
107
108         return i2c_smbus_write_byte(priv->client, data);
109 }
110
111 static int ht16k33_display_off(struct ht16k33_priv *priv)
112 {
113         return i2c_smbus_write_byte(priv->client, REG_DISPLAY_SETUP);
114 }
115
116 static void ht16k33_fb_queue(struct ht16k33_priv *priv)
117 {
118         struct ht16k33_fbdev *fbdev = &priv->fbdev;
119
120         schedule_delayed_work(&fbdev->work,
121                               msecs_to_jiffies(HZ / fbdev->refresh_rate));
122 }
123
124 /*
125  * This gets the fb data from cache and copies it to ht16k33 display RAM
126  */
127 static void ht16k33_fb_update(struct work_struct *work)
128 {
129         struct ht16k33_fbdev *fbdev =
130                 container_of(work, struct ht16k33_fbdev, work.work);
131         struct ht16k33_priv *priv =
132                 container_of(fbdev, struct ht16k33_priv, fbdev);
133
134         uint8_t *p1, *p2;
135         int len, pos = 0, first = -1;
136
137         p1 = fbdev->cache;
138         p2 = fbdev->buffer;
139
140         /* Search for the first byte with changes */
141         while (pos < HT16K33_FB_SIZE && first < 0) {
142                 if (*(p1++) - *(p2++))
143                         first = pos;
144                 pos++;
145         }
146
147         /* No changes found */
148         if (first < 0)
149                 goto requeue;
150
151         len = HT16K33_FB_SIZE - first;
152         p1 = fbdev->cache + HT16K33_FB_SIZE - 1;
153         p2 = fbdev->buffer + HT16K33_FB_SIZE - 1;
154
155         /* Determine i2c transfer length */
156         while (len > 1) {
157                 if (*(p1--) - *(p2--))
158                         break;
159                 len--;
160         }
161
162         p1 = fbdev->cache + first;
163         p2 = fbdev->buffer + first;
164         if (!i2c_smbus_write_i2c_block_data(priv->client, first, len, p2))
165                 memcpy(p1, p2, len);
166 requeue:
167         ht16k33_fb_queue(priv);
168 }
169
170 static int ht16k33_initialize(struct ht16k33_priv *priv)
171 {
172         uint8_t byte;
173         int err;
174         uint8_t data[HT16K33_MATRIX_LED_MAX_COLS * 2];
175
176         /* Clear RAM (8 * 16 bits) */
177         memset(data, 0, sizeof(data));
178         err = i2c_smbus_write_block_data(priv->client, 0, sizeof(data), data);
179         if (err)
180                 return err;
181
182         /* Turn on internal oscillator */
183         byte = REG_SYSTEM_SETUP_OSC_ON | REG_SYSTEM_SETUP;
184         err = i2c_smbus_write_byte(priv->client, byte);
185         if (err)
186                 return err;
187
188         /* Configure INT pin */
189         byte = REG_ROWINT_SET | REG_ROWINT_SET_INT_ACT_HIGH;
190         if (priv->client->irq > 0)
191                 byte |= REG_ROWINT_SET_INT_EN;
192         return i2c_smbus_write_byte(priv->client, byte);
193 }
194
195 static int ht16k33_bl_update_status(struct backlight_device *bl)
196 {
197         int brightness = bl->props.brightness;
198         struct ht16k33_priv *priv = bl_get_data(bl);
199
200         if (bl->props.power != FB_BLANK_UNBLANK ||
201             bl->props.fb_blank != FB_BLANK_UNBLANK ||
202             bl->props.state & BL_CORE_FBBLANK || brightness == 0) {
203                 return ht16k33_display_off(priv);
204         }
205
206         ht16k33_display_on(priv);
207         return i2c_smbus_write_byte(priv->client,
208                                     REG_BRIGHTNESS | (brightness - 1));
209 }
210
211 static int ht16k33_bl_check_fb(struct backlight_device *bl, struct fb_info *fi)
212 {
213         struct ht16k33_priv *priv = bl_get_data(bl);
214
215         return (fi == NULL) || (fi->par == priv);
216 }
217
218 static const struct backlight_ops ht16k33_bl_ops = {
219         .update_status  = ht16k33_bl_update_status,
220         .check_fb       = ht16k33_bl_check_fb,
221 };
222
223 static int ht16k33_mmap(struct fb_info *info, struct vm_area_struct *vma)
224 {
225         struct ht16k33_priv *priv = info->par;
226
227         return vm_insert_page(vma, vma->vm_start,
228                               virt_to_page(priv->fbdev.buffer));
229 }
230
231 static struct fb_ops ht16k33_fb_ops = {
232         .owner = THIS_MODULE,
233         .fb_read = fb_sys_read,
234         .fb_write = fb_sys_write,
235         .fb_fillrect = sys_fillrect,
236         .fb_copyarea = sys_copyarea,
237         .fb_imageblit = sys_imageblit,
238         .fb_mmap = ht16k33_mmap,
239 };
240
241 /*
242  * This gets the keys from keypad and reports it to input subsystem.
243  * Returns true if a key is pressed.
244  */
245 static bool ht16k33_keypad_scan(struct ht16k33_keypad *keypad)
246 {
247         const unsigned short *keycodes = keypad->dev->keycode;
248         u16 new_state[HT16K33_MATRIX_KEYPAD_MAX_COLS];
249         __le16 data[HT16K33_MATRIX_KEYPAD_MAX_COLS];
250         unsigned long bits_changed;
251         int row, col, code;
252         int rc;
253         bool pressed = false;
254
255         rc = i2c_smbus_read_i2c_block_data(keypad->client, 0x40,
256                                            sizeof(data), (u8 *)data);
257         if (rc != sizeof(data)) {
258                 dev_err(&keypad->client->dev,
259                         "Failed to read key data, rc=%d\n", rc);
260                 return false;
261         }
262
263         for (col = 0; col < keypad->cols; col++) {
264                 new_state[col] = le16_to_cpu(data[col]);
265                 if (new_state[col])
266                         pressed = true;
267                 bits_changed = keypad->last_key_state[col] ^ new_state[col];
268
269                 for_each_set_bit(row, &bits_changed, BITS_PER_LONG) {
270                         code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
271                         input_event(keypad->dev, EV_MSC, MSC_SCAN, code);
272                         input_report_key(keypad->dev, keycodes[code],
273                                          new_state[col] & BIT(row));
274                 }
275         }
276         input_sync(keypad->dev);
277         memcpy(keypad->last_key_state, new_state, sizeof(u16) * keypad->cols);
278
279         return pressed;
280 }
281
282 static irqreturn_t ht16k33_keypad_irq_thread(int irq, void *dev)
283 {
284         struct ht16k33_keypad *keypad = dev;
285
286         do {
287                 wait_event_timeout(keypad->wait, keypad->stopped,
288                                     msecs_to_jiffies(keypad->debounce_ms));
289                 if (keypad->stopped)
290                         break;
291         } while (ht16k33_keypad_scan(keypad));
292
293         return IRQ_HANDLED;
294 }
295
296 static int ht16k33_keypad_start(struct input_dev *dev)
297 {
298         struct ht16k33_keypad *keypad = input_get_drvdata(dev);
299
300         keypad->stopped = false;
301         mb();
302         enable_irq(keypad->client->irq);
303
304         return 0;
305 }
306
307 static void ht16k33_keypad_stop(struct input_dev *dev)
308 {
309         struct ht16k33_keypad *keypad = input_get_drvdata(dev);
310
311         keypad->stopped = true;
312         mb();
313         wake_up(&keypad->wait);
314         disable_irq(keypad->client->irq);
315 }
316
317 static int ht16k33_keypad_probe(struct i2c_client *client,
318                                 struct ht16k33_keypad *keypad)
319 {
320         struct device_node *node = client->dev.of_node;
321         u32 rows = HT16K33_MATRIX_KEYPAD_MAX_ROWS;
322         u32 cols = HT16K33_MATRIX_KEYPAD_MAX_COLS;
323         int err;
324
325         keypad->client = client;
326         init_waitqueue_head(&keypad->wait);
327
328         keypad->dev = devm_input_allocate_device(&client->dev);
329         if (!keypad->dev)
330                 return -ENOMEM;
331
332         input_set_drvdata(keypad->dev, keypad);
333
334         keypad->dev->name = DRIVER_NAME"-keypad";
335         keypad->dev->id.bustype = BUS_I2C;
336         keypad->dev->open = ht16k33_keypad_start;
337         keypad->dev->close = ht16k33_keypad_stop;
338
339         if (!of_get_property(node, "linux,no-autorepeat", NULL))
340                 __set_bit(EV_REP, keypad->dev->evbit);
341
342         err = of_property_read_u32(node, "debounce-delay-ms",
343                                    &keypad->debounce_ms);
344         if (err) {
345                 dev_err(&client->dev, "key debounce delay not specified\n");
346                 return err;
347         }
348
349         err = matrix_keypad_parse_of_params(&client->dev, &rows, &cols);
350         if (err)
351                 return err;
352         if (rows > HT16K33_MATRIX_KEYPAD_MAX_ROWS ||
353             cols > HT16K33_MATRIX_KEYPAD_MAX_COLS) {
354                 dev_err(&client->dev, "%u rows or %u cols out of range in DT\n",
355                         rows, cols);
356                 return -ERANGE;
357         }
358
359         keypad->rows = rows;
360         keypad->cols = cols;
361         keypad->row_shift = get_count_order(cols);
362
363         err = matrix_keypad_build_keymap(NULL, NULL, rows, cols, NULL,
364                                          keypad->dev);
365         if (err) {
366                 dev_err(&client->dev, "failed to build keymap\n");
367                 return err;
368         }
369
370         err = devm_request_threaded_irq(&client->dev, client->irq,
371                                         NULL, ht16k33_keypad_irq_thread,
372                                         IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
373                                         DRIVER_NAME, keypad);
374         if (err) {
375                 dev_err(&client->dev, "irq request failed %d, error %d\n",
376                         client->irq, err);
377                 return err;
378         }
379
380         ht16k33_keypad_stop(keypad->dev);
381
382         err = input_register_device(keypad->dev);
383         if (err)
384                 return err;
385
386         return 0;
387 }
388
389 static int ht16k33_probe(struct i2c_client *client,
390                                   const struct i2c_device_id *id)
391 {
392         int err;
393         uint32_t dft_brightness;
394         struct backlight_device *bl;
395         struct backlight_properties bl_props;
396         struct ht16k33_priv *priv;
397         struct ht16k33_fbdev *fbdev;
398         struct device_node *node = client->dev.of_node;
399
400         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
401                 dev_err(&client->dev, "i2c_check_functionality error\n");
402                 return -EIO;
403         }
404
405         if (client->irq <= 0) {
406                 dev_err(&client->dev, "No IRQ specified\n");
407                 return -EINVAL;
408         }
409
410         priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
411         if (!priv)
412                 return -ENOMEM;
413
414         priv->client = client;
415         i2c_set_clientdata(client, priv);
416         fbdev = &priv->fbdev;
417
418         err = ht16k33_initialize(priv);
419         if (err)
420                 return err;
421
422         /* Framebuffer (2 bytes per column) */
423         BUILD_BUG_ON(PAGE_SIZE < HT16K33_FB_SIZE);
424         fbdev->buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL);
425         if (!fbdev->buffer)
426                 return -ENOMEM;
427
428         fbdev->cache = devm_kmalloc(&client->dev, HT16K33_FB_SIZE, GFP_KERNEL);
429         if (!fbdev->cache) {
430                 err = -ENOMEM;
431                 goto err_fbdev_buffer;
432         }
433
434         fbdev->info = framebuffer_alloc(0, &client->dev);
435         if (!fbdev->info) {
436                 err = -ENOMEM;
437                 goto err_fbdev_buffer;
438         }
439
440         err = of_property_read_u32(node, "refresh-rate-hz",
441                 &fbdev->refresh_rate);
442         if (err) {
443                 dev_err(&client->dev, "refresh rate not specified\n");
444                 goto err_fbdev_info;
445         }
446         fb_bl_default_curve(fbdev->info, 0, MIN_BRIGHTNESS, MAX_BRIGHTNESS);
447
448         INIT_DELAYED_WORK(&fbdev->work, ht16k33_fb_update);
449         fbdev->info->fbops = &ht16k33_fb_ops;
450         fbdev->info->screen_base = (char __iomem *) fbdev->buffer;
451         fbdev->info->screen_size = HT16K33_FB_SIZE;
452         fbdev->info->fix = ht16k33_fb_fix;
453         fbdev->info->var = ht16k33_fb_var;
454         fbdev->info->pseudo_palette = NULL;
455         fbdev->info->flags = FBINFO_FLAG_DEFAULT;
456         fbdev->info->par = priv;
457
458         err = register_framebuffer(fbdev->info);
459         if (err)
460                 goto err_fbdev_info;
461
462         err = ht16k33_keypad_probe(client, &priv->keypad);
463         if (err)
464                 goto err_fbdev_unregister;
465
466         /* Backlight */
467         memset(&bl_props, 0, sizeof(struct backlight_properties));
468         bl_props.type = BACKLIGHT_RAW;
469         bl_props.max_brightness = MAX_BRIGHTNESS;
470
471         bl = devm_backlight_device_register(&client->dev, DRIVER_NAME"-bl",
472                                             &client->dev, priv,
473                                             &ht16k33_bl_ops, &bl_props);
474         if (IS_ERR(bl)) {
475                 dev_err(&client->dev, "failed to register backlight\n");
476                 err = PTR_ERR(bl);
477                 goto err_fbdev_unregister;
478         }
479
480         err = of_property_read_u32(node, "default-brightness-level",
481                                    &dft_brightness);
482         if (err) {
483                 dft_brightness = MAX_BRIGHTNESS;
484         } else if (dft_brightness > MAX_BRIGHTNESS) {
485                 dev_warn(&client->dev,
486                          "invalid default brightness level: %u, using %u\n",
487                          dft_brightness, MAX_BRIGHTNESS);
488                 dft_brightness = MAX_BRIGHTNESS;
489         }
490
491         bl->props.brightness = dft_brightness;
492         ht16k33_bl_update_status(bl);
493
494         ht16k33_fb_queue(priv);
495         return 0;
496
497 err_fbdev_unregister:
498         unregister_framebuffer(fbdev->info);
499 err_fbdev_info:
500         framebuffer_release(fbdev->info);
501 err_fbdev_buffer:
502         free_page((unsigned long) fbdev->buffer);
503
504         return err;
505 }
506
507 static int ht16k33_remove(struct i2c_client *client)
508 {
509         struct ht16k33_priv *priv = i2c_get_clientdata(client);
510         struct ht16k33_fbdev *fbdev = &priv->fbdev;
511
512         cancel_delayed_work_sync(&fbdev->work);
513         unregister_framebuffer(fbdev->info);
514         framebuffer_release(fbdev->info);
515         free_page((unsigned long) fbdev->buffer);
516
517         return 0;
518 }
519
520 static const struct i2c_device_id ht16k33_i2c_match[] = {
521         { "ht16k33", 0 },
522         { }
523 };
524 MODULE_DEVICE_TABLE(i2c, ht16k33_i2c_match);
525
526 static const struct of_device_id ht16k33_of_match[] = {
527         { .compatible = "holtek,ht16k33", },
528         { }
529 };
530 MODULE_DEVICE_TABLE(of, ht16k33_of_match);
531
532 static struct i2c_driver ht16k33_driver = {
533         .probe          = ht16k33_probe,
534         .remove         = ht16k33_remove,
535         .driver         = {
536                 .name           = DRIVER_NAME,
537                 .of_match_table = of_match_ptr(ht16k33_of_match),
538         },
539         .id_table = ht16k33_i2c_match,
540 };
541 module_i2c_driver(ht16k33_driver);
542
543 MODULE_DESCRIPTION("Holtek HT16K33 driver");
544 MODULE_LICENSE("GPL");
545 MODULE_AUTHOR("Robin van der Gracht <robin@protonic.nl>");