飛凌2440開發板的led驅動和應用程序

原創 关在家 2020-06-23 20:24

led驅動程序

#include <linux/module.h>   /* Every Linux kernel module must include this head */
#include <linux/init.h>     /* Every Linux kernel module must include this head */
#include <linux/kernel.h>   /* printk() */
#include <linux/fs.h>       /* struct fops */
#include <linux/errno.h>    /* error codes */
#include <linux/cdev.h>     /* cdev_alloc()  */
#include <asm/io.h>         /* ioremap()  */
#include <linux/ioport.h>   /* request_mem_region() */


#include <asm/ioctl.h>      /* Linux kernel space head file for macro _IO() to generate ioctl command  */
#ifndef __KERNEL__
#include <sys/ioctl.h>      /* User space head file for macro _IO() to generate ioctl command */
#endif
//#include <linux/printk.h> /* Define log level KERN_DEBUG, no need include here */


#define DRV_DESC                  "S3C24XX LED driver"


#define DEV_NAME                  "led"
#define LED_NUM                   4


/* Set the LED dev major number */
//#define LED_MAJOR                 79
#ifndef LED_MAJOR
#define LED_MAJOR                 0
#endif


#define DRV_MAJOR_VER             1
#define DRV_MINOR_VER             0
#define DRV_REVER_VER             0


#define DISABLE                   0
#define ENABLE                    1


#define GPIO_INPUT                0x00
#define GPIO_OUTPUT               0x01




#define PLATDRV_MAGIC             0x60
#define LED_OFF                   _IO (PLATDRV_MAGIC, 0x18)
#define LED_ON                    _IO (PLATDRV_MAGIC, 0x19)


#define S3C_GPB_BASE              0x56000010
#define GPBCON_OFFSET             0
#define GPBDAT_OFFSET             4
#define GPBUP_OFFSET              8
#define S3C_GPB_LEN               0x10        /* 0x56000010~0x56000020  */


int led[LED_NUM] = {5,6,8,10};  /* Four LEDs use GPB5,GPB6,GPB8,GPB10 */


static void __iomem *s3c_gpb_membase;




#define s3c_gpio_write(val, reg) __raw_writel((val), (reg)+s3c_gpb_membase)      //#define __raw_readl(a)   (__chk_io_ptr(a), *(volatile unsigned int __force   *)(a))
#define s3c_gpio_read(reg)       __raw_readl((reg)+s3c_gpb_membase)              //#define __raw_writel(v,a) (__chk_io_ptr(a), *(volatile unsigned int __force   *)(a) = (v))




int dev_count = ARRAY_SIZE(led);
int dev_major = LED_MAJOR;
int dev_minor = 0;
int debug = DISABLE;


static struct cdev      *led_cdev;


static int s3c_hw_init(void)       //初始化硬件的函數
{
    int          i;
    volatile unsigned long  gpb_con, gpb_dat, gpb_up;


    if(!request_mem_region(S3C_GPB_BASE, S3C_GPB_LEN, "s3c2440 led"))  //申請一段內存空間失敗的話返回爲0
    {
        return -EBUSY;
    }


    if( !(s3c_gpb_membase=ioremap(S3C_GPB_BASE, S3C_GPB_LEN)) )   //物理地址到虛擬地址的映射  此時開啓了MMU
    {
        release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);   
        return -ENOMEM;
    }


    for(i=0; i<dev_count; i++)
    {
        /* Set GPBCON register, set correspond GPIO port as input or output mode  */
        gpb_con = s3c_gpio_read(GPBCON_OFFSET); 
        gpb_con &= ~(0x3<<(2*led[i]));   /* Clear the currespond LED GPIO configure register */
        gpb_con |= GPIO_OUTPUT<<(2*led[i]); /* Set the currespond LED GPIO as output mode */
        s3c_gpio_write(gpb_con, GPBCON_OFFSET);


        /* Set GPBUP register, set correspond GPIO port pull up resister as enable or disable  */
        gpb_up = s3c_gpio_read(GPBUP_OFFSET);
        //gpb_up &= ~(0x1<<led[i]); /* Enable pull up resister */
        gpb_up |= (0x1<<led[i]);  /* Disable pull up resister */
        s3c_gpio_write(gpb_up, GPBUP_OFFSET);


        /* Set GPBDAT register, set correspond GPIO port power level as high level or low level */
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);
        //gpb_dat &= ~(0x1<<led[i]); /* This port set to low level, then turn LED on */
        gpb_dat |= (0x1<<led[i]);  /* This port set to high level, then turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
    }


    return 0;
}




static void turn_led(int which, unsigned int cmd)   //ioctl 會調用的函數來控制led的開關
{
    volatile unsigned long  gpb_dat;


    gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);


    if(LED_ON == cmd)
    {
        gpb_dat &= ~(0x1<<led[which]); /*  Turn LED On */
    }
    else if(LED_OFF == cmd)
    {
        gpb_dat |= (0x1<<led[which]);  /*  Turn LED off */
    }


    s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
}


