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

/*
 * 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/moduleparam.h>
#include <sound/pcm.h>
#include <linux/interrupt.h>
#include <asm/io.h>
#include "pcsp.h"

static int 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

static void pcsp_start_timer(unsigned long dummy)
{
	hrtimer_start(&pcsp_chip.timer, ktime_set(0, 0), HRTIMER_MODE_REL);
}

/*
 * We need the hrtimer_start as a tasklet to avoid
 * the nasty locking problem. :(
 * The problem:
 * - The timer handler is called with the cpu_base->lock
 *   already held by hrtimer code.
 * - snd_pcm_period_elapsed() takes the
 *   substream->self_group.lock.
 * So far so good.
 * But the snd_pcsp_trigger() is called with the
 * substream->self_group.lock held, and it calls
 * hrtimer_start(), which takes the cpu_base->lock.
 * You see the problem. We have the code pathes
 * which take two locks in a reverse order. This
 * can deadlock and the lock validator complains.
 * The only solution I could find was to move the
 * hrtimer_start() into a tasklet. -stsp
 */
static DECLARE_TASKLET(pcsp_start_timer_tasklet, pcsp_start_timer, 0);

enum hrtimer_restart pcsp_do_timer(struct hrtimer *handle)
{
	unsigned long flags;
	unsigned char timer_cnt, val;
	int fmt_size, periods_elapsed;
	u64 ns;
	size_t period_bytes, buffer_bytes;
	struct snd_pcm_substream *substream;
	struct snd_pcm_runtime *runtime;
	struct snd_pcsp *chip = container_of(handle, struct snd_pcsp, timer);

	if (chip->thalf) {
		outb(chip->val61, 0x61);
		chip->thalf = 0;
		if (!atomic_read(&chip->timer_active))
			return HRTIMER_NORESTART;
		hrtimer_forward(&chip->timer, chip->timer.expires,
				ktime_set(0, chip->ns_rem));
		return HRTIMER_RESTART;
	}

	/* hrtimer calls us from both hardirq and softirq contexts,
	 * so irqsave :( */
	spin_lock_irqsave(&chip->substream_lock, flags);
	/* Takashi Iwai says regarding this extra lock:

	If the irq handler handles some data on the DMA buffer, it should
	do snd_pcm_stream_lock().
	That protects basically against all races among PCM callbacks, yes.
	However, there are two remaining issues:
	1. The substream pointer you try to lock isn't protected _before_
	  this lock yet.
	2. snd_pcm_period_elapsed() itself acquires the lock.
	The requirement of another lock is because of 1.  When you get
	chip->playback_substream, it's not protected.
	Keeping this lock while snd_pcm_period_elapsed() assures the substream
	is still protected (at least, not released).  And the other status is
	handled properly inside snd_pcm_stream_lock() in
	snd_pcm_period_elapsed().

	*/
	if (!chip->playback_substream)
		goto exit_nr_unlock1;
	substream = chip->playback_substream;
	snd_pcm_stream_lock(substream);
	if (!atomic_read(&chip->timer_active))
		goto exit_nr_unlock2;

	runtime = substream->runtime;
	fmt_size = snd_pcm_format_physical_width(runtime->format) >> 3;
	/* assume it is mono! */
	val = runtime->dma_area[chip->playback_ptr + fmt_size - 1];
	if (snd_pcm_format_signed(runtime->format))
		val ^= 0x80;
	timer_cnt = val * CUR_DIV() / 256;

	if (timer_cnt && chip->enable) {
		spin_lock(&i8253_lock);
		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;
		}
		spin_unlock(&i8253_lock);
	}

	period_bytes = snd_pcm_lib_period_bytes(substream);
	buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
	chip->playback_ptr += PCSP_INDEX_INC() * fmt_size;
	periods_elapsed = chip->playback_ptr - chip->period_ptr;
	if (periods_elapsed < 0) {
		printk(KERN_WARNING "PCSP: playback_ptr inconsistent "
			"(%zi %zi %zi)\n",
			chip->playback_ptr, period_bytes, buffer_bytes);
		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;

	snd_pcm_stream_unlock(substream);

	if (periods_elapsed) {
		snd_pcm_period_elapsed(substream);
		chip->period_ptr += periods_elapsed * period_bytes;
		chip->period_ptr %= buffer_bytes;
	}

	spin_unlock_irqrestore(&chip->substream_lock, flags);

	if (!atomic_read(&chip->timer_active))
		return HRTIMER_NORESTART;

	chip->ns_rem = PCSP_PERIOD_NS();
	ns = (chip->thalf ? PCSP_CALC_NS(timer_cnt) : chip->ns_rem);
	chip->ns_rem -= ns;
	hrtimer_forward(&chip->timer, chip->timer.expires, ktime_set(0, ns));
	return HRTIMER_RESTART;

exit_nr_unlock2:
	snd_pcm_stream_unlock(substream);
exit_nr_unlock1:
	spin_unlock_irqrestore(&chip->substream_lock, flags);
	return HRTIMER_NORESTART;
}

static void 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;
	}

	spin_lock(&i8253_lock);
	chip->val61 = inb(0x61) | 0x03;
	outb_p(0x92, 0x43);	/* binary, mode 1, LSB only, ch 2 */
	spin_unlock(&i8253_lock);
	atomic_set(&chip->timer_active, 1);
	chip->thalf = 0;

	tasklet_schedule(&pcsp_start_timer_tasklet);
}

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);
	spin_lock(&i8253_lock);
	/* restore the timer */
	outb_p(0xb6, 0x43);	/* binary, mode 3, LSB/MSB, ch 2 */
	outb(chip->val61 & 0xFC, 0x61);
	spin_unlock(&i8253_lock);
}

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
	if (atomic_read(&chip->timer_active)) {
		printk(KERN_ERR "PCSP: timer still active\n");
		pcsp_stop_playing(chip);
	}
	spin_lock_irq(&chip->substream_lock);
	chip->playback_substream = NULL;
	spin_unlock_irq(&chip->substream_lock);
	return 0;
}

static int snd_pcsp_playback_hw_params(struct snd_pcm_substream *substream,
				       struct snd_pcm_hw_params *hw_params)
{
	int err;
	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)
{
#if PCSP_DEBUG
	printk(KERN_INFO "PCSP: hw_free called\n");
#endif
	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);
#if PCSP_DEBUG
	printk(KERN_INFO "PCSP: prepare called, "
			"size=%zi psize=%zi f=%zi f1=%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);
#endif
	chip->playback_ptr = 0;
	chip->period_ptr = 0;
	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:
		pcsp_start_playing(chip);
		break;
	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);
	return bytes_to_frames(substream->runtime, chip->playback_ptr);
}

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;
	spin_lock_irq(&chip->substream_lock);
	chip->playback_substream = substream;
	spin_unlock_irq(&chip->substream_lock);
	return 0;
}

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