atmel_mxt_ts.c 29 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252
  1. /*
  2. * Atmel maXTouch Touchscreen driver
  3. *
  4. * Copyright (C) 2010 Samsung Electronics Co.Ltd
  5. * Author: Joonyoung Shim <jy0922.shim@samsung.com>
  6. *
  7. * This program is free software; you can redistribute it and/or modify it
  8. * under the terms of the GNU General Public License as published by the
  9. * Free Software Foundation; either version 2 of the License, or (at your
  10. * option) any later version.
  11. *
  12. */
  13. #include <linux/module.h>
  14. #include <linux/init.h>
  15. #include <linux/delay.h>
  16. #include <linux/firmware.h>
  17. #include <linux/i2c.h>
  18. #include <linux/i2c/atmel_mxt_ts.h>
  19. #include <linux/input/mt.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/slab.h>
  22. /* Version */
  23. #define MXT_VER_20 20
  24. #define MXT_VER_21 21
  25. #define MXT_VER_22 22
  26. /* Slave addresses */
  27. #define MXT_APP_LOW 0x4a
  28. #define MXT_APP_HIGH 0x4b
  29. #define MXT_BOOT_LOW 0x24
  30. #define MXT_BOOT_HIGH 0x25
  31. /* Firmware */
  32. #define MXT_FW_NAME "maxtouch.fw"
  33. /* Registers */
  34. #define MXT_INFO 0x00
  35. #define MXT_FAMILY_ID 0x00
  36. #define MXT_VARIANT_ID 0x01
  37. #define MXT_VERSION 0x02
  38. #define MXT_BUILD 0x03
  39. #define MXT_MATRIX_X_SIZE 0x04
  40. #define MXT_MATRIX_Y_SIZE 0x05
  41. #define MXT_OBJECT_NUM 0x06
  42. #define MXT_OBJECT_START 0x07
  43. #define MXT_OBJECT_SIZE 6
  44. /* Object types */
  45. #define MXT_DEBUG_DIAGNOSTIC_T37 37
  46. #define MXT_GEN_MESSAGE_T5 5
  47. #define MXT_GEN_COMMAND_T6 6
  48. #define MXT_GEN_POWER_T7 7
  49. #define MXT_GEN_ACQUIRE_T8 8
  50. #define MXT_GEN_DATASOURCE_T53 53
  51. #define MXT_TOUCH_MULTI_T9 9
  52. #define MXT_TOUCH_KEYARRAY_T15 15
  53. #define MXT_TOUCH_PROXIMITY_T23 23
  54. #define MXT_TOUCH_PROXKEY_T52 52
  55. #define MXT_PROCI_GRIPFACE_T20 20
  56. #define MXT_PROCG_NOISE_T22 22
  57. #define MXT_PROCI_ONETOUCH_T24 24
  58. #define MXT_PROCI_TWOTOUCH_T27 27
  59. #define MXT_PROCI_GRIP_T40 40
  60. #define MXT_PROCI_PALM_T41 41
  61. #define MXT_PROCI_TOUCHSUPPRESSION_T42 42
  62. #define MXT_PROCI_STYLUS_T47 47
  63. #define MXT_PROCG_NOISESUPPRESSION_T48 48
  64. #define MXT_SPT_COMMSCONFIG_T18 18
  65. #define MXT_SPT_GPIOPWM_T19 19
  66. #define MXT_SPT_SELFTEST_T25 25
  67. #define MXT_SPT_CTECONFIG_T28 28
  68. #define MXT_SPT_USERDATA_T38 38
  69. #define MXT_SPT_DIGITIZER_T43 43
  70. #define MXT_SPT_MESSAGECOUNT_T44 44
  71. #define MXT_SPT_CTECONFIG_T46 46
  72. /* MXT_GEN_COMMAND_T6 field */
  73. #define MXT_COMMAND_RESET 0
  74. #define MXT_COMMAND_BACKUPNV 1
  75. #define MXT_COMMAND_CALIBRATE 2
  76. #define MXT_COMMAND_REPORTALL 3
  77. #define MXT_COMMAND_DIAGNOSTIC 5
  78. /* MXT_GEN_POWER_T7 field */
  79. #define MXT_POWER_IDLEACQINT 0
  80. #define MXT_POWER_ACTVACQINT 1
  81. #define MXT_POWER_ACTV2IDLETO 2
  82. /* MXT_GEN_ACQUIRE_T8 field */
  83. #define MXT_ACQUIRE_CHRGTIME 0
  84. #define MXT_ACQUIRE_TCHDRIFT 2
  85. #define MXT_ACQUIRE_DRIFTST 3
  86. #define MXT_ACQUIRE_TCHAUTOCAL 4
  87. #define MXT_ACQUIRE_SYNC 5
  88. #define MXT_ACQUIRE_ATCHCALST 6
  89. #define MXT_ACQUIRE_ATCHCALSTHR 7
  90. /* MXT_TOUCH_MULTI_T9 field */
  91. #define MXT_TOUCH_CTRL 0
  92. #define MXT_TOUCH_XORIGIN 1
  93. #define MXT_TOUCH_YORIGIN 2
  94. #define MXT_TOUCH_XSIZE 3
  95. #define MXT_TOUCH_YSIZE 4
  96. #define MXT_TOUCH_BLEN 6
  97. #define MXT_TOUCH_TCHTHR 7
  98. #define MXT_TOUCH_TCHDI 8
  99. #define MXT_TOUCH_ORIENT 9
  100. #define MXT_TOUCH_MOVHYSTI 11
  101. #define MXT_TOUCH_MOVHYSTN 12
  102. #define MXT_TOUCH_NUMTOUCH 14
  103. #define MXT_TOUCH_MRGHYST 15
  104. #define MXT_TOUCH_MRGTHR 16
  105. #define MXT_TOUCH_AMPHYST 17
  106. #define MXT_TOUCH_XRANGE_LSB 18
  107. #define MXT_TOUCH_XRANGE_MSB 19
  108. #define MXT_TOUCH_YRANGE_LSB 20
  109. #define MXT_TOUCH_YRANGE_MSB 21
  110. #define MXT_TOUCH_XLOCLIP 22
  111. #define MXT_TOUCH_XHICLIP 23
  112. #define MXT_TOUCH_YLOCLIP 24
  113. #define MXT_TOUCH_YHICLIP 25
  114. #define MXT_TOUCH_XEDGECTRL 26
  115. #define MXT_TOUCH_XEDGEDIST 27
  116. #define MXT_TOUCH_YEDGECTRL 28
  117. #define MXT_TOUCH_YEDGEDIST 29
  118. #define MXT_TOUCH_JUMPLIMIT 30
  119. /* MXT_PROCI_GRIPFACE_T20 field */
  120. #define MXT_GRIPFACE_CTRL 0
  121. #define MXT_GRIPFACE_XLOGRIP 1
  122. #define MXT_GRIPFACE_XHIGRIP 2
  123. #define MXT_GRIPFACE_YLOGRIP 3
  124. #define MXT_GRIPFACE_YHIGRIP 4
  125. #define MXT_GRIPFACE_MAXTCHS 5
  126. #define MXT_GRIPFACE_SZTHR1 7
  127. #define MXT_GRIPFACE_SZTHR2 8
  128. #define MXT_GRIPFACE_SHPTHR1 9
  129. #define MXT_GRIPFACE_SHPTHR2 10
  130. #define MXT_GRIPFACE_SUPEXTTO 11
  131. /* MXT_PROCI_NOISE field */
  132. #define MXT_NOISE_CTRL 0
  133. #define MXT_NOISE_OUTFLEN 1
  134. #define MXT_NOISE_GCAFUL_LSB 3
  135. #define MXT_NOISE_GCAFUL_MSB 4
  136. #define MXT_NOISE_GCAFLL_LSB 5
  137. #define MXT_NOISE_GCAFLL_MSB 6
  138. #define MXT_NOISE_ACTVGCAFVALID 7
  139. #define MXT_NOISE_NOISETHR 8
  140. #define MXT_NOISE_FREQHOPSCALE 10
  141. #define MXT_NOISE_FREQ0 11
  142. #define MXT_NOISE_FREQ1 12
  143. #define MXT_NOISE_FREQ2 13
  144. #define MXT_NOISE_FREQ3 14
  145. #define MXT_NOISE_FREQ4 15
  146. #define MXT_NOISE_IDLEGCAFVALID 16
  147. /* MXT_SPT_COMMSCONFIG_T18 */
  148. #define MXT_COMMS_CTRL 0
  149. #define MXT_COMMS_CMD 1
  150. /* MXT_SPT_CTECONFIG_T28 field */
  151. #define MXT_CTE_CTRL 0
  152. #define MXT_CTE_CMD 1
  153. #define MXT_CTE_MODE 2
  154. #define MXT_CTE_IDLEGCAFDEPTH 3
  155. #define MXT_CTE_ACTVGCAFDEPTH 4
  156. #define MXT_CTE_VOLTAGE 5
  157. #define MXT_VOLTAGE_DEFAULT 2700000
  158. #define MXT_VOLTAGE_STEP 10000
  159. /* Define for MXT_GEN_COMMAND_T6 */
  160. #define MXT_BOOT_VALUE 0xa5
  161. #define MXT_BACKUP_VALUE 0x55
  162. #define MXT_BACKUP_TIME 25 /* msec */
  163. #define MXT_RESET_TIME 65 /* msec */
  164. #define MXT_FWRESET_TIME 175 /* msec */
  165. /* Command to unlock bootloader */
  166. #define MXT_UNLOCK_CMD_MSB 0xaa
  167. #define MXT_UNLOCK_CMD_LSB 0xdc
  168. /* Bootloader mode status */
  169. #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */
  170. #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */
  171. #define MXT_FRAME_CRC_CHECK 0x02
  172. #define MXT_FRAME_CRC_FAIL 0x03
  173. #define MXT_FRAME_CRC_PASS 0x04
  174. #define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */
  175. #define MXT_BOOT_STATUS_MASK 0x3f
  176. /* Touch status */
  177. #define MXT_UNGRIP (1 << 0)
  178. #define MXT_SUPPRESS (1 << 1)
  179. #define MXT_AMP (1 << 2)
  180. #define MXT_VECTOR (1 << 3)
  181. #define MXT_MOVE (1 << 4)
  182. #define MXT_RELEASE (1 << 5)
  183. #define MXT_PRESS (1 << 6)
  184. #define MXT_DETECT (1 << 7)
  185. /* Touch orient bits */
  186. #define MXT_XY_SWITCH (1 << 0)
  187. #define MXT_X_INVERT (1 << 1)
  188. #define MXT_Y_INVERT (1 << 2)
  189. /* Touchscreen absolute values */
  190. #define MXT_MAX_AREA 0xff
  191. #define MXT_MAX_FINGER 10
  192. struct mxt_info {
  193. u8 family_id;
  194. u8 variant_id;
  195. u8 version;
  196. u8 build;
  197. u8 matrix_xsize;
  198. u8 matrix_ysize;
  199. u8 object_num;
  200. };
  201. struct mxt_object {
  202. u8 type;
  203. u16 start_address;
  204. u8 size;
  205. u8 instances;
  206. u8 num_report_ids;
  207. /* to map object and message */
  208. u8 max_reportid;
  209. };
  210. struct mxt_message {
  211. u8 reportid;
  212. u8 message[7];
  213. };
  214. /* Each client has this additional data */
  215. struct mxt_data {
  216. struct i2c_client *client;
  217. struct input_dev *input_dev;
  218. char phys[64]; /* device physical location */
  219. const struct mxt_platform_data *pdata;
  220. struct mxt_object *object_table;
  221. struct mxt_info info;
  222. unsigned int irq;
  223. unsigned int max_x;
  224. unsigned int max_y;
  225. };
  226. static bool mxt_object_readable(unsigned int type)
  227. {
  228. switch (type) {
  229. case MXT_GEN_COMMAND_T6:
  230. case MXT_GEN_POWER_T7:
  231. case MXT_GEN_ACQUIRE_T8:
  232. case MXT_GEN_DATASOURCE_T53:
  233. case MXT_TOUCH_MULTI_T9:
  234. case MXT_TOUCH_KEYARRAY_T15:
  235. case MXT_TOUCH_PROXIMITY_T23:
  236. case MXT_TOUCH_PROXKEY_T52:
  237. case MXT_PROCI_GRIPFACE_T20:
  238. case MXT_PROCG_NOISE_T22:
  239. case MXT_PROCI_ONETOUCH_T24:
  240. case MXT_PROCI_TWOTOUCH_T27:
  241. case MXT_PROCI_GRIP_T40:
  242. case MXT_PROCI_PALM_T41:
  243. case MXT_PROCI_TOUCHSUPPRESSION_T42:
  244. case MXT_PROCI_STYLUS_T47:
  245. case MXT_PROCG_NOISESUPPRESSION_T48:
  246. case MXT_SPT_COMMSCONFIG_T18:
  247. case MXT_SPT_GPIOPWM_T19:
  248. case MXT_SPT_SELFTEST_T25:
  249. case MXT_SPT_CTECONFIG_T28:
  250. case MXT_SPT_USERDATA_T38:
  251. case MXT_SPT_DIGITIZER_T43:
  252. case MXT_SPT_CTECONFIG_T46:
  253. return true;
  254. default:
  255. return false;
  256. }
  257. }
  258. static bool mxt_object_writable(unsigned int type)
  259. {
  260. switch (type) {
  261. case MXT_GEN_COMMAND_T6:
  262. case MXT_GEN_POWER_T7:
  263. case MXT_GEN_ACQUIRE_T8:
  264. case MXT_TOUCH_MULTI_T9:
  265. case MXT_TOUCH_KEYARRAY_T15:
  266. case MXT_TOUCH_PROXIMITY_T23:
  267. case MXT_TOUCH_PROXKEY_T52:
  268. case MXT_PROCI_GRIPFACE_T20:
  269. case MXT_PROCG_NOISE_T22:
  270. case MXT_PROCI_ONETOUCH_T24:
  271. case MXT_PROCI_TWOTOUCH_T27:
  272. case MXT_PROCI_GRIP_T40:
  273. case MXT_PROCI_PALM_T41:
  274. case MXT_PROCI_TOUCHSUPPRESSION_T42:
  275. case MXT_PROCI_STYLUS_T47:
  276. case MXT_PROCG_NOISESUPPRESSION_T48:
  277. case MXT_SPT_COMMSCONFIG_T18:
  278. case MXT_SPT_GPIOPWM_T19:
  279. case MXT_SPT_SELFTEST_T25:
  280. case MXT_SPT_CTECONFIG_T28:
  281. case MXT_SPT_DIGITIZER_T43:
  282. case MXT_SPT_CTECONFIG_T46:
  283. return true;
  284. default:
  285. return false;
  286. }
  287. }
  288. static void mxt_dump_message(struct device *dev,
  289. struct mxt_message *message)
  290. {
  291. dev_dbg(dev, "reportid: %u\tmessage: %02x %02x %02x %02x %02x %02x %02x\n",
  292. message->reportid, message->message[0], message->message[1],
  293. message->message[2], message->message[3], message->message[4],
  294. message->message[5], message->message[6]);
  295. }
  296. static int mxt_check_bootloader(struct i2c_client *client,
  297. unsigned int state)
  298. {
  299. u8 val;
  300. recheck:
  301. if (i2c_master_recv(client, &val, 1) != 1) {
  302. dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
  303. return -EIO;
  304. }
  305. switch (state) {
  306. case MXT_WAITING_BOOTLOAD_CMD:
  307. case MXT_WAITING_FRAME_DATA:
  308. val &= ~MXT_BOOT_STATUS_MASK;
  309. break;
  310. case MXT_FRAME_CRC_PASS:
  311. if (val == MXT_FRAME_CRC_CHECK)
  312. goto recheck;
  313. break;
  314. default:
  315. return -EINVAL;
  316. }
  317. if (val != state) {
  318. dev_err(&client->dev, "Unvalid bootloader mode state\n");
  319. return -EINVAL;
  320. }
  321. return 0;
  322. }
  323. static int mxt_unlock_bootloader(struct i2c_client *client)
  324. {
  325. u8 buf[2];
  326. buf[0] = MXT_UNLOCK_CMD_LSB;
  327. buf[1] = MXT_UNLOCK_CMD_MSB;
  328. if (i2c_master_send(client, buf, 2) != 2) {
  329. dev_err(&client->dev, "%s: i2c send failed\n", __func__);
  330. return -EIO;
  331. }
  332. return 0;
  333. }
  334. static int mxt_fw_write(struct i2c_client *client,
  335. const u8 *data, unsigned int frame_size)
  336. {
  337. if (i2c_master_send(client, data, frame_size) != frame_size) {
  338. dev_err(&client->dev, "%s: i2c send failed\n", __func__);
  339. return -EIO;
  340. }
  341. return 0;
  342. }
  343. static int __mxt_read_reg(struct i2c_client *client,
  344. u16 reg, u16 len, void *val)
  345. {
  346. struct i2c_msg xfer[2];
  347. u8 buf[2];
  348. int ret;
  349. buf[0] = reg & 0xff;
  350. buf[1] = (reg >> 8) & 0xff;
  351. /* Write register */
  352. xfer[0].addr = client->addr;
  353. xfer[0].flags = 0;
  354. xfer[0].len = 2;
  355. xfer[0].buf = buf;
  356. /* Read data */
  357. xfer[1].addr = client->addr;
  358. xfer[1].flags = I2C_M_RD;
  359. xfer[1].len = len;
  360. xfer[1].buf = val;
  361. ret = i2c_transfer(client->adapter, xfer, 2);
  362. if (ret == 2) {
  363. ret = 0;
  364. } else {
  365. if (ret >= 0)
  366. ret = -EIO;
  367. dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
  368. __func__, ret);
  369. }
  370. return ret;
  371. }
  372. static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
  373. {
  374. return __mxt_read_reg(client, reg, 1, val);
  375. }
  376. static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
  377. const void *val)
  378. {
  379. u8 *buf;
  380. size_t count;
  381. int ret;
  382. count = len + 2;
  383. buf = kmalloc(count, GFP_KERNEL);
  384. if (!buf)
  385. return -ENOMEM;
  386. buf[0] = reg & 0xff;
  387. buf[1] = (reg >> 8) & 0xff;
  388. memcpy(&buf[2], val, len);
  389. ret = i2c_master_send(client, buf, count);
  390. if (ret == count) {
  391. ret = 0;
  392. } else {
  393. if (ret >= 0)
  394. ret = -EIO;
  395. dev_err(&client->dev, "%s: i2c send failed (%d)\n",
  396. __func__, ret);
  397. }
  398. kfree(buf);
  399. return ret;
  400. }
  401. static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
  402. {
  403. return __mxt_write_reg(client, reg, 1, &val);
  404. }
  405. static int mxt_read_object_table(struct i2c_client *client,
  406. u16 reg, u8 *object_buf)
  407. {
  408. return __mxt_read_reg(client, reg, MXT_OBJECT_SIZE,
  409. object_buf);
  410. }
  411. static struct mxt_object *
  412. mxt_get_object(struct mxt_data *data, u8 type)
  413. {
  414. struct mxt_object *object;
  415. int i;
  416. for (i = 0; i < data->info.object_num; i++) {
  417. object = data->object_table + i;
  418. if (object->type == type)
  419. return object;
  420. }
  421. dev_err(&data->client->dev, "Invalid object type\n");
  422. return NULL;
  423. }
  424. static int mxt_read_message(struct mxt_data *data,
  425. struct mxt_message *message)
  426. {
  427. struct mxt_object *object;
  428. u16 reg;
  429. object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
  430. if (!object)
  431. return -EINVAL;
  432. reg = object->start_address;
  433. return __mxt_read_reg(data->client, reg,
  434. sizeof(struct mxt_message), message);
  435. }
  436. static int mxt_write_object(struct mxt_data *data,
  437. u8 type, u8 offset, u8 val)
  438. {
  439. struct mxt_object *object;
  440. u16 reg;
  441. object = mxt_get_object(data, type);
  442. if (!object || offset >= object->size + 1)
  443. return -EINVAL;
  444. reg = object->start_address;
  445. return mxt_write_reg(data->client, reg + offset, val);
  446. }
  447. static void mxt_input_touchevent(struct mxt_data *data,
  448. struct mxt_message *message, int id)
  449. {
  450. struct device *dev = &data->client->dev;
  451. u8 status = message->message[0];
  452. struct input_dev *input_dev = data->input_dev;
  453. int x;
  454. int y;
  455. int area;
  456. int pressure;
  457. x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
  458. y = (message->message[2] << 4) | ((message->message[3] & 0xf));
  459. if (data->max_x < 1024)
  460. x = x >> 2;
  461. if (data->max_y < 1024)
  462. y = y >> 2;
  463. area = message->message[4];
  464. pressure = message->message[5];
  465. dev_dbg(dev,
  466. "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
  467. id,
  468. (status & MXT_DETECT) ? 'D' : '.',
  469. (status & MXT_PRESS) ? 'P' : '.',
  470. (status & MXT_RELEASE) ? 'R' : '.',
  471. (status & MXT_MOVE) ? 'M' : '.',
  472. (status & MXT_VECTOR) ? 'V' : '.',
  473. (status & MXT_AMP) ? 'A' : '.',
  474. (status & MXT_SUPPRESS) ? 'S' : '.',
  475. (status & MXT_UNGRIP) ? 'U' : '.',
  476. x, y, area, pressure);
  477. input_mt_slot(input_dev, id);
  478. input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
  479. status & MXT_DETECT);
  480. if (status & MXT_DETECT) {
  481. input_report_abs(input_dev, ABS_MT_POSITION_X, x);
  482. input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
  483. input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
  484. input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
  485. }
  486. input_mt_report_pointer_emulation(input_dev, false);
  487. input_sync(input_dev);
  488. }
  489. static irqreturn_t mxt_interrupt(int irq, void *dev_id)
  490. {
  491. struct mxt_data *data = dev_id;
  492. struct mxt_message message;
  493. struct mxt_object *object;
  494. struct device *dev = &data->client->dev;
  495. int id;
  496. u8 reportid;
  497. u8 max_reportid;
  498. u8 min_reportid;
  499. do {
  500. if (mxt_read_message(data, &message)) {
  501. dev_err(dev, "Failed to read message\n");
  502. goto end;
  503. }
  504. reportid = message.reportid;
  505. /* whether reportid is thing of MXT_TOUCH_MULTI_T9 */
  506. object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
  507. if (!object)
  508. goto end;
  509. max_reportid = object->max_reportid;
  510. min_reportid = max_reportid - object->num_report_ids + 1;
  511. id = reportid - min_reportid;
  512. if (reportid >= min_reportid && reportid <= max_reportid)
  513. mxt_input_touchevent(data, &message, id);
  514. else
  515. mxt_dump_message(dev, &message);
  516. } while (reportid != 0xff);
  517. end:
  518. return IRQ_HANDLED;
  519. }
  520. static int mxt_check_reg_init(struct mxt_data *data)
  521. {
  522. const struct mxt_platform_data *pdata = data->pdata;
  523. struct mxt_object *object;
  524. struct device *dev = &data->client->dev;
  525. int index = 0;
  526. int i, size;
  527. int ret;
  528. if (!pdata->config) {
  529. dev_dbg(dev, "No cfg data defined, skipping reg init\n");
  530. return 0;
  531. }
  532. for (i = 0; i < data->info.object_num; i++) {
  533. object = data->object_table + i;
  534. if (!mxt_object_writable(object->type))
  535. continue;
  536. size = (object->size + 1) * (object->instances + 1);
  537. if (index + size > pdata->config_length) {
  538. dev_err(dev, "Not enough config data!\n");
  539. return -EINVAL;
  540. }
  541. ret = __mxt_write_reg(data->client, object->start_address,
  542. size, &pdata->config[index]);
  543. if (ret)
  544. return ret;
  545. index += size;
  546. }
  547. return 0;
  548. }
  549. static int mxt_make_highchg(struct mxt_data *data)
  550. {
  551. struct device *dev = &data->client->dev;
  552. struct mxt_message message;
  553. int count = 10;
  554. int error;
  555. /* Read dummy message to make high CHG pin */
  556. do {
  557. error = mxt_read_message(data, &message);
  558. if (error)
  559. return error;
  560. } while (message.reportid != 0xff && --count);
  561. if (!count) {
  562. dev_err(dev, "CHG pin isn't cleared\n");
  563. return -EBUSY;
  564. }
  565. return 0;
  566. }
  567. static void mxt_handle_pdata(struct mxt_data *data)
  568. {
  569. const struct mxt_platform_data *pdata = data->pdata;
  570. u8 voltage;
  571. /* Set touchscreen lines */
  572. mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_XSIZE,
  573. pdata->x_line);
  574. mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_YSIZE,
  575. pdata->y_line);
  576. /* Set touchscreen orient */
  577. mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT,
  578. pdata->orient);
  579. /* Set touchscreen burst length */
  580. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  581. MXT_TOUCH_BLEN, pdata->blen);
  582. /* Set touchscreen threshold */
  583. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  584. MXT_TOUCH_TCHTHR, pdata->threshold);
  585. /* Set touchscreen resolution */
  586. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  587. MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
  588. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  589. MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
  590. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  591. MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
  592. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  593. MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
  594. /* Set touchscreen voltage */
  595. if (pdata->voltage) {
  596. if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
  597. voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
  598. MXT_VOLTAGE_STEP;
  599. voltage = 0xff - voltage + 1;
  600. } else
  601. voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
  602. MXT_VOLTAGE_STEP;
  603. mxt_write_object(data, MXT_SPT_CTECONFIG_T28,
  604. MXT_CTE_VOLTAGE, voltage);
  605. }
  606. }
  607. static int mxt_get_info(struct mxt_data *data)
  608. {
  609. struct i2c_client *client = data->client;
  610. struct mxt_info *info = &data->info;
  611. int error;
  612. /* Read 7-byte info block starting at address 0 */
  613. error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
  614. if (error)
  615. return error;
  616. return 0;
  617. }
  618. static int mxt_get_object_table(struct mxt_data *data)
  619. {
  620. int error;
  621. int i;
  622. u16 reg;
  623. u8 reportid = 0;
  624. u8 buf[MXT_OBJECT_SIZE];
  625. for (i = 0; i < data->info.object_num; i++) {
  626. struct mxt_object *object = data->object_table + i;
  627. reg = MXT_OBJECT_START + MXT_OBJECT_SIZE * i;
  628. error = mxt_read_object_table(data->client, reg, buf);
  629. if (error)
  630. return error;
  631. object->type = buf[0];
  632. object->start_address = (buf[2] << 8) | buf[1];
  633. object->size = buf[3];
  634. object->instances = buf[4];
  635. object->num_report_ids = buf[5];
  636. if (object->num_report_ids) {
  637. reportid += object->num_report_ids *
  638. (object->instances + 1);
  639. object->max_reportid = reportid;
  640. }
  641. }
  642. return 0;
  643. }
  644. static void mxt_free_object_table(struct mxt_data *data)
  645. {
  646. kfree(data->object_table);
  647. data->object_table = NULL;
  648. }
  649. static int mxt_initialize(struct mxt_data *data)
  650. {
  651. struct i2c_client *client = data->client;
  652. struct mxt_info *info = &data->info;
  653. int error;
  654. u8 val;
  655. error = mxt_get_info(data);
  656. if (error)
  657. return error;
  658. data->object_table = kcalloc(info->object_num,
  659. sizeof(struct mxt_object),
  660. GFP_KERNEL);
  661. if (!data->object_table) {
  662. dev_err(&client->dev, "Failed to allocate memory\n");
  663. return -ENOMEM;
  664. }
  665. /* Get object table information */
  666. error = mxt_get_object_table(data);
  667. if (error)
  668. goto err_free_object_table;
  669. /* Check register init values */
  670. error = mxt_check_reg_init(data);
  671. if (error)
  672. goto err_free_object_table;
  673. mxt_handle_pdata(data);
  674. /* Backup to memory */
  675. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  676. MXT_COMMAND_BACKUPNV,
  677. MXT_BACKUP_VALUE);
  678. msleep(MXT_BACKUP_TIME);
  679. /* Soft reset */
  680. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  681. MXT_COMMAND_RESET, 1);
  682. msleep(MXT_RESET_TIME);
  683. /* Update matrix size at info struct */
  684. error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
  685. if (error)
  686. goto err_free_object_table;
  687. info->matrix_xsize = val;
  688. error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
  689. if (error)
  690. goto err_free_object_table;
  691. info->matrix_ysize = val;
  692. dev_info(&client->dev,
  693. "Family ID: %u Variant ID: %u Major.Minor.Build: %u.%u.%02X\n",
  694. info->family_id, info->variant_id, info->version >> 4,
  695. info->version & 0xf, info->build);
  696. dev_info(&client->dev,
  697. "Matrix X Size: %u Matrix Y Size: %u Object Num: %u\n",
  698. info->matrix_xsize, info->matrix_ysize,
  699. info->object_num);
  700. return 0;
  701. err_free_object_table:
  702. mxt_free_object_table(data);
  703. return error;
  704. }
  705. static void mxt_calc_resolution(struct mxt_data *data)
  706. {
  707. unsigned int max_x = data->pdata->x_size - 1;
  708. unsigned int max_y = data->pdata->y_size - 1;
  709. if (data->pdata->orient & MXT_XY_SWITCH) {
  710. data->max_x = max_y;
  711. data->max_y = max_x;
  712. } else {
  713. data->max_x = max_x;
  714. data->max_y = max_y;
  715. }
  716. }
  717. /* Firmware Version is returned as Major.Minor.Build */
  718. static ssize_t mxt_fw_version_show(struct device *dev,
  719. struct device_attribute *attr, char *buf)
  720. {
  721. struct mxt_data *data = dev_get_drvdata(dev);
  722. struct mxt_info *info = &data->info;
  723. return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
  724. info->version >> 4, info->version & 0xf, info->build);
  725. }
  726. /* Hardware Version is returned as FamilyID.VariantID */
  727. static ssize_t mxt_hw_version_show(struct device *dev,
  728. struct device_attribute *attr, char *buf)
  729. {
  730. struct mxt_data *data = dev_get_drvdata(dev);
  731. struct mxt_info *info = &data->info;
  732. return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
  733. info->family_id, info->variant_id);
  734. }
  735. static ssize_t mxt_show_instance(char *buf, int count,
  736. struct mxt_object *object, int instance,
  737. const u8 *val)
  738. {
  739. int i;
  740. if (object->instances > 0)
  741. count += scnprintf(buf + count, PAGE_SIZE - count,
  742. "Instance %u\n", instance);
  743. for (i = 0; i < object->size + 1; i++)
  744. count += scnprintf(buf + count, PAGE_SIZE - count,
  745. "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
  746. count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
  747. return count;
  748. }
  749. static ssize_t mxt_object_show(struct device *dev,
  750. struct device_attribute *attr, char *buf)
  751. {
  752. struct mxt_data *data = dev_get_drvdata(dev);
  753. struct mxt_object *object;
  754. int count = 0;
  755. int i, j;
  756. int error;
  757. u8 *obuf;
  758. /* Pre-allocate buffer large enough to hold max sized object. */
  759. obuf = kmalloc(256, GFP_KERNEL);
  760. if (!obuf)
  761. return -ENOMEM;
  762. error = 0;
  763. for (i = 0; i < data->info.object_num; i++) {
  764. object = data->object_table + i;
  765. if (!mxt_object_readable(object->type))
  766. continue;
  767. count += scnprintf(buf + count, PAGE_SIZE - count,
  768. "T%u:\n", object->type);
  769. for (j = 0; j < object->instances + 1; j++) {
  770. u16 size = object->size + 1;
  771. u16 addr = object->start_address + j * size;
  772. error = __mxt_read_reg(data->client, addr, size, obuf);
  773. if (error)
  774. goto done;
  775. count = mxt_show_instance(buf, count, object, j, obuf);
  776. }
  777. }
  778. done:
  779. kfree(obuf);
  780. return error ?: count;
  781. }
  782. static int mxt_load_fw(struct device *dev, const char *fn)
  783. {
  784. struct mxt_data *data = dev_get_drvdata(dev);
  785. struct i2c_client *client = data->client;
  786. const struct firmware *fw = NULL;
  787. unsigned int frame_size;
  788. unsigned int pos = 0;
  789. int ret;
  790. ret = request_firmware(&fw, fn, dev);
  791. if (ret) {
  792. dev_err(dev, "Unable to open firmware %s\n", fn);
  793. return ret;
  794. }
  795. /* Change to the bootloader mode */
  796. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  797. MXT_COMMAND_RESET, MXT_BOOT_VALUE);
  798. msleep(MXT_RESET_TIME);
  799. /* Change to slave address of bootloader */
  800. if (client->addr == MXT_APP_LOW)
  801. client->addr = MXT_BOOT_LOW;
  802. else
  803. client->addr = MXT_BOOT_HIGH;
  804. ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD);
  805. if (ret)
  806. goto out;
  807. /* Unlock bootloader */
  808. mxt_unlock_bootloader(client);
  809. while (pos < fw->size) {
  810. ret = mxt_check_bootloader(client,
  811. MXT_WAITING_FRAME_DATA);
  812. if (ret)
  813. goto out;
  814. frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
  815. /* We should add 2 at frame size as the the firmware data is not
  816. * included the CRC bytes.
  817. */
  818. frame_size += 2;
  819. /* Write one frame to device */
  820. mxt_fw_write(client, fw->data + pos, frame_size);
  821. ret = mxt_check_bootloader(client,
  822. MXT_FRAME_CRC_PASS);
  823. if (ret)
  824. goto out;
  825. pos += frame_size;
  826. dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
  827. }
  828. out:
  829. release_firmware(fw);
  830. /* Change to slave address of application */
  831. if (client->addr == MXT_BOOT_LOW)
  832. client->addr = MXT_APP_LOW;
  833. else
  834. client->addr = MXT_APP_HIGH;
  835. return ret;
  836. }
  837. static ssize_t mxt_update_fw_store(struct device *dev,
  838. struct device_attribute *attr,
  839. const char *buf, size_t count)
  840. {
  841. struct mxt_data *data = dev_get_drvdata(dev);
  842. int error;
  843. disable_irq(data->irq);
  844. error = mxt_load_fw(dev, MXT_FW_NAME);
  845. if (error) {
  846. dev_err(dev, "The firmware update failed(%d)\n", error);
  847. count = error;
  848. } else {
  849. dev_dbg(dev, "The firmware update succeeded\n");
  850. /* Wait for reset */
  851. msleep(MXT_FWRESET_TIME);
  852. mxt_free_object_table(data);
  853. mxt_initialize(data);
  854. }
  855. enable_irq(data->irq);
  856. error = mxt_make_highchg(data);
  857. if (error)
  858. return error;
  859. return count;
  860. }
  861. static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
  862. static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
  863. static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
  864. static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
  865. static struct attribute *mxt_attrs[] = {
  866. &dev_attr_fw_version.attr,
  867. &dev_attr_hw_version.attr,
  868. &dev_attr_object.attr,
  869. &dev_attr_update_fw.attr,
  870. NULL
  871. };
  872. static const struct attribute_group mxt_attr_group = {
  873. .attrs = mxt_attrs,
  874. };
  875. static void mxt_start(struct mxt_data *data)
  876. {
  877. /* Touch enable */
  878. mxt_write_object(data,
  879. MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
  880. }
  881. static void mxt_stop(struct mxt_data *data)
  882. {
  883. /* Touch disable */
  884. mxt_write_object(data,
  885. MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
  886. }
  887. static int mxt_input_open(struct input_dev *dev)
  888. {
  889. struct mxt_data *data = input_get_drvdata(dev);
  890. mxt_start(data);
  891. return 0;
  892. }
  893. static void mxt_input_close(struct input_dev *dev)
  894. {
  895. struct mxt_data *data = input_get_drvdata(dev);
  896. mxt_stop(data);
  897. }
  898. static int __devinit mxt_probe(struct i2c_client *client,
  899. const struct i2c_device_id *id)
  900. {
  901. const struct mxt_platform_data *pdata = client->dev.platform_data;
  902. struct mxt_data *data;
  903. struct input_dev *input_dev;
  904. int error;
  905. if (!pdata)
  906. return -EINVAL;
  907. data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
  908. input_dev = input_allocate_device();
  909. if (!data || !input_dev) {
  910. dev_err(&client->dev, "Failed to allocate memory\n");
  911. error = -ENOMEM;
  912. goto err_free_mem;
  913. }
  914. input_dev->name = "Atmel maXTouch Touchscreen";
  915. snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
  916. client->adapter->nr, client->addr);
  917. input_dev->phys = data->phys;
  918. input_dev->id.bustype = BUS_I2C;
  919. input_dev->dev.parent = &client->dev;
  920. input_dev->open = mxt_input_open;
  921. input_dev->close = mxt_input_close;
  922. data->client = client;
  923. data->input_dev = input_dev;
  924. data->pdata = pdata;
  925. data->irq = client->irq;
  926. mxt_calc_resolution(data);
  927. __set_bit(EV_ABS, input_dev->evbit);
  928. __set_bit(EV_KEY, input_dev->evbit);
  929. __set_bit(BTN_TOUCH, input_dev->keybit);
  930. /* For single touch */
  931. input_set_abs_params(input_dev, ABS_X,
  932. 0, data->max_x, 0, 0);
  933. input_set_abs_params(input_dev, ABS_Y,
  934. 0, data->max_y, 0, 0);
  935. input_set_abs_params(input_dev, ABS_PRESSURE,
  936. 0, 255, 0, 0);
  937. /* For multi touch */
  938. error = input_mt_init_slots(input_dev, MXT_MAX_FINGER);
  939. if (error)
  940. goto err_free_mem;
  941. input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
  942. 0, MXT_MAX_AREA, 0, 0);
  943. input_set_abs_params(input_dev, ABS_MT_POSITION_X,
  944. 0, data->max_x, 0, 0);
  945. input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
  946. 0, data->max_y, 0, 0);
  947. input_set_abs_params(input_dev, ABS_MT_PRESSURE,
  948. 0, 255, 0, 0);
  949. input_set_drvdata(input_dev, data);
  950. i2c_set_clientdata(client, data);
  951. error = mxt_initialize(data);
  952. if (error)
  953. goto err_free_mem;
  954. error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
  955. pdata->irqflags, client->name, data);
  956. if (error) {
  957. dev_err(&client->dev, "Failed to register interrupt\n");
  958. goto err_free_object;
  959. }
  960. error = mxt_make_highchg(data);
  961. if (error)
  962. goto err_free_irq;
  963. error = input_register_device(input_dev);
  964. if (error)
  965. goto err_free_irq;
  966. error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
  967. if (error)
  968. dev_warn(&client->dev, "error creating sysfs entries.\n");
  969. return 0;
  970. err_free_irq:
  971. free_irq(client->irq, data);
  972. err_free_object:
  973. kfree(data->object_table);
  974. err_free_mem:
  975. input_free_device(input_dev);
  976. kfree(data);
  977. return error;
  978. }
  979. static int __devexit mxt_remove(struct i2c_client *client)
  980. {
  981. struct mxt_data *data = i2c_get_clientdata(client);
  982. sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
  983. free_irq(data->irq, data);
  984. input_unregister_device(data->input_dev);
  985. kfree(data->object_table);
  986. kfree(data);
  987. return 0;
  988. }
  989. #ifdef CONFIG_PM_SLEEP
  990. static int mxt_suspend(struct device *dev)
  991. {
  992. struct i2c_client *client = to_i2c_client(dev);
  993. struct mxt_data *data = i2c_get_clientdata(client);
  994. struct input_dev *input_dev = data->input_dev;
  995. mutex_lock(&input_dev->mutex);
  996. if (input_dev->users)
  997. mxt_stop(data);
  998. mutex_unlock(&input_dev->mutex);
  999. return 0;
  1000. }
  1001. static int mxt_resume(struct device *dev)
  1002. {
  1003. struct i2c_client *client = to_i2c_client(dev);
  1004. struct mxt_data *data = i2c_get_clientdata(client);
  1005. struct input_dev *input_dev = data->input_dev;
  1006. /* Soft reset */
  1007. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  1008. MXT_COMMAND_RESET, 1);
  1009. msleep(MXT_RESET_TIME);
  1010. mutex_lock(&input_dev->mutex);
  1011. if (input_dev->users)
  1012. mxt_start(data);
  1013. mutex_unlock(&input_dev->mutex);
  1014. return 0;
  1015. }
  1016. #endif
  1017. static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
  1018. static const struct i2c_device_id mxt_id[] = {
  1019. { "qt602240_ts", 0 },
  1020. { "atmel_mxt_ts", 0 },
  1021. { "mXT224", 0 },
  1022. { }
  1023. };
  1024. MODULE_DEVICE_TABLE(i2c, mxt_id);
  1025. static struct i2c_driver mxt_driver = {
  1026. .driver = {
  1027. .name = "atmel_mxt_ts",
  1028. .owner = THIS_MODULE,
  1029. .pm = &mxt_pm_ops,
  1030. },
  1031. .probe = mxt_probe,
  1032. .remove = __devexit_p(mxt_remove),
  1033. .id_table = mxt_id,
  1034. };
  1035. module_i2c_driver(mxt_driver);
  1036. /* Module information */
  1037. MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
  1038. MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
  1039. MODULE_LICENSE("GPL");