//vi firstdriv.c 
#include <linux/init.h>
#include <linux/module.h>

MODULE_LICENSE("GPL");

static int __init driv_init(void)
{
        printk(KERN_INFO "hello world!\n");
        return 0;
}

static void __exit driv_exit(void)
{
        printk(KERN_INFO "bye world!\n");
}

module_init(driv_init);
module_exit(driv_exit);

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

int main()
{
    int fd;
    fd = open("/dev/pin4", O_RDWR);
    if (fd < 0) {
        printf("open failed\n");
        perror("reason:");
    } else {
        printf("open success\n");
    }
    fd = write(fd, '1', 1);  
    close(fd);
}

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

MODULE_LICENSE("GPL");

static int __init driv_init(void)
{
	printk(KERN_INFO "hello world!\n");
	return 0;
}

static void __exit driv_exit(void)
{
	printk(KERN_INFO "bye world!");
}

module_init(driv_init);
module_exit(driv_exit);

#include <linux/fs.h>      //file_operations声明
#include <linux/module.h>  //module_init  module_exit声明
#include <linux/init.h>    //__init  __exit 宏定义声明
#include <linux/device.h>  //class  devise声明
#include <linux/uaccess.h> //copy_from_user 的头文件
#include <linux/types.h>   //设备号  dev_t 类型声明
#include <asm/io.h>        //ioremap iounmap的头文件

static struct class *pin4_class;
static struct device *pin4_class_dev;

static dev_t devno;                //设备号
static int major = 231;            //主设备号
static int minor = 0;              //次设备号
static char *module_name = "pin4"; //模块名

/* led_open函数 */
static ssize_t pin4_open(struct inode *inode, struct file *file)
{
    printk("pin4_open\n"); //内核的打印函数和printf类似
    return 0;
}

/* led_read函数 */
static ssize_t pin4_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    printk("pin4_open\n"); //内核的打印函数和printf类似
    return 0;
}

/* led_write函数 */
static ssize_t pin4_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    printk("pin4_write\n");
    return 0;
}

/* 创建驱动对象 */
static struct file_operations pin4_fops = {
    .owner = THIS_MODULE,
    .open = pin4_open,
    .write = pin4_write,
    .read = pin4_read,
};

/* 真实驱动入口 */
int __init pin4_drv_init(void)  
{
    int ret;
    devno = MKDEV(major, minor);                           //2.创建设备号
    ret = register_chrdev(major, module_name, &pin4_fops); //3.注册驱动  告诉内核，把这个驱动加入到内核驱动的链表中

    //4.创建设备文件，让代码在dev下自动生成设备
    pin4_class = class_create(THIS_MODULE, "myfirstdemo"); 
    pin4_class_dev = device_create(pin4_class, NULL, devno, NULL, module_name); 
    return 0;
}

/* 驱动出口 */
void __exit pin4_drv_exit(void)
{
    device_destroy(pin4_class, devno);
    class_destroy(pin4_class);
    unregister_chrdev(major, module_name); //卸载驱动
}

module_init(pin4_drv_init); //1.入口，内核加载该驱动的时候，这个宏会被展开，然后调用pin4_drv_init
module_exit(pin4_drv_exit);
MODULE_LICENSE("GPL v2");

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
    int fd;
    int cmd = 0;
       
    fd = open("/dev/pin4", O_RDWR);
    if (fd < 0) {
        printf("open /dev/pin4 failed!\n");
        perror("reason:");
    } else {
        printf("open /dev/pin4 success!\n");
    }
    printf("Please input the command: 1/0\n1 : set pin4 high\n0 : set pin4 low\n");
    scanf("%d", &cmd);
       
    if (cmd == 1) {   
        printf("You entered : %d\n", cmd);
        fd = write(fd, &cmd, 1);
    } else if (cmd == 0) {
 		printf("You entered : %d\n", cmd);
        fd = write(fd, &cmd, 1);
    } else {
        printf("You entered : %dis error!\n", cmd);
    }
    close(fd);
}

#include <linux/fs.h>      //file_operations声明
#include <linux/module.h>  //module_init  module_exit声明
#include <linux/init.h>    //__init  __exit 宏定义声明
#include <linux/device.h>  //class  devise声明
#include <linux/uaccess.h> //copy_from_user 的头文件
#include <linux/types.h>   //设备号  dev_t 类型声明
#include <asm/io.h>        //ioremap iounmap的头文件

static struct class *pin4_class;
static struct device *pin4_class_dev;

static dev_t devno;                //设备号
static int major = 231;            //主设备号
static int minor = 0;              //次设备号
static char *module_name = "pin4"; //模块名

/* 寄存器 */
volatile unsigned int *GPFSEL0 = NULL;
volatile unsigned int *GPSET0 = NULL;
volatile unsigned int *GPCLR0 = NULL;

