C++ cdev_init函数代码示例

static int __init my_mem_init(void)
{
	int ret;
	dev_t dev;

	ret = alloc_chrdev_region(&dev, minor, 1, "my_mem");
	if (ret < 0) {
		printk(KERN_CRIT "fail to allocate chrdev region\n");
		return ret;
	}
	major = MAJOR(dev);

	printk("major=%d minor=%d\n", major, minor);

	cl = class_create(THIS_MODULE, "my_mem_class");
	if (IS_ERR(cl)) {
		printk(KERN_CRIT "fail to class_create\n");
		unregister_chrdev_region(dev, 1);
		return -1;
	}

	cdev_init(&my_cdev, &my_mem_fops);
	if (cdev_add(&my_cdev, dev, 1) == -1) {
		printk(KERN_CRIT "fail to cdev_add\n");
		class_destroy(cl);
		unregister_chrdev_region(dev, 1);
		return -1;
	}

	if (device_create(cl, NULL, MKDEV(major, minor), NULL, "my_mem0") == NULL) {
		printk(KERN_CRIT " fail to create device\n");
		class_destroy(cl);
		unregister_chrdev_region(MKDEV(major, minor), 1);
		cdev_del(&my_cdev);
		return -1;
	}
		
	return 0;
}

static int mod_gpio_init(void)
{
    S32         s32Ret;
    dev_t       dev;

    GPIO_PRINT("%s is invoked\n", __FUNCTION__);

    if (GPIODev.s32MajorGPIO)
    {
        dev = MKDEV(GPIODev.s32MajorGPIO, GPIODev.s32MinorGPIO);
        s32Ret = register_chrdev_region(dev, MOD_GPIO_DEVICE_COUNT, MOD_GPIO_NAME);
    }
    else
    {
        s32Ret = alloc_chrdev_region(&dev, GPIODev.s32MinorGPIO, MOD_GPIO_DEVICE_COUNT, MOD_GPIO_NAME);
        GPIODev.s32MajorGPIO = MAJOR(dev);
    }

    if ( 0 > s32Ret)
    {
        GPIO_PRINT("Unable to get major %d\n", GPIODev.s32MajorGPIO);
        return s32Ret;
    }

    cdev_init(&GPIODev.cDevice, &GPIODev.GPIOFop);
    if (0!= (s32Ret= cdev_add(&GPIODev.cDevice, dev, MOD_GPIO_DEVICE_COUNT)))
    {
        GPIO_PRINT("Unable add a character device\n");
        unregister_chrdev_region(dev, MOD_GPIO_DEVICE_COUNT);
        return s32Ret;
    }

	__mod_gpio_init();

	return 0;


}

static int __init bpamem_init(void)
{
	int result;
	unsigned int i;
	for(i = 0; i < MAX_BPA_ALLOCS; i++)
	{
		bpamem_dev[i].used = 0;
		bpamem_dev[i].phys_addr = 0;
	}
	
	result = register_chrdev_region(MKDEV(BPAMEM_MAJOR, 0), MAX_BPA_ALLOCS, DEVICE_NAME);
	if (result < 0) {
		printk( KERN_ALERT "BPAMem cannot register device (%d)\n", result);
		return result;
	}

	cdev_init(&bpamem_cdev, &bpamem_devops);
	bpamem_cdev.owner = THIS_MODULE;
	bpamem_cdev.ops = &bpamem_devops;
	if (cdev_add(&bpamem_cdev, MKDEV(BPAMEM_MAJOR, 0), MAX_BPA_ALLOCS) < 0)
	{
		printk("BPAMem couldn't register '%s' driver\n", DEVICE_NAME);
		return -1;
	}

	bpamem_class = class_create(THIS_MODULE, DEVICE_NAME);
	for(i = 0; i < MAX_BPA_ALLOCS; i++)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
		device_create(bpamem_class, NULL, MKDEV(BPAMEM_MAJOR, i), NULL, "bpamem%d", i);
#else
		class_device_create(bpamem_class, NULL, MKDEV(BPAMEM_MAJOR, i), NULL, "bpamem%d", i);
#endif

	sema_init(&sem_find_dev, 1);
	
	DEBUG_PRINTK("BPAMem driver register result = %d", result);
	return result;
}

