linux 驱动 --- I2C总线及驱动

I2C总线

I2C总线和 platform 总线非常类似，platform 总线初始化位置如下：

kernel_init();
    kernel_init_freeable();
        do_basic_setup();
            driver_init();
                platform_bus_init();

I2C总线是作为一个模块进行初始化

postcore_initcall(i2c_init);

　#define postcore_initcall(fn)       __define_initcall(fn, 2)

由此可见，platform 总线不可或缺，I2C总线是可以被裁剪的。

I2C总线的全局变量如下：

I2C适配器（控制器）设备、I2C设备

每一个soc上基本都会有一个或者多个I2C控制器，每一个I2C控制器下面接的就是SCL 和 SDA 两条线。I2C设备都是挂在这两条线下面的，这就是就硬件层的基本结构。

硬件层的上面就是Linux内核中的适配器驱动层，每一个soc厂家都会在Linux框架上实现自家I2C适配器设备的的驱动程序，这部分是由soc厂家的bsp工程师提供的。适配器的的驱动程序其实就是根据I2C控制器的寄存器操作实现了如何将数据送到I2C总线下的设备中去，以及怎么读取数据。厂家将这一层封装好，驱动工程师写驱动的时候就只需要根据具体的I2C设备来读写数据，不需要自己来实现I2C时序。简单点就说设备驱动只负责准备要发的数据，告诉适配器就可以了。至于怎么发就是厂家自己去实现了，毕竟只有他们才最熟悉自家的芯片。

 

I2C适配器就是根据设备树提供的I2C控制器信息配置芯片，如下i2c1

            i2c1: i2c@21a0000 {
                #address-cells = <1>;
                #size-cells = <0>;
                compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c";
                reg = <0x021a0000 0x4000>;
                interrupts = <GIC_SPI 36 IRQ_TYPE_LEVEL_HIGH>;
                clocks = <&clks IMX6UL_CLK_I2C1>;
                status = "disabled";
            };

 

&i2c1 {
    clock-frequency = <100000>;
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_i2c1>;
    status = "okay";

    magnetometer@e {
        compatible = "fsl,mag3110";
        reg = <0x0e>;
        vdd-supply = <&reg_peri_3v3>;
        vddio-supply = <&reg_peri_3v3>;
        position = <2>;
    };

    fxls8471@1e {
        compatible = "fsl,fxls8471";
        reg = <0x1e>;
        position = <0>;
        interrupt-parent = <&gpio5>;
        interrupts = <0 8>;
    };
};

 

static const struct of_device_id i2c_imx_dt_ids[] = {
    { .compatible = "fsl,imx1-i2c", .data = &imx1_i2c_hwdata, },
    { .compatible = "fsl,imx21-i2c", .data = &imx21_i2c_hwdata, },
    { .compatible = "fsl,vf610-i2c", .data = &vf610_i2c_hwdata, },
    { .compatible = "fsl,imx7d-i2c", .data = &imx7d_i2c_hwdata, },
    { /* sentinel */ }
};

static struct platform_driver i2c_imx_driver = {
    .probe = i2c_imx_probe,
    .remove = i2c_imx_remove,
    .driver = {
        .name = DRIVER_NAME,
        .pm = &i2c_imx_pm_ops,
        .of_match_table = i2c_imx_dt_ids,
        .acpi_match_table = i2c_imx_acpi_ids,
    },
    .id_table = imx_i2c_devtype,
};

static int __init i2c_adap_imx_init(void)

{

    return platform_driver_register(&i2c_imx_driver);

}

subsys_initcall(i2c_adap_imx_init);

i2c_adap_imx_init() 是芯片厂家提供的适配器驱动，设备和驱动匹配执行 i2c_imx_probe() ，内容有：

　　i2c_register_adapter() 添加 i2c_adapter_type 类型设备到 I2C 总线 （bus_add_device），即添加到链表 i2c_bus_type->p->klist_devices，此设备是适配器，即以上设备树的 i2c1

