platform之led驱动分析及测试程序

最新推荐文章于 2025-01-10 11:06:42 发布
最新推荐文章于 2025-01-10 11:06:42 发布
阅读量1.2k 收藏 7
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 驱动篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fml1997/article/details/69659198
本文介绍了Linux中的Platform总线机制，它是用于嵌入式系统中管理SoC上独立外设控制器的机制。通过定义特定的结构体并调用注册函数，设备和驱动可以在Platform总线上进行注册。平台设备和驱动的结构体以及注册注销函数进行了说明。此外，还提供了一个平台LED驱动的代码示例，展示了如何控制LED的开关和闪烁。

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

什么是paltform总线：

一个现实的linux设备和驱动通常都需要挂接在一种总线上，比较常见的总线有USB、PCI总线等。但是，在嵌入式系统里面，SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设却不依附与此类总线。基于这样的背景下，2.6内核加入了platform虚拟总线。platform机制将设备本身的资源注册进内核，有内核统一管理，在驱动程序使用这些资源时使用统一的接口，这样提高了程序的可移植性。



在platform总线上注册设备和驱动，只要定义指定的结构体后调用platform给出的注册函数就可以了


linux在系统启动时就注册了platform总线，看内核代码：

/*drivers/base/platform.c*/
 static int platform_match(struct device *dev, struct device_driver *drv)
 {
     struct platform_device *pdev;

     pdev = container_of(dev, struct platform_device, dev);
     return (strcmp(pdev->name, drv->name) == 0); //配对函数检验名字是否一致
 }
。。。。。
 struct bus_type platform_bus_type = {
     .name = "platform", //定义了总线名字为platform，总线注册后新建目录sys/bus/platform
    .dev_attrs = platform_dev_attrs,
     .match = platform_match, //指定配对函数
     .uevent = platform_uevent,
     .pm = PLATFORM_PM_OPS_PTR,
 };


总线中定义了成员名字和match函数，当有总线或者设备注册到platform总线时，内核自动调用match函数


platform设备对应的结构体paltform_device：

/*linux/platform_device.h*/
 struct platform_device {
    const char * name; //设备的名字，这将代替device->dev_id，用作sys/device下显示的目录名
    int id; //设备id，用于给插入给该总线并且具有相同name的设备编号，如果只有一个设备的话填-1。
     struct device dev; //结构体中内嵌的device结构体。
     u32 num_resources; //资源数。
    struct resource * resource; //用于存放资源的数组。
 };



platform_device的注册和注销使用以下函数：

/*drivers/base/platform.c*/
 int platform_device_register(struct platform_device *pdev) //同样的，需要判断返回值
。。。
 void platform_device_unregister(struct platform_device *pdev)


会在/sys/device/目录下创建一个以name命名的目录，并且创建软连接到/sys/bus/platform/device下。


platform驱动对应的结构体paltform_driver：

/*linux/platform_device.h*/
 struct platform_driver {
    int (*probe)(struct platform_device *);
    int (*remove)(struct platform_device *);
    void (*shutdown)(struct platform_device *);
     int (*suspend)(struct platform_device *, pm_message_t state);
     int (*suspend_late)(struct platform_device *, pm_message_t state);
     int (*resume_early)(struct platform_device *);
    int (*resume)(struct platform_device *);
     struct device_driver driver;
 };



platform_driver结构体内嵌了device_driver，并且实现了prob、remove等操作。其实，当内核需要调用probe函数时，它会调用driver->probe，在dricer->probe中再调用platform_driver->probe。


platform_driver的注册和注销使用以下函数：

/*drivers/base/platform.c*/
 int platform_driver_register(struct platform_driver *drv)
。。。。。
 void platform_driver_unregister(struct platform_driver *drv)


注册成功后内核会在/sys/bus/platform/driver/目录下创建一个名字为driver->name的目录。


更多详细的关于platform或者platled的了解可以参考

http://blog.chinaunix.net/uid-25014876-id-111745.html

http://blog.youkuaiyun.com/zouleideboke/article/details/68969544

platform_LED驱动的代码：

#include "s3c_driver.h"  
  
#define DRV_AUTHOR                "fanmaolin <fanmaolinn@gmail.com>"  
#define DRV_DESC                  "S3C24XX LED driver"  
  
/* Driver version*/  
#define DRV_MAJOR_VER             1  
#define DRV_MINOR_VER             0  
#define DRV_REVER_VER             0  
  
#define DEV_NAME                  DEV_LED_NAME  
#ifndef DEV_MAJOR  
#define DEV_MAJOR                 0 /*  dynamic major by default */   
#endif  
  
#define TIMER_TIMEOUT             40  
  
