EL4121 Embedded System / mbed-os

mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

targets/TARGET_TOSHIBA/TARGET_TMPM066/i2c_api.c@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /* mbed Microcontroller Library
be_bryan 0:b74591d5ab33 2 * (C)Copyright TOSHIBA ELECTRONIC DEVICES & STORAGE CORPORATION 2017 All rights reserved
be_bryan 0:b74591d5ab33 3 *
be_bryan 0:b74591d5ab33 4 * Licensed under the Apache License, Version 2.0 (the "License");
be_bryan 0:b74591d5ab33 5 * you may not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 6 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 7 *
be_bryan 0:b74591d5ab33 8 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 9 *
be_bryan 0:b74591d5ab33 10 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 11 * distributed under the License is distributed on an "AS IS" BASIS,
be_bryan 0:b74591d5ab33 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 13 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 14 * limitations under the License.
be_bryan 0:b74591d5ab33 15 */
be_bryan 0:b74591d5ab33 16 #include "i2c_api.h"
be_bryan 0:b74591d5ab33 17 #include "mbed_error.h"
be_bryan 0:b74591d5ab33 18 #include "PeripheralNames.h"
be_bryan 0:b74591d5ab33 19 #include "pinmap.h"
be_bryan 0:b74591d5ab33 20
be_bryan 0:b74591d5ab33 21 #define I2C_NACK (0)
be_bryan 0:b74591d5ab33 22 #define I2C_ACK (1)
be_bryan 0:b74591d5ab33 23 #define I2C_NO_DATA (0)
be_bryan 0:b74591d5ab33 24 #define I2C_READ_ADDRESSED (1)
be_bryan 0:b74591d5ab33 25 #define I2C_WRITE_GENERAL (2)
be_bryan 0:b74591d5ab33 26 #define I2C_WRITE_ADDRESSED (3)
be_bryan 0:b74591d5ab33 27 #define SELF_ADDR (0xE0)
be_bryan 0:b74591d5ab33 28 #define I2C_TIMEOUT (100000)
be_bryan 0:b74591d5ab33 29
be_bryan 0:b74591d5ab33 30 static const PinMap PinMap_I2C_SDA[] = {
be_bryan 0:b74591d5ab33 31 {PC1, I2C_0, PIN_DATA(1, 2)},
be_bryan 0:b74591d5ab33 32 {PG1, I2C_1, PIN_DATA(1, 2)},
be_bryan 0:b74591d5ab33 33 {NC, NC, 0}
be_bryan 0:b74591d5ab33 34 };
be_bryan 0:b74591d5ab33 35
be_bryan 0:b74591d5ab33 36 static const PinMap PinMap_I2C_SCL[] = {
be_bryan 0:b74591d5ab33 37 {PC0, I2C_0, PIN_DATA(1, 2)},
be_bryan 0:b74591d5ab33 38 {PG0, I2C_1, PIN_DATA(1, 2)},
be_bryan 0:b74591d5ab33 39 {NC, NC, 0}
be_bryan 0:b74591d5ab33 40 };
be_bryan 0:b74591d5ab33 41
be_bryan 0:b74591d5ab33 42 void I2C_ClearINTOutput(TSB_I2C_TypeDef * I2Cx);
be_bryan 0:b74591d5ab33 43 // Clock setting structure definition
be_bryan 0:b74591d5ab33 44 typedef struct {
be_bryan 0:b74591d5ab33 45 uint32_t sck;
be_bryan 0:b74591d5ab33 46 uint32_t prsck;
be_bryan 0:b74591d5ab33 47 } I2C_clock_setting_t;
be_bryan 0:b74591d5ab33 48
be_bryan 0:b74591d5ab33 49 static const uint32_t I2C_SCK_DIVIDER_TBL[8] = {20, 24, 32, 48, 80, 144, 272, 528}; // SCK Divider value table
be_bryan 0:b74591d5ab33 50 static uint32_t start_flag = 0;
be_bryan 0:b74591d5ab33 51 I2C_clock_setting_t clk;
be_bryan 0:b74591d5ab33 52 I2C_State status;
be_bryan 0:b74591d5ab33 53
be_bryan 0:b74591d5ab33 54 static int32_t wait_status(i2c_t *obj)
be_bryan 0:b74591d5ab33 55 {
be_bryan 0:b74591d5ab33 56 volatile int32_t timeout = I2C_TIMEOUT;
be_bryan 0:b74591d5ab33 57
be_bryan 0:b74591d5ab33 58 while (I2C_GetINTI2CStatus(obj->i2c) == DISABLE) {
be_bryan 0:b74591d5ab33 59 if ((timeout--) == 0) {
be_bryan 0:b74591d5ab33 60 return (-1);
be_bryan 0:b74591d5ab33 61 }
be_bryan 0:b74591d5ab33 62 }
be_bryan 0:b74591d5ab33 63 return (0);
be_bryan 0:b74591d5ab33 64 }
be_bryan 0:b74591d5ab33 65
be_bryan 0:b74591d5ab33 66 // Initialize the I2C peripheral. It sets the default parameters for I2C
be_bryan 0:b74591d5ab33 67 void i2c_init(i2c_t *obj, PinName sda, PinName scl)
be_bryan 0:b74591d5ab33 68 {
be_bryan 0:b74591d5ab33 69 MBED_ASSERT(obj != NULL);
be_bryan 0:b74591d5ab33 70 I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA);
be_bryan 0:b74591d5ab33 71 I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL);
be_bryan 0:b74591d5ab33 72 I2CName i2c_name = (I2CName)pinmap_merge(i2c_sda, i2c_scl);
be_bryan 0:b74591d5ab33 73 MBED_ASSERT((int)i2c_name != NC);
be_bryan 0:b74591d5ab33 74
be_bryan 0:b74591d5ab33 75 switch (i2c_name) {
be_bryan 0:b74591d5ab33 76 case I2C_0:
be_bryan 0:b74591d5ab33 77 CG_SetFcPeriphA(CG_FC_PERIPH_I2C0, ENABLE);
be_bryan 0:b74591d5ab33 78 obj->i2c = TSB_I2C0;
be_bryan 0:b74591d5ab33 79 obj->IRQn = INTI2C0_IRQn;
be_bryan 0:b74591d5ab33 80 break;
be_bryan 0:b74591d5ab33 81 case I2C_1:
be_bryan 0:b74591d5ab33 82 CG_SetFcPeriphB(CG_FC_PERIPH_I2C1, ENABLE);
be_bryan 0:b74591d5ab33 83 obj->i2c = TSB_I2C1;
be_bryan 0:b74591d5ab33 84 obj->IRQn = INTI2C1_IRQn;
be_bryan 0:b74591d5ab33 85 break;
be_bryan 0:b74591d5ab33 86 default:
be_bryan 0:b74591d5ab33 87 error("I2C is not available");
be_bryan 0:b74591d5ab33 88 break;
be_bryan 0:b74591d5ab33 89 }
be_bryan 0:b74591d5ab33 90
be_bryan 0:b74591d5ab33 91 pinmap_pinout(sda, PinMap_I2C_SDA);
be_bryan 0:b74591d5ab33 92 pin_mode(sda, OpenDrain);
be_bryan 0:b74591d5ab33 93 pin_mode(sda, PullUp);
be_bryan 0:b74591d5ab33 94
be_bryan 0:b74591d5ab33 95 pinmap_pinout(scl, PinMap_I2C_SCL);
be_bryan 0:b74591d5ab33 96 pin_mode(scl, OpenDrain);
be_bryan 0:b74591d5ab33 97 pin_mode(scl, PullUp);
be_bryan 0:b74591d5ab33 98
be_bryan 0:b74591d5ab33 99 NVIC_DisableIRQ(obj->IRQn);
be_bryan 0:b74591d5ab33 100
be_bryan 0:b74591d5ab33 101 i2c_reset(obj);
be_bryan 0:b74591d5ab33 102 i2c_frequency(obj, 100000);
be_bryan 0:b74591d5ab33 103 }
be_bryan 0:b74591d5ab33 104
be_bryan 0:b74591d5ab33 105 // Configure the I2C frequency
be_bryan 0:b74591d5ab33 106 void i2c_frequency(i2c_t *obj, int hz)
be_bryan 0:b74591d5ab33 107 {
be_bryan 0:b74591d5ab33 108 uint64_t sck, tmp_sck;
be_bryan 0:b74591d5ab33 109 uint64_t prsck, tmp_prsck;
be_bryan 0:b74591d5ab33 110 uint64_t fscl, tmp_fscl;
be_bryan 0:b74591d5ab33 111 uint64_t fx;
be_bryan 0:b74591d5ab33 112
be_bryan 0:b74591d5ab33 113 SystemCoreClockUpdate();
be_bryan 0:b74591d5ab33 114
be_bryan 0:b74591d5ab33 115 if (hz <= 1000000) {
be_bryan 0:b74591d5ab33 116 sck = tmp_sck = 0;
be_bryan 0:b74591d5ab33 117 prsck = tmp_prsck = 1;
be_bryan 0:b74591d5ab33 118 fscl = tmp_fscl = 0;
be_bryan 0:b74591d5ab33 119 for (prsck = 1; prsck <= 32; prsck++) {
be_bryan 0:b74591d5ab33 120 fx = ((uint64_t)SystemCoreClock / prsck);
be_bryan 0:b74591d5ab33 121 if ((fx < 40000000U) && (fx > 6666666U)) {
be_bryan 0:b74591d5ab33 122 for (sck = 0; sck <= 7; sck++) {
be_bryan 0:b74591d5ab33 123 fscl = (fx / (uint64_t)I2C_SCK_DIVIDER_TBL[sck]);
be_bryan 0:b74591d5ab33 124 if ((fscl <= (uint64_t)hz) && (fscl > tmp_fscl)) {
be_bryan 0:b74591d5ab33 125 tmp_fscl = fscl;
be_bryan 0:b74591d5ab33 126 tmp_sck = sck;
be_bryan 0:b74591d5ab33 127 tmp_prsck = (prsck < 32)? prsck: 0;
be_bryan 0:b74591d5ab33 128 }
be_bryan 0:b74591d5ab33 129 }
be_bryan 0:b74591d5ab33 130 }
be_bryan 0:b74591d5ab33 131 }
be_bryan 0:b74591d5ab33 132 clk.sck = (uint32_t)tmp_sck;
be_bryan 0:b74591d5ab33 133 clk.prsck = (tmp_prsck < 32) ? (uint32_t)(tmp_prsck) : 0;
be_bryan 0:b74591d5ab33 134 }
be_bryan 0:b74591d5ab33 135 obj->myi2c.I2CSelfAddr = SELF_ADDR;
be_bryan 0:b74591d5ab33 136 obj->myi2c.I2CDataLen = I2C_DATA_LEN_8;
be_bryan 0:b74591d5ab33 137 obj->myi2c.I2CACKState = ENABLE;
be_bryan 0:b74591d5ab33 138 obj->myi2c.I2CClkDiv = clk.sck;
be_bryan 0:b74591d5ab33 139 obj->myi2c.PrescalerClkDiv = clk.prsck;
be_bryan 0:b74591d5ab33 140
be_bryan 0:b74591d5ab33 141 I2C_Init(obj->i2c, &obj->myi2c);
be_bryan 0:b74591d5ab33 142 NVIC_DisableIRQ(obj->IRQn);
be_bryan 0:b74591d5ab33 143 }
be_bryan 0:b74591d5ab33 144
be_bryan 0:b74591d5ab33 145 int i2c_start(i2c_t *obj)
be_bryan 0:b74591d5ab33 146 {
be_bryan 0:b74591d5ab33 147 start_flag = 1;
be_bryan 0:b74591d5ab33 148 return 0;
be_bryan 0:b74591d5ab33 149 }
be_bryan 0:b74591d5ab33 150
be_bryan 0:b74591d5ab33 151 int i2c_stop(i2c_t *obj)
be_bryan 0:b74591d5ab33 152 {
be_bryan 0:b74591d5ab33 153 I2C_GenerateStop(obj->i2c);
be_bryan 0:b74591d5ab33 154 return 0;
be_bryan 0:b74591d5ab33 155 }
be_bryan 0:b74591d5ab33 156
be_bryan 0:b74591d5ab33 157 void i2c_reset(i2c_t *obj)
be_bryan 0:b74591d5ab33 158 {
be_bryan 0:b74591d5ab33 159 I2C_SWReset(obj->i2c);
be_bryan 0:b74591d5ab33 160 }
be_bryan 0:b74591d5ab33 161
be_bryan 0:b74591d5ab33 162 int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
be_bryan 0:b74591d5ab33 163 {
be_bryan 0:b74591d5ab33 164 int32_t result = 0;
be_bryan 0:b74591d5ab33 165 int32_t count = 0;
be_bryan 0:b74591d5ab33 166
be_bryan 0:b74591d5ab33 167 if (length > 0) {
be_bryan 0:b74591d5ab33 168 start_flag = 1; // Start Condition
be_bryan 0:b74591d5ab33 169 if (i2c_byte_write(obj, (int32_t)((uint32_t)address | 1U)) == I2C_ACK) {
be_bryan 0:b74591d5ab33 170 while (count < length) {
be_bryan 0:b74591d5ab33 171 int32_t pdata = i2c_byte_read(obj, ((count < (length - 1)) ? 0 : 1));
be_bryan 0:b74591d5ab33 172 if (pdata < 0) {
be_bryan 0:b74591d5ab33 173 break;
be_bryan 0:b74591d5ab33 174 }
be_bryan 0:b74591d5ab33 175 data[count++] = (uint8_t)pdata;
be_bryan 0:b74591d5ab33 176 }
be_bryan 0:b74591d5ab33 177 result = count;
be_bryan 0:b74591d5ab33 178 } else {
be_bryan 0:b74591d5ab33 179 stop = 1;
be_bryan 0:b74591d5ab33 180 result = I2C_ERROR_NO_SLAVE;
be_bryan 0:b74591d5ab33 181 }
be_bryan 0:b74591d5ab33 182
be_bryan 0:b74591d5ab33 183 if (stop) { // Stop Condition
be_bryan 0:b74591d5ab33 184 i2c_stop(obj);
be_bryan 0:b74591d5ab33 185 }
be_bryan 0:b74591d5ab33 186 }
be_bryan 0:b74591d5ab33 187 return (result);
be_bryan 0:b74591d5ab33 188 }
be_bryan 0:b74591d5ab33 189
be_bryan 0:b74591d5ab33 190 int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) // Blocking sending data
be_bryan 0:b74591d5ab33 191 {
be_bryan 0:b74591d5ab33 192 int32_t result = 0;
be_bryan 0:b74591d5ab33 193 int32_t count = 0;
be_bryan 0:b74591d5ab33 194
be_bryan 0:b74591d5ab33 195 start_flag = 1; // Start Condition
be_bryan 0:b74591d5ab33 196 if (i2c_byte_write(obj, address) == I2C_ACK) {
be_bryan 0:b74591d5ab33 197 while (count < length) {
be_bryan 0:b74591d5ab33 198 if (i2c_byte_write(obj, (int32_t)data[count++]) < I2C_ACK) {
be_bryan 0:b74591d5ab33 199 break;
be_bryan 0:b74591d5ab33 200 }
be_bryan 0:b74591d5ab33 201 }
be_bryan 0:b74591d5ab33 202 result = count;
be_bryan 0:b74591d5ab33 203 } else {
be_bryan 0:b74591d5ab33 204 stop = 1;
be_bryan 0:b74591d5ab33 205 result = I2C_ERROR_NO_SLAVE;
be_bryan 0:b74591d5ab33 206 }
be_bryan 0:b74591d5ab33 207
be_bryan 0:b74591d5ab33 208 if (stop) { // Stop Condition
be_bryan 0:b74591d5ab33 209 i2c_stop(obj);
be_bryan 0:b74591d5ab33 210 }
be_bryan 0:b74591d5ab33 211 return (result);
be_bryan 0:b74591d5ab33 212 }
be_bryan 0:b74591d5ab33 213
be_bryan 0:b74591d5ab33 214 int i2c_byte_read(i2c_t *obj, int last)
be_bryan 0:b74591d5ab33 215 {
be_bryan 0:b74591d5ab33 216 int32_t result;
be_bryan 0:b74591d5ab33 217
be_bryan 0:b74591d5ab33 218 I2C_ClearINTOutput(obj->i2c);
be_bryan 0:b74591d5ab33 219
be_bryan 0:b74591d5ab33 220 if (last) {
be_bryan 0:b74591d5ab33 221 I2C_SelectACKoutput(obj->i2c, ENABLE);
be_bryan 0:b74591d5ab33 222 } else {
be_bryan 0:b74591d5ab33 223 I2C_SelectACKoutput(obj->i2c, DISABLE);
be_bryan 0:b74591d5ab33 224 }
be_bryan 0:b74591d5ab33 225 I2C_SetSendData(obj->i2c, 0x00);
be_bryan 0:b74591d5ab33 226
be_bryan 0:b74591d5ab33 227 if (wait_status(obj) < 0) {
be_bryan 0:b74591d5ab33 228 result = -1;
be_bryan 0:b74591d5ab33 229 } else {
be_bryan 0:b74591d5ab33 230 result = (int32_t)I2C_GetReceiveData(obj->i2c);
be_bryan 0:b74591d5ab33 231 }
be_bryan 0:b74591d5ab33 232 return (result);
be_bryan 0:b74591d5ab33 233 }
be_bryan 0:b74591d5ab33 234
be_bryan 0:b74591d5ab33 235 void I2C_Start_Condition(i2c_t *p_obj, uint32_t data)
be_bryan 0:b74591d5ab33 236 {
be_bryan 0:b74591d5ab33 237 status = I2C_GetState(p_obj->i2c);
be_bryan 0:b74591d5ab33 238 if (status.Bit.BusState) {
be_bryan 0:b74591d5ab33 239 I2C_SetRepeatStart(p_obj->i2c, ENABLE);
be_bryan 0:b74591d5ab33 240 }
be_bryan 0:b74591d5ab33 241 I2C_SetSendData(p_obj->i2c, (uint32_t)data);
be_bryan 0:b74591d5ab33 242 I2C_GenerateStart(p_obj->i2c);
be_bryan 0:b74591d5ab33 243 }
be_bryan 0:b74591d5ab33 244
be_bryan 0:b74591d5ab33 245 int i2c_byte_write(i2c_t *obj, int data)
be_bryan 0:b74591d5ab33 246 {
be_bryan 0:b74591d5ab33 247 int32_t result;
be_bryan 0:b74591d5ab33 248
be_bryan 0:b74591d5ab33 249 I2C_ClearINTOutput(obj->i2c);
be_bryan 0:b74591d5ab33 250
be_bryan 0:b74591d5ab33 251 if (start_flag == 1) {
be_bryan 0:b74591d5ab33 252 I2C_Start_Condition(obj, (uint32_t)data);
be_bryan 0:b74591d5ab33 253 start_flag = 0;
be_bryan 0:b74591d5ab33 254 } else {
be_bryan 0:b74591d5ab33 255 I2C_SetSendData(obj->i2c, (uint32_t)data);
be_bryan 0:b74591d5ab33 256 }
be_bryan 0:b74591d5ab33 257
be_bryan 0:b74591d5ab33 258 if (wait_status(obj) < 0) {
be_bryan 0:b74591d5ab33 259 return (-1);
be_bryan 0:b74591d5ab33 260 }
be_bryan 0:b74591d5ab33 261
be_bryan 0:b74591d5ab33 262 status = I2C_GetState(obj->i2c);
be_bryan 0:b74591d5ab33 263 if (!status.Bit.LastRxBit) {
be_bryan 0:b74591d5ab33 264 result = 1;
be_bryan 0:b74591d5ab33 265 } else {
be_bryan 0:b74591d5ab33 266 result = 0;
be_bryan 0:b74591d5ab33 267 }
be_bryan 0:b74591d5ab33 268 return (result);
be_bryan 0:b74591d5ab33 269 }
be_bryan 0:b74591d5ab33 270
be_bryan 0:b74591d5ab33 271 void i2c_slave_mode(i2c_t *obj, int enable_slave)
be_bryan 0:b74591d5ab33 272 {
be_bryan 0:b74591d5ab33 273 i2c_reset(obj);
be_bryan 0:b74591d5ab33 274
be_bryan 0:b74591d5ab33 275 obj->myi2c.I2CDataLen = I2C_DATA_LEN_8;
be_bryan 0:b74591d5ab33 276 obj->myi2c.I2CACKState = ENABLE;
be_bryan 0:b74591d5ab33 277 obj->myi2c.I2CClkDiv = clk.sck;
be_bryan 0:b74591d5ab33 278 obj->myi2c.PrescalerClkDiv = clk.prsck;
be_bryan 0:b74591d5ab33 279
be_bryan 0:b74591d5ab33 280 if (enable_slave) {
be_bryan 0:b74591d5ab33 281 obj->myi2c.I2CSelfAddr = obj->address;
be_bryan 0:b74591d5ab33 282 I2C_SetINTI2CReq(obj->i2c, ENABLE);
be_bryan 0:b74591d5ab33 283 } else {
be_bryan 0:b74591d5ab33 284 obj->myi2c.I2CSelfAddr = SELF_ADDR;
be_bryan 0:b74591d5ab33 285 NVIC_DisableIRQ(obj->IRQn);
be_bryan 0:b74591d5ab33 286 I2C_ClearINTOutput(obj->i2c);
be_bryan 0:b74591d5ab33 287 }
be_bryan 0:b74591d5ab33 288 I2C_Init(obj->i2c, &obj->myi2c);
be_bryan 0:b74591d5ab33 289 }
be_bryan 0:b74591d5ab33 290
be_bryan 0:b74591d5ab33 291 int i2c_slave_receive(i2c_t *obj)
be_bryan 0:b74591d5ab33 292 {
be_bryan 0:b74591d5ab33 293 int32_t result = I2C_NO_DATA;
be_bryan 0:b74591d5ab33 294
be_bryan 0:b74591d5ab33 295 if ((I2C_GetINTI2CStatus(obj->i2c)) && (I2C_GetSlaveAddrMatchState(obj->i2c))) {
be_bryan 0:b74591d5ab33 296 status = I2C_GetState(obj->i2c);
be_bryan 0:b74591d5ab33 297 if (!status.Bit.TRx) {
be_bryan 0:b74591d5ab33 298 result = I2C_WRITE_ADDRESSED;
be_bryan 0:b74591d5ab33 299 } else {
be_bryan 0:b74591d5ab33 300 result = I2C_READ_ADDRESSED;
be_bryan 0:b74591d5ab33 301 }
be_bryan 0:b74591d5ab33 302 }
be_bryan 0:b74591d5ab33 303 return (result);
be_bryan 0:b74591d5ab33 304 }
be_bryan 0:b74591d5ab33 305
be_bryan 0:b74591d5ab33 306 int i2c_slave_read(i2c_t *obj, char *data, int length)
be_bryan 0:b74591d5ab33 307 {
be_bryan 0:b74591d5ab33 308 int32_t count = 0;
be_bryan 0:b74591d5ab33 309
be_bryan 0:b74591d5ab33 310 while (count < length) {
be_bryan 0:b74591d5ab33 311 int32_t pdata = i2c_byte_read(obj, ((count < (length - 1))? 0: 1));
be_bryan 0:b74591d5ab33 312 status = I2C_GetState(obj->i2c);
be_bryan 0:b74591d5ab33 313 if (status.Bit.TRx) {
be_bryan 0:b74591d5ab33 314 return (count);
be_bryan 0:b74591d5ab33 315 } else {
be_bryan 0:b74591d5ab33 316 if (pdata < 0) {
be_bryan 0:b74591d5ab33 317 break;
be_bryan 0:b74591d5ab33 318 }
be_bryan 0:b74591d5ab33 319 data[count++] = (uint8_t)pdata;
be_bryan 0:b74591d5ab33 320 }
be_bryan 0:b74591d5ab33 321 }
be_bryan 0:b74591d5ab33 322 i2c_slave_mode(obj, 1);
be_bryan 0:b74591d5ab33 323 return (count);
be_bryan 0:b74591d5ab33 324 }
be_bryan 0:b74591d5ab33 325
be_bryan 0:b74591d5ab33 326 int i2c_slave_write(i2c_t *obj, const char *data, int length)
be_bryan 0:b74591d5ab33 327 {
be_bryan 0:b74591d5ab33 328 int32_t count = 0;
be_bryan 0:b74591d5ab33 329
be_bryan 0:b74591d5ab33 330 while (count < length) {
be_bryan 0:b74591d5ab33 331 if (i2c_byte_write(obj, (int32_t)data[count++]) < I2C_ACK) {
be_bryan 0:b74591d5ab33 332 break;
be_bryan 0:b74591d5ab33 333 }
be_bryan 0:b74591d5ab33 334 }
be_bryan 0:b74591d5ab33 335 i2c_slave_mode(obj, 1);
be_bryan 0:b74591d5ab33 336 return (count);
be_bryan 0:b74591d5ab33 337 }
be_bryan 0:b74591d5ab33 338
be_bryan 0:b74591d5ab33 339 void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask)
be_bryan 0:b74591d5ab33 340 {
be_bryan 0:b74591d5ab33 341 obj->address = address & 0xFE;
be_bryan 0:b74591d5ab33 342 i2c_slave_mode(obj, 1);
be_bryan 0:b74591d5ab33 343 }