[deliverable/linux.git] / sound / firewire / fireworks / fireworks_hwdep.c

/*
 * fireworks_hwdep.c - a part of driver for Fireworks based devices
 *
 * Copyright (c) 2013-2014 Takashi Sakamoto
 *
 * Licensed under the terms of the GNU General Public License, version 2.
 */

/*
 * This codes have five functionalities.
 *
 * 1.get information about firewire node
 * 2.get notification about starting/stopping stream
 * 3.lock/unlock streaming
 * 4.transmit command of EFW transaction
 * 5.receive response of EFW transaction
 *
 */

#include "fireworks.h"

static long
hwdep_read_resp_buf(struct snd_efw *efw, char __user *buf, long remained,
		    loff_t *offset)
{
	unsigned int length, till_end, type;
	struct snd_efw_transaction *t;
	u8 *pull_ptr;
	long count = 0;

	if (remained < sizeof(type) + sizeof(struct snd_efw_transaction))
		return -ENOSPC;

	/* data type is SNDRV_FIREWIRE_EVENT_EFW_RESPONSE */
	type = SNDRV_FIREWIRE_EVENT_EFW_RESPONSE;
	if (copy_to_user(buf, &type, sizeof(type)))
		return -EFAULT;
	remained -= sizeof(type);
	buf += sizeof(type);

	/* write into buffer as many responses as possible */
	spin_lock_irq(&efw->lock);

	/*
	 * When another task reaches here during this task's access to user
	 * space, it picks up current position in buffer and can read the same
	 * series of responses.
	 */
	pull_ptr = efw->pull_ptr;

	while (efw->push_ptr != pull_ptr) {
		t = (struct snd_efw_transaction *)(pull_ptr);
		length = be32_to_cpu(t->length) * sizeof(__be32);

		/* confirm enough space for this response */
		if (remained < length)
			break;

		/* copy from ring buffer to user buffer */
		while (length > 0) {
			till_end = snd_efw_resp_buf_size -
				(unsigned int)(pull_ptr - efw->resp_buf);
			till_end = min_t(unsigned int, length, till_end);

			spin_unlock_irq(&efw->lock);

			if (copy_to_user(buf, pull_ptr, till_end))
				return -EFAULT;

			spin_lock_irq(&efw->lock);

			pull_ptr += till_end;
			if (pull_ptr >= efw->resp_buf + snd_efw_resp_buf_size)
				pull_ptr -= snd_efw_resp_buf_size;

			length -= till_end;
			buf += till_end;
			count += till_end;
			remained -= till_end;
		}
	}

	/*
	 * All of tasks can read from the buffer nearly simultaneously, but the
	 * last position for each task is different depending on the length of
	 * given buffer. Here, for simplicity, a position of buffer is set by
	 * the latest task. It's better for a listening application to allow one
	 * thread to read from the buffer. Unless, each task can read different
	 * sequence of responses depending on variation of buffer length.
	 */
	efw->pull_ptr = pull_ptr;

	spin_unlock_irq(&efw->lock);

	return count;
}

static long
hwdep_read_locked(struct snd_efw *efw, char __user *buf, long count,
		  loff_t *offset)
{
	union snd_firewire_event event = {
		.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS,
	};

	spin_lock_irq(&efw->lock);

	event.lock_status.status = (efw->dev_lock_count > 0);
	efw->dev_lock_changed = false;

	spin_unlock_irq(&efw->lock);

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

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

	return count;
}

static long
hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count,
	   loff_t *offset)
{
	struct snd_efw *efw = hwdep->private_data;
	DEFINE_WAIT(wait);
	bool dev_lock_changed;
	bool queued;

	spin_lock_irq(&efw->lock);

	dev_lock_changed = efw->dev_lock_changed;
	queued = efw->push_ptr != efw->pull_ptr;

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

	spin_unlock_irq(&efw->lock);

	if (dev_lock_changed)
		count = hwdep_read_locked(efw, buf, count, offset);
	else if (queued)
		count = hwdep_read_resp_buf(efw, buf, count, offset);

	return count;
}

