Linux下DM644x设备驱动I2C之总线驱动


Linux DM6441下I2C设备驱动的开发 和常用的Linux I2C的驱动开发一样，主要包括总线Bus驱动，以及相应的设备驱动开发。 总线驱动和CPU的关系较为密切，涉及到相关硬件的操作。 本文以Linux2.6.1和Dm6441简单解析一下整个驱动的编写架构。   1.   总线驱动 涉及到总线驱动的相关代码在drivers/i2c/bussses下面，该目录下是各CPU的I2C模块涉及到的内容，这里我们选择i2c-davinci.c文件 总线驱动中Init函数i2c_davinci_init如下：
  1. static int __init i2c_davinci_init(void)  
  2. {  
  3.     int status;  
  4.     struct device   *dev = NULL;  
  5.   
  6.     DEB0("%s %s", __TIME__, __DATE__);  
  7.   
  8.     DEB1("i2c_davinci_init()");  
  9.   
  10. #if 0  
  11.     if (i2c_davinci_busFreq > 200)  
  12.         i2c_davinci_busFreq = 400;  /*Fast mode */  
  13.     else  
  14.         i2c_davinci_busFreq = 100;  /*Standard mode */  
  15. #endif  
  16.   
  17.     i2c_clock = clk_get (dev, "I2CCLK"); //获取I2C输入时钟批频率27MHz  
  18.   
  19.     if (IS_ERR(i2c_clock))  
  20.             return -1;  
  21.   
  22.     clk_use (i2c_clock);  
  23.     clk_enable (i2c_clock);  
  24.     i2c_davinci_inputClock = clk_get_rate (i2c_clock);    //获取I2C输入时钟批频率27MHz  
  25.   
  26.     DEB1 ("IP CLOCK = %ld", i2c_davinci_inputClock);  
  27.   
  28.     memset(&i2c_davinci_dev, 0, sizeof(i2c_davinci_dev));  
  29.     init_waitqueue_head(&i2c_davinci_dev.cmd_wait);  
  30.   
  31.     i2c_davinci_dev.regs = (davinci_i2cregsovly)I2C_BASE;      //I2C控制器相关寄存器所在地址  
  32.   
  33.     status = (int)request_region(I2C_BASE, I2C_IOSIZE, MODULE_NAME); //申请一块IO输入输出区域#define MODULE_NAME "DaVinci I2C"  
  34.     if (!status) {  
  35.         i2c_err("I2C is already in use\n");  
  36.         return -ENODEV;  
  37.     }  
  38.   
  39.     status = request_irq(IRQ_I2C, i2c_davinci_isr, 0, "i2c",  
  40.                  &i2c_davinci_dev);  //申请I2C中断号IRQ_I2C=39  
  41.     if (status) {  
  42.         i2c_err("failed to request I2C IRQ");  
  43.         goto do_release_region;  
  44.     }  
  45.   
  46.     i2c_set_adapdata(&i2c_davinci_adap, &i2c_davinci_dev);  //adap设备的驱动程序私有数据i2c_davinci_adap->dev->driver_data =i2c_davinci_dev  
  47.     status = i2c_add_adapter(&i2c_davinci_adap);    //I2C上添加adapter  
  48.     if (status) {  
  49.         i2c_err("failed to add adapter");  
  50.         goto do_free_irq;  
  51.     }  
  52.   
  53.     i2c_davinci_reset(&i2c_davinci_dev);   //完成I2C相关寄存器的初始化  
  54.   
  55.     if (driver_register(&davinci_i2c_driver) != 0)            // I2C驱动注册  
  56.         printk(KERN_ERR "Driver register failed for davinci_i2c\n");  
  57.     if (platform_device_register(&davinci_i2c_device) != 0) {  
  58.         printk(KERN_ERR "Device register failed for i2c\n");  
  59.         driver_unregister(&davinci_i2c_driver);  
  60.     }  
  61.   
  62.     return 0;  
  63.   
  64.       do_free_irq:  
  65.     free_irq(IRQ_I2C, &i2c_davinci_dev);  
  66.       do_release_region:  
  67.     release_region(I2C_BASE, I2C_IOSIZE);  
  68.   
  69.     return status;  
  70. }  

