ARM技术论坛
直播中

agdhun

9年用户 470经验值
擅长:可编程逻辑 嵌入式技术 EDA/IC设计 处理器/DSP 接口/总线/驱动 RF/无线
私信 关注
[经验]

【MYD-CZU3EG开发板试用体验】【图像篇】 Sii9022的IIC操作

做图像处理最终结果要么保存到文件内，要么通过一个设备显示出来，HDMI实现了显示渠道的接口，在MYD-CZU3EG这块板卡上，使用了SiI9022这款HDMI发送器，充当了将RGB数据转成HDMI信号发送出去的功能，SiI9022是基于IIC接口进行配置操作，具体有以下几种操作流程：
1.png
Zynq MPSoc使用I2C共有3种模式：
1.     PS I2C Controller+MIO；
2.     PS I2CController+EMIO(PL IO);
3.     PL Logic Driver;
本文基于第二种进行操作，使用EMIO不仅仅可以利用到PS已有的硬核，还可以使用PL端的Chipscope进行波形的抓取，相对于MIO，在内部多了一个逻辑分析仪，相对于PL逻辑实现，无需占用PL逻辑资源；
配置SiI9022前提要先配置MPSoc的I2C controller，Xilinx提供的库函数太过臃肿，故此使用直接寄存器操作：
一般I2C控制器设计的操作流程是：初始化控制器->设置从机地址、数据->启动传输 ->查询状态；MPSoc的初始化控制器流程如下：
1.     备份Interrupt Mask寄存器
2.     设置Interrupt Disabled寄存器为0x2FF
3.     初始化FIFO，清除Transfer Size；
4.     清除Interrupt Status寄存器
5.     设置Mask备份值到Interrupt Enable寄存器；
6.     设置超时周期；
7.     清除Interrupt Status寄存器
8.     设置SCL时钟，SCL时钟根据Control寄存器的DivisorA和DivisorB值计算的，计算公式：I2C系统时钟/22U * (Div_a + 1U) * (Div_b + 1U)
MPSoc通过I2C写数据到从机，一般情况都使用3Phase模式，即从机地址+从机寄存器地址+数据，这种情况下的流程：
1.     等待总线空闲；
2.     设置是否处理应答（ACK_EN）、寻址模式（NEA）、主机模式还是从机模式（MS）、读还是写（RW）、是否需要重启动（HOLD）(Control寄存器)
3.     初始化FIFO，清除Transfer Size；
4.      禁用所有中断，设置Interrupt Disabled寄存器为0x2FF
5.      清除Interrupt Status寄存器
6.      写入从机寄存器地址（寄存器偏移0xC）；
7.     写入从机寄存器地址需要写入的值（寄存器偏移0xC）；（这一步可选）
8.     写入从机地址（寄存器偏移0x8）（在执行这一步写入后，传输已经开始）；
9.     读取ISR寄存器的Complete位，来轮询传输是否已经结束；
10.  判断ISR的ARB_LOST、TX_OVF、NACK是否激活，如果都没有激活，表示传输过程没有出现错误
11.  等待总线空闲；
MPSoc通过I2C从从机读数据，一般有两种模式，
l  先执行写操作，但不是真正写，只是设置从机寄存器地址，然后执行Current Read，即在上次写的从机寄存器地址上读数据（此种方式取决于器件是否支持，根据手册，SiI9022是支持这种操作）
l  先写从机寄存器地址、重启动、读数据，此种方式不太方便利用之前I2C写的流程；
本文使用第一种，读流程如下：
1.     执行I2C写操作；
2.     设置是否处理应答（ACK_EN=1）、寻址模式（NEA=1）、主机模式还是从机模式（MS=1）、读还是写（RW=1）、不需要重启动（HOLD=0）(Control寄存器)
3.     清除Interrupt Status寄存器
4.     设置Transfer Size寄存器为1，只读一个Byte数据；
5.     写入从机地址（寄存器偏移0x8）（在执行这一步写入后，传输已经开始）；
6.     读取ISR寄存器的RX_DV位，来轮询传输是否已经结束，或者延迟1ms；
7.     判断ISR的ARB_LOST、RX_OVF、RX_UNF、NACK是否激活，如果都没有激活，表示传输过程没有出现错误
8.     等待总线空闲；
使用上述流程对SiI9022操作，操作步骤如下：
  • 设置I2C Brige连通channel1；
  • 写寄存器0xC7值0，进行复位；（从机地址居然是0x3b，手册上是0x76，好奇怪）
  • 读寄存器0x1B-0x1D;

读取SiI9022 ID如下图所示，根据手册，发现器件类型是9022A；