static int debug = DISABLE;  
static int dev_major = DEV_MAJOR;  
static int dev_minor = 0;  
  
  
/* ============================ Platform Device part ===============================*/  
/*  LED hardware informtation structure*/  
struct s3c_led_info  
{  
    unsigned char           num;              /* The LED number  */  
    unsigned int            gpio;             /* Which GPIO the LED used */    
    unsigned char           active_level;     /* The GPIO pin level(HIGHLEVEL or LOWLEVEL) to turn on or off  */  
    unsigned char           status;           /* Current LED status: OFF/ON */  
    unsigned char           blink;            /* Blink or not */             
};  
  
/*  The LED platform device private data structure */  
struct s3c_led_platform_data  
{  
    struct s3c_led_info    *leds;  
    int                     nleds;  
};  
  
  
/*  LED hardware informtation data*/   
static struct s3c_led_info  s3c_leds[] = {  
    [0] = {  
        .num = 1,  
        .gpio = S3C2410_GPB(5),  
        .active_level = LOWLEVEL,  
        .status = OFF,  
        .blink = ENABLE,  
    },  
    [1] = {  
        .num = 2,  
        .gpio = S3C2410_GPB(6),  
        .active_level = LOWLEVEL,  
        .status = OFF,  
        .blink = DISABLE,  
    },  
    [2] = {  
        .num = 3,  
        .gpio = S3C2410_GPB(8),  
        .active_level = LOWLEVEL,  
        .status = OFF,  
        .blink = DISABLE,  
    },  
    [3] = {   
        .num = 4,  
        .gpio = S3C2410_GPB(10),  
        .active_level = LOWLEVEL,  
        .status = OFF,  
        .blink = DISABLE,  
    },   
};  
  
/*  The LED platform device private data */  
static struct s3c_led_platform_data s3c_led_data = {  			//定义LED灯的结构体信息  
    .leds = s3c_leds,  //LED灯的每条信息 
    .nleds = ARRAY_SIZE(s3c_leds),  //灯数
};  
  
struct led_device  
{  
    struct s3c_led_platform_data    *data;  
    struct cdev                     cdev;  
    struct class                    *dev_class;  
    struct timer_list               blink_timer;  
} led_device;  
  
static void platform_led_release(struct device * dev)  //撤销LED灯的函数  
{  
    int i;  
    struct s3c_led_platform_data *pdata = dev->platform_data;   
  
    dbg_print("%s():%d\n", __FUNCTION__,__LINE__);  
  
    /* Turn all LED off */  
    for(i=0; i<pdata->nleds; i++)  
    {  
         s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);   
    }  
}  
  
static struct platform_device s3c_led_device = { 							//定义设备结构体 
    .name    = "s3c_led",  
    .id      = 1,  
    .dev     =   
    {  
        .platform_data = &s3c_led_data,   
        .release = platform_led_release,  
    },  
};  
  
  
  
/* ===================== led device driver part ===========================*/  
  
void led_timer_handler(unsigned long data)  
{   
    int  i;   
    struct s3c_led_platform_data *pdata = (struct s3c_led_platform_data *)data;  
  
    for(i=0; i<pdata->nleds; i++)   
    {   
        if(ON == pdata->leds[i].status)  
        {  
              s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level);   
        }  
        else  
        {  
              s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);   
        }  
  
        if(ENABLE == pdata->leds[i].blink )  /* LED should blink */  
        {  
            /* Switch status between 0 and 1 to turn LED ON or off */  
            pdata->leds[i].status = pdata->leds[i].status ^ 0x01;    
        }  
  
        mod_timer(&(led_device.blink_timer), jiffies + TIMER_TIMEOUT);  //闪烁时间设置
    }  
}  
  
  
static int led_open(struct inode *inode, struct file *file)  //LED开启函数 
{   
    struct led_device *pdev ;  
    struct s3c_led_platform_data *pdata;  
  
    pdev = container_of(inode->i_cdev,struct led_device, cdev);  
	 /*container_of 在Linux内核中是一个常用的宏，用于从包含在某个结构中的指针获得结构本身的指针， 
就是通过结构体变量中某个成员的首地址进而获得整个结构体变量的首地址*/ 
    pdata = pdev->data;  
  
    file->private_data = pdata;  
  
    return 0;  
}  
  
  
static int led_release(struct inode *inode, struct file *file)  //关闭led
{   
    return 0;  
}  
  
static void print_led_help(void)  //help信息
{  
    printk("Follow is the ioctl() command for LED driver:\n");  
    printk("Enable Driver debug command: %u\n", SET_DRV_DEBUG);  
    printk("Get Driver verion  command : %u\n", GET_DRV_VER);  
    printk("Turn LED on command        : %u\n", LED_ON);  
    printk("Turn LED off command       : %u\n", LED_OFF);  
    printk("Turn LED blink command     : %u\n", LED_BLINK);  
}  
  