操作主要围绕以下4个结构体展开：

  1. static struct i2c_algorithm i2c_davinci_algo = {            //主要涉及相关的I2C通信协议以及数据的传输和接受  
  2.     .name = "DAVINCI I2C algorithm",  
  3.     .id = I2C_ALGO_EXP,  
  4.     .master_xfer = i2c_davinci_xfer,  
  5.     .smbus_xfer = NULL,  
  6.     .slave_send = NULL,  
  7.     .slave_recv = NULL,  
  8.     .algo_control = NULL,  
  9.     .functionality = i2c_davinci_func,  
  10. };  
  11.   
  12. static struct i2c_adapter i2c_davinci_adap = {       //对I2C通信协议的封装，定义的适配器实例  
  13.     .owner = THIS_MODULE,  
  14.     .name = "DAVINCI I2C adapter",  
  15.     .id = I2C_ALGO_EXP,  
  16.     .algo = &i2c_davinci_algo,  
  17.     .algo_data = NULL,  
  18.     .client_register = NULL,  
  19.     .client_unregister = NULL,  
  20. };  
  21.   
  22. static struct device_driver davinci_i2c_driver = {            //达芬奇的设备驱动  
  23.     .name = "davinci_i2c",  
  24.     .bus = &platform_bus_type,  
  25.     .remove = davinci_i2c_remove,  
  26. };  
  27.   
  28. static struct platform_device davinci_i2c_device = {         //定义的达芬奇平��设备  
  29.     .name = "i2c",  
  30.     .id = -1,  
  31.     .dev = {  
  32.         .driver = &davinci_i2c_driver,  
  33.         .release = davinci_i2c_device_release,  
  34.         },  
  35. };  

结合以上两段代码，可以知道以下内容

1 .在模块初始化函数中完成适配器与设备。的连接了设备驱动davinci_i2c_driver和平台设备davinci_i2c_device的注册

2.获取I2C相关端口的申请，I2C相应寄存器的物理首地址0x01C21000，完成了I2C模块初始化操作以及IRQ_I2C=39的中断申请。

在这里对I2C模块的初始化进行解析，内容如下：

  1. static int i2c_davinci_reset(struct i2c_davinci_device *dev)  
  2. {  
  3.     u16 psc;  
  4.     u32 clk;  
  5.   
  6.         DEB1("i2c: reset called");  
  7.   
  8.     /* put I2C into reset */  
  9.     dev->regs->icmdr &= ~DAVINCI_I2C_ICMDR_IRS_MASK; //首先需复位I2C模块  
  10.   
  11.         /* NOTE: I2C Clock divider programming info  
  12.      * As per I2C specs the following formulas provide prescalar  
  13.          * and low/high divider values  
  14.      *  
  15.      * input clk --> PSC Div -----------> ICCL/H Div --> output clock  
  16.      *                       module clk  
  17.      *  
  18.      * output clk = module clk / (PSC + 1) [ (ICCL + d) + (ICCH + d) ]  
  19.      *  
  20.      * Thus,  
  21.      * (ICCL + ICCH) = clk = (input clk / ((psc +1) * output clk)) - 2d;  
  22.      *  
  23.      * where if PSC == 0, d = 7,  
  24.      *       if PSC == 1, d = 6  
  25.      *       if PSC > 1 , d = 5  
  26.      */  
  27.   
  28.     psc = 26; /* To get 1MHz clock */  
  29.   
  30.   clk = ((i2c_davinci_inputClock/(psc + 1)) / (i2c_davinci_busFreq * 1000)) - 10; //i2c_davinci_busFreq=20  
  31.   
  32.     dev->regs->icpsc = psc;  //PSC寄存器写26，即预分频数27  
  33.     dev->regs->icclkh = (50 * clk) / 100; /* duty cycle should be 50% */  
  34.     dev->regs->icclkl = (clk - dev->regs->icclkh); //高低电平配置内容  
  35.   
  36.     DEB1("CLK  = %d", clk);  
  37.     DEB1("PSC  = %d", dev->regs->icpsc);  
  38.     DEB1("CLKL = %d", dev->regs->icclkl);  
  39.     DEB1("CLKH = %d", dev->regs->icclkh);  
  40.   
  41.     /* Set Own Address: */  
  42.     dev->regs->icoar = i2c_davinci_own_addr; //oxa  
  43.   
  44.     /* Enable interrupts */  
  45.     dev->regs->icimr = I2C_DAVINCI_INTR_ALL;   //所有中断都使能  
  46.   
  47.     /* Take the I2C module out of reset: */  
  48.     dev->regs->icmdr |= DAVINCI_I2C_ICMDR_IRS_MASK;    //使能I2C模块  
  49.   
  50.     return 0;  
  51. }  

主要完成Dm6441上I2C的总线时钟的配置。以及做一些中断使能的初始化。在这里都是对dev->regs这个结构体指针的内容

