[deliverable/linux.git] / sound / firewire / dice / dice-transaction.c

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

#include "dice.h"

#define NOTIFICATION_TIMEOUT_MS	100

static u64 get_subaddr(struct snd_dice *dice, enum snd_dice_addr_type type,
		       u64 offset)
{
	switch (type) {
	case SND_DICE_ADDR_TYPE_TX:
		offset += dice->tx_offset;
		break;
	case SND_DICE_ADDR_TYPE_RX:
		offset += dice->rx_offset;
		break;
	case SND_DICE_ADDR_TYPE_SYNC:
		offset += dice->sync_offset;
		break;
	case SND_DICE_ADDR_TYPE_RSRV:
		offset += dice->rsrv_offset;
		break;
	case SND_DICE_ADDR_TYPE_GLOBAL:
	default:
		offset += dice->global_offset;
		break;
	}
	offset += DICE_PRIVATE_SPACE;
	return offset;
}

int snd_dice_transaction_write(struct snd_dice *dice,
			       enum snd_dice_addr_type type,
			       unsigned int offset, void *buf, unsigned int len)
{
	return snd_fw_transaction(dice->unit,
				  (len == 4) ? TCODE_WRITE_QUADLET_REQUEST :
					       TCODE_WRITE_BLOCK_REQUEST,
				  get_subaddr(dice, type, offset), buf, len, 0);
}

int snd_dice_transaction_read(struct snd_dice *dice,
			      enum snd_dice_addr_type type, unsigned int offset,
			      void *buf, unsigned int len)
{
	return snd_fw_transaction(dice->unit,
				  (len == 4) ? TCODE_READ_QUADLET_REQUEST :
					       TCODE_READ_BLOCK_REQUEST,
				  get_subaddr(dice, type, offset), buf, len, 0);
}

static unsigned int get_clock_info(struct snd_dice *dice, __be32 *info)
{
	return snd_dice_transaction_read_global(dice, GLOBAL_CLOCK_SELECT,
						info, 4);
}

static int set_clock_info(struct snd_dice *dice,
			  unsigned int rate, unsigned int source)
{
	unsigned int retries = 3;
	unsigned int i;
	__be32 info;
	u32 mask;
	u32 clock;
	int err;
retry:
	err = get_clock_info(dice, &info);
	if (err < 0)
		goto end;

	clock = be32_to_cpu(info);
	if (source != UINT_MAX) {
		mask = CLOCK_SOURCE_MASK;
		clock &= ~mask;
		clock |= source;
	}
	if (rate != UINT_MAX) {
		for (i = 0; i < ARRAY_SIZE(snd_dice_rates); i++) {
			if (snd_dice_rates[i] == rate)
				break;
		}
		if (i == ARRAY_SIZE(snd_dice_rates)) {
			err = -EINVAL;
			goto end;
		}

		mask = CLOCK_RATE_MASK;
		clock &= ~mask;
		clock |= i << CLOCK_RATE_SHIFT;
	}
	info = cpu_to_be32(clock);

	if (completion_done(&dice->clock_accepted))
		reinit_completion(&dice->clock_accepted);

	err = snd_dice_transaction_write_global(dice, GLOBAL_CLOCK_SELECT,
						&info, 4);
	if (err < 0)
		goto end;

	/* Timeout means it's invalid request, probably bus reset occurred. */
	if (wait_for_completion_timeout(&dice->clock_accepted,
			msecs_to_jiffies(NOTIFICATION_TIMEOUT_MS)) == 0) {
		if (retries-- == 0) {
			err = -ETIMEDOUT;
			goto end;
		}

		err = snd_dice_transaction_reinit(dice);
		if (err < 0)
			goto end;

		msleep(500);	/* arbitrary */
		goto retry;
	}
end:
	return err;
}

int snd_dice_transaction_get_clock_source(struct snd_dice *dice,
					  unsigned int *source)
{
	__be32 info;
	int err;

	err = get_clock_info(dice, &info);
	if (err >= 0)
		*source = be32_to_cpu(info) & CLOCK_SOURCE_MASK;

	return err;
}

