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(&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>");