BA / SerialCom

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 OmniWheels by Gustav Atmel

mbed-os/targets/TARGET_NXP/TARGET_LPC43XX/i2c_api.c@2:798925c9e4a8, 2018-05-01 (annotated)

Committer:
gustavatmel
Date:
Tue May 01 15:55:34 2018 +0000
Revision:
2:798925c9e4a8
Parent:
1:9c5af431a1f1 
bluetooth

Who changed what in which revision?

UserRevisionLine numberNew contents of line
gustavatmel 1:9c5af431a1f1 1 /* mbed Microcontroller Library
gustavatmel 1:9c5af431a1f1 2 * Copyright (c) 2006-2013 ARM Limited
gustavatmel 1:9c5af431a1f1 3 *
gustavatmel 1:9c5af431a1f1 4 * Licensed under the Apache License, Version 2.0 (the "License");
gustavatmel 1:9c5af431a1f1 5 * you may not use this file except in compliance with the License.
gustavatmel 1:9c5af431a1f1 6 * You may obtain a copy of the License at
gustavatmel 1:9c5af431a1f1 7 *
gustavatmel 1:9c5af431a1f1 8 * http://www.apache.org/licenses/LICENSE-2.0
gustavatmel 1:9c5af431a1f1 9 *
gustavatmel 1:9c5af431a1f1 10 * Unless required by applicable law or agreed to in writing, software
gustavatmel 1:9c5af431a1f1 11 * distributed under the License is distributed on an "AS IS" BASIS,
gustavatmel 1:9c5af431a1f1 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
gustavatmel 1:9c5af431a1f1 13 * See the License for the specific language governing permissions and
gustavatmel 1:9c5af431a1f1 14 * limitations under the License.
gustavatmel 1:9c5af431a1f1 15 *
gustavatmel 1:9c5af431a1f1 16 * Ported to NXP LPC43XX by Micromint USA <support@micromint.com>
gustavatmel 1:9c5af431a1f1 17 */
gustavatmel 1:9c5af431a1f1 18 #include "i2c_api.h"
gustavatmel 1:9c5af431a1f1 19 #include "cmsis.h"
gustavatmel 1:9c5af431a1f1 20 #include "pinmap.h"
gustavatmel 1:9c5af431a1f1 21 #include "mbed_error.h"
gustavatmel 1:9c5af431a1f1 22
gustavatmel 1:9c5af431a1f1 23 // SCU mode for I2C SCL/SDA pins
gustavatmel 1:9c5af431a1f1 24 #define SCU_PINIO_I2C SCU_PINIO_PULLNONE
gustavatmel 1:9c5af431a1f1 25
gustavatmel 1:9c5af431a1f1 26 static const PinMap PinMap_I2C_SDA[] = {
gustavatmel 1:9c5af431a1f1 27 {P_DED, I2C_0, 0},
gustavatmel 1:9c5af431a1f1 28 {P2_3, I2C_1, (SCU_PINIO_I2C | 1)},
gustavatmel 1:9c5af431a1f1 29 {PE_13, I2C_1, (SCU_PINIO_I2C | 2)},
gustavatmel 1:9c5af431a1f1 30 {NC, NC, 0}
gustavatmel 1:9c5af431a1f1 31 };
gustavatmel 1:9c5af431a1f1 32
gustavatmel 1:9c5af431a1f1 33 static const PinMap PinMap_I2C_SCL[] = {
gustavatmel 1:9c5af431a1f1 34 {P_DED, I2C_0, 0},
gustavatmel 1:9c5af431a1f1 35 {P2_4, I2C_1, (SCU_PINIO_I2C | 1)},
gustavatmel 1:9c5af431a1f1 36 {PE_14, I2C_1, (SCU_PINIO_I2C | 2)},
gustavatmel 1:9c5af431a1f1 37 {NC, NC, 0}
gustavatmel 1:9c5af431a1f1 38 };
gustavatmel 1:9c5af431a1f1 39
gustavatmel 1:9c5af431a1f1 40 #define I2C_CONSET(x) (x->i2c->CONSET)
gustavatmel 1:9c5af431a1f1 41 #define I2C_CONCLR(x) (x->i2c->CONCLR)
gustavatmel 1:9c5af431a1f1 42 #define I2C_STAT(x) (x->i2c->STAT)
gustavatmel 1:9c5af431a1f1 43 #define I2C_DAT(x) (x->i2c->DAT)
gustavatmel 1:9c5af431a1f1 44 #define I2C_SCLL(x, val) (x->i2c->SCLL = val)
gustavatmel 1:9c5af431a1f1 45 #define I2C_SCLH(x, val) (x->i2c->SCLH = val)
gustavatmel 1:9c5af431a1f1 46
gustavatmel 1:9c5af431a1f1 47 static const uint32_t I2C_addr_offset[2][4] = {
gustavatmel 1:9c5af431a1f1 48 {0x0C, 0x20, 0x24, 0x28},
gustavatmel 1:9c5af431a1f1 49 {0x30, 0x34, 0x38, 0x3C}
gustavatmel 1:9c5af431a1f1 50 };
gustavatmel 1:9c5af431a1f1 51
gustavatmel 1:9c5af431a1f1 52 static inline void i2c_conclr(i2c_t *obj, int start, int stop, int interrupt, int acknowledge) {
gustavatmel 1:9c5af431a1f1 53 I2C_CONCLR(obj) = (start << 5)
gustavatmel 1:9c5af431a1f1 54 | (stop << 4)
gustavatmel 1:9c5af431a1f1 55 | (interrupt << 3)
gustavatmel 1:9c5af431a1f1 56 | (acknowledge << 2);
gustavatmel 1:9c5af431a1f1 57 }
gustavatmel 1:9c5af431a1f1 58
gustavatmel 1:9c5af431a1f1 59 static inline void i2c_conset(i2c_t *obj, int start, int stop, int interrupt, int acknowledge) {
gustavatmel 1:9c5af431a1f1 60 I2C_CONSET(obj) = (start << 5)
gustavatmel 1:9c5af431a1f1 61 | (stop << 4)
gustavatmel 1:9c5af431a1f1 62 | (interrupt << 3)
gustavatmel 1:9c5af431a1f1 63 | (acknowledge << 2);
gustavatmel 1:9c5af431a1f1 64 }
gustavatmel 1:9c5af431a1f1 65
gustavatmel 1:9c5af431a1f1 66 // Clear the Serial Interrupt (SI)
gustavatmel 1:9c5af431a1f1 67 static inline void i2c_clear_SI(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 68 i2c_conclr(obj, 0, 0, 1, 0);
gustavatmel 1:9c5af431a1f1 69 }
gustavatmel 1:9c5af431a1f1 70
gustavatmel 1:9c5af431a1f1 71 static inline int i2c_status(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 72 return I2C_STAT(obj);
gustavatmel 1:9c5af431a1f1 73 }
gustavatmel 1:9c5af431a1f1 74
gustavatmel 1:9c5af431a1f1 75 // Wait until the Serial Interrupt (SI) is set
gustavatmel 1:9c5af431a1f1 76 static int i2c_wait_SI(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 77 int timeout = 0;
gustavatmel 1:9c5af431a1f1 78 while (!(I2C_CONSET(obj) & (1 << 3))) {
gustavatmel 1:9c5af431a1f1 79 timeout++;
gustavatmel 1:9c5af431a1f1 80 if (timeout > 100000) return -1;
gustavatmel 1:9c5af431a1f1 81 }
gustavatmel 1:9c5af431a1f1 82 return 0;
gustavatmel 1:9c5af431a1f1 83 }
gustavatmel 1:9c5af431a1f1 84
gustavatmel 1:9c5af431a1f1 85 static inline void i2c_interface_enable(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 86 I2C_CONSET(obj) = 0x40;
gustavatmel 1:9c5af431a1f1 87 }
gustavatmel 1:9c5af431a1f1 88
gustavatmel 1:9c5af431a1f1 89 void i2c_init(i2c_t *obj, PinName sda, PinName scl) {
gustavatmel 1:9c5af431a1f1 90 // determine the SPI to use
gustavatmel 1:9c5af431a1f1 91 I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA);
gustavatmel 1:9c5af431a1f1 92 I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL);
gustavatmel 1:9c5af431a1f1 93 obj->i2c = (LPC_I2C_T *)pinmap_merge(i2c_sda, i2c_scl);
gustavatmel 1:9c5af431a1f1 94
gustavatmel 1:9c5af431a1f1 95 if ((int)obj->i2c == NC) {
gustavatmel 1:9c5af431a1f1 96 error("I2C pin mapping failed");
gustavatmel 1:9c5af431a1f1 97 }
gustavatmel 1:9c5af431a1f1 98
gustavatmel 1:9c5af431a1f1 99 // set default frequency at 100k
gustavatmel 1:9c5af431a1f1 100 i2c_frequency(obj, 100000);
gustavatmel 1:9c5af431a1f1 101 i2c_conclr(obj, 1, 1, 1, 1);
gustavatmel 1:9c5af431a1f1 102 i2c_interface_enable(obj);
gustavatmel 1:9c5af431a1f1 103
gustavatmel 1:9c5af431a1f1 104 // Set SCU functions
gustavatmel 1:9c5af431a1f1 105 if (scl == P_DED) {
gustavatmel 1:9c5af431a1f1 106 // Enable dedicated I2C0 SDA and SCL pins (open drain)
gustavatmel 1:9c5af431a1f1 107 LPC_SCU->SFSI2C0 = (1 << 11) | (1 << 3);
gustavatmel 1:9c5af431a1f1 108 } else {
gustavatmel 1:9c5af431a1f1 109 pinmap_pinout(sda, PinMap_I2C_SDA);
gustavatmel 1:9c5af431a1f1 110 pinmap_pinout(scl, PinMap_I2C_SCL);
gustavatmel 1:9c5af431a1f1 111 }
gustavatmel 1:9c5af431a1f1 112 }
gustavatmel 1:9c5af431a1f1 113
gustavatmel 1:9c5af431a1f1 114 inline int i2c_start(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 115 int status = 0;
gustavatmel 1:9c5af431a1f1 116 int isInterrupted = I2C_CONSET(obj) & (1 << 3);
gustavatmel 1:9c5af431a1f1 117
gustavatmel 1:9c5af431a1f1 118 // 8.1 Before master mode can be entered, I2CON must be initialised to:
gustavatmel 1:9c5af431a1f1 119 // - I2EN STA STO SI AA - -
gustavatmel 1:9c5af431a1f1 120 // - 1 0 0 x x - -
gustavatmel 1:9c5af431a1f1 121 // if AA = 0, it can't enter slave mode
gustavatmel 1:9c5af431a1f1 122 i2c_conclr(obj, 1, 1, 0, 1);
gustavatmel 1:9c5af431a1f1 123
gustavatmel 1:9c5af431a1f1 124 // The master mode may now be entered by setting the STA bit
gustavatmel 1:9c5af431a1f1 125 // this will generate a start condition when the bus becomes free
gustavatmel 1:9c5af431a1f1 126 i2c_conset(obj, 1, 0, 0, 1);
gustavatmel 1:9c5af431a1f1 127 // Clearing SI bit when it wasn't set on entry can jump past state
gustavatmel 1:9c5af431a1f1 128 // 0x10 or 0x08 and erroneously send uninitialized slave address.
gustavatmel 1:9c5af431a1f1 129 if (isInterrupted)
gustavatmel 1:9c5af431a1f1 130 i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 131
gustavatmel 1:9c5af431a1f1 132 i2c_wait_SI(obj);
gustavatmel 1:9c5af431a1f1 133 status = i2c_status(obj);
gustavatmel 1:9c5af431a1f1 134
gustavatmel 1:9c5af431a1f1 135 // Clear start bit now that it's transmitted
gustavatmel 1:9c5af431a1f1 136 i2c_conclr(obj, 1, 0, 0, 0);
gustavatmel 1:9c5af431a1f1 137 return status;
gustavatmel 1:9c5af431a1f1 138 }
gustavatmel 1:9c5af431a1f1 139
gustavatmel 1:9c5af431a1f1 140 inline int i2c_stop(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 141 int timeout = 0;
gustavatmel 1:9c5af431a1f1 142
gustavatmel 1:9c5af431a1f1 143 // write the stop bit
gustavatmel 1:9c5af431a1f1 144 i2c_conset(obj, 0, 1, 0, 0);
gustavatmel 1:9c5af431a1f1 145 i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 146
gustavatmel 1:9c5af431a1f1 147 // wait for STO bit to reset
gustavatmel 1:9c5af431a1f1 148 while(I2C_CONSET(obj) & (1 << 4)) {
gustavatmel 1:9c5af431a1f1 149 timeout ++;
gustavatmel 1:9c5af431a1f1 150 if (timeout > 100000) return 1;
gustavatmel 1:9c5af431a1f1 151 }
gustavatmel 1:9c5af431a1f1 152
gustavatmel 1:9c5af431a1f1 153 return 0;
gustavatmel 1:9c5af431a1f1 154 }
gustavatmel 1:9c5af431a1f1 155
gustavatmel 1:9c5af431a1f1 156 static inline int i2c_do_write(i2c_t *obj, int value, uint8_t addr) {
gustavatmel 1:9c5af431a1f1 157 // write the data
gustavatmel 1:9c5af431a1f1 158 I2C_DAT(obj) = value;
gustavatmel 1:9c5af431a1f1 159
gustavatmel 1:9c5af431a1f1 160 // clear SI to init a send
gustavatmel 1:9c5af431a1f1 161 i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 162
gustavatmel 1:9c5af431a1f1 163 // wait and return status
gustavatmel 1:9c5af431a1f1 164 i2c_wait_SI(obj);
gustavatmel 1:9c5af431a1f1 165 return i2c_status(obj);
gustavatmel 1:9c5af431a1f1 166 }
gustavatmel 1:9c5af431a1f1 167
gustavatmel 1:9c5af431a1f1 168 static inline int i2c_do_read(i2c_t *obj, int last) {
gustavatmel 1:9c5af431a1f1 169 // we are in state 0x40 (SLA+R tx'd) or 0x50 (data rx'd and ack)
gustavatmel 1:9c5af431a1f1 170 if(last) {
gustavatmel 1:9c5af431a1f1 171 i2c_conclr(obj, 0, 0, 0, 1); // send a NOT ACK
gustavatmel 1:9c5af431a1f1 172 } else {
gustavatmel 1:9c5af431a1f1 173 i2c_conset(obj, 0, 0, 0, 1); // send a ACK
gustavatmel 1:9c5af431a1f1 174 }
gustavatmel 1:9c5af431a1f1 175
gustavatmel 1:9c5af431a1f1 176 // accept byte
gustavatmel 1:9c5af431a1f1 177 i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 178
gustavatmel 1:9c5af431a1f1 179 // wait for it to arrive
gustavatmel 1:9c5af431a1f1 180 i2c_wait_SI(obj);
gustavatmel 1:9c5af431a1f1 181
gustavatmel 1:9c5af431a1f1 182 // return the data
gustavatmel 1:9c5af431a1f1 183 return (I2C_DAT(obj) & 0xFF);
gustavatmel 1:9c5af431a1f1 184 }
gustavatmel 1:9c5af431a1f1 185
gustavatmel 1:9c5af431a1f1 186 void i2c_frequency(i2c_t *obj, int hz) {
gustavatmel 1:9c5af431a1f1 187 // [TODO] set pclk to /4
gustavatmel 1:9c5af431a1f1 188 uint32_t PCLK = SystemCoreClock / 4;
gustavatmel 1:9c5af431a1f1 189
gustavatmel 1:9c5af431a1f1 190 uint32_t pulse = PCLK / (hz * 2);
gustavatmel 1:9c5af431a1f1 191
gustavatmel 1:9c5af431a1f1 192 // I2C Rate
gustavatmel 1:9c5af431a1f1 193 I2C_SCLL(obj, pulse);
gustavatmel 1:9c5af431a1f1 194 I2C_SCLH(obj, pulse);
gustavatmel 1:9c5af431a1f1 195 }
gustavatmel 1:9c5af431a1f1 196
gustavatmel 1:9c5af431a1f1 197 // The I2C does a read or a write as a whole operation
gustavatmel 1:9c5af431a1f1 198 // There are two types of error conditions it can encounter
gustavatmel 1:9c5af431a1f1 199 // 1) it can not obtain the bus
gustavatmel 1:9c5af431a1f1 200 // 2) it gets error responses at part of the transmission
gustavatmel 1:9c5af431a1f1 201 //
gustavatmel 1:9c5af431a1f1 202 // We tackle them as follows:
gustavatmel 1:9c5af431a1f1 203 // 1) we retry until we get the bus. we could have a "timeout" if we can not get it
gustavatmel 1:9c5af431a1f1 204 // which basically turns it in to a 2)
gustavatmel 1:9c5af431a1f1 205 // 2) on error, we use the standard error mechanisms to report/debug
gustavatmel 1:9c5af431a1f1 206 //
gustavatmel 1:9c5af431a1f1 207 // Therefore an I2C transaction should always complete. If it doesn't it is usually
gustavatmel 1:9c5af431a1f1 208 // because something is setup wrong (e.g. wiring), and we don't need to programatically
gustavatmel 1:9c5af431a1f1 209 // check for that
gustavatmel 1:9c5af431a1f1 210
gustavatmel 1:9c5af431a1f1 211 int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {
gustavatmel 1:9c5af431a1f1 212 int count, status;
gustavatmel 1:9c5af431a1f1 213
gustavatmel 1:9c5af431a1f1 214 status = i2c_start(obj);
gustavatmel 1:9c5af431a1f1 215
gustavatmel 1:9c5af431a1f1 216 if ((status != 0x10) && (status != 0x08)) {
gustavatmel 1:9c5af431a1f1 217 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 218 return I2C_ERROR_BUS_BUSY;
gustavatmel 1:9c5af431a1f1 219 }
gustavatmel 1:9c5af431a1f1 220
gustavatmel 1:9c5af431a1f1 221 status = i2c_do_write(obj, (address | 0x01), 1);
gustavatmel 1:9c5af431a1f1 222 if (status != 0x40) {
gustavatmel 1:9c5af431a1f1 223 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 224 return I2C_ERROR_NO_SLAVE;
gustavatmel 1:9c5af431a1f1 225 }
gustavatmel 1:9c5af431a1f1 226
gustavatmel 1:9c5af431a1f1 227 // Read in all except last byte
gustavatmel 1:9c5af431a1f1 228 for (count = 0; count < (length - 1); count++) {
gustavatmel 1:9c5af431a1f1 229 int value = i2c_do_read(obj, 0);
gustavatmel 1:9c5af431a1f1 230 status = i2c_status(obj);
gustavatmel 1:9c5af431a1f1 231 if (status != 0x50) {
gustavatmel 1:9c5af431a1f1 232 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 233 return count;
gustavatmel 1:9c5af431a1f1 234 }
gustavatmel 1:9c5af431a1f1 235 data[count] = (char) value;
gustavatmel 1:9c5af431a1f1 236 }
gustavatmel 1:9c5af431a1f1 237
gustavatmel 1:9c5af431a1f1 238 // read in last byte
gustavatmel 1:9c5af431a1f1 239 int value = i2c_do_read(obj, 1);
gustavatmel 1:9c5af431a1f1 240 status = i2c_status(obj);
gustavatmel 1:9c5af431a1f1 241 if (status != 0x58) {
gustavatmel 1:9c5af431a1f1 242 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 243 return length - 1;
gustavatmel 1:9c5af431a1f1 244 }
gustavatmel 1:9c5af431a1f1 245
gustavatmel 1:9c5af431a1f1 246 data[count] = (char) value;
gustavatmel 1:9c5af431a1f1 247
gustavatmel 1:9c5af431a1f1 248 // If not repeated start, send stop.
gustavatmel 1:9c5af431a1f1 249 if (stop) {
gustavatmel 1:9c5af431a1f1 250 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 251 }
gustavatmel 1:9c5af431a1f1 252
gustavatmel 1:9c5af431a1f1 253 return length;
gustavatmel 1:9c5af431a1f1 254 }
gustavatmel 1:9c5af431a1f1 255
gustavatmel 1:9c5af431a1f1 256 int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) {
gustavatmel 1:9c5af431a1f1 257 int i, status;
gustavatmel 1:9c5af431a1f1 258
gustavatmel 1:9c5af431a1f1 259 status = i2c_start(obj);
gustavatmel 1:9c5af431a1f1 260
gustavatmel 1:9c5af431a1f1 261 if ((status != 0x10) && (status != 0x08)) {
gustavatmel 1:9c5af431a1f1 262 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 263 return I2C_ERROR_BUS_BUSY;
gustavatmel 1:9c5af431a1f1 264 }
gustavatmel 1:9c5af431a1f1 265
gustavatmel 1:9c5af431a1f1 266 status = i2c_do_write(obj, (address & 0xFE), 1);
gustavatmel 1:9c5af431a1f1 267 if (status != 0x18) {
gustavatmel 1:9c5af431a1f1 268 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 269 return I2C_ERROR_NO_SLAVE;
gustavatmel 1:9c5af431a1f1 270 }
gustavatmel 1:9c5af431a1f1 271
gustavatmel 1:9c5af431a1f1 272 for (i=0; i<length; i++) {
gustavatmel 1:9c5af431a1f1 273 status = i2c_do_write(obj, data[i], 0);
gustavatmel 1:9c5af431a1f1 274 if(status != 0x28) {
gustavatmel 1:9c5af431a1f1 275 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 276 return i;
gustavatmel 1:9c5af431a1f1 277 }
gustavatmel 1:9c5af431a1f1 278 }
gustavatmel 1:9c5af431a1f1 279
gustavatmel 1:9c5af431a1f1 280 // clearing the serial interrupt here might cause an unintended rewrite of the last byte
gustavatmel 1:9c5af431a1f1 281 // see also issue report https://mbed.org/users/mbed_official/code/mbed/issues/1
gustavatmel 1:9c5af431a1f1 282 // i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 283
gustavatmel 1:9c5af431a1f1 284 // If not repeated start, send stop.
gustavatmel 1:9c5af431a1f1 285 if (stop) {
gustavatmel 1:9c5af431a1f1 286 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 287 }
gustavatmel 1:9c5af431a1f1 288
gustavatmel 1:9c5af431a1f1 289 return length;
gustavatmel 1:9c5af431a1f1 290 }
gustavatmel 1:9c5af431a1f1 291
gustavatmel 1:9c5af431a1f1 292 void i2c_reset(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 293 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 294 }
gustavatmel 1:9c5af431a1f1 295
gustavatmel 1:9c5af431a1f1 296 int i2c_byte_read(i2c_t *obj, int last) {
gustavatmel 1:9c5af431a1f1 297 return (i2c_do_read(obj, last) & 0xFF);
gustavatmel 1:9c5af431a1f1 298 }
gustavatmel 1:9c5af431a1f1 299
gustavatmel 1:9c5af431a1f1 300 int i2c_byte_write(i2c_t *obj, int data) {
gustavatmel 1:9c5af431a1f1 301 int ack;
gustavatmel 1:9c5af431a1f1 302 int status = i2c_do_write(obj, (data & 0xFF), 0);
gustavatmel 1:9c5af431a1f1 303
gustavatmel 1:9c5af431a1f1 304 switch(status) {
gustavatmel 1:9c5af431a1f1 305 case 0x18: case 0x28: // Master transmit ACKs
gustavatmel 1:9c5af431a1f1 306 ack = 1;
gustavatmel 1:9c5af431a1f1 307 break;
gustavatmel 1:9c5af431a1f1 308 case 0x40: // Master receive address transmitted ACK
gustavatmel 1:9c5af431a1f1 309 ack = 1;
gustavatmel 1:9c5af431a1f1 310 break;
gustavatmel 1:9c5af431a1f1 311 case 0xB8: // Slave transmit ACK
gustavatmel 1:9c5af431a1f1 312 ack = 1;
gustavatmel 1:9c5af431a1f1 313 break;
gustavatmel 1:9c5af431a1f1 314 default:
gustavatmel 1:9c5af431a1f1 315 ack = 0;
gustavatmel 1:9c5af431a1f1 316 break;
gustavatmel 1:9c5af431a1f1 317 }
gustavatmel 1:9c5af431a1f1 318
gustavatmel 1:9c5af431a1f1 319 return ack;
gustavatmel 1:9c5af431a1f1 320 }
gustavatmel 1:9c5af431a1f1 321
gustavatmel 1:9c5af431a1f1 322 void i2c_slave_mode(i2c_t *obj, int enable_slave) {
gustavatmel 1:9c5af431a1f1 323 if (enable_slave != 0) {
gustavatmel 1:9c5af431a1f1 324 i2c_conclr(obj, 1, 1, 1, 0);
gustavatmel 1:9c5af431a1f1 325 i2c_conset(obj, 0, 0, 0, 1);
gustavatmel 1:9c5af431a1f1 326 } else {
gustavatmel 1:9c5af431a1f1 327 i2c_conclr(obj, 1, 1, 1, 1);
gustavatmel 1:9c5af431a1f1 328 }
gustavatmel 1:9c5af431a1f1 329 }
gustavatmel 1:9c5af431a1f1 330
gustavatmel 1:9c5af431a1f1 331 int i2c_slave_receive(i2c_t *obj) {
gustavatmel 1:9c5af431a1f1 332 int status;
gustavatmel 1:9c5af431a1f1 333 int retval;
gustavatmel 1:9c5af431a1f1 334
gustavatmel 1:9c5af431a1f1 335 status = i2c_status(obj);
gustavatmel 1:9c5af431a1f1 336 switch(status) {
gustavatmel 1:9c5af431a1f1 337 case 0x60: retval = 3; break;
gustavatmel 1:9c5af431a1f1 338 case 0x70: retval = 2; break;
gustavatmel 1:9c5af431a1f1 339 case 0xA8: retval = 1; break;
gustavatmel 1:9c5af431a1f1 340 default : retval = 0; break;
gustavatmel 1:9c5af431a1f1 341 }
gustavatmel 1:9c5af431a1f1 342
gustavatmel 1:9c5af431a1f1 343 return(retval);
gustavatmel 1:9c5af431a1f1 344 }
gustavatmel 1:9c5af431a1f1 345
gustavatmel 1:9c5af431a1f1 346 int i2c_slave_read(i2c_t *obj, char *data, int length) {
gustavatmel 1:9c5af431a1f1 347 int count = 0;
gustavatmel 1:9c5af431a1f1 348 int status;
gustavatmel 1:9c5af431a1f1 349
gustavatmel 1:9c5af431a1f1 350 do {
gustavatmel 1:9c5af431a1f1 351 i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 352 i2c_wait_SI(obj);
gustavatmel 1:9c5af431a1f1 353 status = i2c_status(obj);
gustavatmel 1:9c5af431a1f1 354 if((status == 0x80) || (status == 0x90)) {
gustavatmel 1:9c5af431a1f1 355 data[count] = I2C_DAT(obj) & 0xFF;
gustavatmel 1:9c5af431a1f1 356 }
gustavatmel 1:9c5af431a1f1 357 count++;
gustavatmel 1:9c5af431a1f1 358 } while (((status == 0x80) || (status == 0x90) ||
gustavatmel 1:9c5af431a1f1 359 (status == 0x060) || (status == 0x70)) && (count < length));
gustavatmel 1:9c5af431a1f1 360
gustavatmel 1:9c5af431a1f1 361 if(status != 0xA0) {
gustavatmel 1:9c5af431a1f1 362 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 363 }
gustavatmel 1:9c5af431a1f1 364
gustavatmel 1:9c5af431a1f1 365 i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 366
gustavatmel 1:9c5af431a1f1 367 return count;
gustavatmel 1:9c5af431a1f1 368 }
gustavatmel 1:9c5af431a1f1 369
gustavatmel 1:9c5af431a1f1 370 int i2c_slave_write(i2c_t *obj, const char *data, int length) {
gustavatmel 1:9c5af431a1f1 371 int count = 0;
gustavatmel 1:9c5af431a1f1 372 int status;
gustavatmel 1:9c5af431a1f1 373
gustavatmel 1:9c5af431a1f1 374 if(length <= 0) {
gustavatmel 1:9c5af431a1f1 375 return(0);
gustavatmel 1:9c5af431a1f1 376 }
gustavatmel 1:9c5af431a1f1 377
gustavatmel 1:9c5af431a1f1 378 do {
gustavatmel 1:9c5af431a1f1 379 status = i2c_do_write(obj, data[count], 0);
gustavatmel 1:9c5af431a1f1 380 count++;
gustavatmel 1:9c5af431a1f1 381 } while ((count < length) && (status == 0xB8));
gustavatmel 1:9c5af431a1f1 382
gustavatmel 1:9c5af431a1f1 383 if ((status != 0xC0) && (status != 0xC8)) {
gustavatmel 1:9c5af431a1f1 384 i2c_stop(obj);
gustavatmel 1:9c5af431a1f1 385 }
gustavatmel 1:9c5af431a1f1 386
gustavatmel 1:9c5af431a1f1 387 i2c_clear_SI(obj);
gustavatmel 1:9c5af431a1f1 388
gustavatmel 1:9c5af431a1f1 389 return(count);
gustavatmel 1:9c5af431a1f1 390 }
gustavatmel 1:9c5af431a1f1 391
gustavatmel 1:9c5af431a1f1 392 void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask) {
gustavatmel 1:9c5af431a1f1 393 uint32_t addr;
gustavatmel 1:9c5af431a1f1 394
gustavatmel 1:9c5af431a1f1 395 if ((idx >= 0) && (idx <= 3)) {
gustavatmel 1:9c5af431a1f1 396 addr = ((uint32_t)obj->i2c) + I2C_addr_offset[0][idx];
gustavatmel 1:9c5af431a1f1 397 *((uint32_t *) addr) = address & 0xFF;
gustavatmel 1:9c5af431a1f1 398 addr = ((uint32_t)obj->i2c) + I2C_addr_offset[1][idx];
gustavatmel 1:9c5af431a1f1 399 *((uint32_t *) addr) = mask & 0xFE;
gustavatmel 1:9c5af431a1f1 400 }
gustavatmel 1:9c5af431a1f1 401 }