text: /*
   * PC-Speaker driver for Linux
   *
   * Copyright (C) 1993-1997  Michael Beck
   * Copyright (C) 1997-2001  David Woodhouse
   * Copyright (C) 2001-2008  Stas Sergeev
   */
  
  #include <linux/module.h>
  #include <linux/gfp.h>
  #include <linux/moduleparam.h>
  #include <linux/interrupt.h>
  #include <linux/io.h>
  #include <sound/pcm.h>
  #include "pcsp.h"
  
  static bool nforce_wa;
  module_param(nforce_wa, bool, 0444);
  MODULE_PARM_DESC(nforce_wa, "Apply NForce chipset workaround "
  		"(expect bad sound)");
  
  #define DMIX_WANTS_S16	1
  
  /*
   * Call snd_pcm_period_elapsed in a tasklet
   * This avoids spinlock messes and long-running irq contexts
   */
  static void pcsp_call_pcm_elapsed(unsigned long priv)
  {
  	if (atomic_read(&pcsp_chip.timer_active)) {
  		struct snd_pcm_substream *substream;
  		substream = pcsp_chip.playback_substream;
  		if (substream)
  			snd_pcm_period_elapsed(substream);
  	}
  }
  
  static DECLARE_TASKLET(pcsp_pcm_tasklet, pcsp_call_pcm_elapsed, 0);
  
  /* write the port and returns the next expire time in ns;
   * called at the trigger-start and in hrtimer callback
   */
  static u64 pcsp_timer_update(struct snd_pcsp *chip)
  {
  	unsigned char timer_cnt, val;
  	u64 ns;
  	struct snd_pcm_substream *substream;
  	struct snd_pcm_runtime *runtime;
  	unsigned long flags;
  
  	if (chip->thalf) {
  		outb(chip->val61, 0x61);
  		chip->thalf = 0;
  		return chip->ns_rem;
  	}
  
  	substream = chip->playback_substream;
  	if (!substream)
  		return 0;
  
  	runtime = substream->runtime;
  	/* assume it is mono! */
  	val = runtime->dma_area[chip->playback_ptr + chip->fmt_size - 1];
  	if (chip->is_signed)
  		val ^= 0x80;
  	timer_cnt = val * CUR_DIV() / 256;
  
  	if (timer_cnt && chip->enable) {
  		raw_spin_lock_irqsave(&i8253_lock, flags);
  		if (!nforce_wa) {
  			outb_p(chip->val61, 0x61);
  			outb_p(timer_cnt, 0x42);
  			outb(chip->val61 ^ 1, 0x61);
  		} else {
  			outb(chip->val61 ^ 2, 0x61);
  			chip->thalf = 1;
  		}
  		raw_spin_unlock_irqrestore(&i8253_lock, flags);
  	}
  
  	chip->ns_rem = PCSP_PERIOD_NS();
  	ns = (chip->thalf ? PCSP_CALC_NS(timer_cnt) : chip->ns_rem);
  	chip->ns_rem -= ns;
  	return ns;
  }
  
  static void pcsp_pointer_update(struct snd_pcsp *chip)
  {
  	struct snd_pcm_substream *substream;
  	size_t period_bytes, buffer_bytes;
  	int periods_elapsed;
  	unsigned long flags;
  
  	/* update the playback position */
  	substream = chip->playback_substream;
  	if (!substream)
  		return;
  
  	period_bytes = snd_pcm_lib_period_bytes(substream);
  	buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
  
  	spin_lock_irqsave(&chip->substream_lock, flags);
  	chip->playback_ptr += PCSP_INDEX_INC() * chip->fmt_size;
  	periods_elapsed = chip->playback_ptr - chip->period_ptr;
  	if (periods_elapsed < 0) {
  #if PCSP_DEBUG
  		printk(KERN_INFO "PCSP: buffer_bytes mod period_bytes != 0 ? "
  			"(%zi %zi %zi)\n",
  			chip->playback_ptr, period_bytes, buffer_bytes);
  #endif
  		periods_elapsed += buffer_bytes;
  	}
  	periods_elapsed /= period_bytes;
  	/* wrap the pointer _before_ calling snd_pcm_period_elapsed(),
  	 * or ALSA will BUG on us. */
  	chip->playback_ptr %= buffer_bytes;
  
  	if (periods_elapsed) {
  		chip->period_ptr += periods_elapsed * period_bytes;
  		chip->period_ptr %= buffer_bytes;
  	}
  	spin_unlock_irqrestore(&chip->substream_lock, flags);
  
  	if (periods_elapsed)
  		tasklet_schedule(&pcsp_pcm_tasklet);
  }
  
  enum hrtimer_restart pcsp_do_timer(struct hrtimer *handle)
  {
  	struct snd_pcsp *chip = container_of(handle, struct snd_pcsp, timer);
  	int pointer_update;
  	u64 ns;
  
  	if (!atomic_read(&chip->timer_active) || !chip->playback_substream)
  		return HRTIMER_NORESTART;
  
  	pointer_update = !chip->thalf;
  	ns = pcsp_timer_update(chip);
  	if (!ns) {
  		printk(KERN_WARNING "PCSP: unexpected stop\n");
  		return HRTIMER_NORESTART;
  	}
  
  	if (pointer_update)
  		pcsp_pointer_update(chip);
  
  	hrtimer_forward(handle, hrtimer_get_expires(handle), ns_to_ktime(ns));
  
  	return HRTIMER_RESTART;
  }
  
  static int pcsp_start_playing(struct snd_pcsp *chip)
  {
  #if PCSP_DEBUG
  	printk(KERN_INFO "PCSP: start_playing called\n");
  #endif
  	if (atomic_read(&chip->timer_active)) {
  		printk(KERN_ERR "PCSP: Timer already active\n");
  		return -EIO;
  	}
  
  	raw_spin_lock(&i8253_lock);
  	chip->val61 = inb(0x61) | 0x03;
  	outb_p(0x92, 0x43);	/* binary, mode 1, LSB only, ch 2 */
  	raw_spin_unlock(&i8253_lock);
  	atomic_set(&chip->timer_active, 1);
  	chip->thalf = 0;
  
  	hrtimer_start(&pcsp_chip.timer, 0, HRTIMER_MODE_REL);
  	return 0;
  }
  
  static void pcsp_stop_playing(struct snd_pcsp *chip)
  {
  #if PCSP_DEBUG
  	printk(KERN_INFO "PCSP: stop_playing called\n");
  #endif
  	if (!atomic_read(&chip->timer_active))
  		return;
  
  	atomic_set(&chip->timer_active, 0);
  	raw_spin_lock(&i8253_lock);
  	/* restore the timer */
  	outb_p(0xb6, 0x43);	/* binary, mode 3, LSB/MSB, ch 2 */
  	outb(chip->val61 & 0xFC, 0x61);
  	raw_spin_unlock(&i8253_lock);
  }
  
  /*
   * Force to stop and sync the stream
   */
  void pcsp_sync_stop(struct snd_pcsp *chip)
  {
  	local_irq_disable();
  	pcsp_stop_playing(chip);
  	local_irq_enable();
  	hrtimer_cancel(&chip->timer);
  	tasklet_kill(&pcsp_pcm_tasklet);
  }
  
  static int snd_pcsp_playback_close(struct snd_pcm_substream *substream)
  {
  	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
  #if PCSP_DEBUG
  	printk(KERN_INFO "PCSP: close called\n");
  #endif
  	pcsp_sync_stop(chip);
  	chip->playback_substream = NULL;
  	return 0;
  }
  
  static int snd_pcsp_playback_hw_params(struct snd_pcm_substream *substream,
  				       struct snd_pcm_hw_params *hw_params)
  {
  	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
  	int err;
  	pcsp_sync_stop(chip);
  	err = snd_pcm_lib_malloc_pages(substream,
  				      params_buffer_bytes(hw_params));
  	if (err < 0)
  		return err;
  	return 0;
  }
  
  static int snd_pcsp_playback_hw_free(struct snd_pcm_substream *substream)
  {
  	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
  #if PCSP_DEBUG
  	printk(KERN_INFO "PCSP: hw_free called\n");
  #endif
  	pcsp_sync_stop(chip);
  	return snd_pcm_lib_free_pages(substream);
  }
  
  static int snd_pcsp_playback_prepare(struct snd_pcm_substream *substream)
  {
  	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
  	pcsp_sync_stop(chip);
  	chip->playback_ptr = 0;
  	chip->period_ptr = 0;
  	chip->fmt_size =
  		snd_pcm_format_physical_width(substream->runtime->format) >> 3;
  	chip->is_signed = snd_pcm_format_signed(substream->runtime->format);
  #if PCSP_DEBUG
  	printk(KERN_INFO "PCSP: prepare called, "
  			"size=%zi psize=%zi f=%zi f1=%i fsize=%i\n",
  			snd_pcm_lib_buffer_bytes(substream),
  			snd_pcm_lib_period_bytes(substream),
  			snd_pcm_lib_buffer_bytes(substream) /
  			snd_pcm_lib_period_bytes(substream),
  			substream->runtime->periods,
  			chip->fmt_size);
  #endif
  	return 0;
  }
  
  static int snd_pcsp_trigger(struct snd_pcm_substream *substream, int cmd)
  {
  	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
  #if PCSP_DEBUG
  	printk(KERN_INFO "PCSP: trigger called\n");
  #endif
  	switch (cmd) {
  	case SNDRV_PCM_TRIGGER_START:
  	case SNDRV_PCM_TRIGGER_RESUME:
  		return pcsp_start_playing(chip);
  	case SNDRV_PCM_TRIGGER_STOP:
  	case SNDRV_PCM_TRIGGER_SUSPEND:
  		pcsp_stop_playing(chip);
  		break;
  	default:
  		return -EINVAL;
  	}
  	return 0;
  }
  
  static snd_pcm_uframes_t snd_pcsp_playback_pointer(struct snd_pcm_substream
  						   *substream)
  {
  	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
  	unsigned int pos;
  	spin_lock(&chip->substream_lock);
  	pos = chip->playback_ptr;
  	spin_unlock(&chip->substream_lock);
  	return bytes_to_frames(substream->runtime, pos);
  }
  
  static struct snd_pcm_hardware snd_pcsp_playback = {
  	.info = (SNDRV_PCM_INFO_INTERLEAVED |
  		 SNDRV_PCM_INFO_HALF_DUPLEX |
  		 SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID),
  	.formats = (SNDRV_PCM_FMTBIT_U8
  #if DMIX_WANTS_S16
  		    | SNDRV_PCM_FMTBIT_S16_LE
  #endif
  	    ),
  	.rates = SNDRV_PCM_RATE_KNOT,
  	.rate_min = PCSP_DEFAULT_SRATE,
  	.rate_max = PCSP_DEFAULT_SRATE,
  	.channels_min = 1,
  	.channels_max = 1,
  	.buffer_bytes_max = PCSP_BUFFER_SIZE,
  	.period_bytes_min = 64,
  	.period_bytes_max = PCSP_MAX_PERIOD_SIZE,
  	.periods_min = 2,
  	.periods_max = PCSP_MAX_PERIODS,
  	.fifo_size = 0,
  };
  
  static int snd_pcsp_playback_open(struct snd_pcm_substream *substream)
  {
  	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  #if PCSP_DEBUG
  	printk(KERN_INFO "PCSP: open called\n");
  #endif
  	if (atomic_read(&chip->timer_active)) {
  		printk(KERN_ERR "PCSP: still active!!\n");
  		return -EBUSY;
  	}
  	runtime->hw = snd_pcsp_playback;
  	chip->playback_substream = substream;
  	return 0;
  }
  
  static const struct snd_pcm_ops snd_pcsp_playback_ops = {
  	.open = snd_pcsp_playback_open,
  	.close = snd_pcsp_playback_close,
  	.ioctl = snd_pcm_lib_ioctl,
  	.hw_params = snd_pcsp_playback_hw_params,
  	.hw_free = snd_pcsp_playback_hw_free,
  	.prepare = snd_pcsp_playback_prepare,
  	.trigger = snd_pcsp_trigger,
  	.pointer = snd_pcsp_playback_pointer,
  };
  
  int snd_pcsp_new_pcm(struct snd_pcsp *chip)
  {
  	int err;
  
  	err = snd_pcm_new(chip->card, "pcspeaker", 0, 1, 0, &chip->pcm);
  	if (err < 0)
  		return err;
  
  	snd_pcm_set_ops(chip->pcm, SNDRV_PCM_STREAM_PLAYBACK,
  			&snd_pcsp_playback_ops);
  
  	chip->pcm->private_data = chip;
  	chip->pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
  	strcpy(chip->pcm->name, "pcsp");
  
  	snd_pcm_lib_preallocate_pages_for_all(chip->pcm,
  					      SNDRV_DMA_TYPE_CONTINUOUS,
  					      snd_dma_continuous_data
  					      (GFP_KERNEL), PCSP_BUFFER_SIZE,
  					      PCSP_BUFFER_SIZE);
  
  	return 0;
  }
  