atmel_mxt_ts.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260
  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. struct mxt_info {
  192. u8 family_id;
  193. u8 variant_id;
  194. u8 version;
  195. u8 build;
  196. u8 matrix_xsize;
  197. u8 matrix_ysize;
  198. u8 object_num;
  199. };
  200. struct mxt_object {
  201. u8 type;
  202. u16 start_address;
  203. u8 size; /* Size of each instance - 1 */
  204. u8 instances; /* Number of instances - 1 */
  205. u8 num_report_ids;
  206. } __packed;
  207. struct mxt_message {
  208. u8 reportid;
  209. u8 message[7];
  210. };
  211. /* Each client has this additional data */
  212. struct mxt_data {
  213. struct i2c_client *client;
  214. struct input_dev *input_dev;
  215. char phys[64]; /* device physical location */
  216. const struct mxt_platform_data *pdata;
  217. struct mxt_object *object_table;
  218. struct mxt_info info;
  219. unsigned int irq;
  220. unsigned int max_x;
  221. unsigned int max_y;
  222. /* Cached parameters from object table */
  223. u8 T9_reportid_min;
  224. u8 T9_reportid_max;
  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 struct mxt_object *
  406. mxt_get_object(struct mxt_data *data, u8 type)
  407. {
  408. struct mxt_object *object;
  409. int i;
  410. for (i = 0; i < data->info.object_num; i++) {
  411. object = data->object_table + i;
  412. if (object->type == type)
  413. return object;
  414. }
  415. dev_err(&data->client->dev, "Invalid object type\n");
  416. return NULL;
  417. }
  418. static int mxt_read_message(struct mxt_data *data,
  419. struct mxt_message *message)
  420. {
  421. struct mxt_object *object;
  422. u16 reg;
  423. object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
  424. if (!object)
  425. return -EINVAL;
  426. reg = object->start_address;
  427. return __mxt_read_reg(data->client, reg,
  428. sizeof(struct mxt_message), message);
  429. }
  430. static int mxt_write_object(struct mxt_data *data,
  431. u8 type, u8 offset, u8 val)
  432. {
  433. struct mxt_object *object;
  434. u16 reg;
  435. object = mxt_get_object(data, type);
  436. if (!object || offset >= object->size + 1)
  437. return -EINVAL;
  438. reg = object->start_address;
  439. return mxt_write_reg(data->client, reg + offset, val);
  440. }
  441. static void mxt_input_touchevent(struct mxt_data *data,
  442. struct mxt_message *message, int id)
  443. {
  444. struct device *dev = &data->client->dev;
  445. u8 status = message->message[0];
  446. struct input_dev *input_dev = data->input_dev;
  447. int x;
  448. int y;
  449. int area;
  450. int pressure;
  451. x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
  452. y = (message->message[2] << 4) | ((message->message[3] & 0xf));
  453. if (data->max_x < 1024)
  454. x = x >> 2;
  455. if (data->max_y < 1024)
  456. y = y >> 2;
  457. area = message->message[4];
  458. pressure = message->message[5];
  459. dev_dbg(dev,
  460. "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
  461. id,
  462. (status & MXT_DETECT) ? 'D' : '.',
  463. (status & MXT_PRESS) ? 'P' : '.',
  464. (status & MXT_RELEASE) ? 'R' : '.',
  465. (status & MXT_MOVE) ? 'M' : '.',
  466. (status & MXT_VECTOR) ? 'V' : '.',
  467. (status & MXT_AMP) ? 'A' : '.',
  468. (status & MXT_SUPPRESS) ? 'S' : '.',
  469. (status & MXT_UNGRIP) ? 'U' : '.',
  470. x, y, area, pressure);
  471. input_mt_slot(input_dev, id);
  472. input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
  473. status & MXT_DETECT);
  474. if (status & MXT_DETECT) {
  475. input_report_abs(input_dev, ABS_MT_POSITION_X, x);
  476. input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
  477. input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
  478. input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
  479. }
  480. input_mt_report_pointer_emulation(input_dev, false);
  481. input_sync(input_dev);
  482. }
  483. static bool mxt_is_T9_message(struct mxt_data *data, struct mxt_message *msg)
  484. {
  485. u8 id = msg->reportid;
  486. return (id >= data->T9_reportid_min && id <= data->T9_reportid_max);
  487. }
  488. static irqreturn_t mxt_interrupt(int irq, void *dev_id)
  489. {
  490. struct mxt_data *data = dev_id;
  491. struct mxt_message message;
  492. struct device *dev = &data->client->dev;
  493. int id;
  494. u8 reportid;
  495. do {
  496. if (mxt_read_message(data, &message)) {
  497. dev_err(dev, "Failed to read message\n");
  498. goto end;
  499. }
  500. reportid = message.reportid;
  501. id = reportid - data->T9_reportid_min;
  502. if (mxt_is_T9_message(data, &message))
  503. mxt_input_touchevent(data, &message, id);
  504. else
  505. mxt_dump_message(dev, &message);
  506. } while (reportid != 0xff);
  507. end:
  508. return IRQ_HANDLED;
  509. }
  510. static int mxt_check_reg_init(struct mxt_data *data)
  511. {
  512. const struct mxt_platform_data *pdata = data->pdata;
  513. struct mxt_object *object;
  514. struct device *dev = &data->client->dev;
  515. int index = 0;
  516. int i, size;
  517. int ret;
  518. if (!pdata->config) {
  519. dev_dbg(dev, "No cfg data defined, skipping reg init\n");
  520. return 0;
  521. }
  522. for (i = 0; i < data->info.object_num; i++) {
  523. object = data->object_table + i;
  524. if (!mxt_object_writable(object->type))
  525. continue;
  526. size = (object->size + 1) * (object->instances + 1);
  527. if (index + size > pdata->config_length) {
  528. dev_err(dev, "Not enough config data!\n");
  529. return -EINVAL;
  530. }
  531. ret = __mxt_write_reg(data->client, object->start_address,
  532. size, &pdata->config[index]);
  533. if (ret)
  534. return ret;
  535. index += size;
  536. }
  537. return 0;
  538. }
  539. static int mxt_make_highchg(struct mxt_data *data)
  540. {
  541. struct device *dev = &data->client->dev;
  542. struct mxt_message message;
  543. int count = 10;
  544. int error;
  545. /* Read dummy message to make high CHG pin */
  546. do {
  547. error = mxt_read_message(data, &message);
  548. if (error)
  549. return error;
  550. } while (message.reportid != 0xff && --count);
  551. if (!count) {
  552. dev_err(dev, "CHG pin isn't cleared\n");
  553. return -EBUSY;
  554. }
  555. return 0;
  556. }
  557. static void mxt_handle_pdata(struct mxt_data *data)
  558. {
  559. const struct mxt_platform_data *pdata = data->pdata;
  560. u8 voltage;
  561. /* Set touchscreen lines */
  562. mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_XSIZE,
  563. pdata->x_line);
  564. mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_YSIZE,
  565. pdata->y_line);
  566. /* Set touchscreen orient */
  567. mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT,
  568. pdata->orient);
  569. /* Set touchscreen burst length */
  570. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  571. MXT_TOUCH_BLEN, pdata->blen);
  572. /* Set touchscreen threshold */
  573. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  574. MXT_TOUCH_TCHTHR, pdata->threshold);
  575. /* Set touchscreen resolution */
  576. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  577. MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
  578. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  579. MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
  580. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  581. MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
  582. mxt_write_object(data, MXT_TOUCH_MULTI_T9,
  583. MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
  584. /* Set touchscreen voltage */
  585. if (pdata->voltage) {
  586. if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
  587. voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
  588. MXT_VOLTAGE_STEP;
  589. voltage = 0xff - voltage + 1;
  590. } else
  591. voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
  592. MXT_VOLTAGE_STEP;
  593. mxt_write_object(data, MXT_SPT_CTECONFIG_T28,
  594. MXT_CTE_VOLTAGE, voltage);
  595. }
  596. }
  597. static int mxt_get_info(struct mxt_data *data)
  598. {
  599. struct i2c_client *client = data->client;
  600. struct mxt_info *info = &data->info;
  601. int error;
  602. /* Read 7-byte info block starting at address 0 */
  603. error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
  604. if (error)
  605. return error;
  606. return 0;
  607. }
  608. static int mxt_get_object_table(struct mxt_data *data)
  609. {
  610. struct i2c_client *client = data->client;
  611. size_t table_size;
  612. int error;
  613. int i;
  614. u8 reportid;
  615. table_size = data->info.object_num * sizeof(struct mxt_object);
  616. error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
  617. data->object_table);
  618. if (error)
  619. return error;
  620. /* Valid Report IDs start counting from 1 */
  621. reportid = 1;
  622. for (i = 0; i < data->info.object_num; i++) {
  623. struct mxt_object *object = data->object_table + i;
  624. u8 min_id, max_id;
  625. le16_to_cpus(&object->start_address);
  626. if (object->num_report_ids) {
  627. min_id = reportid;
  628. reportid += object->num_report_ids *
  629. (object->instances + 1);
  630. max_id = reportid - 1;
  631. } else {
  632. min_id = 0;
  633. max_id = 0;
  634. }
  635. dev_dbg(&data->client->dev,
  636. "Type %2d Start %3d Size %3d Instances %2d ReportIDs %3u : %3u\n",
  637. object->type, object->start_address, object->size + 1,
  638. object->instances + 1, min_id, max_id);
  639. switch (object->type) {
  640. case MXT_TOUCH_MULTI_T9:
  641. data->T9_reportid_min = min_id;
  642. data->T9_reportid_max = max_id;
  643. break;
  644. }
  645. }
  646. return 0;
  647. }
  648. static void mxt_free_object_table(struct mxt_data *data)
  649. {
  650. kfree(data->object_table);
  651. data->object_table = NULL;
  652. data->T9_reportid_min = 0;
  653. data->T9_reportid_max = 0;
  654. }
  655. static int mxt_initialize(struct mxt_data *data)
  656. {
  657. struct i2c_client *client = data->client;
  658. struct mxt_info *info = &data->info;
  659. int error;
  660. u8 val;
  661. error = mxt_get_info(data);
  662. if (error)
  663. return error;
  664. data->object_table = kcalloc(info->object_num,
  665. sizeof(struct mxt_object),
  666. GFP_KERNEL);
  667. if (!data->object_table) {
  668. dev_err(&client->dev, "Failed to allocate memory\n");
  669. return -ENOMEM;
  670. }
  671. /* Get object table information */
  672. error = mxt_get_object_table(data);
  673. if (error)
  674. goto err_free_object_table;
  675. /* Check register init values */
  676. error = mxt_check_reg_init(data);
  677. if (error)
  678. goto err_free_object_table;
  679. mxt_handle_pdata(data);
  680. /* Backup to memory */
  681. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  682. MXT_COMMAND_BACKUPNV,
  683. MXT_BACKUP_VALUE);
  684. msleep(MXT_BACKUP_TIME);
  685. /* Soft reset */
  686. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  687. MXT_COMMAND_RESET, 1);
  688. msleep(MXT_RESET_TIME);
  689. /* Update matrix size at info struct */
  690. error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
  691. if (error)
  692. goto err_free_object_table;
  693. info->matrix_xsize = val;
  694. error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
  695. if (error)
  696. goto err_free_object_table;
  697. info->matrix_ysize = val;
  698. dev_info(&client->dev,
  699. "Family ID: %u Variant ID: %u Major.Minor.Build: %u.%u.%02X\n",
  700. info->family_id, info->variant_id, info->version >> 4,
  701. info->version & 0xf, info->build);
  702. dev_info(&client->dev,
  703. "Matrix X Size: %u Matrix Y Size: %u Object Num: %u\n",
  704. info->matrix_xsize, info->matrix_ysize,
  705. info->object_num);
  706. return 0;
  707. err_free_object_table:
  708. mxt_free_object_table(data);
  709. return error;
  710. }
  711. static void mxt_calc_resolution(struct mxt_data *data)
  712. {
  713. unsigned int max_x = data->pdata->x_size - 1;
  714. unsigned int max_y = data->pdata->y_size - 1;
  715. if (data->pdata->orient & MXT_XY_SWITCH) {
  716. data->max_x = max_y;
  717. data->max_y = max_x;
  718. } else {
  719. data->max_x = max_x;
  720. data->max_y = max_y;
  721. }
  722. }
  723. /* Firmware Version is returned as Major.Minor.Build */
  724. static ssize_t mxt_fw_version_show(struct device *dev,
  725. struct device_attribute *attr, char *buf)
  726. {
  727. struct mxt_data *data = dev_get_drvdata(dev);
  728. struct mxt_info *info = &data->info;
  729. return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
  730. info->version >> 4, info->version & 0xf, info->build);
  731. }
  732. /* Hardware Version is returned as FamilyID.VariantID */
  733. static ssize_t mxt_hw_version_show(struct device *dev,
  734. struct device_attribute *attr, char *buf)
  735. {
  736. struct mxt_data *data = dev_get_drvdata(dev);
  737. struct mxt_info *info = &data->info;
  738. return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
  739. info->family_id, info->variant_id);
  740. }
  741. static ssize_t mxt_show_instance(char *buf, int count,
  742. struct mxt_object *object, int instance,
  743. const u8 *val)
  744. {
  745. int i;
  746. if (object->instances > 0)
  747. count += scnprintf(buf + count, PAGE_SIZE - count,
  748. "Instance %u\n", instance);
  749. for (i = 0; i < object->size + 1; i++)
  750. count += scnprintf(buf + count, PAGE_SIZE - count,
  751. "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
  752. count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
  753. return count;
  754. }
  755. static ssize_t mxt_object_show(struct device *dev,
  756. struct device_attribute *attr, char *buf)
  757. {
  758. struct mxt_data *data = dev_get_drvdata(dev);
  759. struct mxt_object *object;
  760. int count = 0;
  761. int i, j;
  762. int error;
  763. u8 *obuf;
  764. /* Pre-allocate buffer large enough to hold max sized object. */
  765. obuf = kmalloc(256, GFP_KERNEL);
  766. if (!obuf)
  767. return -ENOMEM;
  768. error = 0;
  769. for (i = 0; i < data->info.object_num; i++) {
  770. object = data->object_table + i;
  771. if (!mxt_object_readable(object->type))
  772. continue;
  773. count += scnprintf(buf + count, PAGE_SIZE - count,
  774. "T%u:\n", object->type);
  775. for (j = 0; j < object->instances + 1; j++) {
  776. u16 size = object->size + 1;
  777. u16 addr = object->start_address + j * size;
  778. error = __mxt_read_reg(data->client, addr, size, obuf);
  779. if (error)
  780. goto done;
  781. count = mxt_show_instance(buf, count, object, j, obuf);
  782. }
  783. }
  784. done:
  785. kfree(obuf);
  786. return error ?: count;
  787. }
  788. static int mxt_load_fw(struct device *dev, const char *fn)
  789. {
  790. struct mxt_data *data = dev_get_drvdata(dev);
  791. struct i2c_client *client = data->client;
  792. const struct firmware *fw = NULL;
  793. unsigned int frame_size;
  794. unsigned int pos = 0;
  795. int ret;
  796. ret = request_firmware(&fw, fn, dev);
  797. if (ret) {
  798. dev_err(dev, "Unable to open firmware %s\n", fn);
  799. return ret;
  800. }
  801. /* Change to the bootloader mode */
  802. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  803. MXT_COMMAND_RESET, MXT_BOOT_VALUE);
  804. msleep(MXT_RESET_TIME);
  805. /* Change to slave address of bootloader */
  806. if (client->addr == MXT_APP_LOW)
  807. client->addr = MXT_BOOT_LOW;
  808. else
  809. client->addr = MXT_BOOT_HIGH;
  810. ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD);
  811. if (ret)
  812. goto out;
  813. /* Unlock bootloader */
  814. mxt_unlock_bootloader(client);
  815. while (pos < fw->size) {
  816. ret = mxt_check_bootloader(client,
  817. MXT_WAITING_FRAME_DATA);
  818. if (ret)
  819. goto out;
  820. frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
  821. /* We should add 2 at frame size as the the firmware data is not
  822. * included the CRC bytes.
  823. */
  824. frame_size += 2;
  825. /* Write one frame to device */
  826. mxt_fw_write(client, fw->data + pos, frame_size);
  827. ret = mxt_check_bootloader(client,
  828. MXT_FRAME_CRC_PASS);
  829. if (ret)
  830. goto out;
  831. pos += frame_size;
  832. dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
  833. }
  834. out:
  835. release_firmware(fw);
  836. /* Change to slave address of application */
  837. if (client->addr == MXT_BOOT_LOW)
  838. client->addr = MXT_APP_LOW;
  839. else
  840. client->addr = MXT_APP_HIGH;
  841. return ret;
  842. }
  843. static ssize_t mxt_update_fw_store(struct device *dev,
  844. struct device_attribute *attr,
  845. const char *buf, size_t count)
  846. {
  847. struct mxt_data *data = dev_get_drvdata(dev);
  848. int error;
  849. disable_irq(data->irq);
  850. error = mxt_load_fw(dev, MXT_FW_NAME);
  851. if (error) {
  852. dev_err(dev, "The firmware update failed(%d)\n", error);
  853. count = error;
  854. } else {
  855. dev_dbg(dev, "The firmware update succeeded\n");
  856. /* Wait for reset */
  857. msleep(MXT_FWRESET_TIME);
  858. mxt_free_object_table(data);
  859. mxt_initialize(data);
  860. }
  861. enable_irq(data->irq);
  862. error = mxt_make_highchg(data);
  863. if (error)
  864. return error;
  865. return count;
  866. }
  867. static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
  868. static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
  869. static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
  870. static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
  871. static struct attribute *mxt_attrs[] = {
  872. &dev_attr_fw_version.attr,
  873. &dev_attr_hw_version.attr,
  874. &dev_attr_object.attr,
  875. &dev_attr_update_fw.attr,
  876. NULL
  877. };
  878. static const struct attribute_group mxt_attr_group = {
  879. .attrs = mxt_attrs,
  880. };
  881. static void mxt_start(struct mxt_data *data)
  882. {
  883. /* Touch enable */
  884. mxt_write_object(data,
  885. MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
  886. }
  887. static void mxt_stop(struct mxt_data *data)
  888. {
  889. /* Touch disable */
  890. mxt_write_object(data,
  891. MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
  892. }
  893. static int mxt_input_open(struct input_dev *dev)
  894. {
  895. struct mxt_data *data = input_get_drvdata(dev);
  896. mxt_start(data);
  897. return 0;
  898. }
  899. static void mxt_input_close(struct input_dev *dev)
  900. {
  901. struct mxt_data *data = input_get_drvdata(dev);
  902. mxt_stop(data);
  903. }
  904. static int __devinit mxt_probe(struct i2c_client *client,
  905. const struct i2c_device_id *id)
  906. {
  907. const struct mxt_platform_data *pdata = client->dev.platform_data;
  908. struct mxt_data *data;
  909. struct input_dev *input_dev;
  910. int error;
  911. unsigned int num_mt_slots;
  912. if (!pdata)
  913. return -EINVAL;
  914. data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
  915. input_dev = input_allocate_device();
  916. if (!data || !input_dev) {
  917. dev_err(&client->dev, "Failed to allocate memory\n");
  918. error = -ENOMEM;
  919. goto err_free_mem;
  920. }
  921. input_dev->name = "Atmel maXTouch Touchscreen";
  922. snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
  923. client->adapter->nr, client->addr);
  924. input_dev->phys = data->phys;
  925. input_dev->id.bustype = BUS_I2C;
  926. input_dev->dev.parent = &client->dev;
  927. input_dev->open = mxt_input_open;
  928. input_dev->close = mxt_input_close;
  929. data->client = client;
  930. data->input_dev = input_dev;
  931. data->pdata = pdata;
  932. data->irq = client->irq;
  933. mxt_calc_resolution(data);
  934. error = mxt_initialize(data);
  935. if (error)
  936. goto err_free_mem;
  937. __set_bit(EV_ABS, input_dev->evbit);
  938. __set_bit(EV_KEY, input_dev->evbit);
  939. __set_bit(BTN_TOUCH, input_dev->keybit);
  940. /* For single touch */
  941. input_set_abs_params(input_dev, ABS_X,
  942. 0, data->max_x, 0, 0);
  943. input_set_abs_params(input_dev, ABS_Y,
  944. 0, data->max_y, 0, 0);
  945. input_set_abs_params(input_dev, ABS_PRESSURE,
  946. 0, 255, 0, 0);
  947. /* For multi touch */
  948. num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
  949. error = input_mt_init_slots(input_dev, num_mt_slots);
  950. if (error)
  951. goto err_free_object;
  952. input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
  953. 0, MXT_MAX_AREA, 0, 0);
  954. input_set_abs_params(input_dev, ABS_MT_POSITION_X,
  955. 0, data->max_x, 0, 0);
  956. input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
  957. 0, data->max_y, 0, 0);
  958. input_set_abs_params(input_dev, ABS_MT_PRESSURE,
  959. 0, 255, 0, 0);
  960. input_set_drvdata(input_dev, data);
  961. i2c_set_clientdata(client, data);
  962. error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
  963. pdata->irqflags, client->name, data);
  964. if (error) {
  965. dev_err(&client->dev, "Failed to register interrupt\n");
  966. goto err_free_object;
  967. }
  968. error = mxt_make_highchg(data);
  969. if (error)
  970. goto err_free_irq;
  971. error = input_register_device(input_dev);
  972. if (error)
  973. goto err_free_irq;
  974. error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
  975. if (error)
  976. dev_warn(&client->dev, "error creating sysfs entries.\n");
  977. return 0;
  978. err_free_irq:
  979. free_irq(client->irq, data);
  980. err_free_object:
  981. kfree(data->object_table);
  982. err_free_mem:
  983. input_free_device(input_dev);
  984. kfree(data);
  985. return error;
  986. }
  987. static int __devexit mxt_remove(struct i2c_client *client)
  988. {
  989. struct mxt_data *data = i2c_get_clientdata(client);
  990. sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
  991. free_irq(data->irq, data);
  992. input_unregister_device(data->input_dev);
  993. kfree(data->object_table);
  994. kfree(data);
  995. return 0;
  996. }
  997. #ifdef CONFIG_PM_SLEEP
  998. static int mxt_suspend(struct device *dev)
  999. {
  1000. struct i2c_client *client = to_i2c_client(dev);
  1001. struct mxt_data *data = i2c_get_clientdata(client);
  1002. struct input_dev *input_dev = data->input_dev;
  1003. mutex_lock(&input_dev->mutex);
  1004. if (input_dev->users)
  1005. mxt_stop(data);
  1006. mutex_unlock(&input_dev->mutex);
  1007. return 0;
  1008. }
  1009. static int mxt_resume(struct device *dev)
  1010. {
  1011. struct i2c_client *client = to_i2c_client(dev);
  1012. struct mxt_data *data = i2c_get_clientdata(client);
  1013. struct input_dev *input_dev = data->input_dev;
  1014. /* Soft reset */
  1015. mxt_write_object(data, MXT_GEN_COMMAND_T6,
  1016. MXT_COMMAND_RESET, 1);
  1017. msleep(MXT_RESET_TIME);
  1018. mutex_lock(&input_dev->mutex);
  1019. if (input_dev->users)
  1020. mxt_start(data);
  1021. mutex_unlock(&input_dev->mutex);
  1022. return 0;
  1023. }
  1024. #endif
  1025. static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
  1026. static const struct i2c_device_id mxt_id[] = {
  1027. { "qt602240_ts", 0 },
  1028. { "atmel_mxt_ts", 0 },
  1029. { "mXT224", 0 },
  1030. { }
  1031. };
  1032. MODULE_DEVICE_TABLE(i2c, mxt_id);
  1033. static struct i2c_driver mxt_driver = {
  1034. .driver = {
  1035. .name = "atmel_mxt_ts",
  1036. .owner = THIS_MODULE,
  1037. .pm = &mxt_pm_ops,
  1038. },
  1039. .probe = mxt_probe,
  1040. .remove = __devexit_p(mxt_remove),
  1041. .id_table = mxt_id,
  1042. };
  1043. module_i2c_driver(mxt_driver);
  1044. /* Module information */
  1045. MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
  1046. MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
  1047. MODULE_LICENSE("GPL");