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., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19 FILE_LICENCE ( GPL2_OR_LATER );
20
21 #include <stddef.h>
22 #include <stdint.h>
23 #include <string.h>
24 #include <byteswap.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <unistd.h>
28 #include <gpxe/bitbash.h>
29 #include <gpxe/spi_bit.h>
30
31 /** @file
32 *
33 * SPI bit-bashing interface
34 *
35 */
36
37 /** Delay between SCLK changes and around SS changes */
spi_bit_delay(void)38 static void spi_bit_delay ( void ) {
39 udelay ( SPI_BIT_UDELAY );
40 }
41
42 /** Chip select line will be asserted */
43 #define SELECT_SLAVE 0
44
45 /** Chip select line will be deasserted */
46 #define DESELECT_SLAVE SPI_MODE_SSPOL
47
48 /**
49 * Select/deselect slave
50 *
51 * @v spibit SPI bit-bashing interface
52 * @v slave Slave number
53 * @v state Slave select state
54 *
55 * @c state must be @c SELECT_SLAVE or @c DESELECT_SLAVE.
56 */
spi_bit_set_slave_select(struct spi_bit_basher * spibit,unsigned int slave,unsigned int state)57 static void spi_bit_set_slave_select ( struct spi_bit_basher *spibit,
58 unsigned int slave,
59 unsigned int state ) {
60 struct bit_basher *basher = &spibit->basher;
61
62 state ^= ( spibit->bus.mode & SPI_MODE_SSPOL );
63 DBGC2 ( spibit, "SPIBIT %p setting slave %d select %s\n",
64 spibit, slave, ( state ? "high" : "low" ) );
65
66 spi_bit_delay();
67 write_bit ( basher, SPI_BIT_SS ( slave ), state );
68 spi_bit_delay();
69 }
70
71 /**
72 * Transfer bits over SPI bit-bashing bus
73 *
74 * @v bus SPI bus
75 * @v data_out TX data buffer (or NULL)
76 * @v data_in RX data buffer (or NULL)
77 * @v len Length of transfer (in @b bits)
78 * @v endianness Endianness of this data transfer
79 *
80 * This issues @c len clock cycles on the SPI bus, shifting out data
81 * from the @c data_out buffer to the MOSI line and shifting in data
82 * from the MISO line to the @c data_in buffer. If @c data_out is
83 * NULL, then the data sent will be all zeroes. If @c data_in is
84 * NULL, then the incoming data will be discarded.
85 */
spi_bit_transfer(struct spi_bit_basher * spibit,const void * data_out,void * data_in,unsigned int len,int endianness)86 static void spi_bit_transfer ( struct spi_bit_basher *spibit,
87 const void *data_out, void *data_in,
88 unsigned int len, int endianness ) {
89 struct spi_bus *bus = &spibit->bus;
90 struct bit_basher *basher = &spibit->basher;
91 unsigned int sclk = ( ( bus->mode & SPI_MODE_CPOL ) ? 1 : 0 );
92 unsigned int cpha = ( ( bus->mode & SPI_MODE_CPHA ) ? 1 : 0 );
93 unsigned int bit_offset;
94 unsigned int byte_offset;
95 unsigned int byte_mask;
96 unsigned int bit;
97 unsigned int step;
98
99 DBGC2 ( spibit, "SPIBIT %p transferring %d bits in mode %#x\n",
100 spibit, len, bus->mode );
101
102 for ( step = 0 ; step < ( len * 2 ) ; step++ ) {
103 /* Calculate byte offset and byte mask */
104 bit_offset = ( ( endianness == SPI_BIT_BIG_ENDIAN ) ?
105 ( len - ( step / 2 ) - 1 ) : ( step / 2 ) );
106 byte_offset = ( bit_offset / 8 );
107 byte_mask = ( 1 << ( bit_offset % 8 ) );
108
109 /* Shift data in or out */
110 if ( sclk == cpha ) {
111 const uint8_t *byte;
112
113 /* Shift data out */
114 if ( data_out ) {
115 byte = ( data_out + byte_offset );
116 bit = ( *byte & byte_mask );
117 DBGCP ( spibit, "SPIBIT %p wrote bit %d\n",
118 spibit, ( bit ? 1 : 0 ) );
119 } else {
120 bit = 0;
121 }
122 write_bit ( basher, SPI_BIT_MOSI, bit );
123 } else {
124 uint8_t *byte;
125
126 /* Shift data in */
127 bit = read_bit ( basher, SPI_BIT_MISO );
128 if ( data_in ) {
129 DBGCP ( spibit, "SPIBIT %p read bit %d\n",
130 spibit, ( bit ? 1 : 0 ) );
131 byte = ( data_in + byte_offset );
132 *byte &= ~byte_mask;
133 *byte |= ( bit & byte_mask );
134 }
135 }
136
137 /* Toggle clock line */
138 spi_bit_delay();
139 sclk ^= 1;
140 write_bit ( basher, SPI_BIT_SCLK, sclk );
141 }
142 }
143
144 /**
145 * Read/write data via SPI bit-bashing bus
146 *
147 * @v bus SPI bus
148 * @v device SPI device
149 * @v command Command
150 * @v address Address to read/write (<0 for no address)
151 * @v data_out TX data buffer (or NULL)
152 * @v data_in RX data buffer (or NULL)
153 * @v len Length of transfer
154 * @ret rc Return status code
155 */
spi_bit_rw(struct spi_bus * bus,struct spi_device * device,unsigned int command,int address,const void * data_out,void * data_in,size_t len)156 static int spi_bit_rw ( struct spi_bus *bus, struct spi_device *device,
157 unsigned int command, int address,
158 const void *data_out, void *data_in, size_t len ) {
159 struct spi_bit_basher *spibit
160 = container_of ( bus, struct spi_bit_basher, bus );
161 uint32_t tmp_command;
162 uint32_t tmp_address;
163 uint32_t tmp_address_detect;
164
165 /* Set clock line to idle state */
166 write_bit ( &spibit->basher, SPI_BIT_SCLK,
167 ( bus->mode & SPI_MODE_CPOL ) );
168
169 /* Assert chip select on specified slave */
170 spi_bit_set_slave_select ( spibit, device->slave, SELECT_SLAVE );
171
172 /* Transmit command */
173 assert ( device->command_len <= ( 8 * sizeof ( tmp_command ) ) );
174 tmp_command = cpu_to_le32 ( command );
175 spi_bit_transfer ( spibit, &tmp_command, NULL, device->command_len,
176 SPI_BIT_BIG_ENDIAN );
177
178 /* Transmit address, if present */
179 if ( address >= 0 ) {
180 assert ( device->address_len <= ( 8 * sizeof ( tmp_address )));
181 tmp_address = cpu_to_le32 ( address );
182 if ( device->address_len == SPI_AUTODETECT_ADDRESS_LEN ) {
183 /* Autodetect address length. This relies on
184 * the device responding with a dummy zero
185 * data bit before the first real data bit.
186 */
187 DBGC ( spibit, "SPIBIT %p autodetecting device "
188 "address length\n", spibit );
189 assert ( address == 0 );
190 device->address_len = 0;
191 do {
192 spi_bit_transfer ( spibit, &tmp_address,
193 &tmp_address_detect, 1,
194 SPI_BIT_BIG_ENDIAN );
195 device->address_len++;
196 } while ( le32_to_cpu ( tmp_address_detect ) & 1 );
197 DBGC ( spibit, "SPIBIT %p autodetected device address "
198 "length %d\n", spibit, device->address_len );
199 } else {
200 spi_bit_transfer ( spibit, &tmp_address, NULL,
201 device->address_len,
202 SPI_BIT_BIG_ENDIAN );
203 }
204 }
205
206 /* Transmit/receive data */
207 spi_bit_transfer ( spibit, data_out, data_in, ( len * 8 ),
208 spibit->endianness );
209
210 /* Deassert chip select on specified slave */
211 spi_bit_set_slave_select ( spibit, device->slave, DESELECT_SLAVE );
212
213 return 0;
214 }
215
216 /**
217 * Initialise SPI bit-bashing interface
218 *
219 * @v spibit SPI bit-bashing interface
220 */
init_spi_bit_basher(struct spi_bit_basher * spibit)221 void init_spi_bit_basher ( struct spi_bit_basher *spibit ) {
222 assert ( &spibit->basher.op->read != NULL );
223 assert ( &spibit->basher.op->write != NULL );
224 spibit->bus.rw = spi_bit_rw;
225 }
226