[golan] Add various new PCI device IDs
[ipxe.git] / src / drivers / bitbash / spi_bit.c
1 /*
2 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 #include <stddef.h>
27 #include <stdint.h>
28 #include <string.h>
29 #include <byteswap.h>
30 #include <errno.h>
31 #include <assert.h>
32 #include <unistd.h>
33 #include <ipxe/bitbash.h>
34 #include <ipxe/spi_bit.h>
35
36 /** @file
37 *
38 * SPI bit-bashing interface
39 *
40 */
41
42 /** Delay between SCLK changes and around SS changes */
43 static void spi_bit_delay ( void ) {
44 udelay ( SPI_BIT_UDELAY );
45 }
46
47 /** Chip select line will be asserted */
48 #define SELECT_SLAVE 0
49
50 /** Chip select line will be deasserted */
51 #define DESELECT_SLAVE SPI_MODE_SSPOL
52
53 /**
54 * Select/deselect slave
55 *
56 * @v spibit SPI bit-bashing interface
57 * @v slave Slave number
58 * @v state Slave select state
59 *
60 * @c state must be @c SELECT_SLAVE or @c DESELECT_SLAVE.
61 */
62 static void spi_bit_set_slave_select ( struct spi_bit_basher *spibit,
63 unsigned int slave,
64 unsigned int state ) {
65 struct bit_basher *basher = &spibit->basher;
66
67 state ^= ( spibit->bus.mode & SPI_MODE_SSPOL );
68 DBGC2 ( spibit, "SPIBIT %p setting slave %d select %s\n",
69 spibit, slave, ( state ? "high" : "low" ) );
70
71 spi_bit_delay();
72 write_bit ( basher, SPI_BIT_SS ( slave ), state );
73 spi_bit_delay();
74 }
75
76 /**
77 * Transfer bits over SPI bit-bashing bus
78 *
79 * @v bus SPI bus
80 * @v data_out TX data buffer (or NULL)
81 * @v data_in RX data buffer (or NULL)
82 * @v len Length of transfer (in @b bits)
83 * @v endianness Endianness of this data transfer
84 *
85 * This issues @c len clock cycles on the SPI bus, shifting out data
86 * from the @c data_out buffer to the MOSI line and shifting in data
87 * from the MISO line to the @c data_in buffer. If @c data_out is
88 * NULL, then the data sent will be all zeroes. If @c data_in is
89 * NULL, then the incoming data will be discarded.
90 */
91 static void spi_bit_transfer ( struct spi_bit_basher *spibit,
92 const void *data_out, void *data_in,
93 unsigned int len, int endianness ) {
94 struct spi_bus *bus = &spibit->bus;
95 struct bit_basher *basher = &spibit->basher;
96 unsigned int sclk = ( ( bus->mode & SPI_MODE_CPOL ) ? 1 : 0 );
97 unsigned int cpha = ( ( bus->mode & SPI_MODE_CPHA ) ? 1 : 0 );
98 unsigned int bit_offset;
99 unsigned int byte_offset;
100 unsigned int byte_mask;
101 unsigned int bit;
102 unsigned int step;
103
104 DBGC2 ( spibit, "SPIBIT %p transferring %d bits in mode %#x\n",
105 spibit, len, bus->mode );
106
107 for ( step = 0 ; step < ( len * 2 ) ; step++ ) {
108 /* Calculate byte offset and byte mask */
109 bit_offset = ( ( endianness == SPI_BIT_BIG_ENDIAN ) ?
110 ( len - ( step / 2 ) - 1 ) : ( step / 2 ) );
111 byte_offset = ( bit_offset / 8 );
112 byte_mask = ( 1 << ( bit_offset % 8 ) );
113
114 /* Shift data in or out */
115 if ( sclk == cpha ) {
116 const uint8_t *byte;
117
118 /* Shift data out */
119 if ( data_out ) {
120 byte = ( data_out + byte_offset );
121 bit = ( *byte & byte_mask );
122 DBGCP ( spibit, "SPIBIT %p wrote bit %d\n",
123 spibit, ( bit ? 1 : 0 ) );
124 } else {
125 bit = 0;
126 }
127 write_bit ( basher, SPI_BIT_MOSI, bit );
128 } else {
129 uint8_t *byte;
130
131 /* Shift data in */
132 bit = read_bit ( basher, SPI_BIT_MISO );
133 if ( data_in ) {
134 DBGCP ( spibit, "SPIBIT %p read bit %d\n",
135 spibit, ( bit ? 1 : 0 ) );
136 byte = ( data_in + byte_offset );
137 *byte &= ~byte_mask;
138 *byte |= ( bit & byte_mask );
139 }
140 }
141
142 /* Toggle clock line */
143 spi_bit_delay();
144 sclk ^= 1;
145 write_bit ( basher, SPI_BIT_SCLK, sclk );
146 }
147 }
148
149 /**
150 * Read/write data via SPI bit-bashing bus
151 *
152 * @v bus SPI bus
153 * @v device SPI device
154 * @v command Command
155 * @v address Address to read/write (<0 for no address)
156 * @v data_out TX data buffer (or NULL)
157 * @v data_in RX data buffer (or NULL)
158 * @v len Length of transfer
159 * @ret rc Return status code
160 */
161 static int spi_bit_rw ( struct spi_bus *bus, struct spi_device *device,
162 unsigned int command, int address,
163 const void *data_out, void *data_in, size_t len ) {
164 struct spi_bit_basher *spibit
165 = container_of ( bus, struct spi_bit_basher, bus );
166 uint32_t tmp_command;
167 uint32_t tmp_address;
168 uint32_t tmp_address_detect;
169
170 /* Open bit-bashing interface */
171 open_bit ( &spibit->basher );
172
173 /* Deassert chip select to reset specified slave */
174 spi_bit_set_slave_select ( spibit, device->slave, DESELECT_SLAVE );
175
176 /* Set clock line to idle state */
177 write_bit ( &spibit->basher, SPI_BIT_SCLK,
178 ( bus->mode & SPI_MODE_CPOL ) );
179
180 /* Assert chip select on specified slave */
181 spi_bit_set_slave_select ( spibit, device->slave, SELECT_SLAVE );
182
183 /* Transmit command */
184 assert ( device->command_len <= ( 8 * sizeof ( tmp_command ) ) );
185 tmp_command = cpu_to_le32 ( command );
186 spi_bit_transfer ( spibit, &tmp_command, NULL, device->command_len,
187 SPI_BIT_BIG_ENDIAN );
188
189 /* Transmit address, if present */
190 if ( address >= 0 ) {
191 assert ( device->address_len <= ( 8 * sizeof ( tmp_address )));
192 tmp_address = cpu_to_le32 ( address );
193 if ( device->address_len == SPI_AUTODETECT_ADDRESS_LEN ) {
194 /* Autodetect address length. This relies on
195 * the device responding with a dummy zero
196 * data bit before the first real data bit.
197 */
198 DBGC ( spibit, "SPIBIT %p autodetecting device "
199 "address length\n", spibit );
200 assert ( address == 0 );
201 device->address_len = 0;
202 do {
203 spi_bit_transfer ( spibit, &tmp_address,
204 &tmp_address_detect, 1,
205 SPI_BIT_BIG_ENDIAN );
206 device->address_len++;
207 } while ( le32_to_cpu ( tmp_address_detect ) & 1 );
208 DBGC ( spibit, "SPIBIT %p autodetected device address "
209 "length %d\n", spibit, device->address_len );
210 } else {
211 spi_bit_transfer ( spibit, &tmp_address, NULL,
212 device->address_len,
213 SPI_BIT_BIG_ENDIAN );
214 }
215 }
216
217 /* Transmit/receive data */
218 spi_bit_transfer ( spibit, data_out, data_in, ( len * 8 ),
219 spibit->endianness );
220
221 /* Deassert chip select on specified slave */
222 spi_bit_set_slave_select ( spibit, device->slave, DESELECT_SLAVE );
223
224 /* Close bit-bashing interface */
225 close_bit ( &spibit->basher );
226
227 return 0;
228 }
229
230 /**
231 * Initialise SPI bit-bashing interface
232 *
233 * @v spibit SPI bit-bashing interface
234 */
235 void init_spi_bit_basher ( struct spi_bit_basher *spibit ) {
236 assert ( &spibit->basher.op->read != NULL );
237 assert ( &spibit->basher.op->write != NULL );
238 spibit->bus.rw = spi_bit_rw;
239 }