/* led_open函数 */
static ssize_t pin4_open(struct inode *inode, struct file *file)
{
    printk("pin4_open\n"); //内核的打印函数和printf类似
    //配置pin4引脚为输出引脚，pin 12-14配置成001
    *GPFSEL0 &= ~(0x6 << 12);  //把bit13-14配置成0
    *GPFSEL0 |= (0x1 << 12);   //把bit12配置成1
    return 0;
}

///* led_read函数 */
//static ssize_t pin4_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
//{
//     printk("pin4_open\n"); //内核的打印函数和printf类似
//     return 0;
//}

/* led_write函数 */
static ssize_t pin4_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    int user_cmd = 0;  //这里赋值为0非常重要!!!!!
    int n;
    //printk("pin4_write\n");
    // 获取上层write函数的值
    n = copy_from_user(&user_cmd, buf, count);
    if (n != 0) {
        printk("copy form user error\n");
    } else {
        printk("copy form user success\n");
    }
    //根据值来操作IO口，高电平或者低电平
    printk("%d\n", user_cmd);
    if (user_cmd == 1) {
        printk("set pin4 success\n");
        *GPSET0 |= 0x1 << 4;  //将GPSET0寄存器的bit4置1
    } else if (user_cmd == 0) {
        printk("clear pin4 success\n");
        *GPCLR0 |= 0x1 << 4;  //将GPCLR0寄存器的bit4置1
    } else {
        printk("Control pin4 failed\n");
    }
    return 0;
}

/* 创建驱动对象 */
static struct file_operations pin4_fops = {
    .owner = THIS_MODULE,
    .open = pin4_open,
    .write = pin4_write,
    //.read = pin4_read,
};

/* 真实驱动入口 */
int __init pin4_drv_init(void)
{
    int ret;
    printk("Insmod driver pin4 success\n");
    devno = MKDEV(major, minor);                           // 2.创建设备号
    ret = register_chrdev(major, module_name, &pin4_fops); // 3.注册驱动  告诉内核，把这个驱动加入到内核驱动的链表中

    // 4.创建设备文件，让代码在dev下自动生成设备
    pin4_class = class_create(THIS_MODULE, "pin4driver");
    pin4_class_dev = device_create(pin4_class, NULL, devno, NULL, module_name);

    //将寄存器的物理地址转换为虚拟地址，IO口寄存器映射成普通内存单元进行访问
    GPFSEL0 = (volatile unsigned int *) ioremap(0x3f200000, 4);
    GPSET0 = (volatile unsigned int *) ioremap(0x3f20001c, 4);
    GPCLR0 = (volatile unsigned int *) ioremap(0x3f200028, 4);

    return 0;
}

/* 驱动出口 */
void __exit pin4_drv_exit(void)
{
    // 将虚拟地址解绑
    iounmap(GPFSEL0);
    iounmap(GPSET0);
    iounmap(GPCLR0);

    device_destroy(pin4_class, devno);
    class_destroy(pin4_class);
    unregister_chrdev(major, module_name); //卸载驱动
}

module_init(pin4_drv_init); // 1.入口，内核加载该驱动的时候，这个宏会被展开，然后调用pin4_drv_init
module_exit(pin4_drv_exit);
MODULE_LICENSE("GPL v2");

#include <linux/miscdevice.h>    
#include <linux/delay.h>    
#include <asm/irq.h>    
#include <linux/kernel.h>    
#include <linux/module.h>    
#include <linux/init.h>    
#include <linux/mm.h>    
#include <linux/fs.h>    
#include <linux/types.h>    
#include <linux/delay.h>    
#include <linux/moduleparam.h>    
#include <linux/slab.h>    
#include <linux/errno.h>    
#include <linux/ioctl.h>    
#include <linux/cdev.h>    
#include <linux/string.h>    
#include <linux/list.h>    
#include <linux/pci.h>    
#include <asm/uaccess.h>    
#include <asm/atomic.h>    
#include <asm/unistd.h>    
#include <asm/io.h>    
#include <asm/uaccess.h>    
#include <linux/ioport.h>    
      
#define PIN					26 //GPIO26 
  
#define BCM2835_GPSET0                          0x001c  
#define BCM2835_GPFSEL0                         0x0000  
#define BCM2835_GPCLR0                          0x0028  
#define BCM2835_GPIO_FSEL_OUTP      1  
  
#define BCM2835_GPIO_BASE                   0x3f200000  
  
int open_state = 0;         //文件打开状态    
  
    
int bcm2835_gpio_fsel(uint8_t pin, uint8_t mode)    
{    
    //初始化GPIOB功能选择寄存器的物理地址    
    volatile uint32_t * bcm2835_gpio = (volatile uint32_t *)ioremap(BCM2835_GPIO_BASE, 16);    
    volatile uint32_t * bcm2835_gpio_fsel = bcm2835_gpio + BCM2835_GPFSEL0/4 + (pin/10);    
    uint8_t   shift = (pin % 10) * 3;    
    uint32_t  value = mode << shift;    
    *bcm2835_gpio_fsel = *bcm2835_gpio_fsel | value;    
    
    printk("fsel address: 0x%lx : %x\n", (long unsigned int)bcm2835_gpio_fsel, *bcm2835_gpio_fsel);    
    
    return 0;    
}    
    
