tiny6410 platform led驱动

最新推荐文章于 2025-04-25 16:11:28 发布

原创最新推荐文章于 2025-04-25 16:11:28 发布 · 484 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一个基于S3C6410开发板的LED控制方案，通过编写内核模块实现LED的开关控制，并提供了测试程序。文章详细展示了从驱动模块到应用程序的完整流程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实现了对s3c6410开发板led灯的控制

led_dev.c:

#include<linux/init.h>
#include<linux/module.h>
#include<linux/platform_device.h>
#include<linux/device.h>

#define DEVICE_NAME "tiny6410_leds"

static struct resource tiny6410_leds_resource[] = {
    [0] = {
        .start = 0x7f008800,
        .end = 0x7f008800 + 16, //16字节，包括gpkcon0,gpkcon1,gpkdat,gpkpud
        .flags = IORESOURCE_MEM,
    },
};

static void tiny6410_leds_platform_device_release(struct device *dev)
{
    printk("[remove platform_device]\n");
    return ;
}

//初始化，并添加资源
static struct platform_device tiny6410_leds_platform_device = {
    .name = DEVICE_NAME,
    .id = -1, //表示同名的驱动只有一个
    .num_resources = ARRAY_SIZE(tiny6410_leds_resource),
    .resource = tiny6410_leds_resource,
    .dev = {
        .release = tiny6410_leds_platform_device_release,
    },
};

static int __init tiny6410_leds_platform_device_init(void)
{
    printk("[tiny6410_leds_platform_device init]\n");
    return platform_device_register(&tiny6410_leds_platform_device); // >0表示添加platform_device失败
}

static void __exit tiny6410_leds_platform_device_exit(void)
{
    printk("[tiny6410_leds_platform_device exit]\n");
    platform_device_unregister(&tiny6410_leds_platform_device);
}

module_init(tiny6410_leds_platform_device_init);
module_exit(tiny6410_leds_platform_device_exit);

MODULE_AUTHOR("ZHYANG");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("tiny6410_leds_platform_device");

led_drv.c:

#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/platform_device.h>
#include<linux/miscdevice.h>
#include<linux/device.h>
#include<linux/pci.h>
#include<linux/uaccess.h>

#define DEVICE_NAME "tiny6410_leds"

// static struct class *tiny6410_leds_class = NULL; //miscdevice会自动创建设备节点，手动申请设备号会用到
// static struct device *tiny6410_leds_device = NULL; //这边占不演示
// 方法：在__init函数中先class_create,再device_create
//       在__exit中先device_destroy,再class_destroy

static volatile unsigned long *gpkcon0 = NULL;
static volatile unsigned long *gpkdat = NULL;

static int tiny6410_leds_open(struct inode *inode,struct file *filp)
{
    unsigned long tmp;

    //配置GPKCON0的GPK4-GPK7位为0001输出
    tmp = readl(gpkcon0);
    tmp = (tmp & ~(0xffff << 16)) | (0x1111 << 16);
    writel(tmp,gpkcon0);
    //初始化GPK4-GPK7为1,即灯灭
    tmp = readl(gpkdat);
    tmp |= (0xF << 4);
    writel(tmp,gpkdat);

    printk("[tiny6410_leds_open]\n");
    return 0;
}

static ssize_t tiny6410_leds_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
    char val; //1或0表示全亮灭
    unsigned long tmp;

    int ret = copy_from_user(&val,buf,count);
    // printk("[val = %c]\n",val);
    if(val=='1'){
        tmp = readl(gpkdat);
        tmp &= ~(0xf << 4);
        writel(tmp,gpkdat);
    }else{
        tmp = readl(gpkdat);
        tmp |= 0xf << 4;
        writel(tmp,gpkdat);
    }

    printk("[tiny6410_leds_write]\n");
    return ret;
}

//文件操作结构体的初始化
static struct file_operations tiny6410_leds_fops = {
    .owner = THIS_MODULE,
    .open = tiny6410_leds_open,
    .write = tiny6410_leds_write,
};

//杂项设备的初始化
static struct miscdevice tiny6410_leds_miscdevice = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = DEVICE_NAME, //特殊，name必须这么指定，因为Misc会自动创建设备节点
    .fops = &tiny6410_leds_fops,
};

static int __devinit tiny6410_leds_platform_driver_probe(struct platform_device *pdev)
{

    int ret;
    struct resource *res_gpk;

    ret = misc_register(&tiny6410_leds_miscdevice);//注册杂项设备
    res_gpk = platform_get_resource(pdev,IORESOURCE_MEM,0); //获取平台设备资源0
    gpkcon0 = ioremap(res_gpk->start,16); //物理地址到虚拟地址的映射
    gpkdat = gpkcon0 + 2;

    printk("[tiny6410_leds_platform_driver_probe]\n");
    return ret;
}

static int __devexit tiny6410_leds_platform_driver_remove(struct platform_device *pdev)
{
    iounmap(gpkcon0); //取消映射
    misc_deregister(&tiny6410_leds_miscdevice);//注销杂项设备

    printk("[tiny6410_leds_platform_driver_remove]\n");
    return 0;
}

//platform_driver初始化
static struct platform_driver tiny6410_leds_platform_driver = {
    .probe = tiny6410_leds_platform_driver_probe,
    .remove = tiny6410_leds_platform_driver_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name = DEVICE_NAME,
    },
};

static int __init tiny6410_leds_platform_driver_init(void)
{
    printk("[tiny6410_leds_platform_driver_init]\n");

    return platform_driver_register(&tiny6410_leds_platform_driver); //注册平台驱动
}

static void __exit tiny6410_leds_platform_driver_exit(void)
{
    printk("[tiny6410_leds_platform_driver_exit]\n");

    platform_driver_unregister(&tiny6410_leds_platform_driver); //注销平台驱动
}

module_init(tiny6410_leds_platform_driver_init);
module_exit(tiny6410_leds_platform_driver_exit);

MODULE_AUTHOR("ZHYANG");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("tiny6410_leds_platform_driver");

Makefile:

obj-m := led_drv.o led_dev.o

KDIR := /opt/FriendlyARM/mini6410/linux/linux-2.6.38/

all:
make -C $(KDIR) M=$(PWD) modules

clean:
rm -f *.ko *.o *.mod.* *.order *.symvers

测试程序test_led.c:

#include<stdio.h>
#include<fcntl.h>

int main(int argc,char **argv)
{
    int fd;
    char on; //1亮0灭

    if(argc != 2){
        printf("usage:./test_led 0|1\n");
        return -1;
    }
    on = *argv[1];
    // printf("%c\n",on);
    fd = open("/dev/tiny6410_leds",O_RDWR);
    if(fd < 0){
        printf("open device tiny6410_leds failed\n");
        return -1;
    }
    if(write(fd,&on,1) == 0) //0表示成功
        printf("write success\n");
    else printf("write fail\n");

    close(fd);
    return 0;
}