1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * PC-Speaker driver for Linux 4 * 5 * Copyright (C) 1993-1997 Michael Beck 6 * Copyright (C) 1997-2001 David Woodhouse 7 * Copyright (C) 2001-2008 Stas Sergeev 8 */ 9 10 #include <linux/module.h> 11 #include <linux/gfp.h> 12 #include <linux/moduleparam.h> 13 #include <linux/interrupt.h> 14 #include <linux/io.h> 15 #include <sound/pcm.h> 16 #include "pcsp.h" 17 18 static bool nforce_wa; 19 module_param(nforce_wa, bool, 0444); 20 MODULE_PARM_DESC(nforce_wa, "Apply NForce chipset workaround " 21 "(expect bad sound)"); 22 23 #define DMIX_WANTS_S16 1 24 25 /* 26 * Call snd_pcm_period_elapsed in a tasklet 27 * This avoids spinlock messes and long-running irq contexts 28 */ 29 static void pcsp_call_pcm_elapsed(unsigned long priv) 30 { 31 if (atomic_read(&pcsp_chip.timer_active)) { 32 struct snd_pcm_substream *substream; 33 substream = pcsp_chip.playback_substream; 34 if (substream) 35 snd_pcm_period_elapsed(substream); 36 } 37 } 38 39 static DECLARE_TASKLET(pcsp_pcm_tasklet, pcsp_call_pcm_elapsed, 0); 40 41 /* write the port and returns the next expire time in ns; 42 * called at the trigger-start and in hrtimer callback 43 */ 44 static u64 pcsp_timer_update(struct snd_pcsp *chip) 45 { 46 unsigned char timer_cnt, val; 47 u64 ns; 48 struct snd_pcm_substream *substream; 49 struct snd_pcm_runtime *runtime; 50 unsigned long flags; 51 52 if (chip->thalf) { 53 outb(chip->val61, 0x61); 54 chip->thalf = 0; 55 return chip->ns_rem; 56 } 57 58 substream = chip->playback_substream; 59 if (!substream) 60 return 0; 61 62 runtime = substream->runtime; 63 /* assume it is mono! */ 64 val = runtime->dma_area[chip->playback_ptr + chip->fmt_size - 1]; 65 if (chip->is_signed) 66 val ^= 0x80; 67 timer_cnt = val * CUR_DIV() / 256; 68 69 if (timer_cnt && chip->enable) { 70 raw_spin_lock_irqsave(&i8253_lock, flags); 71 if (!nforce_wa) { 72 outb_p(chip->val61, 0x61); 73 outb_p(timer_cnt, 0x42); 74 outb(chip->val61 ^ 1, 0x61); 75 } else { 76 outb(chip->val61 ^ 2, 0x61); 77 chip->thalf = 1; 78 } 79 raw_spin_unlock_irqrestore(&i8253_lock, flags); 80 } 81 82 chip->ns_rem = PCSP_PERIOD_NS(); 83 ns = (chip->thalf ? PCSP_CALC_NS(timer_cnt) : chip->ns_rem); 84 chip->ns_rem -= ns; 85 return ns; 86 } 87 88 static void pcsp_pointer_update(struct snd_pcsp *chip) 89 { 90 struct snd_pcm_substream *substream; 91 size_t period_bytes, buffer_bytes; 92 int periods_elapsed; 93 unsigned long flags; 94 95 /* update the playback position */ 96 substream = chip->playback_substream; 97 if (!substream) 98 return; 99 100 period_bytes = snd_pcm_lib_period_bytes(substream); 101 buffer_bytes = snd_pcm_lib_buffer_bytes(substream); 102 103 spin_lock_irqsave(&chip->substream_lock, flags); 104 chip->playback_ptr += PCSP_INDEX_INC() * chip->fmt_size; 105 periods_elapsed = chip->playback_ptr - chip->period_ptr; 106 if (periods_elapsed < 0) { 107 #if PCSP_DEBUG 108 printk(KERN_INFO "PCSP: buffer_bytes mod period_bytes != 0 ? " 109 "(%zi %zi %zi)\n", 110 chip->playback_ptr, period_bytes, buffer_bytes); 111 #endif 112 periods_elapsed += buffer_bytes; 113 } 114 periods_elapsed /= period_bytes; 115 /* wrap the pointer _before_ calling snd_pcm_period_elapsed(), 116 * or ALSA will BUG on us. */ 117 chip->playback_ptr %= buffer_bytes; 118 119 if (periods_elapsed) { 120 chip->period_ptr += periods_elapsed * period_bytes; 121 chip->period_ptr %= buffer_bytes; 122 } 123 spin_unlock_irqrestore(&chip->substream_lock, flags); 124 125 if (periods_elapsed) 126 tasklet_schedule(&pcsp_pcm_tasklet); 127 } 128 129 enum hrtimer_restart pcsp_do_timer(struct hrtimer *handle) 130 { 131 struct snd_pcsp *chip = container_of(handle, struct snd_pcsp, timer); 132 int pointer_update; 133 u64 ns; 134 135 if (!atomic_read(&chip->timer_active) || !chip->playback_substream) 136 return HRTIMER_NORESTART; 137 138 pointer_update = !chip->thalf; 139 ns = pcsp_timer_update(chip); 140 if (!ns) { 141 printk(KERN_WARNING "PCSP: unexpected stop\n"); 142 return HRTIMER_NORESTART; 143 } 144 145 if (pointer_update) 146 pcsp_pointer_update(chip); 147 148 hrtimer_forward(handle, hrtimer_get_expires(handle), ns_to_ktime(ns)); 149 150 return HRTIMER_RESTART; 151 } 152 153 static int pcsp_start_playing(struct snd_pcsp *chip) 154 { 155 #if PCSP_DEBUG 156 printk(KERN_INFO "PCSP: start_playing called\n"); 157 #endif 158 if (atomic_read(&chip->timer_active)) { 159 printk(KERN_ERR "PCSP: Timer already active\n"); 160 return -EIO; 161 } 162 163 raw_spin_lock(&i8253_lock); 164 chip->val61 = inb(0x61) | 0x03; 165 outb_p(0x92, 0x43); /* binary, mode 1, LSB only, ch 2 */ 166 raw_spin_unlock(&i8253_lock); 167 atomic_set(&chip->timer_active, 1); 168 chip->thalf = 0; 169 170 hrtimer_start(&pcsp_chip.timer, 0, HRTIMER_MODE_REL); 171 return 0; 172 } 173 174 static void pcsp_stop_playing(struct snd_pcsp *chip) 175 { 176 #if PCSP_DEBUG 177 printk(KERN_INFO "PCSP: stop_playing called\n"); 178 #endif 179 if (!atomic_read(&chip->timer_active)) 180 return; 181 182 atomic_set(&chip->timer_active, 0); 183 raw_spin_lock(&i8253_lock); 184 /* restore the timer */ 185 outb_p(0xb6, 0x43); /* binary, mode 3, LSB/MSB, ch 2 */ 186 outb(chip->val61 & 0xFC, 0x61); 187 raw_spin_unlock(&i8253_lock); 188 } 189 190 /* 191 * Force to stop and sync the stream 192 */ 193 void pcsp_sync_stop(struct snd_pcsp *chip) 194 { 195 local_irq_disable(); 196 pcsp_stop_playing(chip); 197 local_irq_enable(); 198 hrtimer_cancel(&chip->timer); 199 tasklet_kill(&pcsp_pcm_tasklet); 200 } 201 202 static int snd_pcsp_playback_close(struct snd_pcm_substream *substream) 203 { 204 struct snd_pcsp *chip = snd_pcm_substream_chip(substream); 205 #if PCSP_DEBUG 206 printk(KERN_INFO "PCSP: close called\n"); 207 #endif 208 pcsp_sync_stop(chip); 209 chip->playback_substream = NULL; 210 return 0; 211 } 212 213 static int snd_pcsp_playback_hw_params(struct snd_pcm_substream *substream, 214 struct snd_pcm_hw_params *hw_params) 215 { 216 struct snd_pcsp *chip = snd_pcm_substream_chip(substream); 217 int err; 218 pcsp_sync_stop(chip); 219 err = snd_pcm_lib_malloc_pages(substream, 220 params_buffer_bytes(hw_params)); 221 if (err < 0) 222 return err; 223 return 0; 224 } 225 226 static int snd_pcsp_playback_hw_free(struct snd_pcm_substream *substream) 227 { 228 struct snd_pcsp *chip = snd_pcm_substream_chip(substream); 229 #if PCSP_DEBUG 230 printk(KERN_INFO "PCSP: hw_free called\n"); 231 #endif 232 pcsp_sync_stop(chip); 233 return snd_pcm_lib_free_pages(substream); 234 } 235 236 static int snd_pcsp_playback_prepare(struct snd_pcm_substream *substream) 237 { 238 struct snd_pcsp *chip = snd_pcm_substream_chip(substream); 239 pcsp_sync_stop(chip); 240 chip->playback_ptr = 0; 241 chip->period_ptr = 0; 242 chip->fmt_size = 243 snd_pcm_format_physical_width(substream->runtime->format) >> 3; 244 chip->is_signed = snd_pcm_format_signed(substream->runtime->format); 245 #if PCSP_DEBUG 246 printk(KERN_INFO "PCSP: prepare called, " 247 "size=%zi psize=%zi f=%zi f1=%i fsize=%i\n", 248 snd_pcm_lib_buffer_bytes(substream), 249 snd_pcm_lib_period_bytes(substream), 250 snd_pcm_lib_buffer_bytes(substream) / 251 snd_pcm_lib_period_bytes(substream), 252 substream->runtime->periods, 253 chip->fmt_size); 254 #endif 255 return 0; 256 } 257 258 static int snd_pcsp_trigger(struct snd_pcm_substream *substream, int cmd) 259 { 260 struct snd_pcsp *chip = snd_pcm_substream_chip(substream); 261 #if PCSP_DEBUG 262 printk(KERN_INFO "PCSP: trigger called\n"); 263 #endif 264 switch (cmd) { 265 case SNDRV_PCM_TRIGGER_START: 266 case SNDRV_PCM_TRIGGER_RESUME: 267 return pcsp_start_playing(chip); 268 case SNDRV_PCM_TRIGGER_STOP: 269 case SNDRV_PCM_TRIGGER_SUSPEND: 270 pcsp_stop_playing(chip); 271 break; 272 default: 273 return -EINVAL; 274 } 275 return 0; 276 } 277 278 static snd_pcm_uframes_t snd_pcsp_playback_pointer(struct snd_pcm_substream 279 *substream) 280 { 281 struct snd_pcsp *chip = snd_pcm_substream_chip(substream); 282 unsigned int pos; 283 spin_lock(&chip->substream_lock); 284 pos = chip->playback_ptr; 285 spin_unlock(&chip->substream_lock); 286 return bytes_to_frames(substream->runtime, pos); 287 } 288 289 static const struct snd_pcm_hardware snd_pcsp_playback = { 290 .info = (SNDRV_PCM_INFO_INTERLEAVED | 291 SNDRV_PCM_INFO_HALF_DUPLEX | 292 SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID), 293 .formats = (SNDRV_PCM_FMTBIT_U8 294 #if DMIX_WANTS_S16 295 | SNDRV_PCM_FMTBIT_S16_LE 296 #endif 297 ), 298 .rates = SNDRV_PCM_RATE_KNOT, 299 .rate_min = PCSP_DEFAULT_SRATE, 300 .rate_max = PCSP_DEFAULT_SRATE, 301 .channels_min = 1, 302 .channels_max = 1, 303 .buffer_bytes_max = PCSP_BUFFER_SIZE, 304 .period_bytes_min = 64, 305 .period_bytes_max = PCSP_MAX_PERIOD_SIZE, 306 .periods_min = 2, 307 .periods_max = PCSP_MAX_PERIODS, 308 .fifo_size = 0, 309 }; 310 311 static int snd_pcsp_playback_open(struct snd_pcm_substream *substream) 312 { 313 struct snd_pcsp *chip = snd_pcm_substream_chip(substream); 314 struct snd_pcm_runtime *runtime = substream->runtime; 315 #if PCSP_DEBUG 316 printk(KERN_INFO "PCSP: open called\n"); 317 #endif 318 if (atomic_read(&chip->timer_active)) { 319 printk(KERN_ERR "PCSP: still active!!\n"); 320 return -EBUSY; 321 } 322 runtime->hw = snd_pcsp_playback; 323 chip->playback_substream = substream; 324 return 0; 325 } 326 327 static const struct snd_pcm_ops snd_pcsp_playback_ops = { 328 .open = snd_pcsp_playback_open, 329 .close = snd_pcsp_playback_close, 330 .ioctl = snd_pcm_lib_ioctl, 331 .hw_params = snd_pcsp_playback_hw_params, 332 .hw_free = snd_pcsp_playback_hw_free, 333 .prepare = snd_pcsp_playback_prepare, 334 .trigger = snd_pcsp_trigger, 335 .pointer = snd_pcsp_playback_pointer, 336 }; 337 338 int snd_pcsp_new_pcm(struct snd_pcsp *chip) 339 { 340 int err; 341 342 err = snd_pcm_new(chip->card, "pcspeaker", 0, 1, 0, &chip->pcm); 343 if (err < 0) 344 return err; 345 346 snd_pcm_set_ops(chip->pcm, SNDRV_PCM_STREAM_PLAYBACK, 347 &snd_pcsp_playback_ops); 348 349 chip->pcm->private_data = chip; 350 chip->pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX; 351 strcpy(chip->pcm->name, "pcsp"); 352 353 snd_pcm_lib_preallocate_pages_for_all(chip->pcm, 354 SNDRV_DMA_TYPE_CONTINUOUS, 355 snd_dma_continuous_data 356 (GFP_KERNEL), PCSP_BUFFER_SIZE, 357 PCSP_BUFFER_SIZE); 358 359 return 0; 360 } 361