lm8333.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * LM8333 keypad driver
  4. * Copyright (C) 2012 Wolfram Sang, Pengutronix <kernel@pengutronix.de>
  5. */
  6. #include <linux/module.h>
  7. #include <linux/slab.h>
  8. #include <linux/irq.h>
  9. #include <linux/i2c.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/input/matrix_keypad.h>
  12. #include <linux/input/lm8333.h>
  13. #define LM8333_FIFO_READ 0x20
  14. #define LM8333_DEBOUNCE 0x22
  15. #define LM8333_READ_INT 0xD0
  16. #define LM8333_ACTIVE 0xE4
  17. #define LM8333_READ_ERROR 0xF0
  18. #define LM8333_KEYPAD_IRQ (1 << 0)
  19. #define LM8333_ERROR_IRQ (1 << 3)
  20. #define LM8333_ERROR_KEYOVR 0x04
  21. #define LM8333_ERROR_FIFOOVR 0x40
  22. #define LM8333_FIFO_TRANSFER_SIZE 16
  23. #define LM8333_NUM_ROWS 8
  24. #define LM8333_NUM_COLS 16
  25. #define LM8333_ROW_SHIFT 4
  26. struct lm8333 {
  27. struct i2c_client *client;
  28. struct input_dev *input;
  29. unsigned short keycodes[LM8333_NUM_ROWS << LM8333_ROW_SHIFT];
  30. };
  31. /* The accessors try twice because the first access may be needed for wakeup */
  32. #define LM8333_READ_RETRIES 2
  33. int lm8333_read8(struct lm8333 *lm8333, u8 cmd)
  34. {
  35. int retries = 0, ret;
  36. do {
  37. ret = i2c_smbus_read_byte_data(lm8333->client, cmd);
  38. } while (ret < 0 && retries++ < LM8333_READ_RETRIES);
  39. return ret;
  40. }
  41. int lm8333_write8(struct lm8333 *lm8333, u8 cmd, u8 val)
  42. {
  43. int retries = 0, ret;
  44. do {
  45. ret = i2c_smbus_write_byte_data(lm8333->client, cmd, val);
  46. } while (ret < 0 && retries++ < LM8333_READ_RETRIES);
  47. return ret;
  48. }
  49. int lm8333_read_block(struct lm8333 *lm8333, u8 cmd, u8 len, u8 *buf)
  50. {
  51. int retries = 0, ret;
  52. do {
  53. ret = i2c_smbus_read_i2c_block_data(lm8333->client,
  54. cmd, len, buf);
  55. } while (ret < 0 && retries++ < LM8333_READ_RETRIES);
  56. return ret;
  57. }
  58. static void lm8333_key_handler(struct lm8333 *lm8333)
  59. {
  60. struct input_dev *input = lm8333->input;
  61. u8 keys[LM8333_FIFO_TRANSFER_SIZE];
  62. u8 code, pressed;
  63. int i, ret;
  64. ret = lm8333_read_block(lm8333, LM8333_FIFO_READ,
  65. LM8333_FIFO_TRANSFER_SIZE, keys);
  66. if (ret != LM8333_FIFO_TRANSFER_SIZE) {
  67. dev_err(&lm8333->client->dev,
  68. "Error %d while reading FIFO\n", ret);
  69. return;
  70. }
  71. for (i = 0; i < LM8333_FIFO_TRANSFER_SIZE && keys[i]; i++) {
  72. pressed = keys[i] & 0x80;
  73. code = keys[i] & 0x7f;
  74. input_event(input, EV_MSC, MSC_SCAN, code);
  75. input_report_key(input, lm8333->keycodes[code], pressed);
  76. }
  77. input_sync(input);
  78. }
  79. static irqreturn_t lm8333_irq_thread(int irq, void *data)
  80. {
  81. struct lm8333 *lm8333 = data;
  82. u8 status = lm8333_read8(lm8333, LM8333_READ_INT);
  83. if (!status)
  84. return IRQ_NONE;
  85. if (status & LM8333_ERROR_IRQ) {
  86. u8 err = lm8333_read8(lm8333, LM8333_READ_ERROR);
  87. if (err & (LM8333_ERROR_KEYOVR | LM8333_ERROR_FIFOOVR)) {
  88. u8 dummy[LM8333_FIFO_TRANSFER_SIZE];
  89. lm8333_read_block(lm8333, LM8333_FIFO_READ,
  90. LM8333_FIFO_TRANSFER_SIZE, dummy);
  91. }
  92. dev_err(&lm8333->client->dev, "Got error %02x\n", err);
  93. }
  94. if (status & LM8333_KEYPAD_IRQ)
  95. lm8333_key_handler(lm8333);
  96. return IRQ_HANDLED;
  97. }
  98. static int lm8333_probe(struct i2c_client *client,
  99. const struct i2c_device_id *id)
  100. {
  101. const struct lm8333_platform_data *pdata =
  102. dev_get_platdata(&client->dev);
  103. struct lm8333 *lm8333;
  104. struct input_dev *input;
  105. int err, active_time;
  106. if (!pdata)
  107. return -EINVAL;
  108. active_time = pdata->active_time ?: 500;
  109. if (active_time / 3 <= pdata->debounce_time / 3) {
  110. dev_err(&client->dev, "Active time not big enough!\n");
  111. return -EINVAL;
  112. }
  113. lm8333 = kzalloc(sizeof(*lm8333), GFP_KERNEL);
  114. input = input_allocate_device();
  115. if (!lm8333 || !input) {
  116. err = -ENOMEM;
  117. goto free_mem;
  118. }
  119. lm8333->client = client;
  120. lm8333->input = input;
  121. input->name = client->name;
  122. input->dev.parent = &client->dev;
  123. input->id.bustype = BUS_I2C;
  124. input_set_capability(input, EV_MSC, MSC_SCAN);
  125. err = matrix_keypad_build_keymap(pdata->matrix_data, NULL,
  126. LM8333_NUM_ROWS, LM8333_NUM_COLS,
  127. lm8333->keycodes, input);
  128. if (err)
  129. goto free_mem;
  130. if (pdata->debounce_time) {
  131. err = lm8333_write8(lm8333, LM8333_DEBOUNCE,
  132. pdata->debounce_time / 3);
  133. if (err)
  134. dev_warn(&client->dev, "Unable to set debounce time\n");
  135. }
  136. if (pdata->active_time) {
  137. err = lm8333_write8(lm8333, LM8333_ACTIVE,
  138. pdata->active_time / 3);
  139. if (err)
  140. dev_warn(&client->dev, "Unable to set active time\n");
  141. }
  142. err = request_threaded_irq(client->irq, NULL, lm8333_irq_thread,
  143. IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  144. "lm8333", lm8333);
  145. if (err)
  146. goto free_mem;
  147. err = input_register_device(input);
  148. if (err)
  149. goto free_irq;
  150. i2c_set_clientdata(client, lm8333);
  151. return 0;
  152. free_irq:
  153. free_irq(client->irq, lm8333);
  154. free_mem:
  155. input_free_device(input);
  156. kfree(lm8333);
  157. return err;
  158. }
  159. static int lm8333_remove(struct i2c_client *client)
  160. {
  161. struct lm8333 *lm8333 = i2c_get_clientdata(client);
  162. free_irq(client->irq, lm8333);
  163. input_unregister_device(lm8333->input);
  164. kfree(lm8333);
  165. return 0;
  166. }
  167. static const struct i2c_device_id lm8333_id[] = {
  168. { "lm8333", 0 },
  169. { }
  170. };
  171. MODULE_DEVICE_TABLE(i2c, lm8333_id);
  172. static struct i2c_driver lm8333_driver = {
  173. .driver = {
  174. .name = "lm8333",
  175. },
  176. .probe = lm8333_probe,
  177. .remove = lm8333_remove,
  178. .id_table = lm8333_id,
  179. };
  180. module_i2c_driver(lm8333_driver);
  181. MODULE_AUTHOR("Wolfram Sang <kernel@pengutronix.de>");
  182. MODULE_DESCRIPTION("LM8333 keyboard driver");
  183. MODULE_LICENSE("GPL v2");