STM32: USB full-speed device driver
[bertos.git] / bertos / cpu / avr / drv / i2c_avr.c
1 /**
2  * \file
3  * <!--
4  * This file is part of BeRTOS.
5  *
6  * Bertos is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * As a special exception, you may use this file as part of a free software
21  * library without restriction.  Specifically, if other files instantiate
22  * templates or use macros or inline functions from this file, or you compile
23  * this file and link it with other files to produce an executable, this
24  * file does not by itself cause the resulting executable to be covered by
25  * the GNU General Public License.  This exception does not however
26  * invalidate any other reasons why the executable file might be covered by
27  * the GNU General Public License.
28  *
29  * Copyright 2003, 2004, 2005 Develer S.r.l. (http://www.develer.com/)
30  *
31  * -->
32  *
33  * \brief Driver for the AVR ATMega TWI (implementation)
34  *
35  * \author Stefano Fedrigo <aleph@develer.com>
36  * \author Bernie Innocenti <bernie@codewiz.org>
37  * \author Daniele Basile <asterix@develer.com>
38  */
39
40
41 #include "cfg/cfg_i2c.h"
42
43 #include <hw/hw_cpufreq.h>  /* CPU_FREQ */
44
45 #define LOG_LEVEL  I2C_LOG_LEVEL
46 #define LOG_FORMAT I2C_LOG_FORMAT
47
48 #include <cfg/log.h>
49
50 #include <cfg/debug.h>
51 #include <cfg/macros.h> // BV()
52 #include <cfg/module.h>
53
54 #include <cpu/detect.h>
55 #include <cpu/irq.h>
56 #include <drv/timer.h>
57 #include <drv/i2c.h>
58
59 #include <cpu/power.h>
60
61 #include <compat/twi.h>
62
63 #if !CONFIG_I2C_DISABLE_OLD_API
64
65 /* Wait for TWINT flag set: bus is ready */
66 #define WAIT_TWI_READY  do {} while (!(TWCR & BV(TWINT)))
67
68 /**
69  * Send START condition on the bus.
70  *
71  * \return true on success, false otherwise.
72  */
73 static bool i2c_builtin_start(void)
74 {
75         TWCR = BV(TWINT) | BV(TWSTA) | BV(TWEN);
76         WAIT_TWI_READY;
77
78         if (TW_STATUS == TW_START || TW_STATUS == TW_REP_START)
79                 return true;
80
81         LOG_ERR("!TW_(REP)START: %x\n", TWSR);
82         return false;
83 }
84
85
86 /**
87  * Send START condition and select slave for write.
88  * \c id is the device id comprehensive of address left shifted by 1.
89  * The LSB of \c id is ignored and reset to 0 for write operation.
90  *
91  * \return true on success, false otherwise.
92  */
93 bool i2c_builtin_start_w(uint8_t id)
94 {
95         /*
96          * Loop on the select write sequence: when the eeprom is busy
97          * writing previously sent data it will reply to the SLA_W
98          * control byte with a NACK.  In this case, we must
99          * keep trying until the eeprom responds with an ACK.
100          */
101         ticks_t start = timer_clock();
102         while (i2c_builtin_start())
103         {
104                 TWDR = id & ~I2C_READBIT;
105                 TWCR = BV(TWINT) | BV(TWEN);
106                 WAIT_TWI_READY;
107
108                 if (TW_STATUS == TW_MT_SLA_ACK)
109                         return true;
110                 else if (TW_STATUS != TW_MT_SLA_NACK)
111                 {
112                         LOG_ERR("!TW_MT_SLA_(N)ACK: %x\n", TWSR);
113                         break;
114                 }
115                 else if (timer_clock() - start > ms_to_ticks(CONFIG_I2C_START_TIMEOUT))
116                 {
117                         LOG_ERR("Timeout on TWI_MT_START\n");
118                         break;
119                 }
120         }
121
122         return false;
123 }
124
125
126 /**
127  * Send START condition and select slave for read.
128  * \c id is the device id comprehensive of address left shifted by 1.
129  * The LSB of \c id is ignored and set to 1 for read operation.
130  *
131  * \return true on success, false otherwise.
132  */
133 bool i2c_builtin_start_r(uint8_t id)
134 {
135         if (i2c_builtin_start())
136         {
137                 TWDR = id | I2C_READBIT;
138                 TWCR = BV(TWINT) | BV(TWEN);
139                 WAIT_TWI_READY;
140
141                 if (TW_STATUS == TW_MR_SLA_ACK)
142                         return true;
143
144                 LOG_ERR("!TW_MR_SLA_ACK: %x\n", TWSR);
145         }
146
147         return false;
148 }
149
150
151 /**
152  * Send STOP condition.
153  */
154 void i2c_builtin_stop(void)
155 {
156         TWCR = BV(TWINT) | BV(TWEN) | BV(TWSTO);
157 }
158
159
160 /**
161  * Put a single byte in master transmitter mode
162  * to the selected slave device through the TWI bus.
163  *
164  * \return true on success, false on error.
165  */
166 bool i2c_builtin_put(const uint8_t data)
167 {
168         TWDR = data;
169         TWCR = BV(TWINT) | BV(TWEN);
170         WAIT_TWI_READY;
171         if (TW_STATUS != TW_MT_DATA_ACK)
172         {
173                 LOG_ERR("!TW_MT_DATA_ACK: %x\n", TWSR);
174                 return false;
175         }
176         return true;
177 }
178
179 /**
180  * Get 1 byte from slave in master transmitter mode
181  * to the selected slave device through the TWI bus.
182  * If \a ack is true issue a ACK after getting the byte,
183  * otherwise a NACK is issued.
184  *
185  * \return the byte read if ok, EOF on errors.
186  */
187 int i2c_builtin_get(bool ack)
188 {
189         TWCR = BV(TWINT) | BV(TWEN) | (ack ? BV(TWEA) : 0);
190         WAIT_TWI_READY;
191
192         if (ack)
193         {
194                 if (TW_STATUS != TW_MR_DATA_ACK)
195                 {
196                         LOG_ERR("!TW_MR_DATA_ACK: %x\n", TWSR);
197                         return EOF;
198                 }
199         }
200         else
201         {
202                 if (TW_STATUS != TW_MR_DATA_NACK)
203                 {
204                         LOG_ERR("!TW_MR_DATA_NACK: %x\n", TWSR);
205                         return EOF;
206                 }
207         }
208
209         /* avoid sign extension */
210         return (int)(uint8_t)TWDR;
211 }
212
213 #endif /* !CONFIG_I2C_DISABLE_OLD_API */
214
215 /*
216  * New Api
217  */
218 struct I2cHardware
219 {
220 };
221
222
223 /* Wait for TWINT flag set: bus is ready */
224 #define WAIT_READY() \
225         do { \
226                 while (!(TWCR & BV(TWINT))) \
227                         cpu_relax(); \
228         } while (0)
229
230 /**
231  * Send START condition on the bus.
232  */
233 INLINE bool i2c_hw_start(void)
234 {
235         TWCR = BV(TWINT) | BV(TWSTA) | BV(TWEN);
236         WAIT_READY();
237
238         if (TW_STATUS == TW_START || TW_STATUS == TW_REP_START)
239                 return true;
240
241         return false;
242 }
243
244 /**
245  * Send STOP condition.
246  */
247 INLINE void i2c_hw_stop(void)
248 {
249         TWCR = BV(TWINT) | BV(TWEN) | BV(TWSTO);
250 }
251
252 static void i2c_avr_start(I2c *i2c, uint16_t slave_addr)
253 {
254         /*
255          * Loop on the select write sequence: when the eeprom is busy
256          * writing previously sent data it will reply to the SLA_W
257          * control byte with a NACK.  In this case, we must
258          * keep trying until the slave responds with an ACK.
259          */
260         ticks_t start = timer_clock();
261         while (i2c_hw_start())
262         {
263                 uint8_t sla_ack = 0;
264                 uint8_t sla_nack = 0;
265                 if (I2C_TEST_START(i2c->flags) == I2C_START_W)
266                 {
267                         TWDR = slave_addr & ~I2C_READBIT;
268                         sla_ack = TW_MT_SLA_ACK;
269                         sla_nack = TW_MT_SLA_NACK;
270                 }
271                 else
272                 {
273                         TWDR = slave_addr | I2C_READBIT;
274                         sla_ack = TW_MR_SLA_ACK;
275                         sla_nack = TW_MR_SLA_NACK;
276                 }
277
278                 TWCR = BV(TWINT) | BV(TWEN);
279                 WAIT_READY();
280
281                 if (TW_STATUS == sla_ack)
282                         return;
283                 else if (TW_STATUS != sla_nack)
284                 {
285                         LOG_ERR("Start addr NACK[%x]\n", TWSR);
286                         i2c->errors |= I2C_NO_ACK;
287                         i2c_hw_stop();
288                         break;
289                 }
290                 else if (timer_clock() - start > ms_to_ticks(CONFIG_I2C_START_TIMEOUT))
291                 {
292                         LOG_ERR("Start timeout\n");
293                         i2c->errors |= I2C_START_TIMEOUT;
294                         i2c_hw_stop();
295                         break;
296                 }
297         }
298
299         LOG_ERR("I2c error\n");
300         i2c->errors |= I2C_ERR;
301         i2c_hw_stop();
302 }
303
304 static void i2c_avr_putc(I2c *i2c, const uint8_t data)
305 {
306
307         TWDR = data;
308         TWCR = BV(TWINT) | BV(TWEN);
309         WAIT_READY();
310
311         if (TW_STATUS != TW_MT_DATA_ACK)
312         {
313                 LOG_ERR("Data nack[%x]\n", TWSR);
314                 i2c->errors |= I2C_DATA_NACK;
315                 i2c_hw_stop();
316         }
317
318         if ((i2c->xfer_size == 1) && (I2C_TEST_STOP(i2c->flags) == I2C_STOP))
319                 i2c_hw_stop();
320 }
321
322 static uint8_t i2c_avr_getc(I2c *i2c)
323 {
324         uint8_t data_flag = 0;
325         if (i2c->xfer_size == 1)
326         {
327                 TWCR = BV(TWINT) | BV(TWEN);
328                 data_flag = TW_MR_DATA_NACK;
329         }
330         else
331         {
332                 TWCR = BV(TWINT) | BV(TWEN) | BV(TWEA);
333                 data_flag = TW_MR_DATA_ACK;
334         }
335
336         WAIT_READY();
337
338         if (TW_STATUS != data_flag)
339         {
340                 LOG_ERR("Data nack[%x]\n", TWSR);
341                 i2c->errors |= I2C_DATA_NACK;
342                 i2c_hw_stop();
343
344                 return 0xFF;
345         }
346
347         uint8_t data = TWDR;
348
349         if ((i2c->xfer_size == 1) && (I2C_TEST_STOP(i2c->flags) == I2C_STOP))
350                 i2c_hw_stop();
351
352         return data;
353 }
354
355
356 static const I2cVT i2c_avr_vt =
357 {
358         .start = i2c_avr_start,
359         .getc = i2c_avr_getc,
360         .putc = i2c_avr_putc,
361         .write = i2c_genericWrite,
362         .read = i2c_genericRead,
363 };
364
365 struct I2cHardware i2c_avr_hw[] =
366 {
367         { /* I2C0 */
368         },
369 };
370
371 /**
372  * Initialize I2C module.
373  */
374 void i2c_hw_init(I2c *i2c, int dev, uint32_t clock)
375 {
376         i2c->hw = &i2c_avr_hw[dev];
377         i2c->vt = &i2c_avr_vt;
378
379         ATOMIC(
380                 /*
381                  * This is pretty useless according to AVR's datasheet,
382                  * but it helps us driving the TWI data lines on boards
383                  * where the bus pull-up resistors are missing.  This is
384                  * probably due to some unwanted interaction between the
385                  * port pin and the TWI lines.
386                  */
387         #if CPU_AVR_ATMEGA64 || CPU_AVR_ATMEGA128 || CPU_AVR_ATMEGA1281 || CPU_AVR_ATMEGA1280
388                 PORTD |= BV(PD0) | BV(PD1);
389                 DDRD  |= BV(PD0) | BV(PD1);
390         #elif CPU_AVR_ATMEGA8
391                 PORTC |= BV(PC4) | BV(PC5);
392                 DDRC  |= BV(PC4) | BV(PC5);
393         #elif CPU_AVR_ATMEGA32
394                 PORTC |= BV(PC1) | BV(PC0);
395                 DDRC  |= BV(PC1) | BV(PC0);
396         #else
397                 #error Unsupported architecture
398         #endif
399
400                 /*
401                  * Set speed:
402                  * F = CPU_FREQ / (16 + 2*TWBR * 4^TWPS)
403                  */
404                 ASSERT(clock);
405                 #define TWI_PRESC    1       /* 4 ^ TWPS */
406
407                 TWBR = (CPU_FREQ / (2 * clock * TWI_PRESC)) - (8 / TWI_PRESC);
408                 TWSR = 0;
409                 TWCR = BV(TWEN);
410         );
411 }