git.oblomov.eu Git - linux-2.6/blob - sound/isa/sb/sb8_main.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
   3  *                   Uros Bizjak <uros@kss-loka.si>
   4  *
   5  *  Routines for control of 8-bit SoundBlaster cards and clones
   6  *  Please note: I don't have access to old SB8 soundcards.
   7  *
   8  *
   9  *   This program is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation; either version 2 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This program is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with this program; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  22  *
  23  * --
  24  *
  25  * Thu Apr 29 20:36:17 BST 1999 George David Morrison <gdm@gedamo.demon.co.uk>
  26  *   DSP can't respond to commands whilst in "high speed" mode. Caused
  27  *   glitching during playback. Fixed.
  28  *
  29  * Wed Jul 12 22:02:55 CEST 2000 Uros Bizjak <uros@kss-loka.si>
  30  *   Cleaned up and rewrote lowlevel routines.
  31  */
  32
  33 #include <sound/driver.h>
  34 #include <asm/io.h>
  35 #include <asm/dma.h>
  36 #include <linux/init.h>
  37 #include <linux/time.h>
  38 #include <sound/core.h>
  39 #include <sound/sb.h>
  40
  41 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Uros Bizjak <uros@kss-loka.si>");
  42 MODULE_DESCRIPTION("Routines for control of 8-bit SoundBlaster cards and clones");
  43 MODULE_LICENSE("GPL");
  44
  45 #define SB8_CLOCK       1000000
  46 #define SB8_DEN(v)      ((SB8_CLOCK + (v) / 2) / (v))
  47 #define SB8_RATE(v)     (SB8_CLOCK / SB8_DEN(v))
  48
  49 static struct snd_ratnum clock = {
  50         .num = SB8_CLOCK,
  51         .den_min = 1,
  52         .den_max = 256,
  53         .den_step = 1,
  54 };
  55
  56 static struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = {
  57         .nrats = 1,
  58         .rats = &clock,
  59 };
  60
  61 static struct snd_ratnum stereo_clocks[] = {
  62         {
  63                 .num = SB8_CLOCK,
  64                 .den_min = SB8_DEN(22050),
  65                 .den_max = SB8_DEN(22050),
  66                 .den_step = 1,
  67         },
  68         {
  69                 .num = SB8_CLOCK,
  70                 .den_min = SB8_DEN(11025),
  71                 .den_max = SB8_DEN(11025),
  72                 .den_step = 1,
  73         }
  74 };
  75
  76 static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params,
  77                                                struct snd_pcm_hw_rule *rule)
  78 {
  79         struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  80         if (c->min > 1) {
  81                 unsigned int num = 0, den = 0;
  82                 int err = snd_interval_ratnum(hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE),
  83                                           2, stereo_clocks, &num, &den);
  84                 if (err >= 0 && den) {
  85                         params->rate_num = num;
  86                         params->rate_den = den;
  87                 }
  88                 return err;
  89         }
  90         return 0;
  91 }
  92
  93 static int snd_sb8_hw_constraint_channels_rate(struct snd_pcm_hw_params *params,
  94                                                struct snd_pcm_hw_rule *rule)
  95 {
  96         struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
  97         if (r->min > SB8_RATE(22050) || r->max <= SB8_RATE(11025)) {
  98                 struct snd_interval t = { .min = 1, .max = 1 };
  99                 return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t);
 100         }
 101         return 0;
 102 }
 103
 104 static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
 105 {
 106         unsigned long flags;
 107         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 108         struct snd_pcm_runtime *runtime = substream->runtime;
 109         unsigned int mixreg, rate, size, count;
 110
 111         rate = runtime->rate;
 112         switch (chip->hardware) {
 113         case SB_HW_PRO:
 114                 if (runtime->channels > 1) {
 115                         snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL);
 116                         chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;
 117                         break;
 118                 }
 119                 /* fallthru */
 120         case SB_HW_201:
 121                 if (rate > 23000) {
 122                         chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;
 123                         break;
 124                 }
 125                 /* fallthru */
 126         case SB_HW_20:
 127                 chip->playback_format = SB_DSP_LO_OUTPUT_AUTO;
 128                 break;
 129         case SB_HW_10:
 130                 chip->playback_format = SB_DSP_OUTPUT;
 131                 break;
 132         default:
 133                 return -EINVAL;
 134         }
 135         size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream);
 136         count = chip->p_period_size = snd_pcm_lib_period_bytes(substream);
 137         spin_lock_irqsave(&chip->reg_lock, flags);
 138         snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON);
 139         if (runtime->channels > 1) {
 140                 /* set playback stereo mode */
 141                 spin_lock(&chip->mixer_lock);
 142                 mixreg = snd_sbmixer_read(chip, SB_DSP_STEREO_SW);
 143                 snd_sbmixer_write(chip, SB_DSP_STEREO_SW, mixreg | 0x02);
 144                 spin_unlock(&chip->mixer_lock);
 145
 146                 /* Soundblaster hardware programming reference guide, 3-23 */
 147                 snd_sbdsp_command(chip, SB_DSP_DMA8_EXIT);
 148                 runtime->dma_area[0] = 0x80;
 149                 snd_dma_program(chip->dma8, runtime->dma_addr, 1, DMA_MODE_WRITE);
 150                 /* force interrupt */
 151                 chip->mode = SB_MODE_HALT;
 152                 snd_sbdsp_command(chip, SB_DSP_OUTPUT);
 153                 snd_sbdsp_command(chip, 0);
 154                 snd_sbdsp_command(chip, 0);
 155         }
 156         snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
 157         if (runtime->channels > 1) {
 158                 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
 159                 spin_lock(&chip->mixer_lock);
 160                 /* save output filter status and turn it off */
 161                 mixreg = snd_sbmixer_read(chip, SB_DSP_PLAYBACK_FILT);
 162                 snd_sbmixer_write(chip, SB_DSP_PLAYBACK_FILT, mixreg | 0x20);
 163                 spin_unlock(&chip->mixer_lock);
 164                 /* just use force_mode16 for temporary storate... */
 165                 chip->force_mode16 = mixreg;
 166         } else {
 167                 snd_sbdsp_command(chip, 256 - runtime->rate_den);
 168         }
 169         if (chip->playback_format != SB_DSP_OUTPUT) {
 170                 count--;
 171                 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
 172                 snd_sbdsp_command(chip, count & 0xff);
 173                 snd_sbdsp_command(chip, count >> 8);
 174         }
 175         spin_unlock_irqrestore(&chip->reg_lock, flags);
 176         snd_dma_program(chip->dma8, runtime->dma_addr,
 177                         size, DMA_MODE_WRITE | DMA_AUTOINIT);
 178         return 0;
 179 }
 180
 181 static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream,
 182                                     int cmd)
 183 {
 184         unsigned long flags;
 185         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 186         unsigned int count;
 187
 188         spin_lock_irqsave(&chip->reg_lock, flags);
 189         switch (cmd) {
 190         case SNDRV_PCM_TRIGGER_START:
 191                 snd_sbdsp_command(chip, chip->playback_format);
 192                 if (chip->playback_format == SB_DSP_OUTPUT) {
 193                         count = chip->p_period_size - 1;
 194                         snd_sbdsp_command(chip, count & 0xff);
 195                         snd_sbdsp_command(chip, count >> 8);
 196                 }
 197                 break;
 198         case SNDRV_PCM_TRIGGER_STOP:
 199                 if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) {
 200                         struct snd_pcm_runtime *runtime = substream->runtime;
 201                         snd_sbdsp_reset(chip);
 202                         if (runtime->channels > 1) {
 203                                 spin_lock(&chip->mixer_lock);
 204                                 /* restore output filter and set hardware to mono mode */
 205                                 snd_sbmixer_write(chip, SB_DSP_STEREO_SW, chip->force_mode16 & ~0x02);
 206                                 spin_unlock(&chip->mixer_lock);
 207                         }
 208                 } else {
 209                         snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
 210                 }
 211                 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
 212         }
 213         spin_unlock_irqrestore(&chip->reg_lock, flags);
 214         chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_PLAYBACK_8 : SB_MODE_HALT;
 215         return 0;
 216 }
 217
 218 static int snd_sb8_hw_params(struct snd_pcm_substream *substream,
 219                              struct snd_pcm_hw_params *hw_params)
 220 {
 221         return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 222 }
 223
 224 static int snd_sb8_hw_free(struct snd_pcm_substream *substream)
 225 {
 226         snd_pcm_lib_free_pages(substream);
 227         return 0;
 228 }
 229
 230 static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)
 231 {
 232         unsigned long flags;
 233         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 234         struct snd_pcm_runtime *runtime = substream->runtime;
 235         unsigned int mixreg, rate, size, count;
 236
 237         rate = runtime->rate;
 238         switch (chip->hardware) {
 239         case SB_HW_PRO:
 240                 if (runtime->channels > 1) {
 241                         snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL);
 242                         chip->capture_format = SB_DSP_HI_INPUT_AUTO;
 243                         break;
 244                 }
 245                 chip->capture_format = (rate > 23000) ? SB_DSP_HI_INPUT_AUTO : SB_DSP_LO_INPUT_AUTO;
 246                 break;
 247         case SB_HW_201:
 248                 if (rate > 13000) {
 249                         chip->capture_format = SB_DSP_HI_INPUT_AUTO;
 250                         break;
 251                 }
 252                 /* fallthru */
 253         case SB_HW_20:
 254                 chip->capture_format = SB_DSP_LO_INPUT_AUTO;
 255                 break;
 256         case SB_HW_10:
 257                 chip->capture_format = SB_DSP_INPUT;
 258                 break;
 259         default:
 260                 return -EINVAL;
 261         }
 262         size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream);
 263         count = chip->c_period_size = snd_pcm_lib_period_bytes(substream);
 264         spin_lock_irqsave(&chip->reg_lock, flags);
 265         snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
 266         if (runtime->channels > 1)
 267                 snd_sbdsp_command(chip, SB_DSP_STEREO_8BIT);
 268         snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
 269         if (runtime->channels > 1) {
 270                 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
 271                 spin_lock(&chip->mixer_lock);
 272                 /* save input filter status and turn it off */
 273                 mixreg = snd_sbmixer_read(chip, SB_DSP_CAPTURE_FILT);
 274                 snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, mixreg | 0x20);
 275                 spin_unlock(&chip->mixer_lock);
 276                 /* just use force_mode16 for temporary storate... */
 277                 chip->force_mode16 = mixreg;
 278         } else {
 279                 snd_sbdsp_command(chip, 256 - runtime->rate_den);
 280         }
 281         if (chip->capture_format != SB_DSP_OUTPUT) {
 282                 count--;
 283                 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
 284                 snd_sbdsp_command(chip, count & 0xff);
 285                 snd_sbdsp_command(chip, count >> 8);
 286         }
 287         spin_unlock_irqrestore(&chip->reg_lock, flags);
 288         snd_dma_program(chip->dma8, runtime->dma_addr,
 289                         size, DMA_MODE_READ | DMA_AUTOINIT);
 290         return 0;
 291 }
 292
 293 static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream,
 294                                    int cmd)
 295 {
 296         unsigned long flags;
 297         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 298         unsigned int count;
 299
 300         spin_lock_irqsave(&chip->reg_lock, flags);
 301         switch (cmd) {
 302         case SNDRV_PCM_TRIGGER_START:
 303                 snd_sbdsp_command(chip, chip->capture_format);
 304                 if (chip->capture_format == SB_DSP_INPUT) {
 305                         count = chip->c_period_size - 1;
 306                         snd_sbdsp_command(chip, count & 0xff);
 307                         snd_sbdsp_command(chip, count >> 8);
 308                 }
 309                 break;
 310         case SNDRV_PCM_TRIGGER_STOP:
 311                 if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) {
 312                         struct snd_pcm_runtime *runtime = substream->runtime;
 313                         snd_sbdsp_reset(chip);
 314                         if (runtime->channels > 1) {
 315                                 /* restore input filter status */
 316                                 spin_lock(&chip->mixer_lock);
 317                                 snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, chip->force_mode16);
 318                                 spin_unlock(&chip->mixer_lock);
 319                                 /* set hardware to mono mode */
 320                                 snd_sbdsp_command(chip, SB_DSP_MONO_8BIT);
 321                         }
 322                 } else {
 323                         snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
 324                 }
 325                 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
 326         }
 327         spin_unlock_irqrestore(&chip->reg_lock, flags);
 328         chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_CAPTURE_8 : SB_MODE_HALT;
 329         return 0;
 330 }
 331
 332 irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip)
 333 {
 334         struct snd_pcm_substream *substream;
 335         struct snd_pcm_runtime *runtime;
 336
 337         snd_sb_ack_8bit(chip);
 338         switch (chip->mode) {
 339         case SB_MODE_PLAYBACK_8:        /* ok.. playback is active */
 340                 substream = chip->playback_substream;
 341                 runtime = substream->runtime;
 342                 if (chip->playback_format == SB_DSP_OUTPUT)
 343                         snd_sb8_playback_trigger(substream, SNDRV_PCM_TRIGGER_START);
 344                 snd_pcm_period_elapsed(substream);
 345                 break;
 346         case SB_MODE_CAPTURE_8:
 347                 substream = chip->capture_substream;
 348                 runtime = substream->runtime;
 349                 if (chip->capture_format == SB_DSP_INPUT)
 350                         snd_sb8_capture_trigger(substream, SNDRV_PCM_TRIGGER_START);
 351                 snd_pcm_period_elapsed(substream);
 352                 break;
 353         }
 354         return IRQ_HANDLED;
 355 }
 356
 357 static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream)
 358 {
 359         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 360         size_t ptr;
 361
 362         if (chip->mode != SB_MODE_PLAYBACK_8)
 363                 return 0;
 364         ptr = snd_dma_pointer(chip->dma8, chip->p_dma_size);
 365         return bytes_to_frames(substream->runtime, ptr);
 366 }
 367
 368 static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream)
 369 {
 370         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 371         size_t ptr;
 372
 373         if (chip->mode != SB_MODE_CAPTURE_8)
 374                 return 0;
 375         ptr = snd_dma_pointer(chip->dma8, chip->c_dma_size);
 376         return bytes_to_frames(substream->runtime, ptr);
 377 }
 378
 379 /*
 380
 381  */
 382
 383 static struct snd_pcm_hardware snd_sb8_playback =
 384 {
 385         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 386                                  SNDRV_PCM_INFO_MMAP_VALID),
 387         .formats =               SNDRV_PCM_FMTBIT_U8,
 388         .rates =                (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 |
 389                                  SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_22050),
 390         .rate_min =             4000,
 391         .rate_max =             23000,
 392         .channels_min =         1,
 393         .channels_max =         1,
 394         .buffer_bytes_max =     65536,
 395         .period_bytes_min =     64,
 396         .period_bytes_max =     65536,
 397         .periods_min =          1,
 398         .periods_max =          1024,
 399         .fifo_size =            0,
 400 };
 401
 402 static struct snd_pcm_hardware snd_sb8_capture =
 403 {
 404         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 405                                  SNDRV_PCM_INFO_MMAP_VALID),
 406         .formats =              SNDRV_PCM_FMTBIT_U8,
 407         .rates =                (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 |
 408                                  SNDRV_PCM_RATE_11025),
 409         .rate_min =             4000,
 410         .rate_max =             13000,
 411         .channels_min =         1,
 412         .channels_max =         1,
 413         .buffer_bytes_max =     65536,
 414         .period_bytes_min =     64,
 415         .period_bytes_max =     65536,
 416         .periods_min =          1,
 417         .periods_max =          1024,
 418         .fifo_size =            0,
 419 };
 420
 421 /*
 422  *
 423  */
 424
 425 static int snd_sb8_open(struct snd_pcm_substream *substream)
 426 {
 427         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 428         struct snd_pcm_runtime *runtime = substream->runtime;
 429         unsigned long flags;
 430
 431         spin_lock_irqsave(&chip->open_lock, flags);
 432         if (chip->open) {
 433                 spin_unlock_irqrestore(&chip->open_lock, flags);
 434                 return -EAGAIN;
 435         }
 436         chip->open |= SB_OPEN_PCM;
 437         spin_unlock_irqrestore(&chip->open_lock, flags);
 438         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 439                 chip->playback_substream = substream;
 440                 runtime->hw = snd_sb8_playback;
 441         } else {
 442                 chip->capture_substream = substream;
 443                 runtime->hw = snd_sb8_capture;
 444         }
 445         switch (chip->hardware) {
 446         case SB_HW_PRO:
 447                 runtime->hw.rate_max = 44100;
 448                 runtime->hw.channels_max = 2;
 449                 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 450                                     snd_sb8_hw_constraint_rate_channels, NULL,
 451                                     SNDRV_PCM_HW_PARAM_CHANNELS,
 452                                     SNDRV_PCM_HW_PARAM_RATE, -1);
 453                 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 454                                      snd_sb8_hw_constraint_channels_rate, NULL,
 455                                      SNDRV_PCM_HW_PARAM_RATE, -1);
 456                 break;
 457         case SB_HW_201:
 458                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 459                         runtime->hw.rate_max = 44100;
 460                 } else {
 461                         runtime->hw.rate_max = 15000;
 462                 }
 463         default:
 464                 break;
 465         }
 466         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 467                                       &hw_constraints_clock);
 468         return 0;
 469 }
 470
 471 static int snd_sb8_close(struct snd_pcm_substream *substream)
 472 {
 473         unsigned long flags;
 474         struct snd_sb *chip = snd_pcm_substream_chip(substream);
 475
 476         chip->playback_substream = NULL;
 477         chip->capture_substream = NULL;
 478         spin_lock_irqsave(&chip->open_lock, flags);
 479         chip->open &= ~SB_OPEN_PCM;
 480         spin_unlock_irqrestore(&chip->open_lock, flags);
 481         return 0;
 482 }
 483
 484 /*
 485  *  Initialization part
 486  */
 487
 488 static struct snd_pcm_ops snd_sb8_playback_ops = {
 489         .open =                 snd_sb8_open,
 490         .close =                snd_sb8_close,
 491         .ioctl =                snd_pcm_lib_ioctl,
 492         .hw_params =            snd_sb8_hw_params,
 493         .hw_free =              snd_sb8_hw_free,
 494         .prepare =              snd_sb8_playback_prepare,
 495         .trigger =              snd_sb8_playback_trigger,
 496         .pointer =              snd_sb8_playback_pointer,
 497 };
 498
 499 static struct snd_pcm_ops snd_sb8_capture_ops = {
 500         .open =                 snd_sb8_open,
 501         .close =                snd_sb8_close,
 502         .ioctl =                snd_pcm_lib_ioctl,
 503         .hw_params =            snd_sb8_hw_params,
 504         .hw_free =              snd_sb8_hw_free,
 505         .prepare =              snd_sb8_capture_prepare,
 506         .trigger =              snd_sb8_capture_trigger,
 507         .pointer =              snd_sb8_capture_pointer,
 508 };
 509
 510 int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
 511 {
 512         struct snd_card *card = chip->card;
 513         struct snd_pcm *pcm;
 514         int err;
 515
 516         if (rpcm)
 517                 *rpcm = NULL;
 518         if ((err = snd_pcm_new(card, "SB8 DSP", device, 1, 1, &pcm)) < 0)
 519                 return err;
 520         sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);
 521         pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
 522         pcm->private_data = chip;
 523
 524         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops);
 525         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops);
 526
 527         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
 528                                               snd_dma_isa_data(),
 529                                               64*1024, 64*1024);
 530
 531         if (rpcm)
 532                 *rpcm = pcm;
 533         return 0;
 534 }
 535
 536 EXPORT_SYMBOL(snd_sb8dsp_pcm);
 537 EXPORT_SYMBOL(snd_sb8dsp_interrupt);
 538   /* sb8_midi.c */
 539 EXPORT_SYMBOL(snd_sb8dsp_midi_interrupt);
 540 EXPORT_SYMBOL(snd_sb8dsp_midi);
 541
 542 /*
 543  *  INIT part
 544  */
 545
 546 static int __init alsa_sb8_init(void)
 547 {
 548         return 0;
 549 }
 550
 551 static void __exit alsa_sb8_exit(void)
 552 {
 553 }
 554
 555 module_init(alsa_sb8_init)
 556 module_exit(alsa_sb8_exit)