内核共提供了三个函数来注册一组字符设备编号，这三个函数分别是 register_chrdev_region()、alloc_chrdev_region()和 register_chrdev()。

区别：register_chrdev比较老的内核注册的形式 早期的驱动，register_chrdev_region/alloc_chrdev_region + cdev属于新的驱动形式。register_chrdev（）可以实现静态和动态注册两种方法，主要是通过判断给定的主设备号是否为0来进行区别，为0的时候为动态注册，否则静态注册。register_chrdev_region以及alloc_chrdev_region就是将上述函数的静态和动态注册设备号进行了拆分，前者为静态注册，后者为动态注册。

• register_chrdev_region(dev_t dev,unsigned int count,char *name):

  • dev ：要分配的设备编号范围的初始值，明确了主设备号和起始次设备号
    count：设备个数，即次设备号个数
    name：相关联的设备名称. (可在/proc/devices目录下查看到)， 也即本组设备的驱动名称
  • register_chrdev_region是在事先知道要使用的主、次设备号时使用的；要先查看cat /proc/devices去查看没有使用的。

• int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)：

  • dev：这个函数的第一个参数，是输出型参数，获得一个分配到的设备号。可以用MAJOR宏和MINOR宏，将主设备号和次设备号，提取打印出来，看是自动分配的是多少，方便我们在mknod创建设备文件时用到主设备号和次设备号。 mknod /dev/xxx c 主设备号 次设备号
  • baseminor：次设备号的基准，即从哪个次设备号开始分配。
  • count：次设备号的个数。
  • name：驱动的名字。
  • 返回值：小于0，则自动分配设备号错误。否则分配得到的设备号就被第一个参数带出来。

• cdev：cdev是一个结构体，里面的成员来共同帮助我们注册驱动到内核中，表达字符设备的，将这个struct cdev结构体进行填充，主要填充的内容就是

  • struct cdev {
        struct kobject kobj;
        struct module *owner;//填充时，值要为 THIS_MODULE，表示模块
        const struct file_operations *ops;//这个file_operations结构体，注册驱动的关键，要填充成这个结构体变量
        struct list_head list;
        dev_t dev;//设备号，主设备号+次设备号
        unsigned int count;//次设备号个数
    };
    

    • file_operations：将file_operations结构体变量的值赋给cdev中的ops成员后，这个结构体就会被cdev_add函数添加进内核。

  • 涉及到cdev结构体的函数：

    • cdev_alloc(cdev pcdev) ：利用内核的kmalloc函数为这个结构体分配堆空间*，如果我们定义了一个全局的 static struct cdev *pcdev; 我们就可以用 pcdev = cdev_alloc();来给这个pcdev分配堆内存空间。

    • *cdev_init(cdev , fops)：将struct cdev类型的结构体变量和file_operations结构体进行绑定。但若前面使用了cdev_alloc，则就可以直接利用pcdev->ops = fops;来进行绑定，就不需要cdev_init函数了。

      • 在cdev_init函数中，除了cdev->ops = fops;之外的其他的操作都在cdev_alloc函数中做了。

      • void cdev_init(struct cdev *cdev, const struct file_operations *fops)
        {
            memset(cdev, 0, sizeof *cdev);
            INIT_LIST_HEAD(&cdev->list);
            cdev->kobj.ktype = &ktype_cdev_default;
            kobject_init(&cdev->kobj);
            cdev->ops = fops;
        }
        

    • cdev_add：向内核里面添加一个驱动，注册驱动

    • *cdev_del(cdev pcdev)：释放cdev结构体空间，cdev_del函数内部是能知道你的struct cdev定义的对象是用的堆内存还是栈内存还是数据段内存的。这个函数cdev_del调用时，会先去看你有没有使用堆内存，如果有用到的话，会先去释放掉你用的堆内存，然后在注销掉你这个设备驱动。所以，如果struct cdev要用堆内存一定要用内核提供的这个cdev_alloc去分配堆内存，因为内部会做记录，这样在cdev_del注销掉这个驱动的时候，才会去释放掉那段堆内存。

• 设备号

  • (1)dev_t类型（包括了主设备号和次设备号 不同的内核中定义不一样有的是16位次设备号和16位主设备号构成 有的是20为次设备号12位主设备号 ）
  • (2)MKDEV、MAJOR、MINOR三个宏
    • MKDEV： 是用来将主设备号和次设备号，转换成一个主次设备号的设备号；
    • MAJOR： 从设备号里面提取出来主设备号的。
    • MINOR：从设备号中提取出来次设备号的。

• 使用对比：register_chrdev_region VS register_chrdev

• 驱动文件实例：

