在线咨询
eetop公众号 创芯大讲堂 创芯人才网
切换到宽版

EETOP 创芯网论坛 (原名:电子顶级开发网)

手机号码,快捷登录

手机号码,快捷登录

找回密码

  登录   注册  

快捷导航
搜帖子
芯片精品文章合集(500篇!)    创芯人才网--重磅上线啦!
查看: 2708|回复: 2

[原创] IIC驱动问题(裸机转Linux的疑问)

[复制链接]
发表于 2011-8-7 23:02:22 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有账号?注册

x
最近在学2440的裸奔程序,有一个疑问:可不可以把裸奔程序直接套进Linux驱动框架里面而转成Linux驱动呢?
于是尝试了一下,遇到了一些困难,望大家能指导一下。

原始的裸奔程序,是mini2440出厂自带的测试程序,IIC的驱动,在iic.c文件中(中断模式):




  1. #include <string.h>
  2. #include "2440addr.h"
  3. #include "2440lib.h"
  4. #include "def.h"
  5. #include "IIC.h"

  6. static U8 _iicData[IICBUFSIZE];
  7. static volatile int _iicDataCount;
  8. static volatile int _iicStatus;
  9. static volatile int _iicMode;
  10. static int _iicPt;

  11. //===================================================================
  12. //       SMDK2440 IIC configuration
  13. //  GPE15=IICSDA, GPE14=IICSCL
  14. //  "Interrupt mode" for IIC block
  15. //===================================================================  

  16. //******************[ Test_Iic ]**************************************
  17. void Test_Iic(void)
  18. {
  19.     unsigned int i,j,save_E,save_PE;
  20.     static U8 data[256];

  21.     Uart_Printf("\nIIC Test(Interrupt) using AT24C02\n");

  22.     save_E   = rGPECON;
  23.     save_PE  = rGPEUP;
  24.     rGPEUP  |= 0xc000;                  //Pull-up disable
  25.     rGPECON |= 0xa00000;                //GPE15:IICSDA , GPE14:IICSCL  

  26.     pISR_IIC = (unsigned)IicInt;
  27.     rINTMSK &= ~(BIT_IIC);

  28.       //Enable ACK, Prescaler IICCLK=PCLK/16, Enable interrupt, Transmit clock value Tx clock=IICCLK/16
  29.       // If PCLK 50.7MHz, IICCLK = 3.17MHz, Tx Clock = 0.198MHz
  30.     rIICCON = (1<<7) | (0<<6) | (1<<5) | (0xf);

  31.     rIICADD  = 0x10;                    //2440 slave address = [7:1]
  32.     rIICSTAT = 0x10;                    //IIC bus data output enable(Rx/Tx)
  33.         rIICLC = (1<<2)|(1);                                  // Filter enable, 15 clocks SDA output delay       added by junon
  34.      
  35.     Uart_Printf("Write test data into AT24C02\n");

  36.     for(i=0;i<256;i++)
  37.         Wr24C080(0xa0,(U8)i,i);
  38.             
  39.     for(i=0;i<256;i++)
  40.         data[i] = 0;

  41.     Uart_Printf("Read test data from AT24C02\n");
  42.      
  43.     for(i=0;i<256;i++)
  44.         Rd24C080(0xa0,(U8)i,&(data[i]));  

  45.         //Line changed 0 ~ f
  46.     for(i=0;i<16;i++)
  47.     {
  48.         for(j=0;j<16;j++)
  49.             Uart_Printf("%2x ",data[i*16+j]);
  50.         Uart_Printf("\n");
  51.     }
  52.     rINTMSK |= BIT_IIC;     
  53.     rGPEUP  = save_PE;
  54.     rGPECON = save_E;
  55. }


  56. //*************************[ Wr24C080 ]****************************
  57. void Wr24C080(U32 slvAddr,U32 addr,U8 data)
  58. {
  59.     _iicMode      = WRDATA;
  60.     _iicPt        = 0;
  61.     _iicData[0]   = (U8)addr;
  62.     _iicData[1]   = data;
  63.     _iicDataCount = 2;
  64.      
  65.     rIICDS   = slvAddr;                 //0xa0
  66.     rIICSTAT = 0xf0;                    //MasTx,Start
  67.       //Clearing the pending bit isn't needed because the pending bit has been cleared.
  68.      
  69.     while(_iicDataCount!=-1);

  70.     _iicMode = POLLACK;

  71.     while(1)
  72.     {
  73.         rIICDS     = slvAddr;
  74.         _iicStatus = 0x100;
  75.         rIICSTAT   = 0xf0;              //MasTx,Start
  76.         rIICCON    = 0xaf;              //Resumes IIC operation.  
  77.             
  78.         while(_iicStatus==0x100);
  79.             
  80.         if(!(_iicStatus&0x1))
  81.             break;                      //When ACK is received
  82.     }
  83.     rIICSTAT = 0xd0;                    //Stop MasTx condition  
  84.     rIICCON  = 0xaf;                    //Resumes IIC operation.  
  85.     Delay(1);                           //Wait until stop condtion is in effect.
  86.        //Write is completed.
  87. }
  88.          
  89. //**********************[ Rd24C080 ] ***********************************
  90. void Rd24C080(U32 slvAddr,U32 addr,U8 *data)
  91. {
  92.     _iicMode      = SETRDADDR;
  93.     _iicPt        = 0;
  94.     _iicData[0]   = (U8)addr;
  95.     _iicDataCount = 1;

  96.     rIICDS   = slvAddr;
  97.     rIICSTAT = 0xf0;                    //MasTx,Start   
  98.       //Clearing the pending bit isn't needed because the pending bit has been cleared.
  99.     while(_iicDataCount!=-1);

  100.     _iicMode      = RDDATA;
  101.     _iicPt        = 0;
  102.     _iicDataCount = 1;
  103.      
  104.     rIICDS        = slvAddr;
  105.     rIICSTAT      = 0xb0;               //MasRx,Start
  106.     rIICCON       = 0xaf;               //Resumes IIC operation.   
  107.     while(_iicDataCount!=-1);

  108.     *data = _iicData[1];
  109. }


  110. //-------------------------------------------------------------------------
  111. void __irq IicInt(void)
  112. {
  113.     U32 iicSt,i;
  114.      
  115.     rSRCPND = BIT_IIC;          //Clear pending bit
  116.     rINTPND = BIT_IIC;
  117.     iicSt   = rIICSTAT;  
  118.      
  119.     if(iicSt & 0x8){}           //When bus arbitration is failed.
  120.     if(iicSt & 0x4){}           //When a slave address is matched with IICADD
  121.     if(iicSt & 0x2){}           //When a slave address is 0000000b
  122.     if(iicSt & 0x1){}           //When ACK isn't received

  123.     switch(_iicMode)
  124.     {
  125.        case POLLACK:
  126.            _iicStatus = iicSt;
  127.            break;

  128.        case RDDATA:
  129.            if((_iicDataCount--)==0)
  130.            {
  131.                _iicData[_iicPt++] = rIICDS;
  132.             
  133.                rIICSTAT = 0x90;                 //Stop MasRx condition  
  134.                rIICCON  = 0xaf;                 //Resumes IIC operation.
  135.                Delay(1);                        //Wait until stop condtion is in effect.
  136.                                                 //Too long time...  
  137.                                                 //The pending bit will not be set after issuing stop condition.
  138.                break;     
  139.            }      
  140.            _iicData[_iicPt++] = rIICDS;         //The last data has to be read with no ack.

  141.            if((_iicDataCount)==0)
  142.                rIICCON = 0x2f;                  //Resumes IIC operation with NOACK.   
  143.            else  
  144.                rIICCON = 0xaf;                  //Resumes IIC operation with ACK
  145.                break;

  146.         case WRDATA:
  147.             if((_iicDataCount--)==0)
  148.             {
  149.                 rIICSTAT = 0xd0;                //Stop MasTx condition  
  150.                 rIICCON  = 0xaf;                //Resumes IIC operation.
  151.                 Delay(1);                       //Wait until stop condtion is in effect.
  152.                        //The pending bit will not be set after issuing stop condition.
  153.                 break;     
  154.             }
  155.             rIICDS = _iicData[_iicPt++];        //_iicData[0] has dummy.
  156.             for(i=0;i<10;i++);                  //for setup time until rising edge of IICSCL
  157.                
  158.             rIICCON = 0xaf;                     //resumes IIC operation.
  159.             break;

  160.         case SETRDADDR:
  161. //          Uart_Printf("[ S%d ]",_iicDataCount);
  162.             if((_iicDataCount--)==0)
  163.                 break;                          //IIC operation is stopped because of IICCON[4]     
  164.             rIICDS = _iicData[_iicPt++];
  165.             for(i=0;i<10;i++);                  //For setup time until rising edge of IICSCL
  166.             rIICCON = 0xaf;                     //Resumes IIC operation.
  167.             break;

  168.         default:
  169.             break;      
  170.     }
  171. }


