tool/mbed/mbed-sdk/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC81X/i2c_api.c

   1 /* mbed Microcontroller Library
   2  * Copyright (c) 2006-2013 ARM Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include "i2c_api.h"
  17 #include "cmsis.h"
  18 #include "pinmap.h"
  19
  20 #if DEVICE_I2C
  21
  22 static const SWM_Map SWM_I2C_SDA[] = {
  23     {7, 24},
  24 };
  25
  26 static const SWM_Map SWM_I2C_SCL[] = {
  27     {8, 0},
  28 };
  29
  30 static uint8_t repeated_start = 0;
  31
  32 #define I2C_DAT(x)          (x->i2c->MSTDAT)
  33 #define I2C_STAT(x)         ((x->i2c->STAT >> 1) & (0x07))
  34
  35 static inline int i2c_status(i2c_t *obj) {
  36     return I2C_STAT(obj);
  37 }
  38
  39 // Wait until the Serial Interrupt (SI) is set
  40 static int i2c_wait_SI(i2c_t *obj) {
  41     int timeout = 0;
  42     while (!(obj->i2c->STAT & (1 << 0))) {
  43         timeout++;
  44         if (timeout > 100000) return -1;
  45     }
  46     return 0;
  47 }
  48
  49 static inline void i2c_interface_enable(i2c_t *obj) {
  50     obj->i2c->CFG |= (1 << 0);
  51 }
  52
  53 static inline void i2c_power_enable(i2c_t *obj) {
  54     LPC_SYSCON->SYSAHBCLKCTRL |= (1<<5);
  55     LPC_SYSCON->PRESETCTRL &= ~(0x1<<6);
  56     LPC_SYSCON->PRESETCTRL |= (0x1<<6);
  57 }
  58
  59 void i2c_init(i2c_t *obj, PinName sda, PinName scl) {
  60     obj->i2c = (LPC_I2C_TypeDef *)LPC_I2C;
  61
  62     const SWM_Map *swm;
  63     uint32_t regVal;
  64
  65     swm = &SWM_I2C_SDA[0];
  66     regVal = LPC_SWM->PINASSIGN[swm->n] & ~(0xFF << swm->offset);
  67     LPC_SWM->PINASSIGN[swm->n] = regVal |  (sda   << swm->offset);
  68
  69     swm = &SWM_I2C_SCL[0];
  70     regVal = LPC_SWM->PINASSIGN[swm->n] & ~(0xFF << swm->offset);
  71     LPC_SWM->PINASSIGN[swm->n] = regVal |  (scl   << swm->offset);
  72
  73     // enable power
  74     i2c_power_enable(obj);
  75     // set default frequency at 100k
  76     i2c_frequency(obj, 100000);
  77     i2c_interface_enable(obj);
  78 }
  79
  80 //Actually Wrong. Spec says: First store Address in DAT before setting STA !
  81 //Undefined state when using single byte I2C operations and too much delay
  82 //between i2c_start and do_i2c_write(Address).
  83 //Also note that lpc812 will immediately continue reading a byte when Address b0 == 1
  84 inline int i2c_start(i2c_t *obj) {
  85     int status = 0;
  86     if (repeated_start) {
  87         obj->i2c->MSTCTL = (1 << 1) | (1 << 0);
  88         repeated_start = 0;
  89     } else {
  90         obj->i2c->MSTCTL = (1 << 1);
  91     }
  92     return status;
  93 }
  94
  95 //Generate Stop condition and wait until bus is Idle
  96 //Will also send NAK for previous RD
  97 inline int i2c_stop(i2c_t *obj) {
  98     int timeout = 0;
  99
 100     obj->i2c->MSTCTL = (1 << 2) | (1 << 0); // STP bit and Continue bit. Sends NAK to complete previous RD
 101
 102     //Spin until Ready (b0 == 1)and Status is Idle (b3..b1 == 000)
 103     while ((obj->i2c->STAT & ((7 << 1) | (1 << 0))) != ((0 << 1) | (1 << 0))) {
 104         timeout ++;
 105         if (timeout > 100000) return 1;
 106     }
 107
 108     return 0;
 109 }
 110
 111 static inline int i2c_do_write(i2c_t *obj, int value, uint8_t addr) {
 112     // write the data
 113     I2C_DAT(obj) = value;
 114
 115     if (!addr)
 116         obj->i2c->MSTCTL = (1 << 0);
 117
 118     // wait and return status
 119     i2c_wait_SI(obj);
 120     return i2c_status(obj);
 121 }
 122
 123 static inline int i2c_do_read(i2c_t *obj, int last) {
 124     // wait for it to arrive
 125     i2c_wait_SI(obj);
 126     if (!last)
 127         obj->i2c->MSTCTL = (1 << 0);
 128
 129     // return the data
 130     return (I2C_DAT(obj) & 0xFF);
 131 }
 132
 133 void i2c_frequency(i2c_t *obj, int hz) {
 134     // No peripheral clock divider on the M0
 135     uint32_t PCLK = SystemCoreClock;
 136
 137     uint32_t clkdiv = PCLK / (hz * 4) - 1;
 138
 139     obj->i2c->DIV = clkdiv;
 140     obj->i2c->MSTTIME = 0;
 141 }
 142
 143 // The I2C does a read or a write as a whole operation
 144 // There are two types of error conditions it can encounter
 145 //  1) it can not obtain the bus
 146 //  2) it gets error responses at part of the transmission
 147 //
 148 // We tackle them as follows:
 149 //  1) we retry until we get the bus. we could have a "timeout" if we can not get it
 150 //      which basically turns it in to a 2)
 151 //  2) on error, we use the standard error mechanisms to report/debug
 152 //
 153 // Therefore an I2C transaction should always complete. If it doesn't it is usually
 154 // because something is setup wrong (e.g. wiring), and we don't need to programatically
 155 // check for that
 156
 157 //New version WH, Tested OK for Start and Repeated Start
 158 //Old version was Wrong: Calls i2c_start without setting address, i2c_do_read continues before checking status, status check for wrong value
 159 int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {
 160     int count, status;
 161
 162     //Store the address+RD and then generate STA
 163     I2C_DAT(obj) = address | 0x01;
 164     i2c_start(obj);
 165
 166     // Wait for completion of STA and Sending of SlaveAddress+RD and first Read byte
 167     i2c_wait_SI(obj);
 168     status = i2c_status(obj);
 169     if (status == 0x03) { // NAK on SlaveAddress
 170         i2c_stop(obj);
 171         return I2C_ERROR_NO_SLAVE;
 172     }
 173
 174     // Read in all except last byte
 175     for (count = 0; count < (length-1); count++) {
 176
 177       // Wait for it to arrive, note that first byte read after address+RD is already waiting
 178       i2c_wait_SI(obj);
 179       status = i2c_status(obj);
 180       if (status != 0x01) { // RX RDY
 181         i2c_stop(obj);
 182         return count;
 183       }
 184       data[count] = I2C_DAT(obj) & 0xFF; // Store read byte
 185
 186       obj->i2c->MSTCTL = (1 << 0); // Send ACK and Continue to read
 187     }
 188
 189     // Read final byte
 190     // Wait for it to arrive
 191     i2c_wait_SI(obj);
 192
 193     status = i2c_status(obj);
 194     if (status != 0x01) { // RX RDY
 195       i2c_stop(obj);
 196       return count;
 197     }
 198     data[count] = I2C_DAT(obj) & 0xFF; // Store final read byte
 199
 200     // If not repeated start, send stop.
 201     if (stop) {
 202         i2c_stop(obj); // Also sends NAK for last read byte
 203     } else {
 204         repeated_start = 1;
 205     }
 206
 207     return length;
 208 }
 209
 210
 211
 212 //New version WH, Tested OK for Start and Repeated Start
 213 //Old version was Wrong: Calls i2c_start without setting address first
 214 int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) {
 215     int i, status;
 216
 217     //Store the address+/WR and then generate STA
 218     I2C_DAT(obj) = address & 0xFE;
 219     i2c_start(obj);
 220
 221     // Wait for completion of STA and Sending of SlaveAddress+/WR
 222     i2c_wait_SI(obj);
 223     status = i2c_status(obj);
 224     if (status == 0x03) { // NAK SlaveAddress
 225         i2c_stop(obj);
 226         return I2C_ERROR_NO_SLAVE;
 227     }
 228
 229     //Write all bytes
 230     for (i=0; i<length; i++) {
 231         status = i2c_do_write(obj, data[i], 0);
 232         if (status != 0x02) { // TX RDY. Handles a Slave NAK on datawrite
 233             i2c_stop(obj);
 234             return i;
 235         }
 236     }
 237
 238     // If not repeated start, send stop.
 239     if (stop) {
 240         i2c_stop(obj);
 241     } else {
 242         repeated_start = 1;
 243     }
 244
 245     return length;
 246 }
 247
 248
 249
 250 void i2c_reset(i2c_t *obj) {
 251     i2c_stop(obj);
 252 }
 253
 254 int i2c_byte_read(i2c_t *obj, int last) {
 255     return (i2c_do_read(obj, last) & 0xFF);
 256 }
 257
 258 int i2c_byte_write(i2c_t *obj, int data) {
 259     int ack;
 260     int status = i2c_do_write(obj, (data & 0xFF), 0);
 261
 262     switch(status) {
 263         case 2:
 264             ack = 1;
 265             break;
 266         default:
 267             ack = 0;
 268             break;
 269     }
 270
 271     return ack;
 272 }
 273
 274 #if DEVICE_I2CSLAVE
 275
 276 #define I2C_SLVDAT(x)        (x->i2c->SLVDAT)
 277 #define I2C_SLVSTAT(x)      ((x->i2c->STAT >> 9) & (0x03))
 278 #define I2C_SLVSI(x)        ((x->i2c->STAT >> 8) & (0x01))
 279 //#define I2C_SLVCNT(x)        (x->i2c->SLVCTL = (1 << 0))
 280 //#define I2C_SLVNAK(x)        (x->i2c->SLVCTL = (1 << 1))
 281
 282 #if(0)
 283 // Wait until the Slave Serial Interrupt (SI) is set
 284 // Timeout when it takes too long.
 285 static int i2c_wait_slave_SI(i2c_t *obj) {
 286     int timeout = 0;
 287     while (!(obj->i2c->STAT & (1 << 8))) {
 288         timeout++;
 289         if (timeout > 100000) return -1;
 290     }
 291     return 0;
 292 }
 293 #endif
 294
 295 void i2c_slave_mode(i2c_t *obj, int enable_slave) {
 296
 297   if (enable_slave) {
 298 //    obj->i2c->CFG &= ~(1 << 0); //Disable Master mode
 299     obj->i2c->CFG |=  (1 << 1); //Enable Slave mode
 300   }
 301   else {
 302 //    obj->i2c->CFG |=  (1 << 0); //Enable Master mode
 303     obj->i2c->CFG &= ~(1 << 1); //Disable Slave mode
 304   }
 305 }
 306
 307 // Wait for next I2C event and find out what is going on
 308 //
 309 int i2c_slave_receive(i2c_t *obj) {
 310   int addr;
 311
 312   // Check if there is any data pending
 313   if (! I2C_SLVSI(obj)) {
 314     return 0; //NoData
 315   };
 316
 317   // Check State
 318   switch(I2C_SLVSTAT(obj)) {
 319     case 0x0: // Slave address plus R/W received
 320               // At least one of the four slave addresses has been matched by hardware.
 321               // You can figure out which address by checking Slave address match Index in STAT register.
 322
 323               // Get the received address
 324               addr = I2C_SLVDAT(obj) & 0xFF;
 325               // Send ACK on address and Continue
 326               obj->i2c->SLVCTL = (1 << 0);
 327
 328               if (addr == 0x00) {
 329                 return 2; //WriteGeneral
 330               }
 331               //check the RW bit
 332               if ((addr & 0x01) == 0x01) {
 333                 return 1; //ReadAddressed
 334               }
 335               else {
 336                 return 3; //WriteAddressed
 337               }
 338               //break;
 339
 340     case 0x1: // Slave receive. Received data is available (Slave Receiver mode).
 341               // Oops, should never get here...
 342               obj->i2c->SLVCTL = (1 << 1);  // Send NACK on received data, try to recover...
 343               return 0; //NoData
 344
 345     case 0x2: // Slave transmit. Data can be transmitted (Slave Transmitter mode).
 346               // Oops, should never get here...
 347               I2C_SLVDAT(obj) = 0xFF;       // Send dummy data for transmission
 348               obj->i2c->SLVCTL = (1 << 0);  // Continue and try to recover...
 349               return 0; //NoData
 350
 351     case 0x3: // Reserved.
 352     default:  // Oops, should never get here...
 353               obj->i2c->SLVCTL = (1 << 0);  // Continue and try to recover...
 354               return 0; //NoData
 355               //break;
 356   } //switch status
 357 }
 358
 359 // The dedicated I2C Slave byte read and byte write functions need to be called
 360 // from 'common' mbed I2CSlave API for devices that have separate Master and
 361 // Slave engines such as the lpc812 and lpc1549.
 362
 363 //Called when Slave is addressed for Write, Slave will receive Data in polling mode
 364 //Parameter last=1 means received byte will be NACKed.
 365 int i2c_slave_byte_read(i2c_t *obj, int last) {
 366   int data;
 367
 368   // Wait for data
 369   while (!I2C_SLVSI(obj)); // Wait forever
 370 //if (i2c_wait_slave_SI(obj) != 0) {return -2;} // Wait with timeout
 371
 372   // Dont bother to check State, were not returning it anyhow..
 373 //if (I2C_SLVSTAT(obj)) == 0x01) {
 374   // Slave receive. Received data is available (Slave Receiver mode).
 375 //};
 376
 377   data = I2C_SLVDAT(obj) & 0xFF; // Get and store the received data
 378   if (last) {
 379     obj->i2c->SLVCTL = (1 << 1);  // Send NACK on received data and Continue
 380   }
 381   else {
 382     obj->i2c->SLVCTL = (1 << 0);  // Send ACK on data and Continue to read
 383   }
 384
 385   return data;
 386 }
 387
 388
 389 //Called when Slave is addressed for Read, Slave will send Data in polling mode
 390 //
 391 int i2c_slave_byte_write(i2c_t *obj, int data) {
 392
 393   // Wait until Ready
 394   while (!I2C_SLVSI(obj)); // Wait forever
 395 //  if (i2c_wait_slave_SI(obj) != 0) {return -2;} // Wait with timeout
 396
 397   // Check State
 398   switch(I2C_SLVSTAT(obj)) {
 399     case 0x0: // Slave address plus R/W received
 400               // At least one of the four slave addresses has been matched by hardware.
 401               // You can figure out which address by checking Slave address match Index in STAT register.
 402               // I2C Restart occurred
 403               return -1;
 404               //break;
 405     case 0x1: // Slave receive. Received data is available (Slave Receiver mode).
 406               // Should not get here...
 407               return -2;
 408               //break;
 409     case 0x2: // Slave transmit. Data can be transmitted (Slave Transmitter mode).
 410               I2C_SLVDAT(obj) = data & 0xFF; // Store the data for transmission
 411               obj->i2c->SLVCTL = (1 << 0);   // Continue to send
 412
 413               return 1;
 414               //break;
 415     case 0x3: // Reserved.
 416     default:
 417               // Should not get here...
 418               return -3;
 419               //break;
 420   } // switch status
 421 }
 422
 423
 424 //Called when Slave is addressed for Write, Slave will receive Data in polling mode
 425 //Parameter length (>=1) is the maximum allowable number of bytes. All bytes will be ACKed.
 426 int i2c_slave_read(i2c_t *obj, char *data, int length) {
 427   int count=0;
 428
 429   // Read and ACK all expected bytes
 430   while (count < length) {
 431     // Wait for data
 432     while (!I2C_SLVSI(obj)); // Wait forever
 433 //    if (i2c_wait_slave_SI(obj) != 0) {return -2;} // Wait with timeout
 434
 435     // Check State
 436     switch(I2C_SLVSTAT(obj)) {
 437       case 0x0: // Slave address plus R/W received
 438                 // At least one of the four slave addresses has been matched by hardware.
 439                 // You can figure out which address by checking Slave address match Index in STAT register.
 440                 // I2C Restart occurred
 441                 return -1;
 442                 //break;
 443
 444       case 0x1: // Slave receive. Received data is available (Slave Receiver mode).
 445                 data[count] = I2C_SLVDAT(obj) & 0xFF; // Get and store the received data
 446                 obj->i2c->SLVCTL = (1 << 0);          // Send ACK on data and Continue to read
 447                 break;
 448
 449       case 0x2: // Slave transmit. Data can be transmitted (Slave Transmitter mode).
 450       case 0x3: // Reserved.
 451       default:  // Should never get here...
 452                 return -2;
 453                 //break;
 454     } // switch status
 455
 456     count++;
 457   } // for all bytes
 458
 459   return count; // Received the expected number of bytes
 460 }
 461
 462
 463 //Called when Slave is addressed for Read, Slave will send Data in polling mode
 464 //Parameter length (>=1) is the maximum number of bytes. Exit when Slave byte is NACKed.
 465 int i2c_slave_write(i2c_t *obj, const char *data, int length) {
 466   int count;
 467
 468   // Send and all bytes or Exit on NAK
 469   for (count=0; count < length; count++) {
 470     // Wait until Ready for data
 471     while (!I2C_SLVSI(obj)); // Wait forever
 472 //    if (i2c_wait_slave_SI(obj) != 0) {return -2;} // Wait with timeout
 473
 474     // Check State
 475     switch(I2C_SLVSTAT(obj)) {
 476       case 0x0: // Slave address plus R/W received
 477                 // At least one of the four slave addresses has been matched by hardware.
 478                 // You can figure out which address by checking Slave address match Index in STAT register.
 479                 // I2C Restart occurred
 480                 return -1;
 481                 //break;
 482       case 0x1: // Slave receive. Received data is available (Slave Receiver mode).
 483                 // Should not get here...
 484                 return -2;
 485                 //break;
 486       case 0x2: // Slave transmit. Data can be transmitted (Slave Transmitter mode).
 487                 I2C_SLVDAT(obj) = data[count] & 0xFF; // Store the data for transmission
 488                 obj->i2c->SLVCTL = (1 << 0);          // Continue to send
 489                 break;
 490       case 0x3: // Reserved.
 491       default:
 492               // Should not get here...
 493               return -3;
 494               //break;
 495     } // switch status
 496   } // for all bytes
 497
 498   return length; // Transmitted the max number of bytes
 499 }
 500
 501
 502 // Set the four slave addresses.
 503 void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask) {
 504   obj->i2c->SLVADR0   = (address & 0xFE); // Store address in address 0 register
 505   obj->i2c->SLVADR1   = (0x00    & 0xFE); // Store general call write address in address 1 register
 506   obj->i2c->SLVADR2   = (0x01);           // Disable address 2 register
 507   obj->i2c->SLVADR3   = (0x01);           // Disable address 3 register
 508   obj->i2c->SLVQUAL0  = (mask & 0xFE);    // Qualifier mask for address 0 register. Any maskbit that is 1 will always be a match
 509 }
 510
 511 #endif
 512
 513 #endif