synaptics_dsx_spi.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698
  1. /*
  2. * Synaptics DSX touchscreen driver
  3. *
  4. * Copyright (C) 2012-2016 Synaptics Incorporated. All rights reserved.
  5. *
  6. * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
  7. * Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com>
  8. * Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com>
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND SYNAPTICS
  21. * EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, INCLUDING ANY
  22. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE,
  23. * AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS.
  24. * IN NO EVENT SHALL SYNAPTICS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25. * SPECIAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION
  26. * WITH THE USE OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED
  27. * AND BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  28. * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS ADVISED OF
  29. * THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF COMPETENT JURISDICTION DOES
  30. * NOT PERMIT THE DISCLAIMER OF DIRECT DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS'
  31. * TOTAL CUMULATIVE LIABILITY TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S.
  32. * DOLLARS.
  33. */
  34. #include <linux/kernel.h>
  35. #include <linux/module.h>
  36. #include <linux/slab.h>
  37. #include <linux/spi/spi.h>
  38. #include <linux/delay.h>
  39. #include <linux/input.h>
  40. #include <linux/types.h>
  41. #include <linux/of_gpio.h>
  42. #include <linux/platform_device.h>
  43. #include <linux/input/synaptics_dsx.h>
  44. #include "synaptics_dsx_core.h"
  45. #define SPI_READ 0x80
  46. #define SPI_WRITE 0x00
  47. static unsigned char *buf;
  48. static struct spi_transfer *xfer;
  49. #ifdef CONFIG_OF
  50. static int parse_dt(struct device *dev, struct synaptics_dsx_board_data *bdata)
  51. {
  52. int retval;
  53. u32 value;
  54. const char *name;
  55. struct property *prop;
  56. struct device_node *np = dev->of_node;
  57. bdata->irq_gpio = of_get_named_gpio_flags(np,
  58. "synaptics,irq-gpio", 0,
  59. (enum of_gpio_flags *)&bdata->irq_flags);
  60. retval = of_property_read_u32(np, "synaptics,irq-on-state",
  61. &value);
  62. if (retval < 0)
  63. bdata->irq_on_state = 0;
  64. else
  65. bdata->irq_on_state = value;
  66. retval = of_property_read_string(np, "synaptics,pwr-reg-name", &name);
  67. if (retval < 0)
  68. bdata->pwr_reg_name = NULL;
  69. else
  70. bdata->pwr_reg_name = name;
  71. retval = of_property_read_string(np, "synaptics,bus-reg-name", &name);
  72. if (retval < 0)
  73. bdata->bus_reg_name = NULL;
  74. else
  75. bdata->bus_reg_name = name;
  76. prop = of_find_property(np, "synaptics,power-gpio", NULL);
  77. if (prop && prop->length) {
  78. bdata->power_gpio = of_get_named_gpio_flags(np,
  79. "synaptics,power-gpio", 0, NULL);
  80. retval = of_property_read_u32(np, "synaptics,power-on-state",
  81. &value);
  82. if (retval < 0) {
  83. dev_err(dev, "%s: Unable to read synaptics,power-on-state property\n",
  84. __func__);
  85. return retval;
  86. }
  87. bdata->power_on_state = value;
  88. } else {
  89. bdata->power_gpio = -1;
  90. }
  91. prop = of_find_property(np, "synaptics,power-delay-ms", NULL);
  92. if (prop && prop->length) {
  93. retval = of_property_read_u32(np, "synaptics,power-delay-ms",
  94. &value);
  95. if (retval < 0) {
  96. dev_err(dev, "%s: Unable to read synaptics,power-delay-ms property\n",
  97. __func__);
  98. return retval;
  99. }
  100. bdata->power_delay_ms = value;
  101. } else {
  102. bdata->power_delay_ms = 0;
  103. }
  104. prop = of_find_property(np, "synaptics,reset-gpio", NULL);
  105. if (prop && prop->length) {
  106. bdata->reset_gpio = of_get_named_gpio_flags(np,
  107. "synaptics,reset-gpio", 0, NULL);
  108. retval = of_property_read_u32(np, "synaptics,reset-on-state",
  109. &value);
  110. if (retval < 0) {
  111. dev_err(dev, "%s: Unable to read synaptics,reset-on-state property\n",
  112. __func__);
  113. return retval;
  114. }
  115. bdata->reset_on_state = value;
  116. retval = of_property_read_u32(np, "synaptics,reset-active-ms",
  117. &value);
  118. if (retval < 0) {
  119. dev_err(dev, "%s: Unable to read synaptics,reset-active-ms property\n",
  120. __func__);
  121. return retval;
  122. }
  123. bdata->reset_active_ms = value;
  124. } else {
  125. bdata->reset_gpio = -1;
  126. }
  127. prop = of_find_property(np, "synaptics,reset-delay-ms", NULL);
  128. if (prop && prop->length) {
  129. retval = of_property_read_u32(np, "synaptics,reset-delay-ms",
  130. &value);
  131. if (retval < 0) {
  132. dev_err(dev, "%s: Unable to read synaptics,reset-delay-ms property\n",
  133. __func__);
  134. return retval;
  135. }
  136. bdata->reset_delay_ms = value;
  137. } else {
  138. bdata->reset_delay_ms = 0;
  139. }
  140. prop = of_find_property(np, "synaptics,byte-delay-us", NULL);
  141. if (prop && prop->length) {
  142. retval = of_property_read_u32(np, "synaptics,byte-delay-us",
  143. &value);
  144. if (retval < 0) {
  145. dev_err(dev, "%s: Unable to read synaptics,byte-delay-us property\n",
  146. __func__);
  147. return retval;
  148. }
  149. bdata->byte_delay_us = value;
  150. } else {
  151. bdata->byte_delay_us = 0;
  152. }
  153. prop = of_find_property(np, "synaptics,block-delay-us", NULL);
  154. if (prop && prop->length) {
  155. retval = of_property_read_u32(np, "synaptics,block-delay-us",
  156. &value);
  157. if (retval < 0) {
  158. dev_err(dev, "%s: Unable to read synaptics,block-delay-us property\n",
  159. __func__);
  160. return retval;
  161. }
  162. bdata->block_delay_us = value;
  163. } else {
  164. bdata->block_delay_us = 0;
  165. }
  166. prop = of_find_property(np, "synaptics,address-delay-us", NULL);
  167. if (prop && prop->length) {
  168. retval = of_property_read_u32(np, "synaptics,address-delay-us",
  169. &value);
  170. if (retval < 0) {
  171. dev_err(dev, "%s: Unable to read synaptics,address-delay-us property\n",
  172. __func__);
  173. return retval;
  174. }
  175. bdata->addr_delay_us = value;
  176. } else {
  177. bdata->addr_delay_us = 0;
  178. }
  179. prop = of_find_property(np, "synaptics,max-y-for-2d", NULL);
  180. if (prop && prop->length) {
  181. retval = of_property_read_u32(np, "synaptics,max-y-for-2d",
  182. &value);
  183. if (retval < 0) {
  184. dev_err(dev, "%s: Unable to read synaptics,max-y-for-2d property\n",
  185. __func__);
  186. return retval;
  187. }
  188. bdata->max_y_for_2d = value;
  189. } else {
  190. bdata->max_y_for_2d = -1;
  191. }
  192. prop = of_find_property(np, "synaptics,swap-axes", NULL);
  193. bdata->swap_axes = prop > 0 ? true : false;
  194. prop = of_find_property(np, "synaptics,x-flip", NULL);
  195. bdata->x_flip = prop > 0 ? true : false;
  196. prop = of_find_property(np, "synaptics,y-flip", NULL);
  197. bdata->y_flip = prop > 0 ? true : false;
  198. prop = of_find_property(np, "synaptics,ub-i2c-addr", NULL);
  199. if (prop && prop->length) {
  200. retval = of_property_read_u32(np, "synaptics,ub-i2c-addr",
  201. &value);
  202. if (retval < 0) {
  203. dev_err(dev, "%s: Unable to read synaptics,ub-i2c-addr property\n",
  204. __func__);
  205. return retval;
  206. }
  207. bdata->ub_i2c_addr = (unsigned short)value;
  208. } else {
  209. bdata->ub_i2c_addr = -1;
  210. }
  211. prop = of_find_property(np, "synaptics,cap-button-codes", NULL);
  212. if (prop && prop->length) {
  213. bdata->cap_button_map->map = devm_kzalloc(dev,
  214. prop->length,
  215. GFP_KERNEL);
  216. if (!bdata->cap_button_map->map)
  217. return -ENOMEM;
  218. bdata->cap_button_map->nbuttons = prop->length / sizeof(u32);
  219. retval = of_property_read_u32_array(np,
  220. "synaptics,cap-button-codes",
  221. bdata->cap_button_map->map,
  222. bdata->cap_button_map->nbuttons);
  223. if (retval < 0) {
  224. bdata->cap_button_map->nbuttons = 0;
  225. bdata->cap_button_map->map = NULL;
  226. }
  227. } else {
  228. bdata->cap_button_map->nbuttons = 0;
  229. bdata->cap_button_map->map = NULL;
  230. }
  231. prop = of_find_property(np, "synaptics,vir-button-codes", NULL);
  232. if (prop && prop->length) {
  233. bdata->vir_button_map->map = devm_kzalloc(dev,
  234. prop->length,
  235. GFP_KERNEL);
  236. if (!bdata->vir_button_map->map)
  237. return -ENOMEM;
  238. bdata->vir_button_map->nbuttons = prop->length / sizeof(u32);
  239. bdata->vir_button_map->nbuttons /= 5;
  240. retval = of_property_read_u32_array(np,
  241. "synaptics,vir-button-codes",
  242. bdata->vir_button_map->map,
  243. bdata->vir_button_map->nbuttons * 5);
  244. if (retval < 0) {
  245. bdata->vir_button_map->nbuttons = 0;
  246. bdata->vir_button_map->map = NULL;
  247. }
  248. } else {
  249. bdata->vir_button_map->nbuttons = 0;
  250. bdata->vir_button_map->map = NULL;
  251. }
  252. return 0;
  253. }
  254. #endif
  255. static int synaptics_rmi4_spi_alloc_buf(struct synaptics_rmi4_data *rmi4_data,
  256. unsigned int size, unsigned int count)
  257. {
  258. static unsigned int buf_size;
  259. static unsigned int xfer_count;
  260. if (size > buf_size) {
  261. if (buf_size)
  262. kfree(buf);
  263. buf = kmalloc(size, GFP_KERNEL);
  264. if (!buf) {
  265. dev_err(rmi4_data->pdev->dev.parent,
  266. "%s: Failed to alloc mem for buf\n",
  267. __func__);
  268. buf_size = 0;
  269. return -ENOMEM;
  270. }
  271. buf_size = size;
  272. }
  273. if (count > xfer_count) {
  274. if (xfer_count)
  275. kfree(xfer);
  276. xfer = kcalloc(count, sizeof(struct spi_transfer), GFP_KERNEL);
  277. if (!xfer) {
  278. dev_err(rmi4_data->pdev->dev.parent,
  279. "%s: Failed to alloc mem for xfer\n",
  280. __func__);
  281. xfer_count = 0;
  282. return -ENOMEM;
  283. }
  284. xfer_count = count;
  285. } else {
  286. memset(xfer, 0, count * sizeof(struct spi_transfer));
  287. }
  288. return 0;
  289. }
  290. static int synaptics_rmi4_spi_set_page(struct synaptics_rmi4_data *rmi4_data,
  291. unsigned short addr)
  292. {
  293. int retval;
  294. unsigned int index;
  295. unsigned int byte_count = PAGE_SELECT_LEN + 1;
  296. unsigned char page;
  297. struct spi_message msg;
  298. struct spi_device *spi = to_spi_device(rmi4_data->pdev->dev.parent);
  299. const struct synaptics_dsx_board_data *bdata =
  300. rmi4_data->hw_if->board_data;
  301. page = ((addr >> 8) & MASK_8BIT);
  302. if ((page >> 7) == (rmi4_data->current_page >> 7))
  303. return PAGE_SELECT_LEN;
  304. spi_message_init(&msg);
  305. retval = synaptics_rmi4_spi_alloc_buf(rmi4_data, byte_count,
  306. byte_count);
  307. if (retval < 0)
  308. return retval;
  309. buf[0] = SPI_WRITE;
  310. buf[1] = MASK_8BIT;
  311. buf[2] = page;
  312. if (bdata->byte_delay_us == 0) {
  313. xfer[0].len = byte_count;
  314. xfer[0].tx_buf = &buf[0];
  315. if (bdata->block_delay_us)
  316. xfer[0].delay_usecs = bdata->block_delay_us;
  317. spi_message_add_tail(&xfer[0], &msg);
  318. } else {
  319. for (index = 0; index < byte_count; index++) {
  320. xfer[index].len = 1;
  321. xfer[index].tx_buf = &buf[index];
  322. if (index == 1)
  323. xfer[index].delay_usecs = bdata->addr_delay_us;
  324. else
  325. xfer[index].delay_usecs = bdata->byte_delay_us;
  326. spi_message_add_tail(&xfer[index], &msg);
  327. }
  328. if (bdata->block_delay_us)
  329. xfer[index - 1].delay_usecs = bdata->block_delay_us;
  330. }
  331. retval = spi_sync(spi, &msg);
  332. if (retval == 0) {
  333. rmi4_data->current_page = page;
  334. retval = PAGE_SELECT_LEN;
  335. } else {
  336. dev_err(rmi4_data->pdev->dev.parent,
  337. "%s: Failed to complete SPI transfer, error = %d\n",
  338. __func__, retval);
  339. }
  340. return retval;
  341. }
  342. static int synaptics_rmi4_spi_read(struct synaptics_rmi4_data *rmi4_data,
  343. unsigned short addr, unsigned char *data, unsigned int length)
  344. {
  345. int retval;
  346. unsigned int index;
  347. unsigned int byte_count = length + ADDRESS_LEN;
  348. unsigned char txbuf[ADDRESS_LEN];
  349. struct spi_message msg;
  350. struct spi_device *spi = to_spi_device(rmi4_data->pdev->dev.parent);
  351. const struct synaptics_dsx_board_data *bdata =
  352. rmi4_data->hw_if->board_data;
  353. spi_message_init(&msg);
  354. txbuf[0] = (addr >> 8) | SPI_READ;
  355. txbuf[1] = addr & MASK_8BIT;
  356. mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex);
  357. retval = synaptics_rmi4_spi_set_page(rmi4_data, addr);
  358. if (retval != PAGE_SELECT_LEN) {
  359. mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex);
  360. return -EIO;
  361. }
  362. if (bdata->byte_delay_us == 0) {
  363. retval = synaptics_rmi4_spi_alloc_buf(rmi4_data, length,
  364. 2);
  365. } else {
  366. retval = synaptics_rmi4_spi_alloc_buf(rmi4_data, length,
  367. byte_count);
  368. }
  369. if (retval < 0) {
  370. mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex);
  371. return retval;
  372. }
  373. if (bdata->byte_delay_us == 0) {
  374. xfer[0].len = ADDRESS_LEN;
  375. xfer[0].tx_buf = &txbuf[0];
  376. spi_message_add_tail(&xfer[0], &msg);
  377. xfer[1].len = length;
  378. xfer[1].rx_buf = &buf[0];
  379. if (bdata->block_delay_us)
  380. xfer[1].delay_usecs = bdata->block_delay_us;
  381. spi_message_add_tail(&xfer[1], &msg);
  382. } else {
  383. for (index = 0; index < byte_count; index++) {
  384. xfer[index].len = 1;
  385. if (index < ADDRESS_LEN)
  386. xfer[index].tx_buf = &txbuf[index];
  387. else
  388. xfer[index].rx_buf = &buf[index - ADDRESS_LEN];
  389. if (index == 1)
  390. xfer[index].delay_usecs = bdata->addr_delay_us;
  391. else
  392. xfer[index].delay_usecs = bdata->byte_delay_us;
  393. spi_message_add_tail(&xfer[index], &msg);
  394. }
  395. if (bdata->block_delay_us)
  396. xfer[index - 1].delay_usecs = bdata->block_delay_us;
  397. }
  398. retval = spi_sync(spi, &msg);
  399. if (retval == 0) {
  400. retval = secure_memcpy(data, length, buf, length, length);
  401. if (retval < 0) {
  402. dev_err(rmi4_data->pdev->dev.parent,
  403. "%s: Failed to copy data\n",
  404. __func__);
  405. } else {
  406. retval = length;
  407. }
  408. } else {
  409. dev_err(rmi4_data->pdev->dev.parent,
  410. "%s: Failed to complete SPI transfer, error = %d\n",
  411. __func__, retval);
  412. }
  413. mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex);
  414. return retval;
  415. }
  416. static int synaptics_rmi4_spi_write(struct synaptics_rmi4_data *rmi4_data,
  417. unsigned short addr, unsigned char *data, unsigned int length)
  418. {
  419. int retval;
  420. unsigned int index;
  421. unsigned int byte_count = length + ADDRESS_LEN;
  422. struct spi_message msg;
  423. struct spi_device *spi = to_spi_device(rmi4_data->pdev->dev.parent);
  424. const struct synaptics_dsx_board_data *bdata =
  425. rmi4_data->hw_if->board_data;
  426. spi_message_init(&msg);
  427. mutex_lock(&rmi4_data->rmi4_io_ctrl_mutex);
  428. retval = synaptics_rmi4_spi_set_page(rmi4_data, addr);
  429. if (retval != PAGE_SELECT_LEN) {
  430. mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex);
  431. return -EIO;
  432. }
  433. if (bdata->byte_delay_us == 0) {
  434. retval = synaptics_rmi4_spi_alloc_buf(rmi4_data, byte_count,
  435. 1);
  436. } else {
  437. retval = synaptics_rmi4_spi_alloc_buf(rmi4_data, byte_count,
  438. byte_count);
  439. }
  440. if (retval < 0) {
  441. mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex);
  442. return retval;
  443. }
  444. buf[0] = (addr >> 8) & ~SPI_READ;
  445. buf[1] = addr & MASK_8BIT;
  446. retval = secure_memcpy(&buf[ADDRESS_LEN],
  447. byte_count - ADDRESS_LEN, data, length, length);
  448. if (retval < 0) {
  449. dev_err(rmi4_data->pdev->dev.parent,
  450. "%s: Failed to copy data\n",
  451. __func__);
  452. mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex);
  453. return retval;
  454. }
  455. if (bdata->byte_delay_us == 0) {
  456. xfer[0].len = byte_count;
  457. xfer[0].tx_buf = &buf[0];
  458. if (bdata->block_delay_us)
  459. xfer[0].delay_usecs = bdata->block_delay_us;
  460. spi_message_add_tail(xfer, &msg);
  461. } else {
  462. for (index = 0; index < byte_count; index++) {
  463. xfer[index].len = 1;
  464. xfer[index].tx_buf = &buf[index];
  465. if (index == 1)
  466. xfer[index].delay_usecs = bdata->addr_delay_us;
  467. else
  468. xfer[index].delay_usecs = bdata->byte_delay_us;
  469. spi_message_add_tail(&xfer[index], &msg);
  470. }
  471. if (bdata->block_delay_us)
  472. xfer[index - 1].delay_usecs = bdata->block_delay_us;
  473. }
  474. retval = spi_sync(spi, &msg);
  475. if (retval == 0) {
  476. retval = length;
  477. } else {
  478. dev_err(rmi4_data->pdev->dev.parent,
  479. "%s: Failed to complete SPI transfer, error = %d\n",
  480. __func__, retval);
  481. }
  482. mutex_unlock(&rmi4_data->rmi4_io_ctrl_mutex);
  483. return retval;
  484. }
  485. static struct synaptics_dsx_bus_access bus_access = {
  486. .type = BUS_SPI,
  487. .read = synaptics_rmi4_spi_read,
  488. .write = synaptics_rmi4_spi_write,
  489. };
  490. static struct synaptics_dsx_hw_interface hw_if;
  491. static struct platform_device *synaptics_dsx_spi_device;
  492. static void synaptics_rmi4_spi_dev_release(struct device *dev)
  493. {
  494. kfree(synaptics_dsx_spi_device);
  495. }
  496. static int synaptics_rmi4_spi_probe(struct spi_device *spi)
  497. {
  498. int retval;
  499. if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) {
  500. dev_err(&spi->dev,
  501. "%s: Full duplex not supported by host\n",
  502. __func__);
  503. return -EIO;
  504. }
  505. synaptics_dsx_spi_device = kzalloc(
  506. sizeof(struct platform_device),
  507. GFP_KERNEL);
  508. if (!synaptics_dsx_spi_device) {
  509. dev_err(&spi->dev,
  510. "%s: Failed to allocate memory for synaptics_dsx_spi_device\n",
  511. __func__);
  512. return -ENOMEM;
  513. }
  514. #ifdef CONFIG_OF
  515. if (spi->dev.of_node) {
  516. hw_if.board_data = devm_kzalloc(&spi->dev,
  517. sizeof(struct synaptics_dsx_board_data),
  518. GFP_KERNEL);
  519. if (!hw_if.board_data) {
  520. dev_err(&spi->dev,
  521. "%s: Failed to allocate memory for board data\n",
  522. __func__);
  523. return -ENOMEM;
  524. }
  525. hw_if.board_data->cap_button_map = devm_kzalloc(&spi->dev,
  526. sizeof(struct synaptics_dsx_button_map),
  527. GFP_KERNEL);
  528. if (!hw_if.board_data->cap_button_map) {
  529. dev_err(&spi->dev,
  530. "%s: Failed to allocate memory for 0D button map\n",
  531. __func__);
  532. return -ENOMEM;
  533. }
  534. hw_if.board_data->vir_button_map = devm_kzalloc(&spi->dev,
  535. sizeof(struct synaptics_dsx_button_map),
  536. GFP_KERNEL);
  537. if (!hw_if.board_data->vir_button_map) {
  538. dev_err(&spi->dev,
  539. "%s: Failed to allocate memory for virtual button map\n",
  540. __func__);
  541. return -ENOMEM;
  542. }
  543. parse_dt(&spi->dev, hw_if.board_data);
  544. }
  545. #else
  546. hw_if.board_data = spi->dev.platform_data;
  547. #endif
  548. hw_if.bus_access = &bus_access;
  549. spi->bits_per_word = 8;
  550. spi->mode = SPI_MODE_3;
  551. retval = spi_setup(spi);
  552. if (retval < 0) {
  553. dev_err(&spi->dev,
  554. "%s: Failed to perform SPI setup\n",
  555. __func__);
  556. return retval;
  557. }
  558. synaptics_dsx_spi_device->name = PLATFORM_DRIVER_NAME;
  559. synaptics_dsx_spi_device->id = 0;
  560. synaptics_dsx_spi_device->num_resources = 0;
  561. synaptics_dsx_spi_device->dev.parent = &spi->dev;
  562. synaptics_dsx_spi_device->dev.platform_data = &hw_if;
  563. synaptics_dsx_spi_device->dev.release = synaptics_rmi4_spi_dev_release;
  564. retval = platform_device_register(synaptics_dsx_spi_device);
  565. if (retval) {
  566. dev_err(&spi->dev,
  567. "%s: Failed to register platform device\n",
  568. __func__);
  569. return -ENODEV;
  570. }
  571. return 0;
  572. }
  573. static int synaptics_rmi4_spi_remove(struct spi_device *spi)
  574. {
  575. platform_device_unregister(synaptics_dsx_spi_device);
  576. return 0;
  577. }
  578. static const struct spi_device_id synaptics_rmi4_id_table[] = {
  579. {SPI_DRIVER_NAME, 0},
  580. {},
  581. };
  582. MODULE_DEVICE_TABLE(spi, synaptics_rmi4_id_table);
  583. #ifdef CONFIG_OF
  584. static const struct of_device_id synaptics_rmi4_of_match_table[] = {
  585. {
  586. .compatible = "synaptics,dsx-spi",
  587. },
  588. {},
  589. };
  590. MODULE_DEVICE_TABLE(of, synaptics_rmi4_of_match_table);
  591. #else
  592. #define synaptics_rmi4_of_match_table NULL
  593. #endif
  594. static struct spi_driver synaptics_rmi4_spi_driver = {
  595. .driver = {
  596. .name = SPI_DRIVER_NAME,
  597. .owner = THIS_MODULE,
  598. .of_match_table = synaptics_rmi4_of_match_table,
  599. },
  600. .probe = synaptics_rmi4_spi_probe,
  601. .remove = synaptics_rmi4_spi_remove,
  602. .id_table = synaptics_rmi4_id_table,
  603. };
  604. int synaptics_rmi4_bus_init(void)
  605. {
  606. return spi_register_driver(&synaptics_rmi4_spi_driver);
  607. }
  608. EXPORT_SYMBOL(synaptics_rmi4_bus_init);
  609. void synaptics_rmi4_bus_exit(void)
  610. {
  611. kfree(buf);
  612. kfree(xfer);
  613. spi_unregister_driver(&synaptics_rmi4_spi_driver);
  614. }
  615. EXPORT_SYMBOL(synaptics_rmi4_bus_exit);
  616. MODULE_AUTHOR("Synaptics, Inc.");
  617. MODULE_DESCRIPTION("Synaptics DSX SPI Bus Support Module");
  618. MODULE_LICENSE("GPL v2");