复制代码


相应的,我直接把上面的程序套到Linux字符驱动的框架里面,除了进行地址映射和寄存器使用函数读取和赋值以外,没有大的改动:





  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/types.h>
  5. #include <linux/mm.h>
  6. #include <linux/gpio.h>
  7. #include <linux/init.h>
  8. #include <linux/cdev.h>
  9. #include <linux/device.h>
  10. #include <linux/miscdevice.h>
  11. #include <linux/clk.h>
  12. #include <linux/interrupt.h>
  13. #include <mach/regs-gpio.h>
  14. #include <asm/mach/time.h>
  15. #include <plat/regs-timer.h>
  16. #include <asm/uaccess.h>
  17. #include <asm/io.h>
  18. #include <mach/hardware.h>
  19. #include <linux/irq.h>
  20. #include <linux/kfifo.h>

  21. #define U32 unsigned long

  22. static void __iomem *gpio_base_addr;
  23. static void __iomem *iic_base_addr;
  24. static void __iomem *timer_base_addr;

  25. #define TIMER_PA        0x51000000
  26. #define rTCFG0  (*(volatile unsigned *)(0x00+timer_base_addr))        //Timer 0 configuration
  27. #define rTCFG1  (*(volatile unsigned *)(0x04+timer_base_addr))        //Timer 1 configuration
  28. #define rTCON   (*(volatile unsigned *)(0x08+timer_base_addr))        //Timer control
  29. #define rTCNTB3 (*(volatile unsigned *)(0x30+timer_base_addr))        //Timer count buffer 3
  30. #define rTCMPB3 (*(volatile unsigned *)(0x34+timer_base_addr))        //Timer compare buffer 3
  31. #define rTCNTO3 (*(volatile unsigned *)(0x38+timer_base_addr))        //Timer count observation 3

  32. #define GPIO_PA        0x56000040
  33. #define rGPECON        (0x00+gpio_base_addr)
  34. #define rGPEUP                (0x08+gpio_base_addr)

  35. #define IIC_PA                0x54000000
  36. #define rIICCON        0x00+iic_base_addr         
  37. #define rIICSTAT        0x04+iic_base_addr
  38. #define rIICADD        0x08+iic_base_addr
  39. #define rIICDS                0x0c+iic_base_addr
  40. #define rIICLC                0x10+iic_base_addr

  41. #define WRDATA      (1)
  42. #define POLLACK     (2)
  43. #define RDDATA      (3)
  44. #define SETRDADDR   (4)

  45. #define IICBUFSIZE 0x20

  46. #define DEVICE_NAME "iic"
  47. MODULE_LICENSE("Dual BSD/GPL");

  48. static int iic_major=254;
  49. static unsigned long gpecon_save, gpeup_save;
  50. module_param(iic_major, int, S_IRUGO);
  51. struct cdev cdev;
  52. static struct semaphore lock;
  53. static unsigned long slvAddr = 0xa0;

  54. static unsigned char _iicData[IICBUFSIZE];
  55. static volatile int _iicDataCount;
  56. static volatile int _iicStatus;
  57. static volatile int _iicMode;
  58. static int _iicPt;
  59. static unsigned long rd_addr = 0;
  60. static unsigned long wr_addr = 0;

  61. void Delay(int time)
  62. {
  63.         unsigned long PCLK = 50000000;
  64.         U32 val = (PCLK>>3)/1000-1;
  65.          
  66.         rTCFG0 &= ~(0xff<<8);
  67.         rTCFG0 |= 3<<8;                        //prescaler = 3+1
  68.         rTCFG1 &= ~(0xf<<12);
  69.         rTCFG1 |= 0<<12;                //mux = 1/2

  70.         rTCNTB3 = val;
  71.         rTCMPB3 = val>>1;                // 50%
  72.         rTCON &= ~(0xf<<16);
  73.         rTCON |= 0xb<<16;                //interval, inv-off, update TCNTB3&TCMPB3, start timer 3
  74.         rTCON &= ~(2<<16);                //clear manual update bit
  75.         while(time--) {
  76.                 while(rTCNTO3>=val>>1);
  77.                 while(rTCNTO3<val>>1);
  78.         };
  79. }

  80. static irqreturn_t iic_interrupt(int irq, void * dev_id)
  81. {
  82.             U32 iicSt,i;
  83.      
  84. //    rSRCPND = BIT_IIC;          //Clear pending bit
  85. //    rINTPND = BIT_IIC;
  86.     iicSt   = ioread32(rIICSTAT);  
  87.      
  88.     if(iicSt & 0x8){}           //When bus arbitration is failed.
  89.     if(iicSt & 0x4){}           //When a slave address is matched with IICADD
  90.     if(iicSt & 0x2){}           //When a slave address is 0000000b
  91.     if(iicSt & 0x1){}           //When ACK isn't received

  92.     switch(_iicMode)
  93.     {
  94.        case POLLACK:
  95.            _iicStatus = iicSt;
  96.            break;

  97.        case RDDATA:
  98.            if((_iicDataCount--)==0)
  99.            {
  100.                _iicData[_iicPt++] = ioread32(rIICDS);
  101.             
  102.                iowrite32(0x90, rIICSTAT);                 //Stop MasRx condition  
  103.                iowrite32(0xaf, rIICCON);                 //Resumes IIC operation.
  104.                Delay(1);                        //Wait until stop condtion is in effect.
  105.                                                 //Too long time...  
  106.                                                 //The pending bit will not be set after issuing stop condition.
  107.                break;     
  108.            }      
  109.            _iicData[_iicPt++] = ioread32(rIICDS);         //The last data has to be read with no ack.

  110.            if((_iicDataCount)==0)
  111.                iowrite32(0x2f,rIICCON);                  //Resumes IIC operation with NOACK.   
  112.            else  
  113.                iowrite32(0xaf,rIICCON);                  //Resumes IIC operation with ACK
  114.                break;

  115.         case WRDATA:
  116.         printk("write interrupt\n");
  117.             if((_iicDataCount--)==0)
  118.             {
  119.                 iowrite32(0xd0,rIICSTAT);                //Stop MasTx condition  
  120.                 iowrite32(0xaf,rIICCON);                //Resumes IIC operation.
  121.                 Delay(1);                       //Wait until stop condtion is in effect.
  122.                        //The pending bit will not be set after issuing stop condition.
  123.                 break;     
  124.             }
  125.             iowrite32(_iicData[_iicPt++], rIICDS);        //_iicData[0] has dummy.
  126.             for(i=0;i<10;i++);                  //for setup time until rising edge of IICSCL
  127.                
  128.             iowrite32(0xaf,rIICCON);                     //resumes IIC operation.
  129.             break;

  130.         case SETRDADDR:
  131. //          Uart_Printf("[ S%d ]",_iicDataCount);
  132.             if((_iicDataCount--)==0)
  133.                 break;                          //IIC operation is stopped because of IICCON[4]     
  134.             iowrite32(_iicData[_iicPt++], rIICDS);
  135.             for(i=0;i<10;i++);                  //For setup time until rising edge of IICSCL
  136.             iowrite32(0xaf,rIICCON);                     //Resumes IIC operation.
  137.             break;

  138.         default:
  139.             break;      
  140.     }
  141.     return IRQ_HANDLED;
  142. }

  143. static int iic_open(struct inode *inode, struct file *filp)
  144. {
  145.         int ret;
  146.         unsigned long gpe;
  147. //        if(!down_trylock(&lock))
  148.         {
  149. //                printk("open succeed.\n");
  150. //                printk("%x\n",S3C2410_TCFG0);
  151. //                unsigned long a=ioread32(S3C2410_TCFG0);
  152. //                printk("%x\n",a);
  153.                 gpe = ioread32(rGPECON);
  154.                 gpecon_save = gpe;
  155.                 iowrite32(gpe|0xa00000, rGPECON);
  156.                 gpe = ioread32(rGPEUP);
  157.                 gpeup_save = gpe;
  158.                 iowrite32(gpe|0xc000, rGPEUP);
  159.                  
  160.                 ret = request_irq(IRQ_IIC, iic_interrupt, IRQF_DISABLED, DEVICE_NAME,NULL);

  161.                 if (ret)
  162.                  {

  163.                         //DPRINTK("Register IRQ_TIMER0 failed!\n");
  164.                         printk("Register IRQ_IIC failed!\n");
  165.                         return ret;

  166.                 }
  167. //                enable_irq(IRQ_IIC);
  168.                  
  169.                 iowrite32(0xaf, rIICCON);
  170.                 iowrite32(0x10, rIICADD);
  171.                 iowrite32(0x10, rIICSTAT);
  172.                 iowrite32((1<<2)|(1<<0), rIICLC);
  173.                  
  174.                 rd_addr=0;
  175.                 wr_addr=0;
  176.                  
  177.                 printk("open succeed\n");
  178.                 return 0;
  179.                                  
  180.         }                 
  181. //        else
  182. //                return -EBUSY;
  183. }

  184. int iic_release(struct inode *inode, struct file *filp)
  185. {
  186. //        disable_irq(IRQ_IIC);
  187.         free_irq(IRQ_IIC,NULL);
  188.         iowrite32(gpecon_save,rGPECON);
  189.         iowrite32(gpeup_save,rGPEUP);
  190. //        up(&lock);
  191.         return 0;
  192. }

  193. static ssize_t iic_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
  194. {
  195.         _iicMode = SETRDADDR;
  196.         _iicPt = 0;
  197.         _iicData[0] = (unsigned char)rd_addr;
  198.         _iicDataCount = 1;
  199.          
  200.         iowrite32(slvAddr, rIICDS);
  201.         iowrite32(0xf0, rIICSTAT);
  202.          
  203.         while(_iicDataCount != -1);
  204.          
  205.         _iicMode = RDDATA;
  206.         _iicPt = 0;
  207.         _iicDataCount =1;
  208.          
  209.         iowrite32(slvAddr, rIICDS);
  210.         iowrite32(0xb0, rIICSTAT);
  211.         iowrite32(0xaf, rIICCON);
  212.          
  213.         while(_iicDataCount != -1)
  214.          
  215.         *buf = _iicData[1];
  216.         rd_addr++;
  217.         return 1;
  218.                  
  219. }


  220. static ssize_t iic_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
  221. {
  222.         _iicMode = WRDATA;
  223.         _iicPt = 0;
  224.         _iicData[0] = (unsigned char)wr_addr;
  225.         _iicData[1] = *buf;
  226.          
  227.         iowrite32(0xaf, rIICCON);
  228.         iowrite32(slvAddr, rIICDS);
  229.         iowrite32(0xf0, rIICSTAT);
  230.          
  231.         while(_iicDataCount != -1);
  232.          
  233.         _iicMode = POLLACK;
  234.          
  235.         while(1)
  236.         {
  237.                 iowrite32(slvAddr,rIICDS);
  238.                 _iicStatus = 0x100;
  239.                 iowrite32(0xf0, rIICSTAT);
  240.                 iowrite32(0xaf, rIICCON);
  241.                  
  242.                 while(_iicStatus == 0x100);
  243.                  
  244.                 if(!(_iicStatus&0x1))
  245.                         break;
  246.         }         
  247.         iowrite32(0xd0,rIICSTAT);
  248.         iowrite32(0xaf,rIICCON);
  249.         Delay(1);
  250.         wr_addr++;         
  251.         return 1;
  252. }

  253. static int iic_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  254. {
  255.         return 0;
  256. }

  257. static const struct file_operations iic_fops =
  258. {
  259.         .owner = THIS_MODULE,
  260.         .open = iic_open,
  261.         .read = iic_read,
  262.         .write = iic_write,
  263.         .ioctl = iic_ioctl,
  264.         .release = iic_release,
  265. };

  266. static int iic_init(void)
  267. {
  268.         int result;
  269.         dev_t devno = MKDEV(iic_major,0);

  270.         if(iic_major)
  271.         {
  272.                 result = register_chrdev_region(devno,1,"iic");
  273.         }
  274.           else  /* 动态分配设备号 */
  275.   {
  276.     result = alloc_chrdev_region(&devno, 0, 1, "iic");
  277.     iic_major = MAJOR(devno);
  278.   }   
  279.    
  280.   if (result < 0)
  281.     return result;

  282.   /*初始化cdev结构*/
  283.   cdev_init(&cdev, &iic_fops);
  284.   cdev.owner = THIS_MODULE;
  285.   cdev.ops = &iic_fops;
  286.    
  287.   /* 注_册字符设备 */
  288.   cdev_add(&cdev, MKDEV(iic_major, 0), 1);
  289.    
  290.           gpio_base_addr=ioremap(GPIO_PA,0x20);
  291.         if (gpio_base_addr == NULL) {
  292.                 printk(KERN_ERR "Failed to remap register block\n");
  293.                 return -ENOMEM;
  294.         }
  295.         iic_base_addr=ioremap(IIC_PA,0x20);
  296.         if (iic_base_addr == NULL) {
  297.                 printk(KERN_ERR "Failed to remap register block\n");
  298.                 iounmap(gpio_base_addr);
  299.                 return -ENOMEM;
  300.         }
  301.         timer_base_addr=ioremap(TIMER_PA,0x50);
  302.         if (timer_base_addr == NULL) {
  303.                 printk(KERN_ERR "Failed to remap register block\n");
  304.                 iounmap(gpio_base_addr);
  305.                 iounmap(iic_base_addr);
  306.                 return -ENOMEM;
  307.         }
  308.          
  309.           printk("iic_init ok!\n");
  310.     return 0;
  311. }

  312. static void iic_exit(void)
  313. {
  314.         iounmap(gpio_base_addr);
  315.         iounmap(iic_base_addr);
  316.         iounmap(timer_base_addr);         
  317.         cdev_del(&cdev);   /*注销设备*/
  318.   unregister_chrdev_region(MKDEV(iic_major, 0), 1); /*释放设备号*/
  319.           printk("iic_exit ok!\n");
  320. }

  321. module_init(iic_init);
  322. module_exit(iic_exit);