static long
hwdep_write(struct snd_hwdep *hwdep, const char __user *data, long count,
	    loff_t *offset)
{
	struct snd_efw *efw = hwdep->private_data;
	u32 seqnum;
	u8 *buf;

	if (count < sizeof(struct snd_efw_transaction) ||
	    SND_EFW_RESPONSE_MAXIMUM_BYTES < count)
		return -EINVAL;

	buf = memdup_user(data, count);
	if (IS_ERR(buf))
		return PTR_ERR(buf);

	/* check seqnum is not for kernel-land */
	seqnum = be32_to_cpu(((struct snd_efw_transaction *)buf)->seqnum);
	if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX) {
		count = -EINVAL;
		goto end;
	}

	if (snd_efw_transaction_cmd(efw->unit, buf, count) < 0)
		count = -EIO;
end:
	kfree(buf);
	return count;
}

static unsigned int
hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait)
{
	struct snd_efw *efw = hwdep->private_data;
	unsigned int events;

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

	spin_lock_irq(&efw->lock);
	if (efw->dev_lock_changed || efw->pull_ptr != efw->push_ptr)
		events = POLLIN | POLLRDNORM;
	else
		events = 0;
	spin_unlock_irq(&efw->lock);

	return events | POLLOUT;
}

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

	memset(&info, 0, sizeof(info));
	info.type = SNDRV_FIREWIRE_TYPE_FIREWORKS;
	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_efw *efw)
{
	int err;

	spin_lock_irq(&efw->lock);

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

	spin_unlock_irq(&efw->lock);

	return err;
}

