コード例 #1
1
int __init disp_module_init(void)
{
    int ret, err;

    __inf("disp_module_init\n");

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

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

    device_create(disp_class, NULL, devid, NULL, "disp");

	ret = platform_device_register(&disp_device);

	if (ret == 0)
	{
		ret = platform_driver_register(&disp_driver);
	}
#ifdef CONFIG_HAS_EARLYSUSPEND
    register_early_suspend(&backlight_early_suspend_handler);
#endif

	return ret;
}
コード例 #2
0
ファイル: drv.c プロジェクト: gurugio/ldd
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;
}
コード例 #3
0
ファイル: mdrv_gpio_io.c プロジェクト: Scorpio92/mstar6a918
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;


}
コード例 #4
0
ファイル: bpamem.c プロジェクト: Vorahaz/RUnigma
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;
}
コード例 #5
0
static signed int felica_uart_init(void)
{
	signed int result = 0;
	struct device *class_dev;

	dev_t dev = MKDEV(MISC_MAJOR, 0);

	MFCUART_DRV_DBG_LOG("START");

	result = alloc_chrdev_region(&dev , 0 , D_FELICA_UART_DEVS, D_FELICA_UART_DEV_NAME);
	if (result) {
		MFCUART_DRV_ERR_LOG("alloc_chrdev_region result = %d", result);
		return result;
	}

	cdev_init(&felica_uart_cdev, &felica_uart_fileops);
	felica_uart_cdev.owner = THIS_MODULE;

	result = cdev_add(&felica_uart_cdev, dev, D_FELICA_UART_DEVS);
	if (result) {
		unregister_chrdev_region(dev, D_FELICA_UART_DEVS);
		MFCUART_DRV_ERR_LOG("cdev_add result = %d", result);
		return result;
	}

	class_dev = device_create(mfcuart_class, NULL, dev, NULL, D_FELICA_UART_DEV_NAME);
	if (IS_ERR(class_dev)) {
		cdev_del(&felica_uart_cdev);
		unregister_chrdev_region(dev, D_FELICA_UART_DEVS);
		result = PTR_ERR(class_dev);
		MFCUART_DRV_ERR_LOG("device_create result = %d", result);
		return result;
	}

	MFCUART_DRV_DBG_LOG("END");

	return result;
}
コード例 #6
0
ファイル: test.c プロジェクト: embedclub/Lavender
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;
}
コード例 #7
0
static int pon_init(void)
{
	int sdResult = 0;
	struct device *class_dev;
	
	dev_t dev = MKDEV(MISC_MAJOR, 0);
	
	MFC_DRV_DBG_LOG("START");
	
	sdResult = alloc_chrdev_region(&dev , 0 , D_PON_DEVS, D_PON_DEV_NAME);
	if (sdResult) {
		MFC_DRV_ERR_LOG("alloc_chrdev_region sdResult = %d", sdResult);
		return sdResult;
	}
	
	cdev_init(&pon_cdev, &pon_fileops);
	pon_cdev.owner = THIS_MODULE;
	
	sdResult = cdev_add(&pon_cdev, dev, D_PON_DEVS);
	if (sdResult) {
		unregister_chrdev_region(dev, D_PON_DEVS);
		MFC_DRV_ERR_LOG("cdev_add sdResult = %d", sdResult);
		return sdResult;
	}
	
	class_dev = device_create(felica_class, NULL, dev, NULL, D_PON_DEV_NAME);
	if (IS_ERR(class_dev)) {
		cdev_del(&pon_cdev);
		unregister_chrdev_region(dev, D_PON_DEVS);
		sdResult = PTR_ERR(class_dev);
		MFC_DRV_ERR_LOG("device_create sdResult = %d", sdResult);
		return sdResult;
	}

	MFC_DRV_DBG_LOG("END");
	
	return sdResult;
}
コード例 #8
0
ファイル: adf_ctl_drv.c プロジェクト: davyb1964/rxe-dev
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;
}
コード例 #9
0
ファイル: pios.c プロジェクト: apgodshall/zfs
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;
}
コード例 #10
0
ファイル: ucm.c プロジェクト: kzlin129/tt-gpl
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;
}
コード例 #11
0
static int succ_init(void)
{
	int result = 0;
	struct device *class_dev;

	dev_t dev = MKDEV(MISC_MAJOR, 0);

	MFC_DRV_DBG_LOG("START");

	result = alloc_chrdev_region(&dev, 0, D_SUCC_DEVS, D_SUCC_DEV_NAME);
	if (result) {
		MFC_DRV_ERR_LOG("alloc_chrdev_region result = %d", result);
		return result;
	}

	cdev_init(&succ_cdev, &succ_fileops);
	succ_cdev.owner = THIS_MODULE;

	result = cdev_add(&succ_cdev, dev, D_SUCC_DEVS);
	if (result) {
		unregister_chrdev_region(dev, D_SUCC_DEVS);
		MFC_DRV_ERR_LOG("cdev_add result = %d", result);
		return result;
	}

	class_dev = device_create(snfc_class, NULL, dev, NULL, D_SUCC_DEV_NAME);
	if (IS_ERR(class_dev)) {
		cdev_del(&succ_cdev);
		unregister_chrdev_region(dev, D_SUCC_DEVS);
		result = PTR_ERR(class_dev);
		MFC_DRV_ERR_LOG("device_create result = %d", result);
		return result;
	}

	MFC_DRV_DBG_LOG("END");

	return result;
}
コード例 #12
0
ファイル: m_led.c プロジェクト: cheermoon/LDD
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
}
コード例 #13
0
ファイル: vmod12e16drvr.c プロジェクト: bradomyn/coht
/* 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;
}
コード例 #14
0
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;
}
コード例 #15
0
ファイル: sleepy.c プロジェクト: zxbuaa/ldd3
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;
}
コード例 #16
0
ファイル: demo.c プロジェクト: Jacob-jiangbo/my-test
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;
}
コード例 #17
0
ファイル: lunix-chrdev.c プロジェクト: spirosmastorakis/OSlab
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;
}
コード例 #18
0
/*初始化设备*/
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;
}
コード例 #19
0
ファイル: FSMClientIOCtl.c プロジェクト: fsmos/FSMServer
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;
}
コード例 #20
0
static int chr_init(void){
	if(alloc_chrdev_region(&dev_alloc,0,count,DEVICE)<0){
		printk("ERROR IN ALLOCATION OF CHRDEV\n");
		return -1;
	}
	if((cdev_naresh=cdev_alloc())==NULL){
		printk("ERROR IN DEVICE ALLOCATION\n");
		unregister_chrdev_region(dev_alloc,count);
		return -1;
	}
	cdev_init(cdev_naresh,&fops_alloc);
	if(cdev_add(cdev_naresh,dev_alloc,count)<0){
		printk("ERROR IN DEVICE CHAR DEVICE ADDTION\n");
		cdev_del(cdev_naresh);
		unregister_chrdev_region(dev_alloc,count);
		return -1;
	}
	naresh_alloc_class = class_create(THIS_MODULE, "DYNAMICALLY_CONFIG");
        device_create(naresh_alloc_class, NULL, dev_alloc, NULL, "%s", "alloc_naresh");
	
	printk("SUCCESSFULLY CREATED ALLOC_CHRDEVICE of major=%d  DEVICE NAME=%s \n",MAJOR(dev_alloc),DEVICE);
return 0;
}
コード例 #21
0
ファイル: devone.c プロジェクト: 0x1abin/linux_kernel_driver
static int devone_init(void)
{
    dev_t dev = MKDEV(devone_major, 0);
    int ret;
    int major;
    int err;

    ret = alloc_chrdev_region(&dev, 0, devone_devs, "devone");
    if (ret < 0)
        return ret;
    devone_major = major = MAJOR(dev);

    cdev_init(&devone_cdev, &devone_fops);
    devone_cdev.owner = THIS_MODULE;
    devone_cdev.ops = &devone_fops;
    err = cdev_add(&devone_cdev, MKDEV(devone_major, 0), 1);
    if (err)
        return err;

    printk(KERN_ALERT "devone driver(major %d) installed.\n", major);

    return 0;
}
コード例 #22
0
//内核加载后的初始化函数.
static int __init pi_led_init(void)
{
   struct device *dev;
   int major; //自动分配主设备号
   major = alloc_chrdev_region(&pi_led_devno,0,1,DRIVER_NAME);
   //register_chrdev 注册字符设备使系统知道有LED这个模块在.
   
   cdev_init(&pi_led_class_dev, &pi_led_dev_fops);
   major = cdev_add(&pi_led_class_dev,pi_led_devno,1);
   //注册class
   pi_led_class = class_create(THIS_MODULE,DRIVER_NAME);
   
   dev = device_create(pi_led_class ,NULL,pi_led_devno,NULL,DRIVER_NAME);
   
   gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);
   gpiochip->direction_output(gpiochip, led_pin, 1);
   gpiochip->set(gpiochip, led_pin, 1);
   msleep(500);
   gpiochip->set(gpiochip, led_pin, 0);
   interval = 500;
   printk("pi led init ok!\n");
   return 0;
}
コード例 #23
0
static int ela_init(void)
{

int ret_val;

ret_val=alloc_chrdev_region(&dev,7,3,"Char_dvr");   //dynamic allocation of major number

if(ret_val<0)
{
printk("error in allocating character driver..\n");
}

cdev_init(&my_char_driver,&fopz);          //connect file operations with cdev
cdev_add(&my_char_driver,dev,3);           //connect major&minor number with cdev

class_var=class_create(THIS_MODULE,"Char_dvr");   //populate sysfs entries

device_create(class_var,NULL,dev,NULL,"Char_dvr");          //send uevents to udev  //   dev/char_dvr will be created

printk("ELA:  In init function ... \n");

return 0;
}
コード例 #24
0
ファイル: lab2_priv.c プロジェクト: YorkZ/docs_utils
static int __init my_init (void)
{
    first = MKDEV (my_major, my_minor);
    if (register_chrdev_region (first, count, MYDEV_NAME) < 0) {
        printk (KERN_ERR "failed to register character device region\n");
        return -1;
    }
    if (!(my_cdev = cdev_alloc ())) {
        printk (KERN_ERR "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 "cdev_add() failed\n");
        cdev_del (my_cdev);
        unregister_chrdev_region (first, count);
        return -1;
    }
    printk (KERN_INFO "\nSucceeded in registering character device %s\n",
            MYDEV_NAME);
    return 0;
}
コード例 #25
0
ファイル: char.c プロジェクト: pplinlin2/kernel
int test_init(void)
{
	devNum = MKDEV(reg_major, reg_minor);
	if(register_chrdev_region(devNum, count, "testchar") == 0){
		printk("register success\n");
	}else{
		return -1;
	}
	
	printk("dev number = %x\n", devNum);
	gDev = kzalloc(sizeof(struct cdev), GFP_KERNEL);
	gFile = kzalloc(sizeof(struct file_operations), GFP_KERNEL);

	gFile->open = testOpen;
	gFile->read = testRead;
	gFile->write = testWrite;
	gFile->unlocked_ioctl = testIoctl;
	gFile->owner = THIS_MODULE;

	cdev_init(gDev, gFile);
	cdev_add(gDev, devNum , 3);
	return 0;
}
コード例 #26
0
ファイル: translate.c プロジェクト: GollyTicker/suseVM
//setup method for character devices from skull driver
static void translate_setup_cdev(struct translate_dev *dev, int index) {
	int result;
    /*set the devicenumber*/
	int devno = MKDEV(translate_major, TRANSLATE_FIRST_MINOR + index);

	#ifdef DEBUG_MESSAGES
	printk(KERN_NOTICE "--- translate_setup_cdev called --- \n");
	#endif
    /*init the characterdevice*/
	cdev_init(&dev->cdev, &translate_ops);
	dev->cdev.owner = THIS_MODULE;
	dev->cdev.ops = &translate_ops;
    /*add the characterdevice*/
	result = cdev_add(&dev->cdev, devno, 1);

	if (result) {

		#ifdef DEBUG_MESSAGES
		printk (KERN_NOTICE "Error %d adding translatedev%d \n", result, index);
		#endif

	}
}
コード例 #27
0
/*******************************************************************************
**
**  onuPonMngInterfaceCreate
**  ____________________________________________________________________________
**
**  DESCRIPTION: The function create management interface - char device
**
**  PARAMETERS:  None
**
**  OUTPUTS:     None
**
**  RETURNS:     MV_OK or MV_ERROR
**
*******************************************************************************/
MV_STATUS onuPonMngInterfaceCreate(void)
{
	int   rcode;
	dev_t dev;

	dev   = MKDEV(MV_PON_MAJOR, 0);
	rcode = register_chrdev_region(dev, PON_NUM_DEVICES, PON_DEV_NAME);
	if (rcode < 0) {
		mvPonPrint(PON_PRINT_ERROR, PON_INIT_MODULE,
				   "ERROR: (%s:%d) Pon Char Device\n", __FILE_DESC__, __LINE__);
		return(MV_ERROR);
	}

	cdev_init(&ponDev.cdev, &ponCdevFops);
	ponDev.cdev.owner = THIS_MODULE;
	ponDev.drvMode = E_PON_DRIVER_UNDEF_MODE;

	rcode = cdev_add(&ponDev.cdev, dev, 1);
	if (rcode < 0) {
		mvPonPrint(PON_PRINT_ERROR, PON_INIT_MODULE,
				   "ERROR: (%s:%d) Pon Char Device Add\n", __FILE_DESC__, __LINE__);

		cdev_del(&ponDev.cdev);
		unregister_chrdev_region(dev, PON_NUM_DEVICES);

		return(MV_ERROR);
	}

	/* create device for udev */
	pon_udev_class = class_create(THIS_MODULE, PON_DEV_NAME);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
	pon_udev_dev   = device_create(pon_udev_class, NULL, dev, PON_DEV_NAME);
#else
	pon_udev_dev   = device_create(pon_udev_class, NULL, dev, NULL, PON_DEV_NAME);
#endif
	return(MV_OK);
}
コード例 #28
0
ファイル: hello.c プロジェクト: StefanoD/systemsoftware
static int __init ModInit(void)
{
	printk(KERN_INFO "%sDriver: Registering...\n", DEV_NAME);
	if (alloc_chrdev_region(&dev_number,0,1, "TestDriver") < 0) 
	{
		printk(KERN_ALERT "%sDriver: Reserving Devicenumber failed!\n", DEV_NAME);
		return -EIO;
	}
	if ((cl = class_create(THIS_MODULE, "chardrv_hello")) == NULL)
	{
		printk(KERN_ALERT "%sDriver: Creating Device Class failed", DEV_NAME);
		unregister_chrdev_region(dev_number, 1);
		return -EIO;
	}
	if (device_create(cl, NULL, dev_number, NULL, "mydevice") == NULL)
	{
		printk(KERN_ALERT "%sDriver: Populating Device Class failed", DEV_NAME);
		class_destroy(cl);
		unregister_chrdev_region(dev_number, 1);
		return -EIO;
	}
	
	cdev_init(&c_dev, &fops);
	if (cdev_add(&c_dev, dev_number, 1) == -1)
	{
		printk(KERN_ALERT "%sDriver: Driver registering failed", DEV_NAME);
		device_destroy(cl, dev_number);
		class_destroy(cl);
		unregister_chrdev_region(dev_number, 1);
		return -EIO;
	}
	
	printk(KERN_INFO "%sDriver: Registered\n", DEV_NAME);
	printk(KERN_INFO "Major, Minor: %d, %d \n", MAJOR(dev_number), MINOR(dev_number));
	return 0;
	
}
コード例 #29
0
ファイル: devinfo.c プロジェクト: Scorpio92/mediatek
/******************************************************************************
 * devinfo_init
 * 
 * DESCRIPTION: 
 *   Init the device driver ! 
 * 
 * PARAMETERS: 
 *   None
 * 
 * RETURNS: 
 *   0 for success
 * 
 * NOTES: 
 *   None
 * 
 ******************************************************************************/
static int __init devinfo_init(void)
{
    int ret = 0;
    devinfo_dev = MKDEV(MAJOR_DEV_NUM, 0);

	xlog_printk(ANDROID_LOG_INFO, DEVINFO_TAG ," init\n");    

	ret = register_chrdev_region(devinfo_dev, 1, DEV_NAME );
	if (ret)    
	{        
	    xlog_printk(ANDROID_LOG_ERROR, DEVINFO_TAG ,"[%s] register device failed, ret:%d\n", MODULE_NAME, ret);
	    return ret;
    }
	/*create class*/
	 devinfo_class = class_create(THIS_MODULE, DEV_NAME);
	 if (IS_ERR(devinfo_class)) {
		ret = PTR_ERR(devinfo_class);
        xlog_printk(ANDROID_LOG_ERROR, DEVINFO_TAG ,"[%s] register class failed, ret:%d\n", MODULE_NAME, ret);
	    return ret;
    }



	/* initialize the device structure and register the device  */
    cdev_init(&devinfo_cdev, &devinfo_fops);
    devinfo_cdev.owner = THIS_MODULE;
    if ((ret = cdev_add(&devinfo_cdev, devinfo_dev  , 1)) < 0) 
    {
        xlog_printk(ANDROID_LOG_ERROR, DEVINFO_TAG ,"[%s] could not allocate chrdev for the device, ret:%d\n", MODULE_NAME, ret);
        return ret;
    }
	
	/*create device*/
	device_create(devinfo_class,NULL,devinfo_dev,NULL,"devmap");
		 
	return 0;
}
コード例 #30
0
ファイル: vf_driver.c プロジェクト: Jackygcc/zynq_driver
static int __init vf_init (void) {
	int err;

	vf_buf = kmalloc(vf_bufsize, GFP_KERNEL);
	buf_pos= kmalloc(1, GFP_KERNEL);
	if (!vf_buf) {
		err = -ENOMEM;
		goto err_exit;
	}

	printk(KERN_INFO "vf_buf: %x\n\r", (unsigned int)vf_buf);
	printk(KERN_INFO "Registering the vf\n\r");
	if (register_chrdev_region(vf_dev, vf_count, "vf-driver")) {
		printk(KERN_INFO "register the vf-driver error\n\r");
		err = -ENODEV;
		goto err_free_buf;
	}

	cdev_init(&vf_cdev, &vf_fops);

	if (cdev_add(&vf_cdev, vf_dev, vf_count)) {
		printk(KERN_INFO "add the vf-driver character device error\n\r");
		err = -ENODEV;
		goto err_dev_unregister;
	}

	printk(KERN_INFO "vf-driver was registered\n\r");
	return 0;

	err_dev_unregister:
		unregister_chrdev_region(vf_dev, vf_count);
	err_free_buf:
		printk(KERN_INFO "FAIL to register vf-driver\n\r");
		iounmap(vf_buf);
	err_exit:
		return err;
}