linux 下IIC驱动程序

驱动代码如下:
iic.c文件

/*模仿这个程序 : linux/drivers/i2c/busses/i2c-s3c2410.c
*左边的适配器使用内核提供的代码
*本程序实现 右边的 驱动代码
详细讨论一下linux中IIC的体系结构

*/

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/mutex.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/device.h>

struct i2c_client * at24c02_client;
static struct class * at24c02_class;
static struct device * at24c02_device;
static struct i2c_driver at24c02_driver; /*把下面定义的结构体，提前声明一下*/
static int major = 0; /*定义主设备号*/

static unsigned short ignore[] = { I2C_CLIENT_END }; //省略
static unsigned short normal_addr[] = { 0x50, I2C_CLIENT_END };//正常地址，第1个:设备地址，第2个: #define I2C_CLIENT_END        0xfffeU
/* 地址值是7位:1010000 ,所以是0x50，不是0xA0*/ /* 改为0x60的话, 由于不存在设备地址为0x60的设备, 所以at24cxx_detect不被调用 */
/*
static unsigned short force_addr[] = {ANY_I2C_BUS, 0x60, I2C_CLIENT_END}; //#define ANY_I2C_BUS        0xffff 指定这个设备让哪个IIC总线适配器来支持它。
static unsigned short * forces[] = {force_addr, NULL};
*/

static struct i2c_client_address_data addr_data = /*设备地址*/
{
        .normal_i2c    = normal_addr, /* 要发出S信号和设备地址并得到ACK信号,才能确定存在这个设备,才会调用 at24c02_detect 函数 */
        .probe        = ignore, /*省略*/
        .ignore        = ignore,
        //.forces = forces, /* 不发送S信号，不得到ACK信号，强制认为存在这个设备(同时存在 normal_i2c 和 forces时，优先使用 forces)*/
};

static int at24c02_release(struct inode *inode, struct file *file)
{
        /*printk("Driver : at24c02_release Called!\n");*/
        return 0;
}

static int at24c02_open(struct inode *inode, struct file *file)
{
        /*printk("Driver : at24c02_open Called!\n");*/
        return 0;
}

/*
*读取函数 : 应用程序从at24c02指定的内部地址中，读取数据。
*读取函数要麻烦一点 : 需要先写 at24c02的内部地址，再读取这个地址上的数据。
* 所以，需要传输2次消息
*用 buf[0] : 来表示 地址 (at24c02的内部地址), 内核读取到的数据后，再用这个字节传递出去就行，所以只需要buf[0]
*/
static ssize_t at24c02_read(struct file *file, char __user *buf, size_t size, loff_t * offset)
{
        unsigned char address;
        unsigned char data;

        struct i2c_msg msgs[2]; /*i2c传输的消息 : 写1次，读1次*/
        int ret = -1;

        /*printk("Driver : at24c02_read Called!\n");*/

        if(size != 1)
        {
                return -EINVAL; /*这些返回码都定义在一个统一的头文件中*/
        }
        copy_from_user(&address, buf, 1); /*把应用程序的数据，拷贝到内核*/
        /*printk("Driver : address=[%d]\n", address);*/

        /*1,读取之前，要先写at24c02的内部地址*/
        /*数据传输3要素 : 源， 目的， 长度*/
        msgs[0].addr = at24c02_client->addr; /*目的 : at24c02的固化地址*/
        msgs[0].buf = &address;                             /*源 : at24c02的内部地址值*/
        msgs[0].len = 1;                                             /*长度 : 地址 = 1个字节*/
        msgs[0].flags = 0;                                         /*0:写*/

        /*2,写地址之后，就可以启动读操作了*/
        /*数据传输3要素 : 源， 目的， 长度*/
        msgs[1].addr = at24c02_client->addr; /*源 : at24c02的固化地址，从这个设备读取数据*/
        msgs[1].buf = &data;                                     /*目的 : 从at24c02读取到的数据,存放在这里*/
        msgs[1].len = 1;                                             /*长度 : 地址 = 1个字节*/
        msgs[1].flags = I2C_M_RD;                         /*0:写 I2C_M_RD : 读*/

        ret = i2c_transfer(at24c02_client->adapter, msgs, 2); /*启动i2c传输, 2个消息*/
        /*printk("Driver : ret=[%d]\n", ret);*/
        if(ret == 2) /*成功的消息个数 : 表示2个消息成功*/
        {
                copy_to_user(buf, &data, 1); /*把内核的数据，拷贝到应用程序*/
                return 1; /*表示成功读取一个数据*/
        }
        else
        {
                return -EIO; /*表示IO错误*/
        }

        return 0;
}

