/**

 * \file pcm/pcm_hw.c

 * \ingroup PCM_Plugins

 * \brief PCM HW Plugin Interface

 * \author Abramo Bagnara <abramo@alsa-project.org>

 * \author Jaroslav Kysela <perex@perex.cz>

 * \date 2000-2001

 */

/*

 *  PCM - Hardware

 *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>

 *

 *

 *   This library is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as

 *   published by the Free Software Foundation; either version 2.1 of

 *   the License, or (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public

 *   License along with this library; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <stddef.h>

#include <unistd.h>

#include <stdbool.h>

#include <signal.h>

#include <string.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <sys/mman.h>

#include "pcm_local.h"

#include "../control/control_local.h"

#include "../timer/timer_local.h"

//#define DEBUG_RW		/* use to debug readi/writei/readn/writen */

//#define DEBUG_MMAP		/* debug mmap_commit */

#ifndef PIC

/* entry for static linking */

const char *_snd_module_pcm_hw = "";

#endif

#ifndef DOC_HIDDEN

#ifndef F_SETSIG

#define F_SETSIG 10

#endif

/*

 *  Compatibility

 */

struct sndrv_pcm_hw_params_old {

	unsigned int flags;

	unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT -

			   SNDRV_PCM_HW_PARAM_ACCESS + 1];

	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME -

					SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];

	unsigned int rmask;

	unsigned int cmask;

	unsigned int info;

	unsigned int msbits;

	unsigned int rate_num;

	unsigned int rate_den;

	sndrv_pcm_uframes_t fifo_size;

	unsigned char reserved[64];

};

#define SND_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct sndrv_pcm_hw_params_old)

#define SND_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct sndrv_pcm_hw_params_old)

static int use_old_hw_params_ioctl(int fd, unsigned int cmd, snd_pcm_hw_params_t *params);

static snd_pcm_sframes_t snd_pcm_hw_avail_update(snd_pcm_t *pcm);

static const snd_pcm_fast_ops_t snd_pcm_hw_fast_ops;

static const snd_pcm_fast_ops_t snd_pcm_hw_fast_ops_timer;

/*

 *

 */

typedef struct {

	int version;

	int fd;

	int card, device, subdevice;

	volatile struct snd_pcm_mmap_status * mmap_status;

	struct snd_pcm_mmap_control *mmap_control;

	bool mmap_status_fallbacked;

	bool mmap_control_fallbacked;

	struct snd_pcm_sync_ptr *sync_ptr;

	int period_event;

	snd_timer_t *period_timer;

	struct pollfd period_timer_pfd;

	int period_timer_need_poll;

	/* restricted parameters */

	snd_pcm_format_t format;

	int rate;

	int channels;

	/* for chmap */

	unsigned int chmap_caps;

	snd_pcm_chmap_query_t **chmap_override;

} snd_pcm_hw_t;

#define SNDRV_FILE_PCM_STREAM_PLAYBACK		ALSA_DEVICE_DIRECTORY "pcmC%iD%ip"

#define SNDRV_FILE_PCM_STREAM_CAPTURE		ALSA_DEVICE_DIRECTORY "pcmC%iD%ic"

#define SNDRV_PCM_VERSION_MAX			SNDRV_PROTOCOL_VERSION(2, 0, 9)

/* update appl_ptr with driver */

#define FAST_PCM_STATE(hw) \

	((snd_pcm_state_t) (hw)->mmap_status->state)

#define FAST_PCM_TSTAMP(hw) \

	((hw)->mmap_status->tstamp)

struct timespec snd_pcm_hw_fast_tstamp(snd_pcm_t *pcm)

{

	struct timespec res;

	snd_pcm_hw_t *hw = pcm->private_data;

	res = FAST_PCM_TSTAMP(hw);

	if (SNDRV_PROTOCOL_VERSION(2, 0, 5) > hw->version)

		res.tv_nsec *= 1000L;

	return res;

}

#endif /* DOC_HIDDEN */

