drivers/sound/pas2_card.c

   1 /*
   2  * sound/pas2_card.c
   3  *
   4  * Detection routine for the Pro Audio Spectrum cards.
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/module.h>
   9 #include "sound_config.h"
  10 #include "soundmodule.h"
  11
  12 #ifdef CONFIG_PAS
  13
  14 static unsigned char dma_bits[] = {
  15         4, 1, 2, 3, 0, 5, 6, 7
  16 };
  17
  18 static unsigned char irq_bits[] = {
  19         0, 0, 1, 2, 3, 4, 5, 6, 0, 1, 7, 8, 9, 0, 10, 11
  20 };
  21
  22 static unsigned char sb_irq_bits[] = {
  23         0x00, 0x00, 0x08, 0x10, 0x00, 0x18, 0x00, 0x20,
  24         0x00, 0x08, 0x28, 0x30, 0x38, 0, 0
  25 };
  26
  27 static unsigned char sb_dma_bits[] = {
  28         0x00, 0x40, 0x80, 0xC0, 0, 0, 0, 0
  29 };
  30
  31 /*
  32  * The Address Translation code is used to convert I/O register addresses to
  33  * be relative to the given base -register
  34  */
  35
  36 int             translate_code = 0;
  37 static int      pas_intr_mask = 0;
  38 static int      pas_irq = 0;
  39 static int      pas_sb_base = 0;
  40 #ifndef CONFIG_PAS_JOYSTICK
  41 static int      joystick = 0;
  42 #else
  43 static int      joystick = 1;
  44 #endif
  45 #ifdef SYMPHONY_PAS
  46 static int      symphony = 1;
  47 #else
  48 static int      symphony = 0;
  49 #endif
  50 #ifdef BROKEN_BUS_CLOCK
  51 static int      broken_bus_clock = 1;
  52 #else
  53 static int      broken_bus_clock = 0;
  54 #endif
  55
  56
  57 char            pas_model = 0;
  58 static char    *pas_model_names[] = {
  59         "",
  60         "Pro AudioSpectrum+",
  61         "CDPC",
  62         "Pro AudioSpectrum 16",
  63         "Pro AudioSpectrum 16D"
  64 };
  65
  66 /*
  67  * pas_read() and pas_write() are equivalents of inb and outb
  68  * These routines perform the I/O address translation required
  69  * to support other than the default base address
  70  */
  71
  72 extern void     mix_write(unsigned char data, int ioaddr);
  73
  74 unsigned char pas_read(int ioaddr)
  75 {
  76         return inb(ioaddr + translate_code);
  77 }
  78
  79 void pas_write(unsigned char data, int ioaddr)
  80 {
  81         outb((data), ioaddr + translate_code);
  82 }
  83
  84 /******************* Begin of the Interrupt Handler ********************/
  85
  86 static void pasintr(int irq, void *dev_id, struct pt_regs *dummy)
  87 {
  88         int             status;
  89
  90         status = pas_read(0x0B89);
  91         pas_write(status, 0x0B89);      /* Clear interrupt */
  92
  93         if (status & 0x08)
  94         {
  95 #ifdef CONFIG_AUDIO
  96                   pas_pcm_interrupt(status, 1);
  97 #endif
  98                   status &= ~0x08;
  99         }
 100         if (status & 0x10)
 101         {
 102 #ifdef CONFIG_MIDI
 103                   pas_midi_interrupt();
 104 #endif
 105                   status &= ~0x10;
 106         }
 107 }
 108
 109 int pas_set_intr(int mask)
 110 {
 111         if (!mask)
 112                 return 0;
 113
 114         pas_intr_mask |= mask;
 115
 116         pas_write(pas_intr_mask, 0x0B8B);
 117         return 0;
 118 }
 119
 120 int pas_remove_intr(int mask)
 121 {
 122         if (!mask)
 123                 return 0;
 124
 125         pas_intr_mask &= ~mask;
 126         pas_write(pas_intr_mask, 0x0B8B);
 127
 128         return 0;
 129 }
 130
 131 /******************* End of the Interrupt handler **********************/
 132
 133 /******************* Begin of the Initialization Code ******************/
 134
 135 extern struct address_info sbhw_config;
 136
 137 static int config_pas_hw(struct address_info *hw_config)
 138 {
 139         char            ok = 1;
 140         unsigned        int_ptrs;       /* scsi/sound interrupt pointers */
 141
 142         pas_irq = hw_config->irq;
 143
 144         pas_write(0x00, 0x0B8B);
 145         pas_write(0x36, 0x138B);
 146         pas_write(0x36, 0x1388);
 147         pas_write(0, 0x1388);
 148         pas_write(0x74, 0x138B);
 149         pas_write(0x74, 0x1389);
 150         pas_write(0, 0x1389);
 151
 152         pas_write(0x80 | 0x40 | 0x20 | 1, 0x0B8A);
 153         pas_write(0x80 | 0x20 | 0x10 | 0x08 | 0x01, 0xF8A);
 154         pas_write(0x01 | 0x02 | 0x04 | 0x10     /*
 155                                                  * |
 156                                                  * 0x80
 157                                                  */ , 0xB88);
 158
 159         pas_write(0x80
 160                   | joystick?0x40:0
 161                   ,0xF388);
 162
 163         if (pas_irq < 0 || pas_irq > 15)
 164         {
 165                 printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
 166                 hw_config->irq=-1;
 167                 ok = 0;
 168         }
 169         else
 170         {
 171                 int_ptrs = pas_read(0xF38A);
 172                 int_ptrs = (int_ptrs & 0xf0) | irq_bits[pas_irq];
 173                 pas_write(int_ptrs, 0xF38A);
 174                 if (!irq_bits[pas_irq])
 175                 {
 176                         printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
 177                         hw_config->irq=-1;
 178                         ok = 0;
 179                 }
 180                 else
 181                 {
 182                         if (request_irq(pas_irq, pasintr, 0, "PAS16",hw_config) < 0) {
 183                                 printk(KERN_ERR "PAS16: Cannot allocate IRQ %d\n",pas_irq);
 184                                 hw_config->irq=-1;
 185                                 ok = 0;
 186                         }
 187                 }
 188         }
 189
 190         if (hw_config->dma < 0 || hw_config->dma > 7)
 191         {
 192                 printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
 193                 hw_config->dma=-1;
 194                 ok = 0;
 195         }
 196         else
 197         {
 198                 pas_write(dma_bits[hw_config->dma], 0xF389);
 199                 if (!dma_bits[hw_config->dma])
 200                 {
 201                         printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
 202                         hw_config->dma=-1;
 203                         ok = 0;
 204                 }
 205                 else
 206                 {
 207                         if (sound_alloc_dma(hw_config->dma, "PAS16"))
 208                         {
 209                                 printk(KERN_ERR "pas2_card.c: Can't allocate DMA channel\n");
 210                                 hw_config->dma=-1;
 211                                 ok = 0;
 212                         }
 213                 }
 214         }
 215
 216         /*
 217          * This fixes the timing problems of the PAS due to the Symphony chipset
 218          * as per Media Vision.  Only define this if your PAS doesn't work correctly.
 219          */
 220
 221         if(symphony)
 222         {
 223                 outb((0x05), 0xa8);
 224                 outb((0x60), 0xa9);
 225         }
 226
 227         if(broken_bus_clock)
 228                 pas_write(0x01 | 0x10 | 0x20 | 0x04, 0x8388);
 229         else
 230                 /*
 231                  * pas_write(0x01, 0x8388);
 232                  */
 233                 pas_write(0x01 | 0x10 | 0x20, 0x8388);
 234
 235         pas_write(0x18, 0x838A);        /* ??? */
 236         pas_write(0x20 | 0x01, 0x0B8A);         /* Mute off, filter = 17.897 kHz */
 237         pas_write(8, 0xBF8A);
 238
 239         mix_write(0x80 | 5, 0x078B);
 240         mix_write(5, 0x078B);
 241
 242 #if !defined(DISABLE_SB_EMULATION) && defined(CONFIG_SB)
 243
 244         {
 245                 struct address_info *sb_config;
 246
 247 #ifndef MODULE
 248                 if ((sb_config = sound_getconf(SNDCARD_SB)))
 249 #else
 250                 sb_config = &sbhw_config;
 251                 if (sb_config->io_base)
 252 #endif
 253                 {
 254                         unsigned char   irq_dma;
 255
 256                         /*
 257                          * Turn on Sound Blaster compatibility
 258                          * bit 1 = SB emulation
 259                          * bit 0 = MPU401 emulation (CDPC only :-( )
 260                          */
 261
 262                         pas_write(0x02, 0xF788);
 263
 264                         /*
 265                          * "Emulation address"
 266                          */
 267
 268                         pas_write((sb_config->io_base >> 4) & 0x0f, 0xF789);
 269                         pas_sb_base = sb_config->io_base;
 270
 271                         if (!sb_dma_bits[sb_config->dma])
 272                                 printk(KERN_ERR "PAS16 Warning: Invalid SB DMA %d\n\n", sb_config->dma);
 273
 274                         if (!sb_irq_bits[sb_config->irq])
 275                                 printk(KERN_ERR "PAS16 Warning: Invalid SB IRQ %d\n\n", sb_config->irq);
 276
 277                         irq_dma = sb_dma_bits[sb_config->dma] |
 278                                 sb_irq_bits[sb_config->irq];
 279
 280                         pas_write(irq_dma, 0xFB8A);
 281                 }
 282                 else
 283                         pas_write(0x00, 0xF788);
 284         }
 285 #else
 286         pas_write(0x00, 0xF788);
 287 #endif
 288
 289         if (!ok)
 290                 printk(KERN_WARNING "PAS16: Driver not enabled\n");
 291
 292         return ok;
 293 }
 294
 295 static int detect_pas_hw(struct address_info *hw_config)
 296 {
 297         unsigned char   board_id, foo;
 298
 299         /*
 300          * WARNING: Setting an option like W:1 or so that disables warm boot reset
 301          * of the card will screw up this detect code something fierce. Adding code
 302          * to handle this means possibly interfering with other cards on the bus if
 303          * you have something on base port 0x388. SO be forewarned.
 304          */
 305
 306         outb((0xBC), 0x9A01);   /* Activate first board */
 307         outb((hw_config->io_base >> 2), 0x9A01);        /* Set base address */
 308         translate_code = hw_config->io_base - 0x388;
 309         pas_write(1, 0xBF88);   /* Select one wait states */
 310
 311         board_id = pas_read(0x0B8B);
 312
 313         if (board_id == 0xff)
 314                 return 0;
 315
 316         /*
 317          * We probably have a PAS-series board, now check for a PAS16-series board
 318          * by trying to change the board revision bits. PAS16-series hardware won't
 319          * let you do this - the bits are read-only.
 320          */
 321
 322         foo = board_id ^ 0xe0;
 323
 324         pas_write(foo, 0x0B8B);
 325         foo = pas_read(0x0B8B);
 326         pas_write(board_id, 0x0B8B);
 327
 328         if (board_id != foo)
 329                 return 0;
 330
 331         pas_model = pas_read(0xFF88);
 332
 333         return pas_model;
 334 }
 335
 336 void attach_pas_card(struct address_info *hw_config)
 337 {
 338         pas_irq = hw_config->irq;
 339
 340         if (detect_pas_hw(hw_config))
 341         {
 342
 343                 if ((pas_model = pas_read(0xFF88)))
 344                 {
 345                         char            temp[100];
 346
 347                         sprintf(temp,
 348                             "%s rev %d", pas_model_names[(int) pas_model],
 349                                     pas_read(0x2789));
 350                         conf_printf(temp, hw_config);
 351                 }
 352                 if (config_pas_hw(hw_config))
 353                 {
 354 #ifdef CONFIG_AUDIO
 355                         pas_pcm_init(hw_config);
 356 #endif
 357
 358 #if !defined(MODULE) && !defined(DISABLE_SB_EMULATION) && defined(CONFIG_SB)
 359
 360                         sb_dsp_disable_midi(pas_sb_base);       /* No MIDI capability */
 361 #endif
 362
 363 #ifdef CONFIG_MIDI
 364                         pas_midi_init();
 365 #endif
 366                         pas_init_mixer();
 367                 }
 368         }
 369 }
 370
 371 int probe_pas(struct address_info *hw_config)
 372 {
 373         return detect_pas_hw(hw_config);
 374 }
 375
 376 void unload_pas(struct address_info *hw_config)
 377 {
 378         extern int pas_audiodev;
 379         extern int pas2_mididev;
 380
 381         if (hw_config->dma>0)
 382                 sound_free_dma(hw_config->dma);
 383         if (hw_config->irq>0)
 384                 free_irq(hw_config->irq, hw_config);
 385
 386         if(pas_audiodev!=-1)
 387                 sound_unload_mixerdev(audio_devs[pas_audiodev]->mixer_dev);
 388         if(pas2_mididev!=-1)
 389                 sound_unload_mididev(pas2_mididev);
 390         if(pas_audiodev!=-1)
 391                 sound_unload_audiodev(pas_audiodev);
 392 }
 393
 394 #ifdef MODULE
 395
 396 int             io = -1;
 397 int             irq = -1;
 398 int             dma = -1;
 399 int             dma16 = -1;     /* Set this for modules that need it */
 400
 401 int             sb_io = 0;
 402 int             sb_irq = -1;
 403 int             sb_dma = -1;
 404 int             sb_dma16 = -1;
 405
 406 MODULE_PARM(io,"i");
 407 MODULE_PARM(irq,"i");
 408 MODULE_PARM(dma,"i");
 409 MODULE_PARM(dma16,"i");
 410
 411 MODULE_PARM(sb_io,"i");
 412 MODULE_PARM(sb_irq,"i");
 413 MODULE_PARM(sb_dma,"i");
 414 MODULE_PARM(sb_dma16,"i");
 415
 416 MODULE_PARM(joystick,"i");
 417 MODULE_PARM(symphony,"i");
 418 MODULE_PARM(broken_bus_clock,"i");
 419
 420 struct address_info config;
 421 struct address_info sbhw_config;
 422
 423 int init_module(void)
 424 {
 425         printk(KERN_INFO "Pro Audio Spectrum driver Copyright (C) by Hannu Savolainen 1993-1996\n");
 426
 427         if (io == -1 || dma == -1 || irq == -1)
 428         {
 429                   printk(KERN_INFO "I/O, IRQ, DMA and type are mandatory\n");
 430                   return -EINVAL;
 431         }
 432         config.io_base = io;
 433         config.irq = irq;
 434         config.dma = dma;
 435         config.dma2 = dma16;
 436
 437         sbhw_config.io_base = sb_io;
 438         sbhw_config.irq = sb_irq;
 439         sbhw_config.dma = sb_dma;
 440         sbhw_config.dma2 = sb_dma16;
 441
 442         if (!probe_pas(&config))
 443                 return -ENODEV;
 444         attach_pas_card(&config);
 445         SOUND_LOCK;
 446         return 0;
 447 }
 448
 449 void cleanup_module(void)
 450 {
 451         unload_pas(&config);
 452         SOUND_LOCK_END;
 453 }
 454
 455
 456 #endif
 457 #endif