static int __init test_init(void)	//模块初始化函数
{
	int result = 0;

	/*1.申请设备号*/
	if(major){						
		devno = MKDEV(major, minor);
		result = register_chrdev_region(devno, 1, "test new driver");
	}else{
		result = alloc_chrdev_region(&devno, minor, 1, "test alloc diver");
		major = MAJOR(devno);
		minor = MINOR(devno);
	}

	if(result < 0){
		P_DEBUG("register devno errno!\n");
		goto err0;
	}

	printk("major[%d] minor[%d]\n", major, minor);

	/*2.注册设备*/
	cdev_init(&test_cdev, &test_fops);
	test_cdev.owner = THIS_MODULE;
	result = cdev_add(&test_cdev, devno, 1);
	if(result < 0){
		P_DEBUG("cdev_add errno!\n");
		goto err1;
	}

	printk("hello kernel\n");
	return 0;

err1:
	unregister_chrdev_region(devno, 1);
err0:
	return result;
}

static int adf_chr_drv_create(void)
{
    dev_t dev_id;
    struct device *drv_device;

    if (alloc_chrdev_region(&dev_id, 0, 1, DEVICE_NAME)) {
        pr_err("QAT: unable to allocate chrdev region\n");
        return -EFAULT;
    }

    adf_ctl_drv.drv_class = class_create(THIS_MODULE, DEVICE_NAME);
    if (IS_ERR(adf_ctl_drv.drv_class)) {
        pr_err("QAT: class_create failed for adf_ctl\n");
        goto err_chrdev_unreg;
    }
    adf_ctl_drv.major = MAJOR(dev_id);
    cdev_init(&adf_ctl_drv.drv_cdev, &adf_ctl_ops);
    if (cdev_add(&adf_ctl_drv.drv_cdev, dev_id, 1)) {
        pr_err("QAT: cdev add failed\n");
        goto err_class_destr;
    }

    drv_device = device_create(adf_ctl_drv.drv_class, NULL,
                               MKDEV(adf_ctl_drv.major, 0),
                               NULL, DEVICE_NAME);
    if (IS_ERR(drv_device)) {
        pr_err("QAT: failed to create device\n");
        goto err_cdev_del;
    }
    return 0;
err_cdev_del:
    cdev_del(&adf_ctl_drv.drv_cdev);
err_class_destr:
    class_destroy(adf_ctl_drv.drv_class);
err_chrdev_unreg:
    unregister_chrdev_region(dev_id, 1);
    return -EFAULT;
}

static int
zpios_init(void)
{
	dev_t dev;
	int rc;

	dev = MKDEV(ZPIOS_MAJOR, 0);
	if ((rc = register_chrdev_region(dev, ZPIOS_MINORS, ZPIOS_NAME)))
		goto error;

	/* Support for registering a character driver */
	cdev_init(&zpios_cdev, &zpios_fops);
	zpios_cdev.owner = THIS_MODULE;
	kobject_set_name(&zpios_cdev.kobj, ZPIOS_NAME);
	if ((rc = cdev_add(&zpios_cdev, dev, ZPIOS_MINORS))) {
		printk(KERN_ERR "ZPIOS: Error adding cdev, %d\n", rc);
		kobject_put(&zpios_cdev.kobj);
		unregister_chrdev_region(dev, ZPIOS_MINORS);
		goto error;
	}

	/* Support for udev make driver info available in sysfs */
	zpios_class = spl_class_create(THIS_MODULE, ZPIOS_NAME);
	if (IS_ERR(zpios_class)) {
		rc = PTR_ERR(zpios_class);
		printk(KERN_ERR "ZPIOS: Error creating zpios class, %d\n", rc);
		cdev_del(&zpios_cdev);
		unregister_chrdev_region(dev, ZPIOS_MINORS);
		goto error;
	}

	zpios_device = spl_device_create(zpios_class, NULL,
					 dev, NULL, ZPIOS_NAME);
	return 0;
error:
	printk(KERN_ERR "ZPIOS: Error registering zpios device, %d\n", rc);
	return rc;
}

static int __init ib_ucm_init(void)
{
	int result;

	result = register_chrdev_region(IB_UCM_DEV, 1, "infiniband_cm");
	if (result) {
		ucm_dbg("Error <%d> registering dev\n", result);
		goto err_chr;
	}

	cdev_init(&ib_ucm_cdev, &ib_ucm_fops);

	result = cdev_add(&ib_ucm_cdev, IB_UCM_DEV, 1);
	if (result) {
 		ucm_dbg("Error <%d> adding cdev\n", result);
		goto err_cdev;
	}

	ib_ucm_class = class_create(THIS_MODULE, "infiniband_cm");
	if (IS_ERR(ib_ucm_class)) {
		result = PTR_ERR(ib_ucm_class);
 		ucm_dbg("Error <%d> creating class\n", result);
		goto err_class;
	}

	class_device_create(ib_ucm_class, IB_UCM_DEV, NULL, "ucm");

	idr_init(&ctx_id_table);
	init_MUTEX(&ctx_id_mutex);

	return 0;
err_class:
	cdev_del(&ib_ucm_cdev);
err_cdev:
	unregister_chrdev_region(IB_UCM_DEV, 1);
err_chr:
	return result;
}

