cdb7b123fd762813f5115842dcd4cc90b06a9b0f
[aversive.git] / modules / comm / spi / spi.c
1 /*  
2  *  Copyright Droids Corporation (2008)
3  * 
4  *  This program is free software; you can redistribute it and/or modify
5  *  it under the terms of the GNU General Public License as published by
6  *  the Free Software Foundation; either version 2 of the License, or
7  *  (at your option) any later version.
8  *
9  *  This program is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  *
18  */
19
20 /*
21  * Author : Julien LE GUEN - jlg@jleguen.info
22  */
23
24 #include <aversive.h>
25 #include <aversive/parts.h>
26 #include <aversive/error.h>
27
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include <spi.h>
32 #include <spi_config.h>
33
34 /* internal structure to store SS pins */
35 typedef struct _ss_pin {
36         volatile uint8_t *port;
37         uint8_t bitnum;
38 } ss_pin_t;
39
40
41 /* global vars */
42 static volatile ss_pin_t g_ss_lines[SPI_MAX_SLAVES+1];
43 static volatile uint8_t g_ss_number;
44 static volatile spi_mode_t g_spi_mode;
45 static volatile uint8_t g_slave_selected;
46
47
48
49
50 /* 
51  * Register a pin as SS line
52  * Returns a unique identifier, or -1 on error
53  * There is always the physical SS line registered as 0
54  */
55 int8_t spi_register_ss_line(volatile uint8_t *port, uint8_t bitnum)
56 {
57         DEBUG(E_SPI, "Trying to register new SS line: port 0x%x, bitnum %d", port, bitnum);
58         /* too much SS lines (try to change SPI_MAX_SLAVES) */
59         if (g_ss_number >= SPI_MAX_SLAVES+1)
60                 return -1;
61         
62         g_ss_lines[g_ss_number].port = port;
63         g_ss_lines[g_ss_number].bitnum = bitnum;
64         *(port-1) |= _BV(bitnum); // was DDR(port) |= _BV(bitnum);
65         /* Unselected at first */
66         *port |= (_BV(bitnum));
67
68         NOTICE(E_SPI, "New Slave Line registered: %d", g_ss_number);
69
70         return g_ss_number++;
71 }
72
73
74 /*
75  *      Set data order (default: MSB first)
76  */
77 inline void spi_set_data_order(uint8_t order)
78 {
79         if (order == SPI_LSB_FIRST)
80                 SPCR |= _BV(DORD);
81         else
82                 SPCR &= ~(_BV(DORD));
83 }
84
85 /*
86  *      Get data order
87  */
88 inline uint8_t spi_get_data_order(void)
89 {
90         if (SPCR & _BV(DORD))
91                 return SPI_LSB_FIRST;
92         return SPI_MSB_FIRST;
93 }
94
95
96 /*
97  *      Initialize SPI
98  */
99 void spi_init(spi_mode_t mode, spi_format_t format, spi_clk_rate_t clk_rate)
100 {
101         NOTICE(E_SPI, "Init SPI: mode %d, format %d, clk_rate %d",
102                mode, format, clk_rate);
103
104         /* Configure SPI pins */
105         DDR(SCK_PORT) |= _BV(SCK_BIT);
106         DDR(MOSI_PORT) |= _BV(MOSI_BIT);
107         DDR(MISO_PORT) &= ~(_BV(MISO_BIT));
108         /* SS pin is not driven by SPI hardware 
109          * This is taken care of by spi_register_ss_line()
110          * EVEN for the "default" SS line */
111         g_ss_number = 0;
112         g_slave_selected = FALSE;
113
114         /* Registers init */
115 #ifdef PRR0
116         PRR0 &= ~(_BV(PRSPI));          /* Clear power reduction bit */
117 #endif
118         SPCR =  0;
119         SPSR =  0;
120
121         SPCR |= _BV(MSTR);              /* XXX Master only for now ! */
122         SPCR |= (uint8_t)format;        /* Clock polarity and phase */
123         
124         /* clockrate: SPR0, SPR1, SPI2X */
125         if (clk_rate & 0x01)
126                 SPR0_REG |= _BV(SPR0);
127         else
128                 SPR0_REG &= ~(_BV(SPR0));
129         if (clk_rate & 0x02)
130                 SPR1_REG |= _BV(SPR1);
131         else
132                 SPR1_REG &= ~(_BV(SPR1));
133         if (clk_rate & 0x10)
134                 SPI2X_REG |= _BV(SPI2X);
135         else
136                 SPI2X_REG &= ~(_BV(SPI2X));
137         
138         SPCR |= _BV(SPE);               /* Enable SPI */
139
140         g_spi_mode = SPI_MODE_MASTER;
141         NOTICE(E_SPI, "Init done");
142 }
143
144 /*
145  *      Returns the state of SPI
146  */
147 inline spi_mode_t spi_get_mode(void)
148 {
149         return g_spi_mode;
150 }
151
152 /*
153  *      Send a byte (and receive one)
154  *      Returns the received byte
155  */
156 uint8_t spi_send_and_receive_byte(uint8_t byte)
157 {
158         //DEBUG(E_SPI, "Sending 0x%x", byte);
159         /* Start transmission */
160         SPDR = byte;
161
162         /* Wait for transmission complete 
163          * Timings are VERY important, do not bypass this ! */
164         while(!(SPSR & (1<<SPIF)))
165                 ;
166         /* Return received byte */
167         return SPDR;
168 }
169
170 /*
171  *      Send a byte, discard the result
172  */
173 inline void spi_send_byte(uint8_t byte)
174 {
175         spi_send_and_receive_byte(byte);
176 }
177
178 /*
179  *      Receives a byte (sends a NULL)
180  */
181 uint8_t spi_receive_byte(void)
182 {
183         return spi_send_and_receive_byte(0x00);
184 }
185
186 /*
187  *      Activates the selected SS line
188  */
189 uint8_t spi_slave_select(uint8_t slave)
190 {
191         if (g_slave_selected) {
192                 ERROR(E_SPI, "A slave is already selected !");
193                 return EBUSY;
194         }
195
196         *(g_ss_lines[slave].port) &= ~(_BV(g_ss_lines[slave].bitnum));
197         g_slave_selected = TRUE;
198         return ESUCCESS;
199 }
200
201 /*
202  *      Desactivates the selected SS line
203  */
204 void spi_slave_deselect(uint8_t slave)
205 {
206         *(g_ss_lines[slave].port) |= (_BV(g_ss_lines[slave].bitnum));
207         g_slave_selected = FALSE;
208 }
209
210 /*
211  *      Display SS lines
212  */
213 void spi_display_ss_lines(void)
214 {
215         uint8_t i;
216         for (i = 0; i < g_ss_number; i++) {
217                 DEBUG(E_SPI, "SS%d: adr 0x%x bitnum %d value 0x%x",
218                       i,
219                       g_ss_lines[i].port,
220                       g_ss_lines[i].bitnum,
221                       *(g_ss_lines[i].port));
222         }
223 }