亚洲色情中文字幕,日韩精品三级免费在线日韩a,欧美亚洲国产蜜臀一区

[導讀]寫一個LED點燈驅動： ①框架(在Linux字符設備驅動開發(fā)基礎已經搭建好) ②完善：硬件的操作 a.看原理圖-確定引腳 b.看2440數(shù)據(jù)手冊 c.寫代碼寫代碼注意：裸機

寫一個LED點燈驅動： ①框架(在Linux字符設備驅動開發(fā)基礎已經搭建好) ②完善：硬件的操作

a.看原理圖-確定引腳
b.看2440數(shù)據(jù)手冊
c.寫代碼

寫代碼注意：裸機代碼用的是物理地址PA，驅動代碼用的是虛擬地址VA<虛擬地址需要用ioremap函數(shù)映射>

驅動程序first_drv.c

#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include 

static struct class *firstdrv_class;
static struct class_device *firstdrv_class_dev;
/*第一步 根據(jù)原理圖定義操作寄存器*/
volatile unsigned long *gpfcon = NULL;
volatile unsigned long *gpfdat = NULL;

static int first_drv_open(struct inode *inode,struct file *file)
{
    printk("first_drv_openn");
    //配置GPF456為輸出引腳
    /*第四步 配置Open函數(shù) 將引腳配置為輸出模式*/
    *gpfcon &= ~((0x3<<4*2) | (0x3<<5*2) | (0x3<<6*2));
    *gpfcon |=  ((1<<4*2) | (1<<5*2) | (1<<6*2));
    return 0;
}

static ssize_t first_drv_write(struct file *file,const char __user *buf, size_t count,loff_t *ppos)
{
    int val;
    printk("first_drv_writen");
    /*第五步 將用戶空間的操作內容傳給內核*/
    copy_from_user(&val,buf,count);
    if(1 == val)
    {
        *gpfdat &= ~((1<<4) | (1<<5) | (1<<6));
    }
    else
    {
        *gpfdat |= ((1<<4) | (1<<5) | (1<<6));
    }
    return 0;
}

static struct file_operations first_drv_fops = {
    .owner = THIS_MODULE,   /* 這是一個宏，推向編譯模塊時自動創(chuàng)建的__this_module變量 */
    .open  = first_drv_open,
    .write = first_drv_write,
};

int major;
static int first_drv_init(void)
{
    major = register_chrdev(0,"first_drv",&first_drv_fops);// 注冊，告訴內核
    //printk("first_drv_initn");
    firstdrv_class = class_create(THIS_MODULE, "firstdrv");
    firstdrv_class_dev = class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz"); /* /dev/xyz */
    /*第二步 根據(jù)數(shù)據(jù)手冊 入口函數(shù)映射VA*/
    gpfcon = (volatile unsigned long *)ioremap(0x56000050,16);
    gpfdat = gpfcon + 1;
    return 0;
}

static void first_drv_exit(void)
{
    unregister_chrdev(major,"first_drv");//卸載

    class_device_unregister(firstdrv_class_dev);
    class_destroy(firstdrv_class);
    /*第三步 出口函數(shù)去掉映射*/
    iounmap(gpfcon);
}

module_init(first_drv_init);
module_exit(first_drv_exit);

MODULE_LICENSE("GPL");

驅動測試程序firstdrvtest.c

#include   
#include   
#include   
#include   

/* firstdrvtest on 
 * firstdrvtest off 
 */

int main(int argc, char **argv)
{
    int fd;
    int val = 1;
    fd = open("/dev/xyz",O_RDWR);
    if(fd < 0)
    {
        printf("can't open!n");
    }
    if (argc != 2)
    {
        printf("Usage : n");
        printf("%s n", argv[0] );
        return 0;
    }
    if (strcmp(argv[1],"on") == 0)
    {
        val = 1 ;
    }
    else
    {
        val = 0 ;
    }
    write(fd,&val,4);
    return 0;
}

測試：

①make -編譯驅動程序
②arm-linux-gcc -o firstdrvtest firstdrvtest.c -編譯驅動測試程序
③cp first_drv.ko /work/nfs_root/czg -拷貝至nfs文件夾
④cp firstdrvtest /work/nfs_root/czg -拷貝至nfs文件夾
⑤rmmod first_drv -卸載先前驅動//cat proc/devices 查看
⑥insmod first_drv.ko -加載驅動
⑦./firstdrvtest -測試驅動

