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