• #include <linux/module.h>        // module_init  module_exit
  #include <linux/init.h>            // __init   __exit
  #include <linux/fs.h>
  #include <asm/uaccess.h>
  #include <mach/regs-gpio.h>
  #include <mach/gpio-bank.h>        // arch/arm/mach-s5pv210/include/mach/gpio-bank.h
  #include <linux/string.h>
  #include <linux/io.h>
  #include <linux/ioport.h>
  #include <linux/cdev.h>
  
  
  
  #define MYMAJOR       200
  #define MYCNT       1
  #define MYNAME      "testchar"
  
  #define GPJ0CON     S5PV210_GPJ0CON
  #define GPJ0DAT     S5PV210_GPJ0DAT
  
  #define rGPJ0CON    *((volatile unsigned int *)GPJ0CON)
  #define rGPJ0DAT    *((volatile unsigned int *)GPJ0DAT)
  
  #define GPJ0CON_PA  0xe0200240
  #define GPJ0DAT_PA  0xe0200244
  
  unsigned int *pGPJ0CON;
  unsigned int *pGPJ0DAT;
  
  
  int mymajor;
  static dev_t mydev;
  static struct cdev test_cdev; //静态全局变量，而如果我们定义了一个全局的 static struct cdev *pcdev; 我们就可以用 pcdev = cdev_alloc();来给这个pcdev分配堆内存空间。
  
  char kbuf[100];            // 内核空间的buf
  
  
  static int test_chrdev_open(struct inode *inode, struct file *file)
  {
      // 这个函数中真正应该放置的是打开这个设备的硬件操作代码部分
      // 但是现在暂时我们写不了这么多，所以用一个printk打印个信息来做代表。
      printk(KERN_INFO "test_chrdev_open\n");
  
      rGPJ0CON = 0x11111111;
      rGPJ0DAT = ((0<<3) | (0<<4) | (0<<5));        // 亮
  
      return 0;
  }
  
  static int test_chrdev_release(struct inode *inode, struct file *file)
  {
      printk(KERN_INFO "test_chrdev_release\n");
  
      rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
  
      return 0;
  }
  
  ssize_t test_chrdev_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos)
  {
      int ret = -1;
  
      printk(KERN_INFO "test_chrdev_read\n");
  
      ret = copy_to_user(ubuf, kbuf, count);
      if (ret)
      {
          printk(KERN_ERR "copy_to_user fail\n");
          return -EINVAL;
      }
      printk(KERN_INFO "copy_to_user success..\n");
      
      return 0;
  }
  
  // 写函数的本质就是将应用层传递过来的数据先复制到内核中，然后将之以正确的方式写入硬件完成操作。
  static ssize_t test_chrdev_write(struct file *file, const char __user *ubuf,
      size_t count, loff_t *ppos)
  {
      int ret = -1;
  
      printk(KERN_INFO "test_chrdev_write\n");
  
      // 使用该函数将应用层传过来的ubuf中的内容拷贝到驱动空间中的一个buf中
      //不能简单使用memcpy(kbuf, ubuf);为2个buf不在一个地址空间中
      memset(kbuf, 0, sizeof(kbuf));
      ret = copy_from_user(kbuf, ubuf, count);
      if (ret)
      {
          printk(KERN_ERR "copy_from_user fail\n");
          return -EINVAL;
      }
      printk(KERN_INFO "copy_from_user success..\n");
  
      if (kbuf[0] == '1')
      {
          rGPJ0DAT = ((0<<3) | (0<<4) | (0<<5));
      }
      else if (kbuf[0] == '0')
      {
          rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
      }
  
  /*
      // 真正的驱动中，数据从应用层复制到驱动中后，我们就要根据这个数据
      // 去写硬件完成硬件的操作。一般会使用ioctl函数，但写函数也能完成相同功能
      //所以这下面就应该是操作硬件的代码:
      if (!strcmp(kbuf, "on"))
      {
          rGPJ0DAT = ((0<<3) | (0<<4) | (0<<5));
      }
      else if (!strcmp(kbuf, "off"))
      {
          rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
      }
  */
      return 0;
  }
  
  
  // 自定义一个file_operations结构体变量，并且去填充
  static const struct file_operations test_fops = {
      .owner        = THIS_MODULE,                // 惯例，直接写即可
  
      .open        = test_chrdev_open,            // 将来应用open打开这个设备时实际调用的
      .release    = test_chrdev_release,        // 就是这个.open对应的函数
      .write         = test_chrdev_write,
      .read        = test_chrdev_read,
  };
  
  
  // 模块安装函数
  static int __init chrdev_init(void)
  {
      int retval;
  
      printk(KERN_INFO "chrdev_init helloworld init\n");
  
  /*
      // 在module_init宏调用的函数中去注册字符设备驱动
      // major传0进去表示要让内核帮我们自动分配一个合适的空白的没被使用的主设备号
      // 内核如果成功分配就会返回分配的主设备好；如果分配失败会返回负数
      mymajor = register_chrdev(0, MYNAME, &test_fops);
      if (mymajor < 0)
      {
          printk(KERN_ERR "register_chrdev fail\n");
          return -EINVAL;
      }
      printk(KERN_INFO "register_chrdev success... mymajor = %d.\n", mymajor);
  */
  
      /* 使用新的cdev接口来注册字符设备驱动需要2步 */
  
      // 第1步：注册/分配主次设备号
      mydev = MKDEV(MYMAJOR, 0);
      retval = register_chrdev_region(mydev, MYCNT, MYNAME);
      if (retval) {
          printk(KERN_ERR "Unable to register minors for %s\n", MYNAME);
          return -EINVAL;
      }
      printk(KERN_INFO "register_chrdev_region success\n");
      
      // 第2步：注册字符设备驱动
      cdev_init(&test_cdev, &test_fops);    //若前面定义的是cdev的指针，而不是cdev结构体的话，就需要以下3个命令来代替cdev_init()函数了，即pcdev = cdev_alloc();pcdev->owner = THIS_MODULE;pcdev->ops = &test_fops;
      retval = cdev_add(&test_cdev, mydev, MYCNT);
      if (retval) {
          printk(KERN_ERR "Unable to cdev_add\n");
          return -EINVAL;
      }
      printk(KERN_INFO "cdev_add success\n");
  
  
      // 使用动态映射的方式来操作寄存器
      if (!request_mem_region(GPJ0CON_PA, 4, "GPJ0CON"))
          return -EINVAL;
      if (!request_mem_region(GPJ0DAT_PA, 4, "GPJ0DAT"))
          return -EINVAL;
  
      pGPJ0CON = ioremap(GPJ0CON_PA, 4);
      pGPJ0DAT = ioremap(GPJ0DAT_PA, 4);
  
      *pGPJ0CON = 0x11111111;
      *pGPJ0DAT = ((0<<3) | (0<<4) | (0<<5));        // 亮
  
      return 0;
  }
  
  // 模块下载函数
  static void __exit chrdev_exit(void)
  {
      printk(KERN_INFO "chrdev_exit helloworld exit\n");
  
      *pGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));   //关灯
  
      // 解除映射
      iounmap(pGPJ0CON);
      iounmap(pGPJ0DAT);
      release_mem_region(GPJ0CON_PA, 4);
      release_mem_region(GPJ0DAT_PA, 4);
  
  /*
      // 在module_exit宏调用的函数中去注销字符设备驱动
      unregister_chrdev(mymajor, MYNAME);
  */
  
      // 使用新的接口按相反顺序来注销字符设备驱动也分2步（）：
      // 第一步真正注销字符设备驱动用cdev_del
      cdev_del(&test_cdev);
      // 第二步去注销申请的主次设备号
      unregister_chrdev_region(mydev, MYCNT);
  }
  
  
  module_init(chrdev_init);
  module_exit(chrdev_exit);
  
  // MODULE_xxx这种宏作用是用来添加模块描述信息
  MODULE_LICENSE("GPL");                // 描述模块的许可证
  MODULE_AUTHOR("aston");                // 描述模块的作者
  MODULE_DESCRIPTION("module test");    // 描述模块的介绍信息
  MODULE_ALIAS("alias xxx");            // 描述模块的别名信息
  

  测试文件：

  #include <stdio.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  #include <string.h>
  
  
  #define FILE    "/dev/test"            // 刚才mknod创建的设备文件名
  
  char buf[100];
  
  int main(void)
  {
      int fd = -1;
      int i = 0;
  
      fd = open(FILE, O_RDWR);
      if (fd < 0)
      {
          printf("open %s error.\n", FILE);
          return -1;
      }
      printf("open %s success..\n", FILE);
  
  /*
      // 读写文件
      write(fd, "on", 2);
      sleep(2);
      write(fd, "off", 3);
      sleep(2);
      write(fd, "on", 2);
      sleep(2);
  */
  /*
      write(fd, "1", 1);
      sleep(2);
      write(fd, "0", 1);
      sleep(2);
      write(fd, "1", 1);
      sleep(2);
  */
      while (1)
      {
          memset(buf, 0 , sizeof(buf));
          printf("请输入 on | off \n");
          scanf("%s", buf);
          getchar();
          if (!strcmp(buf, "on"))
          {
              write(fd, "1", 1);
          }
          else if (!strcmp(buf, "off"))
          {
              write(fd, "0", 1);
          }
          else if (!strcmp(buf, "flash"))
          {
              for (i=0; i<3; i++)
              {
                  write(fd, "1", 1);
                  sleep(1);
                  write(fd, "0", 1);
                  sleep(1);
              }
          }
          else if (!strcmp(buf, "quit"))
          {
              break;
          }
      }
  
  
      // 关闭文件
      close(fd);
  
      return 0;
  }