static int sync_ptr1(snd_pcm_hw_t *hw, unsigned int flags)

{

	int err;

	hw->sync_ptr->flags = flags;

	if (ioctl(hw->fd, SNDRV_PCM_IOCTL_SYNC_PTR, hw->sync_ptr) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_SYNC_PTR failed (%i)", err);

		return err;

	}

	return 0;

}

static int issue_avail_min(snd_pcm_hw_t *hw)

{

	if (!hw->mmap_control_fallbacked)

		return 0;

	/* Avoid unexpected change of applptr in kernel space. */

	return sync_ptr1(hw, SNDRV_PCM_SYNC_PTR_APPL);

}

static int issue_applptr(snd_pcm_hw_t *hw)

{

	if (!hw->mmap_control_fallbacked)

		return 0;

	/* Avoid unexpected change of avail_min in kernel space. */

	return sync_ptr1(hw, SNDRV_PCM_SYNC_PTR_AVAIL_MIN);

}

static int request_hwsync(snd_pcm_hw_t *hw)

{

	if (!hw->mmap_status_fallbacked)

		return 0;

	/*

	 * Query both of control/status data to avoid unexpected change of

	 * control data in kernel space.

	 */

	return sync_ptr1(hw,

			 SNDRV_PCM_SYNC_PTR_HWSYNC |

			 SNDRV_PCM_SYNC_PTR_APPL |

			 SNDRV_PCM_SYNC_PTR_AVAIL_MIN);

}

static int query_status_and_control_data(snd_pcm_hw_t *hw)

{

	if (!hw->mmap_control_fallbacked)

		return 0;

	/*

	 * Query both of control/status data to avoid unexpected change of

	 * control data in kernel space.

	 */

	return sync_ptr1(hw,

			 SNDRV_PCM_SYNC_PTR_APPL |

			 SNDRV_PCM_SYNC_PTR_AVAIL_MIN);

}

static int query_status_data(snd_pcm_hw_t *hw)

{

	if (!hw->mmap_status_fallbacked)

		return 0;

	/*

	 * Query both of control/status data to avoid unexpected change of

	 * control data in kernel space.

	 */

	return sync_ptr1(hw,

			 SNDRV_PCM_SYNC_PTR_APPL |

			 SNDRV_PCM_SYNC_PTR_AVAIL_MIN);

}

static int snd_pcm_hw_clear_timer_queue(snd_pcm_hw_t *hw)

{

	if (hw->period_timer_need_poll) {

		while (poll(&hw->period_timer_pfd, 1, 0) > 0) {

			snd_timer_tread_t rbuf[4];

			snd_timer_read(hw->period_timer, rbuf, sizeof(rbuf));

		}

	} else {

		snd_timer_tread_t rbuf[4];

		snd_timer_read(hw->period_timer, rbuf, sizeof(rbuf));

	}

	return 0;

}

static int snd_pcm_hw_poll_descriptors_count(snd_pcm_t *pcm ATTRIBUTE_UNUSED)

{

	return 2;

}

static int snd_pcm_hw_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int space)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	if (space < 2)

		return -ENOMEM;

	pfds[0].fd = hw->fd;

	pfds[0].events = pcm->poll_events | POLLERR | POLLNVAL;

	pfds[1].fd = hw->period_timer_pfd.fd;

	pfds[1].events = POLLIN | POLLERR | POLLNVAL;

	return 2;

}

static int snd_pcm_hw_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned nfds, unsigned short *revents)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	unsigned int events;

	if (nfds != 2 || pfds[0].fd != hw->fd || pfds[1].fd != hw->period_timer_pfd.fd)

		return -EINVAL;

	events = pfds[0].revents;

	if (pfds[1].revents & POLLIN) {

		snd_pcm_hw_clear_timer_queue(hw);

		events |= pcm->poll_events & ~(POLLERR|POLLNVAL);

	}

	*revents = events;

	return 0;

}

static int snd_pcm_hw_nonblock(snd_pcm_t *pcm, int nonblock)

