8b5060c19497a4a1f1ed7fb8cb0077be708d8e30
[people/asdlkf/gpxe.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., 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 */
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  */
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         DBG ( "Setting slave %d select %s\n", slave,
64               ( 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  */
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         DBG ( "Transferring %d bits in mode %x\n", len, bus->mode );
100
101         for ( step = 0 ; step < ( len * 2 ) ; step++ ) {
102                 /* Calculate byte offset and byte mask */
103                 bit_offset = ( ( endianness == SPI_BIT_BIG_ENDIAN ) ?
104                                ( len - ( step / 2 ) - 1 ) : ( step / 2 ) );
105                 byte_offset = ( bit_offset / 8 );
106                 byte_mask = ( 1 << ( bit_offset % 8 ) );
107
108                 /* Shift data in or out */
109                 if ( sclk == cpha ) {
110                         const uint8_t *byte;
111
112                         /* Shift data out */
113                         if ( data_out ) {
114                                 byte = ( data_out + byte_offset );
115                                 bit = ( *byte & byte_mask );
116                         } else {
117                                 bit = 0;
118                         }
119                         write_bit ( basher, SPI_BIT_MOSI, bit );
120                 } else {
121                         uint8_t *byte;
122
123                         /* Shift data in */
124                         bit = read_bit ( basher, SPI_BIT_MISO );
125                         if ( data_in ) {
126                                 byte = ( data_in + byte_offset );
127                                 *byte &= ~byte_mask;
128                                 *byte |= ( bit & byte_mask );
129                         }
130                 }
131
132                 /* Toggle clock line */
133                 spi_bit_delay();
134                 sclk = ~sclk;
135                 write_bit ( basher, SPI_BIT_SCLK, sclk );
136         }
137 }
138
139 /**
140  * Read/write data via SPI bit-bashing bus
141  *
142  * @v bus               SPI bus
143  * @v device            SPI device
144  * @v command           Command
145  * @v address           Address to read/write (<0 for no address)
146  * @v data_out          TX data buffer (or NULL)
147  * @v data_in           RX data buffer (or NULL)
148  * @v len               Length of transfer
149  * @ret rc              Return status code
150  */
151 static int spi_bit_rw ( struct spi_bus *bus, struct spi_device *device,
152                         unsigned int command, int address,
153                         const void *data_out, void *data_in, size_t len ) {
154         struct spi_bit_basher *spibit
155                 = container_of ( bus, struct spi_bit_basher, bus );
156         uint32_t tmp;
157
158         /* Set clock line to idle state */
159         write_bit ( &spibit->basher, SPI_BIT_SCLK, 
160                     ( bus->mode & SPI_MODE_CPOL ) );
161
162         /* Assert chip select on specified slave */
163         spi_bit_set_slave_select ( spibit, device->slave, SELECT_SLAVE );
164
165         /* Transmit command */
166         assert ( device->command_len <= ( 8 * sizeof ( tmp ) ) );
167         tmp = cpu_to_le32 ( command );
168         spi_bit_transfer ( spibit, &tmp, NULL, device->command_len,
169                            SPI_BIT_BIG_ENDIAN );
170
171         /* Transmit address, if present */
172         if ( address >= 0 ) {
173                 assert ( device->address_len <= ( 8 * sizeof ( tmp ) ) );
174                 tmp = cpu_to_le32 ( address );
175                 spi_bit_transfer ( spibit, &tmp, NULL, device->address_len,
176                                    SPI_BIT_BIG_ENDIAN );
177         }
178
179         /* Transmit/receive data */
180         spi_bit_transfer ( spibit, data_out, data_in, ( len * 8 ),
181                            spibit->endianness );
182
183         /* Deassert chip select on specified slave */
184         spi_bit_set_slave_select ( spibit, device->slave, DESELECT_SLAVE );
185
186         return 0;
187 }
188
189 /**
190  * Initialise SPI bit-bashing interface
191  *
192  * @v spibit            SPI bit-bashing interface
193  */
194 void init_spi_bit_basher ( struct spi_bit_basher *spibit ) {
195         assert ( &spibit->basher.op->read != NULL );
196         assert ( &spibit->basher.op->write != NULL );
197         spibit->bus.rw = spi_bit_rw;
198 }