1 /**
2 ****************************************************************************************
3 * @file app_i2c.c
4 * @author BLE Driver Team
5 * @brief HAL APP module driver.
6 ****************************************************************************************
7 * @attention
8 #####Copyright (c) 2019 GOODIX
9 All rights reserved.
10
11 Redistribution and use in source and binary forms, with or without
12 modification, are permitted provided that the following conditions are met:
13 * Redistributions of source code must retain the above copyright
14 notice, this list of conditions and the following disclaimer.
15 * Redistributions in binary form must reproduce the above copyright
16 notice, this list of conditions and the following disclaimer in the
17 documentation and/or other materials provided with the distribution.
18 * Neither the name of GOODIX nor the names of its contributors may be used
19 to endorse or promote products derived from this software without
20 specific prior written permission.
21
22 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
26 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 POSSIBILITY OF SUCH DAMAGE.
33 ****************************************************************************************
34 */
35
36 /*
37 * INCLUDE FILES
38 *****************************************************************************************
39 */
40 #include <string.h>
41 #include "app_io.h"
42 #include "app_dma.h"
43 #include "app_pwr_mgmt.h"
44 #include "app_systick.h"
45 #include "platform_sdk.h"
46 #include "app_i2c.h"
47
48 #ifdef HAL_I2C_MODULE_ENABLED
49
50 /*
51 * DEFINES
52 *****************************************************************************************
53 */
54
55 /*
56 * STRUCT DEFINE
57 *****************************************************************************************
58 */
59
60 /**@brief App i2c state types. */
61 typedef enum {
62 APP_I2C_INVALID = 0,
63 APP_I2C_ACTIVITY,
64 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
65 APP_I2C_SLEEP,
66 #endif
67 } app_i2c_state_t;
68
69 struct i2c_env_t {
70 app_i2c_evt_handler_t evt_handler;
71 i2c_handle_t handle;
72 app_i2c_mode_t use_mode;
73 app_i2c_role_t role;
74 app_i2c_pin_cfg_t pin_cfg;
75 int16_t dma_id[2];
76 app_i2c_state_t i2c_state;
77 bool start_flag;
78 #ifdef ENV_RTOS_USE_SEMP
79 APP_DRV_SEM_DECL(sem_tx);
80 APP_DRV_SEM_DECL(sem_rx);
81 #endif
82
83 #ifdef ENV_RTOS_USE_MUTEX
84 APP_DRV_MUTEX_DECL(mutex_sync);
85 APP_DRV_MUTEX_DECL(mutex_async);
86 #endif
87 };
88
89 /*
90 * LOCAL FUNCTION DECLARATION
91 *****************************************************************************************
92 */
93 static bool i2c_prepare_for_sleep(void);
94 static void i2c_sleep_canceled(void);
95 static void i2c_wake_up_ind(void);
96 static uint16_t i2c_gpio_config(app_i2c_pin_cfg_t pin_cfg);
97
98 /*
99 * LOCAL VARIABLE DEFINITIONS
100 *****************************************************************************************
101 */
102 static const IRQn_Type s_i2c_irq[APP_I2C_ID_MAX] = { I2C0_IRQn, I2C1_IRQn };
103 static const uint32_t s_i2c_instance[APP_I2C_ID_MAX] = { I2C0_BASE, I2C1_BASE };
104
105 struct i2c_env_t s_i2c_env[APP_I2C_ID_MAX] = {
106 {
107 .evt_handler = NULL,
108 #ifdef ENV_RTOS_USE_SEMP
109 .sem_tx = NULL,
110 .sem_rx = NULL,
111 #endif
112 #ifdef ENV_RTOS_USE_MUTEX
113 .mutex_sync = NULL,
114 .mutex_async = NULL,
115 #endif
116 },
117 {
118 .evt_handler = NULL,
119 #ifdef ENV_RTOS_USE_SEMP
120 .sem_tx = NULL,
121 .sem_rx = NULL,
122 #endif
123 #ifdef ENV_RTOS_USE_MUTEX
124 .mutex_sync = NULL,
125 .mutex_async = NULL,
126 #endif
127 },
128 };
129 static bool s_sleep_cb_registered_flag = false;
130 static int16_t s_i2c_pwr_id;
131
132 static const app_sleep_callbacks_t i2c_sleep_cb = {
133 .app_prepare_for_sleep = i2c_prepare_for_sleep,
134 .app_sleep_canceled = i2c_sleep_canceled,
135 .app_wake_up_ind = i2c_wake_up_ind
136 };
137
138 #ifdef ENV_RTOS_USE_MUTEX
139 static inline void APP_I2C_DRV_SYNC_MUTEX_LOCK(app_i2c_id_t id);
140 static inline void APP_I2C_DRV_SYNC_MUTEX_UNLOCK(app_i2c_id_t id);
141 static inline void APP_I2C_DRV_ASYNC_MUTEX_LOCK(app_i2c_id_t id);
142 static inline void APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(app_i2c_id_t id);
143
APP_I2C_DRV_SYNC_MUTEX_LOCK(app_i2c_id_t id)144 static inline void APP_I2C_DRV_SYNC_MUTEX_LOCK(app_i2c_id_t id)
145 {
146 app_driver_mutex_pend(s_i2c_env[id].mutex_sync, MUTEX_WAIT_FOREVER);
147 }
148
APP_I2C_DRV_SYNC_MUTEX_UNLOCK(app_i2c_id_t id)149 static inline void APP_I2C_DRV_SYNC_MUTEX_UNLOCK(app_i2c_id_t id)
150 {
151 app_driver_mutex_post(s_i2c_env[id].mutex_sync);
152 }
153
APP_I2C_DRV_ASYNC_MUTEX_LOCK(app_i2c_id_t id)154 static inline void APP_I2C_DRV_ASYNC_MUTEX_LOCK(app_i2c_id_t id)
155 {
156 app_driver_mutex_pend(s_i2c_env[id].mutex_async, MUTEX_WAIT_FOREVER);
157 }
158
APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(app_i2c_id_t id)159 static inline void APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(app_i2c_id_t id)
160 {
161 app_driver_mutex_post(s_i2c_env[id].mutex_async);
162 }
163 #endif
164
165 /*
166 * LOCAL FUNCTION DEFINITIONS
167 *****************************************************************************************
168 */
i2c_prepare_for_sleep(void)169 static bool i2c_prepare_for_sleep(void)
170 {
171 hal_i2c_state_t state;
172
173 for (uint8_t i = 0; i < APP_I2C_ID_MAX; i++) {
174 if (s_i2c_env[i].i2c_state == APP_I2C_ACTIVITY) {
175 state = hal_i2c_get_state(&s_i2c_env[i].handle);
176 if ((state != HAL_I2C_STATE_READY) && (state != HAL_I2C_STATE_RESET)) {
177 return false;
178 }
179
180 GLOBAL_EXCEPTION_DISABLE();
181 hal_i2c_suspend_reg(&s_i2c_env[i].handle);
182 GLOBAL_EXCEPTION_ENABLE();
183
184 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
185 s_i2c_env[i].i2c_state = APP_I2C_SLEEP;
186 #endif
187 }
188 }
189
190 return true;
191 }
192
i2c_sleep_canceled(void)193 static void i2c_sleep_canceled(void)
194 {
195 }
196
i2c_wake_up_ind(void)197 SECTION_RAM_CODE static void i2c_wake_up_ind(void)
198 {
199 #ifndef APP_DRIVER_WAKEUP_CALL_FUN
200 for (uint8_t i = 0; i < APP_I2C_ID_MAX; i++) {
201 if (s_i2c_env[i].i2c_state == APP_I2C_ACTIVITY) {
202 GLOBAL_EXCEPTION_DISABLE();
203 hal_i2c_resume_reg(&s_i2c_env[i].handle);
204 GLOBAL_EXCEPTION_ENABLE();
205
206 if (s_i2c_env[i].use_mode.type != APP_I2C_TYPE_POLLING) {
207 hal_nvic_clear_pending_irq(s_i2c_irq[i]);
208 hal_nvic_enable_irq(s_i2c_irq[i]);
209 }
210 }
211 }
212 #endif
213 }
214
215 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
i2c_wake_up(app_i2c_id_t id)216 static void i2c_wake_up(app_i2c_id_t id)
217 {
218 if (s_i2c_env[id].i2c_state == APP_I2C_SLEEP) {
219 GLOBAL_EXCEPTION_DISABLE();
220 hal_i2c_resume_reg(&s_i2c_env[id].handle);
221 GLOBAL_EXCEPTION_ENABLE();
222
223 if (s_i2c_env[id].use_mode.type != APP_I2C_TYPE_POLLING) {
224 hal_nvic_clear_pending_irq(s_i2c_irq[id]);
225 hal_nvic_enable_irq(s_i2c_irq[id]);
226 }
227 s_i2c_env[id].i2c_state = APP_I2C_ACTIVITY;
228 }
229
230 if (s_i2c_env[id].use_mode.type == APP_I2C_TYPE_DMA) {
231 dma_wake_up(s_i2c_env[id].dma_id[0]);
232 dma_wake_up(s_i2c_env[id].dma_id[1]);
233 }
234 }
235 #endif
236
i2c_gpio_config(app_i2c_pin_cfg_t pin_cfg)237 static uint16_t i2c_gpio_config(app_i2c_pin_cfg_t pin_cfg)
238 {
239 app_io_init_t io_init = APP_IO_DEFAULT_CONFIG;
240 app_drv_err_t err_code = APP_DRV_SUCCESS;
241
242 io_init.pull = pin_cfg.scl.pull;
243 io_init.mode = APP_IO_MODE_MUX;
244 io_init.pin = pin_cfg.scl.pin;
245 io_init.mux = pin_cfg.scl.mux;
246 err_code = app_io_init(pin_cfg.scl.type, &io_init);
247 APP_DRV_ERR_CODE_CHECK(err_code);
248
249 io_init.pull = pin_cfg.sda.pull;
250 io_init.pin = pin_cfg.sda.pin;
251 io_init.mux = pin_cfg.sda.mux;
252 err_code = app_io_init(pin_cfg.sda.type, &io_init);
253 APP_DRV_ERR_CODE_CHECK(err_code);
254
255 return err_code;
256 }
257
app_i2c_config_dma(app_i2c_params_t * p_params)258 static uint16_t app_i2c_config_dma(app_i2c_params_t *p_params)
259 {
260 app_dma_params_t tx_dma_params;
261 app_dma_params_t rx_dma_params;
262
263 tx_dma_params.channel_number = p_params->use_mode.tx_dma_channel;
264 tx_dma_params.init.src_request = DMA_REQUEST_MEM;
265 tx_dma_params.init.dst_request = (p_params->id == APP_I2C_ID_0) ? \
266 DMA_REQUEST_I2C0_TX : DMA_REQUEST_I2C1_TX;
267 tx_dma_params.init.direction = DMA_MEMORY_TO_PERIPH;
268 tx_dma_params.init.src_increment = DMA_SRC_INCREMENT;
269 tx_dma_params.init.dst_increment = DMA_DST_NO_CHANGE;
270 tx_dma_params.init.src_data_alignment = DMA_SDATAALIGN_BYTE;
271 tx_dma_params.init.dst_data_alignment = DMA_DDATAALIGN_BYTE;
272 tx_dma_params.init.mode = DMA_NORMAL;
273 tx_dma_params.init.priority = DMA_PRIORITY_LOW;
274
275 s_i2c_env[p_params->id].dma_id[0] = app_dma_init(&tx_dma_params, NULL);
276 if (s_i2c_env[p_params->id].dma_id[0] < 0) {
277 return APP_DRV_ERR_INVALID_PARAM;
278 }
279 s_i2c_env[p_params->id].handle.p_dmatx = app_dma_get_handle(s_i2c_env[p_params->id].dma_id[0]);
280 s_i2c_env[p_params->id].handle.p_dmatx->p_parent = (void*)&s_i2c_env[p_params->id].handle;
281
282 rx_dma_params.channel_number = p_params->use_mode.rx_dma_channel;
283 rx_dma_params.init.src_request = (p_params->id == APP_I2C_ID_0) ? \
284 DMA_REQUEST_I2C0_RX : DMA_REQUEST_I2C1_RX;
285 rx_dma_params.init.dst_request = DMA_REQUEST_MEM;
286 rx_dma_params.init.direction = DMA_PERIPH_TO_MEMORY;
287 rx_dma_params.init.src_increment = DMA_SRC_NO_CHANGE;
288 rx_dma_params.init.dst_increment = DMA_DST_INCREMENT;
289 rx_dma_params.init.src_data_alignment = DMA_SDATAALIGN_BYTE;
290 rx_dma_params.init.dst_data_alignment = DMA_DDATAALIGN_BYTE;
291 rx_dma_params.init.mode = DMA_NORMAL;
292 rx_dma_params.init.priority = DMA_PRIORITY_LOW;
293
294 s_i2c_env[p_params->id].dma_id[1] = app_dma_init(&rx_dma_params, NULL);
295 if (s_i2c_env[p_params->id].dma_id[1] < 0) {
296 return APP_DRV_ERR_INVALID_PARAM;
297 }
298 s_i2c_env[p_params->id].handle.p_dmarx = app_dma_get_handle(s_i2c_env[p_params->id].dma_id[1]);
299 s_i2c_env[p_params->id].handle.p_dmarx->p_parent = (void*)&s_i2c_env[p_params->id].handle;
300
301 return APP_DRV_SUCCESS;
302 }
303
app_i2c_event_call(i2c_handle_t * p_i2c,app_i2c_evt_type_t evt_type)304 static void app_i2c_event_call(i2c_handle_t *p_i2c, app_i2c_evt_type_t evt_type)
305 {
306 app_i2c_evt_t i2c_evt;
307 app_i2c_id_t id;
308 if (p_i2c->p_instance == I2C0) {
309 id = APP_I2C_ID_0;
310 } else if (p_i2c->p_instance == I2C1) {
311 id = APP_I2C_ID_1;
312 }
313 i2c_evt.type = evt_type;
314 if (evt_type == APP_I2C_EVT_ERROR) {
315 #ifdef ENV_RTOS_USE_SEMP
316 app_driver_sem_post_from_isr(s_i2c_env[id].sem_tx);
317 app_driver_sem_post_from_isr(s_i2c_env[id].sem_rx);
318 #endif
319 i2c_evt.data.error_code = p_i2c->error_code;
320 } else if (evt_type == APP_I2C_EVT_TX_CPLT) {
321 #ifdef ENV_RTOS_USE_SEMP
322 app_driver_sem_post_from_isr(s_i2c_env[id].sem_tx);
323 #endif
324 i2c_evt.data.size = p_i2c->xfer_size - p_i2c->xfer_count;
325 } else if (evt_type == APP_I2C_EVT_RX_DATA) {
326 #ifdef ENV_RTOS_USE_SEMP
327 app_driver_sem_post_from_isr(s_i2c_env[id].sem_rx);
328 #endif
329 i2c_evt.data.size = p_i2c->xfer_size - p_i2c->xfer_count;
330 }
331
332 s_i2c_env[id].start_flag = false;
333 if (s_i2c_env[id].evt_handler != NULL) {
334 s_i2c_env[id].evt_handler(&i2c_evt);
335 }
336 }
337
params_check(app_i2c_params_t * p_params)338 static uint16_t params_check(app_i2c_params_t *p_params)
339 {
340 uint8_t id = p_params->id;
341
342 if (p_params == NULL) {
343 return APP_DRV_ERR_POINTER_NULL;
344 }
345
346 if (id >= APP_I2C_ID_MAX) {
347 return APP_DRV_ERR_INVALID_ID;
348 }
349
350 return APP_DRV_SUCCESS;
351 }
352
353 #ifdef ENV_RTOS_USE_SEMP
semp_init_config(uint8_t id)354 static uint16_t semp_init_config(uint8_t id)
355 {
356 app_drv_err_t app_err_code = APP_DRV_SUCCESS;
357
358 if (s_i2c_env[id].sem_tx == NULL) {
359 app_err_code = app_driver_sem_init(&s_i2c_env[id].sem_tx);
360 APP_DRV_ERR_CODE_CHECK(app_err_code);
361 }
362 if (s_i2c_env[id].sem_rx == NULL) {
363 app_err_code = app_driver_sem_init(&s_i2c_env[id].sem_rx);
364 APP_DRV_ERR_CODE_CHECK(app_err_code);
365 }
366
367 return APP_DRV_SUCCESS;
368 }
369 #endif
370
371 #ifdef ENV_RTOS_USE_MUTEX
mutex_init_config(uint8_t id)372 static uint16_t mutex_init_config(uint8_t id)
373 {
374 app_drv_err_t app_err_code = APP_DRV_SUCCESS;
375
376 if (s_i2c_env[id].mutex_async == NULL) {
377 app_err_code = app_driver_mutex_init(&s_i2c_env[id].mutex_async);
378 APP_DRV_ERR_CODE_CHECK(app_err_code);
379 }
380 if (s_i2c_env[id].mutex_sync == NULL) {
381 app_err_code = app_driver_mutex_init(&s_i2c_env[id].mutex_sync);
382 APP_DRV_ERR_CODE_CHECK(app_err_code);
383 }
384
385 return APP_DRV_SUCCESS;
386 }
387 #endif
388
sync_params_to_env(app_i2c_params_t * p_params,app_i2c_evt_handler_t evt_handler,uint8_t id)389 static void sync_params_to_env(app_i2c_params_t *p_params, app_i2c_evt_handler_t evt_handler, uint8_t id)
390 {
391 s_i2c_env[id].use_mode.type = p_params->use_mode.type;
392 s_i2c_env[id].use_mode.rx_dma_channel = p_params->use_mode.rx_dma_channel;
393 s_i2c_env[id].use_mode.tx_dma_channel = p_params->use_mode.tx_dma_channel;
394 s_i2c_env[id].role = p_params->role;
395 memcpy_s(&s_i2c_env[id].pin_cfg, sizeof (s_i2c_env[id].pin_cfg), &p_params->pin_cfg, sizeof(app_i2c_pin_cfg_t));
396 s_i2c_env[id].evt_handler = evt_handler;
397
398 memcpy_s(&s_i2c_env[id].handle.init, sizeof (s_i2c_env[id].handle.init), &p_params->init, sizeof(i2c_init_t));
399 s_i2c_env[id].handle.p_instance = (i2c_regs_t *)s_i2c_instance[id];
400 }
401
register_cb(void)402 static uint16_t register_cb(void)
403 {
404 if (s_sleep_cb_registered_flag == false) { // register sleep callback
405 s_sleep_cb_registered_flag = true;
406 s_i2c_pwr_id = pwr_register_sleep_cb(&i2c_sleep_cb, APP_DRIVER_I2C_WAPEUP_PRIORITY);
407 if (s_i2c_pwr_id < 0) {
408 return APP_DRV_ERR_INVALID_PARAM;
409 }
410 }
411
412 return APP_DRV_SUCCESS;
413 }
414
415 /*
416 * GLOBAL FUNCTION DEFINITIONS
417 ****************************************************************************************
418 */
app_i2c_init(app_i2c_params_t * p_params,app_i2c_evt_handler_t evt_handler)419 uint16_t app_i2c_init(app_i2c_params_t *p_params, app_i2c_evt_handler_t evt_handler)
420 {
421 uint8_t id = p_params->id;
422 app_drv_err_t app_err_code;
423 hal_status_t hal_err_code;
424
425 app_err_code = params_check(p_params);
426 APP_DRV_ERR_CODE_CHECK(app_err_code);
427
428 #ifdef ENV_RTOS_USE_SEMP
429 app_err_code = semp_init_config(id);
430 APP_DRV_ERR_CODE_CHECK(app_err_code);
431 #endif
432
433 #ifdef ENV_RTOS_USE_MUTEX
434 app_err_code = mutex_init_config(id);
435 APP_DRV_ERR_CODE_CHECK(app_err_code);
436 #endif
437
438 app_systick_init();
439
440 app_err_code = i2c_gpio_config(p_params->pin_cfg);
441 APP_DRV_ERR_CODE_CHECK(app_err_code);
442
443 if (p_params->use_mode.type == APP_I2C_TYPE_DMA) {
444 GLOBAL_EXCEPTION_DISABLE();
445 app_err_code = app_i2c_config_dma(p_params);
446 GLOBAL_EXCEPTION_ENABLE();
447 APP_DRV_ERR_CODE_CHECK(app_err_code);
448 }
449
450 if (p_params->use_mode.type != APP_I2C_TYPE_POLLING) {
451 hal_nvic_clear_pending_irq(s_i2c_irq[id]);
452 hal_nvic_enable_irq(s_i2c_irq[id]);
453 }
454
455 sync_params_to_env(p_params, evt_handler, id);
456
457 hal_err_code = hal_i2c_deinit(&s_i2c_env[id].handle);
458 HAL_ERR_CODE_CHECK(hal_err_code);
459
460 hal_err_code = hal_i2c_init(&s_i2c_env[id].handle);
461 HAL_ERR_CODE_CHECK(hal_err_code);
462
463 app_err_code = register_cb();
464 APP_DRV_ERR_CODE_CHECK(app_err_code);
465
466 s_i2c_env[id].i2c_state = APP_I2C_ACTIVITY;
467 s_i2c_env[id].start_flag = false;
468
469 return APP_DRV_SUCCESS;
470 }
471
app_i2c_deinit(app_i2c_id_t id)472 uint16_t app_i2c_deinit(app_i2c_id_t id)
473 {
474 app_drv_err_t app_err_code;
475 hal_status_t hal_err_code;
476
477 if ((id >= APP_I2C_ID_MAX) || (s_i2c_env[id].i2c_state == APP_I2C_INVALID)) {
478 return APP_DRV_ERR_INVALID_ID;
479 }
480
481 #ifdef ENV_RTOS_USE_SEMP
482 if (s_i2c_env[id].sem_tx != NULL) {
483 app_driver_sem_deinit(s_i2c_env[id].sem_tx);
484 s_i2c_env[id].sem_tx = NULL;
485 }
486 if (s_i2c_env[id].sem_rx != NULL) {
487 app_driver_sem_deinit(s_i2c_env[id].sem_rx);
488 s_i2c_env[id].sem_rx = NULL;
489 }
490 #endif
491
492 #ifdef ENV_RTOS_USE_MUTEX
493 if (s_i2c_env[id].mutex_sync != NULL) {
494 app_driver_mutex_deinit(s_i2c_env[id].mutex_sync);
495 s_i2c_env[id].mutex_sync = NULL;
496 }
497 if (s_i2c_env[id].mutex_async != NULL) {
498 app_driver_mutex_deinit(s_i2c_env[id].mutex_async);
499 s_i2c_env[id].mutex_async = NULL;
500 }
501 #endif
502
503 app_err_code = app_io_deinit(s_i2c_env[id].pin_cfg.scl.type, s_i2c_env[id].pin_cfg.scl.pin);
504 APP_DRV_ERR_CODE_CHECK(app_err_code);
505
506 app_err_code = app_io_deinit(s_i2c_env[id].pin_cfg.sda.type, s_i2c_env[id].pin_cfg.sda.pin);
507 APP_DRV_ERR_CODE_CHECK(app_err_code);
508
509 hal_nvic_disable_irq(s_i2c_irq[id]);
510 if (s_i2c_env[id].use_mode.type == APP_I2C_TYPE_DMA) {
511 app_dma_deinit(s_i2c_env[id].dma_id[0]);
512 app_dma_deinit(s_i2c_env[id].dma_id[1]);
513 }
514 s_i2c_env[id].i2c_state = APP_I2C_INVALID;
515 s_i2c_env[id].start_flag = false;
516
517 GLOBAL_EXCEPTION_DISABLE();
518 if (s_i2c_env[APP_I2C_ID_0].i2c_state == APP_I2C_INVALID &&
519 s_i2c_env[APP_I2C_ID_1].i2c_state == APP_I2C_INVALID) {
520 pwr_unregister_sleep_cb(s_i2c_pwr_id);
521 s_sleep_cb_registered_flag = false;
522 }
523 GLOBAL_EXCEPTION_ENABLE();
524
525 app_systick_deinit();
526
527 hal_err_code = hal_i2c_deinit(&s_i2c_env[id].handle);
528 HAL_ERR_CODE_CHECK(hal_err_code);
529
530 return APP_DRV_SUCCESS;
531 }
532
app_i2c_receive_sync(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size,uint32_t timeout)533 uint16_t app_i2c_receive_sync(app_i2c_id_t id, uint16_t target_address, \
534 uint8_t *p_data, uint16_t size, uint32_t timeout)
535 {
536 hal_status_t err_code = HAL_OK;
537
538 if (id >= APP_I2C_ID_MAX ||
539 p_data == NULL ||
540 size == 0 ||
541 s_i2c_env[id].i2c_state == APP_I2C_INVALID) {
542 return APP_DRV_ERR_INVALID_PARAM;
543 }
544
545 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
546 i2c_wake_up(id);
547 #endif
548
549 switch (s_i2c_env[id].role) {
550 case APP_I2C_ROLE_MASTER:
551 err_code = hal_i2c_master_receive(&s_i2c_env[id].handle, target_address, p_data, size, timeout);
552 break;
553
554 case APP_I2C_ROLE_SLAVE:
555 err_code = hal_i2c_slave_receive(&s_i2c_env[id].handle, p_data, size, timeout);
556 break;
557
558 default:
559 break;
560 }
561 if (err_code != HAL_OK) {
562 return (uint16_t)err_code;
563 }
564
565 return APP_DRV_SUCCESS;
566 }
567
568 #ifdef ENV_RTOS_USE_SEMP
sem_sync_params_check(app_i2c_id_t id,uint8_t * p_data,uint16_t size)569 static uint16_t sem_sync_params_check(app_i2c_id_t id, uint8_t *p_data, uint16_t size)
570 {
571 if (id >= APP_I2C_ID_MAX ||
572 p_data == NULL ||
573 size == 0 ||
574 s_i2c_env[id].i2c_state == APP_I2C_INVALID ||
575 s_i2c_env[id].use_mode.type == APP_I2C_TYPE_POLLING) {
576 #ifdef ENV_RTOS_USE_MUTEX
577 APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(id);
578 #endif
579 return APP_DRV_ERR_INVALID_PARAM;
580 }
581 return APP_DRV_SUCCESS;
582 }
583
master_or_slave_receive_process(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size)584 static hal_status_t master_or_slave_receive_process(app_i2c_id_t id, uint16_t target_address,
585 uint8_t *p_data, uint16_t size)
586 {
587 hal_status_t err_code = HAL_OK;
588
589 switch (s_i2c_env[id].role) {
590 case APP_I2C_ROLE_MASTER:
591 switch (s_i2c_env[id].use_mode.type) {
592 case APP_I2C_TYPE_INTERRUPT:
593 err_code = hal_i2c_master_receive_it(&s_i2c_env[id].handle, target_address, p_data, size);
594 break;
595
596 case APP_I2C_TYPE_DMA:
597 err_code = hal_i2c_master_receive_dma(&s_i2c_env[id].handle, target_address, p_data, size);
598 break;
599
600 default:
601 break;
602 }
603 break;
604
605 case APP_I2C_ROLE_SLAVE:
606 switch (s_i2c_env[id].use_mode.type) {
607 case APP_I2C_TYPE_INTERRUPT:
608 err_code = hal_i2c_slave_receive_it(&s_i2c_env[id].handle, p_data, size);
609 break;
610
611 case APP_I2C_TYPE_DMA:
612 err_code = hal_i2c_slave_receive_dma(&s_i2c_env[id].handle, p_data, size);
613 break;
614
615 default:
616 break;
617 }
618 break;
619
620 default:
621 break;
622 }
623 return err_code;
624 }
625 #endif
626
627 #ifdef ENV_RTOS_USE_SEMP
app_i2c_receive_sem_sync(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size)628 uint16_t app_i2c_receive_sem_sync(app_i2c_id_t id, uint16_t target_address, uint8_t *p_data, uint16_t size)
629 {
630 app_drv_err_t app_err_code;
631 hal_status_t err_code = HAL_OK;
632
633 #ifdef ENV_RTOS_USE_MUTEX
634 APP_I2C_DRV_ASYNC_MUTEX_LOCK(id);
635 #endif
636
637 app_err_code = sem_sync_params_check(id, p_data, size);
638 APP_DRV_ERR_CODE_CHECK(app_err_code);
639
640 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
641 i2c_wake_up(id);
642 #endif
643
644 if (s_i2c_env[id].start_flag == false) {
645 s_i2c_env[id].start_flag = true;
646 err_code = master_or_slave_receive_process(id, target_address, p_data, size);
647 if (err_code != HAL_OK) {
648 #ifdef ENV_RTOS_USE_MUTEX
649 APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(id);
650 #endif
651 s_i2c_env[id].start_flag = false;
652 return (uint16_t)err_code;
653 }
654 } else {
655 #ifdef ENV_RTOS_USE_MUTEX
656 APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(id);
657 #endif
658 return APP_DRV_ERR_BUSY;
659 }
660
661 app_driver_sem_pend(s_i2c_env[id].sem_rx, OS_WAIT_FOREVER);
662
663 #ifdef ENV_RTOS_USE_MUTEX
664 APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(id);
665 #endif
666
667 return APP_DRV_SUCCESS;
668 }
669 #endif
670
app_i2c_receive_async(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size)671 uint16_t app_i2c_receive_async(app_i2c_id_t id, uint16_t target_address, uint8_t *p_data, uint16_t size)
672 {
673 hal_status_t err_code = HAL_OK;
674
675 if (id >= APP_I2C_ID_MAX ||
676 p_data == NULL ||
677 size == 0 ||
678 s_i2c_env[id].i2c_state == APP_I2C_INVALID ||
679 s_i2c_env[id].use_mode.type == APP_I2C_TYPE_POLLING) {
680 return APP_DRV_ERR_INVALID_PARAM;
681 }
682
683 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
684 i2c_wake_up(id);
685 #endif
686
687 if (s_i2c_env[id].start_flag == false) {
688 s_i2c_env[id].start_flag = true;
689 switch (s_i2c_env[id].role) {
690 case APP_I2C_ROLE_MASTER:
691 switch (s_i2c_env[id].use_mode.type) {
692 case APP_I2C_TYPE_INTERRUPT:
693 err_code = hal_i2c_master_receive_it(&s_i2c_env[id].handle, target_address, p_data, size);
694 break;
695
696 case APP_I2C_TYPE_DMA:
697 err_code = hal_i2c_master_receive_dma(&s_i2c_env[id].handle, target_address, p_data, size);
698 break;
699
700 default:
701 break;
702 }
703 break;
704
705 case APP_I2C_ROLE_SLAVE:
706 switch (s_i2c_env[id].use_mode.type) {
707 case APP_I2C_TYPE_INTERRUPT:
708 err_code = hal_i2c_slave_receive_it(&s_i2c_env[id].handle, p_data, size);
709 break;
710
711 case APP_I2C_TYPE_DMA:
712 err_code = hal_i2c_slave_receive_dma(&s_i2c_env[id].handle, p_data, size);
713 break;
714
715 default:
716 break;
717 }
718 break;
719
720 default:
721 break;
722 }
723 if (err_code != HAL_OK) {
724 s_i2c_env[id].start_flag = false;
725 return (uint16_t)err_code;
726 }
727 } else {
728 return APP_DRV_ERR_BUSY;
729 }
730
731 return APP_DRV_SUCCESS;
732 }
733
app_i2c_transmit_sync(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size,uint32_t timeout)734 uint16_t app_i2c_transmit_sync(app_i2c_id_t id, uint16_t target_address, \
735 uint8_t *p_data, uint16_t size, uint32_t timeout)
736 {
737 hal_status_t err_code = HAL_OK;
738
739 if (id >= APP_I2C_ID_MAX ||
740 p_data == NULL ||
741 size == 0 ||
742 s_i2c_env[id].i2c_state == APP_I2C_INVALID) {
743 return APP_DRV_ERR_INVALID_PARAM;
744 }
745
746 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
747 i2c_wake_up(id);
748 #endif
749
750 switch (s_i2c_env[id].role) {
751 case APP_I2C_ROLE_MASTER:
752 err_code = hal_i2c_master_transmit(&s_i2c_env[id].handle, target_address, p_data, size, timeout);
753 break;
754
755 case APP_I2C_ROLE_SLAVE:
756 err_code = hal_i2c_slave_transmit(&s_i2c_env[id].handle, p_data, size, timeout);
757 break;
758
759 default:
760 break;
761 }
762
763 if (err_code != HAL_OK) {
764 return (uint16_t)err_code;
765 }
766
767 return APP_DRV_SUCCESS;
768 }
769
770 #ifdef ENV_RTOS_USE_SEMP
master_or_slave_transmit_process(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size)771 static hal_status_t master_or_slave_transmit_process(app_i2c_id_t id, uint16_t target_address,
772 uint8_t *p_data, uint16_t size)
773 {
774 hal_status_t err_code = HAL_OK;
775
776 switch (s_i2c_env[id].role) {
777 case APP_I2C_ROLE_MASTER:
778 switch (s_i2c_env[id].use_mode.type) {
779 case APP_I2C_TYPE_INTERRUPT:
780 err_code = hal_i2c_master_transmit_it(&s_i2c_env[id].handle, target_address, p_data, size);
781 break;
782
783 case APP_I2C_TYPE_DMA:
784 err_code = hal_i2c_master_transmit_dma(&s_i2c_env[id].handle, target_address, p_data, size);
785 break;
786
787 default:
788 break;
789 }
790 break;
791
792 case APP_I2C_ROLE_SLAVE:
793 switch (s_i2c_env[id].use_mode.type) {
794 case APP_I2C_TYPE_INTERRUPT:
795 err_code = hal_i2c_slave_transmit_it(&s_i2c_env[id].handle, p_data, size);
796 break;
797
798 case APP_I2C_TYPE_DMA:
799 err_code = hal_i2c_slave_transmit_dma(&s_i2c_env[id].handle, p_data, size);
800 break;
801
802 default:
803 break;
804 }
805 break;
806
807 default:
808 break;
809 }
810 return err_code;
811 }
812 #endif
813
814 #ifdef ENV_RTOS_USE_SEMP
app_i2c_transmit_sem_sync(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size)815 uint16_t app_i2c_transmit_sem_sync(app_i2c_id_t id, uint16_t target_address, uint8_t *p_data, uint16_t size)
816 {
817 hal_status_t err_code;
818
819 #ifdef ENV_RTOS_USE_MUTEX
820 APP_I2C_DRV_ASYNC_MUTEX_LOCK(id);
821 #endif
822
823 app_err_code = sem_sync_params_check(id, p_data, size);
824 APP_DRV_ERR_CODE_CHECK(app_err_code);
825
826 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
827 i2c_wake_up(id);
828 #endif
829
830 if (s_i2c_env[id].start_flag == false) {
831 s_i2c_env[id].start_flag = true;
832 err_code = master_or_slave_transmit_process(id, target_address, p_data, size);
833 if (err_code != HAL_OK) {
834 #ifdef ENV_RTOS_USE_MUTEX
835 APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(id);
836 #endif
837 s_i2c_env[id].start_flag = false;
838 return (uint16_t)err_code;
839 }
840 } else {
841 #ifdef ENV_RTOS_USE_MUTEX
842 APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(id);
843 #endif
844 return APP_DRV_ERR_BUSY;
845 }
846
847 app_driver_sem_pend(s_i2c_env[id].sem_tx, OS_WAIT_FOREVER);
848
849 #ifdef ENV_RTOS_USE_MUTEX
850 APP_I2C_DRV_ASYNC_MUTEX_UNLOCK(id);
851 #endif
852 return APP_DRV_SUCCESS;
853 }
854 #endif
855
app_i2c_transmit_async(app_i2c_id_t id,uint16_t target_address,uint8_t * p_data,uint16_t size)856 uint16_t app_i2c_transmit_async(app_i2c_id_t id, uint16_t target_address, uint8_t *p_data, uint16_t size)
857 {
858 hal_status_t err_code = HAL_OK;
859
860 if (id >= APP_I2C_ID_MAX ||
861 p_data == NULL ||
862 size == 0 ||
863 s_i2c_env[id].i2c_state == APP_I2C_INVALID ||
864 s_i2c_env[id].use_mode.type == APP_I2C_TYPE_POLLING) {
865 return APP_DRV_ERR_INVALID_PARAM;
866 }
867
868 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
869 i2c_wake_up(id);
870 #endif
871
872 if (s_i2c_env[id].start_flag == false) {
873 s_i2c_env[id].start_flag = true;
874 switch (s_i2c_env[id].role) {
875 case APP_I2C_ROLE_MASTER:
876 switch (s_i2c_env[id].use_mode.type) {
877 case APP_I2C_TYPE_INTERRUPT:
878 err_code = hal_i2c_master_transmit_it(&s_i2c_env[id].handle, target_address, p_data, size);
879 break;
880
881 case APP_I2C_TYPE_DMA:
882 err_code = hal_i2c_master_transmit_dma(&s_i2c_env[id].handle, target_address, p_data, size);
883 break;
884
885 default:
886 break;
887 }
888 break;
889
890 case APP_I2C_ROLE_SLAVE:
891 switch (s_i2c_env[id].use_mode.type) {
892 case APP_I2C_TYPE_INTERRUPT:
893 err_code = hal_i2c_slave_transmit_it(&s_i2c_env[id].handle, p_data, size);
894 break;
895
896 case APP_I2C_TYPE_DMA:
897 err_code = hal_i2c_slave_transmit_dma(&s_i2c_env[id].handle, p_data, size);
898 break;
899
900 default:
901 break;
902 }
903 break;
904
905 default:
906 break;
907 }
908 if (err_code != HAL_OK) {
909 s_i2c_env[id].start_flag = false;
910 return (uint16_t)err_code;
911 }
912 } else {
913 return APP_DRV_ERR_BUSY;
914 }
915
916 return APP_DRV_SUCCESS;
917 }
918
919
app_i2c_mem_read_sync(app_i2c_id_t id,uint16_t dev_address,uint16_t mem_address,uint16_t mem_addr_size,uint8_t * p_data,uint16_t size,uint32_t timeout)920 uint16_t app_i2c_mem_read_sync(app_i2c_id_t id, uint16_t dev_address, \
921 uint16_t mem_address, uint16_t mem_addr_size, \
922 uint8_t *p_data, uint16_t size, uint32_t timeout)
923 {
924 hal_status_t err_code = HAL_OK;
925
926 if (id >= APP_I2C_ID_MAX ||
927 p_data == NULL ||
928 size == 0 ||
929 s_i2c_env[id].i2c_state == APP_I2C_INVALID) {
930 return APP_DRV_ERR_INVALID_PARAM;
931 }
932
933 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
934 i2c_wake_up(id);
935 #endif
936
937 err_code = hal_i2c_mem_read(&s_i2c_env[id].handle, dev_address, mem_address, mem_addr_size, p_data, size, timeout);
938 if (err_code != HAL_OK) {
939 return (uint16_t)err_code;
940 }
941
942 return APP_DRV_SUCCESS;
943 }
944
app_i2c_mem_read_async(app_i2c_id_t id,uint16_t dev_address,uint16_t mem_address,uint16_t mem_addr_size,uint8_t * p_data,uint16_t size)945 uint16_t app_i2c_mem_read_async(app_i2c_id_t id, uint16_t dev_address, \
946 uint16_t mem_address, uint16_t mem_addr_size, uint8_t *p_data, uint16_t size)
947 {
948 hal_status_t err_code = HAL_OK;
949
950 if (id >= APP_I2C_ID_MAX ||
951 p_data == NULL ||
952 size == 0 ||
953 s_i2c_env[id].i2c_state == APP_I2C_INVALID ||
954 s_i2c_env[id].use_mode.type == APP_I2C_TYPE_POLLING) {
955 return APP_DRV_ERR_INVALID_PARAM;
956 }
957
958 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
959 i2c_wake_up(id);
960 #endif
961
962 if (s_i2c_env[id].start_flag == false) {
963 s_i2c_env[id].start_flag = true;
964
965 switch (s_i2c_env[id].use_mode.type) {
966 case APP_I2C_TYPE_INTERRUPT:
967 err_code = hal_i2c_mem_read_it(&s_i2c_env[id].handle, dev_address, \
968 mem_address, mem_addr_size, p_data, size);
969 break;
970
971 case APP_I2C_TYPE_DMA:
972 err_code = hal_i2c_mem_read_dma(&s_i2c_env[id].handle, dev_address, \
973 mem_address, mem_addr_size, p_data, size);
974 break;
975
976 default:
977 break;
978 }
979 if (err_code != HAL_OK) {
980 s_i2c_env[id].start_flag = false;
981 return (uint16_t)err_code;
982 }
983 } else {
984 return APP_DRV_ERR_BUSY;
985 }
986
987 return APP_DRV_SUCCESS;
988 }
989
app_i2c_mem_write_sync(app_i2c_id_t id,uint16_t dev_address,uint16_t mem_address,uint16_t mem_addr_size,uint8_t * p_data,uint16_t size,uint32_t timeout)990 uint16_t app_i2c_mem_write_sync(app_i2c_id_t id, uint16_t dev_address, \
991 uint16_t mem_address, uint16_t mem_addr_size, \
992 uint8_t *p_data, uint16_t size, uint32_t timeout)
993 {
994 hal_status_t err_code = HAL_OK;
995
996 if (id >= APP_I2C_ID_MAX ||
997 p_data == NULL ||
998 size == 0 ||
999 s_i2c_env[id].i2c_state == APP_I2C_INVALID) {
1000 return APP_DRV_ERR_INVALID_PARAM;
1001 }
1002
1003 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
1004 i2c_wake_up(id);
1005 #endif
1006
1007 err_code = hal_i2c_mem_write(&s_i2c_env[id].handle, dev_address, mem_address, mem_addr_size, p_data, size, timeout);
1008 if (err_code != HAL_OK) {
1009 return (uint16_t)err_code;
1010 }
1011
1012 return APP_DRV_SUCCESS;
1013 }
1014
app_i2c_mem_write_async(app_i2c_id_t id,uint16_t dev_address,uint16_t mem_address,uint16_t mem_addr_size,uint8_t * p_data,uint16_t size)1015 uint16_t app_i2c_mem_write_async(app_i2c_id_t id, uint16_t dev_address, \
1016 uint16_t mem_address, uint16_t mem_addr_size, \
1017 uint8_t *p_data, uint16_t size)
1018 {
1019 hal_status_t err_code = HAL_OK;
1020
1021 if (id >= APP_I2C_ID_MAX ||
1022 p_data == NULL ||
1023 size == 0 ||
1024 s_i2c_env[id].i2c_state == APP_I2C_INVALID ||
1025 s_i2c_env[id].use_mode.type == APP_I2C_TYPE_POLLING) {
1026 return APP_DRV_ERR_INVALID_PARAM;
1027 }
1028
1029 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
1030 i2c_wake_up(id);
1031 #endif
1032
1033 if (s_i2c_env[id].start_flag == false) {
1034 s_i2c_env[id].start_flag = true;
1035
1036 switch (s_i2c_env[id].use_mode.type) {
1037 case APP_I2C_TYPE_INTERRUPT:
1038 err_code = hal_i2c_mem_write_it(&s_i2c_env[id].handle, dev_address, \
1039 mem_address, mem_addr_size, p_data, size);
1040 break;
1041
1042 case APP_I2C_TYPE_DMA:
1043 err_code = hal_i2c_mem_write_dma(&s_i2c_env[id].handle, dev_address, \
1044 mem_address, mem_addr_size, p_data, size);
1045 break;
1046
1047 default:
1048 break;
1049 }
1050 if (err_code != HAL_OK) {
1051 s_i2c_env[id].start_flag = false;
1052 return (uint16_t)err_code;
1053 }
1054 } else {
1055 return APP_DRV_ERR_BUSY;
1056 }
1057
1058 return APP_DRV_SUCCESS;
1059 }
1060
app_i2c_get_handle(app_i2c_id_t id)1061 i2c_handle_t *app_i2c_get_handle(app_i2c_id_t id)
1062 {
1063 if (id >= APP_I2C_ID_MAX ||
1064 s_i2c_env[id].i2c_state == APP_I2C_INVALID) {
1065 return NULL;
1066 }
1067
1068 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
1069 i2c_wake_up(id);
1070 #endif
1071
1072 return &s_i2c_env[id].handle;
1073 }
1074
hal_i2c_master_tx_cplt_callback(i2c_handle_t * p_i2c)1075 void hal_i2c_master_tx_cplt_callback(i2c_handle_t *p_i2c)
1076 {
1077 app_i2c_event_call(p_i2c, APP_I2C_EVT_TX_CPLT);
1078 }
1079
hal_i2c_master_rx_cplt_callback(i2c_handle_t * p_i2c)1080 void hal_i2c_master_rx_cplt_callback(i2c_handle_t *p_i2c)
1081 {
1082 app_i2c_event_call(p_i2c, APP_I2C_EVT_RX_DATA);
1083 }
1084
hal_i2c_slave_tx_cplt_callback(i2c_handle_t * p_i2c)1085 void hal_i2c_slave_tx_cplt_callback(i2c_handle_t *p_i2c)
1086 {
1087 app_i2c_event_call(p_i2c, APP_I2C_EVT_TX_CPLT);
1088 }
1089
hal_i2c_slave_rx_cplt_callback(i2c_handle_t * p_i2c)1090 void hal_i2c_slave_rx_cplt_callback(i2c_handle_t *p_i2c)
1091 {
1092 app_i2c_event_call(p_i2c, APP_I2C_EVT_RX_DATA);
1093 }
1094
hal_i2c_mem_tx_cplt_callback(i2c_handle_t * p_i2c)1095 void hal_i2c_mem_tx_cplt_callback(i2c_handle_t *p_i2c)
1096 {
1097 app_i2c_event_call(p_i2c, APP_I2C_EVT_TX_CPLT);
1098 }
1099
hal_i2c_mem_rx_cplt_callback(i2c_handle_t * p_i2c)1100 void hal_i2c_mem_rx_cplt_callback(i2c_handle_t *p_i2c)
1101 {
1102 app_i2c_event_call(p_i2c, APP_I2C_EVT_RX_DATA);
1103 }
1104
hal_i2c_error_callback(i2c_handle_t * p_i2c)1105 void hal_i2c_error_callback(i2c_handle_t *p_i2c)
1106 {
1107 app_i2c_event_call(p_i2c, APP_I2C_EVT_ERROR);
1108 }
1109
I2C0_IRQHandler(void)1110 SECTION_RAM_CODE void I2C0_IRQHandler(void)
1111 {
1112 #if FLASH_PROTECT_PRIORITY
1113 platform_interrupt_protection_push();
1114 #endif
1115 hal_i2c_irq_handler(&s_i2c_env[APP_I2C_ID_0].handle);
1116 #if FLASH_PROTECT_PRIORITY
1117 platform_interrupt_protection_pop();
1118 #endif
1119 }
1120
I2C1_IRQHandler(void)1121 SECTION_RAM_CODE void I2C1_IRQHandler(void)
1122 {
1123 #if FLASH_PROTECT_PRIORITY
1124 platform_interrupt_protection_push();
1125 #endif
1126 hal_i2c_irq_handler(&s_i2c_env[APP_I2C_ID_1].handle);
1127 #if FLASH_PROTECT_PRIORITY
1128 platform_interrupt_protection_pop();
1129 #endif
1130 }
1131
1132 #endif
1133