Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
| 3 | * linux/drivers/char/misc.c |
| 4 | * |
| 5 | * Generic misc open routine by Johan Myreen |
| 6 | * |
| 7 | * Based on code from Linus |
| 8 | * |
| 9 | * Teemu Rantanen's Microsoft Busmouse support and Derrick Cole's |
| 10 | * changes incorporated into 0.97pl4 |
| 11 | * by Peter Cervasio (pete%q106fm.uucp@wupost.wustl.edu) (08SEP92) |
| 12 | * See busmouse.c for particulars. |
| 13 | * |
| 14 | * Made things a lot mode modular - easy to compile in just one or two |
| 15 | * of the misc drivers, as they are now completely independent. Linus. |
| 16 | * |
| 17 | * Support for loadable modules. 8-Sep-95 Philip Blundell <pjb27@cam.ac.uk> |
| 18 | * |
| 19 | * Fixed a failing symbol register to free the device registration |
| 20 | * Alan Cox <alan@lxorguk.ukuu.org.uk> 21-Jan-96 |
| 21 | * |
| 22 | * Dynamic minors and /proc/mice by Alessandro Rubini. 26-Mar-96 |
| 23 | * |
| 24 | * Renamed to misc and miscdevice to be more accurate. Alan Cox 26-Mar-96 |
| 25 | * |
| 26 | * Handling of mouse minor numbers for kerneld: |
| 27 | * Idea by Jacques Gelinas <jack@solucorp.qc.ca>, |
| 28 | * adapted by Bjorn Ekwall <bj0rn@blox.se> |
| 29 | * corrected by Alan Cox <alan@lxorguk.ukuu.org.uk> |
| 30 | * |
| 31 | * Changes for kmod (from kerneld): |
| 32 | * Cyrus Durgin <cider@speakeasy.org> |
| 33 | * |
| 34 | * Added devfs support. Richard Gooch <rgooch@atnf.csiro.au> 10-Jan-1998 |
| 35 | */ |
| 36 | |
| 37 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | |
| 39 | #include <linux/fs.h> |
| 40 | #include <linux/errno.h> |
| 41 | #include <linux/miscdevice.h> |
| 42 | #include <linux/kernel.h> |
| 43 | #include <linux/major.h> |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 44 | #include <linux/mutex.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | #include <linux/proc_fs.h> |
| 46 | #include <linux/seq_file.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | #include <linux/stat.h> |
| 48 | #include <linux/init.h> |
| 49 | #include <linux/device.h> |
| 50 | #include <linux/tty.h> |
| 51 | #include <linux/kmod.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 52 | #include <linux/gfp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | |
| 54 | /* |
| 55 | * Head entry for the doubly linked miscdevice list |
| 56 | */ |
| 57 | static LIST_HEAD(misc_list); |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 58 | static DEFINE_MUTEX(misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | |
| 60 | /* |
| 61 | * Assigned numbers, used for dynamic minors |
| 62 | */ |
| 63 | #define DYNAMIC_MINORS 64 /* like dynamic majors */ |
Thadeu Lima de Souza Cascardo | 1f2f38d | 2009-12-14 18:00:31 -0800 | [diff] [blame] | 64 | static DECLARE_BITMAP(misc_minors, DYNAMIC_MINORS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | #ifdef CONFIG_PROC_FS |
| 67 | static void *misc_seq_start(struct seq_file *seq, loff_t *pos) |
| 68 | { |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 69 | mutex_lock(&misc_mtx); |
Pavel Emelianov | 46c65b7 | 2007-07-15 23:39:53 -0700 | [diff] [blame] | 70 | return seq_list_start(&misc_list, *pos); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | static void *misc_seq_next(struct seq_file *seq, void *v, loff_t *pos) |
| 74 | { |
Pavel Emelianov | 46c65b7 | 2007-07-15 23:39:53 -0700 | [diff] [blame] | 75 | return seq_list_next(v, &misc_list, pos); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | } |
| 77 | |
| 78 | static void misc_seq_stop(struct seq_file *seq, void *v) |
| 79 | { |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 80 | mutex_unlock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | static int misc_seq_show(struct seq_file *seq, void *v) |
| 84 | { |
Pavel Emelianov | 46c65b7 | 2007-07-15 23:39:53 -0700 | [diff] [blame] | 85 | const struct miscdevice *p = list_entry(v, struct miscdevice, list); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | |
| 87 | seq_printf(seq, "%3i %s\n", p->minor, p->name ? p->name : ""); |
| 88 | return 0; |
| 89 | } |
| 90 | |
| 91 | |
James Morris | 88e9d34 | 2009-09-22 16:43:43 -0700 | [diff] [blame] | 92 | static const struct seq_operations misc_seq_ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | .start = misc_seq_start, |
| 94 | .next = misc_seq_next, |
| 95 | .stop = misc_seq_stop, |
| 96 | .show = misc_seq_show, |
| 97 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | #endif |
| 99 | |
Varsha Rao | 65ebd3d | 2017-04-07 16:58:54 +0530 | [diff] [blame] | 100 | static int misc_open(struct inode *inode, struct file *file) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | { |
| 102 | int minor = iminor(inode); |
| 103 | struct miscdevice *c; |
| 104 | int err = -ENODEV; |
Al Viro | e84f9e5 | 2013-09-22 14:17:15 -0400 | [diff] [blame] | 105 | const struct file_operations *new_fops = NULL; |
Thomas Gleixner | 40b798e | 2009-10-10 15:35:43 +0000 | [diff] [blame] | 106 | |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 107 | mutex_lock(&misc_mtx); |
Tal Shorer | 898bc28 | 2015-05-01 14:53:09 +0300 | [diff] [blame] | 108 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | list_for_each_entry(c, &misc_list, list) { |
| 110 | if (c->minor == minor) { |
Tal Shorer | 898bc28 | 2015-05-01 14:53:09 +0300 | [diff] [blame] | 111 | new_fops = fops_get(c->fops); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | break; |
| 113 | } |
| 114 | } |
Tal Shorer | 898bc28 | 2015-05-01 14:53:09 +0300 | [diff] [blame] | 115 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | if (!new_fops) { |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 117 | mutex_unlock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | request_module("char-major-%d-%d", MISC_MAJOR, minor); |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 119 | mutex_lock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | |
| 121 | list_for_each_entry(c, &misc_list, list) { |
| 122 | if (c->minor == minor) { |
| 123 | new_fops = fops_get(c->fops); |
| 124 | break; |
| 125 | } |
| 126 | } |
| 127 | if (!new_fops) |
| 128 | goto fail; |
| 129 | } |
| 130 | |
Tom Van Braeckel | 0b509d8 | 2015-03-31 16:39:21 +0200 | [diff] [blame] | 131 | /* |
| 132 | * Place the miscdevice in the file's |
| 133 | * private_data so it can be used by the |
| 134 | * file operations, including f_op->open below |
| 135 | */ |
| 136 | file->private_data = c; |
| 137 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | err = 0; |
Al Viro | e84f9e5 | 2013-09-22 14:17:15 -0400 | [diff] [blame] | 139 | replace_fops(file, new_fops); |
Tom Van Braeckel | 0b509d8 | 2015-03-31 16:39:21 +0200 | [diff] [blame] | 140 | if (file->f_op->open) |
Varsha Rao | 50a5e314 | 2017-04-07 17:01:31 +0530 | [diff] [blame] | 141 | err = file->f_op->open(inode, file); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | fail: |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 143 | mutex_unlock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | return err; |
| 145 | } |
| 146 | |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 147 | static struct class *misc_class; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | |
Arjan van de Ven | 62322d2 | 2006-07-03 00:24:21 -0700 | [diff] [blame] | 149 | static const struct file_operations misc_fops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | .owner = THIS_MODULE, |
| 151 | .open = misc_open, |
Arnd Bergmann | 6038f37 | 2010-08-15 18:52:59 +0200 | [diff] [blame] | 152 | .llseek = noop_llseek, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | }; |
| 154 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | /** |
| 156 | * misc_register - register a miscellaneous device |
| 157 | * @misc: device structure |
Tal Shorer | 898bc28 | 2015-05-01 14:53:09 +0300 | [diff] [blame] | 158 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | * Register a miscellaneous device with the kernel. If the minor |
| 160 | * number is set to %MISC_DYNAMIC_MINOR a minor number is assigned |
| 161 | * and placed in the minor field of the structure. For other cases |
| 162 | * the minor number requested is used. |
| 163 | * |
| 164 | * The structure passed is linked into the kernel and may not be |
Martin Kepplinger | 03190c6 | 2015-03-23 13:59:46 +0100 | [diff] [blame] | 165 | * destroyed until it has been unregistered. By default, an open() |
| 166 | * syscall to the device sets file->private_data to point to the |
| 167 | * structure. Drivers don't need open in fops for this. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | * |
| 169 | * A zero is returned on success and a negative errno code for |
| 170 | * failure. |
| 171 | */ |
Tal Shorer | 898bc28 | 2015-05-01 14:53:09 +0300 | [diff] [blame] | 172 | |
Varsha Rao | 65ebd3d | 2017-04-07 16:58:54 +0530 | [diff] [blame] | 173 | int misc_register(struct miscdevice *misc) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | dev_t dev; |
Greg Kroah-Hartman | 7c69ef7 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 176 | int err = 0; |
Vladimir Zapolskiy | b575f71 | 2015-05-18 20:11:46 +0300 | [diff] [blame] | 177 | bool is_dynamic = (misc->minor == MISC_DYNAMIC_MINOR); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | |
Neil Horman | 5d469ec0 | 2006-12-06 20:37:08 -0800 | [diff] [blame] | 179 | INIT_LIST_HEAD(&misc->list); |
| 180 | |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 181 | mutex_lock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | |
Vladimir Zapolskiy | b575f71 | 2015-05-18 20:11:46 +0300 | [diff] [blame] | 183 | if (is_dynamic) { |
Thadeu Lima de Souza Cascardo | 1f2f38d | 2009-12-14 18:00:31 -0800 | [diff] [blame] | 184 | int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS); |
Varsha Rao | 5b884a9 | 2017-04-07 17:02:32 +0530 | [diff] [blame] | 185 | |
Thadeu Lima de Souza Cascardo | 1f2f38d | 2009-12-14 18:00:31 -0800 | [diff] [blame] | 186 | if (i >= DYNAMIC_MINORS) { |
Elad Wexler | 684116c | 2013-09-14 18:02:11 +0300 | [diff] [blame] | 187 | err = -EBUSY; |
| 188 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | } |
Thadeu Lima de Souza Cascardo | 1f2f38d | 2009-12-14 18:00:31 -0800 | [diff] [blame] | 190 | misc->minor = DYNAMIC_MINORS - i - 1; |
| 191 | set_bit(i, misc_minors); |
Dae S. Kim | 3c94ce6 | 2013-02-27 17:05:14 -0800 | [diff] [blame] | 192 | } else { |
| 193 | struct miscdevice *c; |
| 194 | |
| 195 | list_for_each_entry(c, &misc_list, list) { |
| 196 | if (c->minor == misc->minor) { |
Elad Wexler | 684116c | 2013-09-14 18:02:11 +0300 | [diff] [blame] | 197 | err = -EBUSY; |
| 198 | goto out; |
Dae S. Kim | 3c94ce6 | 2013-02-27 17:05:14 -0800 | [diff] [blame] | 199 | } |
| 200 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | } |
| 202 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | dev = MKDEV(MISC_MAJOR, misc->minor); |
| 204 | |
Takashi Iwai | bd73599 | 2015-02-02 15:44:54 +0100 | [diff] [blame] | 205 | misc->this_device = |
| 206 | device_create_with_groups(misc_class, misc->parent, dev, |
| 207 | misc, misc->groups, "%s", misc->name); |
Greg Kroah-Hartman | 94fbcde | 2006-07-27 16:16:04 -0700 | [diff] [blame] | 208 | if (IS_ERR(misc->this_device)) { |
Vladimir Zapolskiy | b575f71 | 2015-05-18 20:11:46 +0300 | [diff] [blame] | 209 | if (is_dynamic) { |
| 210 | int i = DYNAMIC_MINORS - misc->minor - 1; |
| 211 | |
| 212 | if (i < DYNAMIC_MINORS && i >= 0) |
| 213 | clear_bit(i, misc_minors); |
| 214 | misc->minor = MISC_DYNAMIC_MINOR; |
| 215 | } |
Greg Kroah-Hartman | 94fbcde | 2006-07-27 16:16:04 -0700 | [diff] [blame] | 216 | err = PTR_ERR(misc->this_device); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | goto out; |
| 218 | } |
| 219 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | /* |
| 221 | * Add it to the front, so that later devices can "override" |
| 222 | * earlier defaults |
| 223 | */ |
| 224 | list_add(&misc->list, &misc_list); |
| 225 | out: |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 226 | mutex_unlock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | return err; |
| 228 | } |
| 229 | |
| 230 | /** |
Rafael J. Wysocki | b844eba | 2008-03-23 20:28:24 +0100 | [diff] [blame] | 231 | * misc_deregister - unregister a miscellaneous device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | * @misc: device to unregister |
| 233 | * |
| 234 | * Unregister a miscellaneous device that was previously |
Greg Kroah-Hartman | f368ed6 | 2015-07-30 15:59:57 -0700 | [diff] [blame] | 235 | * successfully registered with misc_register(). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | */ |
| 237 | |
Greg Kroah-Hartman | f368ed6 | 2015-07-30 15:59:57 -0700 | [diff] [blame] | 238 | void misc_deregister(struct miscdevice *misc) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | { |
Thadeu Lima de Souza Cascardo | 1f2f38d | 2009-12-14 18:00:31 -0800 | [diff] [blame] | 240 | int i = DYNAMIC_MINORS - misc->minor - 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | |
Akinobu Mita | b329bec | 2010-08-09 17:20:35 -0700 | [diff] [blame] | 242 | if (WARN_ON(list_empty(&misc->list))) |
Greg Kroah-Hartman | f368ed6 | 2015-07-30 15:59:57 -0700 | [diff] [blame] | 243 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 245 | mutex_lock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | list_del(&misc->list); |
Rafael J. Wysocki | b844eba | 2008-03-23 20:28:24 +0100 | [diff] [blame] | 247 | device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor)); |
Thadeu Lima de Souza Cascardo | 4ae717d | 2009-12-14 18:00:30 -0800 | [diff] [blame] | 248 | if (i < DYNAMIC_MINORS && i >= 0) |
Thadeu Lima de Souza Cascardo | 1f2f38d | 2009-12-14 18:00:31 -0800 | [diff] [blame] | 249 | clear_bit(i, misc_minors); |
Matthias Kaehlcke | 0e82d5b | 2007-05-08 00:32:08 -0700 | [diff] [blame] | 250 | mutex_unlock(&misc_mtx); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | } |
| 252 | |
| 253 | EXPORT_SYMBOL(misc_register); |
Rafael J. Wysocki | b844eba | 2008-03-23 20:28:24 +0100 | [diff] [blame] | 254 | EXPORT_SYMBOL(misc_deregister); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | |
Al Viro | 2c9ede5 | 2011-07-23 20:24:48 -0400 | [diff] [blame] | 256 | static char *misc_devnode(struct device *dev, umode_t *mode) |
Kay Sievers | d405640 | 2009-04-30 15:23:42 +0200 | [diff] [blame] | 257 | { |
| 258 | struct miscdevice *c = dev_get_drvdata(dev); |
| 259 | |
Kay Sievers | e454cea | 2009-09-18 23:01:12 +0200 | [diff] [blame] | 260 | if (mode && c->mode) |
| 261 | *mode = c->mode; |
| 262 | if (c->nodename) |
| 263 | return kstrdup(c->nodename, GFP_KERNEL); |
Kay Sievers | d405640 | 2009-04-30 15:23:42 +0200 | [diff] [blame] | 264 | return NULL; |
| 265 | } |
| 266 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 267 | static int __init misc_init(void) |
| 268 | { |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 269 | int err; |
Sudip Mukherjee | 1037b278 | 2015-07-13 17:32:28 +0530 | [diff] [blame] | 270 | struct proc_dir_entry *ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | |
Christoph Hellwig | fddda2b | 2018-04-13 19:44:18 +0200 | [diff] [blame] | 272 | ret = proc_create_seq("misc", 0, NULL, &misc_seq_ops); |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 273 | misc_class = class_create(THIS_MODULE, "misc"); |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 274 | err = PTR_ERR(misc_class); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | if (IS_ERR(misc_class)) |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 276 | goto fail_remove; |
Christoph Hellwig | 573fc11 | 2005-09-06 15:16:58 -0700 | [diff] [blame] | 277 | |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 278 | err = -EIO; |
Varsha Rao | 50a5e314 | 2017-04-07 17:01:31 +0530 | [diff] [blame] | 279 | if (register_chrdev(MISC_MAJOR, "misc", &misc_fops)) |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 280 | goto fail_printk; |
Kay Sievers | e454cea | 2009-09-18 23:01:12 +0200 | [diff] [blame] | 281 | misc_class->devnode = misc_devnode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | return 0; |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 283 | |
| 284 | fail_printk: |
Varsha Rao | 8ab44b4 | 2017-04-07 17:04:06 +0530 | [diff] [blame] | 285 | pr_err("unable to get major %d for misc devices\n", MISC_MAJOR); |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 286 | class_destroy(misc_class); |
| 287 | fail_remove: |
Sudip Mukherjee | 1037b278 | 2015-07-13 17:32:28 +0530 | [diff] [blame] | 288 | if (ret) |
| 289 | remove_proc_entry("misc", NULL); |
Denis V. Lunev | 1b50221 | 2008-04-29 01:02:34 -0700 | [diff] [blame] | 290 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | } |
| 292 | subsys_initcall(misc_init); |