{

	long flags;

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if ((flags = fcntl(fd, F_GETFL)) < 0) {

		err = -errno;

		SYSMSG("F_GETFL failed (%i)", err);

		return err;

	}

	if (nonblock)

		flags |= O_NONBLOCK;

	else

		flags &= ~O_NONBLOCK;

	if (fcntl(fd, F_SETFL, flags) < 0) {

		err = -errno;

		SYSMSG("F_SETFL for O_NONBLOCK failed (%i)", err);

		return err;

	}

	return 0;

}

static int snd_pcm_hw_async(snd_pcm_t *pcm, int sig, pid_t pid)

{

	long flags;

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if ((flags = fcntl(fd, F_GETFL)) < 0) {

		err = -errno;

		SYSMSG("F_GETFL failed (%i)", err);

		return err;

	}

	if (sig >= 0)

		flags |= O_ASYNC;

	else

		flags &= ~O_ASYNC;

	if (fcntl(fd, F_SETFL, flags) < 0) {

		err = -errno;

		SYSMSG("F_SETFL for O_ASYNC failed (%i)", err);

		return err;

	}

	if (sig < 0)

		return 0;

	if (fcntl(fd, F_SETSIG, (long)sig) < 0) {

		err = -errno;

		SYSMSG("F_SETSIG failed (%i)", err);

		return err;

	}

	if (fcntl(fd, F_SETOWN, (long)pid) < 0) {

		err = -errno;

		SYSMSG("F_SETOWN failed (%i)", err);

		return err;

	}

	return 0;

}

static int snd_pcm_hw_info(snd_pcm_t *pcm, snd_pcm_info_t * info)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if (ioctl(fd, SNDRV_PCM_IOCTL_INFO, info) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_INFO failed (%i)", err);

		return err;

	}

	return 0;

}

static inline int hw_refine_call(snd_pcm_hw_t *pcm_hw, snd_pcm_hw_params_t *params)

{

	/* check for new hw_params structure; it's available from 2.0.2 version of PCM API */

	if (SNDRV_PROTOCOL_VERSION(2, 0, 2) <= pcm_hw->version)

		return ioctl(pcm_hw->fd, SNDRV_PCM_IOCTL_HW_REFINE, params);

	return use_old_hw_params_ioctl(pcm_hw->fd, SND_PCM_IOCTL_HW_REFINE_OLD, params);

}

static int snd_pcm_hw_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

	if (hw->format != SND_PCM_FORMAT_UNKNOWN) {

		err = _snd_pcm_hw_params_set_format(params, hw->format);

		if (err < 0)

			return err;

	}

	if (hw->channels > 0) {

		err = _snd_pcm_hw_param_set(params, SND_PCM_HW_PARAM_CHANNELS,

					    hw->channels, 0);

		if (err < 0)

			return err;

	}

	if (hw->rate > 0) {

		err = _snd_pcm_hw_param_set_minmax(params, SND_PCM_HW_PARAM_RATE,

						   hw->rate, 0, hw->rate + 1, -1);

		if (err < 0)

			return err;

	}

	if (hw_refine_call(hw, params) < 0) {

		err = -errno;

		// SYSMSG("SNDRV_PCM_IOCTL_HW_REFINE failed");

		return err;

	}

	if (params->info != ~0U) {

		params->info &= ~0xf0000000;

		if (pcm->tstamp_type != SND_PCM_TSTAMP_TYPE_GETTIMEOFDAY)

			params->info |= SND_PCM_INFO_MONOTONIC;

	}

	return 0;

}

static inline int hw_params_call(snd_pcm_hw_t *pcm_hw, snd_pcm_hw_params_t *params)

{

	/* check for new hw_params structure; it's available from 2.0.2 version of PCM API */

	if (SNDRV_PROTOCOL_VERSION(2, 0, 2) <= pcm_hw->version)

		return ioctl(pcm_hw->fd, SNDRV_PCM_IOCTL_HW_PARAMS, params);

	return use_old_hw_params_ioctl(pcm_hw->fd, SND_PCM_IOCTL_HW_PARAMS_OLD, params);

}