/*
*写入函数:应用程序将数据，写入at24c02中
*用 buf[0] : 来表示 地址 (at24c02的内部地址) 用 buf[1] : 来表示 数据 (将写入at24c02的数据)
*所以至少需要2个字节来给内核传递数据。
*/
static ssize_t at24c02_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
{
        unsigned char val[2];
        struct i2c_msg msgs[1]; /*i2c传输的消息*/
        int ret = 0;

        /*printk("Driver : at24c02_write Called!\n");*/

        if(size != 2) /*应用程序写的字节，一定是2个*/
        {
                return -EINVAL; /*表示输入的值错误*/
        }
        copy_from_user(val, buf, 2); /*把应用程序的数据，拷贝到内核*/
        /*printk("Driver : addr val[0]=[%d]\n", val[0]);*/
        /*printk("Driver : data val[1]=[%d]\n", val[1]);*/

        /*数据传输3要素 : 源， 目的， 长度*/
        msgs[0].addr = at24c02_client->addr; /*目的 : at24c02的固化地址*/
        msgs[0].buf = val;                                         /*源 : at24c02的内部地址 + 将要写入的数据*/
        msgs[0].len = 2;                                             /*长度 : 地址+数据 = 2个字节*/
        msgs[0].flags = 0;                                         /*0:写*/

        ret = i2c_transfer(at24c02_client->adapter, msgs, 1); /*启动i2c传输 : 最后一个参数表示消息个数*/
        /*printk("Driver : ret=[%d]\n", ret);*/
        if(ret == 1) /*成功的消息个数 : 表示1个消息成功*/
        {
                return 2; /*表示成功写入2个数据*/
        }
        else
        {
                return -EIO; /*表示IO错误*/
        }
}

/*定义文件操作结构体*/
static struct file_operations at24c02_fops = {
        .owner = THIS_MODULE,
        .read = at24c02_read,
        .write = at24c02_write,
        .open = at24c02_open,
        .release = at24c02_release,
};

/*
*函数功能 : 探测到硬件设备存在之后，执行的函数,要完成连接client设备的过程。
*detect : 侦查
*/
static int at24c02_detect_devices(struct i2c_adapter *adapter, int address, int kind)
{
        printk("at24c02_detect_devices\n");

        /* 构造一个i2c_client结构体: 以后收发数据时就会用到这个结构体了 */
        at24c02_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        at24c02_client->addr = address; /*设备地址*/
        at24c02_client->adapter = adapter; /*连接左边的 适配器*/
        at24c02_client->driver = &at24c02_driver; /*连接右边的 驱动*/
        strcpy(at24c02_client->name, "at24c02");
        i2c_attach_client(at24c02_client); /*连接右边的驱动，这样左右两边都联系起来了*/

        /*注册一个字符设备*/
        major = register_chrdev(0, "at24c02", &at24c02_fops);
        /*这个是2.4内核老方法注册:
        次设备号0到255都对应这一个 file_operations 结构体
        2.6内核使用新方法注册:就是把上面1步拆分成4步
        */

        printk("major=[%d]\n", major);
        /*自动创建设备节点:即在/dev 目录下，自动创建字符设备文件*/
        /*注意: 2.6.13内核是用的class_device_create(); 2.6.30内核是用的device_create();*/
        at24c02_class = class_create(THIS_MODULE, "at24c02");
        at24c02_device = device_create(at24c02_class, NULL, MKDEV(major, 0), NULL, "at24c02");

        return 0;
}

