1 /*
2 * Copyright (c) 2006-2022, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2011-01-06 onelife Initial creation for EFM32
9 * 2011-06-17 onelife Modify init function for EFM32 library v2.0.0 upgrading
10 * 2011-07-11 onelife Add lock (semaphore) to prevent simultaneously access
11 * 2011-08-04 onelife Change the usage of the second parameter of Read
12 * and Write functions from (seldom used) "Offset" to "Slave address"
13 * 2011-08-04 onelife Add a timer to prevent from forever waiting
14 * 2011-11-29 onelife Modify init function for EFM32 library v2.2.2 upgrading
15 * 2011-12-27 onelife Utilize "I2C_PRESENT" and "I2C_COUNT"
16 * 2011-12-27 onelife Change IIC read format
17 */
18
19 /***************************************************************************//**
20 * @addtogroup efm32
21 * @{
22 ******************************************************************************/
23
24 /* Includes ------------------------------------------------------------------*/
25 #include "board.h"
26 #include "hdl_interrupt.h"
27 #include "drv_iic.h"
28
29 #if (defined(RT_USING_IIC0) || defined(RT_USING_IIC1))
30 #if !defined(I2C_PRESENT)
31 #error "IIC module is not available"
32 #endif
33 /* Private typedef -----------------------------------------------------------*/
34 struct efm32_iic_block
35 {
36 struct rt_device device;
37 struct rt_semaphore lock;
38 struct rt_timer timer;
39 };
40
41 /* Private define ------------------------------------------------------------*/
42 /* Private macro -------------------------------------------------------------*/
43 #ifdef RT_IIC_DEBUG
44 #define iic_debug(format,args...) rt_kprintf(format, ##args)
45 #else
46 #define iic_debug(format,args...)
47 #endif
48
49 /* Private variables ---------------------------------------------------------*/
50 #ifdef RT_USING_IIC0
51 #if (RT_USING_IIC0 > EFM32_IIC_LOCATION_COUNT)
52 #error "Wrong location number"
53 #endif
54 static struct efm32_iic_block iic0;
55 #endif
56
57 #ifdef RT_USING_IIC1
58 #if (I2C_COUNT <= 1)
59 #error "Wrong unit number"
60 #endif
61 #if (RT_USING_IIC1 > EFM32_IIC_LOCATION_COUNT)
62 #error "Wrong location number"
63 #endif
64 static struct efm32_iic_block iic1;
65 #endif
66
67 /* Private function prototypes -----------------------------------------------*/
68 /* Private functions ---------------------------------------------------------*/
69 /***************************************************************************//**
70 * @brief
71 * Initialize IIC device
72 *
73 * @details
74 *
75 * @note
76 *
77 * @param[in] dev
78 * Pointer to device descriptor
79 *
80 * @return
81 * Error code
82 ******************************************************************************/
rt_iic_init(rt_device_t dev)83 static rt_err_t rt_iic_init (rt_device_t dev)
84 {
85 struct efm32_iic_device_t* iic;
86
87 iic = (struct efm32_iic_device_t*)dev->user_data;
88
89 if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
90 {
91 /* Enable IIC */
92 I2C_Enable(iic->iic_device, true);
93 iic->rx_buffer = RT_NULL;
94 iic->state = 0;
95
96 dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
97 }
98
99 return RT_EOK;
100 }
101
102 /***************************************************************************//**
103 * @brief
104 * Open IIC device
105 *
106 * @details
107 *
108 * @note
109 *
110 * @param[in] dev
111 * Pointer to device descriptor
112 *
113 * @param[in] oflag
114 * Device open flag
115 *
116 * @return
117 * Error code
118 ******************************************************************************/
rt_iic_open(rt_device_t dev,rt_uint16_t oflag)119 static rt_err_t rt_iic_open(rt_device_t dev, rt_uint16_t oflag)
120 {
121 RT_ASSERT(dev != RT_NULL);
122
123 struct efm32_iic_device_t *iic;
124
125 iic = (struct efm32_iic_device_t *)(dev->user_data);
126 iic->counter++;
127
128 iic_debug("IIC: Open with flag %x\n", oflag);
129 return RT_EOK;
130 }
131
132 /***************************************************************************//**
133 * @brief
134 * Close IIC device
135 *
136 * @details
137 *
138 * @note
139 *
140 * @param[in] dev
141 * Pointer to device descriptor
142 *
143 * @return
144 * Error code
145 ******************************************************************************/
rt_iic_close(rt_device_t dev)146 static rt_err_t rt_iic_close(rt_device_t dev)
147 {
148 RT_ASSERT(dev != RT_NULL);
149
150 struct efm32_iic_device_t *iic;
151
152 iic = (struct efm32_iic_device_t *)(dev->user_data);
153 if (--iic->counter == 0)
154 {
155 rt_free(iic->rx_buffer->data_ptr);
156 rt_free(iic->rx_buffer);
157 iic->rx_buffer = RT_NULL;
158 }
159 return RT_EOK;
160 }
161
162 /***************************************************************************//**
163 * @brief
164 * Read from IIC device
165 *
166 * @details
167 *
168 * @note
169 *
170 * @param[in] dev
171 * Pointer to device descriptor
172 *
173 * @param[in] pos
174 * Slave address
175 *
176 * @param[in] buffer
177 * Poniter to the buffer
178 *
179 * @param[in] size
180 * Buffer size in byte
181 *
182 * @return
183 * Error code
184 ******************************************************************************/
rt_iic_read(rt_device_t dev,rt_off_t pos,void * buffer,rt_size_t size)185 static rt_ssize_t rt_iic_read (
186 rt_device_t dev,
187 rt_off_t pos,
188 void* buffer,
189 rt_size_t size)
190 {
191 rt_err_t err_code;
192 rt_size_t read_size;
193 struct efm32_iic_device_t* iic;
194 I2C_TransferSeq_TypeDef seq;
195 I2C_TransferReturn_TypeDef ret;
196
197 if (!size)
198 {
199 return 0;
200 }
201
202 err_code = RT_EOK;
203 read_size = 0;
204 iic = (struct efm32_iic_device_t*)dev->user_data;
205
206 /* Lock device */
207 if (rt_hw_interrupt_check())
208 {
209 ret = rt_sem_take(iic->lock, RT_WAITING_NO);
210 }
211 else
212 {
213 ret = rt_sem_take(iic->lock, RT_WAITING_FOREVER);
214 }
215 if (ret != RT_EOK)
216 {
217 return ret;
218 }
219
220 if (iic->state & IIC_STATE_MASTER)
221 {
222 seq.addr = (rt_uint16_t)pos << 1;
223 if (*(rt_uint8_t *)buffer == IIC_OP_READ_ONLY)
224 {
225 seq.flags = I2C_FLAG_READ;
226 /* Set read buffer pointer and size */
227 seq.buf[0].data = (rt_uint8_t *)buffer;
228 seq.buf[0].len = size;
229 }
230 else
231 {
232 seq.flags = I2C_FLAG_WRITE_READ;
233 /* Set register to be read */
234 seq.buf[0].data = (rt_uint8_t *)buffer;
235 seq.buf[0].len = 1;
236 /* Set read buffer pointer and size */
237 seq.buf[1].data = (rt_uint8_t *)buffer;
238 seq.buf[1].len = size;
239 }
240
241 /* Do a polled transfer */
242 iic->timeout = false;
243 rt_timer_stop(iic->timer);
244 rt_timer_start(iic->timer);
245 ret = I2C_TransferInit(iic->iic_device, &seq);
246 while ((ret == i2cTransferInProgress) && !iic->timeout)
247 {
248 ret = I2C_Transfer(iic->iic_device);
249 }
250
251 if (ret != i2cTransferDone)
252 {
253 iic_debug("IIC: read error %x\n", ret);
254 iic_debug("IIC: read address %x\n", seq.addr);
255 iic_debug("IIC: read data0 %x -> %x\n", seq.buf[0].data, *seq.buf[0].data);
256 iic_debug("IIC: read len0 %x\n", seq.buf[0].len);
257 iic_debug("IIC: read data1 %x -> %x\n", seq.buf[1].data, *seq.buf[1].data);
258 iic_debug("IIC: read len1 %x\n", seq.buf[1].len);
259 err_code = (rt_err_t)ret;
260 }
261 else
262 {
263 read_size = size;
264 iic_debug("IIC: read size %d\n", read_size);
265 }
266 }
267 else
268 {
269 rt_uint8_t* ptr;
270
271 ptr = buffer;
272
273 /* interrupt mode Rx */
274 while (size)
275 {
276 rt_base_t level;
277 struct efm32_iic_int_mode_t *int_rx;
278
279 int_rx = iic->rx_buffer;
280
281 /* disable interrupt */
282 level = rt_hw_interrupt_disable();
283
284 if (int_rx->read_index != int_rx->save_index)
285 {
286 /* read a character */
287 *ptr++ = int_rx->data_ptr[int_rx->read_index];
288 size--;
289
290 /* move to next position */
291 int_rx->read_index ++;
292 if (int_rx->read_index >= IIC_RX_BUFFER_SIZE)
293 {
294 int_rx->read_index = 0;
295 }
296 }
297 else
298 {
299 /* set error code */
300 err_code = -RT_EEMPTY;
301
302 /* enable interrupt */
303 rt_hw_interrupt_enable(level);
304 break;
305 }
306
307 /* enable interrupt */
308 rt_hw_interrupt_enable(level);
309 }
310
311 read_size = (rt_uint32_t)ptr - (rt_uint32_t)buffer;
312 iic_debug("IIC: slave read size %d\n", read_size);
313 }
314
315 /* Unlock device */
316 rt_sem_release(iic->lock);
317
318 /* set error code */
319 rt_set_errno(err_code);
320 return read_size;
321 }
322
323 /***************************************************************************//**
324 * @brief
325 * Write to IIC device
326 *
327 * @details
328 *
329 * @note
330 *
331 * @param[in] dev
332 * Pointer to device descriptor
333 *
334 * @param[in] pos
335 * Slave address
336 *
337 * @param[in] buffer
338 * Poniter to the buffer
339 *
340 * @param[in] size
341 * Buffer size in byte
342 *
343 * @return
344 * Error code
345 ******************************************************************************/
rt_iic_write(rt_device_t dev,rt_off_t pos,const void * buffer,rt_size_t size)346 static rt_ssize_t rt_iic_write (
347 rt_device_t dev,
348 rt_off_t pos,
349 const void* buffer,
350 rt_size_t size)
351 {
352 rt_err_t err_code;
353 rt_size_t write_size;
354 struct efm32_iic_device_t* iic;
355 I2C_TransferSeq_TypeDef seq;
356 I2C_TransferReturn_TypeDef ret;
357
358 if (!size)
359 {
360 return 0;
361 }
362
363 err_code = RT_EOK;
364 write_size = 0;
365 iic = (struct efm32_iic_device_t*)dev->user_data;
366
367 /* Lock device */
368 if (rt_hw_interrupt_check())
369 {
370 ret = rt_sem_take(iic->lock, RT_WAITING_NO);
371 }
372 else
373 {
374 ret = rt_sem_take(iic->lock, RT_WAITING_FOREVER);
375 }
376 if (ret != RT_EOK)
377 {
378 return ret;
379 }
380
381 if (iic->state & IIC_STATE_MASTER)
382 {
383 seq.addr = (rt_uint16_t)pos << 1;
384 seq.flags = I2C_FLAG_WRITE;
385 /* Set write buffer pointer and size */
386 seq.buf[0].data = (rt_uint8_t *)buffer;
387 seq.buf[0].len = size;
388 }
389 else
390 {
391 // TODO: Slave mode TX
392 }
393
394 /* Do a polled transfer */
395 iic->timeout = false;
396 rt_timer_stop(iic->timer);
397 rt_timer_start(iic->timer);
398 ret = I2C_TransferInit(iic->iic_device, &seq);
399 while ((ret == i2cTransferInProgress) && !iic->timeout)
400 {
401 ret = I2C_Transfer(iic->iic_device);
402 }
403
404 if (ret != i2cTransferDone)
405 {
406 err_code = (rt_err_t)ret;
407 }
408 else
409 {
410 write_size = size;
411 }
412
413 /* Unlock device */
414 rt_sem_release(iic->lock);
415
416 /* set error code */
417 rt_set_errno(err_code);
418 return write_size;
419 }
420
421 /***************************************************************************//**
422 * @brief
423 * Configure IIC device
424 *
425 * @details
426 *
427 * @note
428 *
429 * @param[in] dev
430 * Pointer to device descriptor
431 *
432 * @param[in] cmd
433 * IIC control command
434 *
435 * @param[in] args
436 * Arguments
437 *
438 * @return
439 * Error code
440 ******************************************************************************/
rt_iic_control(rt_device_t dev,rt_uint8_t cmd,void * args)441 static rt_err_t rt_iic_control (
442 rt_device_t dev,
443 rt_uint8_t cmd,
444 void *args)
445 {
446 RT_ASSERT(dev != RT_NULL);
447
448 rt_err_t ret;
449 struct efm32_iic_device_t *iic;
450
451 iic = (struct efm32_iic_device_t*)dev->user_data;
452
453 /* Lock device */
454 if (rt_hw_interrupt_check())
455 {
456 ret = rt_sem_take(iic->lock, RT_WAITING_NO);
457 }
458 else
459 {
460 ret = rt_sem_take(iic->lock, RT_WAITING_FOREVER);
461 }
462 if (ret != RT_EOK)
463 {
464 return ret;
465 }
466
467 switch (cmd)
468 {
469 case RT_DEVICE_CTRL_SUSPEND:
470 /* suspend device */
471 dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
472 I2C_Enable(iic->iic_device, false);
473 break;
474
475 case RT_DEVICE_CTRL_RESUME:
476 /* resume device */
477 dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
478 I2C_Enable(iic->iic_device, true);
479 break;
480
481 case RT_DEVICE_CTRL_IIC_SETTING:
482 {
483 /* change device setting */
484 struct efm32_iic_control_t *control;
485
486 control = (struct efm32_iic_control_t *)args;
487 iic->state = control->config & (IIC_STATE_MASTER | IIC_STATE_BROADCAST);
488 iic->address = control->address << 1;
489
490 if (!(iic->state & IIC_STATE_MASTER))
491 {
492 if (iic->rx_buffer == RT_NULL)
493 {
494 iic->rx_buffer = rt_malloc(sizeof(struct efm32_iic_int_mode_t));
495 if (iic->rx_buffer == RT_NULL)
496 {
497 iic_debug("IIC err: no MEM for IIC RX structure\n");
498 return -RT_ENOMEM;
499 }
500
501 /* Allocate RX buffer */
502 if ((iic->rx_buffer->data_ptr = \
503 rt_malloc(IIC_RX_BUFFER_SIZE)) == RT_NULL)
504 {
505 iic_debug("IIC err: no MEM for IIC RX buffer\n");
506 rt_free(iic->rx_buffer);
507 return -RT_ENOMEM;
508 }
509 rt_memset(iic->rx_buffer->data_ptr, 0, IIC_RX_BUFFER_SIZE);
510 iic->rx_buffer->data_size = IIC_RX_BUFFER_SIZE;
511 iic->rx_buffer->read_index = 0;
512 iic->rx_buffer->save_index = 0;
513 }
514
515 /* Enable slave mode */
516 I2C_SlaveAddressSet(iic->iic_device, iic->address);
517 I2C_SlaveAddressMaskSet(iic->iic_device, 0xFF);
518 iic->iic_device->CTRL |= I2C_CTRL_SLAVE | I2C_CTRL_AUTOACK | I2C_CTRL_AUTOSN;
519
520 /* Enable interrupts */
521 I2C_IntEnable(iic->iic_device, I2C_IEN_ADDR | I2C_IEN_RXDATAV | I2C_IEN_SSTOP);
522 I2C_IntClear(iic->iic_device, _I2C_IFC_MASK);
523
524 /* Enable I2Cn interrupt vector in NVIC */
525 if (dev == &iic0.device)
526 {
527 NVIC_ClearPendingIRQ(I2C0_IRQn);
528 NVIC_SetPriority(I2C0_IRQn, EFM32_IRQ_PRI_DEFAULT);
529 NVIC_EnableIRQ(I2C0_IRQn);
530 }
531 #if (I2C_COUNT > 1)
532 if (dev == &iic1.device)
533 {
534 NVIC_ClearPendingIRQ(I2C1_IRQn);
535 NVIC_SetPriority(I2C1_IRQn, EFM32_IRQ_PRI_DEFAULT);
536 NVIC_EnableIRQ(I2C1_IRQn);
537 }
538 #endif
539 }
540 }
541 break;
542 }
543
544 /* Unlock device */
545 rt_sem_release(iic->lock);
546
547 return RT_EOK;
548 }
549
550 /***************************************************************************//**
551 * @brief
552 * IIC timeout interrupt handler
553 *
554 * @details
555 *
556 * @note
557 *
558 * @param[in] parameter
559 * Parameter
560 ******************************************************************************/
rt_iic_timer(void * timeout)561 static void rt_iic_timer(void *timeout)
562 {
563 *(rt_bool_t *)timeout = true;
564 }
565
566 /***************************************************************************//**
567 * @brief
568 * Register IIC device
569 *
570 * @details
571 *
572 * @note
573 *
574 * @param[in] device
575 * Pointer to device descriptor
576 *
577 * @param[in] name
578 * Device name
579 *
580 * @param[in] flag
581 * Configuration flags
582 *
583 * @param[in] iic
584 * Pointer to IIC device descriptor
585 *
586 * @return
587 * Error code
588 ******************************************************************************/
rt_hw_iic_register(rt_device_t device,const char * name,rt_uint32_t flag,struct efm32_iic_device_t * iic)589 rt_err_t rt_hw_iic_register(
590 rt_device_t device,
591 const char *name,
592 rt_uint32_t flag,
593 struct efm32_iic_device_t *iic)
594 {
595 RT_ASSERT(device != RT_NULL);
596
597 if ((flag & RT_DEVICE_FLAG_DMA_TX) || (flag & RT_DEVICE_FLAG_DMA_RX) ||
598 (flag & RT_DEVICE_FLAG_INT_TX))
599 {
600 RT_ASSERT(0);
601 }
602
603 device->type = RT_Device_Class_Unknown;
604 device->rx_indicate = RT_NULL;
605 device->tx_complete = RT_NULL;
606 device->init = rt_iic_init;
607 device->open = rt_iic_open;
608 device->close = rt_iic_close;
609 device->read = rt_iic_read;
610 device->write = rt_iic_write;
611 device->control = rt_iic_control;
612 device->user_data = iic;
613
614 /* register a character device */
615 return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
616 }
617
618 /***************************************************************************//**
619 * @brief
620 * IIC slave mode RX data valid interrupt handler
621 *
622 * @details
623 *
624 * @note
625 *
626 * @param[in] dev
627 * Pointer to device descriptor
628 ******************************************************************************/
rt_hw_iic_slave_isr(rt_device_t dev)629 static void rt_hw_iic_slave_isr(rt_device_t dev)
630 {
631 struct efm32_iic_device_t *iic;
632 struct efm32_iic_int_mode_t *int_rx;
633 rt_uint32_t status;
634 volatile rt_uint32_t temp;
635
636 /* interrupt mode receive */
637 RT_ASSERT(dev->flag & RT_DEVICE_FLAG_INT_RX);
638
639 iic = (struct efm32_iic_device_t*)dev->user_data;
640 int_rx = iic->rx_buffer;
641 status = iic->iic_device->IF;
642
643 if (status & I2C_IF_ADDR)
644 {
645 /* Address Match */
646 /* Indicating that reception is started */
647 temp = iic->iic_device->RXDATA & 0xFFUL;
648 if ((temp != 0x00) || (iic->state & IIC_STATE_BROADCAST))
649 {
650 iic->state |= IIC_STATE_RX_BUSY;
651 }
652 }
653 else if (status & I2C_IF_RXDATAV)
654 {
655 if (iic->state & IIC_STATE_RX_BUSY)
656 {
657 rt_base_t level;
658
659 /* disable interrupt */
660 level = rt_hw_interrupt_disable();
661
662 /* save character */
663 int_rx->data_ptr[int_rx->save_index] = \
664 (rt_uint8_t)(iic->iic_device->RXDATA & 0xFFUL);
665 int_rx->save_index ++;
666 if (int_rx->save_index >= IIC_RX_BUFFER_SIZE)
667 int_rx->save_index = 0;
668
669 /* if the next position is read index, discard this 'read char' */
670 if (int_rx->save_index == int_rx->read_index)
671 {
672 int_rx->read_index ++;
673 if (int_rx->read_index >= IIC_RX_BUFFER_SIZE)
674 {
675 int_rx->read_index = 0;
676 }
677 }
678
679 /* enable interrupt */
680 rt_hw_interrupt_enable(level);
681 }
682 else
683 {
684 temp = iic->iic_device->RXDATA;
685 }
686 }
687
688 if(status & I2C_IF_SSTOP)
689 {
690 /* Stop received, reception is ended */
691 iic->state &= ~(rt_uint8_t)IIC_STATE_RX_BUSY;
692 }
693 }
694
695 /***************************************************************************//**
696 * @brief
697 * Initialize the specified IIC unit
698 *
699 * @details
700 *
701 * @note
702 *
703 * @param[in] unitNumber
704 * Unit number
705 *
706 * @param[in] location
707 * Pin location number
708 ******************************************************************************/
rt_hw_iic_unit_init(struct efm32_iic_block * block,rt_uint8_t unitNumber,rt_uint8_t location)709 static struct efm32_iic_device_t *rt_hw_iic_unit_init(
710 struct efm32_iic_block *block,
711 rt_uint8_t unitNumber,
712 rt_uint8_t location)
713 {
714 struct efm32_iic_device_t *iic;
715 CMU_Clock_TypeDef iicClock;
716 GPIO_Port_TypeDef port_scl, port_sda;
717 rt_uint32_t pin_scl, pin_sda;
718 I2C_Init_TypeDef init = I2C_INIT_DEFAULT;
719 efm32_irq_hook_init_t hook;
720 rt_uint8_t name[RT_NAME_MAX];
721
722 do
723 {
724 /* Allocate device */
725 iic = rt_malloc(sizeof(struct efm32_iic_device_t));
726 if (iic == RT_NULL)
727 {
728 iic_debug("IIC err: no MEM for IIC%d driver\n", unitNumber);
729 break;
730 }
731 iic->counter = 0;
732 iic->timer = &block->timer;
733 iic->timeout = false;
734 iic->state |= IIC_STATE_MASTER;
735 iic->address = 0x0000;
736 iic->rx_buffer = RT_NULL;
737
738 /* Initialization */
739 if (unitNumber >= I2C_COUNT)
740 {
741 break;
742 }
743 switch (unitNumber)
744 {
745 case 0:
746 iic->iic_device = I2C0;
747 iicClock = (CMU_Clock_TypeDef)cmuClock_I2C0;
748 port_scl = AF_I2C0_SCL_PORT(location);
749 pin_scl = AF_I2C0_SCL_PIN(location);
750 port_sda = AF_I2C0_SDA_PORT(location);
751 pin_sda = AF_I2C0_SDA_PIN(location);
752 break;
753 #if (I2C_COUNT > 1)
754 case 1:
755 iic->iic_device = I2C1;
756 iicClock = (CMU_Clock_TypeDef)cmuClock_I2C1;
757 port_scl = AF_I2C1_SCL_PORT(location);
758 pin_scl = AF_I2C1_SCL_PIN(location);
759 port_sda = AF_I2C1_SDA_PORT(location);
760 pin_sda = AF_I2C1_SDA_PIN(location);
761 break;
762 #endif
763 default:
764 break;
765 }
766 rt_sprintf(name, "iic%d", unitNumber);
767
768 /* Enabling clock */
769 CMU_ClockEnable(iicClock, true);
770
771 /* Reset */
772 I2C_Reset(iic->iic_device);
773
774 /* Config GPIO */
775 GPIO_PinModeSet(
776 port_scl,
777 pin_scl,
778 gpioModeWiredAndPullUpFilter,
779 1);
780 GPIO_PinModeSet(
781 port_sda,
782 pin_sda,
783 gpioModeWiredAndPullUpFilter,
784 1);
785
786 hook.type = efm32_irq_type_iic;
787 hook.unit = unitNumber;
788 hook.cbFunc = rt_hw_iic_slave_isr;
789 hook.userPtr = (void *)&block->device;
790 efm32_irq_hook_register(&hook);
791
792 /* Enable SDZ and SCL pins and set location */
793 iic->iic_device->ROUTE = I2C_ROUTE_SDAPEN | I2C_ROUTE_SCLPEN | \
794 (location << _I2C_ROUTE_LOCATION_SHIFT);
795
796 /* Initializing IIC */
797 init.enable = false;
798 I2C_Init(iic->iic_device, &init);
799
800 /* Abort current TX data and clear TX buffers */
801 iic->iic_device->CMD = I2C_CMD_ABORT | I2C_CMD_CLEARPC | I2C_CMD_CLEARTX;
802
803 /* Initialize lock */
804 iic->lock = &block->lock;
805 if (rt_sem_init(iic->lock, name, 1, RT_IPC_FLAG_FIFO) != RT_EOK)
806 {
807 break;
808 }
809
810 /* Initialize timer */
811 rt_timer_init(iic->timer, name, rt_iic_timer, &iic->timeout,
812 IIC_TIMEOUT_PERIOD, RT_TIMER_FLAG_ONE_SHOT);
813
814 return iic;
815 } while(0);
816
817 if (iic)
818 {
819 rt_free(iic);
820 }
821
822 iic_debug("IIC err: Unit %d init failed!\n", unitNumber);
823 return RT_NULL;
824 }
825
826 /***************************************************************************//**
827 * @brief
828 * Initialize all IIC module related hardware and register IIC device to kernel
829 *
830 * @details
831 *
832 * @note
833 ******************************************************************************/
rt_hw_iic_init(void)834 void rt_hw_iic_init(void)
835 {
836 struct efm32_iic_device_t *iic;
837 rt_uint32_t flag;
838
839 do
840 {
841 flag = RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX;
842 /* Initialize and register iic0 */
843 if ((iic = rt_hw_iic_unit_init(&iic0, 0, RT_USING_IIC0)) != RT_NULL)
844 {
845 rt_hw_iic_register(&iic0.device, RT_IIC0_NAME, flag, iic);
846 }
847 else
848 {
849 break;
850 }
851
852 #if (I2C_COUNT > 1)
853 /* Initialize and register iic1 */
854 if ((iic = rt_hw_iic_unit_init(&iic1, 1, RT_USING_IIC1)) != RT_NULL)
855 {
856 rt_hw_iic_register(&iic1.device, RT_IIC1_NAME, flag, iic);
857 }
858 else
859 {
860 break;
861 }
862 #endif
863
864 iic_debug("IIC: H/W init OK!\n");
865 return;
866 } while (0);
867
868 rt_kprintf("IIC: H/W init failed!\n");
869 }
870
871 #endif /* (defined(RT_USING_IIC0) || defined(RT_USING_IIC1)) */
872 /***************************************************************************//**
873 * @}
874 ******************************************************************************/
875