/* compatible with kernel version >=2.6.38*/  
static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
{   
    struct s3c_led_platform_data *pdata = file->private_data;  
  
    switch (cmd)  
    {  
        case SET_DRV_DEBUG:  
            dbg_print("%s driver debug now.\n", DISABLE == arg ? "Disable" : "Enable");  
            debug = (0==arg) ? DISABLE : ENABLE;  
            break;  
        case GET_DRV_VER:  
            print_version(DRV_VERSION);  
            return DRV_VERSION;  
  
        case LED_OFF:  
            if(pdata->nleds <= arg)  
            {  
               printk("LED%ld doesn't exist\n", arg);    
               return -ENOTTY;  
            }  
            pdata->leds[arg].status = OFF;  
            pdata->leds[arg].blink = DISABLE;  
            break;  
  
        case LED_ON:  
            if(pdata->nleds <= arg)  
            {  
               printk("LED%ld doesn't exist\n", arg);    
               return -ENOTTY;  
            }  
            pdata->leds[arg].status = ON;  
            pdata->leds[arg].blink = DISABLE;  
            break;  
  
        case LED_BLINK:  
            if(pdata->nleds <= arg)  
            {  
               printk("LED%ld doesn't exist\n", arg);    
               return -ENOTTY;  
            }  
            pdata->leds[arg].blink = ENABLE;  
            pdata->leds[arg].status = ON;  
            break;  
  
        default:   
            dbg_print("%s driver don't support ioctl command=%d\n", DEV_NAME, cmd);   
            print_led_help();  
            return -EINVAL;  
  
    }  
    return 0;  
}  
  
  
static struct file_operations led_fops = {   
    .owner = THIS_MODULE,   
    .open = led_open,   
    .release = led_release,   
    .unlocked_ioctl = led_ioctl, /* compatible with kernel version >=2.6.38*/  
};  
  
  
static int s3c_led_probe(struct platform_device *dev) //设备和驱动相互识别是调用由内核把platform_device传到probe函数  
{  
    struct s3c_led_platform_data *pdata = dev->dev.platform_data;   
    int result = 0;  
    int i;  
    dev_t devno;  
  
    /* Initialize the LED status */  
    for(i=0; i<pdata->nleds; i++)  
    {  
         s3c2410_gpio_cfgpin(pdata->leds[i].gpio, S3C2410_GPIO_OUTPUT);  
         if(ON == pdata->leds[i].status)  
         {  
            s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level);   
         }  
         else  
         {  
            s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);   
         }  
    }  
  
    /*  Alloc the device for driver */  
    if (0 != dev_major)   
    {   
        devno = MKDEV(dev_major, dev_minor);   
        result = register_chrdev_region(devno, 1, DEV_NAME);   
    }   
    else   //动态分配主次设备号 
    {   
        result = alloc_chrdev_region(&devno, dev_minor, 1, DEV_NAME);   
        dev_major = MAJOR(devno);   
    }  
  
    /* Alloc for device major failure */   
    if (result < 0)   
    {   
        printk("%s driver can't get major %d\n", DEV_NAME, dev_major);   
        return result;   
    }  
  
    /* Initialize button structure and register cdev*/  
    memset(&led_device, 0, sizeof(led_device));  
    led_device.data = dev->dev.platform_data;  
    cdev_init (&(led_device.cdev), &led_fops);  
    led_device.cdev.owner  = THIS_MODULE;  
  
    result = cdev_add (&(led_device.cdev), devno , 1);   
    if (result)   
    {   
        printk (KERN_NOTICE "error %d add %s device", result, DEV_NAME);   
        goto ERROR;   
    }   
      
    led_device.dev_class = class_create(THIS_MODULE, DEV_NAME);   
    if(IS_ERR(led_device.dev_class))   
    {   
        printk("%s driver create class failture\n",DEV_NAME);   
        result =  -ENOMEM;   
        goto ERROR;   
    }  
  
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)       
   
  
    device_create(led_device.dev_class, NULL, MKDEV(dev_major,0), NULL, DEV_NAME);  
  
#else  
    device_create (led_device.dev_class, NULL, MKDEV(dev_major,0), DEV_NAME);  
