1 /*
2 * Copyright 2018 NXP
3 * All rights reserved.
4 *
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9 #include "fsl_common.h"
10 #include "fsl_lpi2c.h"
11
12 #include "fsl_adapter_i2c.h"
13
14 /*******************************************************************************
15 * Definitions
16 ******************************************************************************/
17
18 /*! @brief i2c master state structure. */
19 typedef struct _hal_i2c_master
20 {
21 hal_i2c_master_transfer_callback_t callback;
22 void *callbackParam;
23 lpi2c_master_handle_t hardwareHandle;
24 uint8_t instance;
25 } hal_i2c_master_t;
26
27 /*! @brief i2c slave state structure. */
28 typedef struct _hal_i2c_slave
29 {
30 hal_i2c_slave_transfer_callback_t callback;
31 void *callbackParam;
32 hal_i2c_slave_transfer_t transfer;
33 lpi2c_slave_handle_t hardwareHandle;
34 uint8_t instance;
35 } hal_i2c_slave_t;
36
37 /*******************************************************************************
38 * Prototypes
39 ******************************************************************************/
40
41 /*******************************************************************************
42 * Variables
43 ******************************************************************************/
44
45 /*! @brief Pointers to i2c bases for each instance. */
46 static LPI2C_Type *const s_i2cBases[] = LPI2C_BASE_PTRS;
47
48 /*******************************************************************************
49 * Code
50 ******************************************************************************/
51
HAL_I2cGetStatus(status_t status)52 static hal_i2c_status_t HAL_I2cGetStatus(status_t status)
53 {
54 hal_i2c_status_t returnStatus;
55 switch (status)
56 {
57 case kStatus_Success:
58 {
59 returnStatus = kStatus_HAL_I2cSuccess;
60 break;
61 }
62 case kStatus_LPI2C_Busy:
63 {
64 returnStatus = kStatus_HAL_I2cBusy;
65 break;
66 }
67 case kStatus_LPI2C_Idle:
68 {
69 returnStatus = kStatus_HAL_I2cIdle;
70 break;
71 }
72 case kStatus_LPI2C_Nak:
73 {
74 returnStatus = kStatus_HAL_I2cNak;
75 break;
76 }
77 case kStatus_LPI2C_ArbitrationLost:
78 {
79 returnStatus = kStatus_HAL_I2cArbitrationLost;
80 break;
81 }
82 case kStatus_LPI2C_Timeout:
83 {
84 returnStatus = kStatus_HAL_I2cTimeout;
85 break;
86 }
87 default:
88 {
89 returnStatus = kStatus_HAL_I2cError;
90 break;
91 }
92 }
93 return returnStatus;
94 }
95
HAL_I2cMasterCallback(LPI2C_Type * lpi2cBase,lpi2c_master_handle_t * handle,status_t status,void * callbackParam)96 static void HAL_I2cMasterCallback(LPI2C_Type *lpi2cBase,
97 lpi2c_master_handle_t *handle,
98 status_t status,
99 void *callbackParam)
100 {
101 hal_i2c_master_t *i2cMasterHandle;
102 assert(NULL != callbackParam);
103
104 i2cMasterHandle = (hal_i2c_master_t *)callbackParam;
105
106 if (NULL != i2cMasterHandle->callback)
107 {
108 i2cMasterHandle->callback(i2cMasterHandle, HAL_I2cGetStatus(status), i2cMasterHandle->callbackParam);
109 }
110 }
111
HAL_I2cSlaveCallback(LPI2C_Type * lpi2cBase,lpi2c_slave_transfer_t * xfer,void * callbackParam)112 static void HAL_I2cSlaveCallback(LPI2C_Type *lpi2cBase, lpi2c_slave_transfer_t *xfer, void *callbackParam)
113 {
114 hal_i2c_slave_t *i2cSlaveHandle;
115 assert(NULL != callbackParam);
116
117 i2cSlaveHandle = (hal_i2c_slave_t *)callbackParam;
118
119 if (NULL != i2cSlaveHandle->callback)
120 {
121 i2cSlaveHandle->transfer.event = (hal_i2c_slave_transfer_event_t)xfer->event;
122 i2cSlaveHandle->transfer.data = xfer->data;
123 i2cSlaveHandle->transfer.dataSize = xfer->dataSize;
124 i2cSlaveHandle->transfer.completionStatus = HAL_I2cGetStatus(xfer->completionStatus);
125 i2cSlaveHandle->transfer.transferredCount = xfer->transferredCount;
126 i2cSlaveHandle->callback(i2cSlaveHandle, &i2cSlaveHandle->transfer, i2cSlaveHandle->callbackParam);
127 xfer->data = i2cSlaveHandle->transfer.data;
128 xfer->dataSize = i2cSlaveHandle->transfer.dataSize;
129 }
130 }
131
HAL_I2cMasterInit(hal_i2c_master_handle_t handle,const hal_i2c_master_config_t * halI2cConfig)132 hal_i2c_status_t HAL_I2cMasterInit(hal_i2c_master_handle_t handle, const hal_i2c_master_config_t *halI2cConfig)
133 {
134 hal_i2c_master_t *i2cMasterHandle;
135 lpi2c_master_config_t i2cConfig;
136
137 assert(NULL != handle);
138 assert(NULL != halI2cConfig);
139 assert(HAL_I2C_MASTER_HANDLE_SIZE >= sizeof(hal_i2c_master_t));
140
141 i2cMasterHandle = (hal_i2c_master_t *)handle;
142
143 LPI2C_MasterGetDefaultConfig(&i2cConfig);
144 i2cConfig.enableMaster = halI2cConfig->enableMaster;
145 i2cConfig.baudRate_Hz = halI2cConfig->baudRate_Bps;
146 i2cMasterHandle->instance = halI2cConfig->instance;
147
148 LPI2C_MasterInit(s_i2cBases[i2cMasterHandle->instance], &i2cConfig, halI2cConfig->srcClock_Hz);
149
150 return kStatus_HAL_I2cSuccess;
151 }
152
HAL_I2cSlaveInit(hal_i2c_slave_handle_t handle,const hal_i2c_slave_config_t * halI2cConfig)153 hal_i2c_status_t HAL_I2cSlaveInit(hal_i2c_slave_handle_t handle, const hal_i2c_slave_config_t *halI2cConfig)
154 {
155 hal_i2c_slave_t *i2cSlaveHandle;
156 lpi2c_slave_config_t i2cConfig;
157
158 assert(NULL != handle);
159 assert(NULL != halI2cConfig);
160 assert(HAL_I2C_SLAVE_HANDLE_SIZE >= sizeof(hal_i2c_slave_t));
161
162 i2cSlaveHandle = (hal_i2c_slave_t *)handle;
163
164 LPI2C_SlaveGetDefaultConfig(&i2cConfig);
165 i2cConfig.enableSlave = halI2cConfig->enableSlave;
166 i2cConfig.address0 = (uint8_t)halI2cConfig->slaveAddress;
167 i2cSlaveHandle->instance = halI2cConfig->instance;
168
169 LPI2C_SlaveInit(s_i2cBases[i2cSlaveHandle->instance], &i2cConfig, halI2cConfig->srcClock_Hz);
170
171 return kStatus_HAL_I2cSuccess;
172 }
173
HAL_I2cMasterDeinit(hal_i2c_master_handle_t handle)174 hal_i2c_status_t HAL_I2cMasterDeinit(hal_i2c_master_handle_t handle)
175 {
176 hal_i2c_master_t *i2cMasterHandle;
177
178 assert(NULL != handle);
179
180 i2cMasterHandle = (hal_i2c_master_t *)handle;
181
182 LPI2C_MasterDeinit(s_i2cBases[i2cMasterHandle->instance]);
183
184 return kStatus_HAL_I2cSuccess;
185 }
186
HAL_I2cSlaveDeinit(hal_i2c_slave_handle_t handle)187 hal_i2c_status_t HAL_I2cSlaveDeinit(hal_i2c_slave_handle_t handle)
188 {
189 hal_i2c_slave_t *i2cSlaveHandle;
190
191 assert(NULL != handle);
192
193 i2cSlaveHandle = (hal_i2c_slave_t *)handle;
194
195 LPI2C_SlaveDeinit(s_i2cBases[i2cSlaveHandle->instance]);
196
197 return kStatus_HAL_I2cSuccess;
198 }
199
HAL_I2cMasterWriteBlocking(hal_i2c_master_handle_t handle,const uint8_t * txBuff,size_t txSize,uint32_t flags)200 hal_i2c_status_t HAL_I2cMasterWriteBlocking(hal_i2c_master_handle_t handle,
201 const uint8_t *txBuff,
202 size_t txSize,
203 uint32_t flags)
204 {
205 return kStatus_HAL_I2cError;
206 }
207
HAL_I2cMasterReadBlocking(hal_i2c_master_handle_t handle,uint8_t * rxBuff,size_t rxSize,uint32_t flags)208 hal_i2c_status_t HAL_I2cMasterReadBlocking(hal_i2c_master_handle_t handle,
209 uint8_t *rxBuff,
210 size_t rxSize,
211 uint32_t flags)
212 {
213 return kStatus_HAL_I2cError;
214 }
215
HAL_I2cSlaveWriteBlocking(hal_i2c_slave_handle_t handle,const uint8_t * txBuff,size_t txSize)216 hal_i2c_status_t HAL_I2cSlaveWriteBlocking(hal_i2c_slave_handle_t handle, const uint8_t *txBuff, size_t txSize)
217 {
218 return kStatus_HAL_I2cError;
219 }
220
HAL_I2cSlaveReadBlocking(hal_i2c_slave_handle_t handle,uint8_t * rxBuff,size_t rxSize)221 hal_i2c_status_t HAL_I2cSlaveReadBlocking(hal_i2c_slave_handle_t handle, uint8_t *rxBuff, size_t rxSize)
222 {
223 return kStatus_HAL_I2cError;
224 }
225
HAL_I2cMasterTransferBlocking(hal_i2c_master_handle_t handle,hal_i2c_master_transfer_t * xfer)226 hal_i2c_status_t HAL_I2cMasterTransferBlocking(hal_i2c_master_handle_t handle, hal_i2c_master_transfer_t *xfer)
227 {
228 hal_i2c_master_t *i2cMasterHandle;
229 lpi2c_master_transfer_t transfer;
230
231 assert(NULL != handle);
232 assert(NULL != xfer);
233
234 i2cMasterHandle = (hal_i2c_master_t *)handle;
235
236 transfer.flags = xfer->flags;
237 transfer.slaveAddress = xfer->slaveAddress;
238 transfer.direction = (kHAL_I2cRead == xfer->direction) ? kLPI2C_Read : kLPI2C_Write;
239 transfer.subaddress = xfer->subaddress;
240 transfer.subaddressSize = xfer->subaddressSize;
241 transfer.data = xfer->data;
242 transfer.dataSize = xfer->dataSize;
243
244 return HAL_I2cGetStatus(LPI2C_MasterTransferBlocking(s_i2cBases[i2cMasterHandle->instance], &transfer));
245 }
246
HAL_I2cMasterTransferInstallCallback(hal_i2c_master_handle_t handle,hal_i2c_master_transfer_callback_t callback,void * callbackParam)247 hal_i2c_status_t HAL_I2cMasterTransferInstallCallback(hal_i2c_master_handle_t handle,
248 hal_i2c_master_transfer_callback_t callback,
249 void *callbackParam)
250 {
251 hal_i2c_master_t *i2cMasterHandle;
252
253 assert(NULL != handle);
254
255 i2cMasterHandle = (hal_i2c_master_t *)handle;
256
257 i2cMasterHandle->callback = callback;
258 i2cMasterHandle->callbackParam = callbackParam;
259 LPI2C_MasterTransferCreateHandle(s_i2cBases[i2cMasterHandle->instance], &i2cMasterHandle->hardwareHandle,
260 HAL_I2cMasterCallback, i2cMasterHandle);
261
262 return kStatus_HAL_I2cSuccess;
263 }
264
HAL_I2cMasterTransferNonBlocking(hal_i2c_master_handle_t handle,hal_i2c_master_transfer_t * xfer)265 hal_i2c_status_t HAL_I2cMasterTransferNonBlocking(hal_i2c_master_handle_t handle, hal_i2c_master_transfer_t *xfer)
266 {
267 hal_i2c_master_t *i2cMasterHandle;
268 lpi2c_master_transfer_t transfer;
269
270 assert(NULL != handle);
271 assert(NULL != xfer);
272
273 i2cMasterHandle = (hal_i2c_master_t *)handle;
274
275 transfer.flags = xfer->flags;
276 transfer.slaveAddress = xfer->slaveAddress;
277 transfer.direction = (kHAL_I2cRead == xfer->direction) ? kLPI2C_Read : kLPI2C_Write;
278 transfer.subaddress = xfer->subaddress;
279 transfer.subaddressSize = xfer->subaddressSize;
280 transfer.data = xfer->data;
281 transfer.dataSize = xfer->dataSize;
282 return HAL_I2cGetStatus(LPI2C_MasterTransferNonBlocking(s_i2cBases[i2cMasterHandle->instance],
283 &i2cMasterHandle->hardwareHandle, &transfer));
284 }
285
HAL_I2cMasterTransferGetCount(hal_i2c_master_handle_t handle,size_t * count)286 hal_i2c_status_t HAL_I2cMasterTransferGetCount(hal_i2c_master_handle_t handle, size_t *count)
287 {
288 hal_i2c_master_t *i2cMasterHandle;
289
290 assert(NULL != handle);
291 assert(NULL != count);
292
293 i2cMasterHandle = (hal_i2c_master_t *)handle;
294 return HAL_I2cGetStatus(
295 LPI2C_MasterTransferGetCount(s_i2cBases[i2cMasterHandle->instance], &i2cMasterHandle->hardwareHandle, count));
296 }
297
HAL_I2cMasterTransferAbort(hal_i2c_master_handle_t handle)298 hal_i2c_status_t HAL_I2cMasterTransferAbort(hal_i2c_master_handle_t handle)
299 {
300 hal_i2c_master_t *i2cMasterHandle;
301
302 assert(NULL != handle);
303
304 i2cMasterHandle = (hal_i2c_master_t *)handle;
305 LPI2C_MasterTransferAbort(s_i2cBases[i2cMasterHandle->instance], &i2cMasterHandle->hardwareHandle);
306
307 return kStatus_HAL_I2cSuccess;
308 }
309
HAL_I2cSlaveTransferInstallCallback(hal_i2c_slave_handle_t handle,hal_i2c_slave_transfer_callback_t callback,void * callbackParam)310 hal_i2c_status_t HAL_I2cSlaveTransferInstallCallback(hal_i2c_slave_handle_t handle,
311 hal_i2c_slave_transfer_callback_t callback,
312 void *callbackParam)
313 {
314 hal_i2c_slave_t *i2cSlaveHandle;
315
316 assert(NULL != handle);
317
318 i2cSlaveHandle = (hal_i2c_slave_t *)handle;
319
320 i2cSlaveHandle->callback = callback;
321 i2cSlaveHandle->callbackParam = callbackParam;
322 LPI2C_SlaveTransferCreateHandle(s_i2cBases[i2cSlaveHandle->instance], &i2cSlaveHandle->hardwareHandle,
323 HAL_I2cSlaveCallback, i2cSlaveHandle);
324
325 return kStatus_HAL_I2cSuccess;
326 }
327
HAL_I2cSlaveTransferNonBlocking(hal_i2c_slave_handle_t handle,uint32_t eventMask)328 hal_i2c_status_t HAL_I2cSlaveTransferNonBlocking(hal_i2c_slave_handle_t handle, uint32_t eventMask)
329 {
330 hal_i2c_slave_t *i2cSlaveHandle;
331
332 assert(NULL != handle);
333
334 i2cSlaveHandle = (hal_i2c_slave_t *)handle;
335
336 return HAL_I2cGetStatus(LPI2C_SlaveTransferNonBlocking(s_i2cBases[i2cSlaveHandle->instance],
337 &i2cSlaveHandle->hardwareHandle, eventMask));
338 }
339
HAL_I2cSlaveTransferAbort(hal_i2c_slave_handle_t handle)340 hal_i2c_status_t HAL_I2cSlaveTransferAbort(hal_i2c_slave_handle_t handle)
341 {
342 hal_i2c_slave_t *i2cSlaveHandle;
343
344 assert(NULL != handle);
345
346 i2cSlaveHandle = (hal_i2c_slave_t *)handle;
347
348 LPI2C_SlaveTransferAbort(s_i2cBases[i2cSlaveHandle->instance], &i2cSlaveHandle->hardwareHandle);
349
350 return kStatus_HAL_I2cSuccess;
351 }
352
HAL_I2cSlaveTransferGetCount(hal_i2c_slave_handle_t handle,size_t * count)353 hal_i2c_status_t HAL_I2cSlaveTransferGetCount(hal_i2c_slave_handle_t handle, size_t *count)
354 {
355 hal_i2c_slave_t *i2cSlaveHandle;
356
357 assert(NULL != handle);
358 assert(NULL != count);
359
360 i2cSlaveHandle = (hal_i2c_slave_t *)handle;
361
362 return HAL_I2cGetStatus(
363 LPI2C_SlaveTransferGetCount(s_i2cBases[i2cSlaveHandle->instance], &i2cSlaveHandle->hardwareHandle, count));
364 }
365
