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 || CPU_AVR_ATMEGA2560
 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 }