static int
hwdep_unlock(struct snd_efw *efw)
{
	int err;

	spin_lock_irq(&efw->lock);

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

	spin_unlock_irq(&efw->lock);

	return err;
}

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

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

	return 0;
}

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

	switch (cmd) {
	case SNDRV_FIREWIRE_IOCTL_GET_INFO:
		return hwdep_get_info(efw, (void __user *)arg);
	case SNDRV_FIREWIRE_IOCTL_LOCK:
		return hwdep_lock(efw);
	case SNDRV_FIREWIRE_IOCTL_UNLOCK:
		return hwdep_unlock(efw);
	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

static const struct snd_hwdep_ops hwdep_ops = {
	.read		= hwdep_read,
	.write		= hwdep_write,
	.release	= hwdep_release,
	.poll		= hwdep_poll,
	.ioctl		= hwdep_ioctl,
	.ioctl_compat	= hwdep_compat_ioctl,
};

int snd_efw_create_hwdep_device(struct snd_efw *efw)
{
	struct snd_hwdep *hwdep;
	int err;

	err = snd_hwdep_new(efw->card, "Fireworks", 0, &hwdep);
	if (err < 0)
		goto end;
	strcpy(hwdep->name, "Fireworks");
	hwdep->iface = SNDRV_HWDEP_IFACE_FW_FIREWORKS;
	hwdep->ops = hwdep_ops;
	hwdep->private_data = efw;
	hwdep->exclusive = true;
end:
	return err;
}
Commit	Line	Data
594ddced TS	1	/*
	2	* fireworks_hwdep.c - a part of driver for Fireworks based devices
	3	*
	4	* Copyright (c) 2013-2014 Takashi Sakamoto
	5	*
	6	* Licensed under the terms of the GNU General Public License, version 2.
	7	*/
	8
	9	/*
555e8a8f	10	* This codes have five functionalities.
594ddced TS	11	*
	12	* 1.get information about firewire node
	13	* 2.get notification about starting/stopping stream
	14	* 3.lock/unlock streaming
555e8a8f TS	15	* 4.transmit command of EFW transaction
	16	* 5.receive response of EFW transaction
	17	*
594ddced TS	18	*/
	19
	20	#include "fireworks.h"
	21
	22	static long
555e8a8f TS	23	hwdep_read_resp_buf(struct snd_efw efw, char __user buf, long remained,
	24	loff_t *offset)
	25	{
	26	unsigned int length, till_end, type;
	27	struct snd_efw_transaction *t;
6b1ca4bc	28	u8 *pull_ptr;
555e8a8f TS	29	long count = 0;
	30
	31	if (remained < sizeof(type) + sizeof(struct snd_efw_transaction))
	32	return -ENOSPC;
	33
	34	/* data type is SNDRV_FIREWIRE_EVENT_EFW_RESPONSE */
	35	type = SNDRV_FIREWIRE_EVENT_EFW_RESPONSE;
	36	if (copy_to_user(buf, &type, sizeof(type)))
	37	return -EFAULT;
	38	remained -= sizeof(type);
	39	buf += sizeof(type);
	40
	41	/* write into buffer as many responses as possible */
6b1ca4bc TS	42	spin_lock_irq(&efw->lock);
	43
	44	/*
	45	* When another task reaches here during this task's access to user
	46	* space, it picks up current position in buffer and can read the same
	47	* series of responses.
	48	*/
	49	pull_ptr = efw->pull_ptr;
	50
	51	while (efw->push_ptr != pull_ptr) {
	52	t = (struct snd_efw_transaction *)(pull_ptr);
555e8a8f TS	53	length = be32_to_cpu(t->length) * sizeof(__be32);
	54
	55	/* confirm enough space for this response */
	56	if (remained < length)
	57	break;
	58
	59	/* copy from ring buffer to user buffer */
	60	while (length > 0) {
	61	till_end = snd_efw_resp_buf_size -
6b1ca4bc	62	(unsigned int)(pull_ptr - efw->resp_buf);
555e8a8f TS	63	till_end = min_t(unsigned int, length, till_end);
555e8a8f TS	64
6b1ca4bc TS	65	spin_unlock_irq(&efw->lock);
	66
	67	if (copy_to_user(buf, pull_ptr, till_end))
555e8a8f TS	68	return -EFAULT;
555e8a8f TS	69
6b1ca4bc TS	70	spin_lock_irq(&efw->lock);
	71
	72	pull_ptr += till_end;
	73	if (pull_ptr >= efw->resp_buf + snd_efw_resp_buf_size)
	74	pull_ptr -= snd_efw_resp_buf_size;
555e8a8f TS	75
	76	length -= till_end;
	77	buf += till_end;
	78	count += till_end;
	79	remained -= till_end;
	80	}
555e8a8f TS	81	}
555e8a8f TS	82
6b1ca4bc TS	83	/*
	84	* All of tasks can read from the buffer nearly simultaneously, but the
	85	* last position for each task is different depending on the length of
	86	* given buffer. Here, for simplicity, a position of buffer is set by
	87	* the latest task. It's better for a listening application to allow one
	88	* thread to read from the buffer. Unless, each task can read different
	89	* sequence of responses depending on variation of buffer length.
	90	*/
	91	efw->pull_ptr = pull_ptr;
	92
	93	spin_unlock_irq(&efw->lock);
	94
555e8a8f TS	95	return count;
	96	}
	97
	98	static long
	99	hwdep_read_locked(struct snd_efw efw, char __user buf, long count,
	100	loff_t *offset)
	101	{
6b1ca4bc TS	102	union snd_firewire_event event = {
	103	.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS,
	104	};
555e8a8f	105
6b1ca4bc	106	spin_lock_irq(&efw->lock);
555e8a8f	107
555e8a8f TS	108	event.lock_status.status = (efw->dev_lock_count > 0);
	109	efw->dev_lock_changed = false;
	110
6b1ca4bc TS	111	spin_unlock_irq(&efw->lock);
6b1ca4bc TS	112
555e8a8f TS	113	count = min_t(long, count, sizeof(event.lock_status));
	114
	115	if (copy_to_user(buf, &event, count))
	116	return -EFAULT;
	117
	118	return count;
	119	}
	120
	121	static long
	122	hwdep_read(struct snd_hwdep hwdep, char __user buf, long count,
594ddced TS	123	loff_t *offset)
	124	{
	125	struct snd_efw *efw = hwdep->private_data;
	126	DEFINE_WAIT(wait);
6b1ca4bc TS	127	bool dev_lock_changed;
6b1ca4bc TS	128	bool queued;
594ddced TS	129
	130	spin_lock_irq(&efw->lock);
	131
6b1ca4bc TS	132	dev_lock_changed = efw->dev_lock_changed;
	133	queued = efw->push_ptr != efw->pull_ptr;
	134
	135	while (!dev_lock_changed && !queued) {
594ddced TS	136	prepare_to_wait(&efw->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
	137	spin_unlock_irq(&efw->lock);
	138	schedule();
	139	finish_wait(&efw->hwdep_wait, &wait);
	140	if (signal_pending(current))
	141	return -ERESTARTSYS;
	142	spin_lock_irq(&efw->lock);
6b1ca4bc TS	143	dev_lock_changed = efw->dev_lock_changed;
6b1ca4bc TS	144	queued = efw->push_ptr != efw->pull_ptr;
594ddced TS	145	}
594ddced TS	146
6b1ca4bc TS	147	spin_unlock_irq(&efw->lock);
	148
	149	if (dev_lock_changed)
555e8a8f	150	count = hwdep_read_locked(efw, buf, count, offset);
6b1ca4bc	151	else if (queued)
555e8a8f	152	count = hwdep_read_resp_buf(efw, buf, count, offset);
594ddced	153
555e8a8f TS	154	return count;
555e8a8f TS	155	}
594ddced	156
555e8a8f TS	157	static long
	158	hwdep_write(struct snd_hwdep hwdep, const char __user data, long count,
	159	loff_t *offset)
	160	{
	161	struct snd_efw *efw = hwdep->private_data;
	162	u32 seqnum;
	163	u8 *buf;
	164
	165	if (count < sizeof(struct snd_efw_transaction) \|\|
	166	SND_EFW_RESPONSE_MAXIMUM_BYTES < count)
	167	return -EINVAL;
	168
	169	buf = memdup_user(data, count);
	170	if (IS_ERR(buf))
ba06b2cb	171	return PTR_ERR(buf);
555e8a8f TS	172
	173	/* check seqnum is not for kernel-land */
	174	seqnum = be32_to_cpu(((struct snd_efw_transaction *)buf)->seqnum);
	175	if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX) {
	176	count = -EINVAL;
	177	goto end;
	178	}
	179
	180	if (snd_efw_transaction_cmd(efw->unit, buf, count) < 0)
	181	count = -EIO;
	182	end:
	183	kfree(buf);
594ddced TS	184	return count;
	185	}
	186
	187	static unsigned int
	188	hwdep_poll(struct snd_hwdep hwdep, struct file file, poll_table *wait)
	189	{
	190	struct snd_efw *efw = hwdep->private_data;
	191	unsigned int events;
	192
	193	poll_wait(file, &efw->hwdep_wait, wait);
	194
	195	spin_lock_irq(&efw->lock);
6b1ca4bc	196	if (efw->dev_lock_changed \|\| efw->pull_ptr != efw->push_ptr)
594ddced TS	197	events = POLLIN \| POLLRDNORM;
	198	else
	199	events = 0;
	200	spin_unlock_irq(&efw->lock);
	201
555e8a8f	202	return events \| POLLOUT;
594ddced TS	203	}
	204
	205	static int
	206	hwdep_get_info(struct snd_efw efw, void __user arg)
	207	{
	208	struct fw_device *dev = fw_parent_device(efw->unit);
	209	struct snd_firewire_get_info info;
	210
	211	memset(&info, 0, sizeof(info));
	212	info.type = SNDRV_FIREWIRE_TYPE_FIREWORKS;
	213	info.card = dev->card->index;
	214	(__be32 )&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
	215	(__be32 )&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
	216	strlcpy(info.device_name, dev_name(&dev->device),
	217	sizeof(info.device_name));
	218
	219	if (copy_to_user(arg, &info, sizeof(info)))
	220	return -EFAULT;
	221
	222	return 0;
	223	}
	224
	225	static int
	226	hwdep_lock(struct snd_efw *efw)
	227	{
	228	int err;
	229
	230	spin_lock_irq(&efw->lock);
	231
	232	if (efw->dev_lock_count == 0) {
	233	efw->dev_lock_count = -1;
	234	err = 0;
	235	} else {
	236	err = -EBUSY;
	237	}
	238
	239	spin_unlock_irq(&efw->lock);
	240
	241	return err;
	242	}
	243
	244	static int
	245	hwdep_unlock(struct snd_efw *efw)
	246	{
	247	int err;
	248
	249	spin_lock_irq(&efw->lock);
	250
	251	if (efw->dev_lock_count == -1) {
	252	efw->dev_lock_count = 0;
	253	err = 0;
	254	} else {
	255	err = -EBADFD;
	256	}
	257
	258	spin_unlock_irq(&efw->lock);
	259
	260	return err;
	261	}
	262
	263	static int
	264	hwdep_release(struct snd_hwdep hwdep, struct file file)
	265	{
	266	struct snd_efw *efw = hwdep->private_data;
267
268	spin_lock_irq(&efw->lock);
269	if (efw->dev_lock_count == -1)
270	efw->dev_lock_count = 0;
271	spin_unlock_irq(&efw->lock);
272
273	return 0;
274	}
275
276	static int
277	hwdep_ioctl(struct snd_hwdep hwdep, struct file file,
278	unsigned int cmd, unsigned long arg)
279	{
280	struct snd_efw *efw = hwdep->private_data;
281
282	switch (cmd) {
283	case SNDRV_FIREWIRE_IOCTL_GET_INFO:
284	return hwdep_get_info(efw, (void __user *)arg);
285	case SNDRV_FIREWIRE_IOCTL_LOCK:
286	return hwdep_lock(efw);
287	case SNDRV_FIREWIRE_IOCTL_UNLOCK:
288	return hwdep_unlock(efw);
289	default:
290	return -ENOIOCTLCMD;
291	}
292	}
293
294	#ifdef CONFIG_COMPAT
295	static int
296	hwdep_compat_ioctl(struct snd_hwdep hwdep, struct file file,
297	unsigned int cmd, unsigned long arg)
298	{
299	return hwdep_ioctl(hwdep, file, cmd,
300	(unsigned long)compat_ptr(arg));
301	}
302	#else
303	#define hwdep_compat_ioctl NULL
304	#endif
305
306	static const struct snd_hwdep_ops hwdep_ops = {
307	.read = hwdep_read,
555e8a8f	308	.write = hwdep_write,
594ddced TS	309	.release = hwdep_release,
	310	.poll = hwdep_poll,
	311	.ioctl = hwdep_ioctl,
	312	.ioctl_compat = hwdep_compat_ioctl,
	313	};
	314
	315	int snd_efw_create_hwdep_device(struct snd_efw *efw)
	316	{
	317	struct snd_hwdep *hwdep;
	318	int err;
	319
	320	err = snd_hwdep_new(efw->card, "Fireworks", 0, &hwdep);
	321	if (err < 0)
	322	goto end;
	323	strcpy(hwdep->name, "Fireworks");
	324	hwdep->iface = SNDRV_HWDEP_IFACE_FW_FIREWORKS;
	325	hwdep->ops = hwdep_ops;
	326	hwdep->private_data = efw;
	327	hwdep->exclusive = true;
	328	end:
	329	return err;
	330	}
	331