ht16k33.c 13 KB

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