IIS模块实现IIS.c如下：

  1. #include"s3c2416.h"
  3. #include "IIS.h"
  5. #include"Exception.h"
  7. #include"UART0.h"
  11. #defineDEBUG_IIS
  13. #ifdef  DEBUG_IIS
  15. #defineDebug(x...) Uart0_Printf(x)
  17. #else
  19. #defineDebug(x...)
  21. #endif
  25. staticunsigned char TX_Channel; // 发送音频的声道数
  27. staticunsigned char TX_BitLen; // 发送位长
  29. staticunsigned char RX_Channel; // 接收音频的声道数
  31. staticunsigned char RX_BitLen; // 接收位长
  35. staticvolatile unsigned char TxBufferFlag;
  37. staticvolatile unsigned char RxBufferFlag;
  39. staticunsigned int  TxCount; // 播放时记录缓存中的写位置
  41. staticunsigned int  RxCount; // 录音时记录缓存中的读位置
  45. // 插放与录音均采用双缓存,DMA传输的主存与cache会有数据一致性问题
  47. // 音频DMA缓存分配到不开启cache的内存区域
  49. staticunsigned int TxBuffer0[4*1024] __attribute__((section("No_Cache"),zero_init));
  51. staticunsigned int TxBuffer1[4*1024] __attribute__((section("No_Cache"),zero_init));
  53. staticunsigned int RxBuffer0[4*1024] __attribute__((section("No_Cache"),zero_init));
  55. staticunsigned int RxBuffer1[4*1024] __attribute__((section("No_Cache"),zero_init));
  59. static voidDMA_IRQ(void)
  61. {      
  63.     static unsigned char TxBufferChannel = 0;
  65.     static unsigned char RxBufferChannel = 0;
  67.     unsigned int DMA_Channel;
  69.     DMA_Channel = rSUBSRCPND;
  71.     if (DMA_Channel &(1<<SUBINT_DMA0)) { // DMA0中断请求, IIS TX
  73.         if (TxBufferChannel == 0) {
  75.             rDISRC0 = ((unsigned int)TxBuffer1);// 开始使用Buffer1缓存   
  77.             TxBufferFlag &= ~(1<<0);// 发送标志0位清空,说明Buffer0数据需填充
  79.             TxBufferChannel = 1; // 正在发送Buffer1缓存
  81.         } else {
  83.             rDISRC0 = ((unsignedint)TxBuffer0);// 开始使用Buffer0缓存
  85.             TxBufferFlag &= ~(1<<1);// 发送标志1位清空,说明Buffer1数据需填充
  87.             TxBufferChannel = 0; // 正在发送Buffer0缓存
  89.         }
  91.         rDCON0 = (rDCON0&(~0xfffff)) |(sizeof(TxBuffer0)/4);
  93.         rDMASKTRIG0 = (1<<1); // IIS TX打开DMA0通道
  95.         rSUBSRCPND |= (1<<SUBINT_DMA0);
  97.     }
  99.     if (DMA_Channel &(1<<SUBINT_DMA1)) { // DMA1中断请求, IIS RX
  101.         if (RxBufferChannel == 0) {    
  103.             rDIDST1 = ((unsigned int)RxBuffer1);// DMA1目的地址   
  105.             RxBufferFlag |= (1<<0); // 接收缓存0位置位,说明Buffer0数据准备好
  107.             RxBufferChannel = 1; // 下一次使用Buffer1
  109.         } else {
  111.             rDIDST1 = ((unsigned int)RxBuffer0);// DMA1目的地址   
  113.             RxBufferFlag |= (1<<1); // 接收缓存1位置位,说明Buffer1数据准备好
  115.             RxBufferChannel = 0; // 下一次使用Buffer0          
  117.         }
  119.         rDCON1 = (rDCON1&(~0xfffff)) |(sizeof(RxBuffer0)/4);
  121.         rDMASKTRIG1 = (1<<1); // IIS RX打开DMA1通道               
  123.         rSUBSRCPND |= (1<<SUBINT_DMA1);    
  125.     }
  127.     rSRCPND1 |= (1 << INT_DMA);
  129.     rINTPND1 |= (1 << INT_DMA);
  131. }
  135. unsignedint IIS_WriteBuffer(unsigned char *pData, unsigned int MaxLen)
  137. {
  139.     unsigned int i;
  141.     unsigned int nCount; // 能写入buffer中数据长度(以字计,fifo 32位长)
  143.     unsigned int *pBuffer;
  145.     unsigned char *pTemp = pData;
  147.     if (pTemp==0 || MaxLen==0) {
  149.         return 0; // 参数错误,数据未写入缓存
  151.     }
  153.     if ((TxBufferFlag&0x3) == 0x3) {
  155.         return 0; // Buffer0,Buffer1均已写满
  157.     }
  159.     if (!(TxBufferFlag & (1<<0))) { //Buffer0需填充
  161.         pBuffer = &TxBuffer0[TxCount];
  163.     } else { // Buffer1需填充
  165.         pBuffer = &TxBuffer1[TxCount];     
  167.     }
  169.     nCount = (sizeof(TxBuffer0)/4) - TxCount;  
  173.     switch (TX_BitLen) {
  175.     case 8:
  177.         if (TX_Channel != 1) { // 双声道
  179.             if (MaxLen/2 == 0) {// 左右声道fifo中有两个8位有效音频数据
  181.                 pTemp += MaxLen; // 不足一个采样2字节数据,丢弃写入buffer中
  183.             }                  
  185.             MaxLen = MaxLen/2; // 32位的fifo中有两个8位有效音频数据  
  187.             if (MaxLen < nCount) {
  189.                 nCount = MaxLen;
  191.             }  
  193.             for (i=0; i<nCount; i++) {
  195.                 *pBuffer++ = (((unsignedint)pTemp[1]<<16)+
  197. ((unsignedint)pTemp[0]<<0));
  199.                 pTemp += 2; // 2个8位的声道数据已写入buffer中
  201.             }
  203.         } else { // 单声道
  205.             if (MaxLen < nCount) {// 32位的fifo中有一个8位有效音频数据
  207.                 nCount = MaxLen;
  209.             }          
  211.             for (i=0; i<nCount; i++) {
  213.                 *pBuffer++ = (unsignedint)pTemp[0]<<0;
  215.                 pTemp += 1; // 1个8位的声道数据已写入FIFO中
  217.             }
  219.         }          
  221.         break;
  223.     case 16:
  225.         if (TX_Channel != 1) { // 双声道
  227.             if (MaxLen/4 == 0) {// 左右声道fifo中有四个8位有效音频数据
  229.                 pTemp += MaxLen; // 不足一个采样4字节数据,丢弃写入buffer中
  231.             }                  
  233.             MaxLen = MaxLen/4; // 32位的fifo中有四个8位有效音频数据
  235.             if (MaxLen < nCount) {
  237.                 nCount = MaxLen;
  239.             }                          
  241.             for (i=0; i<nCount; i++) {
  243.                 *pBuffer++ = (((unsignedint)pTemp[0]<<0) +
  245. ((unsignedint)pTemp[1]<<8)) +
  247.                           (((unsigned int)pTemp[2]<<16) +
  249. ((unsignedint)pTemp[3]<<24));
  251.                 pTemp += 4; // 4个8位的声道数据已写入FIFO中
  253.             }  
  255.         } else { // 单声道
  257.             if (MaxLen/2 == 0) {// 单声道fifo中有两个8位有效音频数据
  259.                 pTemp += MaxLen; // 不足一个采样2字节数据,丢弃写入buffer中
  261.             }                  
  263.             MaxLen = MaxLen/2; // 32位的fifo中有两个8位有效音频数据
  265.             if (MaxLen < nCount) {
  267.                 nCount = MaxLen;
  269.             }              
  271.             for (i=0; i<nCount; i++) {
  273.                 *pBuffer++ = (((unsignedint)pTemp[1]) << 8) + pTemp[0];
  275.                 pTemp += 2; // 2个8位的声道数据已写入FIFO中
  277.             }          
  279.         }
  281.         break;
  283.     case 24:
  285.         if (TX_Channel != 1) { // 双声道
  287.             if (MaxLen/3 == 0) {// 左右声道fifo中有六个8位有效音频数据
  289.                 pTemp += MaxLen; // 一个声道采样3字节数据,丢弃写入buffer中
  291.             }              
  293.             MaxLen = MaxLen/3; // 每个声道fifo中有三个8位有效音频数据
  295.             if (MaxLen < nCount) {
  297.                 nCount = MaxLen;
  299.             }              
  301.             for (i=0; i<nCount; i++) {
  303.                 *pBuffer++ =((pTemp[0]<<0)+
  305. ((unsignedint)pTemp[1]<<8))+((unsigned int)pTemp[2]<<16);
  307.                 pTemp += 3; // 3个8位的声道数据已写入FIFO中
  309.             }  
  311.         } else { // 单声道
  313.             if (MaxLen/3 == 0) {// 单声道fifo中只有三个8位有效音频数据
  315.                 pTemp += MaxLen; // 不足一个采样3字节数据,丢弃写入buffer中
  317.             }  
  319.             MaxLen = MaxLen/3;         
  321.             if (MaxLen < nCount) {
  323.                 nCount = MaxLen;
  325.             }
  327.             if (nCount == 1) {
  329.                 pTemp += 3;
  331.             }
  333.             for (i=0; i<nCount/2; i++) {
  335.                 *pBuffer++ =((pTemp[0]<<0)+
  337. ((unsignedint)pTemp[1]<<8))+((unsigned int)pTemp[2]<<16);
  339.                 *pBuffer++ = 0; // 另一声道静音
  341.                 pTemp += 3; // 3个8位的声道数据已写入FIFO中
  343.             }      
  345.         }      
  347.         break;
  349.     default:
  351.         break;
  353.     }  
  357.     TxCount += nCount; // 记录这一次写后缓存的位置
  359.     if (TxCount >= sizeof(TxBuffer0)/4) { // 到达缓存结尾
  361.         TxCount = 0; // 标记缓存写满并切换到另一个缓存
  363.         if (!(TxBufferFlag & (1<<0))){
  365.             TxBufferFlag |= (1<<0); // Buffer0写滿
  367.         } else {
  369.             TxBufferFlag |= (1<<1); //Buffer1写滿
  371.         }
  373.     }
  375.     return ((unsigned int)(pTemp-pData)); // 返回写入缓存中的字节数
  377. }
  381. unsignedint IIS_ReadBuffer(unsigned char *pData, unsigned int MaxLen)
  383. {
  385.     unsigned int i;
  387.     unsigned int nCount;
  389.     unsigned int Value;
  391.     unsigned int *pBuffer;
  393.     unsigned char *pTemp = pData;
  395.     if (pTemp==0 || MaxLen==0) {
  397.         return 0; // 参数错误,数据未写入缓存
  399.     }
  401.     if ((RxBufferFlag&0x3) == 0x0) {
  403.         return 0; // Buffer0,Buffer1均未准备好
  405.     }
  407.     if (RxBufferFlag & (1<<0)) { //Buffer0准备好
  409.         pBuffer = &RxBuffer0[RxCount];
  411.     } else { // Buffer1准备好
  413.         pBuffer = &RxBuffer1[RxCount];     
  415.     }
  417.     // 剩余缓存的长度
  419.     nCount = (sizeof(RxBuffer0)/4) - RxCount;  
  423.     switch (RX_BitLen) {
  425.     case 8:
  427.         if (RX_Channel != 1) { // 双声道
  429.             if (MaxLen/2 == 0) {// 左右声道fifo中有两个8位有效音频数据
  431.                 pTemp += MaxLen; // 不足一个采样2字节存储空间,丢弃存入
  433.             }                  
  435.             MaxLen = MaxLen/2; // 32位的fifo中有两个8位有效音频数据
  437.             if (MaxLen < nCount) {
  439.                 nCount = MaxLen;
  441.             }              
  443.             for (i=0; i<nCount; i++) {
  445.                 Value = *pBuffer++;
  447.                 pTemp[0] = (unsignedchar)(Value>>0);
  449.                 pTemp[1] = (unsignedchar)(Value>>16);
  451.                 pTemp += 2; // 2个8位的声道数据已从buffer中读取
  453.             }
  455.         } else { // 单声道
  457.             if (MaxLen < nCount) {// 32位的fifo中有一个8位有效音频数据
  459.                 nCount = MaxLen;
  461.             }          
  463.             for (i=0; i<nCount; i++) {
  465.                 Value = *pBuffer++;
  467.                 pTemp[0] = (unsigned char)(Value>>0);
  469.                 pTemp += 1; // 1个8位的声道数据已写入FIFO中
  471.             }
  473.         }          
  475.         break;
  477.     case 16:
  479.         if (RX_Channel != 1) { // 双声道
  481.             if (MaxLen/4 == 0) {// 左右声道fifo中有四个8位有效音频数据
  483.                 pTemp += MaxLen; //  不足一个采样4字节存储空间,丢弃存入
  485.             }                  
  487.             MaxLen = MaxLen/4; // 32位的fifo中有四个8位有效音频数据
  489.             if (MaxLen < nCount) {
  491.                 nCount = MaxLen;
  493.             }          
  495.             for (i=0; i<nCount; i++) {
  497.                 Value = *pBuffer++;
  499.                 pTemp[0] = (unsigned char)Value;
  501.                 pTemp[1] = (unsignedchar)(Value>>8);
  503.                 pTemp[2] = (unsignedchar)(Value>>16);
  505.                 pTemp[3] = (unsigned char)(Value>>24);
  507.                 pTemp += 4; // 4个8位的声道数据已从FIFO中读取
  509.             }  
  511.         } else { // 单声道
  513.             if (MaxLen/2 == 0) {// 单声道fifo中有两个8位有效音频数据
  515.                 pTemp += MaxLen; //  不足一个采样2字节存储空间,丢弃存入
  517.             }                  
  519.             MaxLen = MaxLen/2; // 32位的fifo中有两个8位有效音频数据
  521.             if (MaxLen < nCount) {
  523.                 nCount = MaxLen;
  525.             }          
  527.             for (i=0; i<nCount; i++) {
  529.                 Value = *pBuffer++;
  531.                 pTemp[0] = (unsigned char)Value;
  533.                 pTemp[1] = (unsignedchar)(Value>>8);
  535.                 pTemp += 2; // 2个8位的声道数据已从FIFO中读取
  537.             }          
  539.         }
  541.         break;
  543.     case 24:
  545.         if (RX_Channel != 1) { // 双声道
  547.             if (MaxLen/3 == 0) {// 左右声道fifo中有六个8位有效音频数据
  549.                 pTemp += MaxLen; // 不足一个采样6字节存储空间,丢弃存入
  551.             }              
  553.             MaxLen = MaxLen/3; // 左右声道fifo中有六个8位有效音频数据
  555.             if (MaxLen < nCount) {
  557.                 nCount = MaxLen;
  559.             }          
  561.             for (i=0; i<nCount; i++) {
  563.                 Value = *pBuffer++;
  565.                 pTemp[0]= (unsigned char)Value;
  567.                 pTemp[1] = (unsignedchar)(Value>>8);
  569.                 pTemp[2] = (unsignedchar)(Value>>16);
  571.                 pTemp += 3; // 3个8位的声道数据已从FIFO中读取
  573.             }  
  575.         } else { // 单声道
  577.             if (MaxLen/3 == 0) {// 单声道fifo中只有三个8位有效音频数据
  579.                 pTemp += MaxLen; // 不足一个采样3字节存储空间,丢弃存入
  581.             }
  583.             MaxLen = MaxLen/3;         
  585.             if (MaxLen < nCount) {
  587.                 nCount = MaxLen;
  589.             }
  591.             if (nCount == 1) {
  593.                 pTemp += 3;
  595.             }
  597.             for (i=0; i<nCount/2; i++) {
  599.                 Value = *pBuffer++;
  601.                 pTemp[0] = (unsigned char)Value;
  603.                 pTemp[1] = (unsignedchar)(Value>>8);
  605.                 pTemp[2] = (unsignedchar)(Value>>16);
  607.                 pTemp += 3; // 3个8位的声道数据已从FIFO中读取
  609.                 Value = *pBuffer++; // 下一声道数据无需保存
  611.             }      
  613.         }      
  615.         break;
  617.     default:
  619.         break;
  621.     }  
  623.     // 记录下一次读时缓存的位置
  625.     RxCount += nCount;
  627.     if (RxCount >= sizeof(RxBuffer0)/4) { // 读完一个缓存
  629.         RxCount = 0;
  631.         if (RxBufferFlag & (1<<0)) {
  633.             RxBufferFlag &= ~(1<<0);// Buffer0未准备好
  635.         } else {
  637.             RxBufferFlag &= ~(1<<1);// Buffer1未准备好    
  639.         }
  641.     }
  643.     return ((unsigned int)(pTemp-pData)); // 返回读取buffer的字节数
  645. }
  649. voidIIS_RxPause()
  651. {
  653.     rIISCON |= (1<<5);
  655.     rIISCON &= ~((1<<0) |(1<<1));
  657. }
  661. voidIIS_RxStart()
  663. {
  665.     rIISCON &= ~(1<<5);
  667.     rIISCON |= (1<<0) | (1<<1);
  669. }
  673. voidIIS_TxPause()
  675. {  
  677.     rIISCON |= (1<<6);
  679.     rIISCON &= ~((1<<0) |(1<<2)); 
  681. }
  685. voidIIS_TxStart()
  687. {
  689.     rIISCON &= ~(1<<6);
  691.     rIISCON |= (1<<0) | (1<<2);
  693. }
  697. voidIIS_TxInit(unsigned int Sample, unsigned char BitLen, unsigned char Channel)
  699. {
  701.     unsigned int Mode;
  703.     unsigned int Scaler;
  707.     TX_Channel = Channel; // 单声道/双声道
  709.     TX_BitLen = BitLen; // 每声道的字长
  711.     rIISFIC |= (1<<15); // TX fifo flush
  713.     rIISFIC &= ~(1<<15);
  715.     TxBufferFlag = 0;
  717.     TxCount = 0;
  719.     // Master mode audio clock=96M
  721.     // codec clcok 256fs,bit clock 32fs,
  723.     Mode = (0x0<<16) + (1<<10);//IISSDO1,IISSDO2不使用,即不会写FIFO1,2
  725.     if (((rIISMOD>>8) & 0x3) == 1) {
  727.         Mode |= (0x2<<8); // 已在接收模式,转到同时接收发送
  729.     }
  731.     Mode |= (0x0<<5); // IIS format format
  733.     Mode |= (0x2<<3); // 384fs 
  735.     switch (BitLen) {
  737.     case 8: // 8位采样数也配置成16位进行传输
  739.     case 16:
  741.         Mode |= (0x0 << 13);       
  743.         Mode |= (0x0 << 1); // 32fs
  745.         break;
  747.     case 24:
  749.         Mode |= (0x2 << 13);       
  751.         Mode |= (0x1 << 1); // 48fs
  753.         break; 
  755.     default:
  757.         TX_BitLen = 16; // 其它默认为16位
  759.         Mode |= (0x0 << 13);   
  761.         Mode |= (0x0 << 1); // 32fs
  763.         break;     
  765.     }
  767.     rIISMOD = Mode;
  771.     if (Sample != 0) {
  773.         Scaler =(96000000/384+(Sample>>1))/Sample; // codec clcok 384fs
  775.         rIISPSR =  (1<<15) + ((Scaler-1)<<8); // 预分频输出
  777.     }
  779.     rDMASKTRIG0 = (1<<1); // IIS TX打开DMA0通道
  783.     Debug("Player sampling rate: %dHZ, Bitlength: %d, Channel: ", Sample, BitLen);
  785.     Debug((Channel!=1)?"dual\r\n":"single\r\n");
  787.     Debug("CodeClk = %dHZ\r\n", 96000000/(((rIISPSR>>8)&0x3f)+1));
  789. }
  793. voidIIS_RxInit(unsigned int Sample, unsigned char BitLen, unsigned char Channel)
  795. {
  797.     unsigned int Mode;
  799.     unsigned int Scaler;
  801.     RX_Channel = Channel; // 录音的声道数
  803.     RX_BitLen = BitLen; // 录音的每声道位长
  807.     rIISFIC |= (1<<7); // RX fifo flush
  809.     rIISFIC &= ~(1<<7);
  811.     RxBufferFlag = 0;
  813.     RxCount = 0;
  815.     // 16bit,Master mode audio clock=96M,IISformat
  817.     // codec clcok 256fs,bit clock 32fs
  819.     Mode = (0x0<<16) + (1<<10);
  821.     if (((rIISMOD>>8) & 0x3) == 0) {
  823.         Mode |= (0x2<<8); // 已在发送模式,转到同时接收发送     
  825.     } else {
  827.         Mode |= (0x1<<8); // 接收模式
  829.     }
  831.     Mode |= (0x0<<5); // // IIS formatformat
  833.     Mode |= (0x2<<3); // 384fs
  835.     switch (BitLen) {
  837.     case 8:
  839.     case 16:
  841.         Mode |= (0x0 << 13);
  843.         Mode |= (0x0 << 1); // 32fs
  845.         break;
  847.     case 24:
  849.         Mode |= (0x2 << 13);
  851.         Mode |= (0x1 << 1); // 48fs
  853.         break; 
  855.     default:
  857.         RX_BitLen = 16; // 其它默认为16位
  859.         Mode |= (0x0 << 13);
  861.         Mode |= (0x0 << 1); // 32fs
  863.         break;     
  865.     }  
  867.     rIISMOD = Mode;
  871.     if (Sample != 0) {
  873.         Scaler = 96000000/384/Sample; // codecclcok 384fs
  875.         rIISPSR =  (1<<15) + ((Scaler-1)<<8); // 预分频输出
  877.     }
  879.     rDMASKTRIG1 = (1<<1); // IIS RX打开DMA1通道   
  883.     Debug("Recorder sampling rate: %dHZ,Bit length: %d, Channel: ", Sample, BitLen);
  885.     Debug((Channel!=1)?"dual\r\n":"single\r\n");
  887.     Debug("CodeClk = %dHZ\r\n",96000000/(((rIISPSR>>8)&0x3f)+1));
  889. }
  893. voidIIS_Init()
  895. {
  897.     // 配置IIS接口引脚
  899.     rGPECON &= ~(0x3ff << 0);
  901.     rGPECON |= 0x2aa;
  903.     rGPEUDP &= ~(0x3ff << 0); // 禁止上下位
  907.     rCLKDIV1 &= ~(0xf<<12);
  909.     rCLKDIV1 |= (0<<12); // IIS clock 96M
  911.     rIISCON = 0;
  915.     rDMAREQSEL0 = (4<<1) | (1<<0);// IIS TX通过DMA0传输
  917.     rDMAREQSEL1 = (5<<1) | (1<<0);// IIS RX通过DMA1传输  
  919.     rDISRC0 = (unsigned int)TxBuffer0; // DMA0源地址
  921.     rDISRC1 = (unsigned int)&rIISRXD; //DMA1源地址为RX FIFO寄存器地址
  923.     rDISRCC0 = (0<<1) | (0<<0); //DMA0源地址在AHB总线上,DMA访问后地址自增
  925.     rDISRCC1 = (1<<1) | (1<<0); //DMA1源地址在APB总线上,地址固定 
  927.     rDIDST0 = (unsigned int)&rIISTXD; //DMA0目的地址为TX FIFO寄存器地址
  929.     rDIDST1 = ((unsigned int)RxBuffer0); // DMA1目的地址   
  931.     rDIDSTC0 = (0<<2) | (1<<1) |(1<<0); // DMA0目的地址在APB上,固定,计数0中断
  933.     rDIDSTC1 = (0<<2) | (0<<1) |(0<<0); // DMA1目的地址在AHB上,自增,计数0中断
  935.     // Word transferred, count 16KB/4 word,handshake mode
  937.     // no auto reload, single service, enable tcinterrupt,
  939.     rDCON0 = 0xe0000000 | (1<<22) |(1<<24) | (2<<20) | ((sizeof(TxBuffer0)/4)<<0);
  941.     rDCON1 = 0xe0000000 | (1<<22) |(1<<24) | (2<<20) | ((sizeof(RxBuffer0)/4)<<0);
  945.     TxBufferFlag = 0; // 发送缓存0,1需填充
  947.     RxBufferFlag = 0;
  949.     TxCount = 0;
  951.     RxCount = 0;
  953.     IRQ_Register(INT_DMA, DMA_IRQ);// DMA中断入口函数加入到向量表
  955.     rINTSUBMSK &= ~((1<<SUBINT_DMA0) |(1<<SUBINT_DMA1)); // 开启DMA0与DMA1子中断
  957.     rINTMOD1 &= ~(1 << INT_DMA); //DMA IRQ
  959.     rINTMSK1 &= ~(1 << INT_DMA); //DMA开启中断
  961. }

