static int __init gen_init(void)
{
int result = -EBUSY;
result = __register_chrdev(gen_char_major, 0, MAX_DEVS,
"gen", &gen_char_fops);
if (result < 0 )
goto unregister_chrdev;
else if (result > 0)
gen_char_major = result;
gen_char_cl = class_create(THIS_MODULE, "gen");
if (!gen_char_cl)
goto destroy_class;
result = create_device();
return 0;
destroy_class:
class_destroy(gen_char_cl);
unregister_chrdev:
__unregister_chrdev(gen_char_major, 0, MAX_DEVS, "gen");
return result;
}
static int __init msr_init(void)
{
int err;
if (__register_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr", &msr_fops)) {
pr_err("unable to get major %d for msr\n", MSR_MAJOR);
return -EBUSY;
}
msr_class = class_create(THIS_MODULE, "msr");
if (IS_ERR(msr_class)) {
err = PTR_ERR(msr_class);
goto out_chrdev;
}
msr_class->devnode = msr_devnode;
err = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "x86/msr:online",
msr_device_create, msr_device_destroy);
if (err < 0)
goto out_class;
cpuhp_msr_state = err;
return 0;
out_class:
class_destroy(msr_class);
out_chrdev:
__unregister_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr");
return err;
}
static void __exit msr_exit(void)
{
int cpu = 0;
for_each_online_cpu(cpu)
msr_device_destroy(cpu);
class_destroy(msr_class);
__unregister_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr");
unregister_hotcpu_notifier(&msr_class_cpu_notifier);
}
static void __exit gen_exit(void)
{
kthread_stop(wq_thread);
device_destroy(gen_char_cl, MKDEV(gen_char_major, 0));
class_destroy(gen_char_cl);
__unregister_chrdev(gen_char_major, 0, MAX_DEVS, "gen");
kfree(g_gen);
printk("gen-kd: bye!!\n");
}
static void __exit cpuid_exit(void)
{
int cpu = 0;
for_each_online_cpu(cpu)
cpuid_device_destroy(cpu);
class_destroy(cpuid_class);
__unregister_chrdev(CPUID_MAJOR, 0, NR_CPUS, "cpu/cpuid");
unregister_hotcpu_notifier(&cpuid_class_cpu_notifier);
}
static int __init msr_init(void)
{
int i = 0;
int err = 0;
err = msrbatch_init();
if (err != 0) {
pr_err("failed to initialize msrbatch\n");
goto out;
}
err = msr_whitelist_init();
if (err != 0) {
pr_err("failed to initialize whitelist for msr\n");
goto out_batch;
}
if (__register_chrdev(MSR_MAJOR, 0, num_possible_cpus(),
"cpu/msr", &msr_fops)) {
pr_err("unable to get major %d for msr\n", MSR_MAJOR);
err = -EBUSY;
goto out_wlist;
}
msr_class = class_create(THIS_MODULE, "msr");
if (IS_ERR(msr_class)) {
err = PTR_ERR(msr_class);
goto out_chrdev;
}
msr_class->devnode = msr_devnode;
cpu_notifier_register_begin();
for_each_online_cpu(i) {
err = msr_device_create(i);
if (err != 0)
goto out_class;
}
__register_hotcpu_notifier(&msr_class_cpu_notifier);
cpu_notifier_register_done();
err = 0;
goto out;
out_class:
i = 0;
for_each_online_cpu(i)
msr_device_destroy(i);
cpu_notifier_register_done();
class_destroy(msr_class);
out_chrdev:
__unregister_chrdev(MSR_MAJOR, 0, num_possible_cpus(), "cpu/msr");
out_wlist:
msr_whitelist_cleanup();
out_batch:
msrbatch_cleanup();
out:
return err;
}
static void __exit msr_exit(void)
{
int cpu = 0;
cpu_notifier_register_begin();
for_each_online_cpu(cpu)
msr_device_destroy(cpu);
class_destroy(msr_class);
__unregister_chrdev(MSR_MAJOR, 0, num_possible_cpus(), "cpu/msr");
__unregister_hotcpu_notifier(&msr_class_cpu_notifier);
cpu_notifier_register_done();
msr_whitelist_cleanup();
msrbatch_cleanup();
}
static void sound_remove_unit(struct sound_unit **list, int unit)
{
struct sound_unit *p;
spin_lock(&sound_loader_lock);
p = __sound_remove_unit(list, unit);
spin_unlock(&sound_loader_lock);
if (p) {
if (!preclaim_oss)
__unregister_chrdev(SOUND_MAJOR, p->unit_minor, 1,
p->name);
device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor));
kfree(p);
}
}
static void marsdev_cleanup(void)
{
int i;
int dev_sz = ARRAY_SIZE(mars_devices);
printk(KERN_INFO MARSDEV1_PREF" cleanup\n");
for (i = 0; i < dev_sz; i++) {
platform_device_unregister(mars_devices[i]);
}
//if (mars_cdev)
// cdev_del(mars_cdev);
//
//unregister_chrdev_region(mars_dev_nr, 1);
__unregister_chrdev(mars_dev_nr, 1, 1, "mars-dev");
}
static int __init cpuid_init(void)
{
int i, err = 0;
i = 0;
if (__register_chrdev(CPUID_MAJOR, 0, NR_CPUS,
"cpu/cpuid", &cpuid_fops)) {
printk(KERN_ERR "cpuid: unable to get major %d for cpuid\n",
CPUID_MAJOR);
err = -EBUSY;
goto out;
}
cpuid_class = class_create(THIS_MODULE, "cpuid");
if (IS_ERR(cpuid_class)) {
err = PTR_ERR(cpuid_class);
goto out_chrdev;
}
cpuid_class->devnode = cpuid_devnode;
cpu_notifier_register_begin();
for_each_online_cpu(i) {
err = cpuid_device_create(i);
if (err != 0)
goto out_class;
}
__register_hotcpu_notifier(&cpuid_class_cpu_notifier);
cpu_notifier_register_done();
err = 0;
goto out;
out_class:
i = 0;
for_each_online_cpu(i) {
cpuid_device_destroy(i);
}
cpu_notifier_register_done();
class_destroy(cpuid_class);
out_chrdev:
__unregister_chrdev(CPUID_MAJOR, 0, NR_CPUS, "cpu/cpuid");
out:
return err;
}
static int __init msr_init(void)
{
int i, err = 0;
i = 0;
if (__register_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr", &msr_fops)) {
pr_err("unable to get major %d for msr\n", MSR_MAJOR);
err = -EBUSY;
goto out;
}
msr_class = class_create(THIS_MODULE, "msr");
if (IS_ERR(msr_class)) {
err = PTR_ERR(msr_class);
goto out_chrdev;
}
msr_class->devnode = msr_devnode;
cpu_notifier_register_begin();
for_each_online_cpu(i) {
err = msr_device_create(i);
if (err != 0)
goto out_class;
}
__register_hotcpu_notifier(&msr_class_cpu_notifier);
cpu_notifier_register_done();
err = 0;
goto out;
out_class:
i = 0;
for_each_online_cpu(i)
msr_device_destroy(i);
cpu_notifier_register_done();
class_destroy(msr_class);
out_chrdev:
__unregister_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr");
out:
return err;
}
static int rmidev_init_device(struct rmi_char_device *cd)
{
struct rmi_device *rmi_dev = cd->rmi_dev;
struct rmidev_data *data;
dev_t dev_no;
int retval;
struct device *device_ptr;
if (rmidev_major_num) {
dev_no = MKDEV(rmidev_major_num, cd->rmi_dev->number);
retval = register_chrdev_region(dev_no, 1, CHAR_DEVICE_NAME);
} else {
retval = alloc_chrdev_region(&dev_no, 0, 1, CHAR_DEVICE_NAME);
/* let kernel allocate a major for us */
rmidev_major_num = MAJOR(dev_no);
dev_info(&rmi_dev->dev, "Major number of rmidev: %d\n",
rmidev_major_num);
}
if (retval < 0) {
dev_err(&rmi_dev->dev,
"Failed to get minor dev number %d, code %d.\n",
cd->rmi_dev->number, retval);
return retval;
} else
dev_info(&rmi_dev->dev, "Allocated rmidev %d %d.\n",
MAJOR(dev_no), MINOR(dev_no));
data = kzalloc(sizeof(struct rmidev_data), GFP_KERNEL);
if (!data) {
dev_err(&rmi_dev->dev, "Failed to allocate rmidev_data.\n");
/* unregister the char device region */
__unregister_chrdev(rmidev_major_num, MINOR(dev_no), 1,
CHAR_DEVICE_NAME);
return -ENOMEM;
}
mutex_init(&data->file_mutex);
data->rmi_dev = cd->rmi_dev;
cd->data = data;
cdev_init(&data->main_dev, &rmidev_fops);
retval = cdev_add(&data->main_dev, dev_no, 1);
if (retval) {
dev_err(&cd->rmi_dev->dev, "Error %d adding rmi_char_dev.\n",
retval);
rmidev_device_cleanup(data);
return retval;
}
dev_set_name(&cd->dev, "rmidev%d", MINOR(dev_no));
data->device_class = rmidev_device_class;
device_ptr = device_create(
data->device_class,
NULL, dev_no, NULL,
CHAR_DEVICE_NAME"%d",
MINOR(dev_no));
if (IS_ERR(device_ptr)) {
dev_err(&cd->rmi_dev->dev, "Failed to create rmi device.\n");
rmidev_device_cleanup(data);
return -ENODEV;
}
return 0;
}
static void __exit msr_exit(void)
{
cpuhp_remove_state(cpuhp_msr_state);
class_destroy(msr_class);
__unregister_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr");
}