static int snd_pcm_hw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

	if (hw_params_call(hw, params) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_HW_PARAMS failed (%i)", err);

		return err;

	}

	params->info &= ~0xf0000000;

	if (pcm->tstamp_type != SND_PCM_TSTAMP_TYPE_GETTIMEOFDAY)

		params->info |= SND_PCM_INFO_MONOTONIC;

	return query_status_data(hw);

}

static void snd_pcm_hw_close_timer(snd_pcm_hw_t *hw)

{

	if (hw->period_timer) {

		snd_timer_close(hw->period_timer);

		hw->period_timer = NULL;

	}

}

static int snd_pcm_hw_change_timer(snd_pcm_t *pcm, int enable)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	snd_timer_params_t params = {0};

	unsigned int suspend, resume;

	int err;

	if (enable) {

		err = snd_timer_hw_open(&hw->period_timer,

				"hw-pcm-period-event",

				SND_TIMER_CLASS_PCM, SND_TIMER_SCLASS_NONE,

				hw->card, hw->device,

				(hw->subdevice << 1) | (pcm->stream & 1),

				SND_TIMER_OPEN_NONBLOCK | SND_TIMER_OPEN_TREAD);

		if (err < 0) {

			err = snd_timer_hw_open(&hw->period_timer,

				"hw-pcm-period-event",

				SND_TIMER_CLASS_PCM, SND_TIMER_SCLASS_NONE,

				hw->card, hw->device,

				(hw->subdevice << 1) | (pcm->stream & 1),

				SND_TIMER_OPEN_NONBLOCK);

			return err;

		}

		if (snd_timer_poll_descriptors_count(hw->period_timer) != 1) {

			snd_pcm_hw_close_timer(hw);

			return -EINVAL;

		}

		hw->period_timer_pfd.events = POLLIN;

 		hw->period_timer_pfd.revents = 0;

		snd_timer_poll_descriptors(hw->period_timer,

					   &hw->period_timer_pfd, 1);

		hw->period_timer_need_poll = 0;

		suspend = 1<

		resume = 1<

		/*

		 * hacks for older kernel drivers

		 */

		{

			int ver = 0;

			ioctl(hw->period_timer_pfd.fd,

			      SNDRV_TIMER_IOCTL_PVERSION, &ver);

			/*

			 * In older versions, check via poll before read() is

			 * needed because of the confliction between

			 * TIMER_START and FIONBIO ioctls.

                         */

			if (ver < SNDRV_PROTOCOL_VERSION(2, 0, 4))

				hw->period_timer_need_poll = 1;

			/*

			 * In older versions, timer uses pause events instead

			 * suspend/resume events.

			 */

			if (ver < SNDRV_PROTOCOL_VERSION(2, 0, 5)) {

				suspend = 1<

				resume = 1<

			}

		}

		snd_timer_params_set_auto_start(&params, 1);

		snd_timer_params_set_ticks(&params, 1);

		INTERNAL(snd_timer_params_set_filter)(&params, (1<

					    suspend | resume);

		err = snd_timer_params(hw->period_timer, &params);

		if (err < 0) {

			snd_pcm_hw_close_timer(hw);

			return err;

		}

		err = snd_timer_start(hw->period_timer);

		if (err < 0) {

			snd_pcm_hw_close_timer(hw);

			return err;

		}

		pcm->fast_ops = &snd_pcm_hw_fast_ops_timer;

	} else {

		snd_pcm_hw_close_timer(hw);

		pcm->fast_ops = &snd_pcm_hw_fast_ops;

		hw->period_event = 0;

	}

	return 0;

}

static int snd_pcm_hw_hw_free(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	snd_pcm_hw_change_timer(pcm, 0);

	if (ioctl(fd, SNDRV_PCM_IOCTL_HW_FREE) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_HW_FREE failed (%i)", err);

		return err;

	}

	return 0;

}

