rmi_smbus.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2015 - 2016 Red Hat, Inc
  4. * Copyright (c) 2011, 2012 Synaptics Incorporated
  5. * Copyright (c) 2011 Unixphere
  6. */
  7. #include <linux/kernel.h>
  8. #include <linux/delay.h>
  9. #include <linux/i2c.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/kconfig.h>
  12. #include <linux/lockdep.h>
  13. #include <linux/module.h>
  14. #include <linux/pm.h>
  15. #include <linux/rmi.h>
  16. #include <linux/slab.h>
  17. #include "rmi_driver.h"
  18. #define SMB_PROTOCOL_VERSION_ADDRESS 0xfd
  19. #define SMB_MAX_COUNT 32
  20. #define RMI_SMB2_MAP_SIZE 8 /* 8 entry of 4 bytes each */
  21. #define RMI_SMB2_MAP_FLAGS_WE 0x01
  22. struct mapping_table_entry {
  23. __le16 rmiaddr;
  24. u8 readcount;
  25. u8 flags;
  26. };
  27. struct rmi_smb_xport {
  28. struct rmi_transport_dev xport;
  29. struct i2c_client *client;
  30. struct mutex page_mutex;
  31. int page;
  32. u8 table_index;
  33. struct mutex mappingtable_mutex;
  34. struct mapping_table_entry mapping_table[RMI_SMB2_MAP_SIZE];
  35. };
  36. static int rmi_smb_get_version(struct rmi_smb_xport *rmi_smb)
  37. {
  38. struct i2c_client *client = rmi_smb->client;
  39. int retval;
  40. /* Check if for SMBus new version device by reading version byte. */
  41. retval = i2c_smbus_read_byte_data(client, SMB_PROTOCOL_VERSION_ADDRESS);
  42. if (retval < 0) {
  43. dev_err(&client->dev, "failed to get SMBus version number!\n");
  44. return retval;
  45. }
  46. return retval + 1;
  47. }
  48. /* SMB block write - wrapper over ic2_smb_write_block */
  49. static int smb_block_write(struct rmi_transport_dev *xport,
  50. u8 commandcode, const void *buf, size_t len)
  51. {
  52. struct rmi_smb_xport *rmi_smb =
  53. container_of(xport, struct rmi_smb_xport, xport);
  54. struct i2c_client *client = rmi_smb->client;
  55. int retval;
  56. retval = i2c_smbus_write_block_data(client, commandcode, len, buf);
  57. rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
  58. "wrote %zd bytes at %#04x: %d (%*ph)\n",
  59. len, commandcode, retval, (int)len, buf);
  60. return retval;
  61. }
  62. /*
  63. * The function to get command code for smbus operations and keeps
  64. * records to the driver mapping table
  65. */
  66. static int rmi_smb_get_command_code(struct rmi_transport_dev *xport,
  67. u16 rmiaddr, int bytecount, bool isread, u8 *commandcode)
  68. {
  69. struct rmi_smb_xport *rmi_smb =
  70. container_of(xport, struct rmi_smb_xport, xport);
  71. struct mapping_table_entry new_map;
  72. int i;
  73. int retval = 0;
  74. mutex_lock(&rmi_smb->mappingtable_mutex);
  75. for (i = 0; i < RMI_SMB2_MAP_SIZE; i++) {
  76. struct mapping_table_entry *entry = &rmi_smb->mapping_table[i];
  77. if (le16_to_cpu(entry->rmiaddr) == rmiaddr) {
  78. if (isread) {
  79. if (entry->readcount == bytecount)
  80. goto exit;
  81. } else {
  82. if (entry->flags & RMI_SMB2_MAP_FLAGS_WE) {
  83. goto exit;
  84. }
  85. }
  86. }
  87. }
  88. i = rmi_smb->table_index;
  89. rmi_smb->table_index = (i + 1) % RMI_SMB2_MAP_SIZE;
  90. /* constructs mapping table data entry. 4 bytes each entry */
  91. memset(&new_map, 0, sizeof(new_map));
  92. new_map.rmiaddr = cpu_to_le16(rmiaddr);
  93. new_map.readcount = bytecount;
  94. new_map.flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
  95. retval = smb_block_write(xport, i + 0x80, &new_map, sizeof(new_map));
  96. if (retval < 0) {
  97. /*
  98. * if not written to device mapping table
  99. * clear the driver mapping table records
  100. */
  101. memset(&new_map, 0, sizeof(new_map));
  102. }
  103. /* save to the driver level mapping table */
  104. rmi_smb->mapping_table[i] = new_map;
  105. exit:
  106. mutex_unlock(&rmi_smb->mappingtable_mutex);
  107. if (retval < 0)
  108. return retval;
  109. *commandcode = i;
  110. return 0;
  111. }
  112. static int rmi_smb_write_block(struct rmi_transport_dev *xport, u16 rmiaddr,
  113. const void *databuff, size_t len)
  114. {
  115. int retval = 0;
  116. u8 commandcode;
  117. struct rmi_smb_xport *rmi_smb =
  118. container_of(xport, struct rmi_smb_xport, xport);
  119. int cur_len = (int)len;
  120. mutex_lock(&rmi_smb->page_mutex);
  121. while (cur_len > 0) {
  122. /*
  123. * break into 32 bytes chunks to write get command code
  124. */
  125. int block_len = min_t(int, len, SMB_MAX_COUNT);
  126. retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
  127. false, &commandcode);
  128. if (retval < 0)
  129. goto exit;
  130. retval = smb_block_write(xport, commandcode,
  131. databuff, block_len);
  132. if (retval < 0)
  133. goto exit;
  134. /* prepare to write next block of bytes */
  135. cur_len -= SMB_MAX_COUNT;
  136. databuff += SMB_MAX_COUNT;
  137. rmiaddr += SMB_MAX_COUNT;
  138. }
  139. exit:
  140. mutex_unlock(&rmi_smb->page_mutex);
  141. return retval;
  142. }
  143. /* SMB block read - wrapper over ic2_smb_read_block */
  144. static int smb_block_read(struct rmi_transport_dev *xport,
  145. u8 commandcode, void *buf, size_t len)
  146. {
  147. struct rmi_smb_xport *rmi_smb =
  148. container_of(xport, struct rmi_smb_xport, xport);
  149. struct i2c_client *client = rmi_smb->client;
  150. int retval;
  151. retval = i2c_smbus_read_block_data(client, commandcode, buf);
  152. if (retval < 0)
  153. return retval;
  154. return retval;
  155. }
  156. static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
  157. void *databuff, size_t len)
  158. {
  159. struct rmi_smb_xport *rmi_smb =
  160. container_of(xport, struct rmi_smb_xport, xport);
  161. int retval;
  162. u8 commandcode;
  163. int cur_len = (int)len;
  164. mutex_lock(&rmi_smb->page_mutex);
  165. memset(databuff, 0, len);
  166. while (cur_len > 0) {
  167. /* break into 32 bytes chunks to write get command code */
  168. int block_len = min_t(int, cur_len, SMB_MAX_COUNT);
  169. retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
  170. true, &commandcode);
  171. if (retval < 0)
  172. goto exit;
  173. retval = smb_block_read(xport, commandcode,
  174. databuff, block_len);
  175. if (retval < 0)
  176. goto exit;
  177. /* prepare to read next block of bytes */
  178. cur_len -= SMB_MAX_COUNT;
  179. databuff += SMB_MAX_COUNT;
  180. rmiaddr += SMB_MAX_COUNT;
  181. }
  182. retval = 0;
  183. exit:
  184. mutex_unlock(&rmi_smb->page_mutex);
  185. return retval;
  186. }
  187. static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
  188. {
  189. /* the mapping table has been flushed, discard the current one */
  190. mutex_lock(&rmi_smb->mappingtable_mutex);
  191. memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
  192. mutex_unlock(&rmi_smb->mappingtable_mutex);
  193. }
  194. static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
  195. {
  196. int retval;
  197. /* we need to get the smbus version to activate the touchpad */
  198. retval = rmi_smb_get_version(rmi_smb);
  199. if (retval < 0)
  200. return retval;
  201. return 0;
  202. }
  203. static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
  204. {
  205. struct rmi_smb_xport *rmi_smb =
  206. container_of(xport, struct rmi_smb_xport, xport);
  207. rmi_smb_clear_state(rmi_smb);
  208. /*
  209. * we do not call the actual reset command, it has to be handled in
  210. * PS/2 or there will be races between PS/2 and SMBus.
  211. * PS/2 should ensure that a psmouse_reset is called before
  212. * intializing the device and after it has been removed to be in a known
  213. * state.
  214. */
  215. return rmi_smb_enable_smbus_mode(rmi_smb);
  216. }
  217. static const struct rmi_transport_ops rmi_smb_ops = {
  218. .write_block = rmi_smb_write_block,
  219. .read_block = rmi_smb_read_block,
  220. .reset = rmi_smb_reset,
  221. };
  222. static int rmi_smb_probe(struct i2c_client *client,
  223. const struct i2c_device_id *id)
  224. {
  225. struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
  226. struct rmi_smb_xport *rmi_smb;
  227. int smbus_version;
  228. int error;
  229. if (!pdata) {
  230. dev_err(&client->dev, "no platform data, aborting\n");
  231. return -ENOMEM;
  232. }
  233. if (!i2c_check_functionality(client->adapter,
  234. I2C_FUNC_SMBUS_READ_BLOCK_DATA |
  235. I2C_FUNC_SMBUS_HOST_NOTIFY)) {
  236. dev_err(&client->dev,
  237. "adapter does not support required functionality\n");
  238. return -ENODEV;
  239. }
  240. if (client->irq <= 0) {
  241. dev_err(&client->dev, "no IRQ provided, giving up\n");
  242. return client->irq ? client->irq : -ENODEV;
  243. }
  244. rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
  245. GFP_KERNEL);
  246. if (!rmi_smb)
  247. return -ENOMEM;
  248. rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s\n",
  249. dev_name(&client->dev));
  250. rmi_smb->client = client;
  251. mutex_init(&rmi_smb->page_mutex);
  252. mutex_init(&rmi_smb->mappingtable_mutex);
  253. rmi_smb->xport.dev = &client->dev;
  254. rmi_smb->xport.pdata = *pdata;
  255. rmi_smb->xport.pdata.irq = client->irq;
  256. rmi_smb->xport.proto_name = "smb";
  257. rmi_smb->xport.ops = &rmi_smb_ops;
  258. smbus_version = rmi_smb_get_version(rmi_smb);
  259. if (smbus_version < 0)
  260. return smbus_version;
  261. rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
  262. smbus_version);
  263. if (smbus_version != 2 && smbus_version != 3) {
  264. dev_err(&client->dev, "Unrecognized SMB version %d\n",
  265. smbus_version);
  266. return -ENODEV;
  267. }
  268. i2c_set_clientdata(client, rmi_smb);
  269. dev_info(&client->dev, "registering SMbus-connected sensor\n");
  270. error = rmi_register_transport_device(&rmi_smb->xport);
  271. if (error) {
  272. dev_err(&client->dev, "failed to register sensor: %d\n", error);
  273. return error;
  274. }
  275. return 0;
  276. }
  277. static int rmi_smb_remove(struct i2c_client *client)
  278. {
  279. struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
  280. rmi_unregister_transport_device(&rmi_smb->xport);
  281. return 0;
  282. }
  283. static int __maybe_unused rmi_smb_suspend(struct device *dev)
  284. {
  285. struct i2c_client *client = to_i2c_client(dev);
  286. struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
  287. int ret;
  288. ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
  289. if (ret)
  290. dev_warn(dev, "Failed to suspend device: %d\n", ret);
  291. return ret;
  292. }
  293. static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
  294. {
  295. struct i2c_client *client = to_i2c_client(dev);
  296. struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
  297. int ret;
  298. ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
  299. if (ret)
  300. dev_warn(dev, "Failed to suspend device: %d\n", ret);
  301. return ret;
  302. }
  303. static int __maybe_unused rmi_smb_resume(struct device *dev)
  304. {
  305. struct i2c_client *client = container_of(dev, struct i2c_client, dev);
  306. struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
  307. struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
  308. int ret;
  309. rmi_smb_reset(&rmi_smb->xport, 0);
  310. rmi_reset(rmi_dev);
  311. ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
  312. if (ret)
  313. dev_warn(dev, "Failed to resume device: %d\n", ret);
  314. return 0;
  315. }
  316. static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
  317. {
  318. struct i2c_client *client = to_i2c_client(dev);
  319. struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
  320. int ret;
  321. ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
  322. if (ret)
  323. dev_warn(dev, "Failed to resume device: %d\n", ret);
  324. return 0;
  325. }
  326. static const struct dev_pm_ops rmi_smb_pm = {
  327. SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
  328. SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
  329. NULL)
  330. };
  331. static const struct i2c_device_id rmi_id[] = {
  332. { "rmi4_smbus", 0 },
  333. { }
  334. };
  335. MODULE_DEVICE_TABLE(i2c, rmi_id);
  336. static struct i2c_driver rmi_smb_driver = {
  337. .driver = {
  338. .name = "rmi4_smbus",
  339. .pm = &rmi_smb_pm,
  340. },
  341. .id_table = rmi_id,
  342. .probe = rmi_smb_probe,
  343. .remove = rmi_smb_remove,
  344. };
  345. module_i2c_driver(rmi_smb_driver);
  346. MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
  347. MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
  348. MODULE_DESCRIPTION("RMI4 SMBus driver");
  349. MODULE_LICENSE("GPL");