/*
*函数功能 : driver层，尝试连接I2C总线驱动程序的适配器adpater
*/
static int at24c02_attach_driver(struct i2c_adapter *adapter)
{
        /*
        *函数功能 : 如果发现 addr_data 描述的设备存在，则调用 at24c02_detect 函数。
        */
        return i2c_probe(adapter, &addr_data, at24c02_detect_devices);
}

/*
*函数功能 : driver层，连上I2C总线驱动程序适配器adpater的client设备,这里断开来。
*/
static int at24c02_detach_client(struct i2c_client *client)
{
        printk("at24c02_detach_client\n");
        device_destroy(at24c02_class, MKDEV(major, 0));
        class_destroy(at24c02_class);
        unregister_chrdev(major, "at24c02");

        i2c_detach_client(client);
        kfree(i2c_get_clientdata(client));

        return 0;
}

/*1,分配一个 i2c_driver 结构体 : 是核心结构体，我们这里就不分配了，定义的时候直接填值*/
/*2,设置 i2c_driver 结构体
*attach : 附上
*detach : 分离
*/
static struct i2c_driver at24c02_driver =
{
        .driver =
        {
                .name    = "at24c02",
        },
        .attach_adapter = at24c02_attach_driver, // 它直接调用 i2c_probe(adap, 设备地址, 发现这个设备后要调用的函数);
        .detach_client = at24c02_detach_client, // 卸载这个驱动后,如果之前发现能够支持的设备,则调用它来清理
};

static int __init at24c02_init(void)
{
        /*3,注册一个 i2c_driver 结构体
        *会自动调用at24c02_driver结构里面的成员函数 attach_adapter=at24c02_attach。
        */
        i2c_add_driver(&at24c02_driver);
        return 0;
}

static void __exit at24c02_exit(void)
{
        /*注销 i2c_driver 结构体
        *会自动调用at24c02_driver结构里面的成员函数 detach_client=at24c02_detach
        */
        i2c_del_driver(&at24c02_driver);
}

module_init(at24c02_init);
module_exit(at24c02_exit);
MODULE_AUTHOR("WangXiancai");
MODULE_LICENSE("GPL");

/*
测试1th:
1. # insmod iic.ko
i2c-adapter i2c-0: Invalid probe address 0xa0 //无效的地址0xa0，这里地址只有前面7位，所以改成0x50了。
   观察输出信息
修改:normal_addr里的0x50为0x60
   编译加载，观察输出信息
2. # insmod iic.ko
s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)
s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)
at24c02_detect

错误信息在这里：
drivers/i2c/busses/i2c-s3c2410.c#L502
上面一行调用了s3c24xx_i2c_set_master，这个函数在这：
drivers/i2c/busses/i2c-s3c2410.c#L468
何以看到S3C2410_IICSTAT这个寄存器的S3C2410_IICSTAT[5]这一位总是显示busy,所以就失败了。

我没用过s3c2440,你自己看看硬件手册，什么原因会导致S3C2410_IICSTAT仅存其显示一直忙碌，
是因为没有正确初始化还是其它软件在占用？
这里找到原因如下 : ov9650一直占用着。解决方法如下 :
文件\nfs_2.6.30\etc\init.d\rcS 中屏蔽掉下面这行就OK了 :
### insmod /lib/ov9650.ko //注释掉就行了

3.# rmmod iic.ko //卸载这个驱动函数
断开函数 at24c02_detach_client 里面的打印语句printk("at24c02_detach\n"); 不会被调用，为什么？
探测函数 at24c02_detect_devices 这一句加上之后 i2c_attach_client(new_client); 就调用上面的printk语句了。
也就是说，总线必须连上 具体的client设备，才会在卸载的时候，调用断开client设备的函数。

4,加上 class_create device_create 之后,可自动创建设备节点。
# insmod iic.ko
at24c02_detect_devices
major=[251]
# ls -lrt /dev/at24c*
crw-rw---- 1 root     root      252, 0 Jan  1 01:58 /dev/at24c02
卸载之后，设备节点就会去掉了。

5,加入读写函数之后，再测如下:
还要创建2个设备文件：他们主设备号相同，次设备号不同
# mknod /dev/at24c02 c 252 0


*/