　　of_i2c_register_devices() --->i2c_new_client_device 添加 i2c_client_type 类型设备到 I2C 总线，即以上设备树的 magnetometer 和 fxls8471，是实际的I2C接口的外部芯片，具体的I2C设备。一个设备对应一个 i2c_client，每检测到一个 I2C 设备就会给这个 I2C 设备分配一个 i2c_client。

 

总结：设备树上有I2C适配器设备和I2C设备，都需要对应的驱动程序，I2C适配器设备的驱动程序由厂家提供，I2C设备由开发者自行实现。

I2C驱动

驱动程序实例

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/mod_devicetable.h>
#include <linux/log2.h>
#include <linux/bitops.h>
#include <linux/jiffies.h>
#include <linux/of.h>
#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/platform_device.h>
#include <asm/ioctl.h>
#include <asm/uaccess.h>
 
#define MY_DRV_NAME     "at24cxx"
#define MY_CLASS        "at24cxxClass"
 
 
static int AT24CXX_SIZE = 256;
 
 
struct my_at24_dev {
    struct i2c_client *    m_client; 
    struct class *         m_eeprom_class;
    int                 m_major;
    struct mutex          m_mutex;
};
static struct my_at24_dev * my_at24_devp;
 
unsigned int i2c_RxAddr;
 
 
 
static const struct i2c_device_id my_at24_ids[] = {
    {"my_24cxx", 0},  //和设备树节点 .compatible 属性值匹配
    { },
 
};
 
static ssize_t my_at24c_read(struct file * flip, char __user * buff, size_t count, loff_t * offset)
{
    ssize_t retval = 0;
    unsigned char addr = i2c_RxAddr&0xff;
 
    unsigned char recv_buff[512];
    struct i2c_msg msgs[2];
    struct my_at24_dev * at24_dev = (struct my_at24_dev *)flip->private_data;
    //printk(KERN_INFO "%s enter,count=%d,i2c_RxAddr[0]=%d,i2c_RxAddr[1]=%d\r\n", __FUNCTION__,count,i2c_RxAddr[0],i2c_RxAddr[1]);
    mutex_lock(&at24_dev->m_mutex);
    /*first write the register offset address */
    msgs[0].addr = at24_dev->m_client->addr;    // address of slave device
    msgs[0].flags = 0;    // 0:write, 1:read
    msgs[0].len = 1;
    msgs[0].buf = &addr;
 
    msgs[1].addr = at24_dev->m_client->addr;    
    msgs[1].flags = 1;    
    msgs[1].len = sizeof(recv_buff);
    msgs[1].buf = recv_buff;
 
    retval = i2c_transfer(at24_dev->m_client->adapter, msgs, ARRAY_SIZE(msgs));
    //printk(KERN_INFO "%s: i2c_transfer return %d\r\n", __FUNCTION__,retval);
    if(retval != 2){
        printk(KERN_INFO "my_at24c_read failed");
        goto err;
    }
    
    retval = copy_to_user(buff, recv_buff, count);
    retval = count;
    
err:    
    mutex_unlock(&at24_dev->m_mutex);
    return retval;
}
 
static ssize_t my_at24c_write(struct file *flip, const char __user *buff, size_t count, loff_t *offset)
{
    ssize_t retval = 0;
    unsigned char send_buff[512];
    struct i2c_msg msgs[1];
    unsigned int len = 0;
    struct my_at24_dev * at24_dev = (struct my_at24_dev *)flip->private_data;
    mutex_lock(&at24_dev->m_mutex);
 
    if(count > AT24CXX_SIZE){
        retval = -1;
        goto err;
    }
    //offset address
    send_buff[len++] = i2c_RxAddr&0xff;
 
    retval = copy_from_user(&send_buff[len], buff, count);
    msgs[0].addr = at24_dev->m_client->addr;  // address of slave device
    msgs[0].flags = 0;                        // 0:write, 1:read
    msgs[0].len = len+count;
    msgs[0].buf = send_buff;
    retval = i2c_transfer(at24_dev->m_client->adapter, msgs, ARRAY_SIZE(msgs));
    if(retval > 0){
        retval = 0;
        //printk(KERN_INFO "my_at24c_write successful\r\n");
    }
    
    
err:    
    mutex_unlock(&at24_dev->m_mutex);
    return retval;
}
static loff_t  my_at24c_llseek(struct file * flip, loff_t offset, int flag)
{
    loff_t retval = 0;
    struct my_at24_dev * at24_dev = (struct my_at24_dev *)flip->private_data;
    //printk(KERN_INFO "%s enter,offset=%d, flag=%d\r\n", __FUNCTION__, (int)offset, flag);
 
    mutex_lock(&at24_dev->m_mutex);
    if(flag == SEEK_SET){
        if(offset >= AT24CXX_SIZE){
            i2c_RxAddr = 0;
        }else{
            i2c_RxAddr = offset;
        }
        
    }
    mutex_unlock(&at24_dev->m_mutex);
    return retval;
}
static int my_at24c_open(struct inode * node, struct file * flip)
{
    mutex_init(&my_at24_devp->m_mutex);
    i2c_RxAddr = 0;
    flip->private_data = my_at24_devp;              //将at24结构存到flip中，便于后续读写使用
    return 0;
}
 
