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 }; 69 70 struct ht16k33_priv { 71 struct i2c_client *client; 72 struct delayed_work work; 73 struct ht16k33_keypad keypad; 74 struct ht16k33_fbdev fbdev; 75 }; 76 77 static const 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 const 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(&priv->work, HZ / fbdev->refresh_rate); 121 } 122 123 /* 124 * This gets the fb data from cache and copies it to ht16k33 display RAM 125 */ 126 static void ht16k33_fb_update(struct work_struct *work) 127 { 128 struct ht16k33_priv *priv = container_of(work, struct ht16k33_priv, 129 work.work); 130 struct ht16k33_fbdev *fbdev = &priv->fbdev; 131 132 uint8_t *p1, *p2; 133 int len, pos = 0, first = -1; 134 135 p1 = fbdev->cache; 136 p2 = fbdev->buffer; 137 138 /* Search for the first byte with changes */ 139 while (pos < HT16K33_FB_SIZE && first < 0) { 140 if (*(p1++) - *(p2++)) 141 first = pos; 142 pos++; 143 } 144 145 /* No changes found */ 146 if (first < 0) 147 goto requeue; 148 149 len = HT16K33_FB_SIZE - first; 150 p1 = fbdev->cache + HT16K33_FB_SIZE - 1; 151 p2 = fbdev->buffer + HT16K33_FB_SIZE - 1; 152 153 /* Determine i2c transfer length */ 154 while (len > 1) { 155 if (*(p1--) - *(p2--)) 156 break; 157 len--; 158 } 159 160 p1 = fbdev->cache + first; 161 p2 = fbdev->buffer + first; 162 if (!i2c_smbus_write_i2c_block_data(priv->client, first, len, p2)) 163 memcpy(p1, p2, len); 164 requeue: 165 ht16k33_fb_queue(priv); 166 } 167 168 static int ht16k33_initialize(struct ht16k33_priv *priv) 169 { 170 uint8_t data[HT16K33_FB_SIZE]; 171 uint8_t byte; 172 int err; 173 174 /* Clear RAM (8 * 16 bits) */ 175 memset(data, 0, sizeof(data)); 176 err = i2c_smbus_write_block_data(priv->client, 0, sizeof(data), data); 177 if (err) 178 return err; 179 180 /* Turn on internal oscillator */ 181 byte = REG_SYSTEM_SETUP_OSC_ON | REG_SYSTEM_SETUP; 182 err = i2c_smbus_write_byte(priv->client, byte); 183 if (err) 184 return err; 185 186 /* Configure INT pin */ 187 byte = REG_ROWINT_SET | REG_ROWINT_SET_INT_ACT_HIGH; 188 if (priv->client->irq > 0) 189 byte |= REG_ROWINT_SET_INT_EN; 190 return i2c_smbus_write_byte(priv->client, byte); 191 } 192 193 static int ht16k33_bl_update_status(struct backlight_device *bl) 194 { 195 int brightness = bl->props.brightness; 196 struct ht16k33_priv *priv = bl_get_data(bl); 197 198 if (bl->props.power != FB_BLANK_UNBLANK || 199 bl->props.fb_blank != FB_BLANK_UNBLANK || 200 bl->props.state & BL_CORE_FBBLANK || brightness == 0) { 201 return ht16k33_display_off(priv); 202 } 203 204 ht16k33_display_on(priv); 205 return i2c_smbus_write_byte(priv->client, 206 REG_BRIGHTNESS | (brightness - 1)); 207 } 208 209 static int ht16k33_bl_check_fb(struct backlight_device *bl, struct fb_info *fi) 210 { 211 struct ht16k33_priv *priv = bl_get_data(bl); 212 213 return (fi == NULL) || (fi->par == priv); 214 } 215 216 static const struct backlight_ops ht16k33_bl_ops = { 217 .update_status = ht16k33_bl_update_status, 218 .check_fb = ht16k33_bl_check_fb, 219 }; 220 221 /* 222 * Blank events will be passed to the actual device handling the backlight when 223 * we return zero here. 224 */ 225 static int ht16k33_blank(int blank, struct fb_info *info) 226 { 227 return 0; 228 } 229 230 static int ht16k33_mmap(struct fb_info *info, struct vm_area_struct *vma) 231 { 232 struct ht16k33_priv *priv = info->par; 233 struct page *pages = virt_to_page(priv->fbdev.buffer); 234 235 return vm_map_pages_zero(vma, &pages, 1); 236 } 237 238 static const struct fb_ops ht16k33_fb_ops = { 239 .owner = THIS_MODULE, 240 .fb_read = fb_sys_read, 241 .fb_write = fb_sys_write, 242 .fb_blank = ht16k33_blank, 243 .fb_fillrect = sys_fillrect, 244 .fb_copyarea = sys_copyarea, 245 .fb_imageblit = sys_imageblit, 246 .fb_mmap = ht16k33_mmap, 247 }; 248 249 /* 250 * This gets the keys from keypad and reports it to input subsystem. 251 * Returns true if a key is pressed. 252 */ 253 static bool ht16k33_keypad_scan(struct ht16k33_keypad *keypad) 254 { 255 const unsigned short *keycodes = keypad->dev->keycode; 256 u16 new_state[HT16K33_MATRIX_KEYPAD_MAX_COLS]; 257 __le16 data[HT16K33_MATRIX_KEYPAD_MAX_COLS]; 258 unsigned long bits_changed; 259 int row, col, code; 260 int rc; 261 bool pressed = false; 262 263 rc = i2c_smbus_read_i2c_block_data(keypad->client, 0x40, 264 sizeof(data), (u8 *)data); 265 if (rc != sizeof(data)) { 266 dev_err(&keypad->client->dev, 267 "Failed to read key data, rc=%d\n", rc); 268 return false; 269 } 270 271 for (col = 0; col < keypad->cols; col++) { 272 new_state[col] = le16_to_cpu(data[col]); 273 if (new_state[col]) 274 pressed = true; 275 bits_changed = keypad->last_key_state[col] ^ new_state[col]; 276 277 for_each_set_bit(row, &bits_changed, BITS_PER_LONG) { 278 code = MATRIX_SCAN_CODE(row, col, keypad->row_shift); 279 input_event(keypad->dev, EV_MSC, MSC_SCAN, code); 280 input_report_key(keypad->dev, keycodes[code], 281 new_state[col] & BIT(row)); 282 } 283 } 284 input_sync(keypad->dev); 285 memcpy(keypad->last_key_state, new_state, sizeof(u16) * keypad->cols); 286 287 return pressed; 288 } 289 290 static irqreturn_t ht16k33_keypad_irq_thread(int irq, void *dev) 291 { 292 struct ht16k33_keypad *keypad = dev; 293 294 do { 295 wait_event_timeout(keypad->wait, keypad->stopped, 296 msecs_to_jiffies(keypad->debounce_ms)); 297 if (keypad->stopped) 298 break; 299 } while (ht16k33_keypad_scan(keypad)); 300 301 return IRQ_HANDLED; 302 } 303 304 static int ht16k33_keypad_start(struct input_dev *dev) 305 { 306 struct ht16k33_keypad *keypad = input_get_drvdata(dev); 307 308 keypad->stopped = false; 309 mb(); 310 enable_irq(keypad->client->irq); 311 312 return 0; 313 } 314 315 static void ht16k33_keypad_stop(struct input_dev *dev) 316 { 317 struct ht16k33_keypad *keypad = input_get_drvdata(dev); 318 319 keypad->stopped = true; 320 mb(); 321 wake_up(&keypad->wait); 322 disable_irq(keypad->client->irq); 323 } 324 325 static int ht16k33_keypad_probe(struct i2c_client *client, 326 struct ht16k33_keypad *keypad) 327 { 328 struct device *dev = &client->dev; 329 struct device_node *node = dev->of_node; 330 u32 rows = HT16K33_MATRIX_KEYPAD_MAX_ROWS; 331 u32 cols = HT16K33_MATRIX_KEYPAD_MAX_COLS; 332 int err; 333 334 keypad->client = client; 335 init_waitqueue_head(&keypad->wait); 336 337 keypad->dev = devm_input_allocate_device(dev); 338 if (!keypad->dev) 339 return -ENOMEM; 340 341 input_set_drvdata(keypad->dev, keypad); 342 343 keypad->dev->name = DRIVER_NAME"-keypad"; 344 keypad->dev->id.bustype = BUS_I2C; 345 keypad->dev->open = ht16k33_keypad_start; 346 keypad->dev->close = ht16k33_keypad_stop; 347 348 if (!of_get_property(node, "linux,no-autorepeat", NULL)) 349 __set_bit(EV_REP, keypad->dev->evbit); 350 351 err = of_property_read_u32(node, "debounce-delay-ms", 352 &keypad->debounce_ms); 353 if (err) { 354 dev_err(dev, "key debounce delay not specified\n"); 355 return err; 356 } 357 358 err = matrix_keypad_parse_of_params(dev, &rows, &cols); 359 if (err) 360 return err; 361 if (rows > HT16K33_MATRIX_KEYPAD_MAX_ROWS || 362 cols > HT16K33_MATRIX_KEYPAD_MAX_COLS) { 363 dev_err(dev, "%u rows or %u cols out of range in DT\n", rows, 364 cols); 365 return -ERANGE; 366 } 367 368 keypad->rows = rows; 369 keypad->cols = cols; 370 keypad->row_shift = get_count_order(cols); 371 372 err = matrix_keypad_build_keymap(NULL, NULL, rows, cols, NULL, 373 keypad->dev); 374 if (err) { 375 dev_err(dev, "failed to build keymap\n"); 376 return err; 377 } 378 379 err = devm_request_threaded_irq(dev, client->irq, NULL, 380 ht16k33_keypad_irq_thread, 381 IRQF_TRIGGER_HIGH | IRQF_ONESHOT, 382 DRIVER_NAME, keypad); 383 if (err) { 384 dev_err(dev, "irq request failed %d, error %d\n", client->irq, 385 err); 386 return err; 387 } 388 389 ht16k33_keypad_stop(keypad->dev); 390 391 return input_register_device(keypad->dev); 392 } 393 394 static int ht16k33_probe(struct i2c_client *client) 395 { 396 int err; 397 uint32_t dft_brightness; 398 struct backlight_device *bl; 399 struct backlight_properties bl_props; 400 struct ht16k33_priv *priv; 401 struct ht16k33_fbdev *fbdev; 402 struct device *dev = &client->dev; 403 struct device_node *node = dev->of_node; 404 405 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 406 dev_err(dev, "i2c_check_functionality error\n"); 407 return -EIO; 408 } 409 410 priv = devm_kzalloc(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 /* Backlight */ 423 memset(&bl_props, 0, sizeof(struct backlight_properties)); 424 bl_props.type = BACKLIGHT_RAW; 425 bl_props.max_brightness = MAX_BRIGHTNESS; 426 427 bl = devm_backlight_device_register(dev, DRIVER_NAME"-bl", dev, priv, 428 &ht16k33_bl_ops, &bl_props); 429 if (IS_ERR(bl)) { 430 dev_err(dev, "failed to register backlight\n"); 431 return PTR_ERR(bl); 432 } 433 434 err = of_property_read_u32(node, "default-brightness-level", 435 &dft_brightness); 436 if (err) { 437 dft_brightness = MAX_BRIGHTNESS; 438 } else if (dft_brightness > MAX_BRIGHTNESS) { 439 dev_warn(dev, 440 "invalid default brightness level: %u, using %u\n", 441 dft_brightness, MAX_BRIGHTNESS); 442 dft_brightness = MAX_BRIGHTNESS; 443 } 444 445 bl->props.brightness = dft_brightness; 446 ht16k33_bl_update_status(bl); 447 448 /* Framebuffer (2 bytes per column) */ 449 BUILD_BUG_ON(PAGE_SIZE < HT16K33_FB_SIZE); 450 fbdev->buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL); 451 if (!fbdev->buffer) 452 return -ENOMEM; 453 454 fbdev->cache = devm_kmalloc(dev, HT16K33_FB_SIZE, GFP_KERNEL); 455 if (!fbdev->cache) { 456 err = -ENOMEM; 457 goto err_fbdev_buffer; 458 } 459 460 fbdev->info = framebuffer_alloc(0, dev); 461 if (!fbdev->info) { 462 err = -ENOMEM; 463 goto err_fbdev_buffer; 464 } 465 466 err = of_property_read_u32(node, "refresh-rate-hz", 467 &fbdev->refresh_rate); 468 if (err) { 469 dev_err(dev, "refresh rate not specified\n"); 470 goto err_fbdev_info; 471 } 472 fb_bl_default_curve(fbdev->info, 0, MIN_BRIGHTNESS, MAX_BRIGHTNESS); 473 474 INIT_DELAYED_WORK(&priv->work, ht16k33_fb_update); 475 fbdev->info->fbops = &ht16k33_fb_ops; 476 fbdev->info->screen_base = (char __iomem *) fbdev->buffer; 477 fbdev->info->screen_size = HT16K33_FB_SIZE; 478 fbdev->info->fix = ht16k33_fb_fix; 479 fbdev->info->var = ht16k33_fb_var; 480 fbdev->info->bl_dev = bl; 481 fbdev->info->pseudo_palette = NULL; 482 fbdev->info->flags = FBINFO_FLAG_DEFAULT; 483 fbdev->info->par = priv; 484 485 err = register_framebuffer(fbdev->info); 486 if (err) 487 goto err_fbdev_info; 488 489 /* Keypad */ 490 if (client->irq > 0) { 491 err = ht16k33_keypad_probe(client, &priv->keypad); 492 if (err) 493 goto err_fbdev_unregister; 494 } 495 496 ht16k33_fb_queue(priv); 497 return 0; 498 499 err_fbdev_unregister: 500 unregister_framebuffer(fbdev->info); 501 err_fbdev_info: 502 framebuffer_release(fbdev->info); 503 err_fbdev_buffer: 504 free_page((unsigned long) fbdev->buffer); 505 506 return err; 507 } 508 509 static int ht16k33_remove(struct i2c_client *client) 510 { 511 struct ht16k33_priv *priv = i2c_get_clientdata(client); 512 struct ht16k33_fbdev *fbdev = &priv->fbdev; 513 514 cancel_delayed_work_sync(&priv->work); 515 unregister_framebuffer(fbdev->info); 516 framebuffer_release(fbdev->info); 517 free_page((unsigned long) fbdev->buffer); 518 519 return 0; 520 } 521 522 static const struct i2c_device_id ht16k33_i2c_match[] = { 523 { "ht16k33", 0 }, 524 { } 525 }; 526 MODULE_DEVICE_TABLE(i2c, ht16k33_i2c_match); 527 528 static const struct of_device_id ht16k33_of_match[] = { 529 { .compatible = "holtek,ht16k33", }, 530 { } 531 }; 532 MODULE_DEVICE_TABLE(of, ht16k33_of_match); 533 534 static struct i2c_driver ht16k33_driver = { 535 .probe_new = ht16k33_probe, 536 .remove = ht16k33_remove, 537 .driver = { 538 .name = DRIVER_NAME, 539 .of_match_table = of_match_ptr(ht16k33_of_match), 540 }, 541 .id_table = ht16k33_i2c_match, 542 }; 543 module_i2c_driver(ht16k33_driver); 544 545 MODULE_DESCRIPTION("Holtek HT16K33 driver"); 546 MODULE_LICENSE("GPL"); 547 MODULE_AUTHOR("Robin van der Gracht <robin@protonic.nl>"); 548