linux环境下LED驱动编程一例

效果：流水灯

 

led_drv.h

 

#ifndef __LED_DRV_H__
#define __LED_DRV_H__

struct led_cmd
{
    int status;
    int num;
};

#define LED_ALL_ON _IOW('L',0,int)
#define LED_ALL_OFF _IOW('L',1,int)
#define LED_S_ON _IOW('L',2,int)
#define LED_S_OFF _IOW('L',3,int)


#endif

 

led_drv.c

 

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include "led_drv.h"

MODULE_LICENSE("GPL");
static struct led_dev
{
    struct cdev cdev;
    void *map_con;
    void *map_data;
    dev_t devno;

}my_led_dev;


static int led_open(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "led opened\n");
    return 0;
}

static ssize_t led_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
//    LED_CMDP cmd = (LED_CMDP)buf;
    struct led_cmd *cmd = (struct led_cmd *)buf;
    if(cmd->status == 0)
    {
        writel(readl(my_led_dev.map_data) & (~(0x1<<(cmd->num))), my_led_dev.map_data);
    }
    else
    {

        writel(readl(my_led_dev.map_data) | (0x1<<(cmd->num)), my_led_dev.map_data);
    }
    return 0;
}
static int led_close (struct inode *inode , struct file *file)
{
    printk(KERN_INFO "led closed\n");
    return 0;
}

static int led_ioctl(struct inode *inode, struct file *flip, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {

    case LED_ALL_ON:
        writel((readl(my_led_dev.map_data) | 0xf), my_led_dev.map_data);
        break;
    case LED_ALL_OFF:
        writel((readl(my_led_dev.map_data) & (~0xf)), my_led_dev.map_data);
        break;
    case LED_S_ON:
        writel((readl(my_led_dev.map_data) | (0x1<<arg)), my_led_dev.map_data);
        break;
    case LED_S_OFF:
        writel((readl(my_led_dev.map_data)) & (~(0x1<<arg)), my_led_dev.map_data);
        break;
    default:
        return -EINVAL;
    }

    return 0;
}
static struct file_operations led_fops =
{
    .owner = THIS_MODULE,
    .open = led_open,
    .release = led_close,
    .write = led_write,
    .ioctl = led_ioctl
};


int led_init(void)
{

    int ret;
    my_led_dev.devno = MKDEV(250, 0);

    ret = register_chrdev_region(my_led_dev.devno,1, "pengdonglin");

    if(ret < 0)
    {
        return ret;
    }

    cdev_init(&my_led_dev.cdev, &led_fops);
    my_led_dev.cdev.owner = THIS_MODULE;
    ret = cdev_add(&my_led_dev.cdev, my_led_dev.devno, 1);
    if(ret)
    {
        return ret;
    }
/*
    my_led_dev.map_con = ioremap(0xe03001c0, 4);
    my_led_dev.map_data = ioremap(0xe03001c4, 4);
*/
    my_led_dev.map_con = ioremap(0xe03001c0, 8);
    my_led_dev.map_data = my_led_dev.map_con + 4 ;

    writel((readl(my_led_dev.map_con) & (~0xffff)) | 0x1111, my_led_dev.map_con);
    writel((readl(my_led_dev.map_data) & (~0xf))|0xf, my_led_dev.map_data);

    printk(KERN_INFO "init led\n");

    return 0;
}

void led_exit(void)
{
    iounmap(my_led_dev.map_data);
    iounmap(my_led_dev.map_con);
    cdev_del(&my_led_dev.cdev);
    unregister_chrdev_region(my_led_dev.devno,1);
    printk(KERN_INFO "led exit\n");
}

module_init(led_init);
module_exit(led_exit);

 

 

Makefile

 

$(warning KERNELRELEASE=$(KERNELRELEASE))
ifeq ($(KERNELRELEASE),)

KERNELDIR ?= /home/linux/arm/linux-2.6.35/

#KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

modules:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install

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

.PHONY: modules modules_install clean

else
    obj-m := led_drv.o
endif

 

led_test.c

 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include "led_drv.h"

int main(void)
{
    int fd;
    int num = 0;
    struct led_cmd led = {
        1,0
    };

    printf("start!\n");

    if((fd = open("/dev/led", O_RDWR)) < 0)
    {
        perror("open error\n");
        exit(-1);
    }
    write(fd, &led, 1);
    sleep(1);

    ioctl(fd, LED_ALL_ON,0);

    sleep(1);
    ioctl(fd, LED_ALL_OFF,0);

    while(1)
    {
        usleep(50000);
        ioctl(fd, LED_S_ON,num);
        usleep(50000);
        ioctl(fd, LED_S_OFF,num);
        num = (++num) % 4;
    }

    close(fd);
    return 0;
}