[mirror_ubuntu-jammy-kernel.git] / sound / firewire / oxfw / oxfw-hwdep.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * oxfw_hwdep.c - a part of driver for OXFW970/971 based devices
 *
 * Copyright (c) 2014 Takashi Sakamoto
 */

/*
 * This codes give three functionality.
 *
 * 1.get firewire node information
 * 2.get notification about starting/stopping stream
 * 3.lock/unlock stream
 */

#include "oxfw.h"

static long hwdep_read(struct snd_hwdep *hwdep, char __user *buf,  long count,
		       loff_t *offset)
{
	struct snd_oxfw *oxfw = hwdep->private_data;
	DEFINE_WAIT(wait);
	union snd_firewire_event event;

	spin_lock_irq(&oxfw->lock);

	while (!oxfw->dev_lock_changed) {
		prepare_to_wait(&oxfw->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
		spin_unlock_irq(&oxfw->lock);
		schedule();
		finish_wait(&oxfw->hwdep_wait, &wait);
		if (signal_pending(current))
			return -ERESTARTSYS;
		spin_lock_irq(&oxfw->lock);
	}

	memset(&event, 0, sizeof(event));
	if (oxfw->dev_lock_changed) {
		event.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS;
		event.lock_status.status = (oxfw->dev_lock_count > 0);
		oxfw->dev_lock_changed = false;

		count = min_t(long, count, sizeof(event.lock_status));
	}

	spin_unlock_irq(&oxfw->lock);

	if (copy_to_user(buf, &event, count))
		return -EFAULT;

	return count;
}

static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
			       poll_table *wait)
{
	struct snd_oxfw *oxfw = hwdep->private_data;
	__poll_t events;

	poll_wait(file, &oxfw->hwdep_wait, wait);

	spin_lock_irq(&oxfw->lock);
	if (oxfw->dev_lock_changed)
		events = EPOLLIN | EPOLLRDNORM;
	else
		events = 0;
	spin_unlock_irq(&oxfw->lock);

	return events;
}

static int hwdep_get_info(struct snd_oxfw *oxfw, void __user *arg)
{
	struct fw_device *dev = fw_parent_device(oxfw->unit);
	struct snd_firewire_get_info info;

	memset(&info, 0, sizeof(info));
	info.type = SNDRV_FIREWIRE_TYPE_OXFW;
	info.card = dev->card->index;
	*(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
	*(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
	strlcpy(info.device_name, dev_name(&dev->device),
		sizeof(info.device_name));

	if (copy_to_user(arg, &info, sizeof(info)))
		return -EFAULT;

	return 0;
}

static int hwdep_lock(struct snd_oxfw *oxfw)
{
	int err;

	spin_lock_irq(&oxfw->lock);

	if (oxfw->dev_lock_count == 0) {
		oxfw->dev_lock_count = -1;
		err = 0;
	} else {
		err = -EBUSY;
	}

	spin_unlock_irq(&oxfw->lock);

	return err;
}

static int hwdep_unlock(struct snd_oxfw *oxfw)
{
	int err;

	spin_lock_irq(&oxfw->lock);

	if (oxfw->dev_lock_count == -1) {
		oxfw->dev_lock_count = 0;
		err = 0;
	} else {
		err = -EBADFD;
	}

	spin_unlock_irq(&oxfw->lock);

	return err;
}

static int hwdep_release(struct snd_hwdep *hwdep, struct file *file)
{
	struct snd_oxfw *oxfw = hwdep->private_data;

	spin_lock_irq(&oxfw->lock);
	if (oxfw->dev_lock_count == -1)
		oxfw->dev_lock_count = 0;
	spin_unlock_irq(&oxfw->lock);

	return 0;
}

static int hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,
		       unsigned int cmd, unsigned long arg)
{
	struct snd_oxfw *oxfw = hwdep->private_data;

	switch (cmd) {
	case SNDRV_FIREWIRE_IOCTL_GET_INFO:
		return hwdep_get_info(oxfw, (void __user *)arg);
	case SNDRV_FIREWIRE_IOCTL_LOCK:
		return hwdep_lock(oxfw);
	case SNDRV_FIREWIRE_IOCTL_UNLOCK:
		return hwdep_unlock(oxfw);
	default:
		return -ENOIOCTLCMD;
	}
}

#ifdef CONFIG_COMPAT
static int hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file,
			      unsigned int cmd, unsigned long arg)
{
	return hwdep_ioctl(hwdep, file, cmd,
			   (unsigned long)compat_ptr(arg));
}
#else
#define hwdep_compat_ioctl NULL
#endif

