求教加載模塊device_register出錯(cuò)

wonderwander

很奇怪前兩天加載模塊的時(shí)候沒(méi)問(wèn)題，今天將該模塊加載出現(xiàn) invalid parameters ；
確定是device_register 出錯(cuò)，設(shè)備沒(méi)注冊(cè)成功
代碼沒(méi)有改動(dòng)，內(nèi)核為2.6.38，一直想不明白
lddbus.c源碼
#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include "lddbus.h"

static char *Version = "Revision: 1.9-tekkamanninja";

/*總線->設(shè)備->設(shè)備驅(qū)動(dòng)*/

//****************************************************************************
********************8
/*
* Respond to hotplug events.
*/
/*static int ldd_uevent(struct device *dev, char **envp, int num_envp,
                char *buffer, int buffer_size)*/
static int ldd_uevent(struct device *dev, struct kobj_uevent_env *env)
{
        env->envp[0] =env->buf;
        if (snprintf(env->buf, env->buflen, "LDDBUS_VERSION=%s",
                            Version) >=env->buflen)
                return -ENOMEM;
        env->envp[1] = NULL;
        return 0;
}

/*
* Match LDD devices to drivers.  Just do a simple name test.
*/
static int ldd_match(struct device *dev, struct device_driver *driver)
{
//        return !strncmp(dev->bus_id, driver->name, strlen(driver->name));
        return !strncmp(dev->init_name, driver->name, strlen(driver->name));
}

/*
* And the bus type.
*/
struct bus_type ldd_bus_type = {
        .name = "ldd",
        .match = ldd_match,
        .uevent  = ldd_uevent,
};
//****************************************************************************
****************






/****************************************************************************
* The LDD bus device.
*****************************************************************************
/
static void ldd_bus_release(struct device *dev)
{
        printk( "The LDD bus device \n ldd_bus_release : lddbus release!\n");   //KER
N_DEBUG
}
       
struct device ldd_bus = {
        .init_name   = "ldd0",
        .release  = ldd_bus_release,
};

/*
* Export a simple attribute.
*/
static ssize_t show_bus_version(struct bus_type *bus, char *buf)
{
        return snprintf(buf, PAGE_SIZE, "%s\n", Version);
}

static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);





/*****************************************************************************
****
* LDD devices.
*****************************************************************************
*******/
/*
* For now, no references to LDDbus devices go out which are not
* tracked via the module reference count, so we use a no-op
* release function.
*/
static void ldd_dev_release(struct device *dev)
{ }

int register_ldd_device(struct ldd_device *ldddev)
{
        ldddev->dev.bus = &ldd_bus_type;
        ldddev->dev.parent = &ldd_bus;
        ldddev->dev.release = ldd_dev_release;
        strncpy(ldddev->dev.init_name, ldddev->name, strlen(ldddev->dev.init_name));
        return device_register(&ldddev->dev);
}
/*接口 EXPORT_SYMBOL() make the func or var can be called by other module, i.e
. mod1's func called by mod2*/
EXPORT_SYMBOL(register_ldd_device);

void unregister_ldd_device(struct ldd_device *ldddev)
{
        device_unregister(&ldddev->dev);
}
EXPORT_SYMBOL(unregister_ldd_device);



/*****************************************************************************
*
* Crude driver interface.
*****************************************************************************
*/
static ssize_t show_version(struct device_driver *driver, char *buf)
{
        struct ldd_driver *ldriver = to_ldd_driver(driver);

        sprintf(buf, "%s\n", ldriver->version);
        return strlen(buf);
}
               

int register_ldd_driver(struct ldd_driver *driver)
{
        int ret;
       
        driver->driver.bus = &ldd_bus_type;
        ret = driver_register(&driver->driver);
        if (ret)
                return ret;
        driver->version_attr.attr.name = "version";
        /*2.6.38把owner給刪了也沒(méi)有替補(bǔ)的變量*/
//        driver->version_attr.attr.owner = driver->module;
        driver->version_attr.attr.mode = S_IRUGO;
        driver->version_attr.show = show_version;
        driver->version_attr.store = NULL;
        return driver_create_file(&driver->driver, &driver->version_attr);
}

void unregister_ldd_driver(struct ldd_driver *driver)
{
        driver_unregister(&driver->driver);
}
EXPORT_SYMBOL(register_ldd_driver);
EXPORT_SYMBOL(unregister_ldd_driver);




//****************************************************************************
********************
static int __init ldd_bus_init(void)
{
        int ret;
        ret = bus_register(&ldd_bus_type);
        if (ret)
                return ret;
        if (bus_create_file(&ldd_bus_type, &bus_attr_version))
                printk(KERN_NOTICE "Unable to create version attribute ! \n");
        ret = device_register(&ldd_bus);
        if (ret)
        {        printk(KERN_NOTICE "Unable to register ldd0 ! \nret = %d\n", ret);
                 bus_unregister(&ldd_bus_type);
                return ret;
        }
        printk(KERN_NOTICE "Mount lddbus ok !\nBus device is ldd0 !\nYou can see me i
n sys/module/ , sys/devices/ and sys/bus/ ! \n");
       
        return ret;
}

static void ldd_bus_exit(void)
{
        device_unregister(&ldd_bus);
        bus_unregister(&ldd_bus_type);
}

module_init(ldd_bus_init);
module_exit(ldd_bus_exit);

*************************************************************
lddbus.h 源碼

//extern struct device ldd_bus;
extern struct bus_type ldd_bus_type;


/*
* The LDD driver type.
*/

struct ldd_driver {
        char *version;
        struct module *module;
        struct device_driver driver;
        struct driver_attribute version_attr;
};

#define to_ldd_driver(drv) container_of(drv, struct ldd_driver, driver);

/*
* A device type for things "plugged" into the LDD bus.
*/

struct ldd_device {
//        char *name;
        const char *name;
        struct ldd_driver *driver;
        struct device dev;
};

#define to_ldd_device(dev) container_of(dev, struct ldd_device, dev);

extern int register_ldd_device(struct ldd_device *);
extern void unregister_ldd_device(struct ldd_device *);
extern int register_ldd_driver(struct ldd_driver *);
extern void unregister_ldd_driver(struct ldd_driver *);