1 /*
2 * Simulate a SPI port
3 *
4 * Copyright (c) 2011-2013 The Chromium OS Authors.
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * Licensed under the GPL-2 or later.
9 */
10
11 #define LOG_CATEGORY UCLASS_SPI
12
13 #include <common.h>
14 #include <dm.h>
15 #include <log.h>
16 #include <malloc.h>
17 #include <spi.h>
18 #include <spi_flash.h>
19 #include <os.h>
20
21 #include <linux/errno.h>
22 #include <asm/spi.h>
23 #include <asm/state.h>
24 #include <dm/acpi.h>
25 #include <dm/device-internal.h>
26
27 /**
28 * struct sandbox_spi_priv - Sandbox SPI private data
29 *
30 * Helper struct to keep track of the sandbox SPI bus internal state. It is
31 * used in unit tests to verify that dm spi functions update the bus
32 * speed/mode properly (for instance, when jumping back and forth between spi
33 * slaves claiming the bus, we need to make sure that the bus speed is updated
34 * accordingly for each slave).
35 *
36 * @speed: Current bus speed.
37 * @mode: Current bus mode.
38 */
39 struct sandbox_spi_priv {
40 uint speed;
41 uint mode;
42 };
43
sandbox_spi_get_emul(struct sandbox_state * state,struct udevice * bus,struct udevice * slave,struct udevice ** emulp)44 __weak int sandbox_spi_get_emul(struct sandbox_state *state,
45 struct udevice *bus, struct udevice *slave,
46 struct udevice **emulp)
47 {
48 return -ENOENT;
49 }
50
sandbox_spi_get_speed(struct udevice * dev)51 uint sandbox_spi_get_speed(struct udevice *dev)
52 {
53 struct sandbox_spi_priv *priv = dev_get_priv(dev);
54
55 return priv->speed;
56 }
57
sandbox_spi_get_mode(struct udevice * dev)58 uint sandbox_spi_get_mode(struct udevice *dev)
59 {
60 struct sandbox_spi_priv *priv = dev_get_priv(dev);
61
62 return priv->mode;
63 }
64
sandbox_spi_xfer(struct udevice * slave,unsigned int bitlen,const void * dout,void * din,unsigned long flags)65 static int sandbox_spi_xfer(struct udevice *slave, unsigned int bitlen,
66 const void *dout, void *din, unsigned long flags)
67 {
68 struct udevice *bus = slave->parent;
69 struct sandbox_state *state = state_get_current();
70 struct dm_spi_emul_ops *ops;
71 struct udevice *emul;
72 uint bytes = bitlen / 8, i;
73 int ret;
74 uint busnum, cs;
75
76 if (bitlen == 0)
77 return 0;
78
79 /* we can only do 8 bit transfers */
80 if (bitlen % 8) {
81 printf("sandbox_spi: xfer: invalid bitlen size %u; needs to be 8bit\n",
82 bitlen);
83 return -EINVAL;
84 }
85
86 busnum = dev_seq(bus);
87 cs = spi_chip_select(slave);
88 if (busnum >= CONFIG_SANDBOX_SPI_MAX_BUS ||
89 cs >= CONFIG_SANDBOX_SPI_MAX_CS) {
90 printf("%s: busnum=%u, cs=%u: out of range\n", __func__,
91 busnum, cs);
92 return -ENOENT;
93 }
94 ret = sandbox_spi_get_emul(state, bus, slave, &emul);
95 if (ret) {
96 printf("%s: busnum=%u, cs=%u: no emulation available (err=%d)\n",
97 __func__, busnum, cs, ret);
98 return -ENOENT;
99 }
100 ret = device_probe(emul);
101 if (ret)
102 return ret;
103
104 ops = spi_emul_get_ops(emul);
105 ret = ops->xfer(emul, bitlen, dout, din, flags);
106
107 log_content("sandbox_spi: xfer: got back %i (that's %s)\n rx:",
108 ret, ret ? "bad" : "good");
109 if (din) {
110 for (i = 0; i < bytes; ++i)
111 log_content(" %u:%02x", i, ((u8 *)din)[i]);
112 }
113 log_content("\n");
114
115 return ret;
116 }
117
sandbox_spi_set_speed(struct udevice * bus,uint speed)118 static int sandbox_spi_set_speed(struct udevice *bus, uint speed)
119 {
120 struct sandbox_spi_priv *priv = dev_get_priv(bus);
121
122 priv->speed = speed;
123
124 return 0;
125 }
126
sandbox_spi_set_mode(struct udevice * bus,uint mode)127 static int sandbox_spi_set_mode(struct udevice *bus, uint mode)
128 {
129 struct sandbox_spi_priv *priv = dev_get_priv(bus);
130
131 priv->mode = mode;
132
133 return 0;
134 }
135
sandbox_cs_info(struct udevice * bus,uint cs,struct spi_cs_info * info)136 static int sandbox_cs_info(struct udevice *bus, uint cs,
137 struct spi_cs_info *info)
138 {
139 /* Always allow activity on CS 0, CS 1 */
140 if (cs >= 2)
141 return -EINVAL;
142
143 return 0;
144 }
145
sandbox_spi_get_mmap(struct udevice * dev,ulong * map_basep,uint * map_sizep,uint * offsetp)146 static int sandbox_spi_get_mmap(struct udevice *dev, ulong *map_basep,
147 uint *map_sizep, uint *offsetp)
148 {
149 *map_basep = 0x1000;
150 *map_sizep = 0x2000;
151 *offsetp = 0x100;
152
153 return 0;
154 }
155
156 static const struct dm_spi_ops sandbox_spi_ops = {
157 .xfer = sandbox_spi_xfer,
158 .set_speed = sandbox_spi_set_speed,
159 .set_mode = sandbox_spi_set_mode,
160 .cs_info = sandbox_cs_info,
161 .get_mmap = sandbox_spi_get_mmap,
162 };
163
164 static const struct udevice_id sandbox_spi_ids[] = {
165 { .compatible = "sandbox,spi" },
166 { }
167 };
168
169 U_BOOT_DRIVER(sandbox_spi) = {
170 .name = "sandbox_spi",
171 .id = UCLASS_SPI,
172 .of_match = sandbox_spi_ids,
173 .ops = &sandbox_spi_ops,
174 .priv_auto = sizeof(struct sandbox_spi_priv),
175 };
176