1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2013 Google, Inc
4 */
5
6 #include <common.h>
7 #include <dm.h>
8 #include <fdtdec.h>
9 #include <spi.h>
10 #include <spi_flash.h>
11 #include <asm/state.h>
12 #include <asm/test.h>
13 #include <dm/device-internal.h>
14 #include <dm/test.h>
15 #include <dm/uclass-internal.h>
16 #include <dm/util.h>
17 #include <test/test.h>
18 #include <test/ut.h>
19
20 /* Test that we can find buses and chip-selects */
dm_test_spi_find(struct unit_test_state * uts)21 static int dm_test_spi_find(struct unit_test_state *uts)
22 {
23 struct sandbox_state *state = state_get_current();
24 struct spi_slave *slave;
25 struct udevice *bus, *dev;
26 const int busnum = 0, cs = 0, mode = 0, speed = 1000000, cs_b = 2;
27 struct spi_cs_info info;
28 ofnode node;
29
30 /*
31 * The post_bind() method will bind devices to chip selects. Check
32 * this then remove the emulation and the slave device.
33 */
34 ut_asserteq(0, uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus));
35 ut_assertok(spi_cs_info(bus, cs, &info));
36 node = dev_ofnode(info.dev);
37 device_remove(info.dev, DM_REMOVE_NORMAL);
38 device_unbind(info.dev);
39
40 /*
41 * Even though the device is gone, the sandbox SPI drivers always
42 * reports that CS 0 is present
43 */
44 ut_assertok(spi_cs_info(bus, cs, &info));
45 ut_asserteq_ptr(NULL, info.dev);
46
47 /* This finds nothing because we removed the device */
48 ut_asserteq(-ENODEV, spi_find_bus_and_cs(busnum, cs, &bus, &dev));
49 ut_asserteq(-ENODEV, spi_get_bus_and_cs(busnum, cs, &bus, &slave));
50
51 /*
52 * This forces the device to be re-added, but there is no emulation
53 * connected so the probe will fail. We require that bus is left
54 * alone on failure, and that the _spi_get_bus_and_cs() does not add
55 * a 'partially-inited' device.
56 */
57 ut_asserteq(-ENODEV, spi_find_bus_and_cs(busnum, cs, &bus, &dev));
58 ut_asserteq(-ENOENT, _spi_get_bus_and_cs(busnum, cs, speed, mode,
59 "jedec_spi_nor", "name", &bus,
60 &slave));
61 sandbox_sf_unbind_emul(state_get_current(), busnum, cs);
62 ut_assertok(spi_cs_info(bus, cs, &info));
63 ut_asserteq_ptr(NULL, info.dev);
64
65 /* Add the emulation and try again */
66 ut_assertok(sandbox_sf_bind_emul(state, busnum, cs, bus, node,
67 "name"));
68 ut_assertok(spi_find_bus_and_cs(busnum, cs, &bus, &dev));
69 ut_assertok(_spi_get_bus_and_cs(busnum, cs, speed, mode,
70 "jedec_spi_nor", "name", &bus, &slave));
71
72 ut_assertok(spi_cs_info(bus, cs, &info));
73 ut_asserteq_ptr(info.dev, slave->dev);
74
75 /* We should be able to add something to another chip select */
76 ut_assertok(sandbox_sf_bind_emul(state, busnum, cs_b, bus, node,
77 "name"));
78 ut_asserteq(-EINVAL, _spi_get_bus_and_cs(busnum, cs_b, speed, mode,
79 "jedec_spi_nor", "name", &bus,
80 &slave));
81 ut_asserteq(-EINVAL, spi_cs_info(bus, cs_b, &info));
82 ut_asserteq_ptr(NULL, info.dev);
83
84 /*
85 * Since we are about to destroy all devices, we must tell sandbox
86 * to forget the emulation device
87 */
88 sandbox_sf_unbind_emul(state_get_current(), busnum, cs);
89 sandbox_sf_unbind_emul(state_get_current(), busnum, cs_b);
90
91 return 0;
92 }
93 DM_TEST(dm_test_spi_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
94
95 /* dm_test_spi_switch_slaves - Helper function to check whether spi_claim_bus
96 * operates correctly with two spi slaves.
97 *
98 * Check that switching back and forth between two slaves claiming the bus
99 * will update dm_spi_bus->speed and sandbox_spi bus speed/mode correctly.
100 *
101 * @uts - unit test state
102 * @slave_a - first spi slave used for testing
103 * @slave_b - second spi slave used for testing
104 */
dm_test_spi_switch_slaves(struct unit_test_state * uts,struct spi_slave * slave_a,struct spi_slave * slave_b)105 static int dm_test_spi_switch_slaves(struct unit_test_state *uts,
106 struct spi_slave *slave_a,
107 struct spi_slave *slave_b)
108 {
109 struct udevice *bus;
110 struct dm_spi_bus *bus_data;
111
112 /* Check that slaves are on the same bus */
113 ut_asserteq_ptr(dev_get_parent(slave_a->dev),
114 dev_get_parent(slave_b->dev));
115
116 bus = dev_get_parent(slave_a->dev);
117 bus_data = dev_get_uclass_priv(bus);
118
119 ut_assertok(spi_claim_bus(slave_a));
120 ut_asserteq(slave_a->max_hz, bus_data->speed);
121 ut_asserteq(slave_a->max_hz, sandbox_spi_get_speed(bus));
122 ut_asserteq(slave_a->mode, sandbox_spi_get_mode(bus));
123 spi_release_bus(slave_a);
124
125 ut_assertok(spi_claim_bus(slave_b));
126 ut_asserteq(slave_b->max_hz, bus_data->speed);
127 ut_asserteq(slave_b->max_hz, sandbox_spi_get_speed(bus));
128 ut_asserteq(slave_b->mode, sandbox_spi_get_mode(bus));
129 spi_release_bus(slave_b);
130
131 ut_assertok(spi_claim_bus(slave_a));
132 ut_asserteq(slave_a->max_hz, bus_data->speed);
133 ut_asserteq(slave_a->max_hz, sandbox_spi_get_speed(bus));
134 ut_asserteq(slave_a->mode, sandbox_spi_get_mode(bus));
135 spi_release_bus(slave_a);
136
137 return 0;
138 }
139
dm_test_spi_claim_bus(struct unit_test_state * uts)140 static int dm_test_spi_claim_bus(struct unit_test_state *uts)
141 {
142 struct udevice *bus;
143 struct spi_slave *slave_a, *slave_b;
144 struct dm_spi_slave_plat *slave_plat;
145 const int busnum = 0, cs_a = 0, cs_b = 1;
146
147 /* Get spi slave on CS0 */
148 ut_assertok(spi_get_bus_and_cs(busnum, cs_a, &bus, &slave_a));
149 /* Get spi slave on CS1 */
150 ut_assertok(spi_get_bus_and_cs(busnum, cs_b, &bus, &slave_b));
151
152 /* Different max_hz, different mode. */
153 ut_assert(slave_a->max_hz != slave_b->max_hz);
154 ut_assert(slave_a->mode != slave_b->mode);
155 dm_test_spi_switch_slaves(uts, slave_a, slave_b);
156
157 /* Different max_hz, same mode. */
158 slave_a->mode = slave_b->mode;
159 dm_test_spi_switch_slaves(uts, slave_a, slave_b);
160
161 /*
162 * Same max_hz, different mode.
163 * Restore original mode for slave_a, from platdata.
164 */
165 slave_plat = dev_get_parent_plat(slave_a->dev);
166 slave_a->mode = slave_plat->mode;
167 slave_a->max_hz = slave_b->max_hz;
168 dm_test_spi_switch_slaves(uts, slave_a, slave_b);
169
170 return 0;
171 }
172 DM_TEST(dm_test_spi_claim_bus, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
173
174 /* Test that sandbox SPI works correctly */
dm_test_spi_xfer(struct unit_test_state * uts)175 static int dm_test_spi_xfer(struct unit_test_state *uts)
176 {
177 struct spi_slave *slave;
178 struct udevice *bus;
179 const int busnum = 0, cs = 0;
180 const char dout[5] = {0x9f};
181 unsigned char din[5];
182
183 ut_assertok(spi_get_bus_and_cs(busnum, cs, &bus, &slave));
184 ut_assertok(spi_claim_bus(slave));
185 ut_assertok(spi_xfer(slave, 40, dout, din,
186 SPI_XFER_BEGIN | SPI_XFER_END));
187 ut_asserteq(0xff, din[0]);
188 ut_asserteq(0x20, din[1]);
189 ut_asserteq(0x20, din[2]);
190 ut_asserteq(0x15, din[3]);
191 spi_release_bus(slave);
192
193 /*
194 * Since we are about to destroy all devices, we must tell sandbox
195 * to forget the emulation device
196 */
197 #if CONFIG_IS_ENABLED(DM_SPI_FLASH)
198 sandbox_sf_unbind_emul(state_get_current(), busnum, cs);
199 #endif
200
201 return 0;
202 }
203 DM_TEST(dm_test_spi_xfer, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
204