static void s3c_hw_term(void)    //在rmmode的時候會調用 做一些清理的工作 關燈和 內存釋放取消地址的映射
{
    int                     i;
    volatile unsigned long  gpb_dat;


    for(i=0; i<dev_count; i++)
    {
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);
        gpb_dat |= (0x1<<led[i]);  /* Turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
    }


    release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);  //宏，釋放指定的I/O內存資源  #define release_mem_region(start,n) __release_region(&iomem_resource, (start), (n)) 
    iounmap(s3c_gpb_membase);  //iounmap函數用於取消ioremap（）所做的映射
}




static int led_open(struct inode *inode, struct file *file)   //傳給file_opertion的.open 函數 就是給函數鉤子賦值
{
    int minor = iminor(inode);    //iminor這個宏在 inode的這個結構體中有定義 這個宏是用來獲得此設備號


    file->private_data = (void *)minor;


    printk(KERN_DEBUG "/dev/led%d opened.\n", minor);
    return 0;
}


static int led_release(struct inode *inode, struct file *file)     //在file_opertion 結構體中給.release 函數鉤子 賦值
{
    printk(KERN_DEBUG "/dev/led%d closed.\n", iminor(inode));


    return 0;
}


static void print_help(void)
{
    printk("Follow is the ioctl() commands for %s driver:\n", DEV_NAME);
    //printk("Enable Driver debug command: %u\n", SET_DRV_DEBUG);
    printk("Turn LED on command  : %u\n", LED_ON);
    printk("Turn LED off command : %u\n", LED_OFF);


    return;
}


static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int which = (int)file->private_data;


    switch (cmd)
    {
        case LED_ON:


            turn_led(which, LED_ON);
            break;


        case LED_OFF:
            turn_led(which, LED_OFF);
            break;
    
        default:
            printk(KERN_ERR "%s driver don't support ioctl command=%d\n", DEV_NAME, cmd);
            print_help();
            break;
    }


    return 0;
}




static struct file_operations led_fops = 
{
    .owner = THIS_MODULE,
    .open = led_open,
    .release = led_release,  
    .unlocked_ioctl = led_ioctl,
};


static int __init s3c_led_init(void)
{
    int                    result;    //
    dev_t                  devno;    //設備編號


    if( 0 != s3c_hw_init() )
    {
        printk(KERN_ERR "s3c2440 LED hardware initialize failure.\n");
        return -ENODEV;
    }


    /*  Alloc the device for driver */
    if (0 != dev_major) /*  Static */
    {
        devno = MKDEV(dev_major, 0);            // 將主設備號和次設備號轉換成dev_t 即轉換成設備編號
        result = register_chrdev_region (devno, dev_count, DEV_NAME);   //如果分配成功進行, register_chrdev_region 的返回值是 0,失敗的話返回個了負數 不能存取請求的空間
    }
    else
    {
        result = alloc_chrdev_region(&devno, dev_minor, dev_count, DEV_NAME); //在上面靜態分配出錯時，就會使用該函數動態分配。&devno就是爲把分配的設備編號放在這個地址
        dev_major = MAJOR(devno);
    }


    /*  Alloc for device major failure */
    if (result < 0)   
    {
        printk(KERN_ERR "S3C %s driver can't use major %d\n", DEV_NAME, dev_major);
        return -ENODEV;
    } 
    printk(KERN_DEBUG "S3C %s driver use major %d\n", DEV_NAME, dev_major);


    if(NULL == (led_cdev=cdev_alloc()) )     
    {
        printk(KERN_ERR "S3C %s driver can't alloc for the cdev.\n", DEV_NAME);
        unregister_chrdev_region(devno, dev_count);
        return -ENOMEM;
    }
    
    led_cdev->owner = THIS_MODULE;
    cdev_init(led_cdev, &led_fops);


    result = cdev_add(led_cdev, devno, dev_count);
    if (0 != result)
    {   
        printk(KERN_INFO "S3C %s driver can't reigster cdev: result=%d\n", DEV_NAME, result); 
        goto ERROR;
    }


            
    printk(KERN_ERR "S3C %s driver[major=%d] version %d.%d.%d installed successfully!\n", 
            DEV_NAME, dev_major, DRV_MAJOR_VER, DRV_MINOR_VER,DRV_REVER_VER);
    return 0;




ERROR:
    printk(KERN_ERR "S3C %s driver installed failure.\n", DEV_NAME);
    cdev_del(led_cdev);
    unregister_chrdev_region(devno, dev_count);
    return result;
}


