]>
Commit | Line | Data |
---|---|---|
77f85581 WD |
1 | /* |
2 | * (C) Copyright 2001 | |
3 | * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com. | |
4 | * | |
5 | * See file CREDITS for list of people who contributed to this | |
6 | * project. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of | |
11 | * the License, or (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 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
21 | * MA 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #ifndef _SPI_H_ | |
25 | #define _SPI_H_ | |
26 | ||
f8cc312b BW |
27 | /* Controller-specific definitions: */ |
28 | ||
38254f45 GL |
29 | /* SPI mode flags */ |
30 | #define SPI_CPHA 0x01 /* clock phase */ | |
31 | #define SPI_CPOL 0x02 /* clock polarity */ | |
32 | #define SPI_MODE_0 (0|0) /* (original MicroWire) */ | |
33 | #define SPI_MODE_1 (0|SPI_CPHA) | |
34 | #define SPI_MODE_2 (SPI_CPOL|0) | |
35 | #define SPI_MODE_3 (SPI_CPOL|SPI_CPHA) | |
d255bb0e | 36 | #define SPI_CS_HIGH 0x04 /* CS active high */ |
38254f45 GL |
37 | #define SPI_LSB_FIRST 0x08 /* per-word bits-on-wire */ |
38 | #define SPI_3WIRE 0x10 /* SI/SO signals shared */ | |
39 | #define SPI_LOOP 0x20 /* loopback mode */ | |
40 | ||
d255bb0e HS |
41 | /* SPI transfer flags */ |
42 | #define SPI_XFER_BEGIN 0x01 /* Assert CS before transfer */ | |
43 | #define SPI_XFER_END 0x02 /* Deassert CS after transfer */ | |
77f85581 | 44 | |
d255bb0e HS |
45 | /*----------------------------------------------------------------------- |
46 | * Representation of a SPI slave, i.e. what we're communicating with. | |
47 | * | |
48 | * Drivers are expected to extend this with controller-specific data. | |
49 | * | |
50 | * bus: ID of the bus that the slave is attached to. | |
51 | * cs: ID of the chip select connected to the slave. | |
52 | */ | |
53 | struct spi_slave { | |
54 | unsigned int bus; | |
55 | unsigned int cs; | |
56 | }; | |
77f85581 WD |
57 | |
58 | /*----------------------------------------------------------------------- | |
59 | * Initialization, must be called once on start up. | |
d255bb0e HS |
60 | * |
61 | * TODO: I don't think we really need this. | |
77f85581 WD |
62 | */ |
63 | void spi_init(void); | |
64 | ||
ba6c3ce9 SG |
65 | /** |
66 | * spi_do_alloc_slave - Allocate a new SPI slave (internal) | |
67 | * | |
68 | * Allocate and zero all fields in the spi slave, and set the bus/chip | |
69 | * select. Use the helper macro spi_alloc_slave() to call this. | |
70 | * | |
71 | * @offset: Offset of struct spi_slave within slave structure | |
72 | * @size: Size of slave structure | |
73 | * @bus: Bus ID of the slave chip. | |
74 | * @cs: Chip select ID of the slave chip on the specified bus. | |
75 | */ | |
76 | void *spi_do_alloc_slave(int offset, int size, unsigned int bus, | |
77 | unsigned int cs); | |
78 | ||
79 | /** | |
80 | * spi_alloc_slave - Allocate a new SPI slave | |
81 | * | |
82 | * Allocate and zero all fields in the spi slave, and set the bus/chip | |
83 | * select. | |
84 | * | |
85 | * @_struct: Name of structure to allocate (e.g. struct tegra_spi). This | |
86 | * structure must contain a member 'struct spi_slave *slave'. | |
87 | * @bus: Bus ID of the slave chip. | |
88 | * @cs: Chip select ID of the slave chip on the specified bus. | |
89 | */ | |
90 | #define spi_alloc_slave(_struct, bus, cs) \ | |
91 | spi_do_alloc_slave(offsetof(_struct, slave), \ | |
92 | sizeof(_struct), bus, cs) | |
93 | ||
94 | /** | |
95 | * spi_alloc_slave_base - Allocate a new SPI slave with no private data | |
96 | * | |
97 | * Allocate and zero all fields in the spi slave, and set the bus/chip | |
98 | * select. | |
99 | * | |
100 | * @bus: Bus ID of the slave chip. | |
101 | * @cs: Chip select ID of the slave chip on the specified bus. | |
102 | */ | |
103 | #define spi_alloc_slave_base(bus, cs) \ | |
104 | spi_do_alloc_slave(0, sizeof(struct spi_slave), bus, cs) | |
105 | ||
d255bb0e HS |
106 | /*----------------------------------------------------------------------- |
107 | * Set up communications parameters for a SPI slave. | |
108 | * | |
109 | * This must be called once for each slave. Note that this function | |
110 | * usually doesn't touch any actual hardware, it only initializes the | |
111 | * contents of spi_slave so that the hardware can be easily | |
112 | * initialized later. | |
113 | * | |
114 | * bus: Bus ID of the slave chip. | |
115 | * cs: Chip select ID of the slave chip on the specified bus. | |
116 | * max_hz: Maximum SCK rate in Hz. | |
117 | * mode: Clock polarity, clock phase and other parameters. | |
118 | * | |
119 | * Returns: A spi_slave reference that can be used in subsequent SPI | |
120 | * calls, or NULL if one or more of the parameters are not supported. | |
121 | */ | |
122 | struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs, | |
123 | unsigned int max_hz, unsigned int mode); | |
124 | ||
125 | /*----------------------------------------------------------------------- | |
126 | * Free any memory associated with a SPI slave. | |
127 | * | |
128 | * slave: The SPI slave | |
129 | */ | |
130 | void spi_free_slave(struct spi_slave *slave); | |
131 | ||
132 | /*----------------------------------------------------------------------- | |
133 | * Claim the bus and prepare it for communication with a given slave. | |
134 | * | |
135 | * This must be called before doing any transfers with a SPI slave. It | |
136 | * will enable and initialize any SPI hardware as necessary, and make | |
137 | * sure that the SCK line is in the correct idle state. It is not | |
138 | * allowed to claim the same bus for several slaves without releasing | |
139 | * the bus in between. | |
140 | * | |
141 | * slave: The SPI slave | |
142 | * | |
143 | * Returns: 0 if the bus was claimed successfully, or a negative value | |
144 | * if it wasn't. | |
145 | */ | |
146 | int spi_claim_bus(struct spi_slave *slave); | |
147 | ||
148 | /*----------------------------------------------------------------------- | |
149 | * Release the SPI bus | |
150 | * | |
151 | * This must be called once for every call to spi_claim_bus() after | |
152 | * all transfers have finished. It may disable any SPI hardware as | |
153 | * appropriate. | |
154 | * | |
155 | * slave: The SPI slave | |
156 | */ | |
157 | void spi_release_bus(struct spi_slave *slave); | |
77f85581 WD |
158 | |
159 | /*----------------------------------------------------------------------- | |
160 | * SPI transfer | |
161 | * | |
162 | * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks | |
163 | * "bitlen" bits in the SPI MISO port. That's just the way SPI works. | |
164 | * | |
165 | * The source of the outgoing bits is the "dout" parameter and the | |
166 | * destination of the input bits is the "din" parameter. Note that "dout" | |
167 | * and "din" can point to the same memory location, in which case the | |
168 | * input data overwrites the output data (since both are buffered by | |
169 | * temporary variables, this is OK). | |
170 | * | |
77f85581 | 171 | * spi_xfer() interface: |
d255bb0e HS |
172 | * slave: The SPI slave which will be sending/receiving the data. |
173 | * bitlen: How many bits to write and read. | |
174 | * dout: Pointer to a string of bits to send out. The bits are | |
175 | * held in a byte array and are sent MSB first. | |
176 | * din: Pointer to a string of bits that will be filled in. | |
177 | * flags: A bitwise combination of SPI_XFER_* flags. | |
77f85581 WD |
178 | * |
179 | * Returns: 0 on success, not 0 on failure | |
180 | */ | |
d255bb0e HS |
181 | int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout, |
182 | void *din, unsigned long flags); | |
183 | ||
184 | /*----------------------------------------------------------------------- | |
185 | * Determine if a SPI chipselect is valid. | |
186 | * This function is provided by the board if the low-level SPI driver | |
187 | * needs it to determine if a given chipselect is actually valid. | |
188 | * | |
189 | * Returns: 1 if bus:cs identifies a valid chip on this board, 0 | |
190 | * otherwise. | |
191 | */ | |
192 | int spi_cs_is_valid(unsigned int bus, unsigned int cs); | |
193 | ||
194 | /*----------------------------------------------------------------------- | |
195 | * Activate a SPI chipselect. | |
196 | * This function is provided by the board code when using a driver | |
197 | * that can't control its chipselects automatically (e.g. | |
198 | * common/soft_spi.c). When called, it should activate the chip select | |
199 | * to the device identified by "slave". | |
200 | */ | |
201 | void spi_cs_activate(struct spi_slave *slave); | |
202 | ||
203 | /*----------------------------------------------------------------------- | |
204 | * Deactivate a SPI chipselect. | |
205 | * This function is provided by the board code when using a driver | |
206 | * that can't control its chipselects automatically (e.g. | |
207 | * common/soft_spi.c). When called, it should deactivate the chip | |
208 | * select to the device identified by "slave". | |
209 | */ | |
210 | void spi_cs_deactivate(struct spi_slave *slave); | |
211 | ||
fa1423e7 TC |
212 | /*----------------------------------------------------------------------- |
213 | * Set transfer speed. | |
214 | * This sets a new speed to be applied for next spi_xfer(). | |
215 | * slave: The SPI slave | |
216 | * hz: The transfer speed | |
217 | */ | |
218 | void spi_set_speed(struct spi_slave *slave, uint hz); | |
219 | ||
d255bb0e HS |
220 | /*----------------------------------------------------------------------- |
221 | * Write 8 bits, then read 8 bits. | |
222 | * slave: The SPI slave we're communicating with | |
223 | * byte: Byte to be written | |
224 | * | |
225 | * Returns: The value that was read, or a negative value on error. | |
226 | * | |
227 | * TODO: This function probably shouldn't be inlined. | |
228 | */ | |
229 | static inline int spi_w8r8(struct spi_slave *slave, unsigned char byte) | |
230 | { | |
231 | unsigned char dout[2]; | |
232 | unsigned char din[2]; | |
233 | int ret; | |
234 | ||
235 | dout[0] = byte; | |
236 | dout[1] = 0; | |
38254f45 | 237 | |
d255bb0e HS |
238 | ret = spi_xfer(slave, 16, dout, din, SPI_XFER_BEGIN | SPI_XFER_END); |
239 | return ret < 0 ? ret : din[1]; | |
240 | } | |
77f85581 WD |
241 | |
242 | #endif /* _SPI_H_ */ |