adp5589-keys.c 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Description: keypad driver for ADP5589, ADP5585
  4. * I2C QWERTY Keypad and IO Expander
  5. * Bugs: Enter bugs at http://blackfin.uclinux.org/
  6. *
  7. * Copyright (C) 2010-2011 Analog Devices Inc.
  8. */
  9. #include <linux/module.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/irq.h>
  12. #include <linux/workqueue.h>
  13. #include <linux/errno.h>
  14. #include <linux/pm.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/input.h>
  17. #include <linux/i2c.h>
  18. #include <linux/gpio.h>
  19. #include <linux/slab.h>
  20. #include <linux/input/adp5589.h>
  21. /* ADP5589/ADP5585 Common Registers */
  22. #define ADP5589_5_ID 0x00
  23. #define ADP5589_5_INT_STATUS 0x01
  24. #define ADP5589_5_STATUS 0x02
  25. #define ADP5589_5_FIFO_1 0x03
  26. #define ADP5589_5_FIFO_2 0x04
  27. #define ADP5589_5_FIFO_3 0x05
  28. #define ADP5589_5_FIFO_4 0x06
  29. #define ADP5589_5_FIFO_5 0x07
  30. #define ADP5589_5_FIFO_6 0x08
  31. #define ADP5589_5_FIFO_7 0x09
  32. #define ADP5589_5_FIFO_8 0x0A
  33. #define ADP5589_5_FIFO_9 0x0B
  34. #define ADP5589_5_FIFO_10 0x0C
  35. #define ADP5589_5_FIFO_11 0x0D
  36. #define ADP5589_5_FIFO_12 0x0E
  37. #define ADP5589_5_FIFO_13 0x0F
  38. #define ADP5589_5_FIFO_14 0x10
  39. #define ADP5589_5_FIFO_15 0x11
  40. #define ADP5589_5_FIFO_16 0x12
  41. #define ADP5589_5_GPI_INT_STAT_A 0x13
  42. #define ADP5589_5_GPI_INT_STAT_B 0x14
  43. /* ADP5589 Registers */
  44. #define ADP5589_GPI_INT_STAT_C 0x15
  45. #define ADP5589_GPI_STATUS_A 0x16
  46. #define ADP5589_GPI_STATUS_B 0x17
  47. #define ADP5589_GPI_STATUS_C 0x18
  48. #define ADP5589_RPULL_CONFIG_A 0x19
  49. #define ADP5589_RPULL_CONFIG_B 0x1A
  50. #define ADP5589_RPULL_CONFIG_C 0x1B
  51. #define ADP5589_RPULL_CONFIG_D 0x1C
  52. #define ADP5589_RPULL_CONFIG_E 0x1D
  53. #define ADP5589_GPI_INT_LEVEL_A 0x1E
  54. #define ADP5589_GPI_INT_LEVEL_B 0x1F
  55. #define ADP5589_GPI_INT_LEVEL_C 0x20
  56. #define ADP5589_GPI_EVENT_EN_A 0x21
  57. #define ADP5589_GPI_EVENT_EN_B 0x22
  58. #define ADP5589_GPI_EVENT_EN_C 0x23
  59. #define ADP5589_GPI_INTERRUPT_EN_A 0x24
  60. #define ADP5589_GPI_INTERRUPT_EN_B 0x25
  61. #define ADP5589_GPI_INTERRUPT_EN_C 0x26
  62. #define ADP5589_DEBOUNCE_DIS_A 0x27
  63. #define ADP5589_DEBOUNCE_DIS_B 0x28
  64. #define ADP5589_DEBOUNCE_DIS_C 0x29
  65. #define ADP5589_GPO_DATA_OUT_A 0x2A
  66. #define ADP5589_GPO_DATA_OUT_B 0x2B
  67. #define ADP5589_GPO_DATA_OUT_C 0x2C
  68. #define ADP5589_GPO_OUT_MODE_A 0x2D
  69. #define ADP5589_GPO_OUT_MODE_B 0x2E
  70. #define ADP5589_GPO_OUT_MODE_C 0x2F
  71. #define ADP5589_GPIO_DIRECTION_A 0x30
  72. #define ADP5589_GPIO_DIRECTION_B 0x31
  73. #define ADP5589_GPIO_DIRECTION_C 0x32
  74. #define ADP5589_UNLOCK1 0x33
  75. #define ADP5589_UNLOCK2 0x34
  76. #define ADP5589_EXT_LOCK_EVENT 0x35
  77. #define ADP5589_UNLOCK_TIMERS 0x36
  78. #define ADP5589_LOCK_CFG 0x37
  79. #define ADP5589_RESET1_EVENT_A 0x38
  80. #define ADP5589_RESET1_EVENT_B 0x39
  81. #define ADP5589_RESET1_EVENT_C 0x3A
  82. #define ADP5589_RESET2_EVENT_A 0x3B
  83. #define ADP5589_RESET2_EVENT_B 0x3C
  84. #define ADP5589_RESET_CFG 0x3D
  85. #define ADP5589_PWM_OFFT_LOW 0x3E
  86. #define ADP5589_PWM_OFFT_HIGH 0x3F
  87. #define ADP5589_PWM_ONT_LOW 0x40
  88. #define ADP5589_PWM_ONT_HIGH 0x41
  89. #define ADP5589_PWM_CFG 0x42
  90. #define ADP5589_CLOCK_DIV_CFG 0x43
  91. #define ADP5589_LOGIC_1_CFG 0x44
  92. #define ADP5589_LOGIC_2_CFG 0x45
  93. #define ADP5589_LOGIC_FF_CFG 0x46
  94. #define ADP5589_LOGIC_INT_EVENT_EN 0x47
  95. #define ADP5589_POLL_PTIME_CFG 0x48
  96. #define ADP5589_PIN_CONFIG_A 0x49
  97. #define ADP5589_PIN_CONFIG_B 0x4A
  98. #define ADP5589_PIN_CONFIG_C 0x4B
  99. #define ADP5589_PIN_CONFIG_D 0x4C
  100. #define ADP5589_GENERAL_CFG 0x4D
  101. #define ADP5589_INT_EN 0x4E
  102. /* ADP5585 Registers */
  103. #define ADP5585_GPI_STATUS_A 0x15
  104. #define ADP5585_GPI_STATUS_B 0x16
  105. #define ADP5585_RPULL_CONFIG_A 0x17
  106. #define ADP5585_RPULL_CONFIG_B 0x18
  107. #define ADP5585_RPULL_CONFIG_C 0x19
  108. #define ADP5585_RPULL_CONFIG_D 0x1A
  109. #define ADP5585_GPI_INT_LEVEL_A 0x1B
  110. #define ADP5585_GPI_INT_LEVEL_B 0x1C
  111. #define ADP5585_GPI_EVENT_EN_A 0x1D
  112. #define ADP5585_GPI_EVENT_EN_B 0x1E
  113. #define ADP5585_GPI_INTERRUPT_EN_A 0x1F
  114. #define ADP5585_GPI_INTERRUPT_EN_B 0x20
  115. #define ADP5585_DEBOUNCE_DIS_A 0x21
  116. #define ADP5585_DEBOUNCE_DIS_B 0x22
  117. #define ADP5585_GPO_DATA_OUT_A 0x23
  118. #define ADP5585_GPO_DATA_OUT_B 0x24
  119. #define ADP5585_GPO_OUT_MODE_A 0x25
  120. #define ADP5585_GPO_OUT_MODE_B 0x26
  121. #define ADP5585_GPIO_DIRECTION_A 0x27
  122. #define ADP5585_GPIO_DIRECTION_B 0x28
  123. #define ADP5585_RESET1_EVENT_A 0x29
  124. #define ADP5585_RESET1_EVENT_B 0x2A
  125. #define ADP5585_RESET1_EVENT_C 0x2B
  126. #define ADP5585_RESET2_EVENT_A 0x2C
  127. #define ADP5585_RESET2_EVENT_B 0x2D
  128. #define ADP5585_RESET_CFG 0x2E
  129. #define ADP5585_PWM_OFFT_LOW 0x2F
  130. #define ADP5585_PWM_OFFT_HIGH 0x30
  131. #define ADP5585_PWM_ONT_LOW 0x31
  132. #define ADP5585_PWM_ONT_HIGH 0x32
  133. #define ADP5585_PWM_CFG 0x33
  134. #define ADP5585_LOGIC_CFG 0x34
  135. #define ADP5585_LOGIC_FF_CFG 0x35
  136. #define ADP5585_LOGIC_INT_EVENT_EN 0x36
  137. #define ADP5585_POLL_PTIME_CFG 0x37
  138. #define ADP5585_PIN_CONFIG_A 0x38
  139. #define ADP5585_PIN_CONFIG_B 0x39
  140. #define ADP5585_PIN_CONFIG_D 0x3A
  141. #define ADP5585_GENERAL_CFG 0x3B
  142. #define ADP5585_INT_EN 0x3C
  143. /* ID Register */
  144. #define ADP5589_5_DEVICE_ID_MASK 0xF
  145. #define ADP5589_5_MAN_ID_MASK 0xF
  146. #define ADP5589_5_MAN_ID_SHIFT 4
  147. #define ADP5589_5_MAN_ID 0x02
  148. /* GENERAL_CFG Register */
  149. #define OSC_EN (1 << 7)
  150. #define CORE_CLK(x) (((x) & 0x3) << 5)
  151. #define LCK_TRK_LOGIC (1 << 4) /* ADP5589 only */
  152. #define LCK_TRK_GPI (1 << 3) /* ADP5589 only */
  153. #define INT_CFG (1 << 1)
  154. #define RST_CFG (1 << 0)
  155. /* INT_EN Register */
  156. #define LOGIC2_IEN (1 << 5) /* ADP5589 only */
  157. #define LOGIC1_IEN (1 << 4)
  158. #define LOCK_IEN (1 << 3) /* ADP5589 only */
  159. #define OVRFLOW_IEN (1 << 2)
  160. #define GPI_IEN (1 << 1)
  161. #define EVENT_IEN (1 << 0)
  162. /* Interrupt Status Register */
  163. #define LOGIC2_INT (1 << 5) /* ADP5589 only */
  164. #define LOGIC1_INT (1 << 4)
  165. #define LOCK_INT (1 << 3) /* ADP5589 only */
  166. #define OVRFLOW_INT (1 << 2)
  167. #define GPI_INT (1 << 1)
  168. #define EVENT_INT (1 << 0)
  169. /* STATUS Register */
  170. #define LOGIC2_STAT (1 << 7) /* ADP5589 only */
  171. #define LOGIC1_STAT (1 << 6)
  172. #define LOCK_STAT (1 << 5) /* ADP5589 only */
  173. #define KEC 0x1F
  174. /* PIN_CONFIG_D Register */
  175. #define C4_EXTEND_CFG (1 << 6) /* RESET2 */
  176. #define R4_EXTEND_CFG (1 << 5) /* RESET1 */
  177. /* LOCK_CFG */
  178. #define LOCK_EN (1 << 0)
  179. #define PTIME_MASK 0x3
  180. #define LTIME_MASK 0x3 /* ADP5589 only */
  181. /* Key Event Register xy */
  182. #define KEY_EV_PRESSED (1 << 7)
  183. #define KEY_EV_MASK (0x7F)
  184. #define KEYP_MAX_EVENT 16
  185. #define ADP5589_MAXGPIO 19
  186. #define ADP5585_MAXGPIO 11 /* 10 on the ADP5585-01, 11 on ADP5585-02 */
  187. enum {
  188. ADP5589,
  189. ADP5585_01,
  190. ADP5585_02
  191. };
  192. struct adp_constants {
  193. u8 maxgpio;
  194. u8 keymapsize;
  195. u8 gpi_pin_row_base;
  196. u8 gpi_pin_row_end;
  197. u8 gpi_pin_col_base;
  198. u8 gpi_pin_base;
  199. u8 gpi_pin_end;
  200. u8 gpimapsize_max;
  201. u8 max_row_num;
  202. u8 max_col_num;
  203. u8 row_mask;
  204. u8 col_mask;
  205. u8 col_shift;
  206. u8 c4_extend_cfg;
  207. u8 (*bank) (u8 offset);
  208. u8 (*bit) (u8 offset);
  209. u8 (*reg) (u8 reg);
  210. };
  211. struct adp5589_kpad {
  212. struct i2c_client *client;
  213. struct input_dev *input;
  214. const struct adp_constants *var;
  215. unsigned short keycode[ADP5589_KEYMAPSIZE];
  216. const struct adp5589_gpi_map *gpimap;
  217. unsigned short gpimapsize;
  218. unsigned extend_cfg;
  219. bool is_adp5585;
  220. bool support_row5;
  221. #ifdef CONFIG_GPIOLIB
  222. unsigned char gpiomap[ADP5589_MAXGPIO];
  223. bool export_gpio;
  224. struct gpio_chip gc;
  225. struct mutex gpio_lock; /* Protect cached dir, dat_out */
  226. u8 dat_out[3];
  227. u8 dir[3];
  228. #endif
  229. };
  230. /*
  231. * ADP5589 / ADP5585 derivative / variant handling
  232. */
  233. /* ADP5589 */
  234. static unsigned char adp5589_bank(unsigned char offset)
  235. {
  236. return offset >> 3;
  237. }
  238. static unsigned char adp5589_bit(unsigned char offset)
  239. {
  240. return 1u << (offset & 0x7);
  241. }
  242. static unsigned char adp5589_reg(unsigned char reg)
  243. {
  244. return reg;
  245. }
  246. static const struct adp_constants const_adp5589 = {
  247. .maxgpio = ADP5589_MAXGPIO,
  248. .keymapsize = ADP5589_KEYMAPSIZE,
  249. .gpi_pin_row_base = ADP5589_GPI_PIN_ROW_BASE,
  250. .gpi_pin_row_end = ADP5589_GPI_PIN_ROW_END,
  251. .gpi_pin_col_base = ADP5589_GPI_PIN_COL_BASE,
  252. .gpi_pin_base = ADP5589_GPI_PIN_BASE,
  253. .gpi_pin_end = ADP5589_GPI_PIN_END,
  254. .gpimapsize_max = ADP5589_GPIMAPSIZE_MAX,
  255. .c4_extend_cfg = 12,
  256. .max_row_num = ADP5589_MAX_ROW_NUM,
  257. .max_col_num = ADP5589_MAX_COL_NUM,
  258. .row_mask = ADP5589_ROW_MASK,
  259. .col_mask = ADP5589_COL_MASK,
  260. .col_shift = ADP5589_COL_SHIFT,
  261. .bank = adp5589_bank,
  262. .bit = adp5589_bit,
  263. .reg = adp5589_reg,
  264. };
  265. /* ADP5585 */
  266. static unsigned char adp5585_bank(unsigned char offset)
  267. {
  268. return offset > ADP5585_MAX_ROW_NUM;
  269. }
  270. static unsigned char adp5585_bit(unsigned char offset)
  271. {
  272. return (offset > ADP5585_MAX_ROW_NUM) ?
  273. 1u << (offset - ADP5585_COL_SHIFT) : 1u << offset;
  274. }
  275. static const unsigned char adp5585_reg_lut[] = {
  276. [ADP5589_GPI_STATUS_A] = ADP5585_GPI_STATUS_A,
  277. [ADP5589_GPI_STATUS_B] = ADP5585_GPI_STATUS_B,
  278. [ADP5589_RPULL_CONFIG_A] = ADP5585_RPULL_CONFIG_A,
  279. [ADP5589_RPULL_CONFIG_B] = ADP5585_RPULL_CONFIG_B,
  280. [ADP5589_RPULL_CONFIG_C] = ADP5585_RPULL_CONFIG_C,
  281. [ADP5589_RPULL_CONFIG_D] = ADP5585_RPULL_CONFIG_D,
  282. [ADP5589_GPI_INT_LEVEL_A] = ADP5585_GPI_INT_LEVEL_A,
  283. [ADP5589_GPI_INT_LEVEL_B] = ADP5585_GPI_INT_LEVEL_B,
  284. [ADP5589_GPI_EVENT_EN_A] = ADP5585_GPI_EVENT_EN_A,
  285. [ADP5589_GPI_EVENT_EN_B] = ADP5585_GPI_EVENT_EN_B,
  286. [ADP5589_GPI_INTERRUPT_EN_A] = ADP5585_GPI_INTERRUPT_EN_A,
  287. [ADP5589_GPI_INTERRUPT_EN_B] = ADP5585_GPI_INTERRUPT_EN_B,
  288. [ADP5589_DEBOUNCE_DIS_A] = ADP5585_DEBOUNCE_DIS_A,
  289. [ADP5589_DEBOUNCE_DIS_B] = ADP5585_DEBOUNCE_DIS_B,
  290. [ADP5589_GPO_DATA_OUT_A] = ADP5585_GPO_DATA_OUT_A,
  291. [ADP5589_GPO_DATA_OUT_B] = ADP5585_GPO_DATA_OUT_B,
  292. [ADP5589_GPO_OUT_MODE_A] = ADP5585_GPO_OUT_MODE_A,
  293. [ADP5589_GPO_OUT_MODE_B] = ADP5585_GPO_OUT_MODE_B,
  294. [ADP5589_GPIO_DIRECTION_A] = ADP5585_GPIO_DIRECTION_A,
  295. [ADP5589_GPIO_DIRECTION_B] = ADP5585_GPIO_DIRECTION_B,
  296. [ADP5589_RESET1_EVENT_A] = ADP5585_RESET1_EVENT_A,
  297. [ADP5589_RESET1_EVENT_B] = ADP5585_RESET1_EVENT_B,
  298. [ADP5589_RESET1_EVENT_C] = ADP5585_RESET1_EVENT_C,
  299. [ADP5589_RESET2_EVENT_A] = ADP5585_RESET2_EVENT_A,
  300. [ADP5589_RESET2_EVENT_B] = ADP5585_RESET2_EVENT_B,
  301. [ADP5589_RESET_CFG] = ADP5585_RESET_CFG,
  302. [ADP5589_PWM_OFFT_LOW] = ADP5585_PWM_OFFT_LOW,
  303. [ADP5589_PWM_OFFT_HIGH] = ADP5585_PWM_OFFT_HIGH,
  304. [ADP5589_PWM_ONT_LOW] = ADP5585_PWM_ONT_LOW,
  305. [ADP5589_PWM_ONT_HIGH] = ADP5585_PWM_ONT_HIGH,
  306. [ADP5589_PWM_CFG] = ADP5585_PWM_CFG,
  307. [ADP5589_LOGIC_1_CFG] = ADP5585_LOGIC_CFG,
  308. [ADP5589_LOGIC_FF_CFG] = ADP5585_LOGIC_FF_CFG,
  309. [ADP5589_LOGIC_INT_EVENT_EN] = ADP5585_LOGIC_INT_EVENT_EN,
  310. [ADP5589_POLL_PTIME_CFG] = ADP5585_POLL_PTIME_CFG,
  311. [ADP5589_PIN_CONFIG_A] = ADP5585_PIN_CONFIG_A,
  312. [ADP5589_PIN_CONFIG_B] = ADP5585_PIN_CONFIG_B,
  313. [ADP5589_PIN_CONFIG_D] = ADP5585_PIN_CONFIG_D,
  314. [ADP5589_GENERAL_CFG] = ADP5585_GENERAL_CFG,
  315. [ADP5589_INT_EN] = ADP5585_INT_EN,
  316. };
  317. static unsigned char adp5585_reg(unsigned char reg)
  318. {
  319. return adp5585_reg_lut[reg];
  320. }
  321. static const struct adp_constants const_adp5585 = {
  322. .maxgpio = ADP5585_MAXGPIO,
  323. .keymapsize = ADP5585_KEYMAPSIZE,
  324. .gpi_pin_row_base = ADP5585_GPI_PIN_ROW_BASE,
  325. .gpi_pin_row_end = ADP5585_GPI_PIN_ROW_END,
  326. .gpi_pin_col_base = ADP5585_GPI_PIN_COL_BASE,
  327. .gpi_pin_base = ADP5585_GPI_PIN_BASE,
  328. .gpi_pin_end = ADP5585_GPI_PIN_END,
  329. .gpimapsize_max = ADP5585_GPIMAPSIZE_MAX,
  330. .c4_extend_cfg = 10,
  331. .max_row_num = ADP5585_MAX_ROW_NUM,
  332. .max_col_num = ADP5585_MAX_COL_NUM,
  333. .row_mask = ADP5585_ROW_MASK,
  334. .col_mask = ADP5585_COL_MASK,
  335. .col_shift = ADP5585_COL_SHIFT,
  336. .bank = adp5585_bank,
  337. .bit = adp5585_bit,
  338. .reg = adp5585_reg,
  339. };
  340. static int adp5589_read(struct i2c_client *client, u8 reg)
  341. {
  342. int ret = i2c_smbus_read_byte_data(client, reg);
  343. if (ret < 0)
  344. dev_err(&client->dev, "Read Error\n");
  345. return ret;
  346. }
  347. static int adp5589_write(struct i2c_client *client, u8 reg, u8 val)
  348. {
  349. return i2c_smbus_write_byte_data(client, reg, val);
  350. }
  351. #ifdef CONFIG_GPIOLIB
  352. static int adp5589_gpio_get_value(struct gpio_chip *chip, unsigned off)
  353. {
  354. struct adp5589_kpad *kpad = gpiochip_get_data(chip);
  355. unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
  356. unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
  357. return !!(adp5589_read(kpad->client,
  358. kpad->var->reg(ADP5589_GPI_STATUS_A) + bank) &
  359. bit);
  360. }
  361. static void adp5589_gpio_set_value(struct gpio_chip *chip,
  362. unsigned off, int val)
  363. {
  364. struct adp5589_kpad *kpad = gpiochip_get_data(chip);
  365. unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
  366. unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
  367. mutex_lock(&kpad->gpio_lock);
  368. if (val)
  369. kpad->dat_out[bank] |= bit;
  370. else
  371. kpad->dat_out[bank] &= ~bit;
  372. adp5589_write(kpad->client, kpad->var->reg(ADP5589_GPO_DATA_OUT_A) +
  373. bank, kpad->dat_out[bank]);
  374. mutex_unlock(&kpad->gpio_lock);
  375. }
  376. static int adp5589_gpio_direction_input(struct gpio_chip *chip, unsigned off)
  377. {
  378. struct adp5589_kpad *kpad = gpiochip_get_data(chip);
  379. unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
  380. unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
  381. int ret;
  382. mutex_lock(&kpad->gpio_lock);
  383. kpad->dir[bank] &= ~bit;
  384. ret = adp5589_write(kpad->client,
  385. kpad->var->reg(ADP5589_GPIO_DIRECTION_A) + bank,
  386. kpad->dir[bank]);
  387. mutex_unlock(&kpad->gpio_lock);
  388. return ret;
  389. }
  390. static int adp5589_gpio_direction_output(struct gpio_chip *chip,
  391. unsigned off, int val)
  392. {
  393. struct adp5589_kpad *kpad = gpiochip_get_data(chip);
  394. unsigned int bank = kpad->var->bank(kpad->gpiomap[off]);
  395. unsigned int bit = kpad->var->bit(kpad->gpiomap[off]);
  396. int ret;
  397. mutex_lock(&kpad->gpio_lock);
  398. kpad->dir[bank] |= bit;
  399. if (val)
  400. kpad->dat_out[bank] |= bit;
  401. else
  402. kpad->dat_out[bank] &= ~bit;
  403. ret = adp5589_write(kpad->client, kpad->var->reg(ADP5589_GPO_DATA_OUT_A)
  404. + bank, kpad->dat_out[bank]);
  405. ret |= adp5589_write(kpad->client,
  406. kpad->var->reg(ADP5589_GPIO_DIRECTION_A) + bank,
  407. kpad->dir[bank]);
  408. mutex_unlock(&kpad->gpio_lock);
  409. return ret;
  410. }
  411. static int adp5589_build_gpiomap(struct adp5589_kpad *kpad,
  412. const struct adp5589_kpad_platform_data *pdata)
  413. {
  414. bool pin_used[ADP5589_MAXGPIO];
  415. int n_unused = 0;
  416. int i;
  417. memset(pin_used, false, sizeof(pin_used));
  418. for (i = 0; i < kpad->var->maxgpio; i++)
  419. if (pdata->keypad_en_mask & (1 << i))
  420. pin_used[i] = true;
  421. for (i = 0; i < kpad->gpimapsize; i++)
  422. pin_used[kpad->gpimap[i].pin - kpad->var->gpi_pin_base] = true;
  423. if (kpad->extend_cfg & R4_EXTEND_CFG)
  424. pin_used[4] = true;
  425. if (kpad->extend_cfg & C4_EXTEND_CFG)
  426. pin_used[kpad->var->c4_extend_cfg] = true;
  427. if (!kpad->support_row5)
  428. pin_used[5] = true;
  429. for (i = 0; i < kpad->var->maxgpio; i++)
  430. if (!pin_used[i])
  431. kpad->gpiomap[n_unused++] = i;
  432. return n_unused;
  433. }
  434. static int adp5589_gpio_add(struct adp5589_kpad *kpad)
  435. {
  436. struct device *dev = &kpad->client->dev;
  437. const struct adp5589_kpad_platform_data *pdata = dev_get_platdata(dev);
  438. const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
  439. int i, error;
  440. if (!gpio_data)
  441. return 0;
  442. kpad->gc.parent = dev;
  443. kpad->gc.ngpio = adp5589_build_gpiomap(kpad, pdata);
  444. if (kpad->gc.ngpio == 0) {
  445. dev_info(dev, "No unused gpios left to export\n");
  446. return 0;
  447. }
  448. kpad->export_gpio = true;
  449. kpad->gc.direction_input = adp5589_gpio_direction_input;
  450. kpad->gc.direction_output = adp5589_gpio_direction_output;
  451. kpad->gc.get = adp5589_gpio_get_value;
  452. kpad->gc.set = adp5589_gpio_set_value;
  453. kpad->gc.can_sleep = 1;
  454. kpad->gc.base = gpio_data->gpio_start;
  455. kpad->gc.label = kpad->client->name;
  456. kpad->gc.owner = THIS_MODULE;
  457. mutex_init(&kpad->gpio_lock);
  458. error = gpiochip_add_data(&kpad->gc, kpad);
  459. if (error) {
  460. dev_err(dev, "gpiochip_add_data() failed, err: %d\n", error);
  461. return error;
  462. }
  463. for (i = 0; i <= kpad->var->bank(kpad->var->maxgpio); i++) {
  464. kpad->dat_out[i] = adp5589_read(kpad->client, kpad->var->reg(
  465. ADP5589_GPO_DATA_OUT_A) + i);
  466. kpad->dir[i] = adp5589_read(kpad->client, kpad->var->reg(
  467. ADP5589_GPIO_DIRECTION_A) + i);
  468. }
  469. if (gpio_data->setup) {
  470. error = gpio_data->setup(kpad->client,
  471. kpad->gc.base, kpad->gc.ngpio,
  472. gpio_data->context);
  473. if (error)
  474. dev_warn(dev, "setup failed, %d\n", error);
  475. }
  476. return 0;
  477. }
  478. static void adp5589_gpio_remove(struct adp5589_kpad *kpad)
  479. {
  480. struct device *dev = &kpad->client->dev;
  481. const struct adp5589_kpad_platform_data *pdata = dev_get_platdata(dev);
  482. const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
  483. int error;
  484. if (!kpad->export_gpio)
  485. return;
  486. if (gpio_data->teardown) {
  487. error = gpio_data->teardown(kpad->client,
  488. kpad->gc.base, kpad->gc.ngpio,
  489. gpio_data->context);
  490. if (error)
  491. dev_warn(dev, "teardown failed %d\n", error);
  492. }
  493. gpiochip_remove(&kpad->gc);
  494. }
  495. #else
  496. static inline int adp5589_gpio_add(struct adp5589_kpad *kpad)
  497. {
  498. return 0;
  499. }
  500. static inline void adp5589_gpio_remove(struct adp5589_kpad *kpad)
  501. {
  502. }
  503. #endif
  504. static void adp5589_report_switches(struct adp5589_kpad *kpad,
  505. int key, int key_val)
  506. {
  507. int i;
  508. for (i = 0; i < kpad->gpimapsize; i++) {
  509. if (key_val == kpad->gpimap[i].pin) {
  510. input_report_switch(kpad->input,
  511. kpad->gpimap[i].sw_evt,
  512. key & KEY_EV_PRESSED);
  513. break;
  514. }
  515. }
  516. }
  517. static void adp5589_report_events(struct adp5589_kpad *kpad, int ev_cnt)
  518. {
  519. int i;
  520. for (i = 0; i < ev_cnt; i++) {
  521. int key = adp5589_read(kpad->client, ADP5589_5_FIFO_1 + i);
  522. int key_val = key & KEY_EV_MASK;
  523. if (key_val >= kpad->var->gpi_pin_base &&
  524. key_val <= kpad->var->gpi_pin_end) {
  525. adp5589_report_switches(kpad, key, key_val);
  526. } else {
  527. input_report_key(kpad->input,
  528. kpad->keycode[key_val - 1],
  529. key & KEY_EV_PRESSED);
  530. }
  531. }
  532. }
  533. static irqreturn_t adp5589_irq(int irq, void *handle)
  534. {
  535. struct adp5589_kpad *kpad = handle;
  536. struct i2c_client *client = kpad->client;
  537. int status, ev_cnt;
  538. status = adp5589_read(client, ADP5589_5_INT_STATUS);
  539. if (status & OVRFLOW_INT) /* Unlikely and should never happen */
  540. dev_err(&client->dev, "Event Overflow Error\n");
  541. if (status & EVENT_INT) {
  542. ev_cnt = adp5589_read(client, ADP5589_5_STATUS) & KEC;
  543. if (ev_cnt) {
  544. adp5589_report_events(kpad, ev_cnt);
  545. input_sync(kpad->input);
  546. }
  547. }
  548. adp5589_write(client, ADP5589_5_INT_STATUS, status); /* Status is W1C */
  549. return IRQ_HANDLED;
  550. }
  551. static int adp5589_get_evcode(struct adp5589_kpad *kpad, unsigned short key)
  552. {
  553. int i;
  554. for (i = 0; i < kpad->var->keymapsize; i++)
  555. if (key == kpad->keycode[i])
  556. return (i + 1) | KEY_EV_PRESSED;
  557. dev_err(&kpad->client->dev, "RESET/UNLOCK key not in keycode map\n");
  558. return -EINVAL;
  559. }
  560. static int adp5589_setup(struct adp5589_kpad *kpad)
  561. {
  562. struct i2c_client *client = kpad->client;
  563. const struct adp5589_kpad_platform_data *pdata =
  564. dev_get_platdata(&client->dev);
  565. u8 (*reg) (u8) = kpad->var->reg;
  566. unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
  567. unsigned char pull_mask = 0;
  568. int i, ret;
  569. ret = adp5589_write(client, reg(ADP5589_PIN_CONFIG_A),
  570. pdata->keypad_en_mask & kpad->var->row_mask);
  571. ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_B),
  572. (pdata->keypad_en_mask >> kpad->var->col_shift) &
  573. kpad->var->col_mask);
  574. if (!kpad->is_adp5585)
  575. ret |= adp5589_write(client, ADP5589_PIN_CONFIG_C,
  576. (pdata->keypad_en_mask >> 16) & 0xFF);
  577. if (!kpad->is_adp5585 && pdata->en_keylock) {
  578. ret |= adp5589_write(client, ADP5589_UNLOCK1,
  579. pdata->unlock_key1);
  580. ret |= adp5589_write(client, ADP5589_UNLOCK2,
  581. pdata->unlock_key2);
  582. ret |= adp5589_write(client, ADP5589_UNLOCK_TIMERS,
  583. pdata->unlock_timer & LTIME_MASK);
  584. ret |= adp5589_write(client, ADP5589_LOCK_CFG, LOCK_EN);
  585. }
  586. for (i = 0; i < KEYP_MAX_EVENT; i++)
  587. ret |= adp5589_read(client, ADP5589_5_FIFO_1 + i);
  588. for (i = 0; i < pdata->gpimapsize; i++) {
  589. unsigned short pin = pdata->gpimap[i].pin;
  590. if (pin <= kpad->var->gpi_pin_row_end) {
  591. evt_mode1 |= (1 << (pin - kpad->var->gpi_pin_row_base));
  592. } else {
  593. evt_mode2 |=
  594. ((1 << (pin - kpad->var->gpi_pin_col_base)) & 0xFF);
  595. if (!kpad->is_adp5585)
  596. evt_mode3 |= ((1 << (pin -
  597. kpad->var->gpi_pin_col_base)) >> 8);
  598. }
  599. }
  600. if (pdata->gpimapsize) {
  601. ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_A),
  602. evt_mode1);
  603. ret |= adp5589_write(client, reg(ADP5589_GPI_EVENT_EN_B),
  604. evt_mode2);
  605. if (!kpad->is_adp5585)
  606. ret |= adp5589_write(client,
  607. reg(ADP5589_GPI_EVENT_EN_C),
  608. evt_mode3);
  609. }
  610. if (pdata->pull_dis_mask & pdata->pullup_en_100k &
  611. pdata->pullup_en_300k & pdata->pulldown_en_300k)
  612. dev_warn(&client->dev, "Conflicting pull resistor config\n");
  613. for (i = 0; i <= kpad->var->max_row_num; i++) {
  614. unsigned val = 0, bit = (1 << i);
  615. if (pdata->pullup_en_300k & bit)
  616. val = 0;
  617. else if (pdata->pulldown_en_300k & bit)
  618. val = 1;
  619. else if (pdata->pullup_en_100k & bit)
  620. val = 2;
  621. else if (pdata->pull_dis_mask & bit)
  622. val = 3;
  623. pull_mask |= val << (2 * (i & 0x3));
  624. if (i % 4 == 3 || i == kpad->var->max_row_num) {
  625. ret |= adp5589_write(client, reg(ADP5585_RPULL_CONFIG_A)
  626. + (i >> 2), pull_mask);
  627. pull_mask = 0;
  628. }
  629. }
  630. for (i = 0; i <= kpad->var->max_col_num; i++) {
  631. unsigned val = 0, bit = 1 << (i + kpad->var->col_shift);
  632. if (pdata->pullup_en_300k & bit)
  633. val = 0;
  634. else if (pdata->pulldown_en_300k & bit)
  635. val = 1;
  636. else if (pdata->pullup_en_100k & bit)
  637. val = 2;
  638. else if (pdata->pull_dis_mask & bit)
  639. val = 3;
  640. pull_mask |= val << (2 * (i & 0x3));
  641. if (i % 4 == 3 || i == kpad->var->max_col_num) {
  642. ret |= adp5589_write(client,
  643. reg(ADP5585_RPULL_CONFIG_C) +
  644. (i >> 2), pull_mask);
  645. pull_mask = 0;
  646. }
  647. }
  648. if (pdata->reset1_key_1 && pdata->reset1_key_2 && pdata->reset1_key_3) {
  649. ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_A),
  650. adp5589_get_evcode(kpad,
  651. pdata->reset1_key_1));
  652. ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_B),
  653. adp5589_get_evcode(kpad,
  654. pdata->reset1_key_2));
  655. ret |= adp5589_write(client, reg(ADP5589_RESET1_EVENT_C),
  656. adp5589_get_evcode(kpad,
  657. pdata->reset1_key_3));
  658. kpad->extend_cfg |= R4_EXTEND_CFG;
  659. }
  660. if (pdata->reset2_key_1 && pdata->reset2_key_2) {
  661. ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_A),
  662. adp5589_get_evcode(kpad,
  663. pdata->reset2_key_1));
  664. ret |= adp5589_write(client, reg(ADP5589_RESET2_EVENT_B),
  665. adp5589_get_evcode(kpad,
  666. pdata->reset2_key_2));
  667. kpad->extend_cfg |= C4_EXTEND_CFG;
  668. }
  669. if (kpad->extend_cfg) {
  670. ret |= adp5589_write(client, reg(ADP5589_RESET_CFG),
  671. pdata->reset_cfg);
  672. ret |= adp5589_write(client, reg(ADP5589_PIN_CONFIG_D),
  673. kpad->extend_cfg);
  674. }
  675. ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_A),
  676. pdata->debounce_dis_mask & kpad->var->row_mask);
  677. ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_B),
  678. (pdata->debounce_dis_mask >> kpad->var->col_shift)
  679. & kpad->var->col_mask);
  680. if (!kpad->is_adp5585)
  681. ret |= adp5589_write(client, reg(ADP5589_DEBOUNCE_DIS_C),
  682. (pdata->debounce_dis_mask >> 16) & 0xFF);
  683. ret |= adp5589_write(client, reg(ADP5589_POLL_PTIME_CFG),
  684. pdata->scan_cycle_time & PTIME_MASK);
  685. ret |= adp5589_write(client, ADP5589_5_INT_STATUS,
  686. (kpad->is_adp5585 ? 0 : LOGIC2_INT) |
  687. LOGIC1_INT | OVRFLOW_INT |
  688. (kpad->is_adp5585 ? 0 : LOCK_INT) |
  689. GPI_INT | EVENT_INT); /* Status is W1C */
  690. ret |= adp5589_write(client, reg(ADP5589_GENERAL_CFG),
  691. INT_CFG | OSC_EN | CORE_CLK(3));
  692. ret |= adp5589_write(client, reg(ADP5589_INT_EN),
  693. OVRFLOW_IEN | GPI_IEN | EVENT_IEN);
  694. if (ret < 0) {
  695. dev_err(&client->dev, "Write Error\n");
  696. return ret;
  697. }
  698. return 0;
  699. }
  700. static void adp5589_report_switch_state(struct adp5589_kpad *kpad)
  701. {
  702. int gpi_stat_tmp, pin_loc;
  703. int i;
  704. int gpi_stat1 = adp5589_read(kpad->client,
  705. kpad->var->reg(ADP5589_GPI_STATUS_A));
  706. int gpi_stat2 = adp5589_read(kpad->client,
  707. kpad->var->reg(ADP5589_GPI_STATUS_B));
  708. int gpi_stat3 = !kpad->is_adp5585 ?
  709. adp5589_read(kpad->client, ADP5589_GPI_STATUS_C) : 0;
  710. for (i = 0; i < kpad->gpimapsize; i++) {
  711. unsigned short pin = kpad->gpimap[i].pin;
  712. if (pin <= kpad->var->gpi_pin_row_end) {
  713. gpi_stat_tmp = gpi_stat1;
  714. pin_loc = pin - kpad->var->gpi_pin_row_base;
  715. } else if ((pin - kpad->var->gpi_pin_col_base) < 8) {
  716. gpi_stat_tmp = gpi_stat2;
  717. pin_loc = pin - kpad->var->gpi_pin_col_base;
  718. } else {
  719. gpi_stat_tmp = gpi_stat3;
  720. pin_loc = pin - kpad->var->gpi_pin_col_base - 8;
  721. }
  722. if (gpi_stat_tmp < 0) {
  723. dev_err(&kpad->client->dev,
  724. "Can't read GPIO_DAT_STAT switch %d, default to OFF\n",
  725. pin);
  726. gpi_stat_tmp = 0;
  727. }
  728. input_report_switch(kpad->input,
  729. kpad->gpimap[i].sw_evt,
  730. !(gpi_stat_tmp & (1 << pin_loc)));
  731. }
  732. input_sync(kpad->input);
  733. }
  734. static int adp5589_keypad_add(struct adp5589_kpad *kpad, unsigned int revid)
  735. {
  736. struct i2c_client *client = kpad->client;
  737. const struct adp5589_kpad_platform_data *pdata =
  738. dev_get_platdata(&client->dev);
  739. struct input_dev *input;
  740. unsigned int i;
  741. int error;
  742. if (!((pdata->keypad_en_mask & kpad->var->row_mask) &&
  743. (pdata->keypad_en_mask >> kpad->var->col_shift)) ||
  744. !pdata->keymap) {
  745. dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
  746. return -EINVAL;
  747. }
  748. if (pdata->keymapsize != kpad->var->keymapsize) {
  749. dev_err(&client->dev, "invalid keymapsize\n");
  750. return -EINVAL;
  751. }
  752. if (!pdata->gpimap && pdata->gpimapsize) {
  753. dev_err(&client->dev, "invalid gpimap from pdata\n");
  754. return -EINVAL;
  755. }
  756. if (pdata->gpimapsize > kpad->var->gpimapsize_max) {
  757. dev_err(&client->dev, "invalid gpimapsize\n");
  758. return -EINVAL;
  759. }
  760. for (i = 0; i < pdata->gpimapsize; i++) {
  761. unsigned short pin = pdata->gpimap[i].pin;
  762. if (pin < kpad->var->gpi_pin_base ||
  763. pin > kpad->var->gpi_pin_end) {
  764. dev_err(&client->dev, "invalid gpi pin data\n");
  765. return -EINVAL;
  766. }
  767. if ((1 << (pin - kpad->var->gpi_pin_row_base)) &
  768. pdata->keypad_en_mask) {
  769. dev_err(&client->dev, "invalid gpi row/col data\n");
  770. return -EINVAL;
  771. }
  772. }
  773. if (!client->irq) {
  774. dev_err(&client->dev, "no IRQ?\n");
  775. return -EINVAL;
  776. }
  777. input = input_allocate_device();
  778. if (!input)
  779. return -ENOMEM;
  780. kpad->input = input;
  781. input->name = client->name;
  782. input->phys = "adp5589-keys/input0";
  783. input->dev.parent = &client->dev;
  784. input_set_drvdata(input, kpad);
  785. input->id.bustype = BUS_I2C;
  786. input->id.vendor = 0x0001;
  787. input->id.product = 0x0001;
  788. input->id.version = revid;
  789. input->keycodesize = sizeof(kpad->keycode[0]);
  790. input->keycodemax = pdata->keymapsize;
  791. input->keycode = kpad->keycode;
  792. memcpy(kpad->keycode, pdata->keymap,
  793. pdata->keymapsize * input->keycodesize);
  794. kpad->gpimap = pdata->gpimap;
  795. kpad->gpimapsize = pdata->gpimapsize;
  796. /* setup input device */
  797. __set_bit(EV_KEY, input->evbit);
  798. if (pdata->repeat)
  799. __set_bit(EV_REP, input->evbit);
  800. for (i = 0; i < input->keycodemax; i++)
  801. if (kpad->keycode[i] <= KEY_MAX)
  802. __set_bit(kpad->keycode[i], input->keybit);
  803. __clear_bit(KEY_RESERVED, input->keybit);
  804. if (kpad->gpimapsize)
  805. __set_bit(EV_SW, input->evbit);
  806. for (i = 0; i < kpad->gpimapsize; i++)
  807. __set_bit(kpad->gpimap[i].sw_evt, input->swbit);
  808. error = input_register_device(input);
  809. if (error) {
  810. dev_err(&client->dev, "unable to register input device\n");
  811. goto err_free_input;
  812. }
  813. error = request_threaded_irq(client->irq, NULL, adp5589_irq,
  814. IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  815. client->dev.driver->name, kpad);
  816. if (error) {
  817. dev_err(&client->dev, "irq %d busy?\n", client->irq);
  818. goto err_unreg_dev;
  819. }
  820. device_init_wakeup(&client->dev, 1);
  821. return 0;
  822. err_unreg_dev:
  823. input_unregister_device(input);
  824. input = NULL;
  825. err_free_input:
  826. input_free_device(input);
  827. return error;
  828. }
  829. static void adp5589_keypad_remove(struct adp5589_kpad *kpad)
  830. {
  831. if (kpad->input) {
  832. free_irq(kpad->client->irq, kpad);
  833. input_unregister_device(kpad->input);
  834. }
  835. }
  836. static int adp5589_probe(struct i2c_client *client,
  837. const struct i2c_device_id *id)
  838. {
  839. struct adp5589_kpad *kpad;
  840. const struct adp5589_kpad_platform_data *pdata =
  841. dev_get_platdata(&client->dev);
  842. unsigned int revid;
  843. int error, ret;
  844. if (!i2c_check_functionality(client->adapter,
  845. I2C_FUNC_SMBUS_BYTE_DATA)) {
  846. dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
  847. return -EIO;
  848. }
  849. if (!pdata) {
  850. dev_err(&client->dev, "no platform data?\n");
  851. return -EINVAL;
  852. }
  853. kpad = kzalloc(sizeof(*kpad), GFP_KERNEL);
  854. if (!kpad)
  855. return -ENOMEM;
  856. kpad->client = client;
  857. switch (id->driver_data) {
  858. case ADP5585_02:
  859. kpad->support_row5 = true;
  860. fallthrough;
  861. case ADP5585_01:
  862. kpad->is_adp5585 = true;
  863. kpad->var = &const_adp5585;
  864. break;
  865. case ADP5589:
  866. kpad->support_row5 = true;
  867. kpad->var = &const_adp5589;
  868. break;
  869. }
  870. ret = adp5589_read(client, ADP5589_5_ID);
  871. if (ret < 0) {
  872. error = ret;
  873. goto err_free_mem;
  874. }
  875. revid = (u8) ret & ADP5589_5_DEVICE_ID_MASK;
  876. if (pdata->keymapsize) {
  877. error = adp5589_keypad_add(kpad, revid);
  878. if (error)
  879. goto err_free_mem;
  880. }
  881. error = adp5589_setup(kpad);
  882. if (error)
  883. goto err_keypad_remove;
  884. if (kpad->gpimapsize)
  885. adp5589_report_switch_state(kpad);
  886. error = adp5589_gpio_add(kpad);
  887. if (error)
  888. goto err_keypad_remove;
  889. i2c_set_clientdata(client, kpad);
  890. dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
  891. return 0;
  892. err_keypad_remove:
  893. adp5589_keypad_remove(kpad);
  894. err_free_mem:
  895. kfree(kpad);
  896. return error;
  897. }
  898. static int adp5589_remove(struct i2c_client *client)
  899. {
  900. struct adp5589_kpad *kpad = i2c_get_clientdata(client);
  901. adp5589_write(client, kpad->var->reg(ADP5589_GENERAL_CFG), 0);
  902. adp5589_keypad_remove(kpad);
  903. adp5589_gpio_remove(kpad);
  904. kfree(kpad);
  905. return 0;
  906. }
  907. #ifdef CONFIG_PM_SLEEP
  908. static int adp5589_suspend(struct device *dev)
  909. {
  910. struct adp5589_kpad *kpad = dev_get_drvdata(dev);
  911. struct i2c_client *client = kpad->client;
  912. if (!kpad->input)
  913. return 0;
  914. disable_irq(client->irq);
  915. if (device_may_wakeup(&client->dev))
  916. enable_irq_wake(client->irq);
  917. return 0;
  918. }
  919. static int adp5589_resume(struct device *dev)
  920. {
  921. struct adp5589_kpad *kpad = dev_get_drvdata(dev);
  922. struct i2c_client *client = kpad->client;
  923. if (!kpad->input)
  924. return 0;
  925. if (device_may_wakeup(&client->dev))
  926. disable_irq_wake(client->irq);
  927. enable_irq(client->irq);
  928. return 0;
  929. }
  930. #endif
  931. static SIMPLE_DEV_PM_OPS(adp5589_dev_pm_ops, adp5589_suspend, adp5589_resume);
  932. static const struct i2c_device_id adp5589_id[] = {
  933. {"adp5589-keys", ADP5589},
  934. {"adp5585-keys", ADP5585_01},
  935. {"adp5585-02-keys", ADP5585_02}, /* Adds ROW5 to ADP5585 */
  936. {}
  937. };
  938. MODULE_DEVICE_TABLE(i2c, adp5589_id);
  939. static struct i2c_driver adp5589_driver = {
  940. .driver = {
  941. .name = KBUILD_MODNAME,
  942. .pm = &adp5589_dev_pm_ops,
  943. },
  944. .probe = adp5589_probe,
  945. .remove = adp5589_remove,
  946. .id_table = adp5589_id,
  947. };
  948. module_i2c_driver(adp5589_driver);
  949. MODULE_LICENSE("GPL");
  950. MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
  951. MODULE_DESCRIPTION("ADP5589/ADP5585 Keypad driver");