关闭

LED电路板驱动程序

标签: 调试
305人阅读 评论(0) 收藏 举报
分类:
 为了学习parport提供的服务,让我们编写一个简单的驱动程序。考虑一个有8个发光二极管(LED),提供和标准25针并行端口接口的电路板。因为PC上的8位并行端口数据寄存器直接映射到并行端口的2~9针,所以这些针脚和电路板上的LED连通。向并行端口数据寄存器写数据可以控制这些针脚的电平,进而控制LED的开关。如下代码为一个字符设备驱动程序,它通过系统并行端口和此电路板通信。代码内的注释解释了其中所使用的parport服务例程。
并行端口LED电路板驱动程序(led.c)
#include<linux/fs.h>
#include<linux/cdev.h>
#include<linux/parport.h>
#include<asm/uaccess.h>
#include<linux/platform_device.h>

#define DEVICE_NAME   "led"

static dev_t dev_number;                    /*Allotted device number */
static struct class *led_class;              /* Class to which this device belongs */
struct cdev led_cdev;                           /* Associated cdev */
struct pardevice *pdev                         /* Parallel port device */

/*LED open */
int led_open(struct inode *inode, struct file *file)
{
        return 0;
}

/* Write to the LED */
ssize_t led_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
        char kbuf;

        if (copy_from_user(&kbuf, buf, 1)) return -EFAULT;

        /* Write to the device */
        parport_write_data(pdev->port, kbuf);

        /* Release the port */
        parport_release(pdev);

        return count;
}

/* Release the device */
int led_release(struct inode *inode, struct file *file)
{
        return 0;
}

/* file Operations */
static struct file_operations led_fops = {
        .owner        = THIS_MODULE,
        .open          = led_open,
        .write          = led_write,
        .release     = led_release,
};

static int led_preempt(void *handle)
{
        return 1;
}

/* Parport attach method */
static void led_attach(struct parport *port)
{
        /* Register the paralled LED device with parport */
        pdev = parport_register_device(port, DEVICE_NAME, led_preempt, NULL, NULL, 0, NULL);
        if (pdev == NULL) printk ("Bad register\n");
}

/* Parport detach method */
static void led_detach(struct parport *port)
{
        /* Do nothing */
}

/* Parport driver operations */
static struct parport_driver led_driver = {
        .name        = "led",
        .attach       = led_attach,
        .detach      = led_detach,
};

/* Driver Initialization */
/*
新的设备模型将驱动程序和设备区分开来。led_init()通过parport_register_driver()调用项parport注册LED驱动程序。当内核在led_attach()中查找到LED板时,它调用parport_register_device()注册设备
*/
int __init led_init(void)
{
        /* Request dynamic allocatino of a device major number */
        if (alloc_chrdev_region(&dev_number, 0, 1, DEVICE_NAME) < 0) {
                printk(KERN_DEUG "Can't register device\n");
                return -1;
        }
        
        /* create the led class */
        led_class = class_create(THIS_MODULE, DEVICE_NAME);
        if (IS_ERR(led_class)) printk("Bad class create\n");

        /* Connect the file operation with the cdev */
        cdev_init(&led_cdev, &led_fops);

        led_cdev.owner = THIS_MODULE;

        /* Connect the major/minor number to the cdev */
        if (cdev_add(&led_cdev, dev_number, 1)) {
                printk("Bad cdev add\n");
                return 1;
        }

        class_device_create(led_class, NULL, dev_number, NULL, DEVICE_NAME);
/*
该函数创建设备节点/dev/led,可以用此设备节点控制每个LED的状态
编译并将驱动程序模块加入到内核中:
bash> make -C /path/to/kerneltree/ M=$PWD modules
PS:也许你不一定能成功,因为Linux Kernel 2.6要求编译模块之前,必须先在内核源代码目录下执行make,换言之,必须先配置过内核,执行过make,然后才能make自己的内核。(仔细想想你没有配置过内核,内核怎么知道该部分是编译成模块还是编译进内核的呢)
bash> insmod ./led.ko
LED Driver Initialized
PS:早期的版本使用class_create()和class_device_create()这两个函数创建设备节点,到了2.6.29内核以后,使用的函数则变成了class_create()和device_create(),并且要在声明中加入#include <linux/device.h>,不过使用这两个函数的前提是用户空间已经移植了udev。
内核中定义了struct class结构体,一个struct class结构体类型变量对应一个类(有待商榷), 内核同时提供了class_create(…)函数,可以用它来创建一个类,这个类存放于/sysfs下面,一旦创建好了这个类,再调用 device_create(…)函数来在/dev目录下创建相应的设备节点。这样,加载模块的时候,用户空间中的udev会自动响应 device_create(…)函数,去/sysfs下寻找对应的类从而创建设备节点。
*/

        /* Register this driver with parport */
        if (parport_register_driver(&led_driver)) {
                printk(KERN_ERR "Bad Parport Register\n");
                return -EIO;
        }

        printk("LED Driver Initialized. \n");
        return 0;
}