static int snd_pcm_hw_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t * params)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err = 0;

	int old_period_event = sw_get_period_event(params);

	sw_set_period_event(params, 0);

	if ((snd_pcm_tstamp_t) params->tstamp_mode == pcm->tstamp_mode &&

	    (snd_pcm_tstamp_type_t) params->tstamp_type == pcm->tstamp_type &&

	    params->period_step == pcm->period_step &&

	    params->start_threshold == pcm->start_threshold &&

	    params->stop_threshold == pcm->stop_threshold &&

	    params->silence_threshold == pcm->silence_threshold &&

	    params->silence_size == pcm->silence_size &&

	    old_period_event == hw->period_event) {

		hw->mmap_control->avail_min = params->avail_min;

		err = issue_avail_min(hw);

		goto out;

	}

	if (params->tstamp_type == SND_PCM_TSTAMP_TYPE_MONOTONIC_RAW &&

	    hw->version < SNDRV_PROTOCOL_VERSION(2, 0, 12)) {

		SYSMSG("Kernel doesn't support SND_PCM_TSTAMP_TYPE_MONOTONIC_RAW");

		err = -EINVAL;

		goto out;

	}

	if (params->tstamp_type == SND_PCM_TSTAMP_TYPE_MONOTONIC &&

	    hw->version < SNDRV_PROTOCOL_VERSION(2, 0, 5)) {

		SYSMSG("Kernel doesn't support SND_PCM_TSTAMP_TYPE_MONOTONIC");

		err = -EINVAL;

		goto out;

	}

	if (ioctl(fd, SNDRV_PCM_IOCTL_SW_PARAMS, params) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_SW_PARAMS failed (%i)", err);

		goto out;

	}

	if ((snd_pcm_tstamp_type_t) params->tstamp_type != pcm->tstamp_type) {

		if (hw->version < SNDRV_PROTOCOL_VERSION(2, 0, 12)) {

			int on = (snd_pcm_tstamp_type_t) params->tstamp_type ==

				SND_PCM_TSTAMP_TYPE_MONOTONIC;

			if (ioctl(fd, SNDRV_PCM_IOCTL_TSTAMP, &on) < 0) {

				err = -errno;

				SNDMSG("TSTAMP failed\n");

				goto out;

			}

		}

		pcm->tstamp_type = params->tstamp_type;

	}

	hw->mmap_control->avail_min = params->avail_min;

	if (hw->period_event != old_period_event) {

		err = snd_pcm_hw_change_timer(pcm, old_period_event);

		if (err < 0)

			goto out;

		hw->period_event = old_period_event;

	}

 out:

	sw_set_period_event(params, old_period_event);

	return err;

}

static int snd_pcm_hw_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	struct snd_pcm_channel_info i;

	int fd = hw->fd, err;

	i.channel = info->channel;

	if (ioctl(fd, SNDRV_PCM_IOCTL_CHANNEL_INFO, &i) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_CHANNEL_INFO failed (%i)", err);

		return err;

	}

	info->channel = i.channel;

	info->addr = 0;

	info->first = i.first;

	info->step = i.step;

	info->type = SND_PCM_AREA_MMAP;

	info->u.mmap.fd = fd;

	info->u.mmap.offset = i.offset;

	return 0;

}

static int snd_pcm_hw_status(snd_pcm_t *pcm, snd_pcm_status_t * status)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if (SNDRV_PROTOCOL_VERSION(2, 0, 13) > hw->version) {

		if (ioctl(fd, SNDRV_PCM_IOCTL_STATUS, status) < 0) {

			err = -errno;

			SYSMSG("SNDRV_PCM_IOCTL_STATUS failed (%i)", err);

			return err;

		}

	} else {

		if (ioctl(fd, SNDRV_PCM_IOCTL_STATUS_EXT, status) < 0) {

			err = -errno;

			SYSMSG("SNDRV_PCM_IOCTL_STATUS_EXT failed (%i)", err);

			return err;

		}

	}

	if (SNDRV_PROTOCOL_VERSION(2, 0, 5) > hw->version) {

		status->tstamp.tv_nsec *= 1000L;

		status->trigger_tstamp.tv_nsec *= 1000L;

	}

	return 0;

}