實現(xiàn)對硬件的多種情況操作時：

（1）根據(jù)修改傳入?yún)?shù)，執(zhí)行多種操作
（2）通過此設備號的不同來實現(xiàn)，執(zhí)行不同的硬件操作

驅動程序myleds.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define DEVICE_NAME     "leds"  /* 加載模式后，執(zhí)行”cat /proc/devices”命令看到的設備名稱 */
#define LED_MAJOR       231     /* 主設備號 */


static struct class *leds_class;
static struct class_device  *leds_class_devs[4];


/* bit0<=>D10, 0:亮, 1:滅 
 *  bit1<=>D11, 0:亮, 1:滅 
 *  bit2<=>D12, 0:亮, 1:滅 
 */ 
static char leds_status = 0x0;  
static DECLARE_MUTEX(leds_lock); // 定義賦值

//static int minor;
static unsigned long gpio_va;

#define GPIO_OFT(x) ((x) - 0x56000000)
#define GPFCON  (*(volatile unsigned long *)(gpio_va + GPIO_OFT(0x56000050)))
#define GPFDAT  (*(volatile unsigned long *)(gpio_va + GPIO_OFT(0x56000054)))


/* 應用程序對設備文件/dev/leds執(zhí)行open(...)時，
 * 就會調用s3c24xx_leds_open函數(shù)
 */
static int s3c24xx_leds_open(struct inode *inode, struct file *file)
{
    int minor = MINOR(inode->i_rdev); //MINOR(inode->i_cdev);

    switch(minor)
    {
        case 0: /* /dev/leds */
        {
            // 配置3引腳為輸出
            //s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP);
            GPFCON &= ~(0x3<<(4*2));
            GPFCON |= (1<<(4*2));

            //s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
            GPFCON &= ~(0x3<<(5*2));
            GPFCON |= (1<<(5*2));

            //s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_OUTP);
            GPFCON &= ~(0x3<<(6*2));
            GPFCON |= (1<<(6*2));

            // 都輸出0
            //s3c2410_gpio_setpin(S3C2410_GPF4, 0);
            GPFDAT &= ~(1<<4);

            //s3c2410_gpio_setpin(S3C2410_GPF5, 0);
            GPFDAT &= ~(1<<5);
            //s3c2410_gpio_setpin(S3C2410_GPF6, 0);
            GPFDAT &= ~(1<<6);

            down(&leds_lock);
            leds_status = 0x0;
            up(&leds_lock);

            break;
        }

        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF4, 0);

            down(&leds_lock);
            leds_status &= ~(1<<0);
            up(&leds_lock);

            break;
        }

        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF5, 0);
            leds_status &= ~(1<<1);
            break;
        }

        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF6, 0);

            down(&leds_lock);
            leds_status &= ~(1<<2);
            up(&leds_lock);

            break;
        }

    }

    return 0;
}



static int s3c24xx_leds_read(struct file *filp, char __user *buff, 
                                         size_t count, loff_t *offp)
{
    int minor = MINOR(filp->f_dentry->d_inode->i_rdev);
    char val;

    switch (minor)
    {
        case 0: /* /dev/leds */
        {

            copy_to_user(buff, (const void *)&leds_status, 1);                    
            break;
        }

        case 1: /* /dev/led1 */
        {
            down(&leds_lock);
            val = leds_status & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

        case 2: /* /dev/led2 */
        {
            down(&leds_lock);
            val = (leds_status>>1) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

        case 3: /* /dev/led3 */
        {
            down(&leds_lock);
            val = (leds_status>>2) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

    }

    return 1;
}




static ssize_t s3c24xx_leds_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    //int minor = MINOR(inode->i_rdev); //MINOR(inode->i_cdev);
    int minor = MINOR(file->f_dentry->d_inode->i_rdev);
    char val;

    copy_from_user(&val, buf, 1);

    switch (minor)
    {
        case 0: /* /dev/leds */
        {            
            s3c2410_gpio_setpin(S3C2410_GPF4, (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPF5, (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPF6, (val & 0x1));
            down(&leds_lock);
            leds_status = val;
            up(&leds_lock);
            break;
        }

        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF4, val);

            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<0);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<0);                
                up(&leds_lock);
            }
            break;
        }

        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF5, val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<1);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<1);                
                up(&leds_lock);
            }
            break;
        }

        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF6, val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<2);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<2);                
                up(&leds_lock);
            }
            break;
        }

    }

    return 1;
}



