[mirror_ubuntu-bionic-kernel.git] / sound / drivers / pcsp / pcsp_lib.c

// SPDX-License-Identifier: GPL-2.0
/*
 * 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 const 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;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
9ab4d072 SS	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>
5a0e3ad6	11	#include <linux/gfp.h>
9ab4d072	12	#include <linux/moduleparam.h>
96c7d478	13	#include <linux/interrupt.h>
6cbbfe1c	14	#include <linux/io.h>
9ab4d072	15	#include <sound/pcm.h>
9ab4d072 SS	16	#include "pcsp.h"
9ab4d072 SS	17
a67ff6a5	18	static bool nforce_wa;
9ab4d072 SS	19	module_param(nforce_wa, bool, 0444);
	20	MODULE_PARM_DESC(nforce_wa, "Apply NForce chipset workaround "
	21	"(expect bad sound)");
	22
4dfd7954 SS	23	#define DMIX_WANTS_S16 1
4dfd7954 SS	24
96c7d478 TI	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
eea0579f TI	41	/* write the port and returns the next expire time in ns;
	42	* called at the trigger-start and in hrtimer callback
	43	*/
b71207e9	44	static u64 pcsp_timer_update(struct snd_pcsp *chip)
9ab4d072	45	{
9ab4d072	46	unsigned char timer_cnt, val;
9ab4d072	47	u64 ns;
9ab4d072 SS	48	struct snd_pcm_substream *substream;
9ab4d072 SS	49	struct snd_pcm_runtime *runtime;
96c7d478	50	unsigned long flags;
9ab4d072 SS	51
	52	if (chip->thalf) {
	53	outb(chip->val61, 0x61);
	54	chip->thalf = 0;
eea0579f	55	return chip->ns_rem;
9ab4d072 SS	56	}
9ab4d072 SS	57
96c7d478 TI	58	substream = chip->playback_substream;
96c7d478 TI	59	if (!substream)
eea0579f	60	return 0;
9ab4d072 SS	61
9ab4d072 SS	62	runtime = substream->runtime;
4dfd7954	63	/* assume it is mono! */
eea0579f TI	64	val = runtime->dma_area[chip->playback_ptr + chip->fmt_size - 1];
eea0579f TI	65	if (chip->is_signed)
4dfd7954	66	val ^= 0x80;
9ab4d072 SS	67	timer_cnt = val * CUR_DIV() / 256;
	68
	69	if (timer_cnt && chip->enable) {
ced918eb	70	raw_spin_lock_irqsave(&i8253_lock, flags);
9ab4d072 SS	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	}
ced918eb	79	raw_spin_unlock_irqrestore(&i8253_lock, flags);
9ab4d072 SS	80	}
9ab4d072 SS	81
eea0579f TI	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
b71207e9	88	static void pcsp_pointer_update(struct snd_pcsp *chip)
eea0579f	89	{
eea0579f	90	struct snd_pcm_substream *substream;
eea0579f	91	size_t period_bytes, buffer_bytes;
b71207e9	92	int periods_elapsed;
eea0579f TI	93	unsigned long flags;
eea0579f TI	94
eea0579f TI	95	/* update the playback position */
	96	substream = chip->playback_substream;
	97	if (!substream)
b71207e9	98	return;
eea0579f	99
9ab4d072 SS	100	period_bytes = snd_pcm_lib_period_bytes(substream);
9ab4d072 SS	101	buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
96c7d478 TI	102
96c7d478 TI	103	spin_lock_irqsave(&chip->substream_lock, flags);
eea0579f	104	chip->playback_ptr += PCSP_INDEX_INC() * chip->fmt_size;
9ab4d072 SS	105	periods_elapsed = chip->playback_ptr - chip->period_ptr;
9ab4d072 SS	106	if (periods_elapsed < 0) {
42ece6c1 SS	107	#if PCSP_DEBUG
42ece6c1 SS	108	printk(KERN_INFO "PCSP: buffer_bytes mod period_bytes != 0 ? "
9ab4d072 SS	109	"(%zi %zi %zi)\n",
9ab4d072 SS	110	chip->playback_ptr, period_bytes, buffer_bytes);
42ece6c1	111	#endif
9ab4d072 SS	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
9ab4d072	119	if (periods_elapsed) {
9ab4d072 SS	120	chip->period_ptr += periods_elapsed * period_bytes;
	121	chip->period_ptr %= buffer_bytes;
	122	}
96c7d478	123	spin_unlock_irqrestore(&chip->substream_lock, flags);
9ab4d072	124
eea0579f TI	125	if (periods_elapsed)
eea0579f TI	126	tasklet_schedule(&pcsp_pcm_tasklet);
b71207e9 SS	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);
9ab4d072	147
eea0579f	148	hrtimer_forward(handle, hrtimer_get_expires(handle), ns_to_ktime(ns));
9ab4d072	149
eea0579f	150	return HRTIMER_RESTART;
9ab4d072 SS	151	}
9ab4d072 SS	152
eea0579f	153	static int pcsp_start_playing(struct snd_pcsp *chip)
9ab4d072 SS	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");
eea0579f	160	return -EIO;
9ab4d072 SS	161	}
9ab4d072 SS	162
ced918eb	163	raw_spin_lock(&i8253_lock);
9ab4d072 SS	164	chip->val61 = inb(0x61) \| 0x03;
9ab4d072 SS	165	outb_p(0x92, 0x43); /* binary, mode 1, LSB only, ch 2 */
ced918eb	166	raw_spin_unlock(&i8253_lock);
9ab4d072 SS	167	atomic_set(&chip->timer_active, 1);
	168	chip->thalf = 0;
	169
