aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/devicetree/bindings/spi/spi-mt65xx.txt9
-rw-r--r--drivers/spi/Kconfig9
-rw-r--r--drivers/spi/Makefile1
-rw-r--r--drivers/spi/spi-lm70llp.c43
-rw-r--r--drivers/spi/spi-loopback-test.c1005
-rw-r--r--drivers/spi/spi-mt65xx.c36
-rw-r--r--drivers/spi/spi-omap2-mcspi.c31
-rw-r--r--drivers/spi/spi-test.h136
-rw-r--r--include/linux/spi/spi.h7
9 files changed, 1227 insertions, 50 deletions
diff --git a/Documentation/devicetree/bindings/spi/spi-mt65xx.txt b/Documentation/devicetree/bindings/spi/spi-mt65xx.txt
index ce363c923f44..e43f4cf4cf35 100644
--- a/Documentation/devicetree/bindings/spi/spi-mt65xx.txt
+++ b/Documentation/devicetree/bindings/spi/spi-mt65xx.txt
@@ -2,9 +2,10 @@ Binding for MTK SPI controller
2 2
3Required properties: 3Required properties:
4- compatible: should be one of the following. 4- compatible: should be one of the following.
5 - mediatek,mt8173-spi: for mt8173 platforms 5 - mediatek,mt2701-spi: for mt2701 platforms
6 - mediatek,mt8135-spi: for mt8135 platforms
7 - mediatek,mt6589-spi: for mt6589 platforms 6 - mediatek,mt6589-spi: for mt6589 platforms
7 - mediatek,mt8135-spi: for mt8135 platforms
8 - mediatek,mt8173-spi: for mt8173 platforms
8 9
9- #address-cells: should be 1. 10- #address-cells: should be 1.
10 11
@@ -29,10 +30,10 @@ Required properties:
29 muxes clock, and "spi-clk" for the clock gate. 30 muxes clock, and "spi-clk" for the clock gate.
30 31
31Optional properties: 32Optional properties:
32-cs-gpios: see spi-bus.txt, only required for MT8173. 33-cs-gpios: see spi-bus.txt.
33 34
34- mediatek,pad-select: specify which pins group(ck/mi/mo/cs) spi 35- mediatek,pad-select: specify which pins group(ck/mi/mo/cs) spi
35 controller used. This is a array, the element value should be 0~3, 36 controller used. This is an array, the element value should be 0~3,
36 only required for MT8173. 37 only required for MT8173.
37 0: specify GPIO69,70,71,72 for spi pins. 38 0: specify GPIO69,70,71,72 for spi pins.
38 1: specify GPIO102,103,104,105 for spi pins. 39 1: specify GPIO102,103,104,105 for spi pins.
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 8b9c2a38d1cc..0876d5953797 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -689,6 +689,15 @@ config SPI_SPIDEV
689 Note that this application programming interface is EXPERIMENTAL 689 Note that this application programming interface is EXPERIMENTAL
690 and hence SUBJECT TO CHANGE WITHOUT NOTICE while it stabilizes. 690 and hence SUBJECT TO CHANGE WITHOUT NOTICE while it stabilizes.
691 691
692config SPI_LOOPBACK_TEST
693 tristate "spi loopback test framework support"
694 depends on m
695 help
696 This enables the SPI loopback testing framework driver
697
698 primarily used for development of spi_master drivers
699 and to detect regressions
700
692config SPI_TLE62X0 701config SPI_TLE62X0
693 tristate "Infineon TLE62X0 (for power switching)" 702 tristate "Infineon TLE62X0 (for power switching)"
694 depends on SYSFS 703 depends on SYSFS
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index 31fb7fb2a0b6..8991ffce6e12 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -8,6 +8,7 @@ ccflags-$(CONFIG_SPI_DEBUG) := -DDEBUG
8# config declarations into driver model code 8# config declarations into driver model code
9obj-$(CONFIG_SPI_MASTER) += spi.o 9obj-$(CONFIG_SPI_MASTER) += spi.o
10obj-$(CONFIG_SPI_SPIDEV) += spidev.o 10obj-$(CONFIG_SPI_SPIDEV) += spidev.o
11obj-$(CONFIG_SPI_LOOPBACK_TEST) += spi-loopback-test.o
11 12
12# SPI master controller drivers (bus) 13# SPI master controller drivers (bus)
13obj-$(CONFIG_SPI_ALTERA) += spi-altera.o 14obj-$(CONFIG_SPI_ALTERA) += spi-altera.o
diff --git a/drivers/spi/spi-lm70llp.c b/drivers/spi/spi-lm70llp.c
index ba72347cb99d..61ee0f4269ae 100644
--- a/drivers/spi/spi-lm70llp.c
+++ b/drivers/spi/spi-lm70llp.c
@@ -14,6 +14,8 @@
14 * GNU General Public License for more details. 14 * GNU General Public License for more details.
15 */ 15 */
16 16
17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
17#include <linux/init.h> 19#include <linux/init.h>
18#include <linux/module.h> 20#include <linux/module.h>
19#include <linux/kernel.h> 21#include <linux/kernel.h>
@@ -23,11 +25,9 @@
23#include <linux/sysfs.h> 25#include <linux/sysfs.h>
24#include <linux/workqueue.h> 26#include <linux/workqueue.h>
25 27
26
27#include <linux/spi/spi.h> 28#include <linux/spi/spi.h>
28#include <linux/spi/spi_bitbang.h> 29#include <linux/spi/spi_bitbang.h>
29 30
30
31/* 31/*
32 * The LM70 communicates with a host processor using a 3-wire variant of 32 * The LM70 communicates with a host processor using a 3-wire variant of
33 * the SPI/Microwire bus interface. This driver specifically supports an 33 * the SPI/Microwire bus interface. This driver specifically supports an
@@ -88,7 +88,6 @@ struct spi_lm70llp {
88/* REVISIT : ugly global ; provides "exclusive open" facility */ 88/* REVISIT : ugly global ; provides "exclusive open" facility */
89static struct spi_lm70llp *lm70llp; 89static struct spi_lm70llp *lm70llp;
90 90
91
92/*-------------------------------------------------------------------*/ 91/*-------------------------------------------------------------------*/
93 92
94static inline struct spi_lm70llp *spidev_to_pp(struct spi_device *spi) 93static inline struct spi_lm70llp *spidev_to_pp(struct spi_device *spi)
@@ -122,12 +121,14 @@ static inline void assertCS(struct spi_lm70llp *pp)
122static inline void clkHigh(struct spi_lm70llp *pp) 121static inline void clkHigh(struct spi_lm70llp *pp)
123{ 122{
124 u8 data = parport_read_data(pp->port); 123 u8 data = parport_read_data(pp->port);
124
125 parport_write_data(pp->port, data | SCLK); 125 parport_write_data(pp->port, data | SCLK);
126} 126}
127 127
128static inline void clkLow(struct spi_lm70llp *pp) 128static inline void clkLow(struct spi_lm70llp *pp)
129{ 129{
130 u8 data = parport_read_data(pp->port); 130 u8 data = parport_read_data(pp->port);
131
131 parport_write_data(pp->port, data & ~SCLK); 132 parport_write_data(pp->port, data & ~SCLK);
132} 133}
133 134
@@ -166,8 +167,10 @@ static inline void setmosi(struct spi_device *s, int is_on)
166static inline int getmiso(struct spi_device *s) 167static inline int getmiso(struct spi_device *s)
167{ 168{
168 struct spi_lm70llp *pp = spidev_to_pp(s); 169 struct spi_lm70llp *pp = spidev_to_pp(s);
169 return ((SIO == (parport_read_status(pp->port) & SIO)) ? 0 : 1 ); 170
171 return ((SIO == (parport_read_status(pp->port) & SIO)) ? 0 : 1);
170} 172}
173
171/*--------------------------------------------------------------------*/ 174/*--------------------------------------------------------------------*/
172 175
173#include "spi-bitbang-txrx.h" 176#include "spi-bitbang-txrx.h"
@@ -196,11 +199,10 @@ static void spi_lm70llp_attach(struct parport *p)
196 struct spi_lm70llp *pp; 199 struct spi_lm70llp *pp;
197 struct spi_master *master; 200 struct spi_master *master;
198 int status; 201 int status;
202 struct pardev_cb lm70llp_cb;
199 203
200 if (lm70llp) { 204 if (lm70llp) {
201 printk(KERN_WARNING 205 pr_warn("spi_lm70llp instance already loaded. Aborting.\n");
202 "%s: spi_lm70llp instance already loaded. Aborting.\n",
203 DRVNAME);
204 return; 206 return;
205 } 207 }
206 208
@@ -227,9 +229,11 @@ static void spi_lm70llp_attach(struct parport *p)
227 * Parport hookup 229 * Parport hookup
228 */ 230 */
229 pp->port = p; 231 pp->port = p;
230 pd = parport_register_device(p, DRVNAME, 232 memset(&lm70llp_cb, 0, sizeof(lm70llp_cb));
231 NULL, NULL, NULL, 233 lm70llp_cb.private = pp;
232 PARPORT_FLAG_EXCL, pp); 234 lm70llp_cb.flags = PARPORT_FLAG_EXCL;
235 pd = parport_register_dev_model(p, DRVNAME, &lm70llp_cb, 0);
236
233 if (!pd) { 237 if (!pd) {
234 status = -ENOMEM; 238 status = -ENOMEM;
235 goto out_free_master; 239 goto out_free_master;
@@ -245,9 +249,8 @@ static void spi_lm70llp_attach(struct parport *p)
245 */ 249 */
246 status = spi_bitbang_start(&pp->bitbang); 250 status = spi_bitbang_start(&pp->bitbang);
247 if (status < 0) { 251 if (status < 0) {
248 printk(KERN_WARNING 252 dev_warn(&pd->dev, "spi_bitbang_start failed with status %d\n",
249 "%s: spi_bitbang_start failed with status %d\n", 253 status);
250 DRVNAME, status);
251 goto out_off_and_release; 254 goto out_off_and_release;
252 } 255 }
253 256
@@ -272,9 +275,9 @@ static void spi_lm70llp_attach(struct parport *p)
272 pp->spidev_lm70 = spi_new_device(pp->bitbang.master, &pp->info); 275 pp->spidev_lm70 = spi_new_device(pp->bitbang.master, &pp->info);
273 if (pp->spidev_lm70) 276 if (pp->spidev_lm70)
274 dev_dbg(&pp->spidev_lm70->dev, "spidev_lm70 at %s\n", 277 dev_dbg(&pp->spidev_lm70->dev, "spidev_lm70 at %s\n",
275 dev_name(&pp->spidev_lm70->dev)); 278 dev_name(&pp->spidev_lm70->dev));
276 else { 279 else {
277 printk(KERN_WARNING "%s: spi_new_device failed\n", DRVNAME); 280 dev_warn(&pd->dev, "spi_new_device failed\n");
278 status = -ENODEV; 281 status = -ENODEV;
279 goto out_bitbang_stop; 282 goto out_bitbang_stop;
280 } 283 }
@@ -293,9 +296,9 @@ out_off_and_release:
293out_parport_unreg: 296out_parport_unreg:
294 parport_unregister_device(pd); 297 parport_unregister_device(pd);
295out_free_master: 298out_free_master:
296 (void) spi_master_put(master); 299 spi_master_put(master);
297out_fail: 300out_fail:
298 pr_info("%s: spi_lm70llp probe fail, status %d\n", DRVNAME, status); 301 pr_info("spi_lm70llp probe fail, status %d\n", status);
299} 302}
300 303
301static void spi_lm70llp_detach(struct parport *p) 304static void spi_lm70llp_detach(struct parport *p)
@@ -314,16 +317,16 @@ static void spi_lm70llp_detach(struct parport *p)
314 parport_release(pp->pd); 317 parport_release(pp->pd);
315 parport_unregister_device(pp->pd); 318 parport_unregister_device(pp->pd);
316 319
317 (void) spi_master_put(pp->bitbang.master); 320 spi_master_put(pp->bitbang.master);
318 321
319 lm70llp = NULL; 322 lm70llp = NULL;
320} 323}
321 324
322
323static struct parport_driver spi_lm70llp_drv = { 325static struct parport_driver spi_lm70llp_drv = {
324 .name = DRVNAME, 326 .name = DRVNAME,
325 .attach = spi_lm70llp_attach, 327 .match_port = spi_lm70llp_attach,
326 .detach = spi_lm70llp_detach, 328 .detach = spi_lm70llp_detach,
329 .devmodel = true,
327}; 330};
328 331
329static int __init init_spi_lm70llp(void) 332static int __init init_spi_lm70llp(void)
diff --git a/drivers/spi/spi-loopback-test.c b/drivers/spi/spi-loopback-test.c
new file mode 100644
index 000000000000..894616f687b0
--- /dev/null
+++ b/drivers/spi/spi-loopback-test.c
@@ -0,0 +1,1005 @@
1/*
2 * linux/drivers/spi/spi-loopback-test.c
3 *
4 * (c) Martin Sperl <kernel@martin.sperl.org>
5 *
6 * Loopback test driver to test several typical spi_message conditions
7 * that a spi_master driver may encounter
8 * this can also get used for regression testing
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
21#include <linux/delay.h>
22#include <linux/kernel.h>
23#include <linux/list.h>
24#include <linux/list_sort.h>
25#include <linux/module.h>
26#include <linux/of_device.h>
27#include <linux/printk.h>
28#include <linux/spi/spi.h>
29
30#include "spi-test.h"
31
32/* flag to only simulate transfers */
33int simulate_only;
34module_param(simulate_only, int, 0);
35MODULE_PARM_DESC(simulate_only, "if not 0 do not execute the spi message");
36
37/* dump spi messages */
38int dump_messages;
39module_param(dump_messages, int, 0);
40MODULE_PARM_DESC(dump_messages,
41 "=1 dump the basic spi_message_structure, " \
42 "=2 dump the spi_message_structure including data, " \
43 "=3 dump the spi_message structure before and after execution");
44/* the device is jumpered for loopback - enabling some rx_buf tests */
45int loopback;
46module_param(loopback, int, 0);
47MODULE_PARM_DESC(loopback,
48 "if set enable loopback mode, where the rx_buf " \
49 "is checked to match tx_buf after the spi_message " \
50 "is executed");
51
52/* run only a specific test */
53int run_only_test = -1;
54module_param(run_only_test, int, 0);
55MODULE_PARM_DESC(run_only_test,
56 "only run the test with this number (0-based !)");
57
58/* the actual tests to execute */
59static struct spi_test spi_tests[] = {
60 {
61 .description = "tx/rx-transfer - start of page",
62 .fill_option = FILL_COUNT_8,
63 .iterate_len = { ITERATE_MAX_LEN },
64 .iterate_tx_align = ITERATE_ALIGN,
65 .iterate_rx_align = ITERATE_ALIGN,
66 .transfers = {
67 {
68 .len = 1,
69 .tx_buf = TX(0),
70 .rx_buf = RX(0),
71 },
72 },
73 },
74 {
75 .description = "tx/rx-transfer - crossing PAGE_SIZE",
76 .fill_option = FILL_COUNT_8,
77 .iterate_len = { ITERATE_MAX_LEN },
78 .iterate_tx_align = ITERATE_ALIGN,
79 .iterate_rx_align = ITERATE_ALIGN,
80 .transfers = {
81 {
82 .len = 1,
83 .tx_buf = TX(PAGE_SIZE - 4),
84 .rx_buf = RX(PAGE_SIZE - 4),
85 },
86 },
87 },
88 {
89 .description = "tx-transfer - only",
90 .fill_option = FILL_COUNT_8,
91 .iterate_len = { ITERATE_MAX_LEN },
92 .iterate_tx_align = ITERATE_ALIGN,
93 .transfers = {
94 {
95 .len = 1,
96 .tx_buf = TX(0),
97 },
98 },
99 },
100 {
101 .description = "rx-transfer - only",
102 .fill_option = FILL_COUNT_8,
103 .iterate_len = { ITERATE_MAX_LEN },
104 .iterate_rx_align = ITERATE_ALIGN,
105 .transfers = {
106 {
107 .len = 1,
108 .rx_buf = RX(0),
109 },
110 },
111 },
112 {
113 .description = "two tx-transfers - alter both",
114 .fill_option = FILL_COUNT_8,
115 .iterate_len = { ITERATE_LEN },
116 .iterate_tx_align = ITERATE_ALIGN,
117 .iterate_transfer_mask = BIT(0) | BIT(1),
118 .transfers = {
119 {
120 .len = 1,
121 .tx_buf = TX(0),
122 },
123 {
124 .len = 1,
125 /* this is why we cant use ITERATE_MAX_LEN */
126 .tx_buf = TX(SPI_TEST_MAX_SIZE_HALF),
127 },
128 },
129 },
130 {
131 .description = "two tx-transfers - alter first",
132 .fill_option = FILL_COUNT_8,
133 .iterate_len = { ITERATE_MAX_LEN },
134 .iterate_tx_align = ITERATE_ALIGN,
135 .iterate_transfer_mask = BIT(1),
136 .transfers = {
137 {
138 .len = 1,
139 .tx_buf = TX(64),
140 },
141 {
142 .len = 1,
143 .tx_buf = TX(0),
144 },
145 },
146 },
147 {
148 .description = "two tx-transfers - alter second",
149 .fill_option = FILL_COUNT_8,
150 .iterate_len = { ITERATE_MAX_LEN },
151 .iterate_tx_align = ITERATE_ALIGN,
152 .iterate_transfer_mask = BIT(0),
153 .transfers = {
154 {
155 .len = 16,
156 .tx_buf = TX(0),
157 },
158 {
159 .len = 1,
160 .tx_buf = TX(64),
161 },
162 },
163 },
164 {
165 .description = "two transfers tx then rx - alter both",
166 .fill_option = FILL_COUNT_8,
167 .iterate_len = { ITERATE_MAX_LEN },
168 .iterate_tx_align = ITERATE_ALIGN,
169 .iterate_transfer_mask = BIT(0) | BIT(1),
170 .transfers = {
171 {
172 .len = 1,
173 .tx_buf = TX(0),
174 },
175 {
176 .len = 1,
177 .rx_buf = RX(0),
178 },
179 },
180 },
181 {
182 .description = "two transfers tx then rx - alter tx",
183 .fill_option = FILL_COUNT_8,
184 .iterate_len = { ITERATE_MAX_LEN },
185 .iterate_tx_align = ITERATE_ALIGN,
186 .iterate_transfer_mask = BIT(0),
187 .transfers = {
188 {
189 .len = 1,
190 .tx_buf = TX(0),
191 },
192 {
193 .len = 1,
194 .rx_buf = RX(0),
195 },
196 },
197 },
198 {
199 .description = "two transfers tx then rx - alter rx",
200 .fill_option = FILL_COUNT_8,
201 .iterate_len = { ITERATE_MAX_LEN },
202 .iterate_tx_align = ITERATE_ALIGN,
203 .iterate_transfer_mask = BIT(1),
204 .transfers = {
205 {
206 .len = 1,
207 .tx_buf = TX(0),
208 },
209 {
210 .len = 1,
211 .rx_buf = RX(0),
212 },
213 },
214 },
215 {
216 .description = "two tx+rx transfers - alter both",
217 .fill_option = FILL_COUNT_8,
218 .iterate_len = { ITERATE_LEN },
219 .iterate_tx_align = ITERATE_ALIGN,
220 .iterate_transfer_mask = BIT(0) | BIT(1),
221 .transfers = {
222 {
223 .len = 1,
224 .tx_buf = TX(0),
225 .rx_buf = RX(0),
226 },
227 {
228 .len = 1,
229 /* making sure we align without overwrite
230 * the reason we can not use ITERATE_MAX_LEN
231 */
232 .tx_buf = TX(SPI_TEST_MAX_SIZE_HALF),
233 .rx_buf = RX(SPI_TEST_MAX_SIZE_HALF),
234 },
235 },
236 },
237 {
238 .description = "two tx+rx transfers - alter first",
239 .fill_option = FILL_COUNT_8,
240 .iterate_len = { ITERATE_MAX_LEN },
241 .iterate_tx_align = ITERATE_ALIGN,
242 .iterate_transfer_mask = BIT(0),
243 .transfers = {
244 {
245 .len = 1,
246 /* making sure we align without overwrite */
247 .tx_buf = TX(1024),
248 .rx_buf = RX(1024),
249 },
250 {
251 .len = 1,
252 /* making sure we align without overwrite */
253 .tx_buf = TX(0),
254 .rx_buf = RX(0),
255 },
256 },
257 },
258 {
259 .description = "two tx+rx transfers - alter second",
260 .fill_option = FILL_COUNT_8,
261 .iterate_len = { ITERATE_MAX_LEN },
262 .iterate_tx_align = ITERATE_ALIGN,
263 .iterate_transfer_mask = BIT(1),
264 .transfers = {
265 {
266 .len = 1,
267 .tx_buf = TX(0),
268 .rx_buf = RX(0),
269 },
270 {
271 .len = 1,
272 /* making sure we align without overwrite */
273 .tx_buf = TX(1024),
274 .rx_buf = RX(1024),
275 },
276 },
277 },
278
279 { /* end of tests sequence */ }
280};
281
282static int spi_loopback_test_probe(struct spi_device *spi)
283{
284 int ret;
285
286 dev_info(&spi->dev, "Executing spi-loopback-tests\n");
287
288 ret = spi_test_run_tests(spi, spi_tests);
289
290 dev_info(&spi->dev, "Finished spi-loopback-tests with return: %i\n",
291 ret);
292
293 return ret;
294}
295
296/* non const match table to permit to change via a module parameter */
297static struct of_device_id spi_loopback_test_of_match[] = {
298 { .compatible = "linux,spi-loopback-test", },
299 { }
300};
301
302/* allow to override the compatible string via a module_parameter */
303module_param_string(compatible, spi_loopback_test_of_match[0].compatible,
304 sizeof(spi_loopback_test_of_match[0].compatible),
305 0000);
306
307MODULE_DEVICE_TABLE(of, spi_loopback_test_of_match);
308
309static struct spi_driver spi_loopback_test_driver = {
310 .driver = {
311 .name = "spi-loopback-test",
312 .owner = THIS_MODULE,
313 .of_match_table = spi_loopback_test_of_match,
314 },
315 .probe = spi_loopback_test_probe,
316};
317
318module_spi_driver(spi_loopback_test_driver);
319
320MODULE_AUTHOR("Martin Sperl <kernel@martin.sperl.org>");
321MODULE_DESCRIPTION("test spi_driver to check core functionality");
322MODULE_LICENSE("GPL");
323
324/*-------------------------------------------------------------------------*/
325
326/* spi_test implementation */
327
328#define RANGE_CHECK(ptr, plen, start, slen) \
329 ((ptr >= start) && (ptr + plen <= start + slen))
330
331/* we allocate one page more, to allow for offsets */
332#define SPI_TEST_MAX_SIZE_PLUS (SPI_TEST_MAX_SIZE + PAGE_SIZE)
333
334static void spi_test_print_hex_dump(char *pre, const void *ptr, size_t len)
335{
336 /* limit the hex_dump */
337 if (len < 1024) {
338 print_hex_dump(KERN_INFO, pre,
339 DUMP_PREFIX_OFFSET, 16, 1,
340 ptr, len, 0);
341 return;
342 }
343 /* print head */
344 print_hex_dump(KERN_INFO, pre,
345 DUMP_PREFIX_OFFSET, 16, 1,
346 ptr, 512, 0);
347 /* print tail */
348 pr_info("%s truncated - continuing at offset %04zx\n",
349 pre, len - 512);
350 print_hex_dump(KERN_INFO, pre,
351 DUMP_PREFIX_OFFSET, 16, 1,
352 ptr + (len - 512), 512, 0);
353}
354
355static void spi_test_dump_message(struct spi_device *spi,
356 struct spi_message *msg,
357 bool dump_data)
358{
359 struct spi_transfer *xfer;
360 int i;
361 u8 b;
362
363 dev_info(&spi->dev, " spi_msg@%pK\n", msg);
364 if (msg->status)
365 dev_info(&spi->dev, " status: %i\n",
366 msg->status);
367 dev_info(&spi->dev, " frame_length: %i\n",
368 msg->frame_length);
369 dev_info(&spi->dev, " actual_length: %i\n",
370 msg->actual_length);
371
372 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
373 dev_info(&spi->dev, " spi_transfer@%pK\n", xfer);
374 dev_info(&spi->dev, " len: %i\n", xfer->len);
375 dev_info(&spi->dev, " tx_buf: %pK\n", xfer->tx_buf);
376 if (dump_data && xfer->tx_buf)
377 spi_test_print_hex_dump(" TX: ",
378 xfer->tx_buf,
379 xfer->len);
380
381 dev_info(&spi->dev, " rx_buf: %pK\n", xfer->rx_buf);
382 if (dump_data && xfer->rx_buf)
383 spi_test_print_hex_dump(" RX: ",
384 xfer->rx_buf,
385 xfer->len);
386 /* check for unwritten test pattern on rx_buf */
387 if (xfer->rx_buf) {
388 for (i = 0 ; i < xfer->len ; i++) {
389 b = ((u8 *)xfer->rx_buf)[xfer->len - 1 - i];
390 if (b != SPI_TEST_PATTERN_UNWRITTEN)
391 break;
392 }
393 if (i)
394 dev_info(&spi->dev,
395 " rx_buf filled with %02x starts at offset: %i\n",
396 SPI_TEST_PATTERN_UNWRITTEN,
397 xfer->len - i);
398 }
399 }
400}
401
402struct rx_ranges {
403 struct list_head list;
404 u8 *start;
405 u8 *end;
406};
407
408int rx_ranges_cmp(void *priv, struct list_head *a, struct list_head *b)
409{
410 struct rx_ranges *rx_a = list_entry(a, struct rx_ranges, list);
411 struct rx_ranges *rx_b = list_entry(b, struct rx_ranges, list);
412
413 if (rx_a->start > rx_b->start)
414 return 1;
415 if (rx_a->start < rx_b->start)
416 return -1;
417 return 0;
418}
419
420static int spi_check_rx_ranges(struct spi_device *spi,
421 struct spi_message *msg,
422 void *rx)
423{
424 struct spi_transfer *xfer;
425 struct rx_ranges ranges[SPI_TEST_MAX_TRANSFERS], *r;
426 int i = 0;
427 LIST_HEAD(ranges_list);
428 u8 *addr;
429 int ret = 0;
430
431 /* loop over all transfers to fill in the rx_ranges */
432 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
433 /* if there is no rx, then no check is needed */
434 if (!xfer->rx_buf)
435 continue;
436 /* fill in the rx_range */
437 if (RANGE_CHECK(xfer->rx_buf, xfer->len,
438 rx, SPI_TEST_MAX_SIZE_PLUS)) {
439 ranges[i].start = xfer->rx_buf;
440 ranges[i].end = xfer->rx_buf + xfer->len;
441 list_add(&ranges[i].list, &ranges_list);
442 i++;
443 }
444 }
445
446 /* if no ranges, then we can return and avoid the checks...*/
447 if (!i)
448 return 0;
449
450 /* sort the list */
451 list_sort(NULL, &ranges_list, rx_ranges_cmp);
452
453 /* and iterate over all the rx addresses */
454 for (addr = rx; addr < (u8 *)rx + SPI_TEST_MAX_SIZE_PLUS; addr++) {
455 /* if we are the DO not write pattern,
456 * then continue with the loop...
457 */
458 if (*addr == SPI_TEST_PATTERN_DO_NOT_WRITE)
459 continue;
460
461 /* check if we are inside a range */
462 list_for_each_entry(r, &ranges_list, list) {
463 /* if so then set to end... */
464 if ((addr >= r->start) && (addr < r->end))
465 addr = r->end;
466 }
467 /* second test after a (hopefull) translation */
468 if (*addr == SPI_TEST_PATTERN_DO_NOT_WRITE)
469 continue;
470
471 /* if still not found then something has modified too much */
472 /* we could list the "closest" transfer here... */
473 dev_err(&spi->dev,
474 "loopback strangeness - rx changed outside of allowed range at: %pK\n",
475 addr);
476 /* do not return, only set ret,
477 * so that we list all addresses
478 */
479 ret = -ERANGE;
480 }
481
482 return ret;
483}
484
485static int spi_test_check_loopback_result(struct spi_device *spi,
486 struct spi_message *msg,
487 void *tx, void *rx)
488{
489 struct spi_transfer *xfer;
490 u8 rxb, txb;
491 size_t i;
492 int ret;
493
494 /* checks rx_buffer pattern are valid with loopback or without */
495 ret = spi_check_rx_ranges(spi, msg, rx);
496 if (ret)
497 return ret;
498
499 /* if we run without loopback, then return now */
500 if (!loopback)
501 return 0;
502
503 /* if applicable to transfer check that rx_buf is equal to tx_buf */
504 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
505 /* if there is no rx, then no check is needed */
506 if (!xfer->rx_buf)
507 continue;
508 /* so depending on tx_buf we need to handle things */
509 if (xfer->tx_buf) {
510 for (i = 1; i < xfer->len; i++) {
511 txb = ((u8 *)xfer->tx_buf)[i];
512 rxb = ((u8 *)xfer->rx_buf)[i];
513 if (txb != rxb)
514 goto mismatch_error;
515 }
516 } else {
517 /* first byte received */
518 txb = ((u8 *)xfer->rx_buf)[0];
519 /* first byte may be 0 or xff */
520 if (!((txb == 0) || (txb == 0xff))) {
521 dev_err(&spi->dev,
522 "loopback strangeness - we expect 0x00 or 0xff, but not 0x%02x\n",
523 txb);
524 return -EINVAL;
525 }
526 /* check that all bytes are identical */
527 for (i = 1; i < xfer->len; i++) {
528 rxb = ((u8 *)xfer->rx_buf)[i];
529 if (rxb != txb)
530 goto mismatch_error;
531 }
532 }
533 }
534
535 return 0;
536
537mismatch_error:
538 dev_err(&spi->dev,
539 "loopback strangeness - transfer missmatch on byte %04zx - expected 0x%02x, but got 0x%02x\n",
540 i, txb, rxb);
541
542 return -EINVAL;
543}
544
545static int spi_test_translate(struct spi_device *spi,
546 void **ptr, size_t len,
547 void *tx, void *rx)
548{
549 size_t off;
550
551 /* return on null */
552 if (!*ptr)
553 return 0;
554
555 /* in the MAX_SIZE_HALF case modify the pointer */
556 if (((size_t)*ptr) & SPI_TEST_MAX_SIZE_HALF)
557 /* move the pointer to the correct range */
558 *ptr += (SPI_TEST_MAX_SIZE_PLUS / 2) -
559 SPI_TEST_MAX_SIZE_HALF;
560
561 /* RX range
562 * - we check against MAX_SIZE_PLUS to allow for automated alignment
563 */
564 if (RANGE_CHECK(*ptr, len, RX(0), SPI_TEST_MAX_SIZE_PLUS)) {
565 off = *ptr - RX(0);
566 *ptr = rx + off;
567
568 return 0;
569 }
570
571 /* TX range */
572 if (RANGE_CHECK(*ptr, len, TX(0), SPI_TEST_MAX_SIZE_PLUS)) {
573 off = *ptr - TX(0);
574 *ptr = tx + off;
575
576 return 0;
577 }
578
579 dev_err(&spi->dev,
580 "PointerRange [%pK:%pK[ not in range [%pK:%pK[ or [%pK:%pK[\n",
581 *ptr, *ptr + len,
582 RX(0), RX(SPI_TEST_MAX_SIZE),
583 TX(0), TX(SPI_TEST_MAX_SIZE));
584
585 return -EINVAL;
586}
587
588static int spi_test_fill_pattern(struct spi_device *spi,
589 struct spi_test *test)
590{
591 struct spi_transfer *xfers = test->transfers;
592 u8 *tx_buf;
593 size_t count = 0;
594 int i, j;
595
596#ifdef __BIG_ENDIAN
597#define GET_VALUE_BYTE(value, index, bytes) \
598 (value >> (8 * (bytes - 1 - count % bytes)))
599#else
600#define GET_VALUE_BYTE(value, index, bytes) \
601 (value >> (8 * (count % bytes)))
602#endif
603
604 /* fill all transfers with the pattern requested */
605 for (i = 0; i < test->transfer_count; i++) {
606 /* fill rx_buf with SPI_TEST_PATTERN_UNWRITTEN */
607 if (xfers[i].rx_buf)
608 memset(xfers[i].rx_buf, SPI_TEST_PATTERN_UNWRITTEN,
609 xfers[i].len);
610 /* if tx_buf is NULL then skip */
611 tx_buf = (u8 *)xfers[i].tx_buf;
612 if (!tx_buf)
613 continue;
614 /* modify all the transfers */
615 for (j = 0; j < xfers[i].len; j++, tx_buf++, count++) {
616 /* fill tx */
617 switch (test->fill_option) {
618 case FILL_MEMSET_8:
619 *tx_buf = test->fill_pattern;
620 break;
621 case FILL_MEMSET_16:
622 *tx_buf = GET_VALUE_BYTE(test->fill_pattern,
623 count, 2);
624 break;
625 case FILL_MEMSET_24:
626 *tx_buf = GET_VALUE_BYTE(test->fill_pattern,
627 count, 3);
628 break;
629 case FILL_MEMSET_32:
630 *tx_buf = GET_VALUE_BYTE(test->fill_pattern,
631 count, 4);
632 break;
633 case FILL_COUNT_8:
634 *tx_buf = count;
635 break;
636 case FILL_COUNT_16:
637 *tx_buf = GET_VALUE_BYTE(count, count, 2);
638 break;
639 case FILL_COUNT_24:
640 *tx_buf = GET_VALUE_BYTE(count, count, 3);
641 break;
642 case FILL_COUNT_32:
643 *tx_buf = GET_VALUE_BYTE(count, count, 4);
644 break;
645 case FILL_TRANSFER_BYTE_8:
646 *tx_buf = j;
647 break;
648 case FILL_TRANSFER_BYTE_16:
649 *tx_buf = GET_VALUE_BYTE(j, j, 2);
650 break;
651 case FILL_TRANSFER_BYTE_24:
652 *tx_buf = GET_VALUE_BYTE(j, j, 3);
653 break;
654 case FILL_TRANSFER_BYTE_32:
655 *tx_buf = GET_VALUE_BYTE(j, j, 4);
656 break;
657 case FILL_TRANSFER_NUM:
658 *tx_buf = i;
659 break;
660 default:
661 dev_err(&spi->dev,
662 "unsupported fill_option: %i\n",
663 test->fill_option);
664 return -EINVAL;
665 }
666 }
667 }
668
669 return 0;
670}
671
672static int _spi_test_run_iter(struct spi_device *spi,
673 struct spi_test *test,
674 void *tx, void *rx)
675{
676 struct spi_message *msg = &test->msg;
677 struct spi_transfer *x;
678 int i, ret;
679
680 /* initialize message - zero-filled via static initialization */
681 spi_message_init_no_memset(msg);
682
683 /* fill rx with the DO_NOT_WRITE pattern */
684 memset(rx, SPI_TEST_PATTERN_DO_NOT_WRITE, SPI_TEST_MAX_SIZE_PLUS);
685
686 /* add the individual transfers */
687 for (i = 0; i < test->transfer_count; i++) {
688 x = &test->transfers[i];
689
690 /* patch the values of tx_buf */
691 ret = spi_test_translate(spi, (void **)&x->tx_buf, x->len,
692 (void *)tx, rx);
693 if (ret)
694 return ret;
695
696 /* patch the values of rx_buf */
697 ret = spi_test_translate(spi, &x->rx_buf, x->len,
698 (void *)tx, rx);
699 if (ret)
700 return ret;
701
702 /* and add it to the list */
703 spi_message_add_tail(x, msg);
704 }
705
706 /* fill in the transfer buffers with pattern */
707 ret = spi_test_fill_pattern(spi, test);
708 if (ret)
709 return ret;
710
711 /* and execute */
712 if (test->execute_msg)
713 ret = test->execute_msg(spi, test, tx, rx);
714 else
715 ret = spi_test_execute_msg(spi, test, tx, rx);
716
717 /* handle result */
718 if (ret == test->expected_return)
719 return 0;
720
721 dev_err(&spi->dev,
722 "test failed - test returned %i, but we expect %i\n",
723 ret, test->expected_return);
724
725 if (ret)
726 return ret;
727
728 /* if it is 0, as we expected something else,
729 * then return something special
730 */
731 return -EFAULT;
732}
733
734static int spi_test_run_iter(struct spi_device *spi,
735 const struct spi_test *testtemplate,
736 void *tx, void *rx,
737 size_t len,
738 size_t tx_off,
739 size_t rx_off
740 )
741{
742 struct spi_test test;
743 int i, tx_count, rx_count;
744
745 /* copy the test template to test */
746 memcpy(&test, testtemplate, sizeof(test));
747
748 /* set up test->transfers to the correct count */
749 if (!test.transfer_count) {
750 for (i = 0;
751 (i < SPI_TEST_MAX_TRANSFERS) && test.transfers[i].len;
752 i++) {
753 test.transfer_count++;
754 }
755 }
756
757 /* if iterate_transfer_mask is not set,
758 * then set it to first transfer only
759 */
760 if (!(test.iterate_transfer_mask & (BIT(test.transfer_count) - 1)))
761 test.iterate_transfer_mask = 1;
762
763 /* count number of transfers with tx/rx_buf != NULL */
764 for (i = 0; i < test.transfer_count; i++) {
765 if (test.transfers[i].tx_buf)
766 tx_count++;
767 if (test.transfers[i].rx_buf)
768 rx_count++;
769 }
770
771 /* in some iteration cases warn and exit early,
772 * as there is nothing to do, that has not been tested already...
773 */
774 if (tx_off && (!tx_count)) {
775 dev_warn_once(&spi->dev,
776 "%s: iterate_tx_off configured with tx_buf==NULL - ignoring\n",
777 test.description);
778 return 0;
779 }
780 if (rx_off && (!rx_count)) {
781 dev_warn_once(&spi->dev,
782 "%s: iterate_rx_off configured with rx_buf==NULL - ignoring\n",
783 test.description);
784 return 0;
785 }
786
787 /* write out info */
788 if (!(len || tx_off || rx_off)) {
789 dev_info(&spi->dev, "Running test %s\n", test.description);
790 } else {
791 dev_info(&spi->dev,
792 " with iteration values: len = %zu, tx_off = %zu, rx_off = %zu\n",
793 len, tx_off, rx_off);
794 }
795
796 /* update in the values from iteration values */
797 for (i = 0; i < test.transfer_count; i++) {
798 /* only when bit in transfer mask is set */
799 if (!(test.iterate_transfer_mask & BIT(i)))
800 continue;
801 if (len)
802 test.transfers[i].len = len;
803 if (test.transfers[i].tx_buf)
804 test.transfers[i].tx_buf += tx_off;
805 if (test.transfers[i].tx_buf)
806 test.transfers[i].rx_buf += rx_off;
807 }
808
809 /* and execute */
810 return _spi_test_run_iter(spi, &test, tx, rx);
811}
812
813/**
814 * spi_test_execute_msg - default implementation to run a test
815 *
816 * spi: @spi_device on which to run the @spi_message
817 * test: the test to execute, which already contains @msg
818 * tx: the tx buffer allocated for the test sequence
819 * rx: the rx buffer allocated for the test sequence
820 *
821 * Returns: error code of spi_sync as well as basic error checking
822 */
823int spi_test_execute_msg(struct spi_device *spi, struct spi_test *test,
824 void *tx, void *rx)
825{
826 struct spi_message *msg = &test->msg;
827 int ret = 0;
828 int i;
829
830 /* only if we do not simulate */
831 if (!simulate_only) {
832 /* dump the complete message before and after the transfer */
833 if (dump_messages == 3)
834 spi_test_dump_message(spi, msg, true);
835
836 /* run spi message */
837 ret = spi_sync(spi, msg);
838 if (ret == -ETIMEDOUT) {
839 dev_info(&spi->dev,
840 "spi-message timed out - reruning...\n");
841 /* rerun after a few explicit schedules */
842 for (i = 0; i < 16; i++)
843 schedule();
844 ret = spi_sync(spi, msg);
845 }
846 if (ret) {
847 dev_err(&spi->dev,
848 "Failed to execute spi_message: %i\n",
849 ret);
850 goto exit;
851 }
852
853 /* do some extra error checks */
854 if (msg->frame_length != msg->actual_length) {
855 dev_err(&spi->dev,
856 "actual length differs from expected\n");
857 ret = -EIO;
858 goto exit;
859 }
860
861 /* run rx-buffer tests */
862 ret = spi_test_check_loopback_result(spi, msg, tx, rx);
863 }
864
865 /* if requested or on error dump message (including data) */
866exit:
867 if (dump_messages || ret)
868 spi_test_dump_message(spi, msg,
869 (dump_messages >= 2) || (ret));
870
871 return ret;
872}
873EXPORT_SYMBOL_GPL(spi_test_execute_msg);
874
875/**
876 * spi_test_run_test - run an individual spi_test
877 * including all the relevant iterations on:
878 * length and buffer alignment
879 *
880 * spi: the spi_device to send the messages to
881 * test: the test which we need to execute
882 * tx: the tx buffer allocated for the test sequence
883 * rx: the rx buffer allocated for the test sequence
884 *
885 * Returns: status code of spi_sync or other failures
886 */
887
888int spi_test_run_test(struct spi_device *spi, const struct spi_test *test,
889 void *tx, void *rx)
890{
891 int idx_len;
892 size_t len;
893 size_t tx_align, rx_align;
894 int ret;
895
896 /* test for transfer limits */
897 if (test->transfer_count >= SPI_TEST_MAX_TRANSFERS) {
898 dev_err(&spi->dev,
899 "%s: Exceeded max number of transfers with %i\n",
900 test->description, test->transfer_count);
901 return -E2BIG;
902 }
903
904 /* setting up some values in spi_message
905 * based on some settings in spi_master
906 * some of this can also get done in the run() method
907 */
908
909 /* iterate over all the iterable values using macros
910 * (to make it a bit more readable...
911 */
912#define FOR_EACH_ITERATE(var, defaultvalue) \
913 for (idx_##var = -1, var = defaultvalue; \
914 ((idx_##var < 0) || \
915 ( \
916 (idx_##var < SPI_TEST_MAX_ITERATE) && \
917 (var = test->iterate_##var[idx_##var]) \
918 ) \
919 ); \
920 idx_##var++)
921#define FOR_EACH_ALIGNMENT(var) \
922 for (var = 0; \
923 var < (test->iterate_##var ? \
924 (spi->master->dma_alignment ? \
925 spi->master->dma_alignment : \
926 test->iterate_##var) : \
927 1); \
928 var++)
929
930 FOR_EACH_ITERATE(len, 0) {
931 FOR_EACH_ALIGNMENT(tx_align) {
932 FOR_EACH_ALIGNMENT(rx_align) {
933 /* and run the iteration */
934 ret = spi_test_run_iter(spi, test,
935 tx, rx,
936 len,
937 tx_align,
938 rx_align);
939 if (ret)
940 return ret;
941 }
942 }
943 }
944
945 return 0;
946}
947EXPORT_SYMBOL_GPL(spi_test_run_test);
948
949/**
950 * spi_test_run_tests - run an array of spi_messages tests
951 * @spi: the spi device on which to run the tests
952 * @tests: NULL-terminated array of @spi_test
953 *
954 * Returns: status errors as per @spi_test_run_test()
955 */
956
957int spi_test_run_tests(struct spi_device *spi,
958 struct spi_test *tests)
959{
960 char *rx = NULL, *tx = NULL;
961 int ret = 0, count = 0;
962 struct spi_test *test;
963
964 /* allocate rx/tx buffers of 128kB size without devm
965 * in the hope that is on a page boundary
966 */
967 rx = kzalloc(SPI_TEST_MAX_SIZE_PLUS, GFP_KERNEL);
968 if (!rx) {
969 ret = -ENOMEM;
970 goto out;
971 }
972
973 tx = kzalloc(SPI_TEST_MAX_SIZE_PLUS, GFP_KERNEL);
974 if (!tx) {
975 ret = -ENOMEM;
976 goto out;
977 }
978
979 /* now run the individual tests in the table */
980 for (test = tests, count = 0; test->description[0];
981 test++, count++) {
982 /* only run test if requested */
983 if ((run_only_test > -1) && (count != run_only_test))
984 continue;
985 /* run custom implementation */
986 if (test->run_test)
987 ret = test->run_test(spi, test, tx, rx);
988 else
989 ret = spi_test_run_test(spi, test, tx, rx);
990 if (ret)
991 goto out;
992 /* add some delays so that we can easily
993 * detect the individual tests when using a logic analyzer
994 * we also add scheduling to avoid potential spi_timeouts...
995 */
996 mdelay(100);
997 schedule();
998 }
999
1000out:
1001 kfree(rx);
1002 kfree(tx);
1003 return ret;
1004}
1005EXPORT_SYMBOL_GPL(spi_test_run_tests);
diff --git a/drivers/spi/spi-mt65xx.c b/drivers/spi/spi-mt65xx.c
index 4895fe3944f1..0be89e052428 100644
--- a/drivers/spi/spi-mt65xx.c
+++ b/drivers/spi/spi-mt65xx.c
@@ -95,8 +95,7 @@ struct mtk_spi {
95 const struct mtk_spi_compatible *dev_comp; 95 const struct mtk_spi_compatible *dev_comp;
96}; 96};
97 97
98static const struct mtk_spi_compatible mt6589_compat; 98static const struct mtk_spi_compatible mtk_common_compat;
99static const struct mtk_spi_compatible mt8135_compat;
100static const struct mtk_spi_compatible mt8173_compat = { 99static const struct mtk_spi_compatible mt8173_compat = {
101 .need_pad_sel = true, 100 .need_pad_sel = true,
102 .must_tx = true, 101 .must_tx = true,
@@ -112,9 +111,18 @@ static const struct mtk_chip_config mtk_default_chip_info = {
112}; 111};
113 112
114static const struct of_device_id mtk_spi_of_match[] = { 113static const struct of_device_id mtk_spi_of_match[] = {
115 { .compatible = "mediatek,mt6589-spi", .data = (void *)&mt6589_compat }, 114 { .compatible = "mediatek,mt2701-spi",
116 { .compatible = "mediatek,mt8135-spi", .data = (void *)&mt8135_compat }, 115 .data = (void *)&mtk_common_compat,
117 { .compatible = "mediatek,mt8173-spi", .data = (void *)&mt8173_compat }, 116 },
117 { .compatible = "mediatek,mt6589-spi",
118 .data = (void *)&mtk_common_compat,
119 },
120 { .compatible = "mediatek,mt8135-spi",
121 .data = (void *)&mtk_common_compat,
122 },
123 { .compatible = "mediatek,mt8173-spi",
124 .data = (void *)&mt8173_compat,
125 },
118 {} 126 {}
119}; 127};
120MODULE_DEVICE_TABLE(of, mtk_spi_of_match); 128MODULE_DEVICE_TABLE(of, mtk_spi_of_match);
@@ -154,9 +162,6 @@ static int mtk_spi_prepare_message(struct spi_master *master,
154 reg_val |= SPI_CMD_CPOL; 162 reg_val |= SPI_CMD_CPOL;
155 else 163 else
156 reg_val &= ~SPI_CMD_CPOL; 164 reg_val &= ~SPI_CMD_CPOL;
157 writel(reg_val, mdata->base + SPI_CMD_REG);
158
159 reg_val = readl(mdata->base + SPI_CMD_REG);
160 165
161 /* set the mlsbx and mlsbtx */ 166 /* set the mlsbx and mlsbtx */
162 if (chip_config->tx_mlsb) 167 if (chip_config->tx_mlsb)
@@ -618,7 +623,8 @@ static int mtk_spi_probe(struct platform_device *pdev)
618 ret = clk_set_parent(mdata->sel_clk, mdata->parent_clk); 623 ret = clk_set_parent(mdata->sel_clk, mdata->parent_clk);
619 if (ret < 0) { 624 if (ret < 0) {
620 dev_err(&pdev->dev, "failed to clk_set_parent (%d)\n", ret); 625 dev_err(&pdev->dev, "failed to clk_set_parent (%d)\n", ret);
621 goto err_disable_clk; 626 clk_disable_unprepare(mdata->spi_clk);
627 goto err_put_master;
622 } 628 }
623 629
624 clk_disable_unprepare(mdata->spi_clk); 630 clk_disable_unprepare(mdata->spi_clk);
@@ -628,7 +634,7 @@ static int mtk_spi_probe(struct platform_device *pdev)
628 ret = devm_spi_register_master(&pdev->dev, master); 634 ret = devm_spi_register_master(&pdev->dev, master);
629 if (ret) { 635 if (ret) {
630 dev_err(&pdev->dev, "failed to register master (%d)\n", ret); 636 dev_err(&pdev->dev, "failed to register master (%d)\n", ret);
631 goto err_put_master; 637 goto err_disable_runtime_pm;
632 } 638 }
633 639
634 if (mdata->dev_comp->need_pad_sel) { 640 if (mdata->dev_comp->need_pad_sel) {
@@ -637,14 +643,14 @@ static int mtk_spi_probe(struct platform_device *pdev)
637 "pad_num does not match num_chipselect(%d != %d)\n", 643 "pad_num does not match num_chipselect(%d != %d)\n",
638 mdata->pad_num, master->num_chipselect); 644 mdata->pad_num, master->num_chipselect);
639 ret = -EINVAL; 645 ret = -EINVAL;
640 goto err_put_master; 646 goto err_disable_runtime_pm;
641 } 647 }
642 648
643 if (!master->cs_gpios && master->num_chipselect > 1) { 649 if (!master->cs_gpios && master->num_chipselect > 1) {
644 dev_err(&pdev->dev, 650 dev_err(&pdev->dev,
645 "cs_gpios not specified and num_chipselect > 1\n"); 651 "cs_gpios not specified and num_chipselect > 1\n");
646 ret = -EINVAL; 652 ret = -EINVAL;
647 goto err_put_master; 653 goto err_disable_runtime_pm;
648 } 654 }
649 655
650 if (master->cs_gpios) { 656 if (master->cs_gpios) {
@@ -655,7 +661,7 @@ static int mtk_spi_probe(struct platform_device *pdev)
655 if (ret) { 661 if (ret) {
656 dev_err(&pdev->dev, 662 dev_err(&pdev->dev,
657 "can't get CS GPIO %i\n", i); 663 "can't get CS GPIO %i\n", i);
658 goto err_put_master; 664 goto err_disable_runtime_pm;
659 } 665 }
660 } 666 }
661 } 667 }
@@ -663,8 +669,8 @@ static int mtk_spi_probe(struct platform_device *pdev)
663 669
664 return 0; 670 return 0;
665 671
666err_disable_clk: 672err_disable_runtime_pm:
667 clk_disable_unprepare(mdata->spi_clk); 673 pm_runtime_disable(&pdev->dev);
668err_put_master: 674err_put_master:
669 spi_master_put(master); 675 spi_master_put(master);
670 676
diff --git a/drivers/spi/spi-omap2-mcspi.c b/drivers/spi/spi-omap2-mcspi.c
index 1f8903d356e5..7273820275e9 100644
--- a/drivers/spi/spi-omap2-mcspi.c
+++ b/drivers/spi/spi-omap2-mcspi.c
@@ -24,6 +24,7 @@
24#include <linux/dma-mapping.h> 24#include <linux/dma-mapping.h>
25#include <linux/dmaengine.h> 25#include <linux/dmaengine.h>
26#include <linux/omap-dma.h> 26#include <linux/omap-dma.h>
27#include <linux/pinctrl/consumer.h>
27#include <linux/platform_device.h> 28#include <linux/platform_device.h>
28#include <linux/err.h> 29#include <linux/err.h>
29#include <linux/clk.h> 30#include <linux/clk.h>
@@ -1024,6 +1025,16 @@ static int omap2_mcspi_setup(struct spi_device *spi)
1024 spi->controller_state = cs; 1025 spi->controller_state = cs;
1025 /* Link this to context save list */ 1026 /* Link this to context save list */
1026 list_add_tail(&cs->node, &ctx->cs); 1027 list_add_tail(&cs->node, &ctx->cs);
1028
1029 if (gpio_is_valid(spi->cs_gpio)) {
1030 ret = gpio_request(spi->cs_gpio, dev_name(&spi->dev));
1031 if (ret) {
1032 dev_err(&spi->dev, "failed to request gpio\n");
1033 return ret;
1034 }
1035 gpio_direction_output(spi->cs_gpio,
1036 !(spi->mode & SPI_CS_HIGH));
1037 }
1027 } 1038 }
1028 1039
1029 if (!mcspi_dma->dma_rx || !mcspi_dma->dma_tx) { 1040 if (!mcspi_dma->dma_rx || !mcspi_dma->dma_tx) {
@@ -1032,15 +1043,6 @@ static int omap2_mcspi_setup(struct spi_device *spi)
1032 return ret; 1043 return ret;
1033 } 1044 }
1034 1045
1035 if (gpio_is_valid(spi->cs_gpio)) {
1036 ret = gpio_request(spi->cs_gpio, dev_name(&spi->dev));
1037 if (ret) {
1038 dev_err(&spi->dev, "failed to request gpio\n");
1039 return ret;
1040 }
1041 gpio_direction_output(spi->cs_gpio, !(spi->mode & SPI_CS_HIGH));
1042 }
1043
1044 ret = pm_runtime_get_sync(mcspi->dev); 1046 ret = pm_runtime_get_sync(mcspi->dev);
1045 if (ret < 0) 1047 if (ret < 0)
1046 return ret; 1048 return ret;
@@ -1536,14 +1538,23 @@ static int omap2_mcspi_resume(struct device *dev)
1536 } 1538 }
1537 pm_runtime_mark_last_busy(mcspi->dev); 1539 pm_runtime_mark_last_busy(mcspi->dev);
1538 pm_runtime_put_autosuspend(mcspi->dev); 1540 pm_runtime_put_autosuspend(mcspi->dev);
1539 return 0; 1541
1542 return pinctrl_pm_select_default_state(dev);
1543}
1544
1545static int omap2_mcspi_suspend(struct device *dev)
1546{
1547 return pinctrl_pm_select_sleep_state(dev);
1540} 1548}
1549
1541#else 1550#else
1551#define omap2_mcspi_suspend NULL
1542#define omap2_mcspi_resume NULL 1552#define omap2_mcspi_resume NULL
1543#endif 1553#endif
1544 1554
1545static const struct dev_pm_ops omap2_mcspi_pm_ops = { 1555static const struct dev_pm_ops omap2_mcspi_pm_ops = {
1546 .resume = omap2_mcspi_resume, 1556 .resume = omap2_mcspi_resume,
1557 .suspend = omap2_mcspi_suspend,
1547 .runtime_resume = omap_mcspi_runtime_resume, 1558 .runtime_resume = omap_mcspi_runtime_resume,
1548}; 1559};
1549 1560
diff --git a/drivers/spi/spi-test.h b/drivers/spi/spi-test.h
new file mode 100644
index 000000000000..922c52833239
--- /dev/null
+++ b/drivers/spi/spi-test.h
@@ -0,0 +1,136 @@
1/*
2 * linux/drivers/spi/spi-test.h
3 *
4 * (c) Martin Sperl <kernel@martin.sperl.org>
5 *
6 * spi_test definitions
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 */
18
19#include <linux/spi/spi.h>
20
21#define SPI_TEST_MAX_TRANSFERS 4
22#define SPI_TEST_MAX_SIZE (32 * PAGE_SIZE)
23#define SPI_TEST_MAX_ITERATE 32
24
25/* the "dummy" start addresses used in spi_test
26 * these addresses get translated at a later stage
27 */
28#define RX_START BIT(30)
29#define TX_START BIT(31)
30#define RX(off) ((void *)(RX_START + off))
31#define TX(off) ((void *)(TX_START + off))
32
33/* some special defines for offsets */
34#define SPI_TEST_MAX_SIZE_HALF BIT(29)
35
36/* detection pattern for unfinished reads...
37 * - 0x00 or 0xff could be valid levels for tx_buf = NULL,
38 * so we do not use either of them
39 */
40#define SPI_TEST_PATTERN_UNWRITTEN 0xAA
41#define SPI_TEST_PATTERN_DO_NOT_WRITE 0x55
42#define SPI_TEST_CHECK_DO_NOT_WRITE 64
43
44/**
45 * struct spi_test - describes a specific (set of) tests to execute
46 *
47 * @description: description of the test
48 *
49 * @msg: a template @spi_message usedfor the default settings
50 * @transfers: array of @spi_transfers that are part of the
51 * resulting spi_message. The first transfer with len == 0
52 * signifies the end of the list
53 * @transfer_count: normally computed number of transfers with len > 0
54 *
55 * @run_test: run a specific spi_test - this allows to override
56 * the default implementation of @spi_test_run_transfer
57 * either to add some custom filters for a specific test
58 * or to effectively run some very custom tests...
59 * @execute_msg: run the spi_message for real - this allows to override
60 * @spi_test_execute_msg to apply final modifications
61 * on the spi_message
62 * @expected_return: the expected return code - in some cases we want to
63 * test also for error conditions
64 *
65 * @iterate_len: list of length to iterate on (in addition to the
66 * explicitly set @spi_transfer.len)
67 * @iterate_tx_align: change the alignment of @spi_transfer.tx_buf
68 * for all values in the below range if set.
69 * the ranges are:
70 * [0 : @spi_master.dma_alignment[ if set
71 * [0 : iterate_tx_align[ if unset
72 * @iterate_rx_align: change the alignment of @spi_transfer.rx_buf
73 * see @iterate_tx_align for details
74 * @iterate_transfer_mask: the bitmask of transfers to which the iterations
75 * apply - if 0, then it applies to all transfer
76 *
77 * @fill_option: define the way how tx_buf is filled
78 * @fill_pattern: fill pattern to apply to the tx_buf
79 * (used in some of the @fill_options)
80 */
81
82struct spi_test {
83 char description[64];
84 struct spi_message msg;
85 struct spi_transfer transfers[SPI_TEST_MAX_TRANSFERS];
86 unsigned int transfer_count;
87 int (*run_test)(struct spi_device *spi, struct spi_test *test,
88 void *tx, void *rx);
89 int (*execute_msg)(struct spi_device *spi, struct spi_test *test,
90 void *tx, void *rx);
91 int expected_return;
92 /* iterate over all the non-zero values */
93 int iterate_len[SPI_TEST_MAX_ITERATE];
94 int iterate_tx_align;
95 int iterate_rx_align;
96 u32 iterate_transfer_mask;
97 /* the tx-fill operation */
98 u32 fill_option;
99#define FILL_MEMSET_8 0 /* just memset with 8 bit */
100#define FILL_MEMSET_16 1 /* just memset with 16 bit */
101#define FILL_MEMSET_24 2 /* just memset with 24 bit */
102#define FILL_MEMSET_32 3 /* just memset with 32 bit */
103#define FILL_COUNT_8 4 /* fill with a 8 byte counter */
104#define FILL_COUNT_16 5 /* fill with a 16 bit counter */
105#define FILL_COUNT_24 6 /* fill with a 24 bit counter */
106#define FILL_COUNT_32 7 /* fill with a 32 bit counter */
107#define FILL_TRANSFER_BYTE_8 8 /* fill with the transfer byte - 8 bit */
108#define FILL_TRANSFER_BYTE_16 9 /* fill with the transfer byte - 16 bit */
109#define FILL_TRANSFER_BYTE_24 10 /* fill with the transfer byte - 24 bit */
110#define FILL_TRANSFER_BYTE_32 11 /* fill with the transfer byte - 32 bit */
111#define FILL_TRANSFER_NUM 16 /* fill with the transfer number */
112 u32 fill_pattern;
113};
114
115/* default implementation for @spi_test.run_test */
116int spi_test_run_test(struct spi_device *spi,
117 const struct spi_test *test,
118 void *tx, void *rx);
119
120/* default implementation for @spi_test.execute_msg */
121int spi_test_execute_msg(struct spi_device *spi,
122 struct spi_test *test,
123 void *tx, void *rx);
124
125/* function to execute a set of tests */
126int spi_test_run_tests(struct spi_device *spi,
127 struct spi_test *tests);
128
129/* some of the default @spi_transfer.len to test */
130#define ITERATE_LEN 2, 3, 7, 11, 16, 31, 32, 64, 97, 128, 251, 256, \
131 1021, 1024, 1031, 4093, PAGE_SIZE, 4099, 65536, 65537
132
133#define ITERATE_MAX_LEN ITERATE_LEN, SPI_TEST_MAX_SIZE - 1, SPI_TEST_MAX_SIZE
134
135/* the default alignment to test */
136#define ITERATE_ALIGN sizeof(int)
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 3eebc6c235fb..3bdbba9a86a3 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -768,10 +768,15 @@ struct spi_message {
768 void *state; 768 void *state;
769}; 769};
770 770
771static inline void spi_message_init_no_memset(struct spi_message *m)
772{
773 INIT_LIST_HEAD(&m->transfers);
774}
775
771static inline void spi_message_init(struct spi_message *m) 776static inline void spi_message_init(struct spi_message *m)
772{ 777{
773 memset(m, 0, sizeof *m); 778 memset(m, 0, sizeof *m);
774 INIT_LIST_HEAD(&m->transfers); 779 spi_message_init_no_memset(m);
775} 780}
776 781
777static inline void 782static inline void
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-26 13:33:37 -0500