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; }
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 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; }
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 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; }
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 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; }
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; }
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; }
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; }
//内核加载后的初始化函数. 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; }
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; }
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; }
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; }
//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 } }
/******************************************************************************* ** ** 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); }
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; }
/****************************************************************************** * 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; }
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; }