#endif  
  
    /*  Initial the LED blink timer 初始化闪烁定时器 */  
    init_timer(&(led_device.blink_timer));  
    led_device.blink_timer.function = led_timer_handler;  
    led_device.blink_timer.data = (unsigned long)pdata;  
    led_device.blink_timer.expires  = jiffies + TIMER_TIMEOUT;//jiffies为当前时间  
    add_timer(&(led_device.blink_timer));   
  
    printk("S3C %s driver version %d.%d.%d initiliazed.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER);   
  
    return 0;  
                 
  
ERROR:   
    printk("S3C %s driver version %d.%d.%d install failure.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER);   
    cdev_del(&(led_device.cdev));   
  
    unregister_chrdev_region(devno, 1);   
    return result;  
  
}  
  
static int s3c_led_remove(struct platform_device *dev)  //释放主次设备号给Linux内核
{  
    dev_t devno = MKDEV(dev_major, dev_minor);  
  
    del_timer(&(led_device.blink_timer));  
  
    cdev_del(&(led_device.cdev));   
    //for()  
    device_destroy(led_device.dev_class, devno);   
    class_destroy(led_device.dev_class);   
      
    unregister_chrdev_region(devno, 1);   
    printk("S3C %s driver removed\n", DEV_NAME);  
  
    return 0;  
}  
  
  
static struct platform_driver s3c_led_driver = {   //定义总线驱动结构体 
    .probe      = s3c_led_probe,   //注册设备主次设备号
    .remove     = s3c_led_remove,   
    .driver     = {   
        .name       = "s3c_led",   
        .owner      = THIS_MODULE,   
    },  
};  
  
  
static int __init s3c_led_init(void)  
{  
   int       ret = 0;  
  
   ret = platform_device_register(&s3c_led_device);  
   if(ret)  
   {  
        printk(KERN_ERR "%s:%d: Can't register platform device %d\n", __FUNCTION__,__LINE__, ret);   
        goto fail_reg_plat_dev;  
   }  
   dbg_print("Regist S3C LED Platform Device successfully.\n");  
  
   ret = platform_driver_register(&s3c_led_driver);  
   if(ret)  
   {  
        printk(KERN_ERR "%s:%d: Can't register platform driver %d\n", __FUNCTION__,__LINE__, ret);   
        goto fail_reg_plat_drv;  
   }  
   dbg_print("Regist S3C LED Platform Driver successfully.\n");  
  
   return 0;  
  
fail_reg_plat_drv:  
   platform_driver_unregister(&s3c_led_driver);  
fail_reg_plat_dev:  
   return ret;  
}  
  
  
static void s3c_led_exit(void)  
{  
    dbg_print("%s():%d remove LED platform drvier\n", __FUNCTION__,__LINE__);  
    platform_driver_unregister(&s3c_led_driver);  
    dbg_print("%s():%d remove LED platform device\n", __FUNCTION__,__LINE__);  
    platform_device_unregister(&s3c_led_device);  
}  
  
module_init(s3c_led_init);  
module_exit(s3c_led_exit);  
  
module_param(debug, int, S_IRUGO);  
module_param(dev_major, int, S_IRUGO);  
module_param(dev_minor, int, S_IRUGO);  
  
MODULE_AUTHOR(DRV_AUTHOR);  
MODULE_DESCRIPTION(DRV_DESC);  
MODULE_LICENSE("GPL");  
MODULE_ALIAS("platform:S3C24XX_led");

Makefile: 

obj-m:=plat_led.c  
C=/opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc  
KDIR?=/home/fanmaolin/fl2440/kernel/linux-3.0  
obj-m:=plat_led.o  
   
default:  
        $(MAKE) -C $(KDIR) M=`pwd` modules  
        make clean  
   
clean:  
        rm -f *.o *mod.c *.order *.symvers


make


测试程序vim plat_ioctl.c： 

 1 /*********************************************************************************
  2  *      Copyright:  (C) 2017 fanmaolin<fanmaolinn@gmail.com>
  3  *                  All rights reserved.
  4  *
  5  *       Filename:  plat_testled.c
  6  *    Description:  This file 
  7  *                 
  8  *        Version:  1.0.0(03/25/2017)
  9  *         Author:  fanmaolin <fanmaolinn@gmail.com>
        
 10  *      ChangeLog:  1, Release initial version on "03/25/2017 05:24:09 PM"
 11  *                 
 12  ********************************************************************************/
 13 
 14 #include <stdio.h>
 15 #include <stdarg.h>
 16 #include <fcntl.h>
 17 #include <sys/types.h>
 18 #include <errno.h>
 19 #include <sys/ioctl.h>
 20 #include <sys/stat.h>
 21 #include <unistd.h>
 22 #include <stdlib.h>
 23 #define PLATDRV_MAGIC             0x60  
 24 #define LED_OFF                   _IO (PLATDRV_MAGIC, 0x18)  
 25 #define LED_ON                    _IO (PLATDRV_MAGIC, 0x19)  
 26 #define LED_BLINK                 _IO (PLATDRV_MAGIC, 0x1A)  
 27 #define  DEVNAMELEN 10  
 28 int main (int argc,char **argv)
 29 {
 30         int fd;
 31         fd=open("dev/led",O_RDWR);
 32         ioctl(fd,LED_ON,0);
 33         ioctl(fd,LED_BLINK,1);
 34         ioctl(fd,LED_ON,2);
 35         ioctl(fd,LED_BLINK,4);
 36         close(fd);
 37         return 0;
 38 }


[fanmaolin@Centeros platform]$ /opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc plat_testled.c 

编译后在开发板上操作，与之前不同的是这一次程序中有了自动挂载的代码：

   
    led_device.dev_class = class_create(THIS_MODULE, DEV_NAME);   
    if(IS_ERR(led_device.dev_class))   
    {   
        printk("%s driver create class failture\n",DEV_NAME);   
        result =  -ENOMEM;   
        goto ERROR;   
    }  
  
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)       
   
  
    device_create(led_device.dev_class, NULL, MKDEV(dev_major,0), NULL, DEV_NAME);  
  