复制代码



上面的write函数每次往EEPROM中写一个字节的数据,而且每次写完wd_addr都会加1。
测试程序也附上:




  1. #include <unistd.h>
  2. #include <sys/stat.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <fcntl.h>
  6. #include <string.h>

  7. int main(void)
  8. {
  9.         int fd,i,j;
  10.         unsigned char data[256];
  11.         if((fd=open("/dev/iic",O_RDWR))<0)
  12.         {
  13.                 printf("open /dev/iic failed!\n");
  14.                 return -1;
  15.         }         
  16.          
  17.         for(i=0;i<256;i++)
  18.         {
  19.                 write(fd,&i,1);
  20.         }
  21.          
  22.         memset(data,0,sizeof(data));
  23.         for(i=0;i<256;i++)
  24.         {
  25.                 read(fd,&data[i],1);
  26.         }
  27.          
  28.         for(i=0;i<16;i++)
  29.     {
  30.         for(j=0;j<16;j++)
  31.             printf("%2x ",data[i*16+j]);
  32.         printf("\n");
  33.     }
  34.      
  35.         close(fd);
  36.         return 0;
  37.          
  38. }


复制代码


上面的驱动程序,写的时候,中断一直没有产生,不知道是什么原因。不知道是不是这种方法不可行。
希望大家不吝赐教,先谢过。

发表于 2011-9-8 15:24:31 | 显示全部楼层
建议还是用Linux I2C驱动框架来写
发表于 2011-9-8 15:26:01 | 显示全部楼层
建议还是用Linux I2C驱动框架来写
您需要登录后才可以回帖 登录 | 注册

本版积分规则

关闭

站长推荐 上一条 /1 下一条

关闭

小黑屋| 关于我们| 联系我们| 在线咨询| 隐私声明| EETOP 创芯网
( 京ICP备:10050787号 京公网安备:11010502037710 )

GMT+8, 2024-3-28 20:47 , Processed in 0.040094 second(s), 9 queries , Gzip On, Redis On.

eetop公众号 创芯大讲堂 创芯人才网
快速回复 返回顶部 返回列表