/* 這個結構是字符設備驅動程序的核心
 * 當應用程序操作設備文件時所調用的open、read、write等函數(shù)，
 * 最終會調用這個結構中指定的對應函數(shù)
 */
static struct file_operations s3c24xx_leds_fops = {
    .owner  =   THIS_MODULE,    /* 這是一個宏，推向編譯模塊時自動創(chuàng)建的__this_module變量 */
    .open   =   s3c24xx_leds_open,     
    .read   =   s3c24xx_leds_read,     
    .write  =   s3c24xx_leds_write,    
};

/*
 * 執(zhí)行insmod命令時就會調用這個函數(shù) 
 */
static int __init s3c24xx_leds_init(void)
//static int __init init_module(void)

{
    int ret;
    int minor = 0;

    gpio_va = ioremap(0x56000000, 0x100000);
    if (!gpio_va) {
        return -EIO;
    }

    /* 注冊字符設備
     * 參數(shù)為主設備號、設備名字、file_operations結構；
     * 這樣，主設備號就和具體的file_operations結構聯(lián)系起來了，
     * 操作主設備為LED_MAJOR的設備文件時，就會調用s3c24xx_leds_fops中的相關成員函數(shù)
     * LED_MAJOR可以設為0，表示由內核自動分配主設備號
     */
    ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &s3c24xx_leds_fops);
    if (ret < 0) {
      printk(DEVICE_NAME " can't register major numbern");
      return ret;
    }

    leds_class = class_create(THIS_MODULE, "leds");
    if (IS_ERR(leds_class))
        return PTR_ERR(leds_class);



    leds_class_devs[0] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, 0), NULL, "leds"); /* /dev/leds */

    for (minor = 1; minor < 4; minor++)  /* /dev/led1,2,3 */
    {
        leds_class_devs[minor] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, minor), NULL, "led%d", minor);
        if (unlikely(IS_ERR(leds_class_devs[minor])))
            return PTR_ERR(leds_class_devs[minor]);
    }

    printk(DEVICE_NAME " initializedn");
    return 0;
}

/*
 * 執(zhí)行rmmod命令時就會調用這個函數(shù) 
 */
static void __exit s3c24xx_leds_exit(void)
{
    int minor;
    /* 卸載驅動程序 */
    unregister_chrdev(LED_MAJOR, DEVICE_NAME);

    for (minor = 0; minor < 4; minor++)
    {
        class_device_unregister(leds_class_devs[minor]);
    }
    class_destroy(leds_class);
    iounmap(gpio_va);
}

/* 這兩行指定驅動程序的初始化函數(shù)和卸載函數(shù) */
module_init(s3c24xx_leds_init);
module_exit(s3c24xx_leds_exit);

/* 描述驅動程序的一些信息，不是必須的 */
MODULE_AUTHOR("http://www.100ask.net");
MODULE_VERSION("0.1.0");
MODULE_DESCRIPTION("S3C2410/S3C2440 LED Driver");
MODULE_LICENSE("GPL");

驅動測試程序ledtest.c

#include 
#include 
#include 
#include 

/*
  *  ledtest  
  */

void print_usage(char *file)
{
    printf("Usage:n");
    printf("%s  n",file);
    printf("eg. n");
    printf("%s /dev/leds onn", file);
    printf("%s /dev/leds offn", file);
    printf("%s /dev/led1 onn", file);
    printf("%s /dev/led1 offn", file);
}

int main(int argc, char **argv)
{
    int fd;
    char* filename;
    char val;

    if (argc != 3)
    {
        print_usage(argv[0]);
        return 0;
    }

    filename = argv[1];

    fd = open(filename, O_RDWR);
    if (fd < 0)
    {
        printf("error, can't open %sn", filename);
        return 0;
    }

    if (!strcmp("on", argv[2]))
    {
        // 亮燈
        val = 0;
        write(fd, &val, 1);
    }
    else if (!strcmp("off", argv[2]))
    {
        // 滅燈
        val = 1;
        write(fd, &val, 1);
    }
    else
    {
        print_usage(argv[0]);
        return 0;
    }


    return 0;
}

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   += myleds.o