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;
}
