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> |
| 43 | #include <linux/slab.h> |
| 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> |
| 51 | |
| 52 | /* |
| 53 | * Head entry for the doubly linked miscdevice list |
| 54 | */ |
| 55 | static LIST_HEAD(misc_list); |
| 56 | static DECLARE_MUTEX(misc_sem); |
| 57 | |
| 58 | /* |
| 59 | * Assigned numbers, used for dynamic minors |
| 60 | */ |
| 61 | #define DYNAMIC_MINORS 64 /* like dynamic majors */ |
| 62 | static unsigned char misc_minors[DYNAMIC_MINORS / 8]; |
| 63 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | extern int pmu_device_init(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | |
| 66 | #ifdef CONFIG_PROC_FS |
| 67 | static void *misc_seq_start(struct seq_file *seq, loff_t *pos) |
| 68 | { |
| 69 | struct miscdevice *p; |
| 70 | loff_t off = 0; |
| 71 | |
| 72 | down(&misc_sem); |
| 73 | list_for_each_entry(p, &misc_list, list) { |
| 74 | if (*pos == off++) |
| 75 | return p; |
| 76 | } |
| 77 | return NULL; |
| 78 | } |
| 79 | |
| 80 | static void *misc_seq_next(struct seq_file *seq, void *v, loff_t *pos) |
| 81 | { |
| 82 | struct list_head *n = ((struct miscdevice *)v)->list.next; |
| 83 | |
| 84 | ++*pos; |
| 85 | |
| 86 | return (n != &misc_list) ? list_entry(n, struct miscdevice, list) |
| 87 | : NULL; |
| 88 | } |
| 89 | |
| 90 | static void misc_seq_stop(struct seq_file *seq, void *v) |
| 91 | { |
| 92 | up(&misc_sem); |
| 93 | } |
| 94 | |
| 95 | static int misc_seq_show(struct seq_file *seq, void *v) |
| 96 | { |
| 97 | const struct miscdevice *p = v; |
| 98 | |
| 99 | seq_printf(seq, "%3i %s\n", p->minor, p->name ? p->name : ""); |
| 100 | return 0; |
| 101 | } |
| 102 | |
| 103 | |
| 104 | static struct seq_operations misc_seq_ops = { |
| 105 | .start = misc_seq_start, |
| 106 | .next = misc_seq_next, |
| 107 | .stop = misc_seq_stop, |
| 108 | .show = misc_seq_show, |
| 109 | }; |
| 110 | |
| 111 | static int misc_seq_open(struct inode *inode, struct file *file) |
| 112 | { |
| 113 | return seq_open(file, &misc_seq_ops); |
| 114 | } |
| 115 | |
Arjan van de Ven | 62322d2 | 2006-07-03 00:24:21 -0700 | [diff] [blame] | 116 | static const struct file_operations misc_proc_fops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | .owner = THIS_MODULE, |
| 118 | .open = misc_seq_open, |
| 119 | .read = seq_read, |
| 120 | .llseek = seq_lseek, |
| 121 | .release = seq_release, |
| 122 | }; |
| 123 | #endif |
| 124 | |
| 125 | static int misc_open(struct inode * inode, struct file * file) |
| 126 | { |
| 127 | int minor = iminor(inode); |
| 128 | struct miscdevice *c; |
| 129 | int err = -ENODEV; |
Arjan van de Ven | 99ac48f | 2006-03-28 01:56:41 -0800 | [diff] [blame] | 130 | const struct file_operations *old_fops, *new_fops = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | |
| 132 | down(&misc_sem); |
| 133 | |
| 134 | list_for_each_entry(c, &misc_list, list) { |
| 135 | if (c->minor == minor) { |
| 136 | new_fops = fops_get(c->fops); |
| 137 | break; |
| 138 | } |
| 139 | } |
| 140 | |
| 141 | if (!new_fops) { |
| 142 | up(&misc_sem); |
| 143 | request_module("char-major-%d-%d", MISC_MAJOR, minor); |
| 144 | down(&misc_sem); |
| 145 | |
| 146 | list_for_each_entry(c, &misc_list, list) { |
| 147 | if (c->minor == minor) { |
| 148 | new_fops = fops_get(c->fops); |
| 149 | break; |
| 150 | } |
| 151 | } |
| 152 | if (!new_fops) |
| 153 | goto fail; |
| 154 | } |
| 155 | |
| 156 | err = 0; |
| 157 | old_fops = file->f_op; |
| 158 | file->f_op = new_fops; |
| 159 | if (file->f_op->open) { |
| 160 | err=file->f_op->open(inode,file); |
| 161 | if (err) { |
| 162 | fops_put(file->f_op); |
| 163 | file->f_op = fops_get(old_fops); |
| 164 | } |
| 165 | } |
| 166 | fops_put(old_fops); |
| 167 | fail: |
| 168 | up(&misc_sem); |
| 169 | return err; |
| 170 | } |
| 171 | |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 172 | static struct class *misc_class; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | |
Arjan van de Ven | 62322d2 | 2006-07-03 00:24:21 -0700 | [diff] [blame] | 174 | static const struct file_operations misc_fops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | .owner = THIS_MODULE, |
| 176 | .open = misc_open, |
| 177 | }; |
| 178 | |
| 179 | |
| 180 | /** |
| 181 | * misc_register - register a miscellaneous device |
| 182 | * @misc: device structure |
| 183 | * |
| 184 | * Register a miscellaneous device with the kernel. If the minor |
| 185 | * number is set to %MISC_DYNAMIC_MINOR a minor number is assigned |
| 186 | * and placed in the minor field of the structure. For other cases |
| 187 | * the minor number requested is used. |
| 188 | * |
| 189 | * The structure passed is linked into the kernel and may not be |
| 190 | * destroyed until it has been unregistered. |
| 191 | * |
| 192 | * A zero is returned on success and a negative errno code for |
| 193 | * failure. |
| 194 | */ |
| 195 | |
| 196 | int misc_register(struct miscdevice * misc) |
| 197 | { |
| 198 | struct miscdevice *c; |
| 199 | dev_t dev; |
Greg Kroah-Hartman | 7c69ef7 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 200 | int err = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | |
Neil Horman | 5d469ec | 2006-12-06 20:37:08 -0800 | [diff] [blame] | 202 | INIT_LIST_HEAD(&misc->list); |
| 203 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | down(&misc_sem); |
| 205 | list_for_each_entry(c, &misc_list, list) { |
| 206 | if (c->minor == misc->minor) { |
| 207 | up(&misc_sem); |
| 208 | return -EBUSY; |
| 209 | } |
| 210 | } |
| 211 | |
| 212 | if (misc->minor == MISC_DYNAMIC_MINOR) { |
| 213 | int i = DYNAMIC_MINORS; |
| 214 | while (--i >= 0) |
| 215 | if ( (misc_minors[i>>3] & (1 << (i&7))) == 0) |
| 216 | break; |
| 217 | if (i<0) { |
| 218 | up(&misc_sem); |
| 219 | return -EBUSY; |
| 220 | } |
| 221 | misc->minor = i; |
| 222 | } |
| 223 | |
| 224 | if (misc->minor < DYNAMIC_MINORS) |
| 225 | misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | dev = MKDEV(MISC_MAJOR, misc->minor); |
| 227 | |
Greg Kroah-Hartman | 94fbcde | 2006-07-27 16:16:04 -0700 | [diff] [blame] | 228 | misc->this_device = device_create(misc_class, misc->parent, dev, |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 229 | "%s", misc->name); |
Greg Kroah-Hartman | 94fbcde | 2006-07-27 16:16:04 -0700 | [diff] [blame] | 230 | if (IS_ERR(misc->this_device)) { |
| 231 | err = PTR_ERR(misc->this_device); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | goto out; |
| 233 | } |
| 234 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | /* |
| 236 | * Add it to the front, so that later devices can "override" |
| 237 | * earlier defaults |
| 238 | */ |
| 239 | list_add(&misc->list, &misc_list); |
| 240 | out: |
| 241 | up(&misc_sem); |
| 242 | return err; |
| 243 | } |
| 244 | |
| 245 | /** |
| 246 | * misc_deregister - unregister a miscellaneous device |
| 247 | * @misc: device to unregister |
| 248 | * |
| 249 | * Unregister a miscellaneous device that was previously |
| 250 | * successfully registered with misc_register(). Success |
| 251 | * is indicated by a zero return, a negative errno code |
| 252 | * indicates an error. |
| 253 | */ |
| 254 | |
| 255 | int misc_deregister(struct miscdevice * misc) |
| 256 | { |
| 257 | int i = misc->minor; |
| 258 | |
| 259 | if (list_empty(&misc->list)) |
| 260 | return -EINVAL; |
| 261 | |
| 262 | down(&misc_sem); |
| 263 | list_del(&misc->list); |
Greg Kroah-Hartman | 94fbcde | 2006-07-27 16:16:04 -0700 | [diff] [blame] | 264 | device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | if (i < DYNAMIC_MINORS && i>0) { |
| 266 | misc_minors[i>>3] &= ~(1 << (misc->minor & 7)); |
| 267 | } |
| 268 | up(&misc_sem); |
| 269 | return 0; |
| 270 | } |
| 271 | |
| 272 | EXPORT_SYMBOL(misc_register); |
| 273 | EXPORT_SYMBOL(misc_deregister); |
| 274 | |
| 275 | static int __init misc_init(void) |
| 276 | { |
| 277 | #ifdef CONFIG_PROC_FS |
| 278 | struct proc_dir_entry *ent; |
| 279 | |
| 280 | ent = create_proc_entry("misc", 0, NULL); |
| 281 | if (ent) |
| 282 | ent->proc_fops = &misc_proc_fops; |
| 283 | #endif |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 284 | misc_class = class_create(THIS_MODULE, "misc"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 285 | if (IS_ERR(misc_class)) |
| 286 | return PTR_ERR(misc_class); |
Christoph Hellwig | 573fc11 | 2005-09-06 15:16:58 -0700 | [diff] [blame] | 287 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | if (register_chrdev(MISC_MAJOR,"misc",&misc_fops)) { |
| 289 | printk("unable to get major %d for misc devices\n", |
| 290 | MISC_MAJOR); |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 291 | class_destroy(misc_class); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | return -EIO; |
| 293 | } |
| 294 | return 0; |
| 295 | } |
| 296 | subsys_initcall(misc_init); |