We don't actually have a stdio.h header file. Our printf() functions are
[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 <errno.h>
23 #include <assert.h>
24 #include <timer.h>
25 #include <gpxe/bitbash.h>
26 #include <gpxe/spi.h>
27
28 /** @file
29  *
30  * SPI bit-bashing interface
31  *
32  */
33
34 /** Delay between SCLK changes and around SS changes */
35 static void spi_delay ( void ) {
36         udelay ( SPI_UDELAY );
37 }
38
39 /**
40  * Select/deselect slave
41  *
42  * @v spi               SPI bit-bashing interface
43  * @v slave             Slave number
44  * @v state             Slave select state
45  *
46  * @c state must be set to zero to select the specified slave, or to
47  * @c SPI_MODE_SSPOL to deselect the slave.
48  */
49 static void spi_bit_set_slave_select ( struct spi_bit_basher *spibit,
50                                        unsigned int slave,
51                                        unsigned int state ) {
52         struct bit_basher *basher = &spibit->basher;
53
54         state ^= ( spibit->spi.mode & SPI_MODE_SSPOL );
55         DBG ( "Setting slave %d select %s\n", slave,
56               ( state ? "high" : "low" ) );
57
58         spi_delay();
59         write_bit ( basher, SPI_BIT_SS ( slave ), state );
60         spi_delay();
61 }
62
63 /**
64  * Select slave
65  *
66  * @v spi               SPI interface
67  * @v slave             Slave number
68  */
69 static void spi_bit_select_slave ( struct spi_interface *spi,
70                                    unsigned int slave ) {
71         struct spi_bit_basher *spibit
72                 = container_of ( spi, struct spi_bit_basher, spi );
73
74         spibit->slave = slave;
75         spi_bit_set_slave_select ( spibit, slave, 0 );
76 }
77
78 /**
79  * Deselect slave
80  *
81  * @v spi               SPI interface
82  */
83 static void spi_bit_deselect_slave ( struct spi_interface *spi ) {
84         struct spi_bit_basher *spibit
85                 = container_of ( spi, struct spi_bit_basher, spi );
86
87         spi_bit_set_slave_select ( spibit, spibit->slave, SPI_MODE_SSPOL );
88 }
89
90 /**
91  * Transfer bits over SPI bit-bashing interface
92  *
93  * @v spi               SPI interface
94  * @v data_out          TX data buffer (or NULL)
95  * @v data_in           RX data buffer (or NULL)
96  * @v len               Length of transfer (in @b bits)
97  *
98  * This issues @c len clock cycles on the SPI bus, shifting out data
99  * from the @c data_out buffer to the MOSI line and shifting in data
100  * from the MISO line to the @c data_in buffer.  If @c data_out is
101  * NULL, then the data sent will be all zeroes.  If @c data_in is
102  * NULL, then the incoming data will be discarded.
103  */
104 static void spi_bit_transfer ( struct spi_interface *spi, const void *data_out,
105                                void *data_in, unsigned int len ) {
106         struct spi_bit_basher *spibit
107                 = container_of ( spi, struct spi_bit_basher, spi );
108         struct bit_basher *basher = &spibit->basher;
109         unsigned int sclk = ( ( spi->mode & SPI_MODE_CPOL ) ? 1 : 0 );
110         unsigned int cpha = ( ( spi->mode & SPI_MODE_CPHA ) ? 1 : 0 );
111         unsigned int offset;
112         unsigned int mask;
113         unsigned int bit;
114         int step;
115
116         DBG ( "Transferring %d bits in mode %x\n", len, spi->mode );
117
118         for ( step = ( ( len * 2 ) - 1 ) ; step >= 0 ; step-- ) {
119                 /* Calculate byte offset within data and bit mask */
120                 offset = ( step / 16 );
121                 mask = ( 1 << ( ( step % 16 ) / 2 ) );
122                 
123                 /* Shift data in or out */
124                 if ( sclk == cpha ) {
125                         const uint8_t *byte;
126
127                         /* Shift data out */
128                         if ( data_out ) {
129                                 byte = ( data_out + offset );
130                                 bit = ( *byte & mask );
131                         } else {
132                                 bit = 0;
133                         }
134                         write_bit ( basher, SPI_BIT_MOSI, bit );
135                 } else {
136                         uint8_t *byte;
137
138                         /* Shift data in */
139                         bit = read_bit ( basher, SPI_BIT_MISO );
140                         if ( data_in ) {
141                                 byte = ( data_in + offset );
142                                 *byte &= ~mask;
143                                 *byte |= ( bit & mask );
144                         }
145                 }
146
147                 /* Toggle clock line */
148                 spi_delay();
149                 sclk = ~sclk;
150                 write_bit ( basher, SPI_BIT_SCLK, sclk );
151         }
152 }
153
154 /**
155  * Initialise SPI bit-bashing interface
156  *
157  * @v spibit            SPI bit-bashing interface
158  */
159 void init_spi_bit_basher ( struct spi_bit_basher *spibit ) {
160         assert ( &spibit->basher.read != NULL );
161         assert ( &spibit->basher.write != NULL );
162         spibit->spi.select_slave = spi_bit_select_slave;
163         spibit->spi.deselect_slave = spi_bit_deselect_slave;
164         spibit->spi.transfer = spi_bit_transfer;
165 }