Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2011-2016 Synaptics Incorporated
4 * Copyright (c) 2011 Unixphere
5 */
6
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/rmi.h>
10#include <linux/slab.h>
11#include <linux/spi/spi.h>
12#include <linux/of.h>
13#include "rmi_driver.h"
14
15#define RMI_SPI_DEFAULT_XFER_BUF_SIZE 64
16
17#define RMI_PAGE_SELECT_REGISTER 0x00FF
18#define RMI_SPI_PAGE(addr) (((addr) >> 8) & 0x80)
19#define RMI_SPI_XFER_SIZE_LIMIT 255
20
21#define BUFFER_SIZE_INCREMENT 32
22
23enum rmi_spi_op {
24 RMI_SPI_WRITE = 0,
25 RMI_SPI_READ,
26 RMI_SPI_V2_READ_UNIFIED,
27 RMI_SPI_V2_READ_SPLIT,
28 RMI_SPI_V2_WRITE,
29};
30
31struct rmi_spi_cmd {
32 enum rmi_spi_op op;
33 u16 addr;
34};
35
36struct rmi_spi_xport {
37 struct rmi_transport_dev xport;
38 struct spi_device *spi;
39
40 struct mutex page_mutex;
41 int page;
42
43 u8 *rx_buf;
44 u8 *tx_buf;
45 int xfer_buf_size;
46
47 struct spi_transfer *rx_xfers;
48 struct spi_transfer *tx_xfers;
49 int rx_xfer_count;
50 int tx_xfer_count;
51};
52
53static int rmi_spi_manage_pools(struct rmi_spi_xport *rmi_spi, int len)
54{
55 struct spi_device *spi = rmi_spi->spi;
56 int buf_size = rmi_spi->xfer_buf_size
57 ? rmi_spi->xfer_buf_size : RMI_SPI_DEFAULT_XFER_BUF_SIZE;
58 struct spi_transfer *xfer_buf;
59 void *buf;
60 void *tmp;
61
62 while (buf_size < len)
63 buf_size *= 2;
64
65 if (buf_size > RMI_SPI_XFER_SIZE_LIMIT)
66 buf_size = RMI_SPI_XFER_SIZE_LIMIT;
67
68 tmp = rmi_spi->rx_buf;
69 buf = devm_kcalloc(&spi->dev, buf_size, 2,
70 GFP_KERNEL | GFP_DMA);
71 if (!buf)
72 return -ENOMEM;
73
74 rmi_spi->rx_buf = buf;
75 rmi_spi->tx_buf = &rmi_spi->rx_buf[buf_size];
76 rmi_spi->xfer_buf_size = buf_size;
77
78 if (tmp)
79 devm_kfree(&spi->dev, tmp);
80
81 if (rmi_spi->xport.pdata.spi_data.read_delay_us)
82 rmi_spi->rx_xfer_count = buf_size;
83 else
84 rmi_spi->rx_xfer_count = 1;
85
86 if (rmi_spi->xport.pdata.spi_data.write_delay_us)
87 rmi_spi->tx_xfer_count = buf_size;
88 else
89 rmi_spi->tx_xfer_count = 1;
90
91 /*
92 * Allocate a pool of spi_transfer buffers for devices which need
93 * per byte delays.
94 */
95 tmp = rmi_spi->rx_xfers;
96 xfer_buf = devm_kcalloc(&spi->dev,
97 rmi_spi->rx_xfer_count + rmi_spi->tx_xfer_count,
98 sizeof(struct spi_transfer),
99 GFP_KERNEL);
100 if (!xfer_buf)
101 return -ENOMEM;
102
103 rmi_spi->rx_xfers = xfer_buf;
104 rmi_spi->tx_xfers = &xfer_buf[rmi_spi->rx_xfer_count];
105
106 if (tmp)
107 devm_kfree(&spi->dev, tmp);
108
109 return 0;
110}
111
112static int rmi_spi_xfer(struct rmi_spi_xport *rmi_spi,
113 const struct rmi_spi_cmd *cmd, const u8 *tx_buf,
114 int tx_len, u8 *rx_buf, int rx_len)
115{
116 struct spi_device *spi = rmi_spi->spi;
117 struct rmi_device_platform_data_spi *spi_data =
118 &rmi_spi->xport.pdata.spi_data;
119 struct spi_message msg;
120 struct spi_transfer *xfer;
121 int ret = 0;
122 int len;
123 int cmd_len = 0;
124 int total_tx_len;
125 int i;
126 u16 addr = cmd->addr;
127
128 spi_message_init(&msg);
129
130 switch (cmd->op) {
131 case RMI_SPI_WRITE:
132 case RMI_SPI_READ:
133 cmd_len += 2;
134 break;
135 case RMI_SPI_V2_READ_UNIFIED:
136 case RMI_SPI_V2_READ_SPLIT:
137 case RMI_SPI_V2_WRITE:
138 cmd_len += 4;
139 break;
140 }
141
142 total_tx_len = cmd_len + tx_len;
143 len = max(total_tx_len, rx_len);
144
145 if (len > RMI_SPI_XFER_SIZE_LIMIT)
146 return -EINVAL;
147
148 if (rmi_spi->xfer_buf_size < len) {
149 ret = rmi_spi_manage_pools(rmi_spi, len);
150 if (ret < 0)
151 return ret;
152 }
153
154 if (addr == 0)
155 /*
156 * SPI needs an address. Use 0x7FF if we want to keep
157 * reading from the last position of the register pointer.
158 */
159 addr = 0x7FF;
160
161 switch (cmd->op) {
162 case RMI_SPI_WRITE:
163 rmi_spi->tx_buf[0] = (addr >> 8);
164 rmi_spi->tx_buf[1] = addr & 0xFF;
165 break;
166 case RMI_SPI_READ:
167 rmi_spi->tx_buf[0] = (addr >> 8) | 0x80;
168 rmi_spi->tx_buf[1] = addr & 0xFF;
169 break;
170 case RMI_SPI_V2_READ_UNIFIED:
171 break;
172 case RMI_SPI_V2_READ_SPLIT:
173 break;
174 case RMI_SPI_V2_WRITE:
175 rmi_spi->tx_buf[0] = 0x40;
176 rmi_spi->tx_buf[1] = (addr >> 8) & 0xFF;
177 rmi_spi->tx_buf[2] = addr & 0xFF;
178 rmi_spi->tx_buf[3] = tx_len;
179 break;
180 }
181
182 if (tx_buf)
183 memcpy(&rmi_spi->tx_buf[cmd_len], tx_buf, tx_len);
184
185 if (rmi_spi->tx_xfer_count > 1) {
186 for (i = 0; i < total_tx_len; i++) {
187 xfer = &rmi_spi->tx_xfers[i];
188 memset(xfer, 0, sizeof(struct spi_transfer));
189 xfer->tx_buf = &rmi_spi->tx_buf[i];
190 xfer->len = 1;
191 xfer->delay.value = spi_data->write_delay_us;
192 xfer->delay.unit = SPI_DELAY_UNIT_USECS;
193 spi_message_add_tail(xfer, &msg);
194 }
195 } else {
196 xfer = rmi_spi->tx_xfers;
197 memset(xfer, 0, sizeof(struct spi_transfer));
198 xfer->tx_buf = rmi_spi->tx_buf;
199 xfer->len = total_tx_len;
200 spi_message_add_tail(xfer, &msg);
201 }
202
203 rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: cmd: %s tx_buf len: %d tx_buf: %*ph\n",
204 __func__, cmd->op == RMI_SPI_WRITE ? "WRITE" : "READ",
205 total_tx_len, total_tx_len, rmi_spi->tx_buf);
206
207 if (rx_buf) {
208 if (rmi_spi->rx_xfer_count > 1) {
209 for (i = 0; i < rx_len; i++) {
210 xfer = &rmi_spi->rx_xfers[i];
211 memset(xfer, 0, sizeof(struct spi_transfer));
212 xfer->rx_buf = &rmi_spi->rx_buf[i];
213 xfer->len = 1;
214 xfer->delay.value = spi_data->read_delay_us;
215 xfer->delay.unit = SPI_DELAY_UNIT_USECS;
216 spi_message_add_tail(xfer, &msg);
217 }
218 } else {
219 xfer = rmi_spi->rx_xfers;
220 memset(xfer, 0, sizeof(struct spi_transfer));
221 xfer->rx_buf = rmi_spi->rx_buf;
222 xfer->len = rx_len;
223 spi_message_add_tail(xfer, &msg);
224 }
225 }
226
227 ret = spi_sync(spi, &msg);
228 if (ret < 0) {
229 dev_err(&spi->dev, "spi xfer failed: %d\n", ret);
230 return ret;
231 }
232
233 if (rx_buf) {
234 memcpy(rx_buf, rmi_spi->rx_buf, rx_len);
235 rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: (%d) %*ph\n",
236 __func__, rx_len, rx_len, rx_buf);
237 }
238
239 return 0;
240}
241
242/*
243 * rmi_set_page - Set RMI page
244 * @xport: The pointer to the rmi_transport_dev struct
245 * @page: The new page address.
246 *
247 * RMI devices have 16-bit addressing, but some of the transport
248 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
249 * a page address at 0xff of every page so we can reliable page addresses
250 * every 256 registers.
251 *
252 * The page_mutex lock must be held when this function is entered.
253 *
254 * Returns zero on success, non-zero on failure.
255 */
256static int rmi_set_page(struct rmi_spi_xport *rmi_spi, u8 page)
257{
258 struct rmi_spi_cmd cmd;
259 int ret;
260
261 cmd.op = RMI_SPI_WRITE;
262 cmd.addr = RMI_PAGE_SELECT_REGISTER;
263
264 ret = rmi_spi_xfer(rmi_spi, &cmd, &page, 1, NULL, 0);
265
266 if (ret)
267 rmi_spi->page = page;
268
269 return ret;
270}
271
272static int rmi_spi_write_block(struct rmi_transport_dev *xport, u16 addr,
273 const void *buf, size_t len)
274{
275 struct rmi_spi_xport *rmi_spi =
276 container_of(xport, struct rmi_spi_xport, xport);
277 struct rmi_spi_cmd cmd;
278 int ret;
279
280 mutex_lock(&rmi_spi->page_mutex);
281
282 if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
283 ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
284 if (ret)
285 goto exit;
286 }
287
288 cmd.op = RMI_SPI_WRITE;
289 cmd.addr = addr;
290
291 ret = rmi_spi_xfer(rmi_spi, &cmd, buf, len, NULL, 0);
292
293exit:
294 mutex_unlock(&rmi_spi->page_mutex);
295 return ret;
296}
297
298static int rmi_spi_read_block(struct rmi_transport_dev *xport, u16 addr,
299 void *buf, size_t len)
300{
301 struct rmi_spi_xport *rmi_spi =
302 container_of(xport, struct rmi_spi_xport, xport);
303 struct rmi_spi_cmd cmd;
304 int ret;
305
306 mutex_lock(&rmi_spi->page_mutex);
307
308 if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
309 ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
310 if (ret)
311 goto exit;
312 }
313
314 cmd.op = RMI_SPI_READ;
315 cmd.addr = addr;
316
317 ret = rmi_spi_xfer(rmi_spi, &cmd, NULL, 0, buf, len);
318
319exit:
320 mutex_unlock(&rmi_spi->page_mutex);
321 return ret;
322}
323
324static const struct rmi_transport_ops rmi_spi_ops = {
325 .write_block = rmi_spi_write_block,
326 .read_block = rmi_spi_read_block,
327};
328
329#ifdef CONFIG_OF
330static int rmi_spi_of_probe(struct spi_device *spi,
331 struct rmi_device_platform_data *pdata)
332{
333 struct device *dev = &spi->dev;
334 int retval;
335
336 retval = rmi_of_property_read_u32(dev,
337 &pdata->spi_data.read_delay_us,
338 "spi-rx-delay-us", 1);
339 if (retval)
340 return retval;
341
342 retval = rmi_of_property_read_u32(dev,
343 &pdata->spi_data.write_delay_us,
344 "spi-tx-delay-us", 1);
345 if (retval)
346 return retval;
347
348 return 0;
349}
350
351static const struct of_device_id rmi_spi_of_match[] = {
352 { .compatible = "syna,rmi4-spi" },
353 {},
354};
355MODULE_DEVICE_TABLE(of, rmi_spi_of_match);
356#else
357static inline int rmi_spi_of_probe(struct spi_device *spi,
358 struct rmi_device_platform_data *pdata)
359{
360 return -ENODEV;
361}
362#endif
363
364static void rmi_spi_unregister_transport(void *data)
365{
366 struct rmi_spi_xport *rmi_spi = data;
367
368 rmi_unregister_transport_device(&rmi_spi->xport);
369}
370
371static int rmi_spi_probe(struct spi_device *spi)
372{
373 struct rmi_spi_xport *rmi_spi;
374 struct rmi_device_platform_data *pdata;
375 struct rmi_device_platform_data *spi_pdata = spi->dev.platform_data;
376 int error;
377
378 if (spi->master->flags & SPI_CONTROLLER_HALF_DUPLEX)
379 return -EINVAL;
380
381 rmi_spi = devm_kzalloc(&spi->dev, sizeof(struct rmi_spi_xport),
382 GFP_KERNEL);
383 if (!rmi_spi)
384 return -ENOMEM;
385
386 pdata = &rmi_spi->xport.pdata;
387
388 if (spi->dev.of_node) {
389 error = rmi_spi_of_probe(spi, pdata);
390 if (error)
391 return error;
392 } else if (spi_pdata) {
393 *pdata = *spi_pdata;
394 }
395
396 if (pdata->spi_data.bits_per_word)
397 spi->bits_per_word = pdata->spi_data.bits_per_word;
398
399 if (pdata->spi_data.mode)
400 spi->mode = pdata->spi_data.mode;
401
402 error = spi_setup(spi);
403 if (error < 0) {
404 dev_err(&spi->dev, "spi_setup failed!\n");
405 return error;
406 }
407
408 pdata->irq = spi->irq;
409
410 rmi_spi->spi = spi;
411 mutex_init(&rmi_spi->page_mutex);
412
413 rmi_spi->xport.dev = &spi->dev;
414 rmi_spi->xport.proto_name = "spi";
415 rmi_spi->xport.ops = &rmi_spi_ops;
416
417 spi_set_drvdata(spi, rmi_spi);
418
419 error = rmi_spi_manage_pools(rmi_spi, RMI_SPI_DEFAULT_XFER_BUF_SIZE);
420 if (error)
421 return error;
422
423 /*
424 * Setting the page to zero will (a) make sure the PSR is in a
425 * known state, and (b) make sure we can talk to the device.
426 */
427 error = rmi_set_page(rmi_spi, 0);
428 if (error) {
429 dev_err(&spi->dev, "Failed to set page select to 0.\n");
430 return error;
431 }
432
433 dev_info(&spi->dev, "registering SPI-connected sensor\n");
434
435 error = rmi_register_transport_device(&rmi_spi->xport);
436 if (error) {
437 dev_err(&spi->dev, "failed to register sensor: %d\n", error);
438 return error;
439 }
440
441 error = devm_add_action_or_reset(&spi->dev,
442 rmi_spi_unregister_transport,
443 rmi_spi);
444 if (error)
445 return error;
446
447 return 0;
448}
449
450static int rmi_spi_suspend(struct device *dev)
451{
452 struct spi_device *spi = to_spi_device(dev);
453 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
454 int ret;
455
456 ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, true);
457 if (ret)
458 dev_warn(dev, "Failed to resume device: %d\n", ret);
459
460 return ret;
461}
462
463static int rmi_spi_resume(struct device *dev)
464{
465 struct spi_device *spi = to_spi_device(dev);
466 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
467 int ret;
468
469 ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, true);
470 if (ret)
471 dev_warn(dev, "Failed to resume device: %d\n", ret);
472
473 return ret;
474}
475
476static int rmi_spi_runtime_suspend(struct device *dev)
477{
478 struct spi_device *spi = to_spi_device(dev);
479 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
480 int ret;
481
482 ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, false);
483 if (ret)
484 dev_warn(dev, "Failed to resume device: %d\n", ret);
485
486 return 0;
487}
488
489static int rmi_spi_runtime_resume(struct device *dev)
490{
491 struct spi_device *spi = to_spi_device(dev);
492 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
493 int ret;
494
495 ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, false);
496 if (ret)
497 dev_warn(dev, "Failed to resume device: %d\n", ret);
498
499 return 0;
500}
501
502static const struct dev_pm_ops rmi_spi_pm = {
503 SYSTEM_SLEEP_PM_OPS(rmi_spi_suspend, rmi_spi_resume)
504 RUNTIME_PM_OPS(rmi_spi_runtime_suspend, rmi_spi_runtime_resume, NULL)
505};
506
507static const struct spi_device_id rmi_id[] = {
508 { "rmi4-spi", 0 },
509 { }
510};
511MODULE_DEVICE_TABLE(spi, rmi_id);
512
513static struct spi_driver rmi_spi_driver = {
514 .driver = {
515 .name = "rmi4_spi",
516 .pm = pm_ptr(&rmi_spi_pm),
517 .of_match_table = of_match_ptr(rmi_spi_of_match),
518 },
519 .id_table = rmi_id,
520 .probe = rmi_spi_probe,
521};
522
523module_spi_driver(rmi_spi_driver);
524
525MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com>");
526MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
527MODULE_DESCRIPTION("RMI SPI driver");
528MODULE_LICENSE("GPL");
1/*
2 * Copyright (c) 2011-2016 Synaptics Incorporated
3 * Copyright (c) 2011 Unixphere
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 */
9
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <linux/rmi.h>
13#include <linux/slab.h>
14#include <linux/spi/spi.h>
15#include <linux/irq.h>
16#include <linux/of.h>
17#include "rmi_driver.h"
18
19#define RMI_SPI_DEFAULT_XFER_BUF_SIZE 64
20
21#define RMI_PAGE_SELECT_REGISTER 0x00FF
22#define RMI_SPI_PAGE(addr) (((addr) >> 8) & 0x80)
23#define RMI_SPI_XFER_SIZE_LIMIT 255
24
25#define BUFFER_SIZE_INCREMENT 32
26
27enum rmi_spi_op {
28 RMI_SPI_WRITE = 0,
29 RMI_SPI_READ,
30 RMI_SPI_V2_READ_UNIFIED,
31 RMI_SPI_V2_READ_SPLIT,
32 RMI_SPI_V2_WRITE,
33};
34
35struct rmi_spi_cmd {
36 enum rmi_spi_op op;
37 u16 addr;
38};
39
40struct rmi_spi_xport {
41 struct rmi_transport_dev xport;
42 struct spi_device *spi;
43
44 struct mutex page_mutex;
45 int page;
46
47 int irq;
48
49 u8 *rx_buf;
50 u8 *tx_buf;
51 int xfer_buf_size;
52
53 struct spi_transfer *rx_xfers;
54 struct spi_transfer *tx_xfers;
55 int rx_xfer_count;
56 int tx_xfer_count;
57};
58
59static int rmi_spi_manage_pools(struct rmi_spi_xport *rmi_spi, int len)
60{
61 struct spi_device *spi = rmi_spi->spi;
62 int buf_size = rmi_spi->xfer_buf_size
63 ? rmi_spi->xfer_buf_size : RMI_SPI_DEFAULT_XFER_BUF_SIZE;
64 struct spi_transfer *xfer_buf;
65 void *buf;
66 void *tmp;
67
68 while (buf_size < len)
69 buf_size *= 2;
70
71 if (buf_size > RMI_SPI_XFER_SIZE_LIMIT)
72 buf_size = RMI_SPI_XFER_SIZE_LIMIT;
73
74 tmp = rmi_spi->rx_buf;
75 buf = devm_kzalloc(&spi->dev, buf_size * 2,
76 GFP_KERNEL | GFP_DMA);
77 if (!buf)
78 return -ENOMEM;
79
80 rmi_spi->rx_buf = buf;
81 rmi_spi->tx_buf = &rmi_spi->rx_buf[buf_size];
82 rmi_spi->xfer_buf_size = buf_size;
83
84 if (tmp)
85 devm_kfree(&spi->dev, tmp);
86
87 if (rmi_spi->xport.pdata.spi_data.read_delay_us)
88 rmi_spi->rx_xfer_count = buf_size;
89 else
90 rmi_spi->rx_xfer_count = 1;
91
92 if (rmi_spi->xport.pdata.spi_data.write_delay_us)
93 rmi_spi->tx_xfer_count = buf_size;
94 else
95 rmi_spi->tx_xfer_count = 1;
96
97 /*
98 * Allocate a pool of spi_transfer buffers for devices which need
99 * per byte delays.
100 */
101 tmp = rmi_spi->rx_xfers;
102 xfer_buf = devm_kzalloc(&spi->dev,
103 (rmi_spi->rx_xfer_count + rmi_spi->tx_xfer_count)
104 * sizeof(struct spi_transfer), GFP_KERNEL);
105 if (!xfer_buf)
106 return -ENOMEM;
107
108 rmi_spi->rx_xfers = xfer_buf;
109 rmi_spi->tx_xfers = &xfer_buf[rmi_spi->rx_xfer_count];
110
111 if (tmp)
112 devm_kfree(&spi->dev, tmp);
113
114 return 0;
115}
116
117static int rmi_spi_xfer(struct rmi_spi_xport *rmi_spi,
118 const struct rmi_spi_cmd *cmd, const u8 *tx_buf,
119 int tx_len, u8 *rx_buf, int rx_len)
120{
121 struct spi_device *spi = rmi_spi->spi;
122 struct rmi_device_platform_data_spi *spi_data =
123 &rmi_spi->xport.pdata.spi_data;
124 struct spi_message msg;
125 struct spi_transfer *xfer;
126 int ret = 0;
127 int len;
128 int cmd_len = 0;
129 int total_tx_len;
130 int i;
131 u16 addr = cmd->addr;
132
133 spi_message_init(&msg);
134
135 switch (cmd->op) {
136 case RMI_SPI_WRITE:
137 case RMI_SPI_READ:
138 cmd_len += 2;
139 break;
140 case RMI_SPI_V2_READ_UNIFIED:
141 case RMI_SPI_V2_READ_SPLIT:
142 case RMI_SPI_V2_WRITE:
143 cmd_len += 4;
144 break;
145 }
146
147 total_tx_len = cmd_len + tx_len;
148 len = max(total_tx_len, rx_len);
149
150 if (len > RMI_SPI_XFER_SIZE_LIMIT)
151 return -EINVAL;
152
153 if (rmi_spi->xfer_buf_size < len)
154 rmi_spi_manage_pools(rmi_spi, len);
155
156 if (addr == 0)
157 /*
158 * SPI needs an address. Use 0x7FF if we want to keep
159 * reading from the last position of the register pointer.
160 */
161 addr = 0x7FF;
162
163 switch (cmd->op) {
164 case RMI_SPI_WRITE:
165 rmi_spi->tx_buf[0] = (addr >> 8);
166 rmi_spi->tx_buf[1] = addr & 0xFF;
167 break;
168 case RMI_SPI_READ:
169 rmi_spi->tx_buf[0] = (addr >> 8) | 0x80;
170 rmi_spi->tx_buf[1] = addr & 0xFF;
171 break;
172 case RMI_SPI_V2_READ_UNIFIED:
173 break;
174 case RMI_SPI_V2_READ_SPLIT:
175 break;
176 case RMI_SPI_V2_WRITE:
177 rmi_spi->tx_buf[0] = 0x40;
178 rmi_spi->tx_buf[1] = (addr >> 8) & 0xFF;
179 rmi_spi->tx_buf[2] = addr & 0xFF;
180 rmi_spi->tx_buf[3] = tx_len;
181 break;
182 }
183
184 if (tx_buf)
185 memcpy(&rmi_spi->tx_buf[cmd_len], tx_buf, tx_len);
186
187 if (rmi_spi->tx_xfer_count > 1) {
188 for (i = 0; i < total_tx_len; i++) {
189 xfer = &rmi_spi->tx_xfers[i];
190 memset(xfer, 0, sizeof(struct spi_transfer));
191 xfer->tx_buf = &rmi_spi->tx_buf[i];
192 xfer->len = 1;
193 xfer->delay_usecs = spi_data->write_delay_us;
194 spi_message_add_tail(xfer, &msg);
195 }
196 } else {
197 xfer = rmi_spi->tx_xfers;
198 memset(xfer, 0, sizeof(struct spi_transfer));
199 xfer->tx_buf = rmi_spi->tx_buf;
200 xfer->len = total_tx_len;
201 spi_message_add_tail(xfer, &msg);
202 }
203
204 rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: cmd: %s tx_buf len: %d tx_buf: %*ph\n",
205 __func__, cmd->op == RMI_SPI_WRITE ? "WRITE" : "READ",
206 total_tx_len, total_tx_len, rmi_spi->tx_buf);
207
208 if (rx_buf) {
209 if (rmi_spi->rx_xfer_count > 1) {
210 for (i = 0; i < rx_len; i++) {
211 xfer = &rmi_spi->rx_xfers[i];
212 memset(xfer, 0, sizeof(struct spi_transfer));
213 xfer->rx_buf = &rmi_spi->rx_buf[i];
214 xfer->len = 1;
215 xfer->delay_usecs = spi_data->read_delay_us;
216 spi_message_add_tail(xfer, &msg);
217 }
218 } else {
219 xfer = rmi_spi->rx_xfers;
220 memset(xfer, 0, sizeof(struct spi_transfer));
221 xfer->rx_buf = rmi_spi->rx_buf;
222 xfer->len = rx_len;
223 spi_message_add_tail(xfer, &msg);
224 }
225 }
226
227 ret = spi_sync(spi, &msg);
228 if (ret < 0) {
229 dev_err(&spi->dev, "spi xfer failed: %d\n", ret);
230 return ret;
231 }
232
233 if (rx_buf) {
234 memcpy(rx_buf, rmi_spi->rx_buf, rx_len);
235 rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: (%d) %*ph\n",
236 __func__, rx_len, rx_len, rx_buf);
237 }
238
239 return 0;
240}
241
242/*
243 * rmi_set_page - Set RMI page
244 * @xport: The pointer to the rmi_transport_dev struct
245 * @page: The new page address.
246 *
247 * RMI devices have 16-bit addressing, but some of the transport
248 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
249 * a page address at 0xff of every page so we can reliable page addresses
250 * every 256 registers.
251 *
252 * The page_mutex lock must be held when this function is entered.
253 *
254 * Returns zero on success, non-zero on failure.
255 */
256static int rmi_set_page(struct rmi_spi_xport *rmi_spi, u8 page)
257{
258 struct rmi_spi_cmd cmd;
259 int ret;
260
261 cmd.op = RMI_SPI_WRITE;
262 cmd.addr = RMI_PAGE_SELECT_REGISTER;
263
264 ret = rmi_spi_xfer(rmi_spi, &cmd, &page, 1, NULL, 0);
265
266 if (ret)
267 rmi_spi->page = page;
268
269 return ret;
270}
271
272static int rmi_spi_write_block(struct rmi_transport_dev *xport, u16 addr,
273 const void *buf, size_t len)
274{
275 struct rmi_spi_xport *rmi_spi =
276 container_of(xport, struct rmi_spi_xport, xport);
277 struct rmi_spi_cmd cmd;
278 int ret;
279
280 mutex_lock(&rmi_spi->page_mutex);
281
282 if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
283 ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
284 if (ret)
285 goto exit;
286 }
287
288 cmd.op = RMI_SPI_WRITE;
289 cmd.addr = addr;
290
291 ret = rmi_spi_xfer(rmi_spi, &cmd, buf, len, NULL, 0);
292
293exit:
294 mutex_unlock(&rmi_spi->page_mutex);
295 return ret;
296}
297
298static int rmi_spi_read_block(struct rmi_transport_dev *xport, u16 addr,
299 void *buf, size_t len)
300{
301 struct rmi_spi_xport *rmi_spi =
302 container_of(xport, struct rmi_spi_xport, xport);
303 struct rmi_spi_cmd cmd;
304 int ret;
305
306 mutex_lock(&rmi_spi->page_mutex);
307
308 if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
309 ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
310 if (ret)
311 goto exit;
312 }
313
314 cmd.op = RMI_SPI_READ;
315 cmd.addr = addr;
316
317 ret = rmi_spi_xfer(rmi_spi, &cmd, NULL, 0, buf, len);
318
319exit:
320 mutex_unlock(&rmi_spi->page_mutex);
321 return ret;
322}
323
324static const struct rmi_transport_ops rmi_spi_ops = {
325 .write_block = rmi_spi_write_block,
326 .read_block = rmi_spi_read_block,
327};
328
329static irqreturn_t rmi_spi_irq(int irq, void *dev_id)
330{
331 struct rmi_spi_xport *rmi_spi = dev_id;
332 struct rmi_device *rmi_dev = rmi_spi->xport.rmi_dev;
333 int ret;
334
335 ret = rmi_process_interrupt_requests(rmi_dev);
336 if (ret)
337 rmi_dbg(RMI_DEBUG_XPORT, &rmi_dev->dev,
338 "Failed to process interrupt request: %d\n", ret);
339
340 return IRQ_HANDLED;
341}
342
343static int rmi_spi_init_irq(struct spi_device *spi)
344{
345 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
346 int irq_flags = irqd_get_trigger_type(irq_get_irq_data(rmi_spi->irq));
347 int ret;
348
349 if (!irq_flags)
350 irq_flags = IRQF_TRIGGER_LOW;
351
352 ret = devm_request_threaded_irq(&spi->dev, rmi_spi->irq, NULL,
353 rmi_spi_irq, irq_flags | IRQF_ONESHOT,
354 dev_name(&spi->dev), rmi_spi);
355 if (ret < 0) {
356 dev_warn(&spi->dev, "Failed to register interrupt %d\n",
357 rmi_spi->irq);
358 return ret;
359 }
360
361 return 0;
362}
363
364#ifdef CONFIG_OF
365static int rmi_spi_of_probe(struct spi_device *spi,
366 struct rmi_device_platform_data *pdata)
367{
368 struct device *dev = &spi->dev;
369 int retval;
370
371 retval = rmi_of_property_read_u32(dev,
372 &pdata->spi_data.read_delay_us,
373 "spi-rx-delay-us", 1);
374 if (retval)
375 return retval;
376
377 retval = rmi_of_property_read_u32(dev,
378 &pdata->spi_data.write_delay_us,
379 "spi-tx-delay-us", 1);
380 if (retval)
381 return retval;
382
383 return 0;
384}
385
386static const struct of_device_id rmi_spi_of_match[] = {
387 { .compatible = "syna,rmi4-spi" },
388 {},
389};
390MODULE_DEVICE_TABLE(of, rmi_spi_of_match);
391#else
392static inline int rmi_spi_of_probe(struct spi_device *spi,
393 struct rmi_device_platform_data *pdata)
394{
395 return -ENODEV;
396}
397#endif
398
399static int rmi_spi_probe(struct spi_device *spi)
400{
401 struct rmi_spi_xport *rmi_spi;
402 struct rmi_device_platform_data *pdata;
403 struct rmi_device_platform_data *spi_pdata = spi->dev.platform_data;
404 int retval;
405
406 if (spi->master->flags & SPI_MASTER_HALF_DUPLEX)
407 return -EINVAL;
408
409 rmi_spi = devm_kzalloc(&spi->dev, sizeof(struct rmi_spi_xport),
410 GFP_KERNEL);
411 if (!rmi_spi)
412 return -ENOMEM;
413
414 pdata = &rmi_spi->xport.pdata;
415
416 if (spi->dev.of_node) {
417 retval = rmi_spi_of_probe(spi, pdata);
418 if (retval)
419 return retval;
420 } else if (spi_pdata) {
421 *pdata = *spi_pdata;
422 }
423
424 if (pdata->spi_data.bits_per_word)
425 spi->bits_per_word = pdata->spi_data.bits_per_word;
426
427 if (pdata->spi_data.mode)
428 spi->mode = pdata->spi_data.mode;
429
430 retval = spi_setup(spi);
431 if (retval < 0) {
432 dev_err(&spi->dev, "spi_setup failed!\n");
433 return retval;
434 }
435
436 if (spi->irq > 0)
437 rmi_spi->irq = spi->irq;
438
439 rmi_spi->spi = spi;
440 mutex_init(&rmi_spi->page_mutex);
441
442 rmi_spi->xport.dev = &spi->dev;
443 rmi_spi->xport.proto_name = "spi";
444 rmi_spi->xport.ops = &rmi_spi_ops;
445
446 spi_set_drvdata(spi, rmi_spi);
447
448 retval = rmi_spi_manage_pools(rmi_spi, RMI_SPI_DEFAULT_XFER_BUF_SIZE);
449 if (retval)
450 return retval;
451
452 /*
453 * Setting the page to zero will (a) make sure the PSR is in a
454 * known state, and (b) make sure we can talk to the device.
455 */
456 retval = rmi_set_page(rmi_spi, 0);
457 if (retval) {
458 dev_err(&spi->dev, "Failed to set page select to 0.\n");
459 return retval;
460 }
461
462 retval = rmi_register_transport_device(&rmi_spi->xport);
463 if (retval) {
464 dev_err(&spi->dev, "failed to register transport.\n");
465 return retval;
466 }
467
468 retval = rmi_spi_init_irq(spi);
469 if (retval < 0)
470 return retval;
471
472 dev_info(&spi->dev, "registered RMI SPI driver\n");
473 return 0;
474}
475
476static int rmi_spi_remove(struct spi_device *spi)
477{
478 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
479
480 rmi_unregister_transport_device(&rmi_spi->xport);
481
482 return 0;
483}
484
485#ifdef CONFIG_PM_SLEEP
486static int rmi_spi_suspend(struct device *dev)
487{
488 struct spi_device *spi = to_spi_device(dev);
489 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
490 int ret;
491
492 ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev);
493 if (ret)
494 dev_warn(dev, "Failed to resume device: %d\n", ret);
495
496 disable_irq(rmi_spi->irq);
497 if (device_may_wakeup(&spi->dev)) {
498 ret = enable_irq_wake(rmi_spi->irq);
499 if (!ret)
500 dev_warn(dev, "Failed to enable irq for wake: %d\n",
501 ret);
502 }
503 return ret;
504}
505
506static int rmi_spi_resume(struct device *dev)
507{
508 struct spi_device *spi = to_spi_device(dev);
509 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
510 int ret;
511
512 enable_irq(rmi_spi->irq);
513 if (device_may_wakeup(&spi->dev)) {
514 ret = disable_irq_wake(rmi_spi->irq);
515 if (!ret)
516 dev_warn(dev, "Failed to disable irq for wake: %d\n",
517 ret);
518 }
519
520 ret = rmi_driver_resume(rmi_spi->xport.rmi_dev);
521 if (ret)
522 dev_warn(dev, "Failed to resume device: %d\n", ret);
523
524 return ret;
525}
526#endif
527
528#ifdef CONFIG_PM
529static int rmi_spi_runtime_suspend(struct device *dev)
530{
531 struct spi_device *spi = to_spi_device(dev);
532 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
533 int ret;
534
535 ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev);
536 if (ret)
537 dev_warn(dev, "Failed to resume device: %d\n", ret);
538
539 disable_irq(rmi_spi->irq);
540
541 return 0;
542}
543
544static int rmi_spi_runtime_resume(struct device *dev)
545{
546 struct spi_device *spi = to_spi_device(dev);
547 struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
548 int ret;
549
550 enable_irq(rmi_spi->irq);
551
552 ret = rmi_driver_resume(rmi_spi->xport.rmi_dev);
553 if (ret)
554 dev_warn(dev, "Failed to resume device: %d\n", ret);
555
556 return 0;
557}
558#endif
559
560static const struct dev_pm_ops rmi_spi_pm = {
561 SET_SYSTEM_SLEEP_PM_OPS(rmi_spi_suspend, rmi_spi_resume)
562 SET_RUNTIME_PM_OPS(rmi_spi_runtime_suspend, rmi_spi_runtime_resume,
563 NULL)
564};
565
566static const struct spi_device_id rmi_id[] = {
567 { "rmi4_spi", 0 },
568 { }
569};
570MODULE_DEVICE_TABLE(spi, rmi_id);
571
572static struct spi_driver rmi_spi_driver = {
573 .driver = {
574 .name = "rmi4_spi",
575 .pm = &rmi_spi_pm,
576 .of_match_table = of_match_ptr(rmi_spi_of_match),
577 },
578 .id_table = rmi_id,
579 .probe = rmi_spi_probe,
580 .remove = rmi_spi_remove,
581};
582
583module_spi_driver(rmi_spi_driver);
584
585MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com>");
586MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
587MODULE_DESCRIPTION("RMI SPI driver");
588MODULE_LICENSE("GPL");
589MODULE_VERSION(RMI_DRIVER_VERSION);