static void __exit s3c_led_exit(void)
{
    dev_t devno = MKDEV(dev_major, dev_minor);


    s3c_hw_term();


    cdev_del(led_cdev);
    unregister_chrdev_region(devno, dev_count);


    printk(KERN_ERR "S3C %s driver version %d.%d.%d removed!\n", 
            DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER,DRV_REVER_VER);


    return ;
}






/* These two functions defined in <linux/init.h> */
module_init(s3c_led_init);
module_exit(s3c_led_exit);


module_param(debug, int, S_IRUGO);    //在insmod的時候可以傳參   
module_param(dev_major, int, S_IRUGO);


MODULE_AUTHOR(DRV_AUTHOR);
MODULE_DESCRIPTION(DRV_DESC);
MODULE_LICENSE("GPL");

下面是我們應用程序

#include <stdio.h>
  2 #include <sys/ioctl.h>
  3 #include <sys/stat.h>
  4 #include <unistd.h>
  5 #include <stdarg.h>
  6 #include <errno.h>
  7 #include <sys/types.h>   //open
  8 #include <sys/stat.h> //open 
  9 #include <fcntl.h>     //open
 10 #include <string.h>
 11 #include <unistd.h>   //close
 12 
 13 #define  LED_NUM   4
 14 #define   DEVNAMELEN  10
 15 
 16 
 17 
 18 #define  PLATDRV_MAGIC   0x60
 19 #define  LED_ON       _IO(PLATDRV_MAGIC,0x18)
 20 #define  LED_OFF       _IO(PLATDRV_MAGIC,0x19)
 21 
 22 
 23 
 24 int main(int argc, char ** argv)
 25 {
 26     int i;
 27     char dev_name[DEVNAMELEN]={0};
 28     int fd[LED_NUM];
 29     int b;
 30 
 31      for(i=0;i<LED_NUM;i++)
 32     {
 33         snprintf(dev_name,sizeof(dev_name),"/dev/led%i",i);   //snprint 並不是打印在標稱輸出上讓是在發音在第一個參數裏邊
 34         fd[i]=open(dev_name,O_RDWR,755);      
 35        if(fd[i]<0)
 36        {
 37            printf("open file  %s deflout,%s",dev_name,strerror(errno));
 38            for(b=0;b<i;b++)               //如果出錯了把之前打開的文件一定要close
 39           {
 40            if(fd[b]>0)
 41            close(fd[b]);
 42            }
42            }
 43          return -1;
 44        }
 45     }
 46 
 47 
 48 
 49 
 50    while(1)
 51    {
 52 
 53      for(i=0;i<LED_NUM;i++)
 54       {
 55          ioctl(fd[i], LED_ON);
 56          sleep(1);  
 57          ioctl(fd[i], LED_OFF);
 58 
 59       }
 60 
 61     }
 62 
 63       for(i=0;i<LED_NUM;i++)
 64     {
 65         close(fd[i]);
 66     }
 67 }
