462fd72e8ac6232adce51be8bce134ea26ace1fa
[people/xl0/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 #include <stddef.h>
20 #include <stdint.h>
21 #include <string.h>
22 #include <byteswap.h>
23 #include <errno.h>
24 #include <assert.h>
25 #include <timer.h>
26 #include <gpxe/bitbash.h>
27 #include <gpxe/spi_bit.h>
28
29 /** @file
30  *
31  * SPI bit-bashing interface
32  *
33  */
34
35 /** Delay between SCLK changes and around SS changes */
36 static void spi_bit_delay ( void ) {
37         udelay ( SPI_BIT_UDELAY );
38 }
39
40 /** Chip select line will be asserted */
41 #define SELECT_SLAVE 0
42
43 /** Chip select line will be deasserted */
44 #define DESELECT_SLAVE SPI_MODE_SSPOL
45
46 /**
47  * Select/deselect slave
48  *
49  * @v spibit            SPI bit-bashing interface
50  * @v slave             Slave number
51  * @v state             Slave select state
52  *
53  * @c state must be @c SELECT_SLAVE or @c DESELECT_SLAVE.
54  */
55 static void spi_bit_set_slave_select ( struct spi_bit_basher *spibit,
56                                        unsigned int slave,
57                                        unsigned int state ) {
58         struct bit_basher *basher = &spibit->basher;
59
60         state ^= ( spibit->bus.mode & SPI_MODE_SSPOL );
61         DBG ( "Setting slave %d select %s\n", slave,
62               ( state ? "high" : "low" ) );
63
64         spi_bit_delay();
65         write_bit ( basher, SPI_BIT_SS ( slave ), state );
66         spi_bit_delay();
67 }
68
69 /**
70  * Transfer bits over SPI bit-bashing bus
71  *
72  * @v bus               SPI bus
73  * @v data_out          TX data buffer (or NULL)
74  * @v data_in           RX data buffer (or NULL)
75  * @v len               Length of transfer (in @b bits)
76  *
77  * This issues @c len clock cycles on the SPI bus, shifting out data
78  * from the @c data_out buffer to the MOSI line and shifting in data
79  * from the MISO line to the @c data_in buffer.  If @c data_out is
80  * NULL, then the data sent will be all zeroes.  If @c data_in is
81  * NULL, then the incoming data will be discarded.
82  */
83 static void spi_bit_transfer ( struct spi_bit_basher *spibit,
84                                const void *data_out, void *data_in,
85                                unsigned int len ) {
86         struct spi_bus *bus = &spibit->bus;
87         struct bit_basher *basher = &spibit->basher;
88         unsigned int sclk = ( ( bus->mode & SPI_MODE_CPOL ) ? 1 : 0 );
89         unsigned int cpha = ( ( bus->mode & SPI_MODE_CPHA ) ? 1 : 0 );
90         unsigned int offset;
91         unsigned int mask;
92         unsigned int bit;
93         int step;
94
95         DBG ( "Transferring %d bits in mode %x\n", len, bus->mode );
96
97         for ( step = ( ( len * 2 ) - 1 ) ; step >= 0 ; step-- ) {
98                 /* Calculate byte offset within data and bit mask */
99                 offset = ( step / 16 );
100                 mask = ( 1 << ( ( step % 16 ) / 2 ) );
101                 
102                 /* Shift data in or out */
103                 if ( sclk == cpha ) {
104                         const uint8_t *byte;
105
106                         /* Shift data out */
107                         if ( data_out ) {
108                                 byte = ( data_out + offset );
109                                 bit = ( *byte & mask );
110                         } else {
111                                 bit = 0;
112                         }
113                         write_bit ( basher, SPI_BIT_MOSI, bit );
114                 } else {
115                         uint8_t *byte;
116
117                         /* Shift data in */
118                         bit = read_bit ( basher, SPI_BIT_MISO );
119                         if ( data_in ) {
120                                 byte = ( data_in + offset );
121                                 *byte &= ~mask;
122                                 *byte |= ( bit & mask );
123                         }
124                 }
125
126                 /* Toggle clock line */
127                 spi_bit_delay();
128                 sclk = ~sclk;
129                 write_bit ( basher, SPI_BIT_SCLK, sclk );
130         }
131 }
132
133 /**
134  * Read/write data via SPI bit-bashing bus
135  *
136  * @v bus               SPI bus
137  * @v device            SPI device
138  * @v command           Command
139  * @v address           Address to read/write (<0 for no address)
140  * @v data_out          TX data buffer (or NULL)
141  * @v data_in           RX data buffer (or NULL)
142  * @v len               Length of transfer (in @b words)
143  * @ret rc              Return status code
144  */
145 static int spi_bit_rw ( struct spi_bus *bus, struct spi_device *device,
146                         unsigned int command, int address,
147                         const void *data_out, void *data_in,
148                         unsigned int len ) {
149         struct spi_bit_basher *spibit
150                 = container_of ( bus, struct spi_bit_basher, bus );
151         struct spi_device_type *devtype = device->type;
152         uint32_t tmp;
153
154         /* Assert chip select on specified slave */
155         spi_bit_set_slave_select ( spibit, device->slave, SELECT_SLAVE );
156
157         /* Transmit command */
158         assert ( devtype->command_len <= ( 8 * sizeof ( tmp ) ) );
159         tmp = cpu_to_le32 ( command );
160         spi_bit_transfer ( spibit, &tmp, NULL, devtype->command_len );
161
162         /* Transmit address, if present */
163         if ( address >= 0 ) {
164                 assert ( devtype->address_len <= ( 8 * sizeof ( tmp ) ) );
165                 tmp = cpu_to_le32 ( address );
166                 spi_bit_transfer ( spibit, &tmp, NULL, devtype->address_len );
167         }
168
169         /* Transmit/receive data */
170         spi_bit_transfer ( spibit, data_out, data_in,
171                            ( len * devtype->word_len ) );
172
173         /* Deassert chip select on specified slave */
174         spi_bit_set_slave_select ( spibit, device->slave, DESELECT_SLAVE );
175
176         return 0;
177 }
178
179 /**
180  * Initialise SPI bit-bashing interface
181  *
182  * @v spibit            SPI bit-bashing interface
183  */
184 void init_spi_bit_basher ( struct spi_bit_basher *spibit ) {
185         assert ( &spibit->basher.op->read != NULL );
186         assert ( &spibit->basher.op->write != NULL );
187         spibit->bus.rw = spi_bit_rw;
188 }