drivers/sound/dev

/* */
This source file includes following definitions.
snd_find_driver
start_cards
sndtable_init
sound_unload_drivers
sound_unload_driver
sndtable_probe
sndtable_init_card
sndtable_get_cardcount
sndtable_identify_card
sound_setup
sound_getconf
   1 /*
   2  * sound/dev_table.c
   3  *
   4  * Device call tables.
   5  *
   6  * Copyright by Hannu Savolainen 1993
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met: 1. Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer. 2.
  12  * Redistributions in binary form must reproduce the above copyright notice,
  13  * this list of conditions and the following disclaimer in the documentation
  14  * and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29 
  30 #define _DEV_TABLE_C_
  31 #include "sound_config.h"
  32 
  33 #ifdef CONFIGURE_SOUNDCARD
  34 
  35 int             sound_started = 0;
  36 
  37 int             sndtable_get_cardcount (void);
  38 
  39 int
  40 snd_find_driver (int type)
     /*  */
  41 {
  42   int             i, n = num_sound_drivers;
  43 
  44   for (i = 0; i < n; i++)
  45     if (sound_drivers[i].card_type == type)
  46       return i;
  47 
  48   return -1;
  49 }
  50 
  51 
  52 static long
  53 start_cards (long mem_start)
     /*  */
  54 {
  55   int             i, n = num_sound_cards;
  56   int             drv;
  57 
  58   sound_started = 1;
  59   printk ("Sound initialization started\n");
  60 
  61 /*
  62  * Check the number of cards actually defined in the table
  63  */
  64 
  65   for (i = 0; i < n && snd_installed_cards[i].card_type; i++)
  66     num_sound_cards = i + 1;
  67 
  68   for (i = 0; i < n && snd_installed_cards[i].card_type; i++)
  69     if (snd_installed_cards[i].enabled)
  70       {
  71         snd_installed_cards[i].for_driver_use = NULL;
  72 
  73         if ((drv = snd_find_driver (snd_installed_cards[i].card_type)) == -1)
  74           {
  75             snd_installed_cards[i].enabled = 0;         /*
  76                                                          * Mark as not detected
  77                                                          */
  78             continue;
  79           }
  80 
  81         snd_installed_cards[i].config.card_subtype =
  82           sound_drivers[drv].card_subtype;
  83 
  84         if (sound_drivers[drv].probe (&snd_installed_cards[i].config))
  85           {
  86             int             tmp;
  87 
  88             printk ("snd%d",
  89                     snd_installed_cards[i].card_type);
  90 
  91             mem_start = sound_drivers[drv].attach (mem_start, &snd_installed_cards[i].config);
  92             printk (" at 0x%x",
  93                     snd_installed_cards[i].config.io_base);
  94 
  95             if ((tmp = snd_installed_cards[i].config.irq) != 0)
  96               printk (" irq %d",
  97                       (tmp > 0) ? tmp : -tmp);
  98 
  99             if (snd_installed_cards[i].config.dma >= 0)
 100               printk (" drq %d",
 101                       snd_installed_cards[i].config.dma);
 102             if (snd_installed_cards[i].config.dma2 != -1)
 103               printk (",%d\n",
 104                       snd_installed_cards[i].config.dma2);
 105             else
 106               printk ("\n");
 107           }
 108         else
 109           snd_installed_cards[i].enabled = 0;   /*
 110                                                  * Mark as not detected
 111                                                  */
 112       }
 113 
 114   printk ("Sound initialization complete\n");
 115   return mem_start;
 116 }
 117 
 118 long
 119 sndtable_init (long mem_start)
     /*  */
 120 {
 121   return start_cards (mem_start);
 122 }
 123 
 124 void
 125 sound_unload_drivers (void)
     /*  */
 126 {
 127   int             i, n = num_sound_cards;
 128   int             drv;
 129 
 130   if (!sound_started)
 131     return;
 132 
 133   printk ("Sound unload started\n");
 134 
 135   for (i = 0; i < n && snd_installed_cards[i].card_type; i++)
 136     if (snd_installed_cards[i].enabled)
 137       if ((drv = snd_find_driver (snd_installed_cards[i].card_type)) != -1)
 138         if (sound_drivers[drv].unload)
 139           {
 140             sound_drivers[drv].unload (&snd_installed_cards[i].config);
 141             snd_installed_cards[i].enabled = 0;
 142           }
 143 
 144   printk ("Sound unload complete\n");
 145 }
 146 
 147 void
 148 sound_unload_driver (int type)
     /*  */
 149 {
 150   int             i, drv = -1, n = num_sound_cards;
 151 
 152   unsigned long   flags;
 153 
 154   DDB (printk ("unload driver %d: ", type));
 155 
 156   for (i = 0; i < n && snd_installed_cards[i].card_type; i++)
 157     if (snd_installed_cards[i].card_type == type)
 158       {
 159         if (snd_installed_cards[i].enabled)
 160           {
 161             if ((drv = snd_find_driver (type)) != -1)
 162               {
 163                 if (sound_drivers[drv].unload)
 164                   {
 165                     sound_drivers[drv].unload (&snd_installed_cards[i].config);
 166                     snd_installed_cards[i].enabled = 0;
 167                   }
 168               }
 169           }
 170       }
 171 
 172   save_flags (flags);
 173   cli ();
 174 
 175   restore_flags (flags);
 176 
 177 }
 178 
 179 
 180 int
 181 sndtable_probe (int unit, struct address_info *hw_config)
     /*  */
 182 {
 183   int             i, sel = -1, n = num_sound_cards;
 184 
 185   if (!unit)
 186     return TRUE;
 187 
 188   sound_started = 1;
 189 
 190   for (i = 0; i < n && sel == -1 && snd_installed_cards[i].card_type; i++)
 191     if (snd_installed_cards[i].enabled)
 192       if (snd_installed_cards[i].card_type == unit)
 193         sel = i;
 194 
 195   if (sel == -1 && num_sound_cards < max_sound_cards)
 196     {
 197       int             i;
 198 
 199       i = sel = (num_sound_cards++);
 200 
 201       snd_installed_cards[sel].card_type = unit;
 202       snd_installed_cards[sel].enabled = 1;
 203     }
 204 
 205   if (sel != -1)
 206     {
 207       int             drv;
 208 
 209       snd_installed_cards[sel].for_driver_use = NULL;
 210       snd_installed_cards[sel].config.io_base = hw_config->io_base;
 211       snd_installed_cards[sel].config.irq = hw_config->irq;
 212       snd_installed_cards[sel].config.dma = hw_config->dma;
 213       snd_installed_cards[sel].config.dma2 = hw_config->dma2;
 214       snd_installed_cards[sel].config.name = hw_config->name;
 215       snd_installed_cards[sel].config.always_detect = hw_config->always_detect;
 216       snd_installed_cards[sel].config.driver_use_1 = hw_config->driver_use_1;
 217       snd_installed_cards[sel].config.driver_use_2 = hw_config->driver_use_2;
 218       snd_installed_cards[sel].config.card_subtype = hw_config->card_subtype;
 219       snd_installed_cards[sel].config.osp = hw_config->osp;
 220 
 221       if ((drv = snd_find_driver (snd_installed_cards[sel].card_type)) == -1)
 222         {
 223           snd_installed_cards[sel].enabled = 0;
 224           return FALSE;
 225         }
 226 
 227 
 228       snd_installed_cards[sel].config.card_subtype =
 229         sound_drivers[drv].card_subtype;
 230 
 231       if (sound_drivers[drv].probe (hw_config))
 232         return TRUE;
 233 
 234       snd_installed_cards[sel].enabled = 0;     /*
 235                                                  * Mark as not detected
 236                                                  */
 237       return FALSE;
 238     }
 239 
 240   return FALSE;
 241 }
 242 
 243 int
 244 sndtable_init_card (int unit, struct address_info *hw_config)
     /*  */
 245 {
 246   int             i, n = num_sound_cards;
 247 
 248   DDB (printk ("sndtable_init_card(%d) entered\n", unit));
 249 
 250   if (!unit)
 251     {
 252       if (sndtable_init (0) != 0)
 253         panic ("sound: Invalid memory allocation\n");
 254       return TRUE;
 255     }
 256 
 257   for (i = 0; i < n && snd_installed_cards[i].card_type; i++)
 258     if (snd_installed_cards[i].card_type == unit)
 259       {
 260         int             drv;
 261 
 262         snd_installed_cards[i].config.io_base = hw_config->io_base;
 263         snd_installed_cards[i].config.irq = hw_config->irq;
 264         snd_installed_cards[i].config.dma = hw_config->dma;
 265         snd_installed_cards[i].config.dma2 = hw_config->dma2;
 266         snd_installed_cards[i].config.name = hw_config->name;
 267         snd_installed_cards[i].config.always_detect = hw_config->always_detect;
 268         snd_installed_cards[i].config.driver_use_1 = hw_config->driver_use_1;
 269         snd_installed_cards[i].config.driver_use_2 = hw_config->driver_use_2;
 270         snd_installed_cards[i].config.card_subtype = hw_config->card_subtype;
 271         snd_installed_cards[i].config.osp = hw_config->osp;
 272 
 273         if ((drv = snd_find_driver (snd_installed_cards[i].card_type)) == -1)
 274           snd_installed_cards[i].enabled = 0;   /*
 275                                                  * Mark as not detected
 276                                                  */
 277         else
 278           {
 279 
 280             DDB (printk ("Located card - calling attach routine\n"));
 281             printk ("snd%d", unit);
 282             if (sound_drivers[drv].attach (0, hw_config) != 0)
 283               panic ("sound: Invalid memory allocation\n");
 284 
 285             DDB (printk ("attach routine finished\n"));
 286             printk (" at 0x%x irq %d drq %d",
 287                     snd_installed_cards[i].config.io_base,
 288                     snd_installed_cards[i].config.irq,
 289                     snd_installed_cards[i].config.dma);
 290             if (snd_installed_cards[i].config.dma2 != -1)
 291               printk (",%d\n",
 292                       snd_installed_cards[i].config.dma2);
 293             else
 294               printk ("\n");
 295           }
 296         return TRUE;
 297       }
 298 
 299   printk ("sndtable_init_card: No card defined with type=%d, num cards: %d\n",
 300           unit, num_sound_cards);
 301   return FALSE;
 302 }
 303 
 304 int
 305 sndtable_get_cardcount (void)
     /*  */
 306 {
 307   return num_audiodevs + num_mixers + num_synths + num_midis;
 308 }
 309 
 310 int
 311 sndtable_identify_card (char *name)
     /*  */
 312 {
 313   int             i, n = num_sound_drivers;
 314 
 315   if (name == NULL)
 316     return 0;
 317 
 318   for (i = 0; i < n; i++)
 319     if (sound_drivers[i].driver_id != NULL)
 320       {
 321         char           *id = sound_drivers[i].driver_id;
 322         int             j;
 323 
 324         for (j = 0; j < 80 && name[j] == id[j]; j++)
 325           if (id[j] == 0 && name[j] == 0)       /* Match */
 326             return sound_drivers[i].card_type;
 327       }
 328 
 329   return 0;
 330 }
 331 
 332 void
 333 sound_setup (char *str, int *ints)
     /*  */
 334 {
 335   int             i, n = num_sound_cards;
 336 
 337   /*
 338      * First disable all drivers
 339    */
 340 
 341   for (i = 0; i < n && snd_installed_cards[i].card_type; i++)
 342     snd_installed_cards[i].enabled = 0;
 343 
 344   if (ints[0] == 0 || ints[1] == 0)
 345     return;
 346   /*
 347      * Then enable them one by time
 348    */
 349 
 350   for (i = 1; i <= ints[0]; i++)
 351     {
 352       int             card_type, ioaddr, irq, dma, ptr, j;
 353       unsigned int    val;
 354 
 355       val = (unsigned int) ints[i];
 356 
 357       card_type = (val & 0x0ff00000) >> 20;
 358 
 359       if (card_type > 127)
 360         {
 361           /*
 362            * Add any future extensions here
 363            */
 364           return;
 365         }
 366 
 367       ioaddr = (val & 0x000fff00) >> 8;
 368       irq = (val & 0x000000f0) >> 4;
 369       dma = (val & 0x0000000f);
 370 
 371       ptr = -1;
 372       for (j = 0; j < n && ptr == -1; j++)
 373         if (snd_installed_cards[j].card_type == card_type &&
 374             !snd_installed_cards[j].enabled)    /*
 375                                                  * Not already found
 376                                                  */
 377           ptr = j;
 378 
 379       if (ptr == -1)
 380         printk ("Sound: Invalid setup parameter 0x%08x\n", val);
 381       else
 382         {
 383           snd_installed_cards[ptr].enabled = 1;
 384           snd_installed_cards[ptr].config.io_base = ioaddr;
 385           snd_installed_cards[ptr].config.irq = irq;
 386           snd_installed_cards[ptr].config.dma = dma;
 387           snd_installed_cards[ptr].config.dma2 = -1;
 388           snd_installed_cards[ptr].config.name = NULL;
 389           snd_installed_cards[ptr].config.always_detect = 0;
 390           snd_installed_cards[ptr].config.driver_use_1 = 0;
 391           snd_installed_cards[ptr].config.driver_use_2 = 0;
 392           snd_installed_cards[ptr].config.card_subtype = 0;
 393           snd_installed_cards[ptr].config.osp = NULL;
 394         }
 395     }
 396 }
 397 
 398 
 399 struct address_info
 400                *
 401 sound_getconf (int card_type)
     /*  */
 402 {
 403   int             j, ptr;
 404   int             n = num_sound_cards;
 405 
 406   ptr = -1;
 407   for (j = 0; j < n && ptr == -1 && snd_installed_cards[j].card_type; j++)
 408     if (snd_installed_cards[j].card_type == card_type)
 409       ptr = j;
 410 
 411   if (ptr == -1)
 412     return (struct address_info *) NULL;
 413 
 414   return &snd_installed_cards[ptr].config;
 415 }
 416 
 417 
 418 
 419 #endif
/* */
root/drivers/sound/dev_table.c

DEFINITIONS