這個應用程序要用我們自己的交叉編譯器編譯通過之後，再把可執行文件通過tftp放在我們的2440開發板上

 Makefile的編寫

 Makefile                                                                                                                                                              
  1 CC=/opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc
  2 KDIR?=/home/guanlei/fl2440/kernel/linux-3.0
  3 obj-m:=s3c_led.o
  4 
  5 default:
  6     $(MAKE) -C $(KDIR) M=`pwd` modules
  7     make clean
  8 
  9 clean:
 10     rm -f *.ko.* *.o *mod.c *.order *.symvers

make 會生成led.ko的文件，這個文件也是我們所要的led驅動模塊，同樣也把驅動模塊tftp到我們的飛凌2440開發板上，如果完成上邊的步驟在板子上會有我們的ledapp文件和s3c_led.ko的文件。開始加載驅動 

insmod s3c_led.ko這是我們可以看到自己的主設備號【major=252】

因爲在我們的驅動中並沒有自動的創建設備結點所以我們要手動的創建設備結點

mknod  /dev/led0 c 252 0

mknod  /dev/led1 c 252 1

.....             

mknod  /dev/led3 c 252  3                               

查看我們設備文件

ls -l  dev/led* 

下面就是激動人心的時刻 ./ledapp 看見酷炫的跑馬燈了吧！！！！


                                                                                                                                                           

  










發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

file、inode在應用層和驅動層之間的聯繫

應用層和驅動的銜接，一直是一個老大難問題，若弄不清楚，總覺得驅動寫起來似是而非的。下面就說說我對他們的理解，還有就是如何實現一個驅動支持多個上設備的問題。最主要涉及兩個機制：inode和file 在驅動中: (1)、我們先找到一個設備號

关在家 2020-06-23 20:26:10

wait_queue_head_t 使用

1、定義：wait_queue_head_t my_queue; 2、初始化 init_waitqueue_head(&my_queue)； 3、在一個函數裏面等待：wait_event(queue, condition) ;（別在

关在家 2020-06-23 20:25:06

linux內核定時器struct timer_list

     內核中最終的計時資源是定時器。定時器用於定時器超時處理程序在未來某個特定時間點執行，或者週期性的輪詢硬件的狀態。Linux提供了內核定時器完成這類工作。     定時器的只需要執行一些初始化的操作，如：設置一個超時時間，指定

关在家 2020-06-23 20:25:06

如何利用s3c2440的gpio實現數據輸入和輸出

关在家 2020-02-21 21:32:26

plat_led 驅動的應用程序

关在家 2020-02-21 21:32:26

fl2440開發板hello world模塊驅動編寫

关在家 2020-02-21 21:32:26

mdev 自動創建設備結點

关在家 2020-02-21 21:32:25

內核定時器struct timer_list

关在家 2020-02-21 21:32:25

select()函數以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET

关在家 2020-02-21 21:32:25

file、inode在應用層和驅動層之間的聯繫

應用層和驅動的銜接，一直是一個老大難問題，若弄不清楚，總覺得驅動寫起來似是而非的。下面就說說我對他們的理解，還有就是如何實現一個驅動支持多個上設備的問題。最主要涉及兩個機制：inode和file 在驅動中: (1)、我們先找到一個設備號

关在家 2020-06-23 20:26:10

wait_queue_head_t 使用

1、定義：wait_queue_head_t my_queue; 2、初始化 init_waitqueue_head(&my_queue)； 3、在一個函數裏面等待：wait_event(queue, condition) ;（別在

关在家 2020-06-23 20:25:06

linux內核定時器struct timer_list

     內核中最終的計時資源是定時器。定時器用於定時器超時處理程序在未來某個特定時間點執行，或者週期性的輪詢硬件的狀態。Linux提供了內核定時器完成這類工作。     定時器的只需要執行一些初始化的操作，如：設置一個超時時間，指定

关在家 2020-06-23 20:25:06

如何利用s3c2440的gpio實現數據輸入和輸出

关在家 2020-02-21 21:32:26

plat_led 驅動的應用程序

关在家 2020-02-21 21:32:26

fl2440開發板hello world模塊驅動編寫

关在家 2020-02-21 21:32:26