该结构体的实际内容如下：

  1. typedef struct {  
  2.     u16 icoar;  
  3.     u8 rsvd0[2];  
  4.     u16 icimr;  
  5.     u8 rsvd1[2];  
  6.     u16 icstr;  
  7.     u8 rsvd2[2];  
  8.     u16 icclkl;  
  9.     u8 rsvd3[2];  
  10.     u16 icclkh;  
  11.     u8 rsvd4[2];  
  12.     u16 iccnt;  
  13.     u8 rsvd5[2];  
  14.     u16 icdrr;  
  15.     u8 rsvd6[2];  
  16.     u16 icsar;  
  17.     u8 rsvd7[2];  
  18.     u16 icdxr;  
  19.     u8 rsvd8[2];  
  20.     u16 icmdr;  
  21.     u8 rsvd9[2];  
  22.     u16 icivr;  
  23.     u8 rsvd10[2];  
  24.     u16 icemdr;  
  25.     u8 rsvd11[2];  
  26.     u16 icpsc;  
  27.     u8 rsvd12[2];  
  28.     u16 icpid1;  
  29.     u8 rsvd13[2];  
  30.     u16 icpid2;  
  31.     u8 rsvd14[14];  
  32.     u32 ipcfunc;  
  33.     u32 icpdir;  
  34.     u32 icpdin;  
  35.     u32 icpdout;  
  36.     u32 icpdset;  
  37.     u32 icpdclr;  
  38. } davinci_i2cregs;  
  39.   
  40. /**************************************************************************\  
  41. * Overlay structure typedef definition  
  42. \**************************************************************************/  
  43. typedef volatile davinci_i2cregs *davinci_i2cregsovly;  

涉及的内容是DM6441 I2C模块的相关寄存器。在获取寄存器的物理首地址之后，就可以直接对这个结构体实例的内容写数值，该结构体被包含在以下结构体中

  1. struct i2c_davinci_device {  
  2.     int cmd_complete, cmd_err;  
  3.     wait_queue_head_t cmd_wait;  
  4.     u8 *buf;  
  5.     size_t buf_len;  
  6.     davinci_i2cregsovly regs;  
  7. };  

这里的另一块内容是添加适配器到I2C驱动中使用i2c_add_adapter函数完成i2c_davinci_adap（该结构体实例内容见上述代码）

  1. int i2c_add_adapter(struct i2c_adapter *adap)  
  2. {  
  3.     int id, res = 0;  
  4.     struct list_head   *item;  
  5.     struct i2c_driver  *driver;  
  6.   
  7.     down(&core_lists);  
  8.   
  9.     if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {  
  10.         res = -ENOMEM;  
  11.         goto out_unlock;  
  12.     }  
  13.   
  14.     res = idr_get_new(&i2c_adapter_idr, NULL, &id);  
  15.     if (res < 0) {  
  16.         if (res == -EAGAIN)  
  17.             res = -ENOMEM;  
  18.         goto out_unlock;  
  19.     }  
  20.   
  21.     adap->nr =  id & MAX_ID_MASK;  
  22.     init_MUTEX(&adap->bus_lock);  
  23.     init_MUTEX(&adap->clist_lock);  
  24.     list_add_tail(&adap->list,&adapters);  
  25.     INIT_LIST_HEAD(&adap->clients);  
  26.   
  27.     /* Add the adapter to the driver core.  
  28.      * If the parent pointer is not set up,  
  29.      * we add this adapter to the host bus.  
  30.      */  
  31.     if (adap->dev.parent == NULL)  
  32.         adap->dev.parent = &platform_bus;  
  33.     sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);  
  34.     adap->dev.driver = &i2c_adapter_driver;   //适配器的设备驱动指向i2c_adapter_driver  
  35.     adap->dev.release = &i2c_adapter_dev_release;  
  36.     device_register(&adap->dev);                       //适配器设备注册  
  37.     device_create_file(&adap->dev, &dev_attr_name);  
  38.   
  39.     /* Add this adapter to the i2c_adapter class */  
  40.     memset(&adap->class_dev, 0x00, sizeof(struct class_device));  
  41.     adap->class_dev.dev = &adap->dev;  
  42.     adap->class_dev.class = &i2c_adapter_class;  
  43.     strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);  
  44.     class_device_register(&adap->class_dev);  
  45.   
  46.     /* inform drivers of new adapters */  
  47.     list_for_each(item,&drivers) {  
  48.         driver = list_entry(item, struct i2c_driver, list);  
  49.         if (driver->flags & I2C_DF_NOTIFY)  
  50.             /* We ignore the return code; if it fails, too bad */  
  51.             driver->attach_adapter(adap);  
  52.     }  
  53.   
  54.     dev_dbg(&adap->dev, "registered as adapter #%d\n", adap->nr);  
  55.   
  56. out_unlock:  
  57.     up(&core_lists);  
  58.     return res;  
  59. }  

在该函数内主要完成适配器结构体中成员变量设备dev的初始化，紧接着完成适配器这个抽象设备的注册，再完成适配器设备类的注册以及相关设备节点的生成。

  • 1
  • 2
  • 3
  • 下一页

相关内容