int snd_dice_transaction_get_rate(struct snd_dice *dice, unsigned int *rate)
{
	__be32 info;
	unsigned int index;
	int err;

	err = get_clock_info(dice, &info);
	if (err < 0)
		goto end;

	index = (be32_to_cpu(info) & CLOCK_RATE_MASK) >> CLOCK_RATE_SHIFT;
	if (index >= SND_DICE_RATES_COUNT) {
		err = -ENOSYS;
		goto end;
	}

	*rate = snd_dice_rates[index];
end:
	return err;
}
int snd_dice_transaction_set_rate(struct snd_dice *dice, unsigned int rate)
{
	return set_clock_info(dice, rate, UINT_MAX);
}

int snd_dice_transaction_set_enable(struct snd_dice *dice)
{
	__be32 value;
	int err = 0;

	if (dice->global_enabled)
		goto end;

	value = cpu_to_be32(1);
	err = snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,
				 get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
					     GLOBAL_ENABLE),
				 &value, 4,
				 FW_FIXED_GENERATION | dice->owner_generation);
	if (err < 0)
		goto end;

	dice->global_enabled = true;
end:
	return err;
}

void snd_dice_transaction_clear_enable(struct snd_dice *dice)
{
	__be32 value;

	value = 0;
	snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,
			   get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
				       GLOBAL_ENABLE),
			   &value, 4, FW_QUIET |
			   FW_FIXED_GENERATION | dice->owner_generation);

	dice->global_enabled = false;
}

static void dice_notification(struct fw_card *card, struct fw_request *request,
			      int tcode, int destination, int source,
			      int generation, unsigned long long offset,
			      void *data, size_t length, void *callback_data)
{
	struct snd_dice *dice = callback_data;
	u32 bits;
	unsigned long flags;

	if (tcode != TCODE_WRITE_QUADLET_REQUEST) {
		fw_send_response(card, request, RCODE_TYPE_ERROR);
		return;
	}
	if ((offset & 3) != 0) {
		fw_send_response(card, request, RCODE_ADDRESS_ERROR);
		return;
	}

	bits = be32_to_cpup(data);

	spin_lock_irqsave(&dice->lock, flags);
	dice->notification_bits |= bits;
	spin_unlock_irqrestore(&dice->lock, flags);

	fw_send_response(card, request, RCODE_COMPLETE);

	if (bits & NOTIFY_CLOCK_ACCEPTED)
		complete(&dice->clock_accepted);
	wake_up(&dice->hwdep_wait);
}

static int register_notification_address(struct snd_dice *dice, bool retry)
{
	struct fw_device *device = fw_parent_device(dice->unit);
	__be64 *buffer;
	unsigned int retries;
	int err;

	retries = (retry) ? 3 : 0;

	buffer = kmalloc(2 * 8, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;

	for (;;) {
		buffer[0] = cpu_to_be64(OWNER_NO_OWNER);
		buffer[1] = cpu_to_be64(
			((u64)device->card->node_id << OWNER_NODE_SHIFT) |
			dice->notification_handler.offset);

		dice->owner_generation = device->generation;
		smp_rmb(); /* node_id vs. generation */
		err = snd_fw_transaction(dice->unit, TCODE_LOCK_COMPARE_SWAP,
					 get_subaddr(dice,
						     SND_DICE_ADDR_TYPE_GLOBAL,
						     GLOBAL_OWNER),
					 buffer, 2 * 8,
					 FW_FIXED_GENERATION |
							dice->owner_generation);
		if (err == 0) {
			/* success */
			if (buffer[0] == cpu_to_be64(OWNER_NO_OWNER))
				break;
			/* The address seems to be already registered. */
			if (buffer[0] == buffer[1])
				break;

			dev_err(&dice->unit->device,
				"device is already in use\n");
			err = -EBUSY;
		}
		if (err != -EAGAIN || retries-- > 0)
			break;

		msleep(20);
	}

	kfree(buffer);

	if (err < 0)
		dice->owner_generation = -1;

	return err;
}

static void unregister_notification_address(struct snd_dice *dice)
{
	struct fw_device *device = fw_parent_device(dice->unit);
	__be64 *buffer;

	buffer = kmalloc(2 * 8, GFP_KERNEL);
	if (buffer == NULL)
		return;

	buffer[0] = cpu_to_be64(
		((u64)device->card->node_id << OWNER_NODE_SHIFT) |
		dice->notification_handler.offset);
	buffer[1] = cpu_to_be64(OWNER_NO_OWNER);
	snd_fw_transaction(dice->unit, TCODE_LOCK_COMPARE_SWAP,
			   get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
				       GLOBAL_OWNER),
			   buffer, 2 * 8, FW_QUIET |
			   FW_FIXED_GENERATION | dice->owner_generation);

	kfree(buffer);

	dice->owner_generation = -1;
}