int bcm2835_gpio_set(uint8_t pin)    
{    
    //GPIO输出功能物理地址    
    volatile uint32_t * bcm2835_gpio = (volatile uint32_t *)ioremap(BCM2835_GPIO_BASE, 16);    
    volatile uint32_t * bcm2835_gpio_set = bcm2835_gpio + BCM2835_GPSET0/4 + pin/32;    
    uint8_t   shift = pin % 32;    
    uint32_t  value = 1 << shift;    
    *bcm2835_gpio_set = *bcm2835_gpio_set | value;    
    
    printk("set address:  0x%lx : %x\n", (long unsigned int)bcm2835_gpio_set, *bcm2835_gpio_set);    
    
    return 0;    
}    
    
int bcm2835_gpio_clr(uint8_t pin)    
{    
   //GPIO清除功能物理地址    
    volatile uint32_t * bcm2835_gpio = (volatile uint32_t *)ioremap(BCM2835_GPIO_BASE, 16);    
    volatile uint32_t * bcm2835_gpio_clr = bcm2835_gpio + BCM2835_GPCLR0/4 + pin/32;    
    uint8_t   shift = pin % 32;    
    uint32_t  value = 1 << shift;    
    *bcm2835_gpio_clr = *bcm2835_gpio_clr | value;    
        
    printk("clr address:  0x%lx : %x\n", (long unsigned int)bcm2835_gpio_clr, *bcm2835_gpio_clr);    
    
    return 0;    
}   
  
static int leds_open(struct inode *inode, struct file *filp)    
{    
    if(open_state == 0)      
    {      
        open_state =  1;      
        printk("Open file suc!\n");      
        return 0;      
    }      
    else      
    {      
        printk("The file has opened!\n");      
        return -1;      
    }      
}    
    
static long leds_ioctl(struct file*filp, unsigned int cmd, unsigned long arg)    
{    
    switch(cmd)      
    {      
        case 0:      
            bcm2835_gpio_clr(PIN);    
            printk("LED OFF!\n");    
            break;      
        case 1:      
            bcm2835_gpio_set(PIN);    
            printk("LED ON!\n");    
            break;      
    
        default:      
            return-EINVAL;      
    }      
    
    return 0;    
}    
    
static int leds_release(struct inode *inode, struct file *filp)    
{    
    if(open_state == 1)      
    {      
        open_state =  0;      
        printk("close file suc!\n");      
        return 0;      
    }      
    else      
    {      
        printk("The file has closed!\n");      
        return -1;      
    }      
}    
    
static const struct file_operations leds_fops = {    
    .owner = THIS_MODULE,    
    .open = leds_open,    
    .unlocked_ioctl = leds_ioctl,    
    .release = leds_release,    
};    
    
static struct miscdevice misc = {    
    .minor =MISC_DYNAMIC_MINOR,    
    .name ="my_leds",    
    .fops =&leds_fops,    
};    
    
    
static int __init leds_init(void)    
{    
    int ret;    
    
    //注册混杂设备    
    ret =misc_register(&misc);    
    
    //配置功能选择寄存器为输出    
    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP);    
    
    //设置输出电平为高电平，LED亮    
    bcm2835_gpio_set(PIN);    
    
    printk("ledsinit.\n");    
    return ret;    
}    
    
static void leds_exit(void)    
{    
    //LED灭    
    bcm2835_gpio_clr(PIN);    
    
    misc_deregister(&misc);            
    
    printk("leds_exit\n");    
}    
    
module_init(leds_init);    
module_exit(leds_exit);    
    
MODULE_AUTHOR("yangwen");    
MODULE_LICENSE("GPL"); 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <sys/ioctl.h>  
  
int main(int argc, char **argv)  
{  
    int on;  
    int fd;  
    if (argc != 2 || sscanf(argv[1],"%d", &on) != 1 ||on < 0 || on > 1 ) {  
        fprintf(stderr, "Usage:%s 0|1\n",argv[0]);  
        exit(1);  
    }  
    fd = open("/dev/my_leds", 0);  
    if (fd < 0) {  
        perror("open device leds");  
        exit(1);  
    }  
    /*通过ioctl来控制灯的亮、灭*/  
    if(on){  
        printf("turn on leds!\n");  
        ioctl(fd, 1);  
    }  
    else {  
        printf("turn off leds!\n");  
        ioctl(fd, 0);  
    }  
    close(fd);  
    return 0;  
}