linux设备模型 （2） led设备驱动

接上文，本文记录 led工程中 driver/目录下的3个文件 s5pc100_led.h s5pc100_leddriver.c Makefile

s5pc100_led.h 这个文件和上文一样，不列举了，主要是s5pc100_leddriver.c，先列出完整的函数内容：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/ioport.h>
#include <asm/io.h>
#include <plat/gpio-cfg.h>
#include <linux/platform_device.h>
#include "s5pc100_led.h"

//主设备和从设备号变量
static int led_major = 0;
static int led_minor = 0;

#define mem_size 0x4  
typedef unsigned int long U32;  
//设备类别和设备变量
static struct class* led_class = NULL;
static struct led_android_dev* led_dev = NULL;

//传统的设备文件操作方法
static int led_open(struct inode* inode, struct file* filp);
static int led_ioctl(struct inode *inode,struct file *file,unsigned int cmd, unsigned long arg);
//设备文件操作方法表
static struct file_operations led_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.ioctl=led_ioctl,
};
//定义设备属性
//访问设置属性方法
static ssize_t led_val_show(struct device* dev, struct device_attribute* attr,  char* buf);
static ssize_t led_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, led_val_show, led_val_store);
//访问设置属性方法

//proc文件系统访问设备方法
static ssize_t led_proc_read(char* page, char** start, off_t off, int count, int* eof, void* data);
static ssize_t led_proc_write(struct file* filp, const char __user *buff, unsigned long len, void* data);
//打开设备方法
static int led_open(struct inode* inode, struct file* filp) {
	struct led_android_dev* dev;
 //将自定义设备结构体保存在文件指针的私有数据域中，以便访问设备时拿来用
	dev = container_of(inode->i_cdev, struct led_android_dev, dev);
	filp->private_data = dev;
	unsigned long gpncon_reg;
	gpncon_reg&=0xfffffff0;//将N类引脚的最低一位配置为输出
	gpncon_reg|=0x00000001;	
	*(volatile unsigned long *)(U32)led_dev->pc100_ncon=gpncon_reg;//典型应用 重点
	return 0;
}

static int led_ioctl(struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg){	
	unsigned int long Dat;
	if(arg>1){
		return -EINVAL;
	}
	
	Dat=*(volatile unsigned long *)((U32)led_dev->pc100_ndat);
	switch(cmd){
		case 0: Dat|=0x00000001;printk("set led on\n");break;
		case 1: Dat|=0x00000000;printk("set led off\n");break;
		default :break;
	}

	*(volatile unsigned long *)((U32)led_dev->pc100_ndat) = Dat;
}
//读取寄存器val的值到缓冲区buf中，内部使用
static ssize_t __led_get_val(struct led_android_dev* dev, char* buf) {
	int val = 0;
	if(down_interruptible(&(dev->sem))) {  //同步访问
     return -ERESTARTSYS;
  }
  val = dev->val;
  up(&(dev->sem));
  return snprintf(buf, PAGE_SIZE, "%d\n", val);
}
//把缓冲区buf的值写到设备寄存器val中去，内部使用
static ssize_t __led_set_val(struct led_android_dev* dev, const char* buf, size_t count) {
	int val = 0;
  val = simple_strtol(buf, NULL, 10); //将字符串转换成数字
  if(down_interruptible(&(dev->sem))) {//同步访问
     return -ERESTARTSYS;
  }
  
  dev->val = val;
  up(&(dev->sem));
	return count;
}
//读取设备属性val
static ssize_t led_val_show(struct device* dev, struct device_attribute* attr, char* buf) {
	struct led_android_dev* hdev = (struct led_android_dev*)dev_get_drvdata(dev);
	
        return __led_get_val(hdev, buf);
}
//写设备属性val
static ssize_t led_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) {
	struct led_android_dev* hdev = (struct led_android_dev*)dev_get_drvdata(dev);
  return __led_set_val(hdev, buf,count);
}
//读取设备寄存器val的值，保存在page缓冲区中
static ssize_t led_proc_read(char* page, char** start, off_t off, int count, int* eof, void* data) {
	if(off > 0) {
		*eof = 1;
		return 0;
	}
	
	return __led_get_val(led_dev, page);	
}
//把缓冲区的值buff保存到设备寄存器val中去
static ssize_t led_proc_write(struct file* filp, const char __user *buff, unsigned long len, void* data) {	
	int err = 0;
	char* page = NULL;
	if(len > PAGE_SIZE) {
		printk(KERN_ALERT"The buff is too large: %lu.\n", len);
		return -EFAULT;
	}
	
	page = (char*)__get_free_page(GFP_KERNEL);
	if(!page) {
                printk(KERN_ALERT"Failed to alloc page.\n");
		return -ENOMEM;
	}
	    
	if(copy_from_user(page, buff, len)) {//先把用户提供的缓冲区值拷贝到内核缓冲区中去
		printk(KERN_ALERT"Failed to copy buff from user.\n");
                err = -EFAULT;
		goto out;
	}
	
	err = __led_set_val(led_dev, page, len);
out:
	free_page((unsigned long)page);
	return err;	
}

static void led_create_proc(void) {//创建/proc/led文件
	struct proc_dir_entry* entry;
	entry = create_proc_entry(LED_DEVICE_PROC_NAME, 0, NULL);
	if(entry) {
		entry->owner = THIS_MODULE;
		entry->read_proc = led_proc_read;
		entry->write_proc = led_proc_write;
	}
}