#else  
    device_create (led_device.dev_class, NULL, MKDEV(dev_major,0), DEV_NAME);  
#endif



>: tftp -gr a.out 192.168.1.2
a.out                100% |*******************************|  5139   0:00:00 ETA

>: insmod plat_led.ko 
S3C led driver version 1.0.0 initiliazed.
>: ./a.out 

你会看到1、3灯常亮，2、4灯闪烁

问题总结分析：

[fanmaolin@Centeros platform]$ make
make -C /home/fanmaolin/fl2440/kernel/linux-3.0   M=`pwd` modules 
make[1]: Entering directory `/home/fanmaolin/fl2440/kernel/linux-3.0'
  CC [M]  /home/fanmaolin/fl2440/driver/led/platform/plat_led.o
/home/fanmaolin/fl2440/driver/led/platform/plat_led.c:1:26: fatal error: s3c_driver.h: No such file or directory
compilation terminated.
make[2]: *** [/home/fanmaolin/fl2440/driver/led/platform/plat_led.o] Error 1
make[1]: *** [_module_/home/fanmaolin/fl2440/driver/led/platform] Error 2
make[1]: Leaving directory `/home/fanmaolin/fl2440/kernel/linux-3.0'
make: *** [default] Error 2
缺少部分头文件，加在当前目录下即可参考http://blueshaw.blog.163.com/blog/static/21633118120138249298645/头文件的有关知识

s3c_drive.h:

#ifndef __S3C_DRIVER_H  
#define __S3C_DRIVER_H  
  
#include <linux/version.h>  
#include <linux/kernel.h>  
#include <linux/errno.h>  
#include <linux/init.h>  
#include <linux/slab.h>  
#include <linux/module.h>  
#include <linux/kref.h>  
#include <linux/spinlock.h>  
#include <asm/uaccess.h>  
#include <linux/mutex.h>  
#include <linux/delay.h>  
#include <linux/fs.h>  
#include <linux/device.h>  
#include <linux/i2c.h>  
#include <linux/string.h>  
#include <linux/bcd.h>  
#include <linux/miscdevice.h>  
#include <linux/poll.h>  
#include <linux/irq.h>  
#include <linux/interrupt.h>  
#include <linux/sysfs.h>  
#include <linux/proc_fs.h>  
#include <linux/rtc.h>  
#include <linux/spinlock.h>  
#include <linux/usb.h>  
#include <asm/uaccess.h>  
#include <asm/delay.h>  
#include <linux/syscalls.h>  /* For sys_access*/  
#include <linux/platform_device.h>  
#include <linux/unistd.h>  
#include <linux/tty.h>  
#include <linux/tty_flip.h>  
#include <linux/serial.h>  
#include <linux/serial_core.h>  
#include <linux/irq.h>  
#include <mach/regs-gpio.h>  
  
  
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)  
#include <mach/hardware.h>  
#include <mach/gpio.h>  
#include <asm/irq.h>  
#else  
#include <asm-arm/irq.h>  
#include <asm/arch/gpio.h>  
#include <asm/arch/hardware.h>  
#endif  
#include "plat_ioctl.h"  
  
/* =========================================================================== 
 *  *         S3C24XX device driver common macro definition 
 *   *===========================================================================*/  
  
#define ENPULLUP                    1  
#define DISPULLUP                   0  
  
#define HIGHLEVEL                   1  
#define LOWLEVEL                    0  
  
#define INPUT                       1  
#define OUTPUT                      0  
  
#define OFF                         0  
#define ON                          1  
  
#define ENABLE                      1  
#define DISABLE                     0  
  
#define TRUE                        1  
#define FALSE                       0  
  
/* =========================================================================== 
 *  *         S3C24XX device driver name and Major number define 
 *   *===========================================================================*/  
  
  
#define DEV_LED_NAME                "led"  
#define DEV_LED_MAJOR               203  
  
