android驱动例子（LED灯控制）_android led test

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/init.h>            /* For __init/__exit/... */
#include <linux/module.h>
#include <mach/hardware.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <plat/gpio-cfg.h>
#include <plat/regs-clock.h>
#include <plat/regs-lcd.h>
#include <plat/regs-gpio.h>
#include <mach/map.h>
#include <linux/gpio.h>
#include <plat/gpio-bank-m.h>
#include <linux/cdev.h>
#include <linux/fs.h> //for register_chrdev()
#include <linux/device.h>
#include <mach/map.h>
#include "leddriver.h"
#include <linux/miscdevice.h>        /* For MODULE_ALIAS_MISCDEV
                            (WATCHDOG_MINOR) */
#include <linux/watchdog.h>        /* For the watchdog specific items */
#include <linux/fs.h>            /* For file operations */
#define Viberator_MAJOR        97  //主设备号
#define SCULL_NR_DEVS           4
#define SCULL_QUANTUM         4000
#define SCULL_QSET             1000
//---do as the GIO driver
#define DEVCOUNT                4
#define GIO_MINOR            2    /* GIO minor no. */
static dev_t dev;        //申  请  到的主  设备  号
static struct cdev *cdev_p;
static int openCnt;
//--全局变量------------
int VIB_major  = 97;//we asigment it for test
int VIB_minor = 0;
int VIB_nr_devs = SCULL_NR_DEVS;
int VIB_quantum = SCULL_QUANTUM;
int VIB_qset = SCULL_QSET;

static struct class *vib_dev_class;
#define GPNCON  S3C64XX_GPNCON 
#define GPNDAT  S3C64XX_GPNDAT
#define GPNPUD  S3C64XX_GPNPUD
#define GPMCON S3C64XX_GPMCON
#define GPMDAT  S3C64XX_GPMDAT
#define GPMPUD S3C64XX_GPMPUD

#define VIB_ON 0x11
#define  VIB_OFF 0x22
static const struct file_operations GPIO_Viberator_ctl_ops={
    .owner        = THIS_MODULE,
    .open    = GPIO_VIB_open,
    .read    =GPIO_VIB_read,
    .write    =GPIO_VIB_write,
    .ioctl     = GPIO_VIB_ioctl,
    .release     =GPIO_VIB_release,
};
ssize_t GPIO_VIB_read(struct file * file,char * buf,size_t count,loff_t * f_ops)
{
       char sdas[5]={1,3,8,1,6};
       ssize_t            status = 5;
    unsigned long    missing;
    missing = copy_to_user(buf, sdas, status);
    if (missing == status)
        status = -EFAULT;
    else
        status = status - missing;   
       printk(" GPIO_VIB_read = %d ,count = %d/r/n",status,count);
    gpio_direction_output(S3C64XX_GPM(3), 0);// 
return status ; 
}
ssize_t GPIO_VIB_write (struct file * file,const char * buf, size_t count,loff_t * f_ops)
{
    unsigned long missing;
     char inbuffer[512]={0};
    int i;
     missing = copy_from_user(inbuffer, buf, count);
    printk(" GPIO_VIB_write count = %d missing =%d /r/n",count,missing);
    gpio_direction_output(S3C64XX_GPM(3), 1);// 
    for(i=0;i<count;i++)
        {
            printk("Write:inbuffer[%d]=%d /r/n",i,inbuffer[i]);
        } 
return count;
}