int snd_oxfw_create_hwdep(struct snd_oxfw *oxfw)
{
	static const struct snd_hwdep_ops hwdep_ops = {
		.read		= hwdep_read,
		.release	= hwdep_release,
		.poll		= hwdep_poll,
		.ioctl		= hwdep_ioctl,
		.ioctl_compat	= hwdep_compat_ioctl,
	};
	struct snd_hwdep *hwdep;
	int err;

	err = snd_hwdep_new(oxfw->card, oxfw->card->driver, 0, &hwdep);
	if (err < 0)
		goto end;
	strcpy(hwdep->name, oxfw->card->driver);
	hwdep->iface = SNDRV_HWDEP_IFACE_FW_OXFW;
	hwdep->ops = hwdep_ops;
	hwdep->private_data = oxfw;
	hwdep->exclusive = true;
end:
	return err;
}
Commit	Line	Data
da607e19	1	// SPDX-License-Identifier: GPL-2.0-only
8985f4ac TS	2	/*
	3	* oxfw_hwdep.c - a part of driver for OXFW970/971 based devices
	4	*
	5	* Copyright (c) 2014 Takashi Sakamoto
8985f4ac TS	6	*/
	7
	8	/*
	9	* This codes give three functionality.
	10	*
	11	* 1.get firewire node information
	12	* 2.get notification about starting/stopping stream
	13	* 3.lock/unlock stream
	14	*/
	15
	16	#include "oxfw.h"
	17
	18	static long hwdep_read(struct snd_hwdep hwdep, char __user buf, long count,
	19	loff_t *offset)
	20	{
	21	struct snd_oxfw *oxfw = hwdep->private_data;
	22	DEFINE_WAIT(wait);
	23	union snd_firewire_event event;
	24
	25	spin_lock_irq(&oxfw->lock);
	26
	27	while (!oxfw->dev_lock_changed) {
	28	prepare_to_wait(&oxfw->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
	29	spin_unlock_irq(&oxfw->lock);
	30	schedule();
	31	finish_wait(&oxfw->hwdep_wait, &wait);
	32	if (signal_pending(current))
	33	return -ERESTARTSYS;
	34	spin_lock_irq(&oxfw->lock);
	35	}
	36
	37	memset(&event, 0, sizeof(event));
	38	if (oxfw->dev_lock_changed) {
	39	event.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS;
	40	event.lock_status.status = (oxfw->dev_lock_count > 0);
	41	oxfw->dev_lock_changed = false;
	42
	43	count = min_t(long, count, sizeof(event.lock_status));
	44	}
	45
	46	spin_unlock_irq(&oxfw->lock);
	47
	48	if (copy_to_user(buf, &event, count))
	49	return -EFAULT;
	50
	51	return count;
	52	}
	53
680ef72a	54	static __poll_t hwdep_poll(struct snd_hwdep hwdep, struct file file,
8985f4ac TS	55	poll_table *wait)
	56	{
	57	struct snd_oxfw *oxfw = hwdep->private_data;
680ef72a	58	__poll_t events;
8985f4ac TS	59
	60	poll_wait(file, &oxfw->hwdep_wait, wait);
	61
	62	spin_lock_irq(&oxfw->lock);
	63	if (oxfw->dev_lock_changed)
a9a08845	64	events = EPOLLIN \| EPOLLRDNORM;
8985f4ac TS	65	else
	66	events = 0;
	67	spin_unlock_irq(&oxfw->lock);
	68
	69	return events;
	70	}
	71
	72	static int hwdep_get_info(struct snd_oxfw oxfw, void __user arg)
	73	{
	74	struct fw_device *dev = fw_parent_device(oxfw->unit);
	75	struct snd_firewire_get_info info;
	76
	77	memset(&info, 0, sizeof(info));
	78	info.type = SNDRV_FIREWIRE_TYPE_OXFW;
	79	info.card = dev->card->index;
	80	(__be32 )&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
	81	(__be32 )&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
	82	strlcpy(info.device_name, dev_name(&dev->device),
	83	sizeof(info.device_name));
	84
	85	if (copy_to_user(arg, &info, sizeof(info)))
	86	return -EFAULT;
	87
	88	return 0;
	89	}
	90
	91	static int hwdep_lock(struct snd_oxfw *oxfw)
	92	{
	93	int err;
	94
	95	spin_lock_irq(&oxfw->lock);
	96
	97	if (oxfw->dev_lock_count == 0) {
	98	oxfw->dev_lock_count = -1;
	99	err = 0;
	100	} else {
	101	err = -EBUSY;
	102	}
	103
	104	spin_unlock_irq(&oxfw->lock);
	105
	106	return err;
	107	}
	108
	109	static int hwdep_unlock(struct snd_oxfw *oxfw)
	110	{
	111	int err;
	112
	113	spin_lock_irq(&oxfw->lock);
	114
	115	if (oxfw->dev_lock_count == -1) {
	116	oxfw->dev_lock_count = 0;
	117	err = 0;
	118	} else {
	119	err = -EBADFD;
	120	}
	121
	122	spin_unlock_irq(&oxfw->lock);
	123
	124	return err;
	125	}
	126
	127	static int hwdep_release(struct snd_hwdep hwdep, struct file file)
	128	{
129	struct snd_oxfw *oxfw = hwdep->private_data;
130
131	spin_lock_irq(&oxfw->lock);
132	if (oxfw->dev_lock_count == -1)
133	oxfw->dev_lock_count = 0;
134	spin_unlock_irq(&oxfw->lock);
135
136	return 0;
137	}
138
139	static int hwdep_ioctl(struct snd_hwdep hwdep, struct file file,
140	unsigned int cmd, unsigned long arg)
141	{
142	struct snd_oxfw *oxfw = hwdep->private_data;
143
144	switch (cmd) {
145	case SNDRV_FIREWIRE_IOCTL_GET_INFO:
146	return hwdep_get_info(oxfw, (void __user *)arg);
147	case SNDRV_FIREWIRE_IOCTL_LOCK:
148	return hwdep_lock(oxfw);
149	case SNDRV_FIREWIRE_IOCTL_UNLOCK:
150	return hwdep_unlock(oxfw);
151	default:
152	return -ENOIOCTLCMD;
153	}
154	}
155
156	#ifdef CONFIG_COMPAT
157	static int hwdep_compat_ioctl(struct snd_hwdep hwdep, struct file file,
158	unsigned int cmd, unsigned long arg)
159	{
160	return hwdep_ioctl(hwdep, file, cmd,
161	(unsigned long)compat_ptr(arg));
162	}
163	#else
164	#define hwdep_compat_ioctl NULL
165	#endif
166
167	int snd_oxfw_create_hwdep(struct snd_oxfw *oxfw)
168	{
169	static const struct snd_hwdep_ops hwdep_ops = {
170	.read = hwdep_read,
171	.release = hwdep_release,
172	.poll = hwdep_poll,
173	.ioctl = hwdep_ioctl,
174	.ioctl_compat = hwdep_compat_ioctl,
175	};
176	struct snd_hwdep *hwdep;
177	int err;
178
179	err = snd_hwdep_new(oxfw->card, oxfw->card->driver, 0, &hwdep);
180	if (err < 0)
181	goto end;
182	strcpy(hwdep->name, oxfw->card->driver);
183	hwdep->iface = SNDRV_HWDEP_IFACE_FW_OXFW;
184	hwdep->ops = hwdep_ops;
185	hwdep->private_data = oxfw;
186	hwdep->exclusive = true;
187	end:
188	return err;
189	}