1 /* 2 * Sound core. This file is composed of two parts. sound_class 3 * which is common to both OSS and ALSA and OSS sound core which 4 * is used OSS or emulation of it. 5 */ 6 7 /* 8 * First, the common part. 9 */ 10 #include <linux/module.h> 11 #include <linux/device.h> 12 #include <linux/err.h> 13 #include <linux/kdev_t.h> 14 #include <linux/major.h> 15 #include <sound/core.h> 16 17 #ifdef CONFIG_SOUND_OSS_CORE 18 static int __init init_oss_soundcore(void); 19 static void cleanup_oss_soundcore(void); 20 #else 21 static inline int init_oss_soundcore(void) { return 0; } 22 static inline void cleanup_oss_soundcore(void) { } 23 #endif 24 25 struct class *sound_class; 26 EXPORT_SYMBOL(sound_class); 27 28 MODULE_DESCRIPTION("Core sound module"); 29 MODULE_AUTHOR("Alan Cox"); 30 MODULE_LICENSE("GPL"); 31 32 static char *sound_nodename(struct device *dev) 33 { 34 if (MAJOR(dev->devt) == SOUND_MAJOR) 35 return NULL; 36 return kasprintf(GFP_KERNEL, "snd/%s", dev_name(dev)); 37 } 38 39 static int __init init_soundcore(void) 40 { 41 int rc; 42 43 rc = init_oss_soundcore(); 44 if (rc) 45 return rc; 46 47 sound_class = class_create(THIS_MODULE, "sound"); 48 if (IS_ERR(sound_class)) { 49 cleanup_oss_soundcore(); 50 return PTR_ERR(sound_class); 51 } 52 53 sound_class->nodename = sound_nodename; 54 55 return 0; 56 } 57 58 static void __exit cleanup_soundcore(void) 59 { 60 cleanup_oss_soundcore(); 61 class_destroy(sound_class); 62 } 63 64 module_init(init_soundcore); 65 module_exit(cleanup_soundcore); 66 67 68 #ifdef CONFIG_SOUND_OSS_CORE 69 /* 70 * OSS sound core handling. Breaks out sound functions to submodules 71 * 72 * Author: Alan Cox <alan@lxorguk.ukuu.org.uk> 73 * 74 * Fixes: 75 * 76 * 77 * This program is free software; you can redistribute it and/or 78 * modify it under the terms of the GNU General Public License 79 * as published by the Free Software Foundation; either version 80 * 2 of the License, or (at your option) any later version. 81 * 82 * -------------------- 83 * 84 * Top level handler for the sound subsystem. Various devices can 85 * plug into this. The fact they don't all go via OSS doesn't mean 86 * they don't have to implement the OSS API. There is a lot of logic 87 * to keeping much of the OSS weight out of the code in a compatibility 88 * module, but it's up to the driver to rember to load it... 89 * 90 * The code provides a set of functions for registration of devices 91 * by type. This is done rather than providing a single call so that 92 * we can hide any future changes in the internals (eg when we go to 93 * 32bit dev_t) from the modules and their interface. 94 * 95 * Secondly we need to allocate the dsp, dsp16 and audio devices as 96 * one. Thus we misuse the chains a bit to simplify this. 97 * 98 * Thirdly to make it more fun and for 2.3.x and above we do all 99 * of this using fine grained locking. 100 * 101 * FIXME: we have to resolve modules and fine grained load/unload 102 * locking at some point in 2.3.x. 103 */ 104 105 #include <linux/init.h> 106 #include <linux/slab.h> 107 #include <linux/smp_lock.h> 108 #include <linux/types.h> 109 #include <linux/kernel.h> 110 #include <linux/sound.h> 111 #include <linux/kmod.h> 112 113 #define SOUND_STEP 16 114 115 struct sound_unit 116 { 117 int unit_minor; 118 const struct file_operations *unit_fops; 119 struct sound_unit *next; 120 char name[32]; 121 }; 122 123 #ifdef CONFIG_SOUND_MSNDCLAS 124 extern int msnd_classic_init(void); 125 #endif 126 #ifdef CONFIG_SOUND_MSNDPIN 127 extern int msnd_pinnacle_init(void); 128 #endif 129 130 /* 131 * Low level list operator. Scan the ordered list, find a hole and 132 * join into it. Called with the lock asserted 133 */ 134 135 static int __sound_insert_unit(struct sound_unit * s, struct sound_unit **list, const struct file_operations *fops, int index, int low, int top) 136 { 137 int n=low; 138 139 if (index < 0) { /* first free */ 140 141 while (*list && (*list)->unit_minor<n) 142 list=&((*list)->next); 143 144 while(n<top) 145 { 146 /* Found a hole ? */ 147 if(*list==NULL || (*list)->unit_minor>n) 148 break; 149 list=&((*list)->next); 150 n+=SOUND_STEP; 151 } 152 153 if(n>=top) 154 return -ENOENT; 155 } else { 156 n = low+(index*16); 157 while (*list) { 158 if ((*list)->unit_minor==n) 159 return -EBUSY; 160 if ((*list)->unit_minor>n) 161 break; 162 list=&((*list)->next); 163 } 164 } 165 166 /* 167 * Fill it in 168 */ 169 170 s->unit_minor=n; 171 s->unit_fops=fops; 172 173 /* 174 * Link it 175 */ 176 177 s->next=*list; 178 *list=s; 179 180 181 return n; 182 } 183 184 /* 185 * Remove a node from the chain. Called with the lock asserted 186 */ 187 188 static struct sound_unit *__sound_remove_unit(struct sound_unit **list, int unit) 189 { 190 while(*list) 191 { 192 struct sound_unit *p=*list; 193 if(p->unit_minor==unit) 194 { 195 *list=p->next; 196 return p; 197 } 198 list=&(p->next); 199 } 200 printk(KERN_ERR "Sound device %d went missing!\n", unit); 201 return NULL; 202 } 203 204 /* 205 * This lock guards the sound loader list. 206 */ 207 208 static DEFINE_SPINLOCK(sound_loader_lock); 209 210 /* 211 * Allocate the controlling structure and add it to the sound driver 212 * list. Acquires locks as needed 213 */ 214 215 static int sound_insert_unit(struct sound_unit **list, const struct file_operations *fops, int index, int low, int top, const char *name, umode_t mode, struct device *dev) 216 { 217 struct sound_unit *s = kmalloc(sizeof(*s), GFP_KERNEL); 218 int r; 219 220 if (!s) 221 return -ENOMEM; 222 223 spin_lock(&sound_loader_lock); 224 r = __sound_insert_unit(s, list, fops, index, low, top); 225 spin_unlock(&sound_loader_lock); 226 227 if (r < 0) 228 goto fail; 229 else if (r < SOUND_STEP) 230 sprintf(s->name, "sound/%s", name); 231 else 232 sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP); 233 234 device_create(sound_class, dev, MKDEV(SOUND_MAJOR, s->unit_minor), 235 NULL, s->name+6); 236 return r; 237 238 fail: 239 kfree(s); 240 return r; 241 } 242 243 /* 244 * Remove a unit. Acquires locks as needed. The drivers MUST have 245 * completed the removal before their file operations become 246 * invalid. 247 */ 248 249 static void sound_remove_unit(struct sound_unit **list, int unit) 250 { 251 struct sound_unit *p; 252 253 spin_lock(&sound_loader_lock); 254 p = __sound_remove_unit(list, unit); 255 spin_unlock(&sound_loader_lock); 256 if (p) { 257 device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor)); 258 kfree(p); 259 } 260 } 261 262 /* 263 * Allocations 264 * 265 * 0 *16 Mixers 266 * 1 *8 Sequencers 267 * 2 *16 Midi 268 * 3 *16 DSP 269 * 4 *16 SunDSP 270 * 5 *16 DSP16 271 * 6 -- sndstat (obsolete) 272 * 7 *16 unused 273 * 8 -- alternate sequencer (see above) 274 * 9 *16 raw synthesizer access 275 * 10 *16 unused 276 * 11 *16 unused 277 * 12 *16 unused 278 * 13 *16 unused 279 * 14 *16 unused 280 * 15 *16 unused 281 */ 282 283 static struct sound_unit *chains[SOUND_STEP]; 284 285 /** 286 * register_sound_special_device - register a special sound node 287 * @fops: File operations for the driver 288 * @unit: Unit number to allocate 289 * @dev: device pointer 290 * 291 * Allocate a special sound device by minor number from the sound 292 * subsystem. The allocated number is returned on succes. On failure 293 * a negative error code is returned. 294 */ 295 296 int register_sound_special_device(const struct file_operations *fops, int unit, 297 struct device *dev) 298 { 299 const int chain = unit % SOUND_STEP; 300 int max_unit = 128 + chain; 301 const char *name; 302 char _name[16]; 303 304 switch (chain) { 305 case 0: 306 name = "mixer"; 307 break; 308 case 1: 309 name = "sequencer"; 310 if (unit >= SOUND_STEP) 311 goto __unknown; 312 max_unit = unit + 1; 313 break; 314 case 2: 315 name = "midi"; 316 break; 317 case 3: 318 name = "dsp"; 319 break; 320 case 4: 321 name = "audio"; 322 break; 323 case 8: 324 name = "sequencer2"; 325 if (unit >= SOUND_STEP) 326 goto __unknown; 327 max_unit = unit + 1; 328 break; 329 case 9: 330 name = "dmmidi"; 331 break; 332 case 10: 333 name = "dmfm"; 334 break; 335 case 12: 336 name = "adsp"; 337 break; 338 case 13: 339 name = "amidi"; 340 break; 341 case 14: 342 name = "admmidi"; 343 break; 344 default: 345 { 346 __unknown: 347 sprintf(_name, "unknown%d", chain); 348 if (unit >= SOUND_STEP) 349 strcat(_name, "-"); 350 name = _name; 351 } 352 break; 353 } 354 return sound_insert_unit(&chains[chain], fops, -1, unit, max_unit, 355 name, S_IRUSR | S_IWUSR, dev); 356 } 357 358 EXPORT_SYMBOL(register_sound_special_device); 359 360 int register_sound_special(const struct file_operations *fops, int unit) 361 { 362 return register_sound_special_device(fops, unit, NULL); 363 } 364 365 EXPORT_SYMBOL(register_sound_special); 366 367 /** 368 * register_sound_mixer - register a mixer device 369 * @fops: File operations for the driver 370 * @dev: Unit number to allocate 371 * 372 * Allocate a mixer device. Unit is the number of the mixer requested. 373 * Pass -1 to request the next free mixer unit. On success the allocated 374 * number is returned, on failure a negative error code is returned. 375 */ 376 377 int register_sound_mixer(const struct file_operations *fops, int dev) 378 { 379 return sound_insert_unit(&chains[0], fops, dev, 0, 128, 380 "mixer", S_IRUSR | S_IWUSR, NULL); 381 } 382 383 EXPORT_SYMBOL(register_sound_mixer); 384 385 /** 386 * register_sound_midi - register a midi device 387 * @fops: File operations for the driver 388 * @dev: Unit number to allocate 389 * 390 * Allocate a midi device. Unit is the number of the midi device requested. 391 * Pass -1 to request the next free midi unit. On success the allocated 392 * number is returned, on failure a negative error code is returned. 393 */ 394 395 int register_sound_midi(const struct file_operations *fops, int dev) 396 { 397 return sound_insert_unit(&chains[2], fops, dev, 2, 130, 398 "midi", S_IRUSR | S_IWUSR, NULL); 399 } 400 401 EXPORT_SYMBOL(register_sound_midi); 402 403 /* 404 * DSP's are registered as a triple. Register only one and cheat 405 * in open - see below. 406 */ 407 408 /** 409 * register_sound_dsp - register a DSP device 410 * @fops: File operations for the driver 411 * @dev: Unit number to allocate 412 * 413 * Allocate a DSP device. Unit is the number of the DSP requested. 414 * Pass -1 to request the next free DSP unit. On success the allocated 415 * number is returned, on failure a negative error code is returned. 416 * 417 * This function allocates both the audio and dsp device entries together 418 * and will always allocate them as a matching pair - eg dsp3/audio3 419 */ 420 421 int register_sound_dsp(const struct file_operations *fops, int dev) 422 { 423 return sound_insert_unit(&chains[3], fops, dev, 3, 131, 424 "dsp", S_IWUSR | S_IRUSR, NULL); 425 } 426 427 EXPORT_SYMBOL(register_sound_dsp); 428 429 /** 430 * unregister_sound_special - unregister a special sound device 431 * @unit: unit number to allocate 432 * 433 * Release a sound device that was allocated with 434 * register_sound_special(). The unit passed is the return value from 435 * the register function. 436 */ 437 438 439 void unregister_sound_special(int unit) 440 { 441 sound_remove_unit(&chains[unit % SOUND_STEP], unit); 442 } 443 444 EXPORT_SYMBOL(unregister_sound_special); 445 446 /** 447 * unregister_sound_mixer - unregister a mixer 448 * @unit: unit number to allocate 449 * 450 * Release a sound device that was allocated with register_sound_mixer(). 451 * The unit passed is the return value from the register function. 452 */ 453 454 void unregister_sound_mixer(int unit) 455 { 456 sound_remove_unit(&chains[0], unit); 457 } 458 459 EXPORT_SYMBOL(unregister_sound_mixer); 460 461 /** 462 * unregister_sound_midi - unregister a midi device 463 * @unit: unit number to allocate 464 * 465 * Release a sound device that was allocated with register_sound_midi(). 466 * The unit passed is the return value from the register function. 467 */ 468 469 void unregister_sound_midi(int unit) 470 { 471 sound_remove_unit(&chains[2], unit); 472 } 473 474 EXPORT_SYMBOL(unregister_sound_midi); 475 476 /** 477 * unregister_sound_dsp - unregister a DSP device 478 * @unit: unit number to allocate 479 * 480 * Release a sound device that was allocated with register_sound_dsp(). 481 * The unit passed is the return value from the register function. 482 * 483 * Both of the allocated units are released together automatically. 484 */ 485 486 void unregister_sound_dsp(int unit) 487 { 488 sound_remove_unit(&chains[3], unit); 489 } 490 491 492 EXPORT_SYMBOL(unregister_sound_dsp); 493 494 /* 495 * Now our file operations 496 */ 497 498 static int soundcore_open(struct inode *, struct file *); 499 500 static const struct file_operations soundcore_fops= 501 { 502 /* We must have an owner or the module locking fails */ 503 .owner = THIS_MODULE, 504 .open = soundcore_open, 505 }; 506 507 static struct sound_unit *__look_for_unit(int chain, int unit) 508 { 509 struct sound_unit *s; 510 511 s=chains[chain]; 512 while(s && s->unit_minor <= unit) 513 { 514 if(s->unit_minor==unit) 515 return s; 516 s=s->next; 517 } 518 return NULL; 519 } 520 521 static int soundcore_open(struct inode *inode, struct file *file) 522 { 523 int chain; 524 int unit = iminor(inode); 525 struct sound_unit *s; 526 const struct file_operations *new_fops = NULL; 527 528 lock_kernel (); 529 530 chain=unit&0x0F; 531 if(chain==4 || chain==5) /* dsp/audio/dsp16 */ 532 { 533 unit&=0xF0; 534 unit|=3; 535 chain=3; 536 } 537 538 spin_lock(&sound_loader_lock); 539 s = __look_for_unit(chain, unit); 540 if (s) 541 new_fops = fops_get(s->unit_fops); 542 if (!new_fops) { 543 spin_unlock(&sound_loader_lock); 544 /* 545 * Please, don't change this order or code. 546 * For ALSA slot means soundcard and OSS emulation code 547 * comes as add-on modules which aren't depend on 548 * ALSA toplevel modules for soundcards, thus we need 549 * load them at first. [Jaroslav Kysela <perex@jcu.cz>] 550 */ 551 request_module("sound-slot-%i", unit>>4); 552 request_module("sound-service-%i-%i", unit>>4, chain); 553 spin_lock(&sound_loader_lock); 554 s = __look_for_unit(chain, unit); 555 if (s) 556 new_fops = fops_get(s->unit_fops); 557 } 558 if (new_fops) { 559 /* 560 * We rely upon the fact that we can't be unloaded while the 561 * subdriver is there, so if ->open() is successful we can 562 * safely drop the reference counter and if it is not we can 563 * revert to old ->f_op. Ugly, indeed, but that's the cost of 564 * switching ->f_op in the first place. 565 */ 566 int err = 0; 567 const struct file_operations *old_fops = file->f_op; 568 file->f_op = new_fops; 569 spin_unlock(&sound_loader_lock); 570 if(file->f_op->open) 571 err = file->f_op->open(inode,file); 572 if (err) { 573 fops_put(file->f_op); 574 file->f_op = fops_get(old_fops); 575 } 576 fops_put(old_fops); 577 unlock_kernel(); 578 return err; 579 } 580 spin_unlock(&sound_loader_lock); 581 unlock_kernel(); 582 return -ENODEV; 583 } 584 585 MODULE_ALIAS_CHARDEV_MAJOR(SOUND_MAJOR); 586 587 static void cleanup_oss_soundcore(void) 588 { 589 /* We have nothing to really do here - we know the lists must be 590 empty */ 591 unregister_chrdev(SOUND_MAJOR, "sound"); 592 } 593 594 static int __init init_oss_soundcore(void) 595 { 596 if (register_chrdev(SOUND_MAJOR, "sound", &soundcore_fops)==-1) { 597 printk(KERN_ERR "soundcore: sound device already in use.\n"); 598 return -EBUSY; 599 } 600 601 return 0; 602 } 603 604 #endif /* CONFIG_SOUND_OSS_CORE */ 605