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