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