1 /* 2 * Copyright (c) by Jaroslav Kysela <perex@perex.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 <linux/io.h> 34 #include <asm/dma.h> 35 #include <linux/init.h> 36 #include <linux/time.h> 37 #include <linux/module.h> 38 #include <sound/core.h> 39 #include <sound/sb.h> 40 41 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.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 const struct snd_ratnum clock = { 50 .num = SB8_CLOCK, 51 .den_min = 1, 52 .den_max = 256, 53 .den_step = 1, 54 }; 55 56 static const struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = { 57 .nrats = 1, 58 .rats = &clock, 59 }; 60 61 static const 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 unsigned char format; 111 unsigned char stereo = runtime->channels > 1; 112 int dma; 113 114 rate = runtime->rate; 115 switch (chip->hardware) { 116 case SB_HW_JAZZ16: 117 if (runtime->format == SNDRV_PCM_FORMAT_S16_LE) { 118 if (chip->mode & SB_MODE_CAPTURE_16) 119 return -EBUSY; 120 else 121 chip->mode |= SB_MODE_PLAYBACK_16; 122 } 123 chip->playback_format = SB_DSP_LO_OUTPUT_AUTO; 124 break; 125 case SB_HW_PRO: 126 if (runtime->channels > 1) { 127 if (snd_BUG_ON(rate != SB8_RATE(11025) && 128 rate != SB8_RATE(22050))) 129 return -EINVAL; 130 chip->playback_format = SB_DSP_HI_OUTPUT_AUTO; 131 break; 132 } 133 /* fallthru */ 134 case SB_HW_201: 135 if (rate > 23000) { 136 chip->playback_format = SB_DSP_HI_OUTPUT_AUTO; 137 break; 138 } 139 /* fallthru */ 140 case SB_HW_20: 141 chip->playback_format = SB_DSP_LO_OUTPUT_AUTO; 142 break; 143 case SB_HW_10: 144 chip->playback_format = SB_DSP_OUTPUT; 145 break; 146 default: 147 return -EINVAL; 148 } 149 if (chip->mode & SB_MODE_PLAYBACK_16) { 150 format = stereo ? SB_DSP_STEREO_16BIT : SB_DSP_MONO_16BIT; 151 dma = chip->dma16; 152 } else { 153 format = stereo ? SB_DSP_STEREO_8BIT : SB_DSP_MONO_8BIT; 154 chip->mode |= SB_MODE_PLAYBACK_8; 155 dma = chip->dma8; 156 } 157 size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream); 158 count = chip->p_period_size = snd_pcm_lib_period_bytes(substream); 159 spin_lock_irqsave(&chip->reg_lock, flags); 160 snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON); 161 if (chip->hardware == SB_HW_JAZZ16) 162 snd_sbdsp_command(chip, format); 163 else if (stereo) { 164 /* set playback stereo mode */ 165 spin_lock(&chip->mixer_lock); 166 mixreg = snd_sbmixer_read(chip, SB_DSP_STEREO_SW); 167 snd_sbmixer_write(chip, SB_DSP_STEREO_SW, mixreg | 0x02); 168 spin_unlock(&chip->mixer_lock); 169 170 /* Soundblaster hardware programming reference guide, 3-23 */ 171 snd_sbdsp_command(chip, SB_DSP_DMA8_EXIT); 172 runtime->dma_area[0] = 0x80; 173 snd_dma_program(dma, runtime->dma_addr, 1, DMA_MODE_WRITE); 174 /* force interrupt */ 175 snd_sbdsp_command(chip, SB_DSP_OUTPUT); 176 snd_sbdsp_command(chip, 0); 177 snd_sbdsp_command(chip, 0); 178 } 179 snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE); 180 if (stereo) { 181 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2); 182 spin_lock(&chip->mixer_lock); 183 /* save output filter status and turn it off */ 184 mixreg = snd_sbmixer_read(chip, SB_DSP_PLAYBACK_FILT); 185 snd_sbmixer_write(chip, SB_DSP_PLAYBACK_FILT, mixreg | 0x20); 186 spin_unlock(&chip->mixer_lock); 187 /* just use force_mode16 for temporary storate... */ 188 chip->force_mode16 = mixreg; 189 } else { 190 snd_sbdsp_command(chip, 256 - runtime->rate_den); 191 } 192 if (chip->playback_format != SB_DSP_OUTPUT) { 193 if (chip->mode & SB_MODE_PLAYBACK_16) 194 count /= 2; 195 count--; 196 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE); 197 snd_sbdsp_command(chip, count & 0xff); 198 snd_sbdsp_command(chip, count >> 8); 199 } 200 spin_unlock_irqrestore(&chip->reg_lock, flags); 201 snd_dma_program(dma, runtime->dma_addr, 202 size, DMA_MODE_WRITE | DMA_AUTOINIT); 203 return 0; 204 } 205 206 static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream, 207 int cmd) 208 { 209 unsigned long flags; 210 struct snd_sb *chip = snd_pcm_substream_chip(substream); 211 unsigned int count; 212 213 spin_lock_irqsave(&chip->reg_lock, flags); 214 switch (cmd) { 215 case SNDRV_PCM_TRIGGER_START: 216 snd_sbdsp_command(chip, chip->playback_format); 217 if (chip->playback_format == SB_DSP_OUTPUT) { 218 count = chip->p_period_size - 1; 219 snd_sbdsp_command(chip, count & 0xff); 220 snd_sbdsp_command(chip, count >> 8); 221 } 222 break; 223 case SNDRV_PCM_TRIGGER_STOP: 224 if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) { 225 struct snd_pcm_runtime *runtime = substream->runtime; 226 snd_sbdsp_reset(chip); 227 if (runtime->channels > 1) { 228 spin_lock(&chip->mixer_lock); 229 /* restore output filter and set hardware to mono mode */ 230 snd_sbmixer_write(chip, SB_DSP_STEREO_SW, chip->force_mode16 & ~0x02); 231 spin_unlock(&chip->mixer_lock); 232 } 233 } else { 234 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF); 235 } 236 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF); 237 } 238 spin_unlock_irqrestore(&chip->reg_lock, flags); 239 return 0; 240 } 241 242 static int snd_sb8_hw_params(struct snd_pcm_substream *substream, 243 struct snd_pcm_hw_params *hw_params) 244 { 245 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); 246 } 247 248 static int snd_sb8_hw_free(struct snd_pcm_substream *substream) 249 { 250 snd_pcm_lib_free_pages(substream); 251 return 0; 252 } 253 254 static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream) 255 { 256 unsigned long flags; 257 struct snd_sb *chip = snd_pcm_substream_chip(substream); 258 struct snd_pcm_runtime *runtime = substream->runtime; 259 unsigned int mixreg, rate, size, count; 260 unsigned char format; 261 unsigned char stereo = runtime->channels > 1; 262 int dma; 263 264 rate = runtime->rate; 265 switch (chip->hardware) { 266 case SB_HW_JAZZ16: 267 if (runtime->format == SNDRV_PCM_FORMAT_S16_LE) { 268 if (chip->mode & SB_MODE_PLAYBACK_16) 269 return -EBUSY; 270 else 271 chip->mode |= SB_MODE_CAPTURE_16; 272 } 273 chip->capture_format = SB_DSP_LO_INPUT_AUTO; 274 break; 275 case SB_HW_PRO: 276 if (runtime->channels > 1) { 277 if (snd_BUG_ON(rate != SB8_RATE(11025) && 278 rate != SB8_RATE(22050))) 279 return -EINVAL; 280 chip->capture_format = SB_DSP_HI_INPUT_AUTO; 281 break; 282 } 283 chip->capture_format = (rate > 23000) ? SB_DSP_HI_INPUT_AUTO : SB_DSP_LO_INPUT_AUTO; 284 break; 285 case SB_HW_201: 286 if (rate > 13000) { 287 chip->capture_format = SB_DSP_HI_INPUT_AUTO; 288 break; 289 } 290 /* fallthru */ 291 case SB_HW_20: 292 chip->capture_format = SB_DSP_LO_INPUT_AUTO; 293 break; 294 case SB_HW_10: 295 chip->capture_format = SB_DSP_INPUT; 296 break; 297 default: 298 return -EINVAL; 299 } 300 if (chip->mode & SB_MODE_CAPTURE_16) { 301 format = stereo ? SB_DSP_STEREO_16BIT : SB_DSP_MONO_16BIT; 302 dma = chip->dma16; 303 } else { 304 format = stereo ? SB_DSP_STEREO_8BIT : SB_DSP_MONO_8BIT; 305 chip->mode |= SB_MODE_CAPTURE_8; 306 dma = chip->dma8; 307 } 308 size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream); 309 count = chip->c_period_size = snd_pcm_lib_period_bytes(substream); 310 spin_lock_irqsave(&chip->reg_lock, flags); 311 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF); 312 if (chip->hardware == SB_HW_JAZZ16) 313 snd_sbdsp_command(chip, format); 314 else if (stereo) 315 snd_sbdsp_command(chip, SB_DSP_STEREO_8BIT); 316 snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE); 317 if (stereo) { 318 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2); 319 spin_lock(&chip->mixer_lock); 320 /* save input filter status and turn it off */ 321 mixreg = snd_sbmixer_read(chip, SB_DSP_CAPTURE_FILT); 322 snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, mixreg | 0x20); 323 spin_unlock(&chip->mixer_lock); 324 /* just use force_mode16 for temporary storate... */ 325 chip->force_mode16 = mixreg; 326 } else { 327 snd_sbdsp_command(chip, 256 - runtime->rate_den); 328 } 329 if (chip->capture_format != SB_DSP_INPUT) { 330 if (chip->mode & SB_MODE_PLAYBACK_16) 331 count /= 2; 332 count--; 333 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE); 334 snd_sbdsp_command(chip, count & 0xff); 335 snd_sbdsp_command(chip, count >> 8); 336 } 337 spin_unlock_irqrestore(&chip->reg_lock, flags); 338 snd_dma_program(dma, runtime->dma_addr, 339 size, DMA_MODE_READ | DMA_AUTOINIT); 340 return 0; 341 } 342 343 static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream, 344 int cmd) 345 { 346 unsigned long flags; 347 struct snd_sb *chip = snd_pcm_substream_chip(substream); 348 unsigned int count; 349 350 spin_lock_irqsave(&chip->reg_lock, flags); 351 switch (cmd) { 352 case SNDRV_PCM_TRIGGER_START: 353 snd_sbdsp_command(chip, chip->capture_format); 354 if (chip->capture_format == SB_DSP_INPUT) { 355 count = chip->c_period_size - 1; 356 snd_sbdsp_command(chip, count & 0xff); 357 snd_sbdsp_command(chip, count >> 8); 358 } 359 break; 360 case SNDRV_PCM_TRIGGER_STOP: 361 if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) { 362 struct snd_pcm_runtime *runtime = substream->runtime; 363 snd_sbdsp_reset(chip); 364 if (runtime->channels > 1) { 365 /* restore input filter status */ 366 spin_lock(&chip->mixer_lock); 367 snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, chip->force_mode16); 368 spin_unlock(&chip->mixer_lock); 369 /* set hardware to mono mode */ 370 snd_sbdsp_command(chip, SB_DSP_MONO_8BIT); 371 } 372 } else { 373 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF); 374 } 375 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF); 376 } 377 spin_unlock_irqrestore(&chip->reg_lock, flags); 378 return 0; 379 } 380 381 irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip) 382 { 383 struct snd_pcm_substream *substream; 384 struct snd_pcm_runtime *runtime; 385 386 snd_sb_ack_8bit(chip); 387 switch (chip->mode) { 388 case SB_MODE_PLAYBACK_16: /* ok.. playback is active */ 389 if (chip->hardware != SB_HW_JAZZ16) 390 break; 391 /* fallthru */ 392 case SB_MODE_PLAYBACK_8: 393 substream = chip->playback_substream; 394 runtime = substream->runtime; 395 if (chip->playback_format == SB_DSP_OUTPUT) 396 snd_sb8_playback_trigger(substream, SNDRV_PCM_TRIGGER_START); 397 snd_pcm_period_elapsed(substream); 398 break; 399 case SB_MODE_CAPTURE_16: 400 if (chip->hardware != SB_HW_JAZZ16) 401 break; 402 /* fallthru */ 403 case SB_MODE_CAPTURE_8: 404 substream = chip->capture_substream; 405 runtime = substream->runtime; 406 if (chip->capture_format == SB_DSP_INPUT) 407 snd_sb8_capture_trigger(substream, SNDRV_PCM_TRIGGER_START); 408 snd_pcm_period_elapsed(substream); 409 break; 410 } 411 return IRQ_HANDLED; 412 } 413 414 static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream) 415 { 416 struct snd_sb *chip = snd_pcm_substream_chip(substream); 417 size_t ptr; 418 int dma; 419 420 if (chip->mode & SB_MODE_PLAYBACK_8) 421 dma = chip->dma8; 422 else if (chip->mode & SB_MODE_PLAYBACK_16) 423 dma = chip->dma16; 424 else 425 return 0; 426 ptr = snd_dma_pointer(dma, chip->p_dma_size); 427 return bytes_to_frames(substream->runtime, ptr); 428 } 429 430 static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream) 431 { 432 struct snd_sb *chip = snd_pcm_substream_chip(substream); 433 size_t ptr; 434 int dma; 435 436 if (chip->mode & SB_MODE_CAPTURE_8) 437 dma = chip->dma8; 438 else if (chip->mode & SB_MODE_CAPTURE_16) 439 dma = chip->dma16; 440 else 441 return 0; 442 ptr = snd_dma_pointer(dma, chip->c_dma_size); 443 return bytes_to_frames(substream->runtime, ptr); 444 } 445 446 /* 447 448 */ 449 450 static const struct snd_pcm_hardware snd_sb8_playback = 451 { 452 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 453 SNDRV_PCM_INFO_MMAP_VALID), 454 .formats = SNDRV_PCM_FMTBIT_U8, 455 .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 | 456 SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_22050), 457 .rate_min = 4000, 458 .rate_max = 23000, 459 .channels_min = 1, 460 .channels_max = 1, 461 .buffer_bytes_max = 65536, 462 .period_bytes_min = 64, 463 .period_bytes_max = 65536, 464 .periods_min = 1, 465 .periods_max = 1024, 466 .fifo_size = 0, 467 }; 468 469 static const struct snd_pcm_hardware snd_sb8_capture = 470 { 471 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 472 SNDRV_PCM_INFO_MMAP_VALID), 473 .formats = SNDRV_PCM_FMTBIT_U8, 474 .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 | 475 SNDRV_PCM_RATE_11025), 476 .rate_min = 4000, 477 .rate_max = 13000, 478 .channels_min = 1, 479 .channels_max = 1, 480 .buffer_bytes_max = 65536, 481 .period_bytes_min = 64, 482 .period_bytes_max = 65536, 483 .periods_min = 1, 484 .periods_max = 1024, 485 .fifo_size = 0, 486 }; 487 488 /* 489 * 490 */ 491 492 static int snd_sb8_open(struct snd_pcm_substream *substream) 493 { 494 struct snd_sb *chip = snd_pcm_substream_chip(substream); 495 struct snd_pcm_runtime *runtime = substream->runtime; 496 unsigned long flags; 497 498 spin_lock_irqsave(&chip->open_lock, flags); 499 if (chip->open) { 500 spin_unlock_irqrestore(&chip->open_lock, flags); 501 return -EAGAIN; 502 } 503 chip->open |= SB_OPEN_PCM; 504 spin_unlock_irqrestore(&chip->open_lock, flags); 505 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 506 chip->playback_substream = substream; 507 runtime->hw = snd_sb8_playback; 508 } else { 509 chip->capture_substream = substream; 510 runtime->hw = snd_sb8_capture; 511 } 512 switch (chip->hardware) { 513 case SB_HW_JAZZ16: 514 if (chip->dma16 == 5 || chip->dma16 == 7) 515 runtime->hw.formats |= SNDRV_PCM_FMTBIT_S16_LE; 516 runtime->hw.rates |= SNDRV_PCM_RATE_8000_48000; 517 runtime->hw.rate_min = 4000; 518 runtime->hw.rate_max = 50000; 519 runtime->hw.channels_max = 2; 520 break; 521 case SB_HW_PRO: 522 runtime->hw.rate_max = 44100; 523 runtime->hw.channels_max = 2; 524 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 525 snd_sb8_hw_constraint_rate_channels, NULL, 526 SNDRV_PCM_HW_PARAM_CHANNELS, 527 SNDRV_PCM_HW_PARAM_RATE, -1); 528 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 529 snd_sb8_hw_constraint_channels_rate, NULL, 530 SNDRV_PCM_HW_PARAM_RATE, -1); 531 break; 532 case SB_HW_201: 533 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 534 runtime->hw.rate_max = 44100; 535 } else { 536 runtime->hw.rate_max = 15000; 537 } 538 default: 539 break; 540 } 541 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 542 &hw_constraints_clock); 543 if (chip->dma8 > 3 || chip->dma16 >= 0) { 544 snd_pcm_hw_constraint_step(runtime, 0, 545 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 2); 546 snd_pcm_hw_constraint_step(runtime, 0, 547 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 2); 548 runtime->hw.buffer_bytes_max = 128 * 1024 * 1024; 549 runtime->hw.period_bytes_max = 128 * 1024 * 1024; 550 } 551 return 0; 552 } 553 554 static int snd_sb8_close(struct snd_pcm_substream *substream) 555 { 556 unsigned long flags; 557 struct snd_sb *chip = snd_pcm_substream_chip(substream); 558 559 chip->playback_substream = NULL; 560 chip->capture_substream = NULL; 561 spin_lock_irqsave(&chip->open_lock, flags); 562 chip->open &= ~SB_OPEN_PCM; 563 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 564 chip->mode &= ~SB_MODE_PLAYBACK; 565 else 566 chip->mode &= ~SB_MODE_CAPTURE; 567 spin_unlock_irqrestore(&chip->open_lock, flags); 568 return 0; 569 } 570 571 /* 572 * Initialization part 573 */ 574 575 static const struct snd_pcm_ops snd_sb8_playback_ops = { 576 .open = snd_sb8_open, 577 .close = snd_sb8_close, 578 .ioctl = snd_pcm_lib_ioctl, 579 .hw_params = snd_sb8_hw_params, 580 .hw_free = snd_sb8_hw_free, 581 .prepare = snd_sb8_playback_prepare, 582 .trigger = snd_sb8_playback_trigger, 583 .pointer = snd_sb8_playback_pointer, 584 }; 585 586 static const struct snd_pcm_ops snd_sb8_capture_ops = { 587 .open = snd_sb8_open, 588 .close = snd_sb8_close, 589 .ioctl = snd_pcm_lib_ioctl, 590 .hw_params = snd_sb8_hw_params, 591 .hw_free = snd_sb8_hw_free, 592 .prepare = snd_sb8_capture_prepare, 593 .trigger = snd_sb8_capture_trigger, 594 .pointer = snd_sb8_capture_pointer, 595 }; 596 597 int snd_sb8dsp_pcm(struct snd_sb *chip, int device) 598 { 599 struct snd_card *card = chip->card; 600 struct snd_pcm *pcm; 601 int err; 602 size_t max_prealloc = 64 * 1024; 603 604 if ((err = snd_pcm_new(card, "SB8 DSP", device, 1, 1, &pcm)) < 0) 605 return err; 606 sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff); 607 pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX; 608 pcm->private_data = chip; 609 610 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops); 611 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops); 612 613 if (chip->dma8 > 3 || chip->dma16 >= 0) 614 max_prealloc = 128 * 1024; 615 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 616 snd_dma_isa_data(), 617 64*1024, max_prealloc); 618 619 return 0; 620 } 621 622 EXPORT_SYMBOL(snd_sb8dsp_pcm); 623 EXPORT_SYMBOL(snd_sb8dsp_interrupt); 624 /* sb8_midi.c */ 625 EXPORT_SYMBOL(snd_sb8dsp_midi_interrupt); 626 EXPORT_SYMBOL(snd_sb8dsp_midi); 627 628 /* 629 * INIT part 630 */ 631 632 static int __init alsa_sb8_init(void) 633 { 634 return 0; 635 } 636 637 static void __exit alsa_sb8_exit(void) 638 { 639 } 640 641 module_init(alsa_sb8_init) 642 module_exit(alsa_sb8_exit) 643