linux/sound/isa/sb/sb8_main.c
<<
>>
Prefs
   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
  41MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Uros Bizjak <uros@kss-loka.si>");
  42MODULE_DESCRIPTION("Routines for control of 8-bit SoundBlaster cards and clones");
  43MODULE_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
  49static struct snd_ratnum clock = {
  50        .num = SB8_CLOCK,
  51        .den_min = 1,
  52        .den_max = 256,
  53        .den_step = 1,
  54};
  55
  56static struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = {
  57        .nrats = 1,
  58        .rats = &clock,
  59};
  60
  61static 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
  76static 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
  93static 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
 104static 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
 206static 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
 242static 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
 248static int snd_sb8_hw_free(struct snd_pcm_substream *substream)
 249{
 250        snd_pcm_lib_free_pages(substream);
 251        return 0;
 252}
 253
 254static 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
 343static 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
 381irqreturn_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
 414static 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
 430static 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
 450static 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
 469static 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 
 492static 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
 554static 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 
 575static 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
 586static 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
 597int 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
 622EXPORT_SYMBOL(snd_sb8dsp_pcm);
 623EXPORT_SYMBOL(snd_sb8dsp_interrupt);
 624  /* sb8_midi.c */
 625EXPORT_SYMBOL(snd_sb8dsp_midi_interrupt);
 626EXPORT_SYMBOL(snd_sb8dsp_midi);
 627
 628/*
 629 *  INIT part
 630 */
 631
 632static int __init alsa_sb8_init(void)
 633{
 634        return 0;
 635}
 636
 637static void __exit alsa_sb8_exit(void)
 638{
 639}
 640
 641module_init(alsa_sb8_init)
 642module_exit(alsa_sb8_exit)
 643