C++ cdev_alloc函数代码示例

static int __init complete_init(void)
{
    int ret;
    ret = alloc_chrdev_region(&complete_dev, 0, 1, "complete");
    if (ret < 0) {
        printk(KERN_WARNING "complete: can't alloc chrdev\n");
        return ret;
    }

    complete_cdev = cdev_alloc();
    if (!complete_cdev) {
        ret = -ENOMEM;
        goto fail;
    }
    complete_cdev->ops = &complete_fops;
    ret = cdev_add(complete_cdev, complete_dev, 1);
    if (ret < 0) {
        printk(KERN_NOTICE "complete: Error adding cdev\n");
        goto fail_cdev;
    }

    return 0;

fail_cdev:
    kfree(complete_cdev);
fail:
    unregister_chrdev_region(complete_dev, 1);
    return ret;
}

static int uio_major_init(void)
{
	static const char name[] = "uio";
	struct cdev *cdev = NULL;
	dev_t uio_dev = 0;
	int result;

	result = alloc_chrdev_region(&uio_dev, 0, UIO_MAX_DEVICES, name);
	if (result)
		goto out;

	result = -ENOMEM;
	cdev = cdev_alloc();
	if (!cdev)
		goto out_unregister;

	cdev->owner = THIS_MODULE;
	cdev->ops = &uio_fops;
	kobject_set_name(&cdev->kobj, "%s", name);

	result = cdev_add(cdev, uio_dev, UIO_MAX_DEVICES);
	if (result)
		goto out_put;

	uio_major = MAJOR(uio_dev);
	uio_cdev = cdev;
	return 0;
out_put:
	kobject_put(&cdev->kobj);
out_unregister:
	unregister_chrdev_region(uio_dev, UIO_MAX_DEVICES);
out:
	return result;
}

static int at91_adc_cdev_setup(void){

	int status;
	/* alloc a new device number (major: dynamic, minor: 0) */
	status = alloc_chrdev_region(&at91_adc_devno,0,1,at91_adc_device.name);

	if(status){
		goto err;
	}

	/* create a new char device */
	at91_adc_cdev = cdev_alloc();
	if(at91_adc_cdev == NULL){ status=-ENOMEM; goto err; }
	at91_adc_cdev->owner = THIS_MODULE;
	at91_adc_cdev->ops	 = &at91_adc_fops;
	status = cdev_add(at91_adc_cdev,at91_adc_devno,1);
	if(status){
		goto err;
	}
	
	/* register the class */
	at91_adc_class = class_create(THIS_MODULE, DRV_CLASS);
	if(IS_ERR(at91_adc_class)){ status=-EFAULT; goto err; }
	device_create(at91_adc_class, NULL, at91_adc_devno, NULL, at91_adc_device.name);
	printk(KERN_INFO "Major: %u; minor: %u\n", \
		MAJOR(at91_adc_devno), MINOR(at91_adc_devno) \
	);

	return 0;

err:
	at91_adc_cdev_teardown();
	return status;
}

int __init lcd_module_init(void)
{
	int ret = 0, err;

	__inf("lcd_module_init\n");

	 alloc_chrdev_region(&devid, 0, 1, "lcd");
	 my_cdev = cdev_alloc();
	 cdev_init(my_cdev, &lcd_fops);
	 my_cdev->owner = THIS_MODULE;
	 err = cdev_add(my_cdev, devid, 1);
	 if (err)
	 {
		  __wrn("cdev_add fail.\n");
		  return -1;
	 }

    lcd_class = class_create(THIS_MODULE, "lcd");
    if (IS_ERR(lcd_class))
    {
        __wrn("class_create fail\n");
        return -1;
    }

	device_create(lcd_class, NULL, devid, NULL, "lcd");

	lcd_init();

	return ret;
}

static int cs598_create_char_dev(void)
{
	int result = 0;

	/* Dynamically allocate a major number for the device */
	result = alloc_chrdev_region(&cs598_dev,
				     cs598_dev_minor,
				     cs598_nr_devs,
				     "my_char_dev");
	cs598_dev_major = result;
	if (result < 0) {
		printk(KERN_INFO "cs598: Char dev cannot get major\n");
		return result;
	}

	/* Allocate a character device structure */
	cs598_cdev = cdev_alloc();

	/* Assign the function pointers */
	cs598_cdev->ops = &cs598_dev_fops;
	cs598_cdev->owner = THIS_MODULE;

	/* Add this character device */
	result = cdev_add(cs598_cdev, cs598_dev, 1);
	if (result) {
		printk(KERN_INFO "cs598: Error adding device\n");
		return result;
	}
	return result;
}