void snd_dice_transaction_destroy(struct snd_dice *dice)
{
	struct fw_address_handler *handler = &dice->notification_handler;

	if (handler->callback_data == NULL)
		return;

	unregister_notification_address(dice);

	fw_core_remove_address_handler(handler);
	handler->callback_data = NULL;
}

int snd_dice_transaction_reinit(struct snd_dice *dice)
{
	struct fw_address_handler *handler = &dice->notification_handler;

	if (handler->callback_data == NULL)
		return -EINVAL;

	return register_notification_address(dice, false);
}

int snd_dice_transaction_init(struct snd_dice *dice)
{
	struct fw_address_handler *handler = &dice->notification_handler;
	__be32 *pointers;
	int err;

	/* Use the same way which dice_interface_check() does. */
	pointers = kmalloc(sizeof(__be32) * 10, GFP_KERNEL);
	if (pointers == NULL)
		return -ENOMEM;

	/* Get offsets for sub-addresses */
	err = snd_fw_transaction(dice->unit, TCODE_READ_BLOCK_REQUEST,
				 DICE_PRIVATE_SPACE,
				 pointers, sizeof(__be32) * 10, 0);
	if (err < 0)
		goto end;

	/* Allocation callback in address space over host controller */
	handler->length = 4;
	handler->address_callback = dice_notification;
	handler->callback_data = dice;
	err = fw_core_add_address_handler(handler, &fw_high_memory_region);
	if (err < 0) {
		handler->callback_data = NULL;
		goto end;
	}

	/* Register the address space */
	err = register_notification_address(dice, true);
	if (err < 0) {
		fw_core_remove_address_handler(handler);
		handler->callback_data = NULL;
		goto end;
	}

	dice->global_offset = be32_to_cpu(pointers[0]) * 4;
	dice->tx_offset = be32_to_cpu(pointers[2]) * 4;
	dice->rx_offset = be32_to_cpu(pointers[4]) * 4;
	dice->sync_offset = be32_to_cpu(pointers[6]) * 4;
	dice->rsrv_offset = be32_to_cpu(pointers[8]) * 4;

	/* Set up later. */
	if (be32_to_cpu(pointers[1]) * 4 >= GLOBAL_CLOCK_CAPABILITIES + 4)
		dice->clock_caps = 1;
end:
	kfree(pointers);
	return err;
}
Commit	Line	Data
7c2d4c0c TS	1	/*
	2	* dice_transaction.c - a part of driver for Dice based devices
	3	*
	4	* Copyright (c) Clemens Ladisch
	5	* Copyright (c) 2014 Takashi Sakamoto
	6	*
	7	* Licensed under the terms of the GNU General Public License, version 2.
	8	*/
	9
	10	#include "dice.h"
	11
	12	#define NOTIFICATION_TIMEOUT_MS 100
	13
	14	static u64 get_subaddr(struct snd_dice *dice, enum snd_dice_addr_type type,
	15	u64 offset)
	16	{
	17	switch (type) {
	18	case SND_DICE_ADDR_TYPE_TX:
	19	offset += dice->tx_offset;
	20	break;
	21	case SND_DICE_ADDR_TYPE_RX:
	22	offset += dice->rx_offset;
	23	break;
	24	case SND_DICE_ADDR_TYPE_SYNC:
	25	offset += dice->sync_offset;
	26	break;
	27	case SND_DICE_ADDR_TYPE_RSRV:
	28	offset += dice->rsrv_offset;
	29	break;
	30	case SND_DICE_ADDR_TYPE_GLOBAL:
	31	default:
	32	offset += dice->global_offset;
	33	break;
ea09dd3b	34	}
7c2d4c0c TS	35	offset += DICE_PRIVATE_SPACE;
	36	return offset;
	37	}
	38
	39	int snd_dice_transaction_write(struct snd_dice *dice,
	40	enum snd_dice_addr_type type,
	41	unsigned int offset, void *buf, unsigned int len)
	42	{
	43	return snd_fw_transaction(dice->unit,
	44	(len == 4) ? TCODE_WRITE_QUADLET_REQUEST :
	45	TCODE_WRITE_BLOCK_REQUEST,
	46	get_subaddr(dice, type, offset), buf, len, 0);
	47	}
	48
	49	int snd_dice_transaction_read(struct snd_dice *dice,
	50	enum snd_dice_addr_type type, unsigned int offset,
	51	void *buf, unsigned int len)
	52	{
	53	return snd_fw_transaction(dice->unit,
	54	(len == 4) ? TCODE_READ_QUADLET_REQUEST :
	55	TCODE_READ_BLOCK_REQUEST,
	56	get_subaddr(dice, type, offset), buf, len, 0);
	57	}
	58
	59	static unsigned int get_clock_info(struct snd_dice dice, __be32 info)
	60	{
	61	return snd_dice_transaction_read_global(dice, GLOBAL_CLOCK_SELECT,
	62	info, 4);
	63	}
	64
	65	static int set_clock_info(struct snd_dice *dice,
	66	unsigned int rate, unsigned int source)
	67	{
	68	unsigned int retries = 3;
	69	unsigned int i;
	70	__be32 info;
	71	u32 mask;
	72	u32 clock;
	73	int err;
	74	retry:
	75	err = get_clock_info(dice, &info);
	76	if (err < 0)
	77	goto end;
	78
	79	clock = be32_to_cpu(info);
	80	if (source != UINT_MAX) {
	81	mask = CLOCK_SOURCE_MASK;
	82	clock &= ~mask;
	83	clock \|= source;
	84	}
	85	if (rate != UINT_MAX) {
	86	for (i = 0; i < ARRAY_SIZE(snd_dice_rates); i++) {
	87	if (snd_dice_rates[i] == rate)
	88	break;
	89	}
	90	if (i == ARRAY_SIZE(snd_dice_rates)) {
	91	err = -EINVAL;
	92	goto end;
	93	}
	94
	95	mask = CLOCK_RATE_MASK;
	96	clock &= ~mask;
	97	clock \|= i << CLOCK_RATE_SHIFT;
	98	}
99	info = cpu_to_be32(clock);
100
101	if (completion_done(&dice->clock_accepted))
102	reinit_completion(&dice->clock_accepted);
103
104	err = snd_dice_transaction_write_global(dice, GLOBAL_CLOCK_SELECT,
105	&info, 4);
106	if (err < 0)
107	goto end;
108
109	/* Timeout means it's invalid request, probably bus reset occurred. */
110	if (wait_for_completion_timeout(&dice->clock_accepted,
111	msecs_to_jiffies(NOTIFICATION_TIMEOUT_MS)) == 0) {
112	if (retries-- == 0) {
113	err = -ETIMEDOUT;
114	goto end;
115	}
116
117	err = snd_dice_transaction_reinit(dice);
118	if (err < 0)
119	goto end;
120
121	msleep(500); /* arbitrary */
122	goto retry;
123	}
124	end:
125	return err;
126	}
127
128	int snd_dice_transaction_get_clock_source(struct snd_dice *dice,
129	unsigned int *source)
130	{
131	__be32 info;
132	int err;
133
134	err = get_clock_info(dice, &info);
135	if (err >= 0)
136	*source = be32_to_cpu(info) & CLOCK_SOURCE_MASK;
137
138	return err;
139	}
7c2d4c0c TS	140
	141	int snd_dice_transaction_get_rate(struct snd_dice dice, unsigned int rate)
	142	{
	143	__be32 info;
	144	unsigned int index;
	145	int err;
	146
	147	err = get_clock_info(dice, &info);
	148	if (err < 0)
	149	goto end;
	150
	151	index = (be32_to_cpu(info) & CLOCK_RATE_MASK) >> CLOCK_RATE_SHIFT;
	152	if (index >= SND_DICE_RATES_COUNT) {
	153	err = -ENOSYS;
	154	goto end;
	155	}
	156
	157	*rate = snd_dice_rates[index];
	158	end:
	159	return err;
	160	}
	161	int snd_dice_transaction_set_rate(struct snd_dice *dice, unsigned int rate)
	162	{
	163	return set_clock_info(dice, rate, UINT_MAX);
	164	}
	165
	166	int snd_dice_transaction_set_enable(struct snd_dice *dice)
	167	{
	168	__be32 value;
	169	int err = 0;
	170
	171	if (dice->global_enabled)
	172	goto end;
	173
	174	value = cpu_to_be32(1);
	175	err = snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,
	176	get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
	177	GLOBAL_ENABLE),
	178	&value, 4,
	179	FW_FIXED_GENERATION \| dice->owner_generation);
	180	if (err < 0)
	181	goto end;
	182
	183	dice->global_enabled = true;
	184	end:
	185	return err;
	186	}
	187
	188	void snd_dice_transaction_clear_enable(struct snd_dice *dice)
	189	{
	190	__be32 value;
	191
	192	value = 0;
	193	snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,
	194	get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
	195	GLOBAL_ENABLE),
	196	&value, 4, FW_QUIET \|
	197	FW_FIXED_GENERATION \| dice->owner_generation);
	198
	199	dice->global_enabled = false;
	200	}
	201
	202	static void dice_notification(struct fw_card card, struct fw_request request,
	203	int tcode, int destination, int source,
204	int generation, unsigned long long offset,
205	void data, size_t length, void callback_data)
206	{
207	struct snd_dice *dice = callback_data;
208	u32 bits;
209	unsigned long flags;
210
211	if (tcode != TCODE_WRITE_QUADLET_REQUEST) {
212	fw_send_response(card, request, RCODE_TYPE_ERROR);
213	return;
214	}
215	if ((offset & 3) != 0) {
216	fw_send_response(card, request, RCODE_ADDRESS_ERROR);
217	return;
218	}
219
220	bits = be32_to_cpup(data);
221
222	spin_lock_irqsave(&dice->lock, flags);
223	dice->notification_bits \|= bits;
224	spin_unlock_irqrestore(&dice->lock, flags);
225
226	fw_send_response(card, request, RCODE_COMPLETE);
227
228	if (bits & NOTIFY_CLOCK_ACCEPTED)
229	complete(&dice->clock_accepted);
230	wake_up(&dice->hwdep_wait);
231	}
232
233	static int register_notification_address(struct snd_dice *dice, bool retry)
234	{
235	struct fw_device *device = fw_parent_device(dice->unit);
236	__be64 *buffer;
237	unsigned int retries;
238	int err;
239
240	retries = (retry) ? 3 : 0;
241
242	buffer = kmalloc(2 * 8, GFP_KERNEL);
243	if (!buffer)
244	return -ENOMEM;
245
246	for (;;) {
247	buffer[0] = cpu_to_be64(OWNER_NO_OWNER);
248	buffer[1] = cpu_to_be64(
249	((u64)device->card->node_id << OWNER_NODE_SHIFT) \|
250	dice->notification_handler.offset);
251
252	dice->owner_generation = device->generation;
253	smp_rmb(); /* node_id vs. generation */
254	err = snd_fw_transaction(dice->unit, TCODE_LOCK_COMPARE_SWAP,
255	get_subaddr(dice,
256	SND_DICE_ADDR_TYPE_GLOBAL,
257	GLOBAL_OWNER),
258	buffer, 2 * 8,
259	FW_FIXED_GENERATION \|
260	dice->owner_generation);
261	if (err == 0) {
262	/* success */
263	if (buffer[0] == cpu_to_be64(OWNER_NO_OWNER))
264	break;
265	/* The address seems to be already registered. */
266	if (buffer[0] == buffer[1])
267	break;
268
269	dev_err(&dice->unit->device,
270	"device is already in use\n");
271	err = -EBUSY;
272	}
273	if (err != -EAGAIN \|\| retries-- > 0)
274	break;
275
276	msleep(20);
277	}
278
279	kfree(buffer);
280
281	if (err < 0)
282	dice->owner_generation = -1;
283
284	return err;
285	}
286
287	static void unregister_notification_address(struct snd_dice *dice)
288	{
289	struct fw_device *device = fw_parent_device(dice->unit);
290	__be64 *buffer;
291
292	buffer = kmalloc(2 * 8, GFP_KERNEL);
293	if (buffer == NULL)
294	return;
295
296	buffer[0] = cpu_to_be64(
297	((u64)device->card->node_id << OWNER_NODE_SHIFT) \|
298	dice->notification_handler.offset);
299	buffer[1] = cpu_to_be64(OWNER_NO_OWNER);
300	snd_fw_transaction(dice->unit, TCODE_LOCK_COMPARE_SWAP,
301	get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
302	GLOBAL_OWNER),
303	buffer, 2 * 8, FW_QUIET \|
304	FW_FIXED_GENERATION \| dice->owner_generation);
305
306	kfree(buffer);
307
308	dice->owner_generation = -1;
309	}
310
311	void snd_dice_transaction_destroy(struct snd_dice *dice)
312	{
313	struct fw_address_handler *handler = &dice->notification_handler;
314
315	if (handler->callback_data == NULL)
316	return;
317
318	unregister_notification_address(dice);
319
320	fw_core_remove_address_handler(handler);
321	handler->callback_data = NULL;
322	}
323
324	int snd_dice_transaction_reinit(struct snd_dice *dice)
325	{
326	struct fw_address_handler *handler = &dice->notification_handler;
327
328	if (handler->callback_data == NULL)
329	return -EINVAL;
330
331	return register_notification_address(dice, false);
332	}
333
334	int snd_dice_transaction_init(struct snd_dice *dice)
335	{
336	struct fw_address_handler *handler = &dice->notification_handler;
337	__be32 *pointers;
338	int err;
339
340	/* Use the same way which dice_interface_check() does. */
341	pointers = kmalloc(sizeof(__be32) * 10, GFP_KERNEL);
342	if (pointers == NULL)
343	return -ENOMEM;
344
345	/* Get offsets for sub-addresses */
346	err = snd_fw_transaction(dice->unit, TCODE_READ_BLOCK_REQUEST,
347	DICE_PRIVATE_SPACE,
348	pointers, sizeof(__be32) * 10, 0);
349	if (err < 0)
350	goto end;
351
352	/* Allocation callback in address space over host controller */
353	handler->length = 4;
354	handler->address_callback = dice_notification;
355	handler->callback_data = dice;
356	err = fw_core_add_address_handler(handler, &fw_high_memory_region);
357	if (err < 0) {
358	handler->callback_data = NULL;
359	goto end;
360	}
361
362	/* Register the address space */
363	err = register_notification_address(dice, true);
364	if (err < 0) {
365	fw_core_remove_address_handler(handler);
366	handler->callback_data = NULL;
367	goto end;
368	}
369
370	dice->global_offset = be32_to_cpu(pointers[0]) * 4;
371	dice->tx_offset = be32_to_cpu(pointers[2]) * 4;
372	dice->rx_offset = be32_to_cpu(pointers[4]) * 4;
373	dice->sync_offset = be32_to_cpu(pointers[6]) * 4;
374	dice->rsrv_offset = be32_to_cpu(pointers[8]) * 4;
375
376	/* Set up later. */
377	if (be32_to_cpu(pointers[1]) * 4 >= GLOBAL_CLOCK_CAPABILITIES + 4)
378	dice->clock_caps = 1;
379	end:
380	kfree(pointers);
381	return err;
382	}