8b0e1953	170	hrtimer_start(&pcsp_chip.timer, 0, HRTIMER_MODE_REL);
eea0579f	171	return 0;
9ab4d072 SS	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);
ced918eb	183	raw_spin_lock(&i8253_lock);
9ab4d072 SS	184	/* restore the timer */
	185	outb_p(0xb6, 0x43); /* binary, mode 3, LSB/MSB, ch 2 */
	186	outb(chip->val61 & 0xFC, 0x61);
ced918eb	187	raw_spin_unlock(&i8253_lock);
9ab4d072 SS	188	}
9ab4d072 SS	189
96c7d478 TI	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
9ab4d072 SS	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
96c7d478	208	pcsp_sync_stop(chip);
9ab4d072	209	chip->playback_substream = NULL;
9ab4d072 SS	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	{
96c7d478	216	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
9ab4d072	217	int err;
96c7d478	218	pcsp_sync_stop(chip);
9ab4d072 SS	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	{
96c7d478	228	struct snd_pcsp *chip = snd_pcm_substream_chip(substream);
9ab4d072 SS	229	#if PCSP_DEBUG
	230	printk(KERN_INFO "PCSP: hw_free called\n");
	231	#endif
96c7d478	232	pcsp_sync_stop(chip);
9ab4d072 SS	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);
b71207e9 SS	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);
9ab4d072 SS	245	#if PCSP_DEBUG
9ab4d072 SS	246	printk(KERN_INFO "PCSP: prepare called, "
b71207e9	247	"size=%zi psize=%zi f=%zi f1=%i fsize=%i\n",
9ab4d072 SS	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),
b71207e9 SS	252	substream->runtime->periods,
b71207e9 SS	253	chip->fmt_size);
9ab4d072	254	#endif
9ab4d072 SS	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:
eea0579f	267	return pcsp_start_playing(chip);
9ab4d072 SS	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);
96c7d478 TI	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);
9ab4d072 SS	287	}
9ab4d072 SS	288
b6c0b715	289	static const struct snd_pcm_hardware snd_pcsp_playback = {
9ab4d072 SS	290	.info = (SNDRV_PCM_INFO_INTERLEAVED \|
	291	SNDRV_PCM_INFO_HALF_DUPLEX \|
	292	SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID),
4dfd7954 SS	293	.formats = (SNDRV_PCM_FMTBIT_U8
	294	#if DMIX_WANTS_S16
	295	\| SNDRV_PCM_FMTBIT_S16_LE
	296	#endif
	297	),
9ab4d072 SS	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
642b7589	327	static const struct snd_pcm_ops snd_pcsp_playback_ops = {
9ab4d072 SS	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
fbbb01a1	338	int snd_pcsp_new_pcm(struct snd_pcsp *chip)
9ab4d072 SS	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	}