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