static long my_at24c_ioctl(struct file *flip, unsigned int cmd, unsigned long arg)
{
    return 0;
}
 
static int my_at24c_release (struct inode *inodep, struct file *flip) 
{ 
   flip->private_data = NULL; 
   i2c_RxAddr = 0;
   return 0; 
}
 
struct file_operations my_at24_fops = {
    .owner = THIS_MODULE,
    .llseek = my_at24c_llseek,
    .read =   my_at24c_read,
    .write=   my_at24c_write,
    .open =   my_at24c_open,
    .compat_ioctl = my_at24c_ioctl,
    .release =      my_at24c_release, 
};
 
/*will be called when the device and driver matched success*/
static int my_at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int retval = 0;
    
    my_at24_devp = kmalloc(sizeof(struct my_at24_dev), GFP_KERNEL);
    if(!my_at24_devp){
        retval = -ENOMEM;
        goto err;
    }
    memset (my_at24_devp, 0, sizeof (struct my_at24_dev));
    my_at24_devp->m_client = client;
 
    //register char device
    my_at24_devp->m_major = register_chrdev(0, MY_DRV_NAME, &my_at24_fops);   
    if(my_at24_devp->m_major < 0){
        printk (KERN_NOTICE "register_chrdev failed return %d",my_at24_devp->m_major); 
        goto err;
    }
 
    //create class
    my_at24_devp->m_eeprom_class = class_create(THIS_MODULE, MY_CLASS);
    if (IS_ERR(my_at24_devp->m_eeprom_class)) {
        printk(KERN_ERR "%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
        unregister_chrdev(my_at24_devp->m_major, MY_DRV_NAME);
        retval = -1;
        goto err;
     }
    
    device_create(my_at24_devp->m_eeprom_class, NULL, MKDEV(my_at24_devp->m_major,0), NULL, "%s%d",MY_DRV_NAME, 0);  // 在 /dev下创建 MY_DRV_NAME 设备文件（/dev/Myled0, 1, ...)
    
err:
    return retval;
}
 
 
static int my_at24_remove(struct i2c_client *client)
{
    int retval = 0;
    device_destroy(my_at24_devp->m_eeprom_class, MKDEV(my_at24_devp->m_major, 0));
    class_destroy(my_at24_devp->m_eeprom_class);
    unregister_chrdev(my_at24_devp->m_major, MY_DRV_NAME);
    kfree (my_at24_devp); 
    return retval;
}
 
 
 
static struct i2c_driver my_at24_driver = {
    .driver = {
        .name = "at24cxx",
        .owner = THIS_MODULE,
    },
    .probe = my_at24_probe,
    .remove = my_at24_remove,
    .id_table = my_at24_ids,
};
 
 
static int __init my_at24_init(void)
{
    return i2c_add_driver(&my_at24_driver);
}
module_init(my_at24_init);
 
static void __exit my_at24_exit(void)
{
    i2c_del_driver(&my_at24_driver);
}
module_exit(my_at24_exit);
 
MODULE_DESCRIPTION("Driver for I2C EEPROM");
MODULE_AUTHOR("Daniel.Dai");
MODULE_LICENSE("GPL");