static snd_pcm_state_t snd_pcm_hw_state(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err = query_status_data(hw);

	if (err < 0)

		return err;

	return (snd_pcm_state_t) hw->mmap_status->state;

}

static int snd_pcm_hw_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if (ioctl(fd, SNDRV_PCM_IOCTL_DELAY, delayp) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_DELAY failed (%i)", err);

		return err;

	}

	return 0;

}

static int snd_pcm_hw_hwsync(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if (SNDRV_PROTOCOL_VERSION(2, 0, 3) <= hw->version) {

		if (hw->mmap_status_fallbacked) {

			err = request_hwsync(hw);

			if (err < 0)

				return err;

		} else {

			if (ioctl(fd, SNDRV_PCM_IOCTL_HWSYNC) < 0) {

				err = -errno;

				SYSMSG("SNDRV_PCM_IOCTL_HWSYNC failed (%i)", err);

				return err;

			}

		}

	} else {

		snd_pcm_sframes_t delay;

		int err = snd_pcm_hw_delay(pcm, &delay);

		if (err < 0) {

			switch (FAST_PCM_STATE(hw)) {

			case SND_PCM_STATE_PREPARED:

			case SND_PCM_STATE_SUSPENDED:

				return 0;

			default:

				return err;

			}

		}

	}

	return 0;

}

static int snd_pcm_hw_prepare(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if (ioctl(fd, SNDRV_PCM_IOCTL_PREPARE) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_PREPARE failed (%i)", err);

		return err;

	}

	return query_status_and_control_data(hw);

}

static int snd_pcm_hw_reset(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if (ioctl(fd, SNDRV_PCM_IOCTL_RESET) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_RESET failed (%i)", err);

		return err;

	}

	return query_status_and_control_data(hw);

}

static int snd_pcm_hw_start(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

#if 0

	assert(pcm->stream != SND_PCM_STREAM_PLAYBACK ||

	       snd_pcm_mmap_playback_hw_avail(pcm) > 0);

#endif

	issue_applptr(hw);

	if (ioctl(hw->fd, SNDRV_PCM_IOCTL_START) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_START failed (%i)", err);

#if 0

		if (err == -EBADFD)

			SNDERR("PCM state = %s", snd_pcm_state_name(snd_pcm_hw_state(pcm)));

#endif

		return err;

	}

	return 0;

}

static int snd_pcm_hw_drop(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

	if (ioctl(hw->fd, SNDRV_PCM_IOCTL_DROP) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_DROP failed (%i)", err);

		return err;

	} else {

	}

	return 0;

}

static int snd_pcm_hw_drain(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

	if (ioctl(hw->fd, SNDRV_PCM_IOCTL_DRAIN) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_DRAIN failed (%i)", err);

		return err;

	}

	return 0;

}

static int snd_pcm_hw_pause(snd_pcm_t *pcm, int enable)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

	if (ioctl(hw->fd, SNDRV_PCM_IOCTL_PAUSE, enable) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_PAUSE failed (%i)", err);

		return err;

	}

	return 0;

}

static snd_pcm_sframes_t snd_pcm_hw_rewindable(snd_pcm_t *pcm)

{

	return snd_pcm_mmap_hw_rewindable(pcm);

}

static snd_pcm_sframes_t snd_pcm_hw_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

	if (ioctl(hw->fd, SNDRV_PCM_IOCTL_REWIND, &frames) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_REWIND failed (%i)", err);

		return err;

	}

	err = query_status_and_control_data(hw);

	if (err < 0)

		return err;

	return frames;

}

static snd_pcm_sframes_t snd_pcm_hw_forwardable(snd_pcm_t *pcm)

{

	return snd_pcm_mmap_avail(pcm);

}