#define DEV_BUTTON_NAME             "button"  
#define DEV_BUTTON_MAJOR            "211"  
  
#define DEV_ADC_NAME                "adc"  
#define DEV_ADC_MAJOR               "212"  
  
/*  ***** Bit Operate Define *****/  
#define SET_BIT(data, i)   ((data) |=  (1 << (i)))    /*   Set the bit "i" in "data" to 1  */  
#define CLR_BIT(data, i)   ((data) &= ~(1 << (i)))    /*   Clear the bit "i" in "data" to 0 */  
#define NOT_BIT(data, i)   ((data) ^=  (1 << (i)))    /*   Inverse the bit "i" in "data"  */  
#define GET_BIT(data, i)   ((data) >> (i) & 1)        /*   Get the value of bit "i"  in "data" */  
#define L_SHIFT(data, i)   ((data) << (i))            /*   Shift "data" left for "i" bit  */  
#define R_SHIFT(data, i)   ((data) >> (i))            /*   Shift "data" Right for "i" bit  */  
  
  
/* =========================================================================== 
 *  *         S3C24XX device driver common function definition 
 *   *===========================================================================*/  
  
#define SLEEP(x)    {DECLARE_WAIT_QUEUE_HEAD (stSleep); if (10 > x) mdelay ((x * 1000)); \  
                        else wait_event_interruptible_timeout (stSleep, 0, (x / 10));}  
  
#define VERSION_CODE(a,b,c)       ( ((a)<<16) + ((b)<<8) + (c))  
#define DRV_VERSION               VERSION_CODE(DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER)  
#define MAJOR_VER(a)              ((a)>>16&0xFF)  
#define MINOR_VER(a)              ((a)>>8&0xFF)  
#define REVER_VER(a)              ((a)&0xFF)  
  
