sound/sound_core.c

   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, 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);