static snd_pcm_sframes_t snd_pcm_hw_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int err;

	if (SNDRV_PROTOCOL_VERSION(2, 0, 4) <= hw->version) {

		if (ioctl(hw->fd, SNDRV_PCM_IOCTL_FORWARD, &frames) < 0) {

			err = -errno;

			SYSMSG("SNDRV_PCM_IOCTL_FORWARD failed (%i)", err);

			return err;

		}

		err = query_status_and_control_data(hw);

		if (err < 0)

			return err;

		return frames;

	} else {

		snd_pcm_sframes_t avail;

		switch (FAST_PCM_STATE(hw)) {

		case SNDRV_PCM_STATE_RUNNING:

		case SNDRV_PCM_STATE_DRAINING:

		case SNDRV_PCM_STATE_PAUSED:

		case SNDRV_PCM_STATE_PREPARED:

			break;

		case SNDRV_PCM_STATE_XRUN:

			return -EPIPE;

		default:

			return -EBADFD;

		}

		avail = snd_pcm_mmap_avail(pcm);

		if (avail < 0)

			return 0;

		if (frames > (snd_pcm_uframes_t)avail)

			frames = avail;

		snd_pcm_mmap_appl_forward(pcm, frames);

		return frames;

	}

}

static int snd_pcm_hw_resume(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd, err;

	if (ioctl(fd, SNDRV_PCM_IOCTL_RESUME) < 0) {

		err = -errno;

		SYSMSG("SNDRV_PCM_IOCTL_RESUME failed (%i)", err);

		return err;

	}

	return 0;

}

static int hw_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)

{

	snd_pcm_hw_t *hw1 = pcm1->private_data;

	snd_pcm_hw_t *hw2 = pcm2->private_data;

	if (ioctl(hw1->fd, SNDRV_PCM_IOCTL_LINK, hw2->fd) < 0) {

		SYSMSG("SNDRV_PCM_IOCTL_LINK failed (%i)", -errno);

		return -errno;

	}

	return 0;

}

static int snd_pcm_hw_link_slaves(snd_pcm_t *pcm, snd_pcm_t *master)

{

	if (master->type != SND_PCM_TYPE_HW) {

		SYSMSG("Invalid type for SNDRV_PCM_IOCTL_LINK (%i)", master->type);

		return -EINVAL;

	}

	return hw_link(master, pcm);

}

static int snd_pcm_hw_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)

{

	if (pcm2->type != SND_PCM_TYPE_HW) {

		if (pcm2->fast_ops->link_slaves)

			return pcm2->fast_ops->link_slaves(pcm2, pcm1);

		return -ENOSYS;

	}

	return hw_link(pcm1, pcm2);

 }

static int snd_pcm_hw_unlink(snd_pcm_t *pcm)

{

	snd_pcm_hw_t *hw = pcm->private_data;

	if (ioctl(hw->fd, SNDRV_PCM_IOCTL_UNLINK) < 0) {

		SYSMSG("SNDRV_PCM_IOCTL_UNLINK failed (%i)", -errno);

		return -errno;

	}

	return 0;

}

static snd_pcm_sframes_t snd_pcm_hw_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size)

{

	int err;

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd;

	struct snd_xferi xferi;

	xferi.buf = (char*) buffer;

	xferi.frames = size;

	xferi.result = 0; /* make valgrind happy */

	if (ioctl(fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &xferi) < 0)

		err = -errno;

	else

		err = query_status_and_control_data(hw);

#ifdef DEBUG_RW

	fprintf(stderr, "hw_writei: frames = %li, xferi.result = %li, err = %i\n", size, xferi.result, err);

#endif

	if (err < 0)

		return snd_pcm_check_error(pcm, err);

	return xferi.result;

}

static snd_pcm_sframes_t snd_pcm_hw_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size)

{

	int err;

	snd_pcm_hw_t *hw = pcm->private_data;

	int fd = hw->fd;

	struct snd_xfern xfern;

	memset(&xfern, 0, sizeof(xfern)); /* make valgrind happy */

	xfern.bufs = bufs;

	xfern.frames = size;