2.png

使用EMIO可以利用Vivado的Chipscope对从PS过来的信号进行捕捉，EMIO并不是PS直接到PL引脚上，而是到PL逻辑入口，具体怎么连接到哪，是否会做某些处理，完全取决于PL Logic；

Vivado的Chipscope捕捉分为Trigger和Capture，Trigger是捕捉到一次匹配条件，抓取设定好的前后多少个数据，而Capture是在满足一次匹配，捕捉一次，有多少个匹配，就会产生多少个点。捕捉低速信号，例如I2C，可以使用Capture，不过需要有scl的N倍频时钟作为捕捉条件；Trigger还有多窗口捕捉，可以实现多次捕捉，一次只捕捉设定好的点数；

下图是捕捉本例的结果：

3.png

写从机地址0x70，数据2，2Phase模式

4.png

写从机地址0x3b，寄存器地址0xC7，数据0，3Phase模式

5.png

读从机地址0x3b，寄存器地址0x1B

6.png

读从机地址0x3b，寄存器地址0x1C

7.png

读从机地址0x3b，寄存器地址0x1D
Main Code:
  1. #include
  2. #include "platform.h"
  3. #include "xil_printf.h"
  4. #include "xil_io.h"
  5. #include "sleep.h"

  7. #define CRL_APB 0xFF5E0000
  8. #define RST_LPD_IOU2 0x238
  9. #define I2C0_BASE     0xFF020000
  10. #define I2C1_BASE     0xFF030000

  12. static u32 i2cc_addr = I2C0_BASE;

  14. u32 Zu_I2c_Init(void)
  15. {
  16.     u32 IntrMaskReg;
  17.         u32 IntrStatusReg;
  18.         IntrMaskReg = Xil_In32(i2cc_addr+0x20);
  19.         Xil_Out32(i2cc_addr+0x28, 0x2FF);
  20.         Xil_Out32(i2cc_addr, 0x40);
  21.         IntrStatusReg = Xil_In32(i2cc_addr+0x10);
  22.         Xil_Out32(i2cc_addr+0x10, IntrStatusReg);
  23.         IntrMaskReg = (u32)0x2FF & (~IntrMaskReg);
  24.         Xil_Out32(i2cc_addr+0x24, IntrMaskReg);
  25.         Xil_Out32(i2cc_addr, 0);
  26.         Xil_Out32(i2cc_addr+0x1C, 0xFF);
  27.         Xil_Out32(i2cc_addr+0x28, 0x2FF);
  28. }

  30. s32 Zu_I2c_BusIsBusy()
  31. {
  32.         u32 ControlReg;
  33.         u32 StatusReg;
  34.         s32        Status;

  36.         ControlReg = Xil_In32(i2cc_addr);
  37.         StatusReg = Xil_In32(i2cc_addr+0x4);
  38.         if (((StatusReg & 0x100) != 0x0U) && ((ControlReg&0x10)==0)) {
  39.                 Status = (s32)TRUE;
  40.         }else {
  41.                 Status = (s32)FALSE;
  42.         }
  43.         return Status;
  44. }

  46. u32 Zu_I2c_Write(u32 phy_addr, u32 reg_addr, u32 *reg_data)
  47. {
  48.         u32 ControlReg;
  49.         u32 Intrs;
  50.         u32 IntrStatusReg;
  51.         u32 Status;
  52.         if(Zu_I2c_BusIsBusy())
  53.         {
  54.                 xil_printf("Bus is Busynr");
  55.                 return 1;
  56.         }
  57.         ControlReg = Xil_In32(i2cc_addr)&(~0x4F);
  58.         ControlReg |= (u32)0x4E;
  59.         Xil_Out32(i2cc_addr, ControlReg);

  61.         Xil_Out32(i2cc_addr+0x28, 0x2FF);// Disabled all interrupt
  62.         Intrs = (u32)0x240;//0x244;
  63.         IntrStatusReg = Xil_In32(i2cc_addr+0x10);
  64.         Xil_Out32(i2cc_addr+0x10, IntrStatusReg);

  66.         Xil_Out32(i2cc_addr+0xC,(u32)(reg_addr));
  67.         if(reg_data != NULL)
  68.                 Xil_Out32(i2cc_addr+0xC,(u32)(*reg_data));
  69. //        Xil_Out32(i2cc_addr+0x14,1);
  70.         Xil_Out32(i2cc_addr+0x8, (u32)phy_addr);
  71.         IntrStatusReg = Xil_In32(i2cc_addr+0x10);
  72.         while ((IntrStatusReg & 1) != 1){    //Check Complete
  73.                 IntrStatusReg = Xil_In32(i2cc_addr+0x10);
  74.                 if ((IntrStatusReg & Intrs) != 0U) {
  75.                         break; //Capture Error
  76.                 }
  77.         }

  79.         if ((IntrStatusReg & Intrs) != 0U) {
  80.                 if (IntrStatusReg & 0x200) {
  81.                         Status = (s32) 1089;
  82.                 } else {
  83.                         Status = (s32)1;
  84.                 }
  85.         } else {
  86.                         Status = (s32)0;
  87.                         while(Zu_I2c_BusIsBusy());
  88.         }
  89.         return Status;
  90. }

  92. u32 Zu_I2c_Read(u32 phy_addr, u32 reg_addr, u32 *reg_data)
  93. {
  94.         u32 IntrStatusReg = 0;
  95.         u32 Intrs = 0;
  96.         u32 StatusReg = 0;
  97.         u32 Status = 0;
  98.         u32 ControlReg = 0;

  100.         Status = Zu_I2c_Write(phy_addr, reg_addr, NULL);
  101.         if(Status != 0)
  102.         {
  103.                 xil_printf("Write Status: %dnr", Status);
  104.                 return Status;
  105.         }

  107.         usleep(250000);
  108.         ControlReg = Xil_In32(i2cc_addr);
  109.         ControlReg |= (u32)0x4F;
  110.         Xil_Out32(i2cc_addr, ControlReg);

  112.         IntrStatusReg = Xil_In32(i2cc_addr+0x10);
  113.         Xil_Out32(i2cc_addr+0x10, IntrStatusReg);

  115.         Xil_Out32(i2cc_addr+0x14,1);
  116.         Xil_Out32(i2cc_addr+0x8, (u32)phy_addr);
  117.         usleep(1000);
  118.         Intrs = (u32)0x2a4;
  119.         IntrStatusReg = Xil_In32(i2cc_addr+0x10);
  120.         if ((IntrStatusReg & Intrs) == 0U) {
  121.                 StatusReg = Xil_In32(i2cc_addr+0x4);

  123.             if((StatusReg & 0x20) != 0U) {
  124.                         *reg_data = Xil_In32(i2cc_addr+0x0C);
  125.                         StatusReg = Xil_In32(i2cc_addr+0x4);
  126.                 }
  127.             else if((StatusReg & 0x40) != 0U) {
  128.                     xil_printf("RX FIFO Overflownr");
  129.                         *reg_data = Xil_In32(i2cc_addr+0x0C);
  130.                         StatusReg = Xil_In32(i2cc_addr+0x4);
  131.                 }
  132. //                IntrStatusReg = Xil_In32(i2cc_addr+0x10);
  133. //                Xil_Out32(i2cc_addr+0x10, IntrStatusReg);
  134. //                Xil_Out32(i2cc_addr+0x08, phy_addr);
  135. //                Xil_Out32(i2cc_addr+0x14,1);
  136. //                IntrStatusReg = Xil_In32(i2cc_addr+0x0C);
  137.         }

  139. //        Xil_Out32(i2cc_addr+0x0C, Xil_In32(i2cc_addr+0x0) & (~0x10));
  140.         if ((IntrStatusReg & Intrs) != 0U) {
  141.                 if (IntrStatusReg & 0x20) {
  142.                         Status = (s32) 1089;
  143.                 } else {
  144.                         Status = (s32)1;
  145.                 }
  146.         } else {
  147.                 Status = (s32)0;

  149.                 while(Zu_I2c_BusIsBusy());
  150.         }

  152.         return Status;
  153. }



  157. void Zu_Set_Scl_Clock(u32 freq)
  158. {
  159.         u32 Div_a;
  160.         u32 Div_b;
  161.         u32 ActualFscl;
  162.         u32 Temp;
  163.         u32 TempLimit;
  164.         u32 LastError;
  165.         u32 BestError;
  166.         u32 CurrentError;
  167.         u32 ControlReg;
  168.         u32 CalcDivA;
  169.         u32 CalcDivB;
  170.         u32 BestDivA;
  171.         u32 BestDivB;
  172.         u32 FsclHzVar = 100000;

  174.         Temp = XPAR_PSU_I2C_0_I2C_CLK_FREQ_HZ / ((u32)22U * FsclHzVar);
  175.         /*
  176.          * If frequency 400KHz is selected, 384.6KHz should be set.
  177.          * If frequency 100KHz is selected, 90KHz should be set.
  178.          * This is due to a hardware limitation.
  179.          */
  180.         if(FsclHzVar > (u32)384600U) {
  181.                 FsclHzVar = (u32)384600U;
  182.         }
  183.         if((FsclHzVar <= (u32)100000U) && (FsclHzVar > (u32)90000U)) {
  184.                 FsclHzVar = (u32)90000U;
  185.         }
  186.         TempLimit = ((XPAR_PSU_I2C_0_I2C_CLK_FREQ_HZ %
  187.                         ((u32)22 * FsclHzVar)) !=         (u32)0x0U) ?
  188.                                                 Temp + (u32)1U : Temp;
  189.         BestError = FsclHzVar;

  191.         BestDivA = 0U;
  192.         BestDivB = 0U;
  193.         for ( ; Temp <= TempLimit ; Temp++)
  194.         {
  195.                 LastError = FsclHzVar;
  196.                 CalcDivA = 0U;
  197.                 CalcDivB = 0U;

  199.                 for (Div_b = 0U; Div_b < 64U; Div_b++) {

  201.                         Div_a = Temp / (Div_b + 1U);

  203.                         if (Div_a != 0U){
  204.                                 Div_a = Div_a - (u32)1U;
  205.                         }
  206.                         if (Div_a > 3U){
  207.                                 continue;
  208.                         }
  209.                         ActualFscl = XPAR_PSU_I2C_0_I2C_CLK_FREQ_HZ /
  210.                                                 (22U * (Div_a + 1U) * (Div_b + 1U));

  212.                         if (ActualFscl > FsclHzVar){
  213.                                 CurrentError = (ActualFscl - FsclHzVar);}
  214.                         else{
  215.                                 CurrentError = (FsclHzVar - ActualFscl);}

  217.                         if (LastError > CurrentError) {
  218.                                 CalcDivA = Div_a;
  219.                                 CalcDivB = Div_b;
  220.                                 LastError = CurrentError;
  221.                         }
  222.                 }
  223.                 if (LastError < BestError) {
  224.                         BestError = LastError;
  225.                         BestDivA = CalcDivA;
  226.                         BestDivB = CalcDivB;
  227.                 }
  228.         }
  229.         ControlReg = Xil_In32(i2cc_addr);
  230.         ControlReg &= ~((u32)0xC000 | (u32)0x3F00);
  231.         ControlReg |= (BestDivA << 14) | (BestDivB << 8);
  232.         Xil_Out32(i2cc_addr, ControlReg);
  233. }

  235. int main()
  236. {
  237.         u32 dev_1 = 0 ;
  238.         u32 dev_2 = 0;
  239.         u32 dev_3 = 0 ;
  240.         u32 dev_4 = 0;
  241.         u32 sii_dev = 0;
  242.         u32 reset = 0;
  243.         u32 Status;
  244.         u32 ov2640_addr = 0x3b;
  245.     init_platform();
  246.     Xil_Out32(0xFF0A0000 + 0x2C4,0x00000001);
  247.         Xil_Out32(0xFF0A0000 + 0x2C8,0x00000001);
  248.         Xil_Out32(0xFF0A0000 + 0x18,0xFFFE0001);
  249.         usleep(2500);
  250.     Zu_I2c_Init();

  252.         //Xil_Out32(0xA0001000, 1);
  253.         Zu_Set_Scl_Clock(100000);
  254.         Zu_I2c_Write(0x70, 0x2, NULL);
  255.         Zu_I2c_Write(0x3b, 0xC7, &reset);
  256.         usleep(250000);
  257.         Status = Zu_I2c_Read(0x3b, 0x1B, &dev_1);
  258.         Status = Zu_I2c_Read(0x3b, 0x1C, &dev_2);
  259.         Status = Zu_I2c_Read(0x3b, 0x1D, &dev_3);
  260.         Status = Zu_I2c_Read(0x3b, 0x30, &dev_4);
  261.         sii_dev = dev_1 | (dev_2 << 8) | (dev_3 << 16) | (dev_4 << 24);
  262.         if(sii_dev== 0xB0)
  263.                 xil_printf("Detect Sii9022nr");
  264.         if(sii_dev== 0x0302B0)
  265.                 xil_printf("Detect Sii9022Anr");
  266.         if(sii_dev== 0x120000B0)
  267.                 xil_printf("Detect Sii9024nr");
  268.         if(sii_dev== 0x120302B0)
  269.                 xil_printf("Detect Sii9024Anr");
  270.         if(sii_dev== 0x123000B4)
  271.                 xil_printf("Detect Sii9136/9334nr");

  273.     cleanup_platform();
  274.     return 0;
  275. }


更多回帖

0 0 0

相关帖子

I2C SiI9022A ILA 开发板
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分