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