static int __init led_init(void)
{
	int ret;
	dev_t dev_no;

	ret = alloc_chrdev_region(&dev_no, 0, 1, "led_drv");  
	if (!!ret) {
		 printk(KERN_ERR"arrage device no erro!\n");  
		 return ret;
	}

	devp = kmalloc(sizeof(struct led_dev), GFP_KERNEL);
	if (!devp) {
		ret = -ENOMEM;
		goto out1;//goto !!
	}
	memset(devp, 0, sizeof(struct led_dev));
	
	/*init led_dev*/
	devp->major_no = MAJOR(dev_no);
	cdev_init(&devp->cdev, &led_fops);
	devp->cdev.owner = THIS_MODULE;
	ret = cdev_add(&devp->cdev, dev_no, 1);
    if(ret) {	
		goto out2;//goto !!
	}
	
	led_cls = class_create(THIS_MODULE, "led_drv");
	led_cls_dev = device_create(led_cls, NULL, dev_no, "m_led");
	
	return 0; //init successful

out2 :
	kfree(devp);	
out1 :
	unregister_chrdev_region(dev_no, 1);	
	return ret;//init failed
}

/* module initialization and cleanup */
static int __init init(void)
{
	int i, err;

	printk(KERN_INFO PFX "reading parameters\n");
	err = read_params(DRIVER_NAME, &config);
	if (err != 0)
		return -1;
	printk(KERN_INFO PFX
		"initializing driver for %d (max %d) cards\n",
		config.num_modules, VMOD_MAX_BOARDS);

	/* fill in config data and semaphore */
	for (i = 0; i < config.num_modules; i++) {
		device_list[i].config = &config.module[i];
		init_MUTEX(&device_list[i].sem);
	}

	err = alloc_chrdev_region(&devno, 0, VMOD12E16_MAX_MODULES, DRIVER_NAME);
	if (err != 0)
		goto fail_chrdev;
	printk(KERN_INFO PFX "allocated device %d\n", MAJOR(devno));

	cdev_init(&cdev, &fops);
	cdev.owner = THIS_MODULE;
	if (cdev_add(&cdev, devno, VMOD12E16_MAX_MODULES) != 0) {
		printk(KERN_ERR PFX
			"failed to create chardev %d with err %d\n",
				MAJOR(devno), err);
		goto fail_cdev;
	}
	return 0;

fail_cdev:	
	unregister_chrdev_region(devno, VMOD12E16_MAX_MODULES);
fail_chrdev:	
	return -1;
}

static int BT_init(void)
{
    dev_t dev = MKDEV(BT_major, 0);
    int alloc_ret = 0;
    int cdev_err = 0;

    /*static allocate chrdev*/
    alloc_ret = register_chrdev_region(dev, 1, BT_DRIVER_NAME);
    if (alloc_ret) {
        BT_ERR_FUNC("fail to register chrdev\n");
        return alloc_ret;
    }

    cdev_init(&BT_cdev, &BT_fops);
    BT_cdev.owner = THIS_MODULE;

    cdev_err = cdev_add(&BT_cdev, dev, BT_devs);
    if (cdev_err)
        goto error;

    BT_INFO_FUNC("%s driver(major %d) installed.\n", BT_DRIVER_NAME, BT_major);
    retflag = 0;
    mtk_wcn_stp_register_event_cb(BT_TASK_INDX, NULL);

    /* init wait queue */
    init_waitqueue_head(&(inq));

    return 0;

error:
    if (cdev_err == 0)
        cdev_del(&BT_cdev);

    if (alloc_ret == 0)
        unregister_chrdev_region(dev, BT_devs);

    return -1;
}

static int sleepy_init(void)
{
	dev_t devno;
	int result;

	/*
	 * Register your major, and accept a dynamic number
	 */
	if (sleepy_major) {
		devno = MKDEV(sleepy_major, 0);
		result = register_chrdev_region(devno, 1, "sleepy");
	} else {
		result = alloc_chrdev_region(&devno, sleepy_major, 1, "sleepy");
		sleepy_major = MAJOR(devno);
	}
	if (result < 0)
		goto register_chrdev_region_failed;

	cdev = cdev_alloc();
	if (!cdev) {
		result = -ENOMEM;
		goto cdev_alloc_failed;
	}
	cdev_init(cdev, &sleepy_fops);
	cdev->owner = sleepy_fops.owner;
	result = cdev_add(cdev, devno, 1);
	if (result < 0)
		goto cdev_add_failed;

	return 0;

cdev_add_failed:
	cdev_del(cdev);
cdev_alloc_failed:
	unregister_chrdev_region(devno, 1);
register_chrdev_region_failed:
	return result;
}