makefile文件

# File: Makefile
# wangxiancai

MODEXT = ko
# INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.13/wxc/driver/chardriver/ko
INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.30/wxc/driver/chardriver/ko
# CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-
CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-
# KERNELDIR=/home/wangxc/linux/kernel/kernel-2.6.13
KERNELDIR=/home/wangxc/linux/kernel/kerner-2.6.30

CC= $(CROSS)gcc
LD= $(CROSS)ld

#############################################################################
# Compiler Flags
#############################################################################
EXTRA_CFLAGS += -I$(KERNELDIR)/include
#############################################################################
# Make Targets
#############################################################################
obj-m := iic.o
default:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
# Otherwise we were called directly from the command line; invoke the kernel build system.

install: default
    cp -rf $(PWD)/iic.$(MODEXT) $(INSTALLDIR)

clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions *.bak modules.order Module.symvers

应用代码如下:
iictest.c文件

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char * * argv)
{
        int fd = 0;
        unsigned char buf[2];
        int ret = -1;

        if((argc != 3) && (argc != 4))
        {
                printf("%s r|R addr\n", argv[0]);
                printf("%s w|W addr val\n", argv[0]);
                return -1;
        }

        fd = open("/dev/at24c02", O_RDWR);
        if(fd < 0)
        {
                perror("open /dev/at24c02");
                exit(-1);
        }

        if(strcmp(argv[1], "r") == 0)
        {
                buf[0] = strtoul(argv[2], NULL, 0); /*将字符串转换成无符号长整型数*/
                printf("read address = [%d]\n", buf[0]);
                ret = read(fd, buf, 1); /*注意 : read调用时，buf[0]表示读取的地址，read返回时，buf[0]存储读取的值*/
                if(ret == 1) /*表示成功读取1个字节*/
                {
                        printf("data = [%d]\n", buf[0]);
                }
                else
                {
                        printf("write err ret = [%d]\n", ret);
                }
        }
        else if(strcmp(argv[1], "w") == 0)
        {
                buf[0] = strtoul(argv[2], NULL, 0);
                buf[1] = strtoul(argv[3], NULL, 0);
                /*printf("APP : buf[0] = [%d]\n", buf[0]);*/
                /*printf("APP : buf[1] = [%d]\n", buf[1]);*/
                ret = write(fd, buf, 2);
                if(ret == 2) /*表示成功写入2个字节*/
                {
                        printf("write address [%d] with data [%d]\n", buf[0], buf[1]);
                }
                else
                {
                        printf("write err ret = [%d]\n", ret);
                }
        }
        else
        {
                printf("%s r|R addr\n", argv[0]);
                printf("%s w|W addr val\n", argv[0]);
                return -1;
        }

        close(fd);

        return 0;
}

/*
测试 :
1， 刚才开始的测试的时候，由于open函数使用的是 RDONLY 只读打开，驱动函数 write不能调用，
使用 O_RDWR 可读可写方式打开，才能正确
2，
# ./iictest
./iictest r|R addr
./iictest w|W addr val
# ./iictest w 100 56 //向100地址中写入数据56
write address [100] with data [56]
# ./iictest r 100 //从100地址中读取数据
read address = [100]
data = [56]
*/

makefile文件

# CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-gcc
CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-gcc
all:iictest
iictest:iictest.c
    $(CROSS) -o iictest iictest.c
clean:
    @rm -vf iictest.o iictest