#define dbg_print(format,args...) if(DISABLE!=debug) \  
        {printk("[kernel] ");printk(format, ##args);}  
  
static inline void print_version(int version)  
{  
#ifdef __KERNEL__  
        printk("%d.%d.%d\n", MAJOR_VER(version), MINOR_VER(version), REVER_VER(version));  
#else  
        printf("%d.%d.%d\n", MAJOR_VER(version), MINOR_VER(version), REVER_VER(version));  
#endif  
}  
  
  
#endif /* __S3C_DRIVER_H */

plat_ioctl.h:

  1. #ifndef __PLAT_IOCTL_H  
  2. #define __PLAT_IOCTL_H  
  3.   
  4. #include <asm/ioctl.h>  
  5.   
  6. /*=========================================================================== 
  7.  *  *                Common ioctl command definition 
  8.  *   *===========================================================================*/  
  9.   
  10. #define PLATDRV_MAGIC           0x60  
  11.   
  12. /*=========================================================================== 
  13.  *  *                 ioctl command for all the drivers 0x01~0x0F 
  14.  *   *===========================================================================*/  
  15.   
  16. /*args is enable or disable*/  
  17. #define SET_DRV_DEBUG               _IO (PLATDRV_MAGIC, 0x01)  
  18. #define GET_DRV_VER                 _IO (PLATDRV_MAGIC, 0x02)  
  19.   
  20. /*=========================================================================== 
  21.  *  *                 ioctl command for few ioctl() cmd driver 0x10~0x2F 
  22.  *   *===========================================================================*/  
  23.   
  24. /* LED driver */  
  25. #define LED_OFF                     _IO (PLATDRV_MAGIC, 0x18)  
  26. #define LED_ON                      _IO (PLATDRV_MAGIC, 0x19)  
  27. #define LED_BLINK                   _IO (PLATDRV_MAGIC, 0x1A)  
  28. #define ADC_SET_CHANNEL             _IO (PLATDRV_MAGIC, 0x1B)  
  29.   
  30. /*=========================================================================== 
  31.  *  *                   ioctl command for GPRS driver 0x30~0x4F 
  32.  *   *===========================================================================*/  
  33. #define GPRS_POWERDOWN              _IO (PLATDRV_MAGIC, 0x30)  
  34. #define GPRS_POWERON                _IO (PLATDRV_MAGIC, 0x31)  
  35. #define GPRS_RESET                  _IO (PLATDRV_MAGIC, 0x32)  
  36. #define GPRS_POWERMON               _IO (PLATDRV_MAGIC, 0x33)  
  37. #define GPRS_CHK_SIMDOOR            _IO (PLATDRV_MAGIC, 0x36)  
  38. #define GPRS_SET_DTR                _IO (PLATDRV_MAGIC, 0x37)  
  39. #define GPRS_SET_RTS                _IO (PLATDRV_MAGIC, 0x38)  
  40. #define GPRS_GET_RING               _IO (PLATDRV_MAGIC, 0x39)  
  41. #define SET_PWUP_TIME               _IO (PLATDRV_MAGIC, 0x3A)  
  42. #define SET_PWDOWN_TIME             _IO (PLATDRV_MAGIC, 0x3B)  
  43. #define SET_RESET_TIME              _IO (PLATDRV_MAGIC, 0x3C)  
  44. #define GPRS_CHK_MODEL              _IO (PLATDRV_MAGIC, 0x3E)  
  45.   
  46. /*=========================================================================== 
  47.  *  *                   ioctl command for EEPROM driver 0x50~0x5F 
  48.  *   *===========================================================================*/  
  49. #define LL_POWEROFF                 _IO (PLATDRV_MAGIC, 0x50)  
  50. #define LL_POWERON                  _IO (PLATDRV_MAGIC, 0x51)  
  51. #define LL_STOP                     _IO (PLATDRV_MAGIC, 0x52)  
  52. #define LL_START                    _IO (PLATDRV_MAGIC, 0x53)  
  53. #define LL_READ                     _IO (PLATDRV_MAGIC, 0x54)  
  54. #define LL_WRITE                    _IO (PLATDRV_MAGIC, 0x55)  
  55. #define LL_DATALOW                  _IO (PLATDRV_MAGIC, 0x56)  
  56. #define LL_ACKNAK                   _IO (PLATDRV_MAGIC, 0x57)  
  57.   
  58.   
  59. #endif                          /* __PLAT_IOCTL_H */  







035_platform_led
嵌入式
03-26 220
一、驱动测试源码 platform_led_device.c #include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> #include <linux/platform_device.h> MODU...
Linux驱动：用platform平台总线驱动编写一个led驱动
weixin_44498318的博客
11-27 690
文章目录1、平台总线1.1 简介1.2 相关API函数1.2.1 平台设备1.2.2 平台驱动1.3 驱动程序框架1.3.1 平台设备1.3.2 平台驱动3、平台驱动和平台设备老式写法（不使用设备树写法）3.1 平台设备3.2 平台驱动4、平台驱动和平台设备新式写法（使用设备树写法）4.1 平台设备（设备树节点）4.2 平台驱动（驱动代码）5、测试程序6、内核中的led驱动 1、平台总线 1.1 简介   platform平台总线并不是像usb、i2c那些物理的总线，它是在软件上实现的一种“虚拟”总线。它的
led驱动测试程序
luliteng的博客
05-04 476
1 /*********************************************************************************    2  *      Copyright:  (C) 2017 minda    3  *                  All rights reserved.    4  *    5  *       Fil
Linux嵌入式驱动初体验（六）--- LED驱动测试程序
Mr.Right
09-25 3201
<br />      通过上一篇文章，我们已经写好了一个LED驱动，但是如果光运行这个驱动程序（其实它是一个模块程序，不能称之为运行），LED灯是不会亮的，驱动程序的作用其实就相当于编写了一些库函数一样，当驱动程序通过编译，然后以模块的形式加载到内核之后，这些函数就是可以用的了，然后通过调用这些函数来实现设备的使用。原理就是这么个原理，下面就根据上一篇文章得到的那些函数，来写一个能够让LED闪烁的，称之为测试程序的代码。<br />      其实代码并不长，重点在于编写的模式和思路。对于一个设备来说，L
小小的led驱动和测试程序
fight_onlyfor_you的博客
02-27 371
使用的板子为gec210的板子 #include #include #include #include #include #include #include #include #include #include #include #define LEDCON 0xe0200280  //led控制寄存器的物理地址 #define LE
基于platform驱动模型的LED驱动
2621593260的专栏
04-20 1300
上一篇博文《platform设备驱动框架搭建分析》主要是根据内核源码来分析platform驱动模型工作的原理，在实际的驱动开发中如何使用Linux的这么一种模型来管理这种类型的设备呢？把tq2440开发板上的LED1当做是平台设备注册到Linux系统中，让系统可以用这种platform驱动来管理他。 ①总线层：代码不用我们自己去写，内核已经提供了 ②设备层：向platform总线层注册硬件相关
linux platform tree下的led驱动程序
02-21
9. **调试工具**：如`ledctl`命令行工具，可以用来测试和调试LED驱动，方便开发过程中验证驱动程序的功能。 10. **电源管理**：考虑电源效率，LED驱动程序可能需要实现电源管理功能，如在设备待机时关闭LED，以减少...
利用Linux的Platform总线设备驱动实现对多个LED的驱动【只是假想对LED进行驱动,并没有实际的硬件操作】【Makefile如何书写能生成多个模块文件】【总线设备驱动的好处】
最新发布
昊虹AI笔记
01-10 726
Platform 总线设备驱动是一种基于 Linux 驱动模型的驱动框架，专门用于管理片上系统 (SoC) 内部的硬件资源。这种框架非常适合开发嵌入式设备中与具体硬件总线无关的驱动程序，例如板载 LED、GPIO、按键等。1. Platform 总线设备驱动的基本概念Platform 总线 (Platform Bus)是一种虚拟总线，与硬件无关，用于匹配设备（）和驱动（Platform 设备 (Platform Device)表示具体的硬件资源，例如板载的 LED、UART 控制器等。
【Linux驱动】platform 设备驱动分离（二）—— LED驱动（无设备树）
challenglistic的博客
01-12 1285
【Linux驱动】platform 设备驱动分离（二）—— LED驱动（无设备树）
基于Linux的LED驱动程序设计.doc
02-23
在嵌入式系统开发中，LED驱动程序设计是一项基础但至关重要的任务，尤其是在Linux环境下。Linux作为一个开源的操作系统，广泛应用于各种嵌入式设备，包括基于ARM微处理器的硬件平台如S3C6410。本课程设计的目标是让...
字符设备驱动程序之LED驱动程序_测试改进
cumtchw
04-15 567
前面我们写了一个初步的led驱动程序框架，下面来简单测试一下。使用如下的makefile编译 KERN_DIR = /work/system/linux-2.6.22.6 all: make -C $(KERN_DIR) M=`pwd` modules clean: make -C $(KERN_DIR) M=`pwd` modules clean rm -rf modules.order obj-m += first_drv.o 编译得到first_drv.ko，在加载之前我们先用c
platform之LED测试
Peter_tang6的博客
04-25 467
知不足，然后能自反也;知困，然后能自强也 ——《礼记》 前面学习了platform总线驱动，虽然它的测试程序和普通总线LED差不多，但是还是给一个测试程序吧。 /********************************************************************************* * Copyright: (C) 2017 mi
platform_led驱动
hongfuhaocomon的博客
10-27 282
驱动程序： [hongfuhao@centos6 platform_led]$ ls plat_led. [hongfuhao@centos6 platform_led]$ vim plat_led.c [cpp] view plain copy  print? /*************************************
基于设备树的platform驱动之LED（平台设备驱动）
RyanLee90的博客
04-26 1115
platform 驱动框架分为总线、设备和驱动。总线：是 Linux 内核提供的，不需要我们这些驱动程序员去管理。我们在编写驱动的时候只要关注于设备和驱动的具体实现即可。设备、驱动：在没有设备树的 Linux 内核下，我们需要分别编写并注册 platform_device 和platform_driver，分别代表设备和驱动。在使用设备树的时候，设备的描述被放到了设备树中，因此 platform_device 就不需要我们去编写了，我们只需要实现 platform_driver 即可。
FL2440开发板 platform_led驱动及应用程序
LYX_WIN
07-28 1050
FL2440开发板 platform_led驱动及应用程序 驱动程序： [leiyuxing@centos6 platform_led]$ ls plat_led.c [leiyuxing@centos6 platform_led]$ vim plat_led.c /*********************************************************
platform 设备驱动实验
zhuguanlin121的博客
11-09 1088
目录Linux 驱动的分离与分层驱动的分隔与分离驱动的分层platform 平台驱动模型简介platform 总线platform 驱动platform 设备硬件原理图分析试验程序编写platform 设备与驱动程序编写测试APP 编写54.5 运行测试编译驱动程序和测试APP运行测试 我们在前面几章编写的设备驱动都非常的简单，都是对IO 进行最简单的读写操作。像I2C、SPI、LCD 等这些复杂外设的驱动就不能这么去写了，Linux 系统要考虑到驱动的可重用性，因此提出了驱动的分离与分层这样的软件思路，在
platform设备驱动实验（led灯为例）
weixin_56755662的博客
03-31 557
根据总线-驱动-设备驱动模型，IIC、SPI、USB这样实实在在的总线是完全匹配的，但是要有一些外设是没法归结为具体的总线：比如定时器、RTC、LCD等。为此linux内核创造了一个虚拟的总线：platform总线。 1、方便开发，linux提出了驱动分离与分层。 2、进一步引出了驱动-总线-设备驱动模型，或者框架。 3、对于SOC内部的RTC，timer等等不好归结为具体的总线，为此linux内核提出了一个虚拟总线：platform总线，platform设备...
基于platform驱动框架编写LED灯的驱动
liu319293960_的博客
06-25 367
【代码】基于platform驱动框架编写LED灯的驱动。
arm Linux 驱动LED子系统 测试
06-28 428
Linux内核在3.0以上引入了设备树概念（具体哪个版本不清楚）在编译内核后需要将与之对应的dtb文件也下载人板子上才能使内核与硬件关联起来。 dtb文件是有dts文件编译后生成的：例如 /* * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/ * * This progra...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值