static int __init pa_dev_init(void)
{
//    int status = 0;
    int err = 0;	
	printk("[pa_drv] start!!!\n");
	
	if((platform_device_register(&sw_device_pa))<0)
		return err;

	if ((err = platform_driver_register(&sw_pa_driver)) < 0)
		return err;
  	

    alloc_chrdev_region(&dev_num, 0, 1, "pa_chrdev");
    pa_dev = cdev_alloc();
    cdev_init(pa_dev, &pa_dev_fops);
    pa_dev->owner = THIS_MODULE;
    err = cdev_add(pa_dev, dev_num, 1);	
    if (err){
    	printk(KERN_NOTICE"Error %d adding pa_dev!\n", err);    
        return -1;
    }
    pa_dev_class = class_create(THIS_MODULE, "pa_cls");
    device_create(pa_dev_class, NULL,
                  dev_num, NULL, "pa_dev");   
    printk("[pa_drv] init end!!!\n");
    return 0;
}

/*
 * devapc_init: module init function.
 */
static int __init devapc_init(void)
{
    int ret;

    /*You do not need to open the clock for Rainier*/
    //enable_clock(MT_CG_INFRA_DEVICE_APC,"DEVAPC");
    
    pr_warn("[DEVAPC] module init. \n");

    ret = platform_device_register(&devapc_device);
    if (ret) {
        pr_warn("[DEVAPC] Unable to do device register(%d)\n", ret);
        return ret;
    }

    ret = platform_driver_register(&devapc_driver);
    if (ret) {
        pr_warn("[DEVAPC] Unable to register driver (%d)\n", ret);
        platform_device_unregister(&devapc_device);
        return ret;
    }

    g_devapc_ctrl = cdev_alloc();
    if (!g_devapc_ctrl) {
        pr_warn("[DEVAPC] Failed to add devapc device! (%d)\n", ret);
        platform_driver_unregister(&devapc_driver);
        platform_device_unregister(&devapc_device);
        return ret;
    }
    g_devapc_ctrl->owner = THIS_MODULE;

    return 0;
}

int capture_module_init(void)
{
	int ret = 0, err;

	pr_info("[DISP]capture_module_init\n");

	alloc_chrdev_region(&devid, 0, 1, "capture");
	my_cdev = cdev_alloc();
	my_cdev->owner = THIS_MODULE;
	err = cdev_add(my_cdev, devid, 1);
	if (err) {
		__wrn("cdev_add fail\n");
		return -1;
	}

	capture_class = class_create(THIS_MODULE, "capture");
	if (IS_ERR(capture_class))	{
		__wrn("class_create fail\n");
		return -1;
	}

	device_create(capture_class, NULL, devid, NULL, "capture");

	ret = platform_device_register(&capture_device);

	if (ret == 0) {
		ret = platform_driver_register(&capture_driver);
	}

	pr_info("[DISP]==capture finish==\n");

	return ret;
}

static int createDevice(void)
{
	/*Alocciert platz für device*/
	if(alloc_chrdev_region(&my_dev,0, DEV_COUNT, DEV_NAME) < 0)
	{
		printk (KERN_ERR "Alloc device fehler\n");  
		return -EIO;  
	
	}
	printk (KERN_INFO "MAJOR NUMBER: %d/n", MAJOR(my_dev)); 
	my_cdev = cdev_alloc();

	if(my_cdev == NULL){
		printk (KERN_ERR "cdev alloc FAIL!/n");  
		
	}
	my_cdev->owner = THIS_MODULE;
	my_cdev->ops = &my_fops;
	printk (KERN_INFO "cdev alloc SUCCESSFUL\n");

	
	if(cdev_add(my_cdev, my_dev, DEV_COUNT)){
		printk (KERN_ERR "add device FAILD\n");
		my_cdev = NULL;
		return -EIO;
	}
	return 0;
	
} 

static int __init driver_entry_init(void)
{
	printk(KERN_WARNING "Gilc: The moudle has been loaded!\n");
	ret = alloc_chrdev_region(&dev_num,0,1,DEVICE_NAME);
	if (ret < 0){
		printk(KERN_WARNING "Gilc: Failed to allocate a major number\n");
		return ret;
	}
	major_number = MAJOR(dev_num);
	printk(KERN_WARNING "Gilc: major number is %d", major_number);
	printk(KERN_WARNING "\tuse \"mknod /dev/%s c %d 0\" for device file", DEVICE_NAME,major_number);

	my_cdev = cdev_alloc();
	my_cdev->ops = &fops;
	my_cdev->owner = THIS_MODULE;
	ret = cdev_add(my_cdev,dev_num,1);
	if (ret < 0){
		printk(KERN_WARNING "Gilc: unable to add cdev to kernel\n");
		return ret;
	}

	sema_init(&virtual_device.sem , 1);

	return 0;
}

static int __init my_init(void)
{
        if (alloc_chrdev_region(&first, 0, count, MYDEV_NAME) < 0) {
                printk(KERN_ERR ME 
                       "failed to allocate character device region\n");
                return -1;
        }
        if (!(my_cdev = cdev_alloc())) {
                printk(KERN_ERR ME "cdev_alloc() failed\n");
                unregister_chrdev_region(first, count);
                return -1;
        }
        cdev_init(my_cdev, &mycdrv_fops);
        if (cdev_add(my_cdev, first, count) < 0) {
                printk(KERN_ERR ME "cdev_add() failed\n");
                cdev_del(my_cdev);
                unregister_chrdev_region(first, count);
                return -1;
        }
        my_sysfs_class = class_create(THIS_MODULE, "my_class");
        device_create(my_sysfs_class, NULL, first, NULL, "%s", "mycdrv");

        printk(KERN_INFO ME "simple ioctl chrdrv created, major %d\n",
               MAJOR(first));
        printk(KERN_INFO ME "sizeof(uint32_t) is %d\n", sizeof(uint32_t));
        return 0;
}

