Thomas Byrne / mbed-src-stm32f030k6

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-src by mbed official

targets/hal/TARGET_NXP/TARGET_LPC81X/i2c_api.c@596:d25a30803853, 2015-07-21 (annotated)

Committer:
ersatzavian
Date:
Tue Jul 21 14:09:45 2015 -0700
Revision:
596:d25a30803853
Parent:
470:07f8455214b5 
added missing bracket probably I hope

Who changed what in which revision?

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