Thomas Gleixner | 1a59d1b8 | 2019-05-27 08:55:05 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
Jaroslav Kysela | c1017a4 | 2007-10-15 09:50:19 +0200 | [diff] [blame] | 3 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * Uros Bizjak <uros@kss-loka.si> |
| 5 | * |
| 6 | * Routines for control of 8-bit SoundBlaster cards and clones |
| 7 | * Please note: I don't have access to old SB8 soundcards. |
| 8 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | * -- |
| 10 | * |
| 11 | * Thu Apr 29 20:36:17 BST 1999 George David Morrison <gdm@gedamo.demon.co.uk> |
| 12 | * DSP can't respond to commands whilst in "high speed" mode. Caused |
| 13 | * glitching during playback. Fixed. |
| 14 | * |
| 15 | * Wed Jul 12 22:02:55 CEST 2000 Uros Bizjak <uros@kss-loka.si> |
| 16 | * Cleaned up and rewrote lowlevel routines. |
| 17 | */ |
| 18 | |
Takashi Iwai | 6cbbfe1 | 2015-01-28 16:49:33 +0100 | [diff] [blame] | 19 | #include <linux/io.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <asm/dma.h> |
| 21 | #include <linux/init.h> |
| 22 | #include <linux/time.h> |
Paul Gortmaker | da155d5 | 2011-07-15 12:38:28 -0400 | [diff] [blame] | 23 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <sound/core.h> |
| 25 | #include <sound/sb.h> |
| 26 | |
Jaroslav Kysela | c1017a4 | 2007-10-15 09:50:19 +0200 | [diff] [blame] | 27 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Uros Bizjak <uros@kss-loka.si>"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | MODULE_DESCRIPTION("Routines for control of 8-bit SoundBlaster cards and clones"); |
| 29 | MODULE_LICENSE("GPL"); |
| 30 | |
| 31 | #define SB8_CLOCK 1000000 |
| 32 | #define SB8_DEN(v) ((SB8_CLOCK + (v) / 2) / (v)) |
| 33 | #define SB8_RATE(v) (SB8_CLOCK / SB8_DEN(v)) |
| 34 | |
Takashi Iwai | b078bbf | 2017-06-07 14:16:34 +0200 | [diff] [blame] | 35 | static const struct snd_ratnum clock = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | .num = SB8_CLOCK, |
| 37 | .den_min = 1, |
| 38 | .den_max = 256, |
| 39 | .den_step = 1, |
| 40 | }; |
| 41 | |
Takashi Iwai | b078bbf | 2017-06-07 14:16:34 +0200 | [diff] [blame] | 42 | static const struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | .nrats = 1, |
| 44 | .rats = &clock, |
| 45 | }; |
| 46 | |
Takashi Iwai | b078bbf | 2017-06-07 14:16:34 +0200 | [diff] [blame] | 47 | static const struct snd_ratnum stereo_clocks[] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | { |
| 49 | .num = SB8_CLOCK, |
| 50 | .den_min = SB8_DEN(22050), |
| 51 | .den_max = SB8_DEN(22050), |
| 52 | .den_step = 1, |
| 53 | }, |
| 54 | { |
| 55 | .num = SB8_CLOCK, |
| 56 | .den_min = SB8_DEN(11025), |
| 57 | .den_max = SB8_DEN(11025), |
| 58 | .den_step = 1, |
| 59 | } |
| 60 | }; |
| 61 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 62 | static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params, |
| 63 | struct snd_pcm_hw_rule *rule) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 65 | struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | if (c->min > 1) { |
| 67 | unsigned int num = 0, den = 0; |
| 68 | int err = snd_interval_ratnum(hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE), |
| 69 | 2, stereo_clocks, &num, &den); |
| 70 | if (err >= 0 && den) { |
| 71 | params->rate_num = num; |
| 72 | params->rate_den = den; |
| 73 | } |
| 74 | return err; |
| 75 | } |
| 76 | return 0; |
| 77 | } |
| 78 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 79 | static int snd_sb8_hw_constraint_channels_rate(struct snd_pcm_hw_params *params, |
| 80 | struct snd_pcm_hw_rule *rule) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 82 | struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | if (r->min > SB8_RATE(22050) || r->max <= SB8_RATE(11025)) { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 84 | struct snd_interval t = { .min = 1, .max = 1 }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t); |
| 86 | } |
| 87 | return 0; |
| 88 | } |
| 89 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 90 | static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | { |
| 92 | unsigned long flags; |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 93 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
| 94 | struct snd_pcm_runtime *runtime = substream->runtime; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | unsigned int mixreg, rate, size, count; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 96 | unsigned char format; |
| 97 | unsigned char stereo = runtime->channels > 1; |
| 98 | int dma; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | |
| 100 | rate = runtime->rate; |
| 101 | switch (chip->hardware) { |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 102 | case SB_HW_JAZZ16: |
| 103 | if (runtime->format == SNDRV_PCM_FORMAT_S16_LE) { |
| 104 | if (chip->mode & SB_MODE_CAPTURE_16) |
| 105 | return -EBUSY; |
| 106 | else |
| 107 | chip->mode |= SB_MODE_PLAYBACK_16; |
| 108 | } |
| 109 | chip->playback_format = SB_DSP_LO_OUTPUT_AUTO; |
| 110 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | case SB_HW_PRO: |
| 112 | if (runtime->channels > 1) { |
Takashi Iwai | 622207d | 2008-08-08 17:11:45 +0200 | [diff] [blame] | 113 | if (snd_BUG_ON(rate != SB8_RATE(11025) && |
| 114 | rate != SB8_RATE(22050))) |
| 115 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | chip->playback_format = SB_DSP_HI_OUTPUT_AUTO; |
| 117 | break; |
| 118 | } |
Gustavo A. R. Silva | c0dbbda | 2020-07-08 15:32:36 -0500 | [diff] [blame] | 119 | fallthrough; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | case SB_HW_201: |
| 121 | if (rate > 23000) { |
| 122 | chip->playback_format = SB_DSP_HI_OUTPUT_AUTO; |
| 123 | break; |
| 124 | } |
Gustavo A. R. Silva | c0dbbda | 2020-07-08 15:32:36 -0500 | [diff] [blame] | 125 | fallthrough; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | } |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 135 | if (chip->mode & SB_MODE_PLAYBACK_16) { |
| 136 | format = stereo ? SB_DSP_STEREO_16BIT : SB_DSP_MONO_16BIT; |
| 137 | dma = chip->dma16; |
| 138 | } else { |
| 139 | format = stereo ? SB_DSP_STEREO_8BIT : SB_DSP_MONO_8BIT; |
| 140 | chip->mode |= SB_MODE_PLAYBACK_8; |
| 141 | dma = chip->dma8; |
| 142 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream); |
| 144 | count = chip->p_period_size = snd_pcm_lib_period_bytes(substream); |
| 145 | spin_lock_irqsave(&chip->reg_lock, flags); |
| 146 | snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON); |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 147 | if (chip->hardware == SB_HW_JAZZ16) |
| 148 | snd_sbdsp_command(chip, format); |
| 149 | else if (stereo) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | /* set playback stereo mode */ |
| 151 | spin_lock(&chip->mixer_lock); |
| 152 | mixreg = snd_sbmixer_read(chip, SB_DSP_STEREO_SW); |
| 153 | snd_sbmixer_write(chip, SB_DSP_STEREO_SW, mixreg | 0x02); |
| 154 | spin_unlock(&chip->mixer_lock); |
| 155 | |
| 156 | /* Soundblaster hardware programming reference guide, 3-23 */ |
| 157 | snd_sbdsp_command(chip, SB_DSP_DMA8_EXIT); |
| 158 | runtime->dma_area[0] = 0x80; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 159 | snd_dma_program(dma, runtime->dma_addr, 1, DMA_MODE_WRITE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | /* force interrupt */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | snd_sbdsp_command(chip, SB_DSP_OUTPUT); |
| 162 | snd_sbdsp_command(chip, 0); |
| 163 | snd_sbdsp_command(chip, 0); |
| 164 | } |
| 165 | snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE); |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 166 | if (stereo) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | snd_sbdsp_command(chip, 256 - runtime->rate_den / 2); |
| 168 | spin_lock(&chip->mixer_lock); |
| 169 | /* save output filter status and turn it off */ |
| 170 | mixreg = snd_sbmixer_read(chip, SB_DSP_PLAYBACK_FILT); |
| 171 | snd_sbmixer_write(chip, SB_DSP_PLAYBACK_FILT, mixreg | 0x20); |
| 172 | spin_unlock(&chip->mixer_lock); |
| 173 | /* just use force_mode16 for temporary storate... */ |
| 174 | chip->force_mode16 = mixreg; |
| 175 | } else { |
| 176 | snd_sbdsp_command(chip, 256 - runtime->rate_den); |
| 177 | } |
| 178 | if (chip->playback_format != SB_DSP_OUTPUT) { |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 179 | if (chip->mode & SB_MODE_PLAYBACK_16) |
| 180 | count /= 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | count--; |
| 182 | snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE); |
| 183 | snd_sbdsp_command(chip, count & 0xff); |
| 184 | snd_sbdsp_command(chip, count >> 8); |
| 185 | } |
| 186 | spin_unlock_irqrestore(&chip->reg_lock, flags); |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 187 | snd_dma_program(dma, runtime->dma_addr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | size, DMA_MODE_WRITE | DMA_AUTOINIT); |
| 189 | return 0; |
| 190 | } |
| 191 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 192 | static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | int cmd) |
| 194 | { |
| 195 | unsigned long flags; |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 196 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | unsigned int count; |
| 198 | |
| 199 | spin_lock_irqsave(&chip->reg_lock, flags); |
| 200 | switch (cmd) { |
| 201 | case SNDRV_PCM_TRIGGER_START: |
| 202 | snd_sbdsp_command(chip, chip->playback_format); |
| 203 | if (chip->playback_format == SB_DSP_OUTPUT) { |
| 204 | count = chip->p_period_size - 1; |
| 205 | snd_sbdsp_command(chip, count & 0xff); |
| 206 | snd_sbdsp_command(chip, count >> 8); |
| 207 | } |
| 208 | break; |
| 209 | case SNDRV_PCM_TRIGGER_STOP: |
| 210 | if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 211 | struct snd_pcm_runtime *runtime = substream->runtime; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | snd_sbdsp_reset(chip); |
| 213 | if (runtime->channels > 1) { |
| 214 | spin_lock(&chip->mixer_lock); |
| 215 | /* restore output filter and set hardware to mono mode */ |
| 216 | snd_sbmixer_write(chip, SB_DSP_STEREO_SW, chip->force_mode16 & ~0x02); |
| 217 | spin_unlock(&chip->mixer_lock); |
| 218 | } |
| 219 | } else { |
| 220 | snd_sbdsp_command(chip, SB_DSP_DMA8_OFF); |
| 221 | } |
| 222 | snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF); |
| 223 | } |
| 224 | spin_unlock_irqrestore(&chip->reg_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | return 0; |
| 226 | } |
| 227 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 228 | static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | { |
| 230 | unsigned long flags; |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 231 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
| 232 | struct snd_pcm_runtime *runtime = substream->runtime; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | unsigned int mixreg, rate, size, count; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 234 | unsigned char format; |
| 235 | unsigned char stereo = runtime->channels > 1; |
| 236 | int dma; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
| 238 | rate = runtime->rate; |
| 239 | switch (chip->hardware) { |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 240 | case SB_HW_JAZZ16: |
| 241 | if (runtime->format == SNDRV_PCM_FORMAT_S16_LE) { |
| 242 | if (chip->mode & SB_MODE_PLAYBACK_16) |
| 243 | return -EBUSY; |
| 244 | else |
| 245 | chip->mode |= SB_MODE_CAPTURE_16; |
| 246 | } |
| 247 | chip->capture_format = SB_DSP_LO_INPUT_AUTO; |
| 248 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | case SB_HW_PRO: |
| 250 | if (runtime->channels > 1) { |
Takashi Iwai | 622207d | 2008-08-08 17:11:45 +0200 | [diff] [blame] | 251 | if (snd_BUG_ON(rate != SB8_RATE(11025) && |
| 252 | rate != SB8_RATE(22050))) |
| 253 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | chip->capture_format = SB_DSP_HI_INPUT_AUTO; |
| 255 | break; |
| 256 | } |
| 257 | chip->capture_format = (rate > 23000) ? SB_DSP_HI_INPUT_AUTO : SB_DSP_LO_INPUT_AUTO; |
| 258 | break; |
| 259 | case SB_HW_201: |
| 260 | if (rate > 13000) { |
| 261 | chip->capture_format = SB_DSP_HI_INPUT_AUTO; |
| 262 | break; |
| 263 | } |
Gustavo A. R. Silva | c0dbbda | 2020-07-08 15:32:36 -0500 | [diff] [blame] | 264 | fallthrough; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | case SB_HW_20: |
| 266 | chip->capture_format = SB_DSP_LO_INPUT_AUTO; |
| 267 | break; |
| 268 | case SB_HW_10: |
| 269 | chip->capture_format = SB_DSP_INPUT; |
| 270 | break; |
| 271 | default: |
| 272 | return -EINVAL; |
| 273 | } |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 274 | if (chip->mode & SB_MODE_CAPTURE_16) { |
| 275 | format = stereo ? SB_DSP_STEREO_16BIT : SB_DSP_MONO_16BIT; |
| 276 | dma = chip->dma16; |
| 277 | } else { |
| 278 | format = stereo ? SB_DSP_STEREO_8BIT : SB_DSP_MONO_8BIT; |
| 279 | chip->mode |= SB_MODE_CAPTURE_8; |
| 280 | dma = chip->dma8; |
| 281 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream); |
| 283 | count = chip->c_period_size = snd_pcm_lib_period_bytes(substream); |
| 284 | spin_lock_irqsave(&chip->reg_lock, flags); |
| 285 | snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF); |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 286 | if (chip->hardware == SB_HW_JAZZ16) |
| 287 | snd_sbdsp_command(chip, format); |
| 288 | else if (stereo) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | snd_sbdsp_command(chip, SB_DSP_STEREO_8BIT); |
| 290 | snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE); |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 291 | if (stereo) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | snd_sbdsp_command(chip, 256 - runtime->rate_den / 2); |
| 293 | spin_lock(&chip->mixer_lock); |
| 294 | /* save input filter status and turn it off */ |
| 295 | mixreg = snd_sbmixer_read(chip, SB_DSP_CAPTURE_FILT); |
| 296 | snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, mixreg | 0x20); |
| 297 | spin_unlock(&chip->mixer_lock); |
| 298 | /* just use force_mode16 for temporary storate... */ |
| 299 | chip->force_mode16 = mixreg; |
| 300 | } else { |
| 301 | snd_sbdsp_command(chip, 256 - runtime->rate_den); |
| 302 | } |
Clemens Ladisch | 20cde9e | 2008-02-25 11:04:41 +0100 | [diff] [blame] | 303 | if (chip->capture_format != SB_DSP_INPUT) { |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 304 | if (chip->mode & SB_MODE_PLAYBACK_16) |
| 305 | count /= 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | count--; |
| 307 | snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE); |
| 308 | snd_sbdsp_command(chip, count & 0xff); |
| 309 | snd_sbdsp_command(chip, count >> 8); |
| 310 | } |
| 311 | spin_unlock_irqrestore(&chip->reg_lock, flags); |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 312 | snd_dma_program(dma, runtime->dma_addr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 313 | size, DMA_MODE_READ | DMA_AUTOINIT); |
| 314 | return 0; |
| 315 | } |
| 316 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 317 | static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | int cmd) |
| 319 | { |
| 320 | unsigned long flags; |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 321 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | unsigned int count; |
| 323 | |
| 324 | spin_lock_irqsave(&chip->reg_lock, flags); |
| 325 | switch (cmd) { |
| 326 | case SNDRV_PCM_TRIGGER_START: |
| 327 | snd_sbdsp_command(chip, chip->capture_format); |
| 328 | if (chip->capture_format == SB_DSP_INPUT) { |
| 329 | count = chip->c_period_size - 1; |
| 330 | snd_sbdsp_command(chip, count & 0xff); |
| 331 | snd_sbdsp_command(chip, count >> 8); |
| 332 | } |
| 333 | break; |
| 334 | case SNDRV_PCM_TRIGGER_STOP: |
| 335 | if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 336 | struct snd_pcm_runtime *runtime = substream->runtime; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | snd_sbdsp_reset(chip); |
| 338 | if (runtime->channels > 1) { |
| 339 | /* restore input filter status */ |
| 340 | spin_lock(&chip->mixer_lock); |
| 341 | snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, chip->force_mode16); |
| 342 | spin_unlock(&chip->mixer_lock); |
| 343 | /* set hardware to mono mode */ |
| 344 | snd_sbdsp_command(chip, SB_DSP_MONO_8BIT); |
| 345 | } |
| 346 | } else { |
| 347 | snd_sbdsp_command(chip, SB_DSP_DMA8_OFF); |
| 348 | } |
| 349 | snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF); |
| 350 | } |
| 351 | spin_unlock_irqrestore(&chip->reg_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | return 0; |
| 353 | } |
| 354 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 355 | irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 357 | struct snd_pcm_substream *substream; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | snd_sb_ack_8bit(chip); |
| 360 | switch (chip->mode) { |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 361 | case SB_MODE_PLAYBACK_16: /* ok.. playback is active */ |
| 362 | if (chip->hardware != SB_HW_JAZZ16) |
| 363 | break; |
Gustavo A. R. Silva | c0dbbda | 2020-07-08 15:32:36 -0500 | [diff] [blame] | 364 | fallthrough; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 365 | case SB_MODE_PLAYBACK_8: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 366 | substream = chip->playback_substream; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | if (chip->playback_format == SB_DSP_OUTPUT) |
| 368 | snd_sb8_playback_trigger(substream, SNDRV_PCM_TRIGGER_START); |
| 369 | snd_pcm_period_elapsed(substream); |
| 370 | break; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 371 | case SB_MODE_CAPTURE_16: |
| 372 | if (chip->hardware != SB_HW_JAZZ16) |
| 373 | break; |
Gustavo A. R. Silva | c0dbbda | 2020-07-08 15:32:36 -0500 | [diff] [blame] | 374 | fallthrough; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | case SB_MODE_CAPTURE_8: |
| 376 | substream = chip->capture_substream; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 377 | if (chip->capture_format == SB_DSP_INPUT) |
| 378 | snd_sb8_capture_trigger(substream, SNDRV_PCM_TRIGGER_START); |
| 379 | snd_pcm_period_elapsed(substream); |
| 380 | break; |
| 381 | } |
| 382 | return IRQ_HANDLED; |
| 383 | } |
| 384 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 385 | static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 386 | { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 387 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | size_t ptr; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 389 | int dma; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 391 | if (chip->mode & SB_MODE_PLAYBACK_8) |
| 392 | dma = chip->dma8; |
| 393 | else if (chip->mode & SB_MODE_PLAYBACK_16) |
| 394 | dma = chip->dma16; |
| 395 | else |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | return 0; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 397 | ptr = snd_dma_pointer(dma, chip->p_dma_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | return bytes_to_frames(substream->runtime, ptr); |
| 399 | } |
| 400 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 401 | static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 402 | { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 403 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 404 | size_t ptr; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 405 | int dma; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 407 | if (chip->mode & SB_MODE_CAPTURE_8) |
| 408 | dma = chip->dma8; |
| 409 | else if (chip->mode & SB_MODE_CAPTURE_16) |
| 410 | dma = chip->dma16; |
| 411 | else |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | return 0; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 413 | ptr = snd_dma_pointer(dma, chip->c_dma_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | return bytes_to_frames(substream->runtime, ptr); |
| 415 | } |
| 416 | |
| 417 | /* |
| 418 | |
| 419 | */ |
| 420 | |
Bhumika Goyal | aec5465 | 2017-08-17 14:45:52 +0530 | [diff] [blame] | 421 | static const struct snd_pcm_hardware snd_sb8_playback = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 422 | { |
| 423 | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | |
| 424 | SNDRV_PCM_INFO_MMAP_VALID), |
| 425 | .formats = SNDRV_PCM_FMTBIT_U8, |
| 426 | .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 | |
| 427 | SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_22050), |
| 428 | .rate_min = 4000, |
| 429 | .rate_max = 23000, |
| 430 | .channels_min = 1, |
| 431 | .channels_max = 1, |
| 432 | .buffer_bytes_max = 65536, |
| 433 | .period_bytes_min = 64, |
| 434 | .period_bytes_max = 65536, |
| 435 | .periods_min = 1, |
| 436 | .periods_max = 1024, |
| 437 | .fifo_size = 0, |
| 438 | }; |
| 439 | |
Bhumika Goyal | aec5465 | 2017-08-17 14:45:52 +0530 | [diff] [blame] | 440 | static const struct snd_pcm_hardware snd_sb8_capture = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | { |
| 442 | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | |
| 443 | SNDRV_PCM_INFO_MMAP_VALID), |
| 444 | .formats = SNDRV_PCM_FMTBIT_U8, |
| 445 | .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 | |
| 446 | SNDRV_PCM_RATE_11025), |
| 447 | .rate_min = 4000, |
| 448 | .rate_max = 13000, |
| 449 | .channels_min = 1, |
| 450 | .channels_max = 1, |
| 451 | .buffer_bytes_max = 65536, |
| 452 | .period_bytes_min = 64, |
| 453 | .period_bytes_max = 65536, |
| 454 | .periods_min = 1, |
| 455 | .periods_max = 1024, |
| 456 | .fifo_size = 0, |
| 457 | }; |
| 458 | |
| 459 | /* |
| 460 | * |
| 461 | */ |
| 462 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 463 | static int snd_sb8_open(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 465 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
| 466 | struct snd_pcm_runtime *runtime = substream->runtime; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 467 | unsigned long flags; |
| 468 | |
| 469 | spin_lock_irqsave(&chip->open_lock, flags); |
| 470 | if (chip->open) { |
| 471 | spin_unlock_irqrestore(&chip->open_lock, flags); |
| 472 | return -EAGAIN; |
| 473 | } |
| 474 | chip->open |= SB_OPEN_PCM; |
| 475 | spin_unlock_irqrestore(&chip->open_lock, flags); |
| 476 | if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { |
| 477 | chip->playback_substream = substream; |
| 478 | runtime->hw = snd_sb8_playback; |
| 479 | } else { |
| 480 | chip->capture_substream = substream; |
| 481 | runtime->hw = snd_sb8_capture; |
| 482 | } |
| 483 | switch (chip->hardware) { |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 484 | case SB_HW_JAZZ16: |
Krzysztof Helt | 44eba3e | 2009-12-23 18:02:41 +0100 | [diff] [blame] | 485 | if (chip->dma16 == 5 || chip->dma16 == 7) |
| 486 | runtime->hw.formats |= SNDRV_PCM_FMTBIT_S16_LE; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 487 | runtime->hw.rates |= SNDRV_PCM_RATE_8000_48000; |
| 488 | runtime->hw.rate_min = 4000; |
| 489 | runtime->hw.rate_max = 50000; |
| 490 | runtime->hw.channels_max = 2; |
| 491 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 492 | case SB_HW_PRO: |
| 493 | runtime->hw.rate_max = 44100; |
| 494 | runtime->hw.channels_max = 2; |
| 495 | snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, |
| 496 | snd_sb8_hw_constraint_rate_channels, NULL, |
| 497 | SNDRV_PCM_HW_PARAM_CHANNELS, |
| 498 | SNDRV_PCM_HW_PARAM_RATE, -1); |
| 499 | snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, |
| 500 | snd_sb8_hw_constraint_channels_rate, NULL, |
| 501 | SNDRV_PCM_HW_PARAM_RATE, -1); |
| 502 | break; |
| 503 | case SB_HW_201: |
| 504 | if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { |
| 505 | runtime->hw.rate_max = 44100; |
| 506 | } else { |
| 507 | runtime->hw.rate_max = 15000; |
| 508 | } |
Gustavo A. R. Silva | 45bbe6c | 2020-11-20 12:34:12 -0600 | [diff] [blame] | 509 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 510 | default: |
| 511 | break; |
| 512 | } |
| 513 | snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, |
| 514 | &hw_constraints_clock); |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 515 | if (chip->dma8 > 3 || chip->dma16 >= 0) { |
| 516 | snd_pcm_hw_constraint_step(runtime, 0, |
| 517 | SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 2); |
| 518 | snd_pcm_hw_constraint_step(runtime, 0, |
| 519 | SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 2); |
| 520 | runtime->hw.buffer_bytes_max = 128 * 1024 * 1024; |
| 521 | runtime->hw.period_bytes_max = 128 * 1024 * 1024; |
| 522 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | return 0; |
| 524 | } |
| 525 | |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 526 | static int snd_sb8_close(struct snd_pcm_substream *substream) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 527 | { |
| 528 | unsigned long flags; |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 529 | struct snd_sb *chip = snd_pcm_substream_chip(substream); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 530 | |
| 531 | chip->playback_substream = NULL; |
| 532 | chip->capture_substream = NULL; |
| 533 | spin_lock_irqsave(&chip->open_lock, flags); |
| 534 | chip->open &= ~SB_OPEN_PCM; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 535 | if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| 536 | chip->mode &= ~SB_MODE_PLAYBACK; |
| 537 | else |
| 538 | chip->mode &= ~SB_MODE_CAPTURE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 539 | spin_unlock_irqrestore(&chip->open_lock, flags); |
| 540 | return 0; |
| 541 | } |
| 542 | |
| 543 | /* |
| 544 | * Initialization part |
| 545 | */ |
| 546 | |
Arvind Yadav | 9917685 | 2017-08-11 17:28:06 +0530 | [diff] [blame] | 547 | static const struct snd_pcm_ops snd_sb8_playback_ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 548 | .open = snd_sb8_open, |
| 549 | .close = snd_sb8_close, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 550 | .prepare = snd_sb8_playback_prepare, |
| 551 | .trigger = snd_sb8_playback_trigger, |
| 552 | .pointer = snd_sb8_playback_pointer, |
| 553 | }; |
| 554 | |
Arvind Yadav | 9917685 | 2017-08-11 17:28:06 +0530 | [diff] [blame] | 555 | static const struct snd_pcm_ops snd_sb8_capture_ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 556 | .open = snd_sb8_open, |
| 557 | .close = snd_sb8_close, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 558 | .prepare = snd_sb8_capture_prepare, |
| 559 | .trigger = snd_sb8_capture_trigger, |
| 560 | .pointer = snd_sb8_capture_pointer, |
| 561 | }; |
| 562 | |
Lars-Peter Clausen | 8c77629 | 2015-01-02 12:24:41 +0100 | [diff] [blame] | 563 | int snd_sb8dsp_pcm(struct snd_sb *chip, int device) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 564 | { |
Takashi Iwai | 029d64b | 2005-11-17 14:34:36 +0100 | [diff] [blame] | 565 | struct snd_card *card = chip->card; |
| 566 | struct snd_pcm *pcm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 567 | int err; |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 568 | size_t max_prealloc = 64 * 1024; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 569 | |
Takashi Iwai | 10dc8ad | 2021-06-08 16:04:35 +0200 | [diff] [blame] | 570 | err = snd_pcm_new(card, "SB8 DSP", device, 1, 1, &pcm); |
| 571 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 572 | return err; |
| 573 | sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff); |
| 574 | pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX; |
| 575 | pcm->private_data = chip; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 576 | |
| 577 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops); |
| 578 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops); |
| 579 | |
Krzysztof Helt | ad8decb | 2009-12-20 19:01:50 +0100 | [diff] [blame] | 580 | if (chip->dma8 > 3 || chip->dma16 >= 0) |
| 581 | max_prealloc = 128 * 1024; |
Takashi Iwai | 07ed72b | 2019-12-09 10:48:46 +0100 | [diff] [blame] | 582 | snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, |
| 583 | card->dev, 64*1024, max_prealloc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 584 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 585 | return 0; |
| 586 | } |
| 587 | |
| 588 | EXPORT_SYMBOL(snd_sb8dsp_pcm); |
| 589 | EXPORT_SYMBOL(snd_sb8dsp_interrupt); |
| 590 | /* sb8_midi.c */ |
| 591 | EXPORT_SYMBOL(snd_sb8dsp_midi_interrupt); |
| 592 | EXPORT_SYMBOL(snd_sb8dsp_midi); |