static int sound_insert_unit(struct sound_unit **list, struct file_operations *fops, int index, int low, int top, const char *name, umode_t mode) { struct sound_unit *s = kmalloc(sizeof(*s), GFP_KERNEL); int r; if (!s) return -ENOMEM; spin_lock(&sound_loader_lock); r = __sound_insert_unit(s, list, fops, index, low, top); spin_unlock(&sound_loader_lock); if (r < 0) goto fail; else if (r < SOUND_STEP) sprintf(s->name, "sound/%s", name); else sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP); devfs_mk_cdev(MKDEV(SOUND_MAJOR, s->unit_minor), S_IFCHR | mode, s->name); class_simple_device_add(sound_class, MKDEV(SOUND_MAJOR, s->unit_minor), NULL, s->name+6); return r; fail: kfree(s); return r; }
int init_module(void) { int ret; dev_t dev = MKDEV(DVB_MAJOR, 0); if ((ret = register_chrdev_region(dev, 64, DEVICE_NAME)) != 0) { printk(KERN_INFO "td-dvb-fe: unable to get major %d\n", DVB_MAJOR); goto error; } cdev_init(&device_cdev, &fops); if ((ret = cdev_add(&device_cdev, dev, 64)) != 0) { printk(KERN_INFO "td-dvb-fe: unable to get major %d\n", DVB_MAJOR); goto error; } devfs_mk_dir("dvb"); my_class = class_simple_create(THIS_MODULE, DEVICE_NAME); if (IS_ERR(my_class)) { ret = PTR_ERR(my_class); goto error; } devfs_mk_cdev(MKDEV(DVB_MAJOR, 3), S_IFCHR | S_IRUSR | S_IWUSR, "dvb/adapter0/frontend0"); class_simple_device_add(my_class, MKDEV(DVB_MAJOR, 3), NULL, "dvb0.frontend0"); printk(KERN_INFO "[td-dvb-fe] loaded\n"); return 0; error: cdev_del(&device_cdev); unregister_chrdev_region(dev, 64); return ret; }
static int init_kb(void) { unsigned int ret; kb_file_ops.owner = THIS_MODULE, kb_file_ops.read = kb_read; kb_file_ops.open = kb_open; kb_file_ops.release = kb_release; /*kb_drv.driver.name = "mykb"; kb_drv.interrupt = kb_interrupt; kb_drv.connect = kb_connect; */ ret=alloc_chrdev_region(&mydev,0,1,"mykb"); kb_id= MAJOR(mydev);//extract major no /* Let's Start Udev stuff */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) veda_class = class_simple_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } class_simple_device_add(veda_class,mydev,NULL,"mykb"); #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14) veda_class = class_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } device_create(veda_class,NULL,mydev,NULL,"mykb"); #endif /*Register our character Device*/ veda_cdev= cdev_alloc(); veda_cdev->owner=THIS_MODULE; veda_cdev->ops= &kb_file_ops; ret=cdev_add(veda_cdev,mydev,1); if( ret < 0 ) { printk("Error registering device driver\n"); return ret; } printk("Device Registered with MAJOR NO[%d]\n",kb_id); if(request_irq(KB_INT,kb_interrupt,IRQF_SHARED, "mykb",(void *)&some_data)){ printk(KERN_ERR "mykb: cannot register IRQ %d\n", 8); return -EIO; } init_waitqueue_head( &mykb_queue ); printk("mykb interrupt registered\n"); return 0; }
int kb_init(void) { unsigned int ret; inuse = 0; kb_file_ops.owner = THIS_MODULE, kb_file_ops.read = kb_read; kb_file_ops.open = kb_open; kb_file_ops.release = kb_release; ret = alloc_chrdev_region(&mydev,0,1,"mykb"); char_device_id = MAJOR(mydev); #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) veda_class = class_simple_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } class_simple_device_add(veda_class,mydev,NULL,"mykb"); #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14) veda_class = class_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } device_create(veda_class,NULL,mydev,"mykb"); #endif /*Register our character Device*/ veda_cdev = cdev_alloc(); veda_cdev -> owner = THIS_MODULE; veda_cdev -> ops = &kb_file_ops; ret = cdev_add(veda_cdev, mydev, 1); init_waitqueue_head(&kb_queue); if( ret < 0 ) { printk("Error registering device driver\n"); return ret; } printk("\n Device Regitered with id : %d",char_device_id); if(request_irq(KB_INT,kb_interrupt,IRQF_SHARED, "mykb",(void *)&some_data)){ printk(KERN_ERR "mykb: cannot register IRQ %d\n", 8); return -EIO; } printk("\n mykb interrupt registered\n"); return 0; }
int init_char_device(void) { int i,ret; char_device_file_ops.owner = THIS_MODULE; char_device_file_ops.read = char_device_read; char_device_file_ops.write = char_device_write; char_device_file_ops.open = char_device_open; char_device_file_ops.release = char_device_release; char_device_file_ops.llseek = char_device_lseek; char_device_file_ops.aio_read = char_device_aio_read; char_device_file_ops.aio_write = char_device_aio_write; ret=alloc_chrdev_region(&mydev,0,1,"veda_cdrv"); char_device_id= MAJOR(mydev);//extract major no #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) veda_class = class_simple_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } class_simple_device_add(veda_class,mydev,NULL,"veda_cdrv"); #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14) veda_class=class_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } device_create(veda_class,NULL,mydev,NULL,"veda_cdrv"); #endif /*Register our character Device*/ veda_cdev= cdev_alloc(); veda_cdev->owner=THIS_MODULE; veda_cdev->ops= &char_device_file_ops; ret=cdev_add(veda_cdev,mydev,1); if( ret < 0 ) { printk("Error registering device driver\n"); return ret; } printk("Device Registered with MAJOR NO[%d]\n",char_device_id); for(i=0; i<MAX_LENGTH; i++) char_device_buf[i] = 0; char_device_buf[MAX_LENGTH] = '\0'; return 0; }
static int cpuid_class_simple_device_add(int i) { int err = 0; struct class_device *class_err; class_err = class_simple_device_add(cpuid_class, MKDEV(CPUID_MAJOR, i), NULL, "cpu%d",i); if (IS_ERR(class_err)) err = PTR_ERR(class_err); return err; }
int __init gbshm_init(void) { int err = 0; /* cut-and-paste above as part of adding support for more than 2 blocks */ gbshm_major = register_chrdev(0, "vidctl", &gbshm_fxns); if (gbshm_major < 0) { __E("Failed to allocate major number.\n"); return -ENODEV; } __D("Allocated major number: %d\n", gbshm_major); #if (USE_UDEV==1) #ifdef USE_CLASS_SIMPLE gbshm_class = class_simple_create(THIS_MODULE, "gbshm"); #else gbshm_class = class_create(THIS_MODULE, "gbshm"); #endif if (IS_ERR(gbshm_class)) { __E("Error creating cmem device class.\n"); err = -EIO; return err; } #ifdef USE_CLASS_SIMPLE class_simple_device_add(gbshm_class, MKDEV(gbshm_major, 0), NULL, "gbshm"); #else #ifdef USE_CLASS_DEVICE class_device_create(gbshm_class, NULL, MKDEV(gbshm_major, 0), NULL, "gbshm"); #else #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) device_create(gbshm_class, NULL, MKDEV(gbshm_major, 0), NULL, "gbshm"); #else device_create(gbshm_class, NULL, MKDEV(gbshm_major, 0), "gbshm"); #endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) #endif // USE_CLASS_DEVICE #endif // USE_CLASS_SIMPLE #endif // USE_UDEV /* Create the /proc entry */ printk(KERN_INFO "vidctl initialized\n"); //set_reg(); //printk_reg(); //tvp5150_set_input_mux(0); return 0; }
int init_char_device(void) { int i,ret; char_device_file_ops.owner = THIS_MODULE; char_device_file_ops.read = char_device_read; char_device_file_ops.write = char_device_write; char_device_file_ops.open = char_device_open; char_device_file_ops.release = char_device_release; char_device_file_ops.llseek = char_device_lseek; ret=alloc_chrdev_region(&mydev,0,1,CHAR_DEVICE_NAME);/* allocating major number and no. of minor numbers (in mydev) to my char driver name sc CHAR_DEVICE_NAME */ char_device_id= MAJOR(mydev);//extract major no /* Let's Start Udev stuff */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) veda_class = class_simple_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } class_simple_device_add(veda_class,mydev,NULL,"veda_cdrv"); #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14) veda_class=class_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } device_create(veda_class,NULL,mydev,"veda_cdrv");/*This function args are changed after 2.6.18 kernel (ref:drivers/base/class.c" 914L)*/ #endif /*Register our character Device*/ veda_cdev= cdev_alloc(); veda_cdev->owner=THIS_MODULE; veda_cdev->ops= &char_device_file_ops; ret=cdev_add(veda_cdev,mydev,1); if( ret < 0 ) { printk("Error registering device driver\n"); return ret; } printk("Device Registered with MAJOR NO[%d]\n",char_device_id); for(i=0; i<MAX_LENGTH; i++) char_device_buf[i] = 0; char_device_buf[MAX_LENGTH] = '\0'; return 0; }
static void adbdev_init(void) { if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) { printk(KERN_ERR "adb: unable to get major %d\n", ADB_MAJOR); return; } devfs_mk_cdev(MKDEV(ADB_MAJOR, 0), S_IFCHR | S_IRUSR | S_IWUSR, "adb"); adb_dev_class = class_simple_create(THIS_MODULE, "adb"); if (IS_ERR(adb_dev_class)) { return; } class_simple_device_add(adb_dev_class, MKDEV(ADB_MAJOR, 0), NULL, "adb"); }
static int __init chr_dev_init(void) { int i; if (register_chrdev(MEM_MAJOR,"mem",&memory_fops)) printk("unable to get major %d for memory devs\n", MEM_MAJOR); mem_class = class_simple_create(THIS_MODULE, "mem"); for (i = 0; i < ARRAY_SIZE(devlist); i++) { class_simple_device_add(mem_class, MKDEV(MEM_MAJOR, devlist[i].minor), NULL, devlist[i].name); devfs_mk_cdev(MKDEV(MEM_MAJOR, devlist[i].minor), S_IFCHR | devlist[i].mode, devlist[i].name); } return 0; }
static int __init mod_init(void) { int i; banner(); major = register_chrdev(0, "edma", &fops); __D("edma registered major = %d\n", major); #ifdef USE_CLASS_SIMPLE dma_class = class_simple_create(THIS_MODULE, "edma"); class_simple_device_add(dma_class, MKDEV(major, 0), NULL, "edma"); #else #ifdef USE_CLASS_DEVICE dma_class = class_create(THIS_MODULE, "edma"); class_device_create(dma_class, NULL, MKDEV(major, 0), NULL, "edma"); #else dma_class = class_create(THIS_MODULE, "edma"); #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) device_create(dma_class, NULL, MKDEV(major, 0), NULL, "edma"); #else device_create(dma_class, NULL, MKDEV(major, 0), "edma"); #endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) #endif // USE_CLASS_DEVICE #endif // USE_CLASS_SIMPLE __D("initializing channel owner array...\n"); for (i = 0; i < NCHAN; i++) { INIT_LIST_HEAD(&channels[i].users); channels[i].nParam = 0; channels[i].isParam = 0; } mutex_init(&edma_mutex); return 0; }
static int __init dsp56k_init_driver(void) { int err = 0; if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) { printk("DSP56k driver: Hardware not present\n"); return -ENODEV; } if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) { printk("DSP56k driver: Unable to register driver\n"); return -ENODEV; } dsp56k_class = class_simple_create(THIS_MODULE, "dsp56k"); if (IS_ERR(dsp56k_class)) { err = PTR_ERR(dsp56k_class); goto out_chrdev; } class_simple_device_add(dsp56k_class, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k"); err = devfs_mk_cdev(MKDEV(DSP56K_MAJOR, 0), S_IFCHR | S_IRUSR | S_IWUSR, "dsp56k"); if(err) goto out_class; printk(banner); goto out; out_class: class_simple_device_remove(MKDEV(DSP56K_MAJOR, 0)); class_simple_destroy(dsp56k_class); out_chrdev: unregister_chrdev(DSP56K_MAJOR, "dsp56k"); out: return err; }
/* * scdrv_init * * Called at boot time to initialize the system controller communication * facility. */ int __init scdrv_init(void) { geoid_t geoid; cmoduleid_t cmod; int i; char devname[32]; char *devnamep; module_t *m; struct sysctl_data_s *scd; void *salbuf; struct class_simple *snsc_class; dev_t first_dev, dev; if (alloc_chrdev_region(&first_dev, 0, (MAX_SLABS*nummodules), SYSCTL_BASENAME) < 0) { printk("%s: failed to register SN system controller device\n", __FUNCTION__); return -ENODEV; } snsc_class = class_simple_create(THIS_MODULE, SYSCTL_BASENAME); for (cmod = 0; cmod < nummodules; cmod++) { m = sn_modules[cmod]; for (i = 0; i <= MAX_SLABS; i++) { if (m->nodes[i] == -1) { /* node is not alive in module */ continue; } geoid = m->geoid[i]; devnamep = devname; format_module_id(devnamep, geo_module(geoid), MODULE_FORMAT_BRIEF); devnamep = devname + strlen(devname); sprintf(devnamep, "#%d", geo_slab(geoid)); /* allocate sysctl device data */ scd = kmalloc(sizeof (struct sysctl_data_s), GFP_KERNEL); if (!scd) { printk("%s: failed to allocate device info" "for %s/%s\n", __FUNCTION__, SYSCTL_BASENAME, devname); continue; } memset(scd, 0, sizeof (struct sysctl_data_s)); /* initialize sysctl device data fields */ scd->scd_nasid = cnodeid_to_nasid(m->nodes[i]); if (!(salbuf = kmalloc(SCDRV_BUFSZ, GFP_KERNEL))) { printk("%s: failed to allocate driver buffer" "(%s%s)\n", __FUNCTION__, SYSCTL_BASENAME, devname); kfree(scd); continue; } if (ia64_sn_irtr_init(scd->scd_nasid, salbuf, SCDRV_BUFSZ) < 0) { printk ("%s: failed to initialize SAL for" " system controller communication" " (%s/%s): outdated PROM?\n", __FUNCTION__, SYSCTL_BASENAME, devname); kfree(scd); kfree(salbuf); continue; } dev = first_dev + m->nodes[i]; cdev_init(&scd->scd_cdev, &scdrv_fops); if (cdev_add(&scd->scd_cdev, dev, 1)) { printk("%s: failed to register system" " controller device (%s%s)\n", __FUNCTION__, SYSCTL_BASENAME, devname); kfree(scd); kfree(salbuf); continue; } class_simple_device_add(snsc_class, dev, NULL, "%s", devname); ia64_sn_irtr_intr_enable(scd->scd_nasid, 0 /*ignored */ , SAL_IROUTER_INTR_RECV); } } return 0; }
int ndas_ctrldev_init(void) { int ret = 0; #ifdef NDAS_DEVFS // Create control device file devfs_control_handle = devfs_register(NULL, "ndas", DEVFS_FL_DEFAULT, NDAS_CHR_DEV_MAJOR, 0, S_IFCHR | S_IRUGO | S_IWUGO, &ndasctrl_fops, NULL); if (!devfs_control_handle) { printk(KERN_ERR "Failed to register control device file\n"); return -EBUSY; } #else ret = register_chrdev(NDAS_CHR_DEV_MAJOR, "ndas", &ndasctrl_fops); if (ret < 0) { printk(KERN_ERR "ndas: can't register char device\n"); return ret; } #endif #if LINUX_VERSION_25_ABOVE #if LINUX_VERSION_HAS_CLASS_CREATE ndas_ctrldev_class = class_create(THIS_MODULE, "ndas"); if (IS_ERR(ndas_ctrldev_class)) { #ifdef NDAS_DEVFS devfs_unregister(devfs_control_handle); #else unregister_chrdev(NDAS_CHR_DEV_MAJOR, "ndas"); #endif return PTR_ERR(ndas_ctrldev_class); } #if LINUX_VERSION_HAS_DEVICE_CREATE #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28) ) device_create( #else device_create_drvdata( #endif // Linux 2.6.28 (device_create_drvdata deprecated, now removed) ndas_ctrldev_class, NULL, MKDEV(NDAS_CHR_DEV_MAJOR, NDAS_CHR_DEV_MINOR), NULL, "ndas"); #else class_device_create(ndas_ctrldev_class, NULL, MKDEV(NDAS_CHR_DEV_MAJOR, NDAS_CHR_DEV_MINOR), NULL, "ndas"); #endif //#if LINUX_VERSION_HAS_DEVICE_CREATE #else ndas_ctrldev_class = class_simple_create(THIS_MODULE, "ndas"); if (IS_ERR(ndas_ctrldev_class)) { #ifdef NDAS_DEVFS devfs_unregister(devfs_control_handle); #else unregister_chrdev(NDAS_CHR_DEV_MAJOR, "ndas"); #endif return PTR_ERR(ndas_ctrldev_class); } class_simple_device_add(ndas_ctrldev_class, MKDEV(NDAS_CHR_DEV_MAJOR, NDAS_CHR_DEV_MINOR), NULL, "ndas"); #endif /* LINUX_VERSION_HAS_CLASS_CREATE */ #endif /* LINUX_VERSION_25_ABOVE */ return ret; }
/** * usb_register_dev - register a USB device, and ask for a minor number * @intf: pointer to the usb_interface that is being registered * @class_driver: pointer to the usb_class_driver for this device * * This should be called by all USB drivers that use the USB major number. * If CONFIG_USB_DYNAMIC_MINORS is enabled, the minor number will be * dynamically allocated out of the list of available ones. If it is not * enabled, the minor number will be based on the next available free minor, * starting at the class_driver->minor_base. * * This function also creates the devfs file for the usb device, if devfs * is enabled, and creates a usb class device in the sysfs tree. * * usb_deregister_dev() must be called when the driver is done with * the minor numbers given out by this function. * * Returns -EINVAL if something bad happens with trying to register a * device, and 0 on success. */ int usb_register_dev(struct usb_interface *intf, struct usb_class_driver *class_driver) { int retval = -EINVAL; int minor_base = class_driver->minor_base; int minor = 0; char name[BUS_ID_SIZE]; char *temp; #ifdef CONFIG_USB_DYNAMIC_MINORS /* * We don't care what the device tries to start at, we want to start * at zero to pack the devices into the smallest available space with * no holes in the minor range. */ minor_base = 0; #endif intf->minor = -1; dbg ("looking for a minor, starting at %d", minor_base); if (class_driver->fops == NULL) goto exit; spin_lock (&minor_lock); for (minor = minor_base; minor < MAX_USB_MINORS; ++minor) { if (usb_minors[minor]) continue; usb_minors[minor] = class_driver->fops; retval = 0; break; } spin_unlock (&minor_lock); if (retval) goto exit; intf->minor = minor; /* handle the devfs registration */ snprintf(name, BUS_ID_SIZE, class_driver->name, minor - minor_base); devfs_mk_cdev(MKDEV(USB_MAJOR, minor), class_driver->mode, name); /* create a usb class device for this usb interface */ temp = strrchr(name, '/'); if (temp && (temp[1] != 0x00)) ++temp; else temp = name; intf->class_dev = class_simple_device_add(usb_class, MKDEV(USB_MAJOR, minor), &intf->dev, "%s", temp); if (IS_ERR(intf->class_dev)) { spin_lock (&minor_lock); usb_minors[intf->minor] = NULL; spin_unlock (&minor_lock); devfs_remove (name); retval = PTR_ERR(intf->class_dev); } exit: return retval; }
/* * scdrv_init * * Called at boot time to initialize the system controller communication * facility. */ int __init scdrv_init(void) { geoid_t geoid; cnodeid_t cnode; char devname[32]; char *devnamep; struct sysctl_data_s *scd; void *salbuf; struct class_simple *snsc_class; dev_t first_dev, dev; nasid_t event_nasid = ia64_sn_get_console_nasid(); if (alloc_chrdev_region(&first_dev, 0, numionodes, SYSCTL_BASENAME) < 0) { printk("%s: failed to register SN system controller device\n", __FUNCTION__); return -ENODEV; } snsc_class = class_simple_create(THIS_MODULE, SYSCTL_BASENAME); for (cnode = 0; cnode < numionodes; cnode++) { geoid = cnodeid_get_geoid(cnode); devnamep = devname; format_module_id(devnamep, geo_module(geoid), MODULE_FORMAT_BRIEF); devnamep = devname + strlen(devname); sprintf(devnamep, "#%d", geo_slab(geoid)); /* allocate sysctl device data */ scd = kmalloc(sizeof (struct sysctl_data_s), GFP_KERNEL); if (!scd) { printk("%s: failed to allocate device info" "for %s/%s\n", __FUNCTION__, SYSCTL_BASENAME, devname); continue; } memset(scd, 0, sizeof (struct sysctl_data_s)); /* initialize sysctl device data fields */ scd->scd_nasid = cnodeid_to_nasid(cnode); if (!(salbuf = kmalloc(SCDRV_BUFSZ, GFP_KERNEL))) { printk("%s: failed to allocate driver buffer" "(%s%s)\n", __FUNCTION__, SYSCTL_BASENAME, devname); kfree(scd); continue; } if (ia64_sn_irtr_init(scd->scd_nasid, salbuf, SCDRV_BUFSZ) < 0) { printk ("%s: failed to initialize SAL for" " system controller communication" " (%s/%s): outdated PROM?\n", __FUNCTION__, SYSCTL_BASENAME, devname); kfree(scd); kfree(salbuf); continue; } dev = first_dev + cnode; cdev_init(&scd->scd_cdev, &scdrv_fops); if (cdev_add(&scd->scd_cdev, dev, 1)) { printk("%s: failed to register system" " controller device (%s%s)\n", __FUNCTION__, SYSCTL_BASENAME, devname); kfree(scd); kfree(salbuf); continue; } class_simple_device_add(snsc_class, dev, NULL, "%s", devname); ia64_sn_irtr_intr_enable(scd->scd_nasid, 0 /*ignored */ , SAL_IROUTER_INTR_RECV); /* on the console nasid, prepare to receive * system controller environmental events */ if(scd->scd_nasid == event_nasid) { scdrv_event_init(scd); } } return 0; }
static int dvblo_chardev_init(struct dvblo_chardev *chardev, struct dvblo_chardev_config *cfg) { int rv = SUCCESS, i; if(chardev->used != 0) { rv = -EINVAL; } else { chardev->used = 1; chardev->initlev = 0; chardev->initdone = 0; do { dprintk(DBGLEV_ALL, "initializing char device with minor device number %u\n", chardev->minor); i = snprintf(chardev->name, sizeof(chardev->name), DVBLO_NAME "%d", chardev->minor); if(i < 0 || i >= sizeof(chardev->name)) { if(i < 0) rv = i; else rv = -ENOBUFS; break; } chardev->hcount = 0; chardev->cfg.ts_sz = DVBLO_TS_SZ; chardev->cfg.hwrbuf_sz = 20 * chardev->cfg.ts_sz; i = dvblo_adap_create(chardev->minor, cfg ? &cfg->dvbcfg : NULL, &chardev->dvblo); if(i < 0) { mprintk(KERN_ALERT, "failed to create virtual DVB adapter: %d\n", i); rv = i; break; } chardev->initlev++; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) /* In 2.6.15, class_device_create() got a pointer to the parent device (if any) as its second param */ chardev->clsdev = class_device_create(dvblo_class, NULL, MKDEV(dvblo_char_major, chardev->minor), NULL, chardev->name); #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13) /* class_device_create() first appeared in 2.6.13 */ chardev->clsdev = class_device_create(dvblo_class, MKDEV(dvblo_char_major, chardev->minor), NULL, chardev->name); #else /* The old-style "simple" class API */ chardev->clsdev = class_simple_device_add(dvblo_class, MKDEV(dvblo_char_major, chardev->minor), NULL, chardev->name); #endif if(IS_ERR(chardev->clsdev)) { rv = PTR_ERR(chardev->clsdev); mprintk(KERN_ALERT, "failed to create device class \"%s\": %d\n", chardev->name, rv); break; } chardev->initlev++; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13) for(i=0; i<(sizeof(clsdev_attrs)/sizeof(clsdev_attrs[0])) && rv == SUCCESS; i++) rv = class_device_create_file(chardev->clsdev, &clsdev_attrs[i]); if(rv != SUCCESS) break; #endif chardev->initlev++; mprintk(KERN_INFO, "added character device %s\n", chardev->name); } while(0); if(rv != 0) dvblo_chardev_release(chardev); // error cleanup } return rv; }
static int init_char_device(void) { unsigned int i,ret; char_device_buf_minor0 = (char *)kmalloc(MAX_LENGTH*sizeof(char), GFP_KERNEL); char_device_buf_minor1 = (char *)kmalloc(MAX_LENGTH*sizeof(char), GFP_KERNEL); char_device_buf_minor2 = (char *)kmalloc(MAX_LENGTH*sizeof(char), GFP_KERNEL); if( !char_device_buf_minor0 ) return -ENOSPC; if( !char_device_buf_minor1 ) return -ENOSPC; if( !char_device_buf_minor2 ) return -ENOSPC; char_device_file_ops.owner = THIS_MODULE, char_device_file_ops.read = char_device_read; char_device_file_ops.read = char_device_read; char_device_file_ops.write = char_device_write; char_device_file_ops.open = char_device_open; char_device_file_ops.release = char_device_release; ret=alloc_chrdev_region(&mydev,0,3,"veda_cdrv"); char_device_id= MAJOR(mydev);//extract major no /* Let's Start Udev stuff */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) veda_class = class_simple_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } for(i=0;i<3;i++) class_simple_device_add(veda_class,MKDEV(char_device_id,i),NULL,"veda_cdrv",i); #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14) veda_class = class_create(THIS_MODULE,"Veda"); if(IS_ERR(veda_class)){ printk(KERN_ERR "Error registering veda class\n"); } for(i=0;i<3;i++) device_create(veda_class,NULL,MKDEV(char_device_id,i),"veda_cdrv"); #endif /*Register our character Device*/ veda_cdev= cdev_alloc(); veda_cdev->owner=THIS_MODULE; veda_cdev->ops= &char_device_file_ops; for(i=0;i<3;i++) ret=cdev_add(veda_cdev,MKDEV(char_device_id,i),3); if( ret < 0 ) { printk("Error registering device driver\n"); return ret; } printk("Device Registered with MAJOR NO[%d]\n",char_device_id); for(i=0; i<MAX_LENGTH; i++) char_device_buf_minor0[i] = 0; for(i=0; i<MAX_LENGTH; i++) char_device_buf_minor1[i] = 0; for(i=0; i<MAX_LENGTH; i++) char_device_buf_minor2[i] = 0; init_waitqueue_head( &veda_queue0 ); init_waitqueue_head( &veda_queue1 ); init_waitqueue_head( &veda_queue2 ); mutex_init(&vmut0); mutex_init(&vmut1); mutex_init(&vmut2); return 0; }