cap11xx.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Input driver for Microchip CAP11xx based capacitive touch sensors
  4. *
  5. * (c) 2014 Daniel Mack <linux@zonque.org>
  6. */
  7. #include <linux/kernel.h>
  8. #include <linux/module.h>
  9. #include <linux/interrupt.h>
  10. #include <linux/input.h>
  11. #include <linux/leds.h>
  12. #include <linux/of_irq.h>
  13. #include <linux/regmap.h>
  14. #include <linux/i2c.h>
  15. #include <linux/gpio/consumer.h>
  16. #define CAP11XX_REG_MAIN_CONTROL 0x00
  17. #define CAP11XX_REG_MAIN_CONTROL_GAIN_SHIFT (6)
  18. #define CAP11XX_REG_MAIN_CONTROL_GAIN_MASK (0xc0)
  19. #define CAP11XX_REG_MAIN_CONTROL_DLSEEP BIT(4)
  20. #define CAP11XX_REG_GENERAL_STATUS 0x02
  21. #define CAP11XX_REG_SENSOR_INPUT 0x03
  22. #define CAP11XX_REG_NOISE_FLAG_STATUS 0x0a
  23. #define CAP11XX_REG_SENOR_DELTA(X) (0x10 + (X))
  24. #define CAP11XX_REG_SENSITIVITY_CONTROL 0x1f
  25. #define CAP11XX_REG_CONFIG 0x20
  26. #define CAP11XX_REG_SENSOR_ENABLE 0x21
  27. #define CAP11XX_REG_SENSOR_CONFIG 0x22
  28. #define CAP11XX_REG_SENSOR_CONFIG2 0x23
  29. #define CAP11XX_REG_SAMPLING_CONFIG 0x24
  30. #define CAP11XX_REG_CALIBRATION 0x26
  31. #define CAP11XX_REG_INT_ENABLE 0x27
  32. #define CAP11XX_REG_REPEAT_RATE 0x28
  33. #define CAP11XX_REG_MT_CONFIG 0x2a
  34. #define CAP11XX_REG_MT_PATTERN_CONFIG 0x2b
  35. #define CAP11XX_REG_MT_PATTERN 0x2d
  36. #define CAP11XX_REG_RECALIB_CONFIG 0x2f
  37. #define CAP11XX_REG_SENSOR_THRESH(X) (0x30 + (X))
  38. #define CAP11XX_REG_SENSOR_NOISE_THRESH 0x38
  39. #define CAP11XX_REG_STANDBY_CHANNEL 0x40
  40. #define CAP11XX_REG_STANDBY_CONFIG 0x41
  41. #define CAP11XX_REG_STANDBY_SENSITIVITY 0x42
  42. #define CAP11XX_REG_STANDBY_THRESH 0x43
  43. #define CAP11XX_REG_CONFIG2 0x44
  44. #define CAP11XX_REG_CONFIG2_ALT_POL BIT(6)
  45. #define CAP11XX_REG_SENSOR_BASE_CNT(X) (0x50 + (X))
  46. #define CAP11XX_REG_LED_POLARITY 0x73
  47. #define CAP11XX_REG_LED_OUTPUT_CONTROL 0x74
  48. #define CAP11XX_REG_LED_DUTY_CYCLE_1 0x90
  49. #define CAP11XX_REG_LED_DUTY_CYCLE_2 0x91
  50. #define CAP11XX_REG_LED_DUTY_CYCLE_3 0x92
  51. #define CAP11XX_REG_LED_DUTY_CYCLE_4 0x93
  52. #define CAP11XX_REG_LED_DUTY_MIN_MASK (0x0f)
  53. #define CAP11XX_REG_LED_DUTY_MIN_MASK_SHIFT (0)
  54. #define CAP11XX_REG_LED_DUTY_MAX_MASK (0xf0)
  55. #define CAP11XX_REG_LED_DUTY_MAX_MASK_SHIFT (4)
  56. #define CAP11XX_REG_LED_DUTY_MAX_VALUE (15)
  57. #define CAP11XX_REG_SENSOR_CALIB (0xb1 + (X))
  58. #define CAP11XX_REG_SENSOR_CALIB_LSB1 0xb9
  59. #define CAP11XX_REG_SENSOR_CALIB_LSB2 0xba
  60. #define CAP11XX_REG_PRODUCT_ID 0xfd
  61. #define CAP11XX_REG_MANUFACTURER_ID 0xfe
  62. #define CAP11XX_REG_REVISION 0xff
  63. #define CAP11XX_MANUFACTURER_ID 0x5d
  64. #ifdef CONFIG_LEDS_CLASS
  65. struct cap11xx_led {
  66. struct cap11xx_priv *priv;
  67. struct led_classdev cdev;
  68. u32 reg;
  69. };
  70. #endif
  71. struct cap11xx_priv {
  72. struct regmap *regmap;
  73. struct input_dev *idev;
  74. struct cap11xx_led *leds;
  75. int num_leds;
  76. /* config */
  77. u32 keycodes[];
  78. };
  79. struct cap11xx_hw_model {
  80. u8 product_id;
  81. unsigned int num_channels;
  82. unsigned int num_leds;
  83. };
  84. enum {
  85. CAP1106,
  86. CAP1126,
  87. CAP1188,
  88. };
  89. static const struct cap11xx_hw_model cap11xx_devices[] = {
  90. [CAP1106] = { .product_id = 0x55, .num_channels = 6, .num_leds = 0 },
  91. [CAP1126] = { .product_id = 0x53, .num_channels = 6, .num_leds = 2 },
  92. [CAP1188] = { .product_id = 0x50, .num_channels = 8, .num_leds = 8 },
  93. };
  94. static const struct reg_default cap11xx_reg_defaults[] = {
  95. { CAP11XX_REG_MAIN_CONTROL, 0x00 },
  96. { CAP11XX_REG_GENERAL_STATUS, 0x00 },
  97. { CAP11XX_REG_SENSOR_INPUT, 0x00 },
  98. { CAP11XX_REG_NOISE_FLAG_STATUS, 0x00 },
  99. { CAP11XX_REG_SENSITIVITY_CONTROL, 0x2f },
  100. { CAP11XX_REG_CONFIG, 0x20 },
  101. { CAP11XX_REG_SENSOR_ENABLE, 0x3f },
  102. { CAP11XX_REG_SENSOR_CONFIG, 0xa4 },
  103. { CAP11XX_REG_SENSOR_CONFIG2, 0x07 },
  104. { CAP11XX_REG_SAMPLING_CONFIG, 0x39 },
  105. { CAP11XX_REG_CALIBRATION, 0x00 },
  106. { CAP11XX_REG_INT_ENABLE, 0x3f },
  107. { CAP11XX_REG_REPEAT_RATE, 0x3f },
  108. { CAP11XX_REG_MT_CONFIG, 0x80 },
  109. { CAP11XX_REG_MT_PATTERN_CONFIG, 0x00 },
  110. { CAP11XX_REG_MT_PATTERN, 0x3f },
  111. { CAP11XX_REG_RECALIB_CONFIG, 0x8a },
  112. { CAP11XX_REG_SENSOR_THRESH(0), 0x40 },
  113. { CAP11XX_REG_SENSOR_THRESH(1), 0x40 },
  114. { CAP11XX_REG_SENSOR_THRESH(2), 0x40 },
  115. { CAP11XX_REG_SENSOR_THRESH(3), 0x40 },
  116. { CAP11XX_REG_SENSOR_THRESH(4), 0x40 },
  117. { CAP11XX_REG_SENSOR_THRESH(5), 0x40 },
  118. { CAP11XX_REG_SENSOR_NOISE_THRESH, 0x01 },
  119. { CAP11XX_REG_STANDBY_CHANNEL, 0x00 },
  120. { CAP11XX_REG_STANDBY_CONFIG, 0x39 },
  121. { CAP11XX_REG_STANDBY_SENSITIVITY, 0x02 },
  122. { CAP11XX_REG_STANDBY_THRESH, 0x40 },
  123. { CAP11XX_REG_CONFIG2, 0x40 },
  124. { CAP11XX_REG_LED_POLARITY, 0x00 },
  125. { CAP11XX_REG_SENSOR_CALIB_LSB1, 0x00 },
  126. { CAP11XX_REG_SENSOR_CALIB_LSB2, 0x00 },
  127. };
  128. static bool cap11xx_volatile_reg(struct device *dev, unsigned int reg)
  129. {
  130. switch (reg) {
  131. case CAP11XX_REG_MAIN_CONTROL:
  132. case CAP11XX_REG_SENSOR_INPUT:
  133. case CAP11XX_REG_SENOR_DELTA(0):
  134. case CAP11XX_REG_SENOR_DELTA(1):
  135. case CAP11XX_REG_SENOR_DELTA(2):
  136. case CAP11XX_REG_SENOR_DELTA(3):
  137. case CAP11XX_REG_SENOR_DELTA(4):
  138. case CAP11XX_REG_SENOR_DELTA(5):
  139. case CAP11XX_REG_PRODUCT_ID:
  140. case CAP11XX_REG_MANUFACTURER_ID:
  141. case CAP11XX_REG_REVISION:
  142. return true;
  143. }
  144. return false;
  145. }
  146. static const struct regmap_config cap11xx_regmap_config = {
  147. .reg_bits = 8,
  148. .val_bits = 8,
  149. .max_register = CAP11XX_REG_REVISION,
  150. .reg_defaults = cap11xx_reg_defaults,
  151. .num_reg_defaults = ARRAY_SIZE(cap11xx_reg_defaults),
  152. .cache_type = REGCACHE_RBTREE,
  153. .volatile_reg = cap11xx_volatile_reg,
  154. };
  155. static irqreturn_t cap11xx_thread_func(int irq_num, void *data)
  156. {
  157. struct cap11xx_priv *priv = data;
  158. unsigned int status;
  159. int ret, i;
  160. /*
  161. * Deassert interrupt. This needs to be done before reading the status
  162. * registers, which will not carry valid values otherwise.
  163. */
  164. ret = regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL, 1, 0);
  165. if (ret < 0)
  166. goto out;
  167. ret = regmap_read(priv->regmap, CAP11XX_REG_SENSOR_INPUT, &status);
  168. if (ret < 0)
  169. goto out;
  170. for (i = 0; i < priv->idev->keycodemax; i++)
  171. input_report_key(priv->idev, priv->keycodes[i],
  172. status & (1 << i));
  173. input_sync(priv->idev);
  174. out:
  175. return IRQ_HANDLED;
  176. }
  177. static int cap11xx_set_sleep(struct cap11xx_priv *priv, bool sleep)
  178. {
  179. /*
  180. * DLSEEP mode will turn off all LEDS, prevent this
  181. */
  182. if (IS_ENABLED(CONFIG_LEDS_CLASS) && priv->num_leds)
  183. return 0;
  184. return regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL,
  185. CAP11XX_REG_MAIN_CONTROL_DLSEEP,
  186. sleep ? CAP11XX_REG_MAIN_CONTROL_DLSEEP : 0);
  187. }
  188. static int cap11xx_input_open(struct input_dev *idev)
  189. {
  190. struct cap11xx_priv *priv = input_get_drvdata(idev);
  191. return cap11xx_set_sleep(priv, false);
  192. }
  193. static void cap11xx_input_close(struct input_dev *idev)
  194. {
  195. struct cap11xx_priv *priv = input_get_drvdata(idev);
  196. cap11xx_set_sleep(priv, true);
  197. }
  198. #ifdef CONFIG_LEDS_CLASS
  199. static int cap11xx_led_set(struct led_classdev *cdev,
  200. enum led_brightness value)
  201. {
  202. struct cap11xx_led *led = container_of(cdev, struct cap11xx_led, cdev);
  203. struct cap11xx_priv *priv = led->priv;
  204. /*
  205. * All LEDs share the same duty cycle as this is a HW
  206. * limitation. Brightness levels per LED are either
  207. * 0 (OFF) and 1 (ON).
  208. */
  209. return regmap_update_bits(priv->regmap,
  210. CAP11XX_REG_LED_OUTPUT_CONTROL,
  211. BIT(led->reg),
  212. value ? BIT(led->reg) : 0);
  213. }
  214. static int cap11xx_init_leds(struct device *dev,
  215. struct cap11xx_priv *priv, int num_leds)
  216. {
  217. struct device_node *node = dev->of_node, *child;
  218. struct cap11xx_led *led;
  219. int cnt = of_get_child_count(node);
  220. int error;
  221. if (!num_leds || !cnt)
  222. return 0;
  223. if (cnt > num_leds)
  224. return -EINVAL;
  225. led = devm_kcalloc(dev, cnt, sizeof(struct cap11xx_led), GFP_KERNEL);
  226. if (!led)
  227. return -ENOMEM;
  228. priv->leds = led;
  229. error = regmap_update_bits(priv->regmap,
  230. CAP11XX_REG_LED_OUTPUT_CONTROL, 0xff, 0);
  231. if (error)
  232. return error;
  233. error = regmap_update_bits(priv->regmap, CAP11XX_REG_LED_DUTY_CYCLE_4,
  234. CAP11XX_REG_LED_DUTY_MAX_MASK,
  235. CAP11XX_REG_LED_DUTY_MAX_VALUE <<
  236. CAP11XX_REG_LED_DUTY_MAX_MASK_SHIFT);
  237. if (error)
  238. return error;
  239. for_each_child_of_node(node, child) {
  240. u32 reg;
  241. led->cdev.name =
  242. of_get_property(child, "label", NULL) ? : child->name;
  243. led->cdev.default_trigger =
  244. of_get_property(child, "linux,default-trigger", NULL);
  245. led->cdev.flags = 0;
  246. led->cdev.brightness_set_blocking = cap11xx_led_set;
  247. led->cdev.max_brightness = 1;
  248. led->cdev.brightness = LED_OFF;
  249. error = of_property_read_u32(child, "reg", &reg);
  250. if (error != 0 || reg >= num_leds) {
  251. of_node_put(child);
  252. return -EINVAL;
  253. }
  254. led->reg = reg;
  255. led->priv = priv;
  256. error = devm_led_classdev_register(dev, &led->cdev);
  257. if (error) {
  258. of_node_put(child);
  259. return error;
  260. }
  261. priv->num_leds++;
  262. led++;
  263. }
  264. return 0;
  265. }
  266. #else
  267. static int cap11xx_init_leds(struct device *dev,
  268. struct cap11xx_priv *priv, int num_leds)
  269. {
  270. return 0;
  271. }
  272. #endif
  273. static int cap11xx_i2c_probe(struct i2c_client *i2c_client,
  274. const struct i2c_device_id *id)
  275. {
  276. struct device *dev = &i2c_client->dev;
  277. struct cap11xx_priv *priv;
  278. struct device_node *node;
  279. const struct cap11xx_hw_model *cap;
  280. int i, error, irq, gain = 0;
  281. unsigned int val, rev;
  282. u32 gain32;
  283. if (id->driver_data >= ARRAY_SIZE(cap11xx_devices)) {
  284. dev_err(dev, "Invalid device ID %lu\n", id->driver_data);
  285. return -EINVAL;
  286. }
  287. cap = &cap11xx_devices[id->driver_data];
  288. if (!cap || !cap->num_channels) {
  289. dev_err(dev, "Invalid device configuration\n");
  290. return -EINVAL;
  291. }
  292. priv = devm_kzalloc(dev,
  293. struct_size(priv, keycodes, cap->num_channels),
  294. GFP_KERNEL);
  295. if (!priv)
  296. return -ENOMEM;
  297. priv->regmap = devm_regmap_init_i2c(i2c_client, &cap11xx_regmap_config);
  298. if (IS_ERR(priv->regmap))
  299. return PTR_ERR(priv->regmap);
  300. error = regmap_read(priv->regmap, CAP11XX_REG_PRODUCT_ID, &val);
  301. if (error)
  302. return error;
  303. if (val != cap->product_id) {
  304. dev_err(dev, "Product ID: Got 0x%02x, expected 0x%02x\n",
  305. val, cap->product_id);
  306. return -ENXIO;
  307. }
  308. error = regmap_read(priv->regmap, CAP11XX_REG_MANUFACTURER_ID, &val);
  309. if (error)
  310. return error;
  311. if (val != CAP11XX_MANUFACTURER_ID) {
  312. dev_err(dev, "Manufacturer ID: Got 0x%02x, expected 0x%02x\n",
  313. val, CAP11XX_MANUFACTURER_ID);
  314. return -ENXIO;
  315. }
  316. error = regmap_read(priv->regmap, CAP11XX_REG_REVISION, &rev);
  317. if (error < 0)
  318. return error;
  319. dev_info(dev, "CAP11XX detected, revision 0x%02x\n", rev);
  320. node = dev->of_node;
  321. if (!of_property_read_u32(node, "microchip,sensor-gain", &gain32)) {
  322. if (is_power_of_2(gain32) && gain32 <= 8)
  323. gain = ilog2(gain32);
  324. else
  325. dev_err(dev, "Invalid sensor-gain value %d\n", gain32);
  326. }
  327. if (of_property_read_bool(node, "microchip,irq-active-high")) {
  328. error = regmap_update_bits(priv->regmap, CAP11XX_REG_CONFIG2,
  329. CAP11XX_REG_CONFIG2_ALT_POL, 0);
  330. if (error)
  331. return error;
  332. }
  333. /* Provide some useful defaults */
  334. for (i = 0; i < cap->num_channels; i++)
  335. priv->keycodes[i] = KEY_A + i;
  336. of_property_read_u32_array(node, "linux,keycodes",
  337. priv->keycodes, cap->num_channels);
  338. error = regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL,
  339. CAP11XX_REG_MAIN_CONTROL_GAIN_MASK,
  340. gain << CAP11XX_REG_MAIN_CONTROL_GAIN_SHIFT);
  341. if (error)
  342. return error;
  343. /* Disable autorepeat. The Linux input system has its own handling. */
  344. error = regmap_write(priv->regmap, CAP11XX_REG_REPEAT_RATE, 0);
  345. if (error)
  346. return error;
  347. priv->idev = devm_input_allocate_device(dev);
  348. if (!priv->idev)
  349. return -ENOMEM;
  350. priv->idev->name = "CAP11XX capacitive touch sensor";
  351. priv->idev->id.bustype = BUS_I2C;
  352. priv->idev->evbit[0] = BIT_MASK(EV_KEY);
  353. if (of_property_read_bool(node, "autorepeat"))
  354. __set_bit(EV_REP, priv->idev->evbit);
  355. for (i = 0; i < cap->num_channels; i++)
  356. __set_bit(priv->keycodes[i], priv->idev->keybit);
  357. __clear_bit(KEY_RESERVED, priv->idev->keybit);
  358. priv->idev->keycode = priv->keycodes;
  359. priv->idev->keycodesize = sizeof(priv->keycodes[0]);
  360. priv->idev->keycodemax = cap->num_channels;
  361. priv->idev->id.vendor = CAP11XX_MANUFACTURER_ID;
  362. priv->idev->id.product = cap->product_id;
  363. priv->idev->id.version = rev;
  364. priv->idev->open = cap11xx_input_open;
  365. priv->idev->close = cap11xx_input_close;
  366. error = cap11xx_init_leds(dev, priv, cap->num_leds);
  367. if (error)
  368. return error;
  369. input_set_drvdata(priv->idev, priv);
  370. /*
  371. * Put the device in deep sleep mode for now.
  372. * ->open() will bring it back once the it is actually needed.
  373. */
  374. cap11xx_set_sleep(priv, true);
  375. error = input_register_device(priv->idev);
  376. if (error)
  377. return error;
  378. irq = irq_of_parse_and_map(node, 0);
  379. if (!irq) {
  380. dev_err(dev, "Unable to parse or map IRQ\n");
  381. return -ENXIO;
  382. }
  383. error = devm_request_threaded_irq(dev, irq, NULL, cap11xx_thread_func,
  384. IRQF_ONESHOT, dev_name(dev), priv);
  385. if (error)
  386. return error;
  387. return 0;
  388. }
  389. static const struct of_device_id cap11xx_dt_ids[] = {
  390. { .compatible = "microchip,cap1106", },
  391. { .compatible = "microchip,cap1126", },
  392. { .compatible = "microchip,cap1188", },
  393. {}
  394. };
  395. MODULE_DEVICE_TABLE(of, cap11xx_dt_ids);
  396. static const struct i2c_device_id cap11xx_i2c_ids[] = {
  397. { "cap1106", CAP1106 },
  398. { "cap1126", CAP1126 },
  399. { "cap1188", CAP1188 },
  400. {}
  401. };
  402. MODULE_DEVICE_TABLE(i2c, cap11xx_i2c_ids);
  403. static struct i2c_driver cap11xx_i2c_driver = {
  404. .driver = {
  405. .name = "cap11xx",
  406. .of_match_table = cap11xx_dt_ids,
  407. },
  408. .id_table = cap11xx_i2c_ids,
  409. .probe = cap11xx_i2c_probe,
  410. };
  411. module_i2c_driver(cap11xx_i2c_driver);
  412. MODULE_DESCRIPTION("Microchip CAP11XX driver");
  413. MODULE_AUTHOR("Daniel Mack <linux@zonque.org>");
  414. MODULE_LICENSE("GPL v2");