[linux-2.6-block.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"

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);
}

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_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_LOCK_CHG)
		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);
}

static int get_subaddrs(struct snd_dice *dice)
{
	static const int min_values[10] = {
		10, 0x60 / 4,
		10, 0x18 / 4,
		10, 0x18 / 4,
		0, 0,
		0, 0,
	};
	__be32 *pointers;
	__be32 version;
	u32 data;
	unsigned int i;
	int err;

	pointers = kmalloc_array(ARRAY_SIZE(min_values), sizeof(__be32),
				 GFP_KERNEL);
	if (pointers == NULL)
		return -ENOMEM;

	/*
	 * Check that the sub address spaces exist and are located inside the
	 * private address space.  The minimum values are chosen so that all
	 * minimally required registers are included.
	 */
	err = snd_fw_transaction(dice->unit, TCODE_READ_BLOCK_REQUEST,
				 DICE_PRIVATE_SPACE, pointers,
				 sizeof(__be32) * ARRAY_SIZE(min_values), 0);
	if (err < 0)
		goto end;

	for (i = 0; i < ARRAY_SIZE(min_values); ++i) {
		data = be32_to_cpu(pointers[i]);
		if (data < min_values[i] || data >= 0x40000) {
			err = -ENODEV;
			goto end;
		}
	}

	if (be32_to_cpu(pointers[1]) > 0x18) {
		/*
		 * Check that the implemented DICE driver specification major
		 * version number matches.
		 */
		err = snd_fw_transaction(dice->unit, TCODE_READ_QUADLET_REQUEST,
				DICE_PRIVATE_SPACE +
				be32_to_cpu(pointers[0]) * 4 + GLOBAL_VERSION,
				&version, sizeof(version), 0);
		if (err < 0)
			goto end;

		if ((version & cpu_to_be32(0xff000000)) !=
						cpu_to_be32(0x01000000)) {
			dev_err(&dice->unit->device,
				"unknown DICE version: 0x%08x\n",
				be32_to_cpu(version));
			err = -ENODEV;
			goto end;
		}

		/* Set up later. */
		dice->clock_caps = 1;
	}

	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;

	/* Old firmware doesn't support these fields. */
	if (pointers[7])
		dice->sync_offset = be32_to_cpu(pointers[6]) * 4;
	if (pointers[9])
		dice->rsrv_offset = be32_to_cpu(pointers[8]) * 4;
end:
	kfree(pointers);
	return err;
}

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

	err = get_subaddrs(dice);
	if (err < 0)
		return err;

	/* 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;
		return err;
	}

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

	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
7c2d4c0c TS	12	static u64 get_subaddr(struct snd_dice *dice, enum snd_dice_addr_type type,
	13	u64 offset)
	14	{
	15	switch (type) {
	16	case SND_DICE_ADDR_TYPE_TX:
	17	offset += dice->tx_offset;
	18	break;
	19	case SND_DICE_ADDR_TYPE_RX:
	20	offset += dice->rx_offset;
	21	break;
	22	case SND_DICE_ADDR_TYPE_SYNC:
	23	offset += dice->sync_offset;
	24	break;
	25	case SND_DICE_ADDR_TYPE_RSRV:
	26	offset += dice->rsrv_offset;
	27	break;
	28	case SND_DICE_ADDR_TYPE_GLOBAL:
	29	default:
	30	offset += dice->global_offset;
	31	break;
ea09dd3b	32	}
7c2d4c0c TS	33	offset += DICE_PRIVATE_SPACE;
	34	return offset;
	35	}
	36
	37	int snd_dice_transaction_write(struct snd_dice *dice,
	38	enum snd_dice_addr_type type,
	39	unsigned int offset, void *buf, unsigned int len)
	40	{
	41	return snd_fw_transaction(dice->unit,
	42	(len == 4) ? TCODE_WRITE_QUADLET_REQUEST :
	43	TCODE_WRITE_BLOCK_REQUEST,
	44	get_subaddr(dice, type, offset), buf, len, 0);
	45	}
	46
	47	int snd_dice_transaction_read(struct snd_dice *dice,
	48	enum snd_dice_addr_type type, unsigned int offset,
	49	void *buf, unsigned int len)
	50	{
	51	return snd_fw_transaction(dice->unit,
	52	(len == 4) ? TCODE_READ_QUADLET_REQUEST :
	53	TCODE_READ_BLOCK_REQUEST,
	54	get_subaddr(dice, type, offset), buf, len, 0);
	55	}
	56
	57	static unsigned int get_clock_info(struct snd_dice dice, __be32 info)
	58	{
	59	return snd_dice_transaction_read_global(dice, GLOBAL_CLOCK_SELECT,
	60	info, 4);
	61	}
	62
7c2d4c0c TS	63	int snd_dice_transaction_get_clock_source(struct snd_dice *dice,
	64	unsigned int *source)
	65	{
	66	__be32 info;
	67	int err;
	68
	69	err = get_clock_info(dice, &info);
	70	if (err >= 0)
	71	*source = be32_to_cpu(info) & CLOCK_SOURCE_MASK;
	72
	73	return err;
	74	}
7c2d4c0c TS	75
	76	int snd_dice_transaction_get_rate(struct snd_dice dice, unsigned int rate)
	77	{
	78	__be32 info;
	79	unsigned int index;
	80	int err;
	81
	82	err = get_clock_info(dice, &info);
	83	if (err < 0)
	84	goto end;
	85
	86	index = (be32_to_cpu(info) & CLOCK_RATE_MASK) >> CLOCK_RATE_SHIFT;
	87	if (index >= SND_DICE_RATES_COUNT) {
	88	err = -ENOSYS;
	89	goto end;
	90	}
	91
	92	*rate = snd_dice_rates[index];
	93	end:
	94	return err;
	95	}
7c2d4c0c TS	96
	97	int snd_dice_transaction_set_enable(struct snd_dice *dice)
	98	{
	99	__be32 value;
	100	int err = 0;
	101
	102	if (dice->global_enabled)
	103	goto end;
	104
	105	value = cpu_to_be32(1);
	106	err = snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,
	107	get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
	108	GLOBAL_ENABLE),
	109	&value, 4,
	110	FW_FIXED_GENERATION \| dice->owner_generation);
	111	if (err < 0)
	112	goto end;
	113
	114	dice->global_enabled = true;
	115	end:
	116	return err;
	117	}
	118
	119	void snd_dice_transaction_clear_enable(struct snd_dice *dice)
	120	{
	121	__be32 value;
	122
	123	value = 0;
	124	snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,
	125	get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
	126	GLOBAL_ENABLE),
	127	&value, 4, FW_QUIET \|
	128	FW_FIXED_GENERATION \| dice->owner_generation);
	129
	130	dice->global_enabled = false;
	131	}
	132
	133	static void dice_notification(struct fw_card card, struct fw_request request,
	134	int tcode, int destination, int source,
	135	int generation, unsigned long long offset,
	136	void data, size_t length, void callback_data)
	137	{
	138	struct snd_dice *dice = callback_data;
	139	u32 bits;
	140	unsigned long flags;
	141
	142	if (tcode != TCODE_WRITE_QUADLET_REQUEST) {
	143	fw_send_response(card, request, RCODE_TYPE_ERROR);
	144	return;
	145	}
	146	if ((offset & 3) != 0) {
	147	fw_send_response(card, request, RCODE_ADDRESS_ERROR);
	148	return;
	149	}
	150
	151	bits = be32_to_cpup(data);
	152
	153	spin_lock_irqsave(&dice->lock, flags);
	154	dice->notification_bits \|= bits;
	155	spin_unlock_irqrestore(&dice->lock, flags);
	156
	157	fw_send_response(card, request, RCODE_COMPLETE);
	158
aec045b8	159	if (bits & NOTIFY_LOCK_CHG)
7c2d4c0c TS	160	complete(&dice->clock_accepted);
	161	wake_up(&dice->hwdep_wait);
	162	}
	163
	164	static int register_notification_address(struct snd_dice *dice, bool retry)
	165	{
	166	struct fw_device *device = fw_parent_device(dice->unit);
	167	__be64 *buffer;
	168	unsigned int retries;
	169	int err;
	170
	171	retries = (retry) ? 3 : 0;
	172
	173	buffer = kmalloc(2 * 8, GFP_KERNEL);
	174	if (!buffer)
	175	return -ENOMEM;
	176
	177	for (;;) {
	178	buffer[0] = cpu_to_be64(OWNER_NO_OWNER);
	179	buffer[1] = cpu_to_be64(
	180	((u64)device->card->node_id << OWNER_NODE_SHIFT) \|
	181	dice->notification_handler.offset);
	182
	183	dice->owner_generation = device->generation;
	184	smp_rmb(); /* node_id vs. generation */
	185	err = snd_fw_transaction(dice->unit, TCODE_LOCK_COMPARE_SWAP,
	186	get_subaddr(dice,
	187	SND_DICE_ADDR_TYPE_GLOBAL,
	188	GLOBAL_OWNER),
	189	buffer, 2 * 8,
	190	FW_FIXED_GENERATION \|
	191	dice->owner_generation);
	192	if (err == 0) {
	193	/* success */
	194	if (buffer[0] == cpu_to_be64(OWNER_NO_OWNER))
	195	break;
	196	/* The address seems to be already registered. */
	197	if (buffer[0] == buffer[1])
	198	break;
	199
	200	dev_err(&dice->unit->device,
	201	"device is already in use\n");
	202	err = -EBUSY;
	203	}
	204	if (err != -EAGAIN \|\| retries-- > 0)
	205	break;
	206
	207	msleep(20);
	208	}
	209
	210	kfree(buffer);
	211
	212	if (err < 0)
	213	dice->owner_generation = -1;
	214
	215	return err;
	216	}
	217
	218	static void unregister_notification_address(struct snd_dice *dice)
	219	{
	220	struct fw_device *device = fw_parent_device(dice->unit);
	221	__be64 *buffer;
	222
	223	buffer = kmalloc(2 * 8, GFP_KERNEL);
224	if (buffer == NULL)
225	return;
226
227	buffer[0] = cpu_to_be64(
228	((u64)device->card->node_id << OWNER_NODE_SHIFT) \|
229	dice->notification_handler.offset);
230	buffer[1] = cpu_to_be64(OWNER_NO_OWNER);
231	snd_fw_transaction(dice->unit, TCODE_LOCK_COMPARE_SWAP,
232	get_subaddr(dice, SND_DICE_ADDR_TYPE_GLOBAL,
233	GLOBAL_OWNER),
234	buffer, 2 * 8, FW_QUIET \|
235	FW_FIXED_GENERATION \| dice->owner_generation);
236
237	kfree(buffer);
238
239	dice->owner_generation = -1;
240	}
241
242	void snd_dice_transaction_destroy(struct snd_dice *dice)
243	{
244	struct fw_address_handler *handler = &dice->notification_handler;
245
246	if (handler->callback_data == NULL)
247	return;
248
249	unregister_notification_address(dice);
250
251	fw_core_remove_address_handler(handler);
252	handler->callback_data = NULL;
253	}
254
255	int snd_dice_transaction_reinit(struct snd_dice *dice)
256	{
257	struct fw_address_handler *handler = &dice->notification_handler;
258
259	if (handler->callback_data == NULL)
260	return -EINVAL;
261
262	return register_notification_address(dice, false);
263	}
264
4a47a87d	265	static int get_subaddrs(struct snd_dice *dice)
7c2d4c0c	266	{
4a47a87d	267	static const int min_values[10] = {
c1a36101	268	10, 0x60 / 4,
4a47a87d TS	269	10, 0x18 / 4,
	270	10, 0x18 / 4,
	271	0, 0,
	272	0, 0,
	273	};
7c2d4c0c	274	__be32 *pointers;
4a47a87d TS	275	__be32 version;
	276	u32 data;
	277	unsigned int i;
7c2d4c0c TS	278	int err;
7c2d4c0c TS	279
4a47a87d TS	280	pointers = kmalloc_array(ARRAY_SIZE(min_values), sizeof(__be32),
4a47a87d TS	281	GFP_KERNEL);
7c2d4c0c TS	282	if (pointers == NULL)
	283	return -ENOMEM;
	284
4a47a87d TS	285	/*
	286	* Check that the sub address spaces exist and are located inside the
	287	* private address space. The minimum values are chosen so that all
	288	* minimally required registers are included.
	289	*/
7c2d4c0c	290	err = snd_fw_transaction(dice->unit, TCODE_READ_BLOCK_REQUEST,
4a47a87d TS	291	DICE_PRIVATE_SPACE, pointers,
4a47a87d TS	292	sizeof(__be32) * ARRAY_SIZE(min_values), 0);
7c2d4c0c TS	293	if (err < 0)
	294	goto end;
	295
4a47a87d TS	296	for (i = 0; i < ARRAY_SIZE(min_values); ++i) {
	297	data = be32_to_cpu(pointers[i]);
	298	if (data < min_values[i] \|\| data >= 0x40000) {
	299	err = -ENODEV;
	300	goto end;
	301	}
7c2d4c0c TS	302	}
7c2d4c0c TS	303
c1a36101 TS	304	if (be32_to_cpu(pointers[1]) > 0x18) {
	305	/*
	306	* Check that the implemented DICE driver specification major
	307	* version number matches.
	308	*/
	309	err = snd_fw_transaction(dice->unit, TCODE_READ_QUADLET_REQUEST,
	310	DICE_PRIVATE_SPACE +
	311	be32_to_cpu(pointers[0]) * 4 + GLOBAL_VERSION,
	312	&version, sizeof(version), 0);
	313	if (err < 0)
	314	goto end;
4a47a87d	315
c1a36101 TS	316	if ((version & cpu_to_be32(0xff000000)) !=
	317	cpu_to_be32(0x01000000)) {
	318	dev_err(&dice->unit->device,
	319	"unknown DICE version: 0x%08x\n",
	320	be32_to_cpu(version));
	321	err = -ENODEV;
	322	goto end;
	323	}
	324
	325	/* Set up later. */
	326	dice->clock_caps = 1;
7c2d4c0c TS	327	}
	328
	329	dice->global_offset = be32_to_cpu(pointers[0]) * 4;
	330	dice->tx_offset = be32_to_cpu(pointers[2]) * 4;
	331	dice->rx_offset = be32_to_cpu(pointers[4]) * 4;
7c2d4c0c	332
c1a36101 TS	333	/* Old firmware doesn't support these fields. */
	334	if (pointers[7])
	335	dice->sync_offset = be32_to_cpu(pointers[6]) * 4;
	336	if (pointers[9])
	337	dice->rsrv_offset = be32_to_cpu(pointers[8]) * 4;
7c2d4c0c TS	338	end:
	339	kfree(pointers);
	340	return err;
	341	}
4a47a87d TS	342
	343	int snd_dice_transaction_init(struct snd_dice *dice)
	344	{
	345	struct fw_address_handler *handler = &dice->notification_handler;
	346	int err;
	347
	348	err = get_subaddrs(dice);
	349	if (err < 0)
	350	return err;
	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	return err;
	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	}
	368
	369	return err;
	370	}