/**

 * alloc_chrdev_region() - register a range of char device numbers

 * @dev: output parameter for first assigned number

 * @baseminor: first of the requested range of minor numbers

 * @count: the number of minor numbers required

 * @name: the name of the associated device or driver

 *

 * Allocates a range of char device numbers. The major number will be

 * chosen dynamically, and returned (along with the first minor number)

 * in @dev. Returns zero or a negative error code.

 */

 int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,

 const char *name)

 {//分配字符设备的次设备号范围，主设备号有系统动态分配，不需要主动指定

 struct char_device_struct *cd;

 cd = __register_chrdev_region(, baseminor, count, name);

 if (IS_ERR(cd))

 return PTR_ERR(cd);

 *dev = MKDEV(cd->major, cd->baseminor);

 return ;

 }

 static struct char_device_struct *

 __register_chrdev_region(unsigned int major, unsigned int baseminor,

                int minorct, const char *name)

 {

     struct char_device_struct *cd, **cp;

     int ret = ;

     int i;

     cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);

     if (cd == NULL)

         return ERR_PTR(-ENOMEM);

     mutex_lock(&chrdevs_lock);

     /* temporary */

     if (major == ) {

         for (i = ARRAY_SIZE(chrdevs)-; i > ; i--) {

             if (chrdevs[i] == NULL)

                 break;

         }

         if (i == ) {

             ret = -EBUSY;

             goto out;

         }

         major = i;

         ret = major;

     }

     cd->major = major;

     cd->baseminor = baseminor;

     cd->minorct = minorct;

     strlcpy(cd->name, name, sizeof(cd->name));

     i = major_to_index(major);

     for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)

         if ((*cp)->major > major ||

             ((*cp)->major == major &&

              (((*cp)->baseminor >= baseminor) ||

               ((*cp)->baseminor + (*cp)->minorct > baseminor))))

             break;

     /* Check for overlapping minor ranges.  */

     if (*cp && (*cp)->major == major) {

         int old_min = (*cp)->baseminor;

         int old_max = (*cp)->baseminor + (*cp)->minorct - ;

         int new_min = baseminor;

         int new_max = baseminor + minorct - ;

         /* New driver overlaps from the left.  */

         if (new_max >= old_min && new_max <= old_max) {

             ret = -EBUSY;

             goto out;

         }

         /* New driver overlaps from the right.  */

         if (new_min <= old_max && new_min >= old_min) {

             ret = -EBUSY;

             goto out;

         }

     }

     cd->next = *cp;

     *cp = cd;

     mutex_unlock(&chrdevs_lock);

     return cd;

 out:

     mutex_unlock(&chrdevs_lock);

     kfree(cd);

     return ERR_PTR(ret);

 }