int scull_init_module(void) { int result,i; dev_t dev = 0; /* * Get a range of minor numbers to work with, asking for a dynamic * major unless directed otherwise at load time. */ if (scull_major) { dev = MKDEV(scull_major, scull_minor); result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } /* * allocate the devices -- we can't have them static, as the number * can be specified at load time */ scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; goto fail; /* Make this more graceful */ } memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); /* Initialize each device. */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; //init_MUTEX(&scull_devices[i].sem); //mutex_init(&scull_devices[i].sem); sema_init(&scull_devices[i].sem,1); scull_setup_cdev(&scull_devices[i], i); } /* At this point call the init function for any friend device */ //dev = MKDEV(scull_major, scull_minor + scull_nr_devs); //dev += scull_p_init(dev); //dev += scull_access_init(dev); #ifdef SCULL_DEBUG /* only when debugging */ scull_create_proc(); printk(KERN_ALERT "Debugging is working"); #endif printk(KERN_ALERT "Scull device registered.. \n"); return 0; /* succeed */ fail: scull_cleanup_module(); return result; }
int scull_init_module(void) { int result, i; dev_t dev = 0; /* * Get a range of minor numbers to work with, asking for a dynamic * major unless directed otherwise at load time. */ if (scull_major) { dev = MKDEV(scull_major, scull_minor); result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } /* * allocate the devices -- we can't have them static, as the number * can be specified at load time */ scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; goto fail; /* Make this more graceful */ } memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); /* Initialize each device. */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; //init_MUTEX(&scull_devices[i].sem); //changed to below based on this: http://www.linuxquestions.org/questions/blog/frandalla-68463/patching-802-11-linux-sta-driver-for-kernel-2-6-37-3558/ sema_init(&scull_devices[i].sem,1); scull_setup_cdev(&scull_devices[i], i); } /* At this point call the init function for any friend device */ dev = MKDEV(scull_major, scull_minor + scull_nr_devs); dev += scull_p_init(dev); dev += scull_access_init(dev); #ifdef SCULL_DEBUG /* only when debugging */ scull_create_proc(); #endif return 0; /* succeed */ fail: scull_cleanup_module(); return result; }
int scull_init_module(void) { int result, i; dev_t dev = 0; struct proc_dir_entry *entry; /* * Get a range of minor numbers to work with, asking for a dynamic * major unless directed otherwise at load time. */ if (scull_major) { dev = MKDEV(scull_major, scull_minor); result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); } if (result < 0) { PDEBUG("scull: can't get major %d\n", scull_major); return result; } /* * allocate the devices -- we can't have them static, as the number * can be specified at load time */ scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; goto fail; /* Make this more graceful */ } memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); /* Initialize each device. */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; init_MUTEX(&scull_devices[i].sem); scull_setup_cdev(&scull_devices[i], i); /* ignore error */ } /* register proc entry */ create_proc_read_entry("scullmem", 0 /* default mode */, NULL /* parent dir */, scull_read_procmem, NULL /* client data */); /* register seq_file interfaced proc entry */ entry = create_proc_entry("scullseq", 0, NULL); if (entry) entry->proc_fops = &scull_proc_ops; return 0; /* succeed */ fail: scull_cleanup_module(); return result; }
int scull_init_module(void) { int result, i; dev_t dev = 0; /* * Get a range of minor numbers to work with, asking for a dynamic major * unless directed otherwise at load time. */ if (scull_major) { dev = MKDEV(scull_major, scull_minor); result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } /* * Allocate the devices. This must be dynamic as the device number can * be specified at load time. */ scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; goto fail; } memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); /* Initialize each device. */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; mutex_init(&scull_devices[i].mutex); scull_setup_cdev(&scull_devices[i], i); } /* Call the init function for any friend device. */ dev = MKDEV(scull_major, scull_minor + scull_nr_devs); dev += scull_p_init(dev); dev += scull_access_init(dev); #ifdef SCULL_DEBUG /* only when debugging */ scull_create_proc(); #endif return 0; /* succeed */ fail: scull_cleanup_module(); return result; }
static int scull_init_module(void) { int res = 0; dev_t dev; int i; #ifdef __DEBUG_INFO printk(KERN_ALERT "In init!!!\n"); #endif if(scull_major){ dev = MKDEV(scull_major, scull_minor); res = register_chrdev_region(dev, scull_num, "gzhSCULL"); }else{ res = alloc_chrdev_region(&dev, scull_minor, scull_num, "gzhSCULL"); scull_major = MAJOR(dev); } if(res != 0 ){ printk(KERN_ALERT "In scull_init_module(), register dev error"); return res; } printk(KERN_ALERT "tht major is %d\n", scull_major); scull_devices = kmalloc(scull_num * sizeof(struct scull_dev), GFP_KERNEL); if(scull_devices == NULL){ printk(KERN_ALERT "scull_devices malloc error\n"); goto fail; } memset(scull_devices, 0, scull_num * sizeof(struct scull_dev)); for(i = 0; i < scull_num; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; sema_init(&scull_devices[i].sem, 1); init_completion(&scull_devices[i].comp); scull_setup_cdev(&(scull_devices[i]), i); } return 0; fail: { printk(KERN_ALERT "In Failed\n"); scull_cleanup_module(); } return 0; }
int scull_init_module(void) { int result, i; dev_t dev = 0; if (scull_major) { dev = MKDEV(scull_major, scull_minor); result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); //alloc_chrdev_region 第二个参数?? scull_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; //??-ENOMEM goto fail; } memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; //scull_qset?? init_MUTEX(&scull_devices[i].sem); //??init_MUTEX 加锁 scull_setup_cdev(&scull_devices[i], i); } // dev = MKDEV(scull_major, scull_minor + scull_nr_devs); // dev += scull_p_init(dev);// // dev += scull_access_init(dev); //#ifdef SCULL_DEBUG scull_create_proc(); //#endif return 0; fail: scull_cleanup_module(); return result; }
int scull_init_module(void) { int result, i; dev_t dev = 0; printk(KERN_WARNING "scull: yaomoon debug\n"); printk(KERN_NOTICE "scull: yaomoon debug\n"); /* * Get a range of minor numbers to work with, asking for a dynamic * major unless directed otherwise at load time. */ if (scull_major) { dev = MKDEV(scull_major, scull_minor); result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } /* * allocate the devices -- we can't have them static, as the number * can be specified at load time */ scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; goto fail; /* Make this more graceful */ } memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); /* Initialize each device. */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; init_MUTEX(&scull_devices[i].sem); scull_setup_cdev(&scull_devices[i], i); } return 0; /* succeed */ fail: scull_cleanup_module(); return result; }
static int __init scull_init_module(void) { int result = -1; dev_t dev = 0; int i = 0; /* 动态分配主设备号 */ result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devices, "scull"); scull_major = MAJOR(dev); // 获得 dev_t 的主设备号 if (0 > result) // 主设备号分配失败 { printk(KERN_ALERT "scull cannot get major %d\n", scull_major); return result; } /* 为设备分配内存空间并初始化 */ scull_devices = kmalloc(scull_nr_devices * sizeof(struct scull_dev), GFP_KERNEL); if (NULL == scull_devices) { printk(KERN_ALERT "kmalloc(%d * %ld) failed\n", scull_nr_devices, sizeof(struct scull_dev)); result = -ENOMEM; goto fail; } memset(scull_devices, 0, scull_nr_devices * sizeof(struct scull_dev)); /* 依次初始化每个设备 */ for (i = 0; i < scull_nr_devices; i++) { printk(KERN_INFO "Init module: scull%d-%d\n", scull_major, i); scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; scull_setup_cdev(&scull_devices[i], i); } return 0; fail: scull_exit_module(); return result; }
static int __init scull_init_module(void) { int result; dev_t dev = 0; if (scull_major) { dev = MKDEV(scull_major, scull_minor); result = register_chrdev_region(dev, 1, "scull"); } else { result = alloc_chrdev_region(&dev, scull_minor, 1, "scull"); scull_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } scull_device = kmalloc(sizeof(struct scull_dev), GFP_KERNEL); if (!scull_device) { result = -ENOMEM; goto fail; } memset(scull_device, 0, sizeof(struct scull_dev)); //init_MUTEX(&scull_device->sem); sema_init(&scull_device->sem, 1); scull_setup_cdev(scull_device); return 0; fail: scull_cleanup_module(); return result; }
static int initilization_function(void) { int recv; #ifdef DEFINE printk(KERN_INFO " begin : %s\n",__func__); #endif if(!majorno) { recv=alloc_chrdev_region(&dev,minorno,nod,DEV_NAME); if(recv<0) { #ifdef DEFINE printk(KERN_INFO"registration failed :\n"); #endif } majorno = MAJOR(dev); #ifdef DEFINE printk(KERN_INFO "device has registored with number %d\n",majorno); printk(KERN_INFO "registration completed\n"); #endif } else { minorno=minorno+1; dev_new=MKDEV( majorno , minorno); register_chrdev_region(dev,nod,DEV_NAME); printk(KERN_INFO "____________device has registored with number %d\n",dev_new); } printk(KERN_INFO "%p\n",sculldev); sculldev = kmalloc(sizeof(struct Sculldev)*nod,GFP_KERNEL); if(sculldev>0) { #ifdef DEFINE printk(KERN_INFO "kmalloc successfull\n"); #endif } memset(sculldev,'\0',sizeof(struct Sculldev)*nod); #ifdef DEFINE printk(KERN_INFO "%p\n",sculldev); #endif scull_setup_cdev(); init_scull(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ret = check_region(BASE,3); if(ret<0) { #ifdef DEFINE printk(KERN_INFO "region busy\n"); #endif release_region(BASE,3); } request_region(BASE,3,DEV_NAME); outb(16,BASE+2); ret_intrrupt=request_irq(7,handler_irq,IRQF_SHARED,"Parrallelport","freeargument"); if(ret_intrrupt==0) { #ifdef DEFINE printk(KERN_INFO "irq_request is successful\n"); #endif } else #ifdef DEFINE printk(KERN_INFO "irq_request is failed\n"); #endif //outb(0,BASE+2); //outb(0,BASE); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #ifdef DEFINE printk(KERN_INFO " end : %s\n",__func__); #endif return 0; }
int scull_init_module(void) { int result, i; dev_t dev = 0; /* * Get a range of minor numbers to work with, asking for a dynamic * major unless directed otherwise at load time. * 根据scull_major的值是否为0,分别采用静态分配或动态分配 * scull_major为主设备编号,在scull中初始定义为 #define SCULL_MAJOR 0,如果用户通过命令行参数给major赋 >0 的值,则采取静态分配 * scull_minor为从设备编号 */ printk(KERN_ALERT "Debug by andrea:scull_init_module()/n"); if (scull_major) { dev = MKDEV(scull_major, scull_minor); /* * 静态分配设备编号 */ result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { /* * 动态分配设备编号 */ result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); } /*分配设备编号出错*/ if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } /* * allocate the devices -- we can't have them static, as the number * can be specified at load time */ /* * 为每一个设备分配内存空间 * scull_nr_devs 默认为4 ,即默认创建4个scull设备, 在scull.h 定义 define SCULL_NR_DEVS 4 */ scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; goto fail; /* Make this more graceful */ } /* * 将scull_devices分配的内存清零 */ memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); /* Initialize each device. */ /* * 初始化 scull_nr_dev个 scull_dev结构体, 即scull_nr_dev个scull_dev设备 * scull_devices[i].qset代表当前scull设备中每一个qset的data域指向的数组有SCULL_QSET(默认1000)个指针 * scull_devices[i].quantum代表当前scull设备中每一个qset中上面的数组指向的量子有SCULL_QUANTUM(默认4000)个字节 */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; /* init_MUTEX(&scull_devices[i].sem);*/ sema_init(&scull_devices[i].sem,1); /* * 调用了scull_setup_cdev函数对相应scull设备进行设置 */ scull_setup_cdev(&scull_devices[i], i); } /* At this point call the init function for any friend device */ dev = MKDEV(scull_major, scull_minor + scull_nr_devs); dev += scull_p_init(dev); dev += scull_access_init(dev); #ifdef SCULL_DEBUG /* only when debugging */ scull_create_proc(); #endif return 0; /* succeed */ fail: scull_cleanup_module(); return result; }
/*[Tag000] * 当模块加载时,调用;但是为什么要放在最后来实现他呢,看到Tag002时,你应该就明白了; */ int scull_init_module(void) { int result, i; dev_t dev = 0; /* [Tag001] */ /* [1]分配设备编号 */ /* * Get a range of minor numbers to work with, asking for a dynamic * major unless directed otherwise at load time. */ if (scull_major) { /* 预先自己指定了主设备号 */ dev = MKDEV(scull_major, scull_minor); /* 利用主设备号,找到设备编号给方法1用 */ result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { /* 动态自己生成设备编号,然后再利用设备编号得到主设备号; 记住如果用这个方法那么就要后建设备文件了,因为不能提前知道主号 当然也可以利用ldd3书中提供的脚本,巨方便&&通用 */ result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); } if (result < 0) { printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return result; } /*[2]设备对象实例化*/ /* * allocate the devices -- we can't have them static, as the number * can be specified at load time */ scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_devices) { result = -ENOMEM; goto fail; /* Make this more graceful */ } memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev)); /* [3]在这里初始化设备用了2.6的新方法,在scull_setup_cdev里完成 */ /* Initialize each device. */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; /* 可以根据自己insmod时传参 来自己改变量子和量子集(指针数组)的大小 */ scull_devices[i].qset = scull_qset; init_MUTEX(&scull_devices[i].sem); scull_setup_cdev(&scull_devices[i], i); /* 在分别完主设备编号后goto Tag002 设备注册 */ } /* At this point call the init function for any friend device */ dev = MKDEV(scull_major, scull_minor + scull_nr_devs); dev += scull_p_init(dev); dev += scull_access_init(dev); #ifdef SCULL_DEBUG /* only when debugging */ scull_create_proc(); #endif return 0; /* succeed */ fail: scull_cleanup_module(); return result; }