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  */
  38
  39 #include <hw/hw_cpufreq.h>  /* CPU_FREQ */
  40
  41 #include "cfg/cfg_i2c.h"
  42
  43 #define LOG_LEVEL  I2C_LOG_LEVEL
  44 #define LOG_FORMAT I2C_LOG_FORMAT
  45
  46 #include <cfg/log.h>
  47
  48 #include <cfg/debug.h>
  49 #include <cfg/macros.h> // BV()
  50 #include <cfg/module.h>
  51
  52 #include <cpu/detect.h>
  53 #include <cpu/irq.h>
  54 #include <drv/timer.h>
  55 #include <drv/i2c.h>
  56
  57 #include <compat/twi.h>
  58
  59
  60 struct I2cHardware
  61 {
  62 };
  63
  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
 214
 215 static void i2c_avr_start(struct I2c *i2c, uint16_t slave_addr)
 216 {
 217         if (I2C_TEST_START(i2c->flags) == I2C_START_W)
 218         {
 219                 if (i2c_builtin_start_w(slave_addr))
 220                 {
 221                         LOG_ERR("Start timeout\n");
 222                         i2c->errors |= I2C_START_TIMEOUT;
 223                 }
 224         }
 225         else /* (I2C_TEST_START(i2c->flags) == I2C_START_R) */
 226         {
 227                 if (i2c_builtin_start_r(slave_addr))
 228                 {
 229                         LOG_ERR("Start r no ACK\n");
 230                         i2c->errors |= I2C_NO_ACK;
 231                 }
 232         }
 233 }
 234
 235 static void i2c_avr_put(I2c *i2c, const uint8_t data)
 236 {
 237         if (i2c_builtin_put(data))
 238         {
 239                 LOG_ERR("Start r no ACK\n");
 240                 i2c->errors |= I2C_DATA_NACK;
 241         }
 242
 243         if ((i2c->xfer_size == 1) && (I2C_TEST_STOP(i2c->flags) == I2C_STOP))
 244                 i2c_bitbang_stop();
 245 }
 246
 247 static uint8_t i2c_avr_get(I2c *i2c)
 248 {
 249         bool ack = true;
 250         if (i2c->xfer_size == 1)
 251                 ack = false;
 252
 253         uint8_t data = i2c_builtin_get(ack);
 254
 255         if ((i2c->xfer_size == 1) && (I2C_TEST_STOP(i2c->flags) == I2C_STOP))
 256                 i2c_bitbang_stop();
 257
 258         return data;
 259 }
 260
 261
 262 MOD_DEFINE(i2c);
 263
 264 /**
 265  * Initialize TWI module.
 266  */
 267 INLINE void i2c_avr_init(uint32_t clock)
 268 {
 269         ATOMIC(
 270                 /*
 271                  * This is pretty useless according to AVR's datasheet,
 272                  * but it helps us driving the TWI data lines on boards
 273                  * where the bus pull-up resistors are missing.  This is
 274                  * probably due to some unwanted interaction between the
 275                  * port pin and the TWI lines.
 276                  */
 277 #if CPU_AVR_ATMEGA64 || CPU_AVR_ATMEGA128 || CPU_AVR_ATMEGA1281
 278                 PORTD |= BV(PD0) | BV(PD1);
 279                 DDRD  |= BV(PD0) | BV(PD1);
 280 #elif CPU_AVR_ATMEGA8
 281                 PORTC |= BV(PC4) | BV(PC5);
 282                 DDRC  |= BV(PC4) | BV(PC5);
 283 #elif CPU_AVR_ATMEGA32
 284                 PORTC |= BV(PC1) | BV(PC0);
 285                 DDRC  |= BV(PC1) | BV(PC0);
 286 #else
 287                 #error Unsupported architecture
 288 #endif
 289
 290                 /*
 291                  * Set speed:
 292                  * F = CPU_FREQ / (16 + 2*TWBR * 4^TWPS)
 293                  */
 294                 ASSERT(clock);
 295                 #define TWI_PRESC   1       /* 4 ^ TWPS */
 296
 297                 TWBR = (CPU_FREQ / (2 * clock * TWI_PRESC)) - (8 / TWI_PRESC);
 298                 TWSR = 0;
 299                 TWCR = BV(TWEN);
 300         );
 301         MOD_INIT(i2c);
 302 }
 303
 304
 305 static const I2cVT i2c_lm3s_vt =
 306 {
 307         .start = i2c_avr_start,
 308         .get = i2c_avr_get,
 309         .put = i2c_avr_put,
 310         .send = i2c_swSend,
 311         .recv = i2c_swRecv,
 312 };
 313
 314 struct I2cHardware i2c_avr_hw[] =
 315 {
 316         { /* I2C0 */
 317         },
 318 };
 319
 320 /**
 321  * Initialize I2C module.
 322  */
 323 void i2c_hw_init(I2c *i2c, int dev, uint32_t clock)
 324 {
 325         i2c->hw = &i2c_avr_hw[dev];
 326         i2c->vt = &i2c_avr_vt;
 327
 328         i2c_avr_init(clock);
 329 }
 330
 331 void i2c_bitbang_init(void)
 332 {
 333         i2c_avr_init(CONFIG_I2C_FREQ);
 334 }
 335