int DEMO_init_module(void)
{
	int result;
	dev_t dev = 0;

	dev = MKDEV(DEMO_MAJOR, DEMO_MINOR);
	result = register_chrdev_region(dev, 1, "DEMO");
	if (result < 0) 
	{
		printk(KERN_WARNING "DEMO: can't get major %d\n", DEMO_MAJOR);
		return result;
	}

	DEMO_devices = kmalloc(sizeof(struct DEMO_dev), GFP_KERNEL);
	if (!DEMO_devices)
	{
		result = -ENOMEM;
		goto fail;
	}
	memset(DEMO_devices, 0, sizeof(struct DEMO_dev));

	init_MUTEX(&DEMO_devices->sem);
	cdev_init(&DEMO_devices->cdev, &DEMO_fops);
	DEMO_devices->cdev.owner = THIS_MODULE;
	DEMO_devices->cdev.ops = &DEMO_fops;
	result = cdev_add (&DEMO_devices->cdev, dev, 1);
	if(result)
	{
		printk(KERN_NOTICE "Error %d adding DEMO\n", result);
		goto fail;
	}
	init_waitqueue_head(&DEMO_devices->wq);
	return 0;

fail:
	DEMO_cleanup_module();
	return result;
}

int lunix_chrdev_init(void)
{
	/*
	 * Register the character device with the kernel, asking for
	 * a range of minor numbers (number of sensors * 8 measurements / sensor)
	 * beginning with LINUX_CHRDEV_MAJOR:0
	 */
	int ret;
	dev_t dev_no;
	unsigned int lunix_minor_cnt = lunix_sensor_cnt << 3;
	
	debug("initializing character device\n");
	cdev_init(&lunix_chrdev_cdev, &lunix_chrdev_fops);
	lunix_chrdev_cdev.owner = THIS_MODULE;
	
	dev_no = MKDEV(LUNIX_CHRDEV_MAJOR, 0);
	/* ? */
	/* register_chrdev_region? */
    ret=register_chrdev_region(dev_no,lunix_minor_cnt,"Lunix:TNG");
	if (ret < 0) {
		debug("failed to register region, ret = %d\n", ret);
		goto out;
	}
	/* ? */
	/* cdev_add? */
    ret=cdev_add(&lunix_chrdev_cdev,dev_no,lunix_minor_cnt);
	if (ret < 0) {
		debug("failed to add character device\n");
		goto out_with_chrdev_region;
	}
	debug("completed successfully\n");
	return 0;
    
out_with_chrdev_region:
	unregister_chrdev_region(dev_no, lunix_minor_cnt);
out:
	return ret;
}

/*初始化设备*/
static int  __hello_setup_dev(struct hello_android_dev* dev) {
    int err;
    dev_t devno = MKDEV(hello_major, hello_minor);

    memset(dev, 0, sizeof(struct hello_android_dev));

    cdev_init(&(dev->dev), &hello_fops);
    dev->dev.owner = THIS_MODULE;
    dev->dev.ops = &hello_fops;

    /*注册字符设备*/
    err = cdev_add(&(dev->dev),devno, 1);
    if(err) {
        return err;
    }

    /*初始化信号量和寄存器val的值*/
    //init_MUTEX(&(dev->sem));
    sema_init(&(dev->sem), 1);
    dev->val = 0;

    return 0;
}

static int __init FSM_CSIOCTLModule_init(void)
{
    if(alloc_chrdev_region(&FSM_CIO_first, 0, 1, "fsmr") < 0)
        return -1;
    if((FSM_CIO_cl = class_create(THIS_MODULE, "fsm")) == NULL) {
        unregister_chrdev_region(FSM_CIO_first, 1);
        return -1;
    }
    if(device_create(FSM_CIO_cl, NULL, FSM_CIO_first, NULL, "fsmio") == NULL) {
        class_destroy(FSM_CIO_cl);
        unregister_chrdev_region(FSM_CIO_first, 1);
        return -1;
    }
    cdev_init(&FSM_CIO_c_dev, &fops);
    if(cdev_add(&FSM_CIO_c_dev, FSM_CIO_first, 1) == -1) {
        device_destroy(FSM_CIO_cl, FSM_CIO_first);
        class_destroy(FSM_CIO_cl);
        unregister_chrdev_region(FSM_CIO_first, 1);
        return -1;
    }
    printk(KERN_INFO "FSM SIOCTL module loaded\n");
    return 0;
}