//ssize_t GPIO_VIB_ioctl(struct inode *  inode,struct file * file,unsigned int cmd, long data)
static int GPIO_VIB_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    printk(KERN_ERR"VIB:GPIO_VIB_ioctl --CMD=%x /n",cmd);
    switch(cmd)
        {
           case VIB_ON:
            gpio_direction_output(S3C64XX_GPM(1), 0);// 
            gpio_direction_output(S3C64XX_GPM(2), 0);// 
            gpio_direction_output(S3C64XX_GPM(3), 0);// 
            gpio_direction_output(S3C64XX_GPM(4), 1);// 
            printk(KERN_ERR"VIB:GPIO_VIB_ioctl --VIB_ON/n");
            break;
         case VIB_OFF:
            {
            printk(KERN_ERR"VIB:GPIO_VIB_ioctl --VIB_OFF/n");
            gpio_direction_output(S3C64XX_GPM(1), 1);// 
            gpio_direction_output(S3C64XX_GPM(2), 1);// 
            gpio_direction_output(S3C64XX_GPM(3), 1);// 
            gpio_direction_output(S3C64XX_GPM(4), 0);// 
            break;
         }
         default:break;
                
    }
        //gpio_free(S3C64XX_GPN(7));
}
ssize_t GPIO_VIB_open(struct inode * inode,struct file * file)
{
//模块数
  //MOD_INC_USE_COUNT;
  printk("GPIO_VIB_open() /n");   
  return 0;
}
ssize_t GPIO_VIB_release(struct inode * inode, struct file * file)
{
   // MOD_DEC_USE_COUNT;//模块数减1
     printk("GPIO_VIB_release() /n");   
    return 0;
}
static int GPIO_VIB_CTL_init(void)
{
    int ret  = -ENODEV;
   int error ;
    printk("---------------------------------------------- /r/n");
    //初始化端口
        s3c_gpio_cfgpin(S3C64XX_GPM(1), S3C_GPIO_SFN(1));//GPM1 output
        s3c_gpio_cfgpin(S3C64XX_GPM(2), S3C_GPIO_SFN(1));//GPM2 output
        s3c_gpio_cfgpin(S3C64XX_GPM(3), S3C_GPIO_SFN(1));//GPM3 output
        s3c_gpio_cfgpin(S3C64XX_GPM(4), S3C_GPIO_SFN(1));//GPM4 output
#if 1 /*静态方式注册驱动*/
ret = register_chrdev(Viberator_MAJOR, "viberator", &GPIO_Viberator_ctl_ops);
if (ret < 0) {
    printk(KERN_ERR "VIB: unable to get major %d/n", ret);
    return ret;
}
//创建class
vib_dev_class = class_create(THIS_MODULE, "viberator");
if (IS_ERR(vib_dev_class)) {
    unregister_chrdev(Viberator_MAJOR, "capi20");
    return PTR_ERR(vib_dev_class);
}
//创建节点，
device_create(vib_dev_class, NULL, MKDEV(Viberator_MAJOR, 0), NULL, "vib");
// create a point under /dev/class/vib  
//通过上面这两步，驱动加载后，就会在/dev/class/下面生成vib节点，应用程序可以像操作文件那样操作这个节点，通过open ,write,read 等函数操作，详情可以看后面的应用示例程序。
  return 0;    
#endif
#if 0/* 注册动态 */
    if ((error = alloc_chrdev_region(&dev, 0, DEVCOUNT, "vibrate")) < 0)
        {
        printk(KERN_ERR
               "VIB: Couldn't alloc_chrdev_region, error=%d/n",
               error);
        return 1;
    }
         printk("dev = %d  /n",dev);
    cdev_p = cdev_alloc();
    cdev_p->ops = &GPIO_Viberator_ctl_ops;
    error = cdev_add(cdev_p, dev, DEVCOUNT);
    if (error) {
        printk(KERN_ERR
               "VIB: Couldn't cdev_add, error=%d/n", error);
        return 1;
    }

    vib_dev_class = class_create(THIS_MODULE, "vib-dev");
    if (IS_ERR(vib_dev_class)) {
        res = PTR_ERR(vib_dev_class);
        goto out_unreg_class;
    }
    return 0;
#endif
out_unreg_class:
    class_destroy(vib_dev_class);
return 1;
}

static int __init S3C6410_VIB_init(void)
{
    int ret = -ENODEV;
    //调用函数    
        printk(KERN_ERR "Auly: S3C6410_VIB_init---/n");
    ret = GPIO_VIB_CTL_init();
    if(ret)
        {
        printk(KERN_ERR "Auly: S3C6410_VIB_init--Fail !!!/n");
        return ret;
    }
    return 0;
}
static void __exit cleanup_GPIO_VIB(void)
{
    //注销设备
  //  devfs_unregister_chrdev(Viberator_MAJOR,"gpio_vib_ctl");
 #if 0 
      cdev_del(cdev_p);
    unregister_chrdev_region(dev, DEVCOUNT);
    class_destroy(vib_dev_class);
#endif 
device_destroy(vib_dev_class, MKDEV(Viberator_MAJOR, 0));
class_destroy(vib_dev_class);
unregister_chrdev(Viberator_MAJOR, "viberator");
}
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Peter first driver");
MODULE_ALIAS_CHARDEV(Viberator_MAJOR, 0);

module_init(S3C6410_VIB_init);
module_exit(cleanup_GPIO_VIB);