elan_i2c_smbus.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Elan I2C/SMBus Touchpad driver - SMBus interface
  4. *
  5. * Copyright (c) 2013 ELAN Microelectronics Corp.
  6. *
  7. * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
  8. *
  9. * Based on cyapa driver:
  10. * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
  11. * copyright (c) 2011-2012 Google, Inc.
  12. *
  13. * Trademarks are the property of their respective owners.
  14. */
  15. #include <linux/delay.h>
  16. #include <linux/i2c.h>
  17. #include <linux/init.h>
  18. #include <linux/kernel.h>
  19. #include "elan_i2c.h"
  20. /* Elan SMbus commands */
  21. #define ETP_SMBUS_IAP_CMD 0x00
  22. #define ETP_SMBUS_ENABLE_TP 0x20
  23. #define ETP_SMBUS_SLEEP_CMD 0x21
  24. #define ETP_SMBUS_IAP_PASSWORD_WRITE 0x29
  25. #define ETP_SMBUS_IAP_PASSWORD_READ 0x80
  26. #define ETP_SMBUS_WRITE_FW_BLOCK 0x2A
  27. #define ETP_SMBUS_IAP_RESET_CMD 0x2B
  28. #define ETP_SMBUS_RANGE_CMD 0xA0
  29. #define ETP_SMBUS_FW_VERSION_CMD 0xA1
  30. #define ETP_SMBUS_XY_TRACENUM_CMD 0xA2
  31. #define ETP_SMBUS_SM_VERSION_CMD 0xA3
  32. #define ETP_SMBUS_UNIQUEID_CMD 0xA3
  33. #define ETP_SMBUS_RESOLUTION_CMD 0xA4
  34. #define ETP_SMBUS_HELLOPACKET_CMD 0xA7
  35. #define ETP_SMBUS_PACKET_QUERY 0xA8
  36. #define ETP_SMBUS_IAP_VERSION_CMD 0xAC
  37. #define ETP_SMBUS_IAP_CTRL_CMD 0xAD
  38. #define ETP_SMBUS_IAP_CHECKSUM_CMD 0xAE
  39. #define ETP_SMBUS_FW_CHECKSUM_CMD 0xAF
  40. #define ETP_SMBUS_MAX_BASELINE_CMD 0xC3
  41. #define ETP_SMBUS_MIN_BASELINE_CMD 0xC4
  42. #define ETP_SMBUS_CALIBRATE_QUERY 0xC5
  43. #define ETP_SMBUS_REPORT_LEN 32
  44. #define ETP_SMBUS_REPORT_LEN2 7
  45. #define ETP_SMBUS_REPORT_OFFSET 2
  46. #define ETP_SMBUS_HELLOPACKET_LEN 5
  47. #define ETP_SMBUS_IAP_PASSWORD 0x1234
  48. #define ETP_SMBUS_IAP_MODE_ON (1 << 6)
  49. static int elan_smbus_initialize(struct i2c_client *client)
  50. {
  51. u8 check[ETP_SMBUS_HELLOPACKET_LEN] = { 0x55, 0x55, 0x55, 0x55, 0x55 };
  52. u8 values[I2C_SMBUS_BLOCK_MAX] = {0};
  53. int len, error;
  54. /* Get hello packet */
  55. len = i2c_smbus_read_block_data(client,
  56. ETP_SMBUS_HELLOPACKET_CMD, values);
  57. if (len != ETP_SMBUS_HELLOPACKET_LEN) {
  58. dev_err(&client->dev, "hello packet length fail: %d\n", len);
  59. error = len < 0 ? len : -EIO;
  60. return error;
  61. }
  62. /* compare hello packet */
  63. if (memcmp(values, check, ETP_SMBUS_HELLOPACKET_LEN)) {
  64. dev_err(&client->dev, "hello packet fail [%*ph]\n",
  65. ETP_SMBUS_HELLOPACKET_LEN, values);
  66. return -ENXIO;
  67. }
  68. /* enable tp */
  69. error = i2c_smbus_write_byte(client, ETP_SMBUS_ENABLE_TP);
  70. if (error) {
  71. dev_err(&client->dev, "failed to enable touchpad: %d\n", error);
  72. return error;
  73. }
  74. return 0;
  75. }
  76. static int elan_smbus_set_mode(struct i2c_client *client, u8 mode)
  77. {
  78. u8 cmd[4] = { 0x00, 0x07, 0x00, mode };
  79. return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
  80. sizeof(cmd), cmd);
  81. }
  82. static int elan_smbus_sleep_control(struct i2c_client *client, bool sleep)
  83. {
  84. if (sleep)
  85. return i2c_smbus_write_byte(client, ETP_SMBUS_SLEEP_CMD);
  86. else
  87. return 0; /* XXX should we send ETP_SMBUS_ENABLE_TP here? */
  88. }
  89. static int elan_smbus_power_control(struct i2c_client *client, bool enable)
  90. {
  91. return 0; /* A no-op */
  92. }
  93. static int elan_smbus_calibrate(struct i2c_client *client)
  94. {
  95. u8 cmd[4] = { 0x00, 0x08, 0x00, 0x01 };
  96. return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
  97. sizeof(cmd), cmd);
  98. }
  99. static int elan_smbus_calibrate_result(struct i2c_client *client, u8 *val)
  100. {
  101. int error;
  102. u8 buf[I2C_SMBUS_BLOCK_MAX] = {0};
  103. BUILD_BUG_ON(ETP_CALIBRATE_MAX_LEN > sizeof(buf));
  104. error = i2c_smbus_read_block_data(client,
  105. ETP_SMBUS_CALIBRATE_QUERY, buf);
  106. if (error < 0)
  107. return error;
  108. memcpy(val, buf, ETP_CALIBRATE_MAX_LEN);
  109. return 0;
  110. }
  111. static int elan_smbus_get_baseline_data(struct i2c_client *client,
  112. bool max_baseline, u8 *value)
  113. {
  114. int error;
  115. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  116. error = i2c_smbus_read_block_data(client,
  117. max_baseline ?
  118. ETP_SMBUS_MAX_BASELINE_CMD :
  119. ETP_SMBUS_MIN_BASELINE_CMD,
  120. val);
  121. if (error < 0)
  122. return error;
  123. *value = be16_to_cpup((__be16 *)val);
  124. return 0;
  125. }
  126. static int elan_smbus_get_version(struct i2c_client *client,
  127. u8 pattern, bool iap, u8 *version)
  128. {
  129. int error;
  130. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  131. error = i2c_smbus_read_block_data(client,
  132. iap ? ETP_SMBUS_IAP_VERSION_CMD :
  133. ETP_SMBUS_FW_VERSION_CMD,
  134. val);
  135. if (error < 0) {
  136. dev_err(&client->dev, "failed to get %s version: %d\n",
  137. iap ? "IAP" : "FW", error);
  138. return error;
  139. }
  140. *version = val[2];
  141. return 0;
  142. }
  143. static int elan_smbus_get_sm_version(struct i2c_client *client, u8 pattern,
  144. u16 *ic_type, u8 *version, u8 *clickpad)
  145. {
  146. int error;
  147. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  148. error = i2c_smbus_read_block_data(client,
  149. ETP_SMBUS_SM_VERSION_CMD, val);
  150. if (error < 0) {
  151. dev_err(&client->dev, "failed to get SM version: %d\n", error);
  152. return error;
  153. }
  154. *version = val[0];
  155. *ic_type = val[1];
  156. *clickpad = val[0] & 0x10;
  157. return 0;
  158. }
  159. static int elan_smbus_get_product_id(struct i2c_client *client, u16 *id)
  160. {
  161. int error;
  162. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  163. error = i2c_smbus_read_block_data(client,
  164. ETP_SMBUS_UNIQUEID_CMD, val);
  165. if (error < 0) {
  166. dev_err(&client->dev, "failed to get product ID: %d\n", error);
  167. return error;
  168. }
  169. *id = be16_to_cpup((__be16 *)val);
  170. return 0;
  171. }
  172. static int elan_smbus_get_checksum(struct i2c_client *client,
  173. bool iap, u16 *csum)
  174. {
  175. int error;
  176. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  177. error = i2c_smbus_read_block_data(client,
  178. iap ? ETP_SMBUS_FW_CHECKSUM_CMD :
  179. ETP_SMBUS_IAP_CHECKSUM_CMD,
  180. val);
  181. if (error < 0) {
  182. dev_err(&client->dev, "failed to get %s checksum: %d\n",
  183. iap ? "IAP" : "FW", error);
  184. return error;
  185. }
  186. *csum = be16_to_cpup((__be16 *)val);
  187. return 0;
  188. }
  189. static int elan_smbus_get_max(struct i2c_client *client,
  190. unsigned int *max_x, unsigned int *max_y)
  191. {
  192. int ret;
  193. int error;
  194. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  195. ret = i2c_smbus_read_block_data(client, ETP_SMBUS_RANGE_CMD, val);
  196. if (ret != 3) {
  197. error = ret < 0 ? ret : -EIO;
  198. dev_err(&client->dev, "failed to get dimensions: %d\n", error);
  199. return error;
  200. }
  201. *max_x = (0x0f & val[0]) << 8 | val[1];
  202. *max_y = (0xf0 & val[0]) << 4 | val[2];
  203. return 0;
  204. }
  205. static int elan_smbus_get_resolution(struct i2c_client *client,
  206. u8 *hw_res_x, u8 *hw_res_y)
  207. {
  208. int ret;
  209. int error;
  210. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  211. ret = i2c_smbus_read_block_data(client, ETP_SMBUS_RESOLUTION_CMD, val);
  212. if (ret != 3) {
  213. error = ret < 0 ? ret : -EIO;
  214. dev_err(&client->dev, "failed to get resolution: %d\n", error);
  215. return error;
  216. }
  217. *hw_res_x = val[1] & 0x0F;
  218. *hw_res_y = (val[1] & 0xF0) >> 4;
  219. return 0;
  220. }
  221. static int elan_smbus_get_num_traces(struct i2c_client *client,
  222. unsigned int *x_traces,
  223. unsigned int *y_traces)
  224. {
  225. int ret;
  226. int error;
  227. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  228. ret = i2c_smbus_read_block_data(client, ETP_SMBUS_XY_TRACENUM_CMD, val);
  229. if (ret != 3) {
  230. error = ret < 0 ? ret : -EIO;
  231. dev_err(&client->dev, "failed to get trace info: %d\n", error);
  232. return error;
  233. }
  234. *x_traces = val[1];
  235. *y_traces = val[2];
  236. return 0;
  237. }
  238. static int elan_smbus_get_pressure_adjustment(struct i2c_client *client,
  239. int *adjustment)
  240. {
  241. *adjustment = ETP_PRESSURE_OFFSET;
  242. return 0;
  243. }
  244. static int elan_smbus_iap_get_mode(struct i2c_client *client,
  245. enum tp_mode *mode)
  246. {
  247. int error;
  248. u16 constant;
  249. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  250. error = i2c_smbus_read_block_data(client, ETP_SMBUS_IAP_CTRL_CMD, val);
  251. if (error < 0) {
  252. dev_err(&client->dev, "failed to read iap ctrol register: %d\n",
  253. error);
  254. return error;
  255. }
  256. constant = be16_to_cpup((__be16 *)val);
  257. dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant);
  258. *mode = (constant & ETP_SMBUS_IAP_MODE_ON) ? IAP_MODE : MAIN_MODE;
  259. return 0;
  260. }
  261. static int elan_smbus_iap_reset(struct i2c_client *client)
  262. {
  263. int error;
  264. error = i2c_smbus_write_byte(client, ETP_SMBUS_IAP_RESET_CMD);
  265. if (error) {
  266. dev_err(&client->dev, "cannot reset IC: %d\n", error);
  267. return error;
  268. }
  269. return 0;
  270. }
  271. static int elan_smbus_set_flash_key(struct i2c_client *client)
  272. {
  273. int error;
  274. u8 cmd[4] = { 0x00, 0x0B, 0x00, 0x5A };
  275. error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
  276. sizeof(cmd), cmd);
  277. if (error) {
  278. dev_err(&client->dev, "cannot set flash key: %d\n", error);
  279. return error;
  280. }
  281. return 0;
  282. }
  283. static int elan_smbus_prepare_fw_update(struct i2c_client *client, u16 ic_type,
  284. u8 iap_version, u16 fw_page_size)
  285. {
  286. struct device *dev = &client->dev;
  287. int len;
  288. int error;
  289. enum tp_mode mode;
  290. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  291. u8 cmd[4] = {0x0F, 0x78, 0x00, 0x06};
  292. u16 password;
  293. /* Get FW in which mode (IAP_MODE/MAIN_MODE) */
  294. error = elan_smbus_iap_get_mode(client, &mode);
  295. if (error)
  296. return error;
  297. if (mode == MAIN_MODE) {
  298. /* set flash key */
  299. error = elan_smbus_set_flash_key(client);
  300. if (error)
  301. return error;
  302. /* write iap password */
  303. if (i2c_smbus_write_byte(client,
  304. ETP_SMBUS_IAP_PASSWORD_WRITE) < 0) {
  305. dev_err(dev, "cannot write iap password\n");
  306. return -EIO;
  307. }
  308. error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
  309. sizeof(cmd), cmd);
  310. if (error) {
  311. dev_err(dev, "failed to write iap password: %d\n",
  312. error);
  313. return error;
  314. }
  315. /*
  316. * Read back password to make sure we enabled flash
  317. * successfully.
  318. */
  319. len = i2c_smbus_read_block_data(client,
  320. ETP_SMBUS_IAP_PASSWORD_READ,
  321. val);
  322. if (len < (int)sizeof(u16)) {
  323. error = len < 0 ? len : -EIO;
  324. dev_err(dev, "failed to read iap password: %d\n",
  325. error);
  326. return error;
  327. }
  328. password = be16_to_cpup((__be16 *)val);
  329. if (password != ETP_SMBUS_IAP_PASSWORD) {
  330. dev_err(dev, "wrong iap password = 0x%X\n", password);
  331. return -EIO;
  332. }
  333. /* Wait 30ms for MAIN_MODE change to IAP_MODE */
  334. msleep(30);
  335. }
  336. error = elan_smbus_set_flash_key(client);
  337. if (error)
  338. return error;
  339. /* Reset IC */
  340. error = elan_smbus_iap_reset(client);
  341. if (error)
  342. return error;
  343. return 0;
  344. }
  345. static int elan_smbus_write_fw_block(struct i2c_client *client, u16 fw_page_size,
  346. const u8 *page, u16 checksum, int idx)
  347. {
  348. struct device *dev = &client->dev;
  349. int error;
  350. u16 result;
  351. u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
  352. /*
  353. * Due to the limitation of smbus protocol limiting
  354. * transfer to 32 bytes at a time, we must split block
  355. * in 2 transfers.
  356. */
  357. error = i2c_smbus_write_block_data(client,
  358. ETP_SMBUS_WRITE_FW_BLOCK,
  359. fw_page_size / 2,
  360. page);
  361. if (error) {
  362. dev_err(dev, "Failed to write page %d (part %d): %d\n",
  363. idx, 1, error);
  364. return error;
  365. }
  366. error = i2c_smbus_write_block_data(client,
  367. ETP_SMBUS_WRITE_FW_BLOCK,
  368. fw_page_size / 2,
  369. page + fw_page_size / 2);
  370. if (error) {
  371. dev_err(dev, "Failed to write page %d (part %d): %d\n",
  372. idx, 2, error);
  373. return error;
  374. }
  375. /* Wait for F/W to update one page ROM data. */
  376. usleep_range(8000, 10000);
  377. error = i2c_smbus_read_block_data(client,
  378. ETP_SMBUS_IAP_CTRL_CMD, val);
  379. if (error < 0) {
  380. dev_err(dev, "Failed to read IAP write result: %d\n",
  381. error);
  382. return error;
  383. }
  384. result = be16_to_cpup((__be16 *)val);
  385. if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
  386. dev_err(dev, "IAP reports failed write: %04hx\n",
  387. result);
  388. return -EIO;
  389. }
  390. return 0;
  391. }
  392. static int elan_smbus_get_report_features(struct i2c_client *client, u8 pattern,
  393. unsigned int *features,
  394. unsigned int *report_len)
  395. {
  396. /*
  397. * SMBus controllers with pattern 2 lack area info, as newer
  398. * high-precision packets use that space for coordinates.
  399. */
  400. *features = pattern <= 0x01 ? ETP_FEATURE_REPORT_MK : 0;
  401. *report_len = ETP_SMBUS_REPORT_LEN;
  402. return 0;
  403. }
  404. static int elan_smbus_get_report(struct i2c_client *client,
  405. u8 *report, unsigned int report_len)
  406. {
  407. int len;
  408. BUILD_BUG_ON(I2C_SMBUS_BLOCK_MAX > ETP_SMBUS_REPORT_LEN);
  409. len = i2c_smbus_read_block_data(client,
  410. ETP_SMBUS_PACKET_QUERY,
  411. &report[ETP_SMBUS_REPORT_OFFSET]);
  412. if (len < 0) {
  413. dev_err(&client->dev, "failed to read report data: %d\n", len);
  414. return len;
  415. }
  416. if (report[ETP_REPORT_ID_OFFSET] == ETP_TP_REPORT_ID2)
  417. report_len = ETP_SMBUS_REPORT_LEN2;
  418. if (len != report_len) {
  419. dev_err(&client->dev,
  420. "wrong report length (%d vs %d expected)\n",
  421. len, report_len);
  422. return -EIO;
  423. }
  424. return 0;
  425. }
  426. static int elan_smbus_finish_fw_update(struct i2c_client *client,
  427. struct completion *fw_completion)
  428. {
  429. /* No special handling unlike I2C transport */
  430. return 0;
  431. }
  432. static int elan_smbus_get_pattern(struct i2c_client *client, u8 *pattern)
  433. {
  434. *pattern = 0;
  435. return 0;
  436. }
  437. const struct elan_transport_ops elan_smbus_ops = {
  438. .initialize = elan_smbus_initialize,
  439. .sleep_control = elan_smbus_sleep_control,
  440. .power_control = elan_smbus_power_control,
  441. .set_mode = elan_smbus_set_mode,
  442. .calibrate = elan_smbus_calibrate,
  443. .calibrate_result = elan_smbus_calibrate_result,
  444. .get_baseline_data = elan_smbus_get_baseline_data,
  445. .get_version = elan_smbus_get_version,
  446. .get_sm_version = elan_smbus_get_sm_version,
  447. .get_product_id = elan_smbus_get_product_id,
  448. .get_checksum = elan_smbus_get_checksum,
  449. .get_pressure_adjustment = elan_smbus_get_pressure_adjustment,
  450. .get_max = elan_smbus_get_max,
  451. .get_resolution = elan_smbus_get_resolution,
  452. .get_num_traces = elan_smbus_get_num_traces,
  453. .iap_get_mode = elan_smbus_iap_get_mode,
  454. .iap_reset = elan_smbus_iap_reset,
  455. .prepare_fw_update = elan_smbus_prepare_fw_update,
  456. .write_fw_block = elan_smbus_write_fw_block,
  457. .finish_fw_update = elan_smbus_finish_fw_update,
  458. .get_report_features = elan_smbus_get_report_features,
  459. .get_report = elan_smbus_get_report,
  460. .get_pattern = elan_smbus_get_pattern,
  461. };