static int mtk_ext_disp_mgr_probe(struct platform_device *pdev)
{
    int ret = 0;
    struct class_device *class_dev = NULL;

    printk("[EXTD]%s\n", __func__);

    /* Allocate device number for hdmi driver */
    ret = alloc_chrdev_region(&hdmi_devno, 0, 1, HDMI_DEVNAME);

    if (ret)
    {
        printk("[EXTD]alloc_chrdev_region fail\n");
        return -1;
    }

    /* For character driver register to system, device number binded to file operations */
    hdmi_cdev = cdev_alloc();
    hdmi_cdev->owner = THIS_MODULE;
    hdmi_cdev->ops = &external_display_fops;
    ret = cdev_add(hdmi_cdev, hdmi_devno, 1);

    /* For device number binded to device name(hdmitx), one class is corresponeded to one node */
    hdmi_class = class_create(THIS_MODULE, HDMI_DEVNAME);
    /* mknod /dev/hdmitx */
    class_dev = (struct class_device *)device_create(hdmi_class, NULL, hdmi_devno, NULL, HDMI_DEVNAME);

    printk("[EXTD][%s] out\n", __func__);

    return 0;
}

//------------------------------------------------------------------------------
static inline int SYSRAM_RegCharDrv(void)
{
    LOG_MSG("E");
    if(alloc_chrdev_region(&Sysram.DevNo, 0, 1,SYSRAM_DEV_NAME) )
    {
        LOG_ERR("allocate device no failed");
        return -EAGAIN;
    }
    //allocate driver
    Sysram.pCharDrv = cdev_alloc();
    if(Sysram.pCharDrv == NULL)
    {
        unregister_chrdev_region(Sysram.DevNo, 1);
        LOG_ERR("allocate mem for kobject failed");
        return -ENOMEM;
    }
    //Attatch file operation.
    cdev_init(Sysram.pCharDrv, &SysramFileOper);
    Sysram.pCharDrv->owner = THIS_MODULE;
    //Add to system
    if(cdev_add(Sysram.pCharDrv, Sysram.DevNo, 1))
    {
        LOG_ERR("Attatch file operation failed");
        unregister_chrdev_region(Sysram.DevNo, 1);
        return -EAGAIN;
    }
    LOG_MSG("X");
    return 0;
}

int init__ (void)
{
  
  buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
  if (buffer==NULL)
  { 
   printk (KERN_INFO "Create buffer error\n");     
   return -ENOMEM;
  }
   register_chrdev (866, "myeth", &chardev_fops);

   first_node = MKDEV(866, 50);	
   register_chrdev_region (first_node, 1, "myeth");
   my_cdev = cdev_alloc();
   cdev_init(my_cdev, &chardev_fops);
   cdev_add (my_cdev,first_node, 1);
   printk (KERN_INFO "loaded: %s\n", NIITM_NAME);
   
   //eth  *****
     myeth_dev = alloc_netdev(sizeof(struct myeth_dev), NDEV_NAME,
		NET_NAME_UNKNOWN, &mynet_init);
  

    if(register_netdev(myeth_dev)) {
	printk(KERN_ERR "netdev register failed\n");
	return -ENODEV;
    }
	
   printk(KERN_INFO "netdev registered success\n");


   return 0;
}

static int hdmi_probe(struct platform_device *pdev)
{
    	int ret = 0;
	struct class_device *class_dev = NULL;

    	printk("[hdmi]%s\n", __func__);

    	/* Allocate device number for hdmi driver */
	ret = alloc_chrdev_region(&hdmi_devno, 0, 1, HDMI_DEVNAME);
	if(ret)
	{
		printk("[hdmi]alloc_chrdev_region fail\n");
		return -1;
	}

    	/* For character driver register to system, device number binded to file operations */
	hdmi_cdev = cdev_alloc();
	hdmi_cdev->owner = THIS_MODULE;
	hdmi_cdev->ops = &hdmi_fops;
	ret = cdev_add(hdmi_cdev, hdmi_devno, 1);

	/* For device number binded to device name(hdmitx), one class is corresponeded to one node */
	hdmi_class = class_create(THIS_MODULE, HDMI_DEVNAME);
	/* mknod /dev/hdmitx */
	class_dev = (struct class_device *)device_create(hdmi_class, NULL, hdmi_devno,	NULL, HDMI_DEVNAME);

	printk("[hdmi][%s] current=0x%08x\n", __func__, (unsigned int)current);
    	init_waitqueue_head(&hdmi_update_wq);


    	hdmi_update_task = kthread_create(hdmi_update_kthread, NULL, "hdmi_update_kthread");
    	wake_up_process(hdmi_update_task);
    	return 0;
}