git.oblomov.eu Git - linux-2.6/blob - sound/drivers/pcsp/pcsp_lib.c

   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 <sound/pcm.h>
  12 #include <asm/io.h>
  13 #include "pcsp.h"
  14
  15 static int nforce_wa;
  16 module_param(nforce_wa, bool, 0444);
  17 MODULE_PARM_DESC(nforce_wa, "Apply NForce chipset workaround "
  18                 "(expect bad sound)");
  19
  20 #define DMIX_WANTS_S16  1
  21
  22 enum hrtimer_restart pcsp_do_timer(struct hrtimer *handle)
  23 {
  24         unsigned char timer_cnt, val;
  25         int fmt_size, periods_elapsed;
  26         u64 ns;
  27         size_t period_bytes, buffer_bytes;
  28         struct snd_pcm_substream *substream;
  29         struct snd_pcm_runtime *runtime;
  30         struct snd_pcsp *chip = container_of(handle, struct snd_pcsp, timer);
  31
  32         if (chip->thalf) {
  33                 outb(chip->val61, 0x61);
  34                 chip->thalf = 0;
  35                 if (!atomic_read(&chip->timer_active))
  36                         return HRTIMER_NORESTART;
  37                 hrtimer_forward(&chip->timer, hrtimer_get_expires(&chip->timer),
  38                                 ktime_set(0, chip->ns_rem));
  39                 return HRTIMER_RESTART;
  40         }
  41
  42         spin_lock_irq(&chip->substream_lock);
  43         /* Takashi Iwai says regarding this extra lock:
  44
  45         If the irq handler handles some data on the DMA buffer, it should
  46         do snd_pcm_stream_lock().
  47         That protects basically against all races among PCM callbacks, yes.
  48         However, there are two remaining issues:
  49         1. The substream pointer you try to lock isn't protected _before_
  50           this lock yet.
  51         2. snd_pcm_period_elapsed() itself acquires the lock.
  52         The requirement of another lock is because of 1.  When you get
  53         chip->playback_substream, it's not protected.
  54         Keeping this lock while snd_pcm_period_elapsed() assures the substream
  55         is still protected (at least, not released).  And the other status is
  56         handled properly inside snd_pcm_stream_lock() in
  57         snd_pcm_period_elapsed().
  58
  59         */
  60         if (!chip->playback_substream)
  61                 goto exit_nr_unlock1;
  62         substream = chip->playback_substream;
  63         snd_pcm_stream_lock(substream);
  64         if (!atomic_read(&chip->timer_active))
  65                 goto exit_nr_unlock2;
  66
  67         runtime = substream->runtime;
  68         fmt_size = snd_pcm_format_physical_width(runtime->format) >> 3;
  69         /* assume it is mono! */
  70         val = runtime->dma_area[chip->playback_ptr + fmt_size - 1];
  71         if (snd_pcm_format_signed(runtime->format))
  72                 val ^= 0x80;
  73         timer_cnt = val * CUR_DIV() / 256;
  74
  75         if (timer_cnt && chip->enable) {
  76                 spin_lock(&i8253_lock);
  77                 if (!nforce_wa) {
  78                         outb_p(chip->val61, 0x61);
  79                         outb_p(timer_cnt, 0x42);
  80                         outb(chip->val61 ^ 1, 0x61);
  81                 } else {
  82                         outb(chip->val61 ^ 2, 0x61);
  83                         chip->thalf = 1;
  84                 }
  85                 spin_unlock(&i8253_lock);
  86         }
  87
  88         period_bytes = snd_pcm_lib_period_bytes(substream);
  89         buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
  90         chip->playback_ptr += PCSP_INDEX_INC() * fmt_size;
  91         periods_elapsed = chip->playback_ptr - chip->period_ptr;
  92         if (periods_elapsed < 0) {
  93 #if PCSP_DEBUG
  94                 printk(KERN_INFO "PCSP: buffer_bytes mod period_bytes != 0 ? "
  95                         "(%zi %zi %zi)\n",
  96                         chip->playback_ptr, period_bytes, buffer_bytes);
  97 #endif
  98                 periods_elapsed += buffer_bytes;
  99         }
 100         periods_elapsed /= period_bytes;
 101         /* wrap the pointer _before_ calling snd_pcm_period_elapsed(),
 102          * or ALSA will BUG on us. */
 103         chip->playback_ptr %= buffer_bytes;
 104
 105         snd_pcm_stream_unlock(substream);
 106
 107         if (periods_elapsed) {
 108                 snd_pcm_period_elapsed(substream);
 109                 chip->period_ptr += periods_elapsed * period_bytes;
 110                 chip->period_ptr %= buffer_bytes;
 111         }
 112
 113         spin_unlock_irq(&chip->substream_lock);
 114
 115         if (!atomic_read(&chip->timer_active))
 116                 return HRTIMER_NORESTART;
 117
 118         chip->ns_rem = PCSP_PERIOD_NS();
 119         ns = (chip->thalf ? PCSP_CALC_NS(timer_cnt) : chip->ns_rem);
 120         chip->ns_rem -= ns;
 121         hrtimer_forward(&chip->timer, hrtimer_get_expires(&chip->timer),
 122                                                         ktime_set(0, ns));
 123         return HRTIMER_RESTART;
 124
 125 exit_nr_unlock2:
 126         snd_pcm_stream_unlock(substream);
 127 exit_nr_unlock1:
 128         spin_unlock_irq(&chip->substream_lock);
 129         return HRTIMER_NORESTART;
 130 }
 131
 132 static void pcsp_start_playing(struct snd_pcsp *chip)
 133 {
 134 #if PCSP_DEBUG
 135         printk(KERN_INFO "PCSP: start_playing called\n");
 136 #endif
 137         if (atomic_read(&chip->timer_active)) {
 138                 printk(KERN_ERR "PCSP: Timer already active\n");
 139                 return;
 140         }
 141
 142         spin_lock(&i8253_lock);
 143         chip->val61 = inb(0x61) | 0x03;
 144         outb_p(0x92, 0x43);     /* binary, mode 1, LSB only, ch 2 */
 145         spin_unlock(&i8253_lock);
 146         atomic_set(&chip->timer_active, 1);
 147         chip->thalf = 0;
 148
 149         hrtimer_start(&pcsp_chip.timer, ktime_set(0, 0), HRTIMER_MODE_REL);
 150 }
 151
 152 static void pcsp_stop_playing(struct snd_pcsp *chip)
 153 {
 154 #if PCSP_DEBUG
 155         printk(KERN_INFO "PCSP: stop_playing called\n");
 156 #endif
 157         if (!atomic_read(&chip->timer_active))
 158                 return;
 159
 160         atomic_set(&chip->timer_active, 0);
 161         spin_lock(&i8253_lock);
 162         /* restore the timer */
 163         outb_p(0xb6, 0x43);     /* binary, mode 3, LSB/MSB, ch 2 */
 164         outb(chip->val61 & 0xFC, 0x61);
 165         spin_unlock(&i8253_lock);
 166 }
 167
 168 static int snd_pcsp_playback_close(struct snd_pcm_substream *substream)
 169 {
 170         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
 171 #if PCSP_DEBUG
 172         printk(KERN_INFO "PCSP: close called\n");
 173 #endif
 174         if (atomic_read(&chip->timer_active)) {
 175                 printk(KERN_ERR "PCSP: timer still active\n");
 176                 pcsp_stop_playing(chip);
 177         }
 178         spin_lock_irq(&chip->substream_lock);
 179         chip->playback_substream = NULL;
 180         spin_unlock_irq(&chip->substream_lock);
 181         return 0;
 182 }
 183
 184 static int snd_pcsp_playback_hw_params(struct snd_pcm_substream *substream,
 185                                        struct snd_pcm_hw_params *hw_params)
 186 {
 187         int err;
 188         err = snd_pcm_lib_malloc_pages(substream,
 189                                       params_buffer_bytes(hw_params));
 190         if (err < 0)
 191                 return err;
 192         return 0;
 193 }
 194
 195 static int snd_pcsp_playback_hw_free(struct snd_pcm_substream *substream)
 196 {
 197 #if PCSP_DEBUG
 198         printk(KERN_INFO "PCSP: hw_free called\n");
 199 #endif
 200         return snd_pcm_lib_free_pages(substream);
 201 }
 202
 203 static int snd_pcsp_playback_prepare(struct snd_pcm_substream *substream)
 204 {
 205         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
 206 #if PCSP_DEBUG
 207         printk(KERN_INFO "PCSP: prepare called, "
 208                         "size=%zi psize=%zi f=%zi f1=%i\n",
 209                         snd_pcm_lib_buffer_bytes(substream),
 210                         snd_pcm_lib_period_bytes(substream),
 211                         snd_pcm_lib_buffer_bytes(substream) /
 212                         snd_pcm_lib_period_bytes(substream),
 213                         substream->runtime->periods);
 214 #endif
 215         chip->playback_ptr = 0;
 216         chip->period_ptr = 0;
 217         return 0;
 218 }
 219
 220 static int snd_pcsp_trigger(struct snd_pcm_substream *substream, int cmd)
 221 {
 222         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
 223 #if PCSP_DEBUG
 224         printk(KERN_INFO "PCSP: trigger called\n");
 225 #endif
 226         switch (cmd) {
 227         case SNDRV_PCM_TRIGGER_START:
 228         case SNDRV_PCM_TRIGGER_RESUME:
 229                 pcsp_start_playing(chip);
 230                 break;
 231         case SNDRV_PCM_TRIGGER_STOP:
 232         case SNDRV_PCM_TRIGGER_SUSPEND:
 233                 pcsp_stop_playing(chip);
 234                 break;
 235         default:
 236                 return -EINVAL;
 237         }
 238         return 0;
 239 }
 240
 241 static snd_pcm_uframes_t snd_pcsp_playback_pointer(struct snd_pcm_substream
 242                                                    *substream)
 243 {
 244         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
 245         return bytes_to_frames(substream->runtime, chip->playback_ptr);
 246 }
 247
 248 static struct snd_pcm_hardware snd_pcsp_playback = {
 249         .info = (SNDRV_PCM_INFO_INTERLEAVED |
 250                  SNDRV_PCM_INFO_HALF_DUPLEX |
 251                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID),
 252         .formats = (SNDRV_PCM_FMTBIT_U8
 253 #if DMIX_WANTS_S16
 254                     | SNDRV_PCM_FMTBIT_S16_LE
 255 #endif
 256             ),
 257         .rates = SNDRV_PCM_RATE_KNOT,
 258         .rate_min = PCSP_DEFAULT_SRATE,
 259         .rate_max = PCSP_DEFAULT_SRATE,
 260         .channels_min = 1,
 261         .channels_max = 1,
 262         .buffer_bytes_max = PCSP_BUFFER_SIZE,
 263         .period_bytes_min = 64,
 264         .period_bytes_max = PCSP_MAX_PERIOD_SIZE,
 265         .periods_min = 2,
 266         .periods_max = PCSP_MAX_PERIODS,
 267         .fifo_size = 0,
 268 };
 269
 270 static int snd_pcsp_playback_open(struct snd_pcm_substream *substream)
 271 {
 272         struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
 273         struct snd_pcm_runtime *runtime = substream->runtime;
 274 #if PCSP_DEBUG
 275         printk(KERN_INFO "PCSP: open called\n");
 276 #endif
 277         if (atomic_read(&chip->timer_active)) {
 278                 printk(KERN_ERR "PCSP: still active!!\n");
 279                 return -EBUSY;
 280         }
 281         runtime->hw = snd_pcsp_playback;
 282         spin_lock_irq(&chip->substream_lock);
 283         chip->playback_substream = substream;
 284         spin_unlock_irq(&chip->substream_lock);
 285         return 0;
 286 }
 287
 288 static struct snd_pcm_ops snd_pcsp_playback_ops = {
 289         .open = snd_pcsp_playback_open,
 290         .close = snd_pcsp_playback_close,
 291         .ioctl = snd_pcm_lib_ioctl,
 292         .hw_params = snd_pcsp_playback_hw_params,
 293         .hw_free = snd_pcsp_playback_hw_free,
 294         .prepare = snd_pcsp_playback_prepare,
 295         .trigger = snd_pcsp_trigger,
 296         .pointer = snd_pcsp_playback_pointer,
 297 };
 298
 299 int __devinit snd_pcsp_new_pcm(struct snd_pcsp *chip)
 300 {
 301         int err;
 302
 303         err = snd_pcm_new(chip->card, "pcspeaker", 0, 1, 0, &chip->pcm);
 304         if (err < 0)
 305                 return err;
 306
 307         snd_pcm_set_ops(chip->pcm, SNDRV_PCM_STREAM_PLAYBACK,
 308                         &snd_pcsp_playback_ops);
 309
 310         chip->pcm->private_data = chip;
 311         chip->pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
 312         strcpy(chip->pcm->name, "pcsp");
 313
 314         snd_pcm_lib_preallocate_pages_for_all(chip->pcm,
 315                                               SNDRV_DMA_TYPE_CONTINUOUS,
 316                                               snd_dma_continuous_data
 317                                               (GFP_KERNEL), PCSP_BUFFER_SIZE,
 318                                               PCSP_BUFFER_SIZE);
 319
 320         return 0;
 321 }