IIS模块头文件IIS.h如下：

  1. #ifndef __IIC_H__
  3. #define __IIC_H__
  5. #ifdef __cplusplus
  7. extern "C" {
  9. #endif
  13. #define ArbitrationFailed   (1<<3)// 总线仲裁失败
  15. #define AddressMatche   (1<<2)// 从机地址相配
  17. #define AddressZeros        (1<<1)// 接收的地址为0
  19. #define NoAck           (1<<0)// 没有回复信号
  23. extern int IIC_WriteBytes(unsigned char SlaveAddr, unsigned char WriteAddr,
  25.                    unsigned char *pData, int Length);
  27. extern int IIC_ReadBytes(unsigned char SlaveAddr, unsigned char ReadAddr,
  29.                   unsigned char *pData, int Length);
  31. extern void IIC_Init(void);
  35. #ifdef __cplusplus
  37. }
  39. #endif
  41. #endif /*__IIC_H__*/

5. 附录

WM8960.rar，包含音频驱动模块相关源码，WM8960.c/WM8960.h为音频编解码器驱动模块，IIS.c/IIS.h为音频接口IIS驱动模块，IIC.c/IIC.h为IIC接口驱动模块(需通过IIC控制WM8960)，由于音频驱动是从工程应用角度实现，实现适用于不同采样频率、采样位数、声道数，并通过DMA的方式传输音频，采用双缓存的概念来实现音频的驱动，相对代码较长，但已经是直入主题，尽可能简单明了。

http://pan.baidu.com/s/1c0iXLhI