/*Driver Exit */
void __exit led_cleanup(void)
{
        unregister_chrdev_region(dev_number, 1);
        class_device_destroy(led_class, dev_number);
        class_destroy(led_class);
        return ;
}

module_init(led_init);
module_exit(led_cleanup);

MODULE_LICENSE("GPL");

为了有选择地驱动一些并行端口针脚,点亮相应的LED,将相应的值赋给/dev/led:
bash> echo 1 > /dev/led
        因为1的ASCII值是31(00110001),第1,5和6个LED将会发亮。
        前述命令触发led_write()调用。此驱动程序方法首先通过copy_from_user()将用户内存数据(在本例中为31)复制到内核缓冲区。然后占用并行端口,写入数据,释放端口,所有这些都使用parport接口。
        相比于/dev,sysfs是更好的控制设备状态的地方。因此将LED控制委托给sysfs效果更佳。下面代码为此种驱动程序的实现代码,其中哦功能sysfs操作代码也可以作为模版用到其它的设备控制中去

使用sysfs控制并行端口LED电路板:
#include<linux/fs.h>
#include<linux/cdev.h>
#include<linux/parport.h>
#include<asm/uaccess.h>
#include<linux/pci.h>
static dev_t dev_number;          /* Allotted Device Number */
static struct class *led_class;    /* Class Device Model */
struct cdev led_cdev;                 /* Character dev struct*/
struct pardevice *pdev;              /*Parallel Port device */

struct kobject kobj;                     /* Sysfs directory object */

/* sysfs attribute of the leds */
struct led_attr {
        struct attribute attr;
        ssize_t (*show)(char *);
        ssize_t (*store)(const char *, size_t cont);
};

#define glow_show_led(number)                                                                                \
static ssize_t glow_led_##number(const char *buffer, size_t count)                        \
{                                                                                                                                         \
        unsigned char buf;                                                                                                 \
        int value;                                                                                                                  \
                                                                                                                                          \
        sscanf(buffer, "%d", &value);                                                                                \
                                                                                                                                          \
        parport_claim_or_block(pdev);                                                                            \
        buf = parport_read_data(pdev->port);                                                                 \
        if (value) {                                                                                                                \
                parport_write_data(pdev->port, buf | (1<<number));                                \
        } else {                                                                                                                     \
                parport_write_data(pdev->port, buf & ~(1<<number));                            \
        }                                                                                                                               \
        parport_release(pdev);                                                                                        \
        return count;                                                                                                          \
}                                                                                                                                       \
                                                                                                                                       \
