1
2
3
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
21static 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
32
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
42
43
44 ut_assertok(spi_cs_info(bus, cs, &info));
45 ut_asserteq_ptr(NULL, info.dev);
46
47
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
53
54
55
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
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
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
86
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}
93DM_TEST(dm_test_spi_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
94
95
96
97
98
99
100
101
102
103
104
105static 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
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
140static 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
148 ut_assertok(spi_get_bus_and_cs(busnum, cs_a, &bus, &slave_a));
149
150 ut_assertok(spi_get_bus_and_cs(busnum, cs_b, &bus, &slave_b));
151
152
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
158 slave_a->mode = slave_b->mode;
159 dm_test_spi_switch_slaves(uts, slave_a, slave_b);
160
161
162
163
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}
172DM_TEST(dm_test_spi_claim_bus, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
173
174
175static 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
195
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}
203DM_TEST(dm_test_spi_xfer, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
204