代码示例_i2c读写e2prom驱动_2

i2c_eeprom.c

---

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/mod_devicetable.h>


#include <asm/io.h>
#include <asm/uaccess.h>


//设计一个全局的设备类型
struct i2c_e2prom{
    int dev_major;
    struct class *cls;
    struct device *dev;
    struct i2c_client *client;  //记录当前匹配的client
};
struct i2c_e2prom *at24_dev;

int at24_e2prom_drv_open(struct inode *inode , struct file * filp)
{
    printk("---------^_^ %s-----------
",__FUNCTION__);
    return 0;
}

//编写一个封装了i2c_transfer的类似于i2c_master_recv的函数
int at24_i2c_read(const struct i2c_client *client, const char *buf,int size)
{
    int ret;
    struct i2c_adapter *adapter;
    struct i2c_msg msg;
    printk("---------^_^ %s-----------
",__FUNCTION__);

    adapter = at24_dev->client->adapter;

    msg.addr = at24_dev->client->addr;
    msg.flags |= I2C_M_RD;
    msg.len = size;
    msg.buf = buf;

    //参数1 ---- 适配器
    //参数2 ---- 数据包
    //参数3 ---- 数据的个数
    ret = i2c_transfer(adapter, &msg, 1);

    return ret == 1?size:ret;
    
}
//编写一个封装了i2c_transfer的类似于i2c_master_send的函数
int at24_i2c_write(const struct i2c_client *client, const char *buf,int size)
{
    int ret;
    struct i2c_adapter *adapter;
    struct i2c_msg msg;
    printk("---------^_^ %s-----------
",__FUNCTION__);

    adapter = at24_dev->client->adapter;

    msg.addr = at24_dev->client->addr;
    msg.flags = 0;
    msg.len = size;
    msg.buf = buf;

    //参数1 ---- 适配器
    //参数2 ---- 数据包
    //参数3 ---- 数据的个数
    ret = i2c_transfer(adapter, &msg, 1);

    return ret == 1?size:ret;
    
}


ssize_t at24_e2prom_drv_read (struct file *filp , char __user *buf , size_t count, loff_t * flags)
{
    int ret;
    char *tmp;
    printk("---------^_^ %s-----------
",__FUNCTION__);
//    if(count < 0 || count > 256)
    //    return -EINVAL;        

    tmp = kzalloc(count, GFP_KERNEL);
    
    // 1， 从硬件中获取数据
    ret = at24_i2c_read(at24_dev->client, tmp, count);
    if(ret < 0){
        printk("at24_i2c_read error
");
        goto err_kfree;
    }

    // 2, 将数据给由用户
    ret = copy_to_user(buf, tmp, count);
    if(ret > 0){
        printk("copy_to_user error
");
        goto err_kfree;
    }

    kfree(tmp);
    return count;
err_kfree:
    kfree(tmp);
    return ret;
        
}
ssize_t at24_e2prom_drv_write(struct file *filp, const char __user *buf, size_t count , loff_t * flags)
{
    int ret;
    char *tmp;
    printk("---------^_^ %s-----------
",__FUNCTION__);
//    if(size < 0 || size > 256)
//        return -EINVAL;        

    tmp = kzalloc(count, GFP_KERNEL);
    
    // 1, 获取用户空间的数据
    ret = copy_from_user(tmp, buf, count);
    if(ret > 0){
        printk("copy_from_user error
");
        goto err_kfree;
    }
    
    // 2，将数据写入到硬件(从设备)中
    ret = at24_i2c_write(at24_dev->client, tmp, count);
    if(ret < 0){
        printk("at24_i2c_write error
");
        goto err_kfree;
    }

    kfree(tmp);
    return count;
err_kfree:
    kfree(tmp);
    return ret;
    
}
int at24_e2prom_drv_close(struct inode *inode , struct file *filp)
{
    printk("---------^_^ %s-----------
",__FUNCTION__);
    return 0;
}

const struct file_operations at24_fops = {
    .open = at24_e2prom_drv_open,
    .read = at24_e2prom_drv_read,
    .write = at24_e2prom_drv_write,
    .release = at24_e2prom_drv_close,
};

int at24_drv_probe(struct i2c_client * client, const struct i2c_device_id * id)
{
    printk("-------id->name = %s, id->driver_data = 0x%x-----------
",id->name,id->driver_data);
    //0，实例化设备对象
    at24_dev = kzalloc(sizeof(struct i2c_e2prom), GFP_KERNEL);
    
    //1, 申请设备号
    at24_dev->dev_major = register_chrdev(0, "at24_drv", &at24_fops);
    
    //2，创建设备节点
    at24_dev->cls = class_create(THIS_MODULE, "at24_cls");
    at24_dev->dev = device_create(at24_dev->cls, NULL, MKDEV(at24_dev->dev_major, 0), NULL, "at24_e2prom");

    //保存当前client
    at24_dev->client = client;

    
    //3，硬件初始化 ----- e2prom只要上电就可以工作
    //4，实现fops

    return 0;
}
int at24_drv_remove(struct i2c_client * client)
{
    device_destroy(at24_dev->cls, MKDEV(at24_dev->dev_major, 0));
    class_destroy(at24_dev->cls);
    unregister_chrdev(at24_dev->dev_major, "at24_drv");
    kfree(at24_dev);

    return 0;
}

const struct i2c_device_id at24_id_table[] = {
    {"at24c02a", 0x2222},
    {"at24c04a", 0x2222},
    {"at24c08a", 0x2222},
};


struct i2c_driver at24_drv = {
    .probe =    at24_drv_probe,
    .remove =     at24_drv_remove,
    .driver = {
            .name = "at24_e2prom_drv",        //不会用于比对
                //   /sys/i2c/driver/at24_e2prom_drv
    },
    .id_table = at24_id_table,
};


static int __init at24_drv_init(void)
{
    //注册一个i2c_driver
    return i2c_add_driver(&at24_drv);
}


static void __exit at24_drv_exit(void)
{
    i2c_del_driver(&at24_drv);
}


module_init(at24_drv_init);
module_exit(at24_drv_exit);
MODULE_LICENSE("GPL");

app.c

---

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/i2c-dev.h>


int main(int argc,char **argv)
{
    int fd;
    unsigned char val;  //8bit变量
    char register_addr = 0x08;     //片内地址
    int res;
    char wbuf[10];
    char rbuf[10];

    if(argc < 2){
    printf("%s r :read at24c02 address 0
",argv[0]);
    printf("%s w  val:write at24c02 address 0
",argv[0]);
    exit(1);
    }

    //打开设备
    fd = open("/dev/at24_e2prom",O_RDWR);
    if(fd < 0){
    perror("open");
    exit(1);
    }

    if(!strncmp(argv[1],"r",1)){  //从硬件中读数据  

    //先将片内地址写给控制器
    if(write(fd,&register_addr,1) != 1){
        perror("write");
        exit(1);
    }
    //再去读取硬件中的数据
    if(read(fd,rbuf,1) != 1){
        perror("read");
        exit(1);
    }else{
        printf("rbuf = 0x%x
",rbuf[0]);
    }

    }else if((argc == 3) && !strncmp(argv[1],"w",1)){  //向硬件中写数据:argv[2]
    // ./at24_e2prom_app  w 0x99

    val = strtoul(argv[2],NULL,0);
    wbuf[0] = register_addr; //片内地址0x08
    wbuf[1] = val;

    if(write(fd,wbuf,2) != 2){
        perror("write");
        exit(1);
    }
    printf("write data ok!
");
    }

    close(fd);
    return 0;
}

makefile

---

CRAOSS_COMPILE = arm-none-linux-gnueabi-
CC = $(CRAOSS_COMPILE)gcc

MODULE_NAME1 = at24_i2c_e2prom
#MODULE_NAME2 = plat_input_dev
MYAPP =  at24_i2c_app

#指定内核源码的路径
KERNEL_DIR = /home/lpf/s5pv210/kernel/linux-3.0.8
CUR_DIR = ${shell pwd}

all:
    #make进入内核源码目录，并告诉内核将当前路径下的源码编译为内核的模块
    make -C $(KERNEL_DIR) M=$(CUR_DIR) modules
    $(CC) -o $(MYAPP) $(MYAPP).c
clean:
    #删除编译过程中生成的文件
    make -C $(KERNEL_DIR) M=$(CUR_DIR) clean
    $(RM) $(MYAPP) .*.sw?
install:
    cp *.ko $(MYAPP) /opt/rootfs/drv_module

#指定将哪个源文件编程为内核模块
obj-m := $(MODULE_NAME1).o
#obj-m += $(MODULE_NAME2).o
    

---