static void led_remove_proc(void) {//删除/proc/led文件
	remove_proc_entry(LED_DEVICE_PROC_NAME, NULL);
}

static int  __led_setup_dev(struct led_android_dev* dev) {//初始化设备
	int err;
	dev_t devno = MKDEV(led_major, led_minor);
	memset(dev, 0, sizeof(struct led_android_dev));
	cdev_init(&(dev->dev), &led_fops);
	dev->dev.owner = THIS_MODULE;
	dev->dev.ops = &led_fops;
	err = cdev_add(&(dev->dev),devno, 1);//注册字符设备
	if(err) {
		return err;
	}	

	init_MUTEX(&(dev->sem));//初始化信号量和寄存器val的值
	dev->val = 0;
	return 0;
}

void init_led(void){
	int err = -1;
	dev_t dev = 0;
	struct device* temp = NULL;
	printk(KERN_ALERT"Initializing led device.\n");
	err = alloc_chrdev_region(&dev, 0, 1, LED_DEVICE_NODE_NAME);//动态分配主设备和从设备号
	if(err < 0) {
		printk(KERN_ALERT"Failed to alloc char dev region.\n");
		goto fail;
	}
	
	led_major = MAJOR(dev);
	led_minor = MINOR(dev);
	led_dev = kmalloc(sizeof(struct led_android_dev), GFP_KERNEL);//分配led设备结构体变量
	if(!led_dev) {
		err = -ENOMEM;
		printk(KERN_ALERT"Failed to alloc led_dev.\n");
		goto unregister;
	}

	err = __led_setup_dev(led_dev);//初始化设备
	if(err) {
		printk(KERN_ALERT"Failed to setup dev: %d.\n", err);
		goto cleanup;
	}
	
	led_class = class_create(THIS_MODULE, LED_DEVICE_CLASS_NAME);//在/sys/class/目录下创建设备类别目录led
	if(IS_ERR(led_class)) {
		err = PTR_ERR(led_class);
		printk(KERN_ALERT"Failed to create led class.\n");
		goto destroy_cdev;
	}

	temp = device_create(led_class, NULL, dev, "%s", LED_DEVICE_FILE_NAME);//在/dev/目录和/sys/class/led目录下分别创建设备文件led
	if(IS_ERR(temp)) {
		err = PTR_ERR(temp);
		printk(KERN_ALERT"Failed to create led device.");
		goto destroy_class;
	}
	err = device_create_file(temp, &dev_attr_val);//在/sys/class/led/led目录下创建属性文件val
	if(err < 0) {
		printk(KERN_ALERT"Failed to create attribute val.");
                goto destroy_device;
	}
	dev_set_drvdata(temp, led_dev);
	led_create_proc();//创建/proc/led文件
	printk(KERN_ALERT"Succedded to initialize led device.\n");
	return 0;
destroy_device:
	device_destroy(led_class, dev);
destroy_class:
	class_destroy(led_class);
destroy_cdev:
	cdev_del(&(led_dev->dev));	
cleanup:
	kfree(led_dev);
unregister:
	unregister_chrdev_region(MKDEV(led_major, led_minor), 1);	
fail:
	return err;
}

int led_driver_probe(struct platform_device *pdev)
{//查询特定设备是否存在，以及是否能够才操作该设备，然后再进行设备操作。
	//check_led();	//自己假设一下检查设备
	unsigned long phys,virt;
	//struct resource *mm;
	init_led();
	//mm=platform_get_resource(pdev,IORESOURCE_MEM,0);//关键函数 获取 设备的资源 io 内存  dma 等 这里获取io内存
	phys = pdev->resource[0].start;
	//struct led_plat_data *pdata= pdev->dev.platform_data;//获得设备的私有数据
	virt= ioremap(phys, 8);
	led_dev->pc100_ncon = virt + 0x0;
	led_dev->pc100_ndat = virt + 0x4;
  return 0;
}

int led_driver_remove(struct platform_device *dev){
	dev_t devno = MKDEV(led_major, led_minor);
	printk(KERN_ALERT"Destroy led device.\n");
	led_remove_proc(); //删除/proc/led文件
	if(led_class) {//销毁设备类别和设备
		device_destroy(led_class, MKDEV(led_major, led_minor));
		class_destroy(led_class);
	}
	if(led_dev) {//删除字符设备和释放设备内存
		cdev_del(&(led_dev->dev));
		kfree(led_dev);
	}
	unregister_chrdev_region(devno, 1);//释放设备号
    return 0;
}

struct platform_driver led_drv = {//结构体中不需要指定总线的成员，交由platform_device_register来完成
    .probe = led_driver_probe,
    .remove = led_driver_remove,
    .driver = {
        .name = "led",	//在/sys/中的驱动目录名字
		.owner = THIS_MODULE,
	},
};

static int __init led_driver_init(void){
    int ret;
    ret = platform_driver_register(&led_drv);//驱动注册，注册成功后在/sys/platform/led/driver目录下创建目录
    if(ret){
        printk("driver register failed!\n");
        return ret;	
    }
    printk("led driver init\n");
    return 0;
}

static void __exit led_driver_exit(void){
    platform_driver_unregister(&led_drv);
    printk("led driver bye!\n");
}

module_init(led_driver_init);
module_exit(led_driver_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("kevin");