mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/hal/TARGET_Freescale/TARGET_KLXX/i2c_api.c@178:a873352662d8, 2014-05-07 (annotated)

Committer:
mbed_official
Date:
Wed May 07 09:00:07 2014 +0100
Revision:
178:a873352662d8
Parent:
82:0b31dbcd4769
Child:
182:242346c42295
Synchronized with git revision 42a3edb815167b2aed138226781ff2ebcac662e4



Full URL: https://github.com/mbedmicro/mbed/commit/42a3edb815167b2aed138226781ff2ebcac662e4/

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 82:0b31dbcd4769 1 /* mbed Microcontroller Library
mbed_official 82:0b31dbcd4769 2 * Copyright (c) 2006-2013 ARM Limited
mbed_official 82:0b31dbcd4769 3 *
mbed_official 82:0b31dbcd4769 4 * Licensed under the Apache License, Version 2.0 (the "License");
mbed_official 82:0b31dbcd4769 5 * you may not use this file except in compliance with the License.
mbed_official 82:0b31dbcd4769 6 * You may obtain a copy of the License at
mbed_official 82:0b31dbcd4769 7 *
mbed_official 82:0b31dbcd4769 8 * http://www.apache.org/licenses/LICENSE-2.0
mbed_official 82:0b31dbcd4769 9 *
mbed_official 82:0b31dbcd4769 10 * Unless required by applicable law or agreed to in writing, software
mbed_official 82:0b31dbcd4769 11 * distributed under the License is distributed on an "AS IS" BASIS,
mbed_official 82:0b31dbcd4769 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
mbed_official 82:0b31dbcd4769 13 * See the License for the specific language governing permissions and
mbed_official 82:0b31dbcd4769 14 * limitations under the License.
mbed_official 82:0b31dbcd4769 15 */
mbed_official 82:0b31dbcd4769 16 #include "i2c_api.h"
mbed_official 82:0b31dbcd4769 17
mbed_official 82:0b31dbcd4769 18 #include "cmsis.h"
mbed_official 82:0b31dbcd4769 19 #include "pinmap.h"
mbed_official 82:0b31dbcd4769 20 #include "error.h"
mbed_official 82:0b31dbcd4769 21 #include "clk_freqs.h"
mbed_official 82:0b31dbcd4769 22 #include "PeripheralPins.h"
mbed_official 82:0b31dbcd4769 23
mbed_official 82:0b31dbcd4769 24 static const uint16_t ICR[0x40] = {
mbed_official 82:0b31dbcd4769 25 20, 22, 24, 26, 28,
mbed_official 82:0b31dbcd4769 26 30, 34, 40, 28, 32,
mbed_official 82:0b31dbcd4769 27 36, 40, 44, 48, 56,
mbed_official 82:0b31dbcd4769 28 68, 48, 56, 64, 72,
mbed_official 82:0b31dbcd4769 29 80, 88, 104, 128, 80,
mbed_official 82:0b31dbcd4769 30 96, 112, 128, 144, 160,
mbed_official 82:0b31dbcd4769 31 192, 240, 160, 192, 224,
mbed_official 82:0b31dbcd4769 32 256, 288, 320, 384, 480,
mbed_official 82:0b31dbcd4769 33 320, 384, 448, 512, 576,
mbed_official 82:0b31dbcd4769 34 640, 768, 960, 640, 768,
mbed_official 82:0b31dbcd4769 35 896, 1024, 1152, 1280, 1536,
mbed_official 82:0b31dbcd4769 36 1920, 1280, 1536, 1792, 2048,
mbed_official 82:0b31dbcd4769 37 2304, 2560, 3072, 3840
mbed_official 82:0b31dbcd4769 38 };
mbed_official 82:0b31dbcd4769 39
mbed_official 82:0b31dbcd4769 40
mbed_official 82:0b31dbcd4769 41 void i2c_init(i2c_t *obj, PinName sda, PinName scl) {
mbed_official 82:0b31dbcd4769 42 // determine the I2C to use
mbed_official 82:0b31dbcd4769 43 I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA);
mbed_official 82:0b31dbcd4769 44 I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL);
mbed_official 82:0b31dbcd4769 45 obj->i2c = (I2C_Type*)pinmap_merge(i2c_sda, i2c_scl);
mbed_official 82:0b31dbcd4769 46 if ((int)obj->i2c == NC) {
mbed_official 82:0b31dbcd4769 47 error("I2C pin mapping failed");
mbed_official 82:0b31dbcd4769 48 }
mbed_official 82:0b31dbcd4769 49
mbed_official 82:0b31dbcd4769 50 // enable power
mbed_official 82:0b31dbcd4769 51 switch ((int)obj->i2c) {
mbed_official 82:0b31dbcd4769 52 case I2C_0: SIM->SCGC5 |= 1 << 13; SIM->SCGC4 |= 1 << 6; break;
mbed_official 82:0b31dbcd4769 53 case I2C_1: SIM->SCGC5 |= 1 << 11; SIM->SCGC4 |= 1 << 7; break;
mbed_official 82:0b31dbcd4769 54 }
mbed_official 82:0b31dbcd4769 55
mbed_official 82:0b31dbcd4769 56 // set default frequency at 100k
mbed_official 82:0b31dbcd4769 57 i2c_frequency(obj, 100000);
mbed_official 82:0b31dbcd4769 58
mbed_official 82:0b31dbcd4769 59 // enable I2C interface
mbed_official 82:0b31dbcd4769 60 obj->i2c->C1 |= 0x80;
mbed_official 82:0b31dbcd4769 61
mbed_official 82:0b31dbcd4769 62 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 82:0b31dbcd4769 63 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 82:0b31dbcd4769 64 }
mbed_official 82:0b31dbcd4769 65
mbed_official 82:0b31dbcd4769 66 int i2c_start(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 67 uint8_t temp;
mbed_official 82:0b31dbcd4769 68 volatile int i;
mbed_official 82:0b31dbcd4769 69 // if we are in the middle of a transaction
mbed_official 82:0b31dbcd4769 70 // activate the repeat_start flag
mbed_official 82:0b31dbcd4769 71 if (obj->i2c->S & I2C_S_BUSY_MASK) {
mbed_official 82:0b31dbcd4769 72 // KL25Z errata sheet: repeat start cannot be generated if the
mbed_official 82:0b31dbcd4769 73 // I2Cx_F[MULT] field is set to a non-zero value
mbed_official 82:0b31dbcd4769 74 temp = obj->i2c->F >> 6;
mbed_official 82:0b31dbcd4769 75 obj->i2c->F &= 0x3F;
mbed_official 82:0b31dbcd4769 76 obj->i2c->C1 |= 0x04;
mbed_official 82:0b31dbcd4769 77 for (i = 0; i < 100; i ++) __NOP();
mbed_official 82:0b31dbcd4769 78 obj->i2c->F |= temp << 6;
mbed_official 82:0b31dbcd4769 79 } else {
mbed_official 82:0b31dbcd4769 80 obj->i2c->C1 |= I2C_C1_MST_MASK;
mbed_official 82:0b31dbcd4769 81 obj->i2c->C1 |= I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 82 }
mbed_official 82:0b31dbcd4769 83 return 0;
mbed_official 82:0b31dbcd4769 84 }
mbed_official 82:0b31dbcd4769 85
mbed_official 82:0b31dbcd4769 86 int i2c_stop(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 87 volatile uint32_t n = 0;
mbed_official 82:0b31dbcd4769 88 obj->i2c->C1 &= ~I2C_C1_MST_MASK;
mbed_official 82:0b31dbcd4769 89 obj->i2c->C1 &= ~I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 90
mbed_official 82:0b31dbcd4769 91 // It seems that there are timing problems
mbed_official 82:0b31dbcd4769 92 // when there is no waiting time after a STOP.
mbed_official 82:0b31dbcd4769 93 // This wait is also included on the samples
mbed_official 82:0b31dbcd4769 94 // code provided with the freedom board
mbed_official 82:0b31dbcd4769 95 for (n = 0; n < 100; n++) __NOP();
mbed_official 82:0b31dbcd4769 96 return 0;
mbed_official 82:0b31dbcd4769 97 }
mbed_official 82:0b31dbcd4769 98
mbed_official 82:0b31dbcd4769 99 static int timeout_status_poll(i2c_t *obj, uint32_t mask) {
mbed_official 82:0b31dbcd4769 100 uint32_t i, timeout = 1000;
mbed_official 82:0b31dbcd4769 101
mbed_official 82:0b31dbcd4769 102 for (i = 0; i < timeout; i++) {
mbed_official 82:0b31dbcd4769 103 if (obj->i2c->S & mask)
mbed_official 82:0b31dbcd4769 104 return 0;
mbed_official 82:0b31dbcd4769 105 }
mbed_official 82:0b31dbcd4769 106
mbed_official 82:0b31dbcd4769 107 return 1;
mbed_official 82:0b31dbcd4769 108 }
mbed_official 82:0b31dbcd4769 109
mbed_official 82:0b31dbcd4769 110 // this function waits the end of a tx transfer and return the status of the transaction:
mbed_official 82:0b31dbcd4769 111 // 0: OK ack received
mbed_official 82:0b31dbcd4769 112 // 1: OK ack not received
mbed_official 82:0b31dbcd4769 113 // 2: failure
mbed_official 82:0b31dbcd4769 114 static int i2c_wait_end_tx_transfer(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 115
mbed_official 82:0b31dbcd4769 116 // wait for the interrupt flag
mbed_official 82:0b31dbcd4769 117 if (timeout_status_poll(obj, I2C_S_IICIF_MASK)) {
mbed_official 82:0b31dbcd4769 118 return 2;
mbed_official 82:0b31dbcd4769 119 }
mbed_official 82:0b31dbcd4769 120
mbed_official 82:0b31dbcd4769 121 obj->i2c->S |= I2C_S_IICIF_MASK;
mbed_official 82:0b31dbcd4769 122
mbed_official 82:0b31dbcd4769 123 // wait transfer complete
mbed_official 82:0b31dbcd4769 124 if (timeout_status_poll(obj, I2C_S_TCF_MASK)) {
mbed_official 82:0b31dbcd4769 125 return 2;
mbed_official 82:0b31dbcd4769 126 }
mbed_official 82:0b31dbcd4769 127
mbed_official 82:0b31dbcd4769 128 // check if we received the ACK or not
mbed_official 82:0b31dbcd4769 129 return obj->i2c->S & I2C_S_RXAK_MASK ? 1 : 0;
mbed_official 82:0b31dbcd4769 130 }
mbed_official 82:0b31dbcd4769 131
mbed_official 82:0b31dbcd4769 132 // this function waits the end of a rx transfer and return the status of the transaction:
mbed_official 82:0b31dbcd4769 133 // 0: OK
mbed_official 82:0b31dbcd4769 134 // 1: failure
mbed_official 82:0b31dbcd4769 135 static int i2c_wait_end_rx_transfer(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 136 // wait for the end of the rx transfer
mbed_official 82:0b31dbcd4769 137 if (timeout_status_poll(obj, I2C_S_IICIF_MASK)) {
mbed_official 82:0b31dbcd4769 138 return 1;
mbed_official 82:0b31dbcd4769 139 }
mbed_official 82:0b31dbcd4769 140
mbed_official 82:0b31dbcd4769 141 obj->i2c->S |= I2C_S_IICIF_MASK;
mbed_official 82:0b31dbcd4769 142
mbed_official 82:0b31dbcd4769 143 return 0;
mbed_official 82:0b31dbcd4769 144 }
mbed_official 82:0b31dbcd4769 145
mbed_official 82:0b31dbcd4769 146 static void i2c_send_nack(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 147 obj->i2c->C1 |= I2C_C1_TXAK_MASK; // NACK
mbed_official 82:0b31dbcd4769 148 }
mbed_official 82:0b31dbcd4769 149
mbed_official 82:0b31dbcd4769 150 static void i2c_send_ack(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 151 obj->i2c->C1 &= ~I2C_C1_TXAK_MASK; // ACK
mbed_official 82:0b31dbcd4769 152 }
mbed_official 82:0b31dbcd4769 153
mbed_official 82:0b31dbcd4769 154 static int i2c_do_write(i2c_t *obj, int value) {
mbed_official 82:0b31dbcd4769 155 // write the data
mbed_official 82:0b31dbcd4769 156 obj->i2c->D = value;
mbed_official 82:0b31dbcd4769 157
mbed_official 82:0b31dbcd4769 158 // init and wait the end of the transfer
mbed_official 82:0b31dbcd4769 159 return i2c_wait_end_tx_transfer(obj);
mbed_official 82:0b31dbcd4769 160 }
mbed_official 82:0b31dbcd4769 161
mbed_official 82:0b31dbcd4769 162 static int i2c_do_read(i2c_t *obj, char * data, int last) {
mbed_official 82:0b31dbcd4769 163 if (last)
mbed_official 82:0b31dbcd4769 164 i2c_send_nack(obj);
mbed_official 82:0b31dbcd4769 165 else
mbed_official 82:0b31dbcd4769 166 i2c_send_ack(obj);
mbed_official 82:0b31dbcd4769 167
mbed_official 82:0b31dbcd4769 168 *data = (obj->i2c->D & 0xFF);
mbed_official 82:0b31dbcd4769 169
mbed_official 82:0b31dbcd4769 170 // start rx transfer and wait the end of the transfer
mbed_official 82:0b31dbcd4769 171 return i2c_wait_end_rx_transfer(obj);
mbed_official 82:0b31dbcd4769 172 }
mbed_official 82:0b31dbcd4769 173
mbed_official 82:0b31dbcd4769 174 void i2c_frequency(i2c_t *obj, int hz) {
mbed_official 82:0b31dbcd4769 175 uint8_t icr = 0;
mbed_official 82:0b31dbcd4769 176 uint8_t mult = 0;
mbed_official 82:0b31dbcd4769 177 uint32_t error = 0;
mbed_official 82:0b31dbcd4769 178 uint32_t p_error = 0xffffffff;
mbed_official 82:0b31dbcd4769 179 uint32_t ref = 0;
mbed_official 82:0b31dbcd4769 180 uint8_t i, j;
mbed_official 82:0b31dbcd4769 181 // bus clk
mbed_official 82:0b31dbcd4769 182 uint32_t PCLK = bus_frequency();
mbed_official 82:0b31dbcd4769 183 uint32_t pulse = PCLK / (hz * 2);
mbed_official 82:0b31dbcd4769 184
mbed_official 82:0b31dbcd4769 185 // we look for the values that minimize the error
mbed_official 82:0b31dbcd4769 186
mbed_official 82:0b31dbcd4769 187 // test all the MULT values
mbed_official 82:0b31dbcd4769 188 for (i = 1; i < 5; i*=2) {
mbed_official 82:0b31dbcd4769 189 for (j = 0; j < 0x40; j++) {
mbed_official 82:0b31dbcd4769 190 ref = PCLK / (i*ICR[j]);
mbed_official 82:0b31dbcd4769 191 if (ref > (uint32_t)hz)
mbed_official 82:0b31dbcd4769 192 continue;
mbed_official 82:0b31dbcd4769 193 error = hz - ref;
mbed_official 82:0b31dbcd4769 194 if (error < p_error) {
mbed_official 82:0b31dbcd4769 195 icr = j;
mbed_official 82:0b31dbcd4769 196 mult = i/2;
mbed_official 82:0b31dbcd4769 197 p_error = error;
mbed_official 82:0b31dbcd4769 198 }
mbed_official 82:0b31dbcd4769 199 }
mbed_official 82:0b31dbcd4769 200 }
mbed_official 82:0b31dbcd4769 201 pulse = icr | (mult << 6);
mbed_official 82:0b31dbcd4769 202
mbed_official 82:0b31dbcd4769 203 // I2C Rate
mbed_official 82:0b31dbcd4769 204 obj->i2c->F = pulse;
mbed_official 82:0b31dbcd4769 205 }
mbed_official 82:0b31dbcd4769 206
mbed_official 82:0b31dbcd4769 207 int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {
mbed_official 82:0b31dbcd4769 208 int count;
mbed_official 82:0b31dbcd4769 209 char dummy_read, *ptr;
mbed_official 82:0b31dbcd4769 210
mbed_official 82:0b31dbcd4769 211 if (i2c_start(obj)) {
mbed_official 82:0b31dbcd4769 212 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 213 return I2C_ERROR_BUS_BUSY;
mbed_official 82:0b31dbcd4769 214 }
mbed_official 82:0b31dbcd4769 215
mbed_official 82:0b31dbcd4769 216 if (i2c_do_write(obj, (address | 0x01))) {
mbed_official 82:0b31dbcd4769 217 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 218 return I2C_ERROR_NO_SLAVE;
mbed_official 82:0b31dbcd4769 219 }
mbed_official 82:0b31dbcd4769 220
mbed_official 82:0b31dbcd4769 221 // set rx mode
mbed_official 82:0b31dbcd4769 222 obj->i2c->C1 &= ~I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 223
mbed_official 82:0b31dbcd4769 224 // Read in bytes
mbed_official 82:0b31dbcd4769 225 for (count = 0; count < (length); count++) {
mbed_official 82:0b31dbcd4769 226 ptr = (count == 0) ? &dummy_read : &data[count - 1];
mbed_official 82:0b31dbcd4769 227 uint8_t stop_ = (count == (length - 1)) ? 1 : 0;
mbed_official 82:0b31dbcd4769 228 if (i2c_do_read(obj, ptr, stop_)) {
mbed_official 82:0b31dbcd4769 229 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 230 return count;
mbed_official 82:0b31dbcd4769 231 }
mbed_official 82:0b31dbcd4769 232 }
mbed_official 82:0b31dbcd4769 233
mbed_official 82:0b31dbcd4769 234 // If not repeated start, send stop.
mbed_official 82:0b31dbcd4769 235 if (stop) {
mbed_official 82:0b31dbcd4769 236 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 237 }
mbed_official 82:0b31dbcd4769 238
mbed_official 82:0b31dbcd4769 239 // last read
mbed_official 82:0b31dbcd4769 240 data[count-1] = obj->i2c->D;
mbed_official 82:0b31dbcd4769 241
mbed_official 82:0b31dbcd4769 242 return length;
mbed_official 82:0b31dbcd4769 243 }
mbed_official 82:0b31dbcd4769 244 int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) {
mbed_official 82:0b31dbcd4769 245 int i;
mbed_official 82:0b31dbcd4769 246
mbed_official 82:0b31dbcd4769 247 if (i2c_start(obj)) {
mbed_official 82:0b31dbcd4769 248 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 249 return I2C_ERROR_BUS_BUSY;
mbed_official 82:0b31dbcd4769 250 }
mbed_official 82:0b31dbcd4769 251
mbed_official 82:0b31dbcd4769 252 if (i2c_do_write(obj, (address & 0xFE))) {
mbed_official 82:0b31dbcd4769 253 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 254 return I2C_ERROR_NO_SLAVE;
mbed_official 82:0b31dbcd4769 255 }
mbed_official 82:0b31dbcd4769 256
mbed_official 82:0b31dbcd4769 257 for (i = 0; i < length; i++) {
mbed_official 82:0b31dbcd4769 258 if(i2c_do_write(obj, data[i])) {
mbed_official 82:0b31dbcd4769 259 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 260 return i;
mbed_official 82:0b31dbcd4769 261 }
mbed_official 82:0b31dbcd4769 262 }
mbed_official 82:0b31dbcd4769 263
mbed_official 82:0b31dbcd4769 264 if (stop) {
mbed_official 82:0b31dbcd4769 265 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 266 }
mbed_official 82:0b31dbcd4769 267
mbed_official 82:0b31dbcd4769 268 return length;
mbed_official 82:0b31dbcd4769 269 }
mbed_official 82:0b31dbcd4769 270
mbed_official 82:0b31dbcd4769 271 void i2c_reset(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 272 i2c_stop(obj);
mbed_official 82:0b31dbcd4769 273 }
mbed_official 82:0b31dbcd4769 274
mbed_official 82:0b31dbcd4769 275 int i2c_byte_read(i2c_t *obj, int last) {
mbed_official 82:0b31dbcd4769 276 char data;
mbed_official 82:0b31dbcd4769 277
mbed_official 82:0b31dbcd4769 278 // set rx mode
mbed_official 82:0b31dbcd4769 279 obj->i2c->C1 &= ~I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 280
mbed_official 178:a873352662d8 281 // Setup read
mbed_official 82:0b31dbcd4769 282 i2c_do_read(obj, &data, last);
mbed_official 178:a873352662d8 283
mbed_official 178:a873352662d8 284 // set tx mode
mbed_official 178:a873352662d8 285 obj->i2c->C1 |= I2C_C1_TX_MASK;
mbed_official 178:a873352662d8 286 return obj->i2c->D;
mbed_official 82:0b31dbcd4769 287 }
mbed_official 82:0b31dbcd4769 288
mbed_official 82:0b31dbcd4769 289 int i2c_byte_write(i2c_t *obj, int data) {
mbed_official 82:0b31dbcd4769 290 // set tx mode
mbed_official 82:0b31dbcd4769 291 obj->i2c->C1 |= I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 292
mbed_official 82:0b31dbcd4769 293 return !i2c_do_write(obj, (data & 0xFF));
mbed_official 82:0b31dbcd4769 294 }
mbed_official 82:0b31dbcd4769 295
mbed_official 82:0b31dbcd4769 296
mbed_official 82:0b31dbcd4769 297 #if DEVICE_I2CSLAVE
mbed_official 82:0b31dbcd4769 298 void i2c_slave_mode(i2c_t *obj, int enable_slave) {
mbed_official 82:0b31dbcd4769 299 if (enable_slave) {
mbed_official 82:0b31dbcd4769 300 // set slave mode
mbed_official 82:0b31dbcd4769 301 obj->i2c->C1 &= ~I2C_C1_MST_MASK;
mbed_official 82:0b31dbcd4769 302 obj->i2c->C1 |= I2C_C1_IICIE_MASK;
mbed_official 82:0b31dbcd4769 303 } else {
mbed_official 82:0b31dbcd4769 304 // set master mode
mbed_official 82:0b31dbcd4769 305 obj->i2c->C1 |= I2C_C1_MST_MASK;
mbed_official 82:0b31dbcd4769 306 }
mbed_official 82:0b31dbcd4769 307 }
mbed_official 82:0b31dbcd4769 308
mbed_official 82:0b31dbcd4769 309 int i2c_slave_receive(i2c_t *obj) {
mbed_official 82:0b31dbcd4769 310 switch(obj->i2c->S) {
mbed_official 82:0b31dbcd4769 311 // read addressed
mbed_official 82:0b31dbcd4769 312 case 0xE6: return 1;
mbed_official 82:0b31dbcd4769 313
mbed_official 82:0b31dbcd4769 314 // write addressed
mbed_official 82:0b31dbcd4769 315 case 0xE2: return 3;
mbed_official 82:0b31dbcd4769 316
mbed_official 82:0b31dbcd4769 317 default: return 0;
mbed_official 82:0b31dbcd4769 318 }
mbed_official 82:0b31dbcd4769 319 }
mbed_official 82:0b31dbcd4769 320
mbed_official 82:0b31dbcd4769 321 int i2c_slave_read(i2c_t *obj, char *data, int length) {
mbed_official 82:0b31dbcd4769 322 uint8_t dummy_read;
mbed_official 82:0b31dbcd4769 323 uint8_t * ptr;
mbed_official 82:0b31dbcd4769 324 int count;
mbed_official 82:0b31dbcd4769 325
mbed_official 82:0b31dbcd4769 326 // set rx mode
mbed_official 82:0b31dbcd4769 327 obj->i2c->C1 &= ~I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 328
mbed_official 82:0b31dbcd4769 329 // first dummy read
mbed_official 82:0b31dbcd4769 330 dummy_read = obj->i2c->D;
mbed_official 82:0b31dbcd4769 331 if(i2c_wait_end_rx_transfer(obj)) {
mbed_official 82:0b31dbcd4769 332 return 0;
mbed_official 82:0b31dbcd4769 333 }
mbed_official 82:0b31dbcd4769 334
mbed_official 82:0b31dbcd4769 335 // read address
mbed_official 82:0b31dbcd4769 336 dummy_read = obj->i2c->D;
mbed_official 82:0b31dbcd4769 337 if(i2c_wait_end_rx_transfer(obj)) {
mbed_official 82:0b31dbcd4769 338 return 0;
mbed_official 82:0b31dbcd4769 339 }
mbed_official 82:0b31dbcd4769 340
mbed_official 82:0b31dbcd4769 341 // read (length - 1) bytes
mbed_official 82:0b31dbcd4769 342 for (count = 0; count < (length - 1); count++) {
mbed_official 82:0b31dbcd4769 343 data[count] = obj->i2c->D;
mbed_official 82:0b31dbcd4769 344 if(i2c_wait_end_rx_transfer(obj)) {
mbed_official 82:0b31dbcd4769 345 return count;
mbed_official 82:0b31dbcd4769 346 }
mbed_official 82:0b31dbcd4769 347 }
mbed_official 82:0b31dbcd4769 348
mbed_official 82:0b31dbcd4769 349 // read last byte
mbed_official 82:0b31dbcd4769 350 ptr = (length == 0) ? &dummy_read : (uint8_t *)&data[count];
mbed_official 82:0b31dbcd4769 351 *ptr = obj->i2c->D;
mbed_official 82:0b31dbcd4769 352
mbed_official 82:0b31dbcd4769 353 return (length) ? (count + 1) : 0;
mbed_official 82:0b31dbcd4769 354 }
mbed_official 82:0b31dbcd4769 355
mbed_official 82:0b31dbcd4769 356 int i2c_slave_write(i2c_t *obj, const char *data, int length) {
mbed_official 82:0b31dbcd4769 357 int i, count = 0;
mbed_official 82:0b31dbcd4769 358
mbed_official 82:0b31dbcd4769 359 // set tx mode
mbed_official 82:0b31dbcd4769 360 obj->i2c->C1 |= I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 361
mbed_official 82:0b31dbcd4769 362 for (i = 0; i < length; i++) {
mbed_official 82:0b31dbcd4769 363 if(i2c_do_write(obj, data[count++]) == 2) {
mbed_official 82:0b31dbcd4769 364 return i;
mbed_official 82:0b31dbcd4769 365 }
mbed_official 82:0b31dbcd4769 366 }
mbed_official 82:0b31dbcd4769 367
mbed_official 82:0b31dbcd4769 368 // set rx mode
mbed_official 82:0b31dbcd4769 369 obj->i2c->C1 &= ~I2C_C1_TX_MASK;
mbed_official 82:0b31dbcd4769 370
mbed_official 82:0b31dbcd4769 371 // dummy rx transfer needed
mbed_official 82:0b31dbcd4769 372 // otherwise the master cannot generate a stop bit
mbed_official 82:0b31dbcd4769 373 obj->i2c->D;
mbed_official 82:0b31dbcd4769 374 if(i2c_wait_end_rx_transfer(obj) == 2) {
mbed_official 82:0b31dbcd4769 375 return count;
mbed_official 82:0b31dbcd4769 376 }
mbed_official 82:0b31dbcd4769 377
mbed_official 82:0b31dbcd4769 378 return count;
mbed_official 82:0b31dbcd4769 379 }
mbed_official 82:0b31dbcd4769 380
mbed_official 82:0b31dbcd4769 381 void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask) {
mbed_official 82:0b31dbcd4769 382 obj->i2c->A1 = address & 0xfe;
mbed_official 82:0b31dbcd4769 383 }
mbed_official 82:0b31dbcd4769 384 #endif
mbed_official 82:0b31dbcd4769 385