static ssize_t                                                                                                                \
show_led_##number(char *buffer)                                                                          \
{                                                                                                                                     \
        unsigned char buf;                                                                                             \
                                                                                                                                      \
        parport_claim_or_block(pdev);                                                                        \
                                                                                                                                      \
        buf = parport_read_data(pdev->port);                                                             \
        parport_release(pdev);                                                                                     \
                                                                                                                                     \
        if (buf & (1 << number)) {                                                                                  \
                return sprintf(buffer, "ON\n");                                                                   \
        } else {                                                                                                                 \
                return sprintf(buffer, "OFF\n");                                                                 \
        }                                                                                                                            \
}                                                                                                                                    \
static struct led_attr led##number =                                                                       \
__ATTR(led##number, 0644, show_led_##number, glow_led_##number);

glow_show_led(0); glow_show_led(1); glow_show_led(2);
glow_show_led(3); glow_show_led(4); glow_show_led(5);
glow_show_led(6); glow_show_led(7); 
/*
glow_show_led()使用了内核源代码中经常使用的技术,以便简洁地定义几个类似的函数。定义的read()和write()方法(在sysfs中用术语show()和store()表示)同8个/sys文件相关,电路板上每个LED对应一个文件。因此glow_show_led(0)将glow_led_0()和show_led_0()与第一个LED对应一个文件。这些函数分别负责点亮/熄灭第一个LED,并读取其状态。##在宏定义中用于把字符串连接在一起,因此当编译器处理语句glow_show_led(0)时,glow_led_##number就变成glow_led_0()。
*/
#define DEVICE_NAME "led"

static int led_preempt (void * handle)
{
        return 1;
}

/* Parport attach method */
static void led_attach (struct parport *port)
{
        pdev = parport_register_device(port, DEVICE_NAME, led_preempt, NULL, NULL, 0, NULL);
}

/* Parent sysfs show() method. Calls the show() method corresponding to the individual sysfs file */
static ssize_t l_show(struct kobject *kobj, struct attribute *a, char *buf)
{
        int ret;
        struct led_attr *lattr = container_of(a, struct led_attr, attr);

        ret = lattr->show ? lattr->show(buf) : -EIO;
        return ret;
}

/* Sysfs store() method. Calls the store()method corresponding to the individual sysfs file */
static ssize_t l_store(struct kobject *kobj, struct attribute 8a, const char *buf, size_t count)
{
        int ret;
        struct led_attr *lattr = container_of(a, struct led_attr, attr);

        ret = lattr->store ? lattr->store(buf, count) : -EIO;
        return ret;
}

/* Sysfs operations structure */
static struct sysfs_ops sysfs_ops = {
        .show = l_show,
        .store = l_store,
};

/* Attributes of the /sys/class/pardevice/led/control/ kobject.
   Each file in this directory corresponds to one LED. Control
   each LED by writing or reading  the associated sysfs file */
static struct attribute *led_atrrs[] = {
        &led0.attr,
        &led1.attr,
        &led2.attr,
        &led3.attr,
        &led4.attr,
        &led5.attr,
        &led6.attr,
        &led7.attr,
        NULL
};

/* This describes the kobject. The kobject has 8 files, one corresponding to each LED. This representation is called the ktype of the kobject */
static struct kobj_type ktype_led = {
        .sysfs_ops        = &sysfs_ops,
        .default_attrs    =  led_attrs,
};

/* Parport methods. We don't have a detach method */
static struct parport_driver led_driver = {
        .name        = "led",
        .attach       = led_atach,
};

/* Driver Initialization */
int __init led_init(void)
{
        struct class_device *c_d;
        if calloc_chrdev_region(&dev_number, 01, DEVICE_NAME <0) {
                printk(KERN_DEBUG "can't register device \n");
                return -1;
        }

        /* Create the pardevice class - /sys/class/pardevice */
        led_class = class_create(THIS_MODULE, "pardevice");
        if (IS_ERR(led_class)) printk("Bad class create\n");

        /* Create the led class device - /sys/class/pardevice/led/ */
        c_d = class_device_create(led_class, NULL, dev_number, NULL, DEVICE_NAME);

        /* Register this driver with parport */
        if (parport_register_driver(&led_driver)) {
                printk(KERN_ERR "Bad parport Register \n");
                return -EIO;
        }

        /* Instantiate a kobject to control each LED on the board */

        /* Parent is /sys/classpardevice/led */
        kobj.parent = &c_d->kobj;

        /* the sysfs file corresponding to kboj is /sys/class/pardevice/led/control/    */
        strlcpy(kobj.name, "control", KOBJ_NAME_LED);

        /* Description of the kobject. Specifies the list of attribute files in /sys/class/pardevice/led/control/      */
        kobj.ktype  =  &ktype_led;
/*
ktype描述了kobject。ktype_led结构描述了“控制”kobject,它包含指向属性数组的指针led_attrs[]。led_attrs[]数组包含每个LED的设备属性的地址。每个LED的属性通过下列语句连接在一起:
        static struct led_attr led##number =
        __ATTR(led##number, 0644, show_led_##number, glow_led_##number);
        其结果是为每个LED产生一个控制文件/sys/class/pardevice/led/control/ledX,其中X是LED序号。为了改变ledX的状态,将1(或者0)回送给相应的控制文件。如为了点亮第一个LED,可做如下操作:
        bash> echo 1 > /sys/class/pardevice/led/control/led0
在模块退出期间,驱动程序使用kobject_unregister(),class_device_destroy()和class_destroy()移除kobject和class。
*/
        /* Register the kobject */
        kobject_register(&kobj);
/*
基于sysfs版本的驱动程序使用了kobject用于代表“控制”抽象,它模拟了一个软件按钮控制LED。sysfs下的每个目录名代表一个kobject,因此代码清单中的kobject_register()创建了/sys/class/pardevice/led/control/目录
*/
        printk("LED Driver Initialized. \n");
        return 0;
}

/* Driver Exit */
void led_cleanup(void)
{
        /* unregister kobject corresponding to /sys/class/pardevice/led/control */
        kobject_unregister(&kobj);

        /* Destroy class device corresponding to /sys/class/pardevice/led/   */
        class_device_destroy(led_class, dev_number);

        /* Destroy /sys/class/pardevice */
        class_destroy(led_class);

        return;
}

module_init(led_init);
module_exit(led_cleanup);

MODULE_LICENSE("GPL");

        编写字符驱动程序不再像2.4内核中那样简单了。在上下文中,为了开发简单的LED驱动彻骨女婿,我们使用了6个数据抽象:cdev,sysfs,kobject,class,class device 和parport。当然,这些数据抽象也有优点,如编译模块无bug,代码可重用,设计流程严谨。
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:153369次
    • 积分:2508
    • 等级:
    • 排名:第15236名
    • 原创:88篇
    • 转载:82篇
    • 译文:2篇
    • 评论:21条
    最新评论