sound/firewire/dice/dice.c - kernel/msm-4.9 - Gitiles

 /*
  * TC Applied Technologies Digital Interface Communications Engine driver
  *
  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
  * Licensed under the terms of the GNU General Public License, version 2.
  */

 #include "dice.h"

 MODULE_DESCRIPTION("DICE driver");
 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
 MODULE_LICENSE("GPL v2");

 static int dice_proc_read_mem(struct snd_dice *dice, void *buffer,
 			      unsigned int offset_q, unsigned int quadlets)
 {
 	unsigned int i;
 	int err;

 	err = snd_fw_transaction(dice->unit, TCODE_READ_BLOCK_REQUEST,
 				 DICE_PRIVATE_SPACE + 4 * offset_q,
 				 buffer, 4 * quadlets, 0);
 	if (err < 0)
 		return err;

 	for (i = 0; i < quadlets; ++i)
 		be32_to_cpus(&((u32 *)buffer)[i]);

 	return 0;
 }

 static const char *str_from_array(const char *const strs[], unsigned int count,
 				  unsigned int i)
 {
 	if (i < count)
 		return strs[i];

 	return "(unknown)";
 }

 static void dice_proc_fixup_string(char *s, unsigned int size)
 {
 	unsigned int i;

 	for (i = 0; i < size; i += 4)
 		cpu_to_le32s((u32 *)(s + i));

 	for (i = 0; i < size - 2; ++i) {
 		if (s[i] == '\0')
 			return;
 		if (s[i] == '\\' && s[i + 1] == '\\') {
 			s[i + 2] = '\0';
 			return;
 		}
 	}
 	s[size - 1] = '\0';
 }

 static void dice_proc_read(struct snd_info_entry *entry,
 			   struct snd_info_buffer *buffer)
 {
 	static const char *const section_names[5] = {
 		"global", "tx", "rx", "ext_sync", "unused2"
 	};
 	static const char *const clock_sources[] = {
 		"aes1", "aes2", "aes3", "aes4", "aes", "adat", "tdif",
 		"wc", "arx1", "arx2", "arx3", "arx4", "internal"
 	};
 	static const char *const rates[] = {
 		"32000", "44100", "48000", "88200", "96000", "176400", "192000",
 		"any low", "any mid", "any high", "none"
 	};
 	struct snd_dice *dice = entry->private_data;
 	u32 sections[ARRAY_SIZE(section_names) * 2];
 	struct {
 		u32 number;
 		u32 size;
 	} tx_rx_header;
 	union {
 		struct {
 			u32 owner_hi, owner_lo;
 			u32 notification;
 			char nick_name[NICK_NAME_SIZE];
 			u32 clock_select;
 			u32 enable;
 			u32 status;
 			u32 extended_status;
 			u32 sample_rate;
 			u32 version;
 			u32 clock_caps;
 			char clock_source_names[CLOCK_SOURCE_NAMES_SIZE];
 		} global;
 		struct {
 			u32 iso;
 			u32 number_audio;
 			u32 number_midi;
 			u32 speed;
 			char names[TX_NAMES_SIZE];
 			u32 ac3_caps;
 			u32 ac3_enable;
 		} tx;
 		struct {
 			u32 iso;
 			u32 seq_start;
 			u32 number_audio;
 			u32 number_midi;
 			char names[RX_NAMES_SIZE];
 			u32 ac3_caps;
 			u32 ac3_enable;
 		} rx;
 		struct {
 			u32 clock_source;
 			u32 locked;
 			u32 rate;
 			u32 adat_user_data;
 		} ext_sync;
 	} buf;
 	unsigned int quadlets, stream, i;

 	if (dice_proc_read_mem(dice, sections, 0, ARRAY_SIZE(sections)) < 0)
 		return;
 	snd_iprintf(buffer, "sections:\n");
 	for (i = 0; i < ARRAY_SIZE(section_names); ++i)
 		snd_iprintf(buffer, "  %s: offset %u, size %u\n",
 			    section_names[i],
 			    sections[i * 2], sections[i * 2 + 1]);

 	quadlets = min_t(u32, sections[1], sizeof(buf.global) / 4);
 	if (dice_proc_read_mem(dice, &buf.global, sections[0], quadlets) < 0)
 		return;
 	snd_iprintf(buffer, "global:\n");
 	snd_iprintf(buffer, "  owner: %04x:%04x%08x\n",
 		    buf.global.owner_hi >> 16,
 		    buf.global.owner_hi & 0xffff, buf.global.owner_lo);
 	snd_iprintf(buffer, "  notification: %08x\n", buf.global.notification);
 	dice_proc_fixup_string(buf.global.nick_name, NICK_NAME_SIZE);
 	snd_iprintf(buffer, "  nick name: %s\n", buf.global.nick_name);
 	snd_iprintf(buffer, "  clock select: %s %s\n",
 		    str_from_array(clock_sources, ARRAY_SIZE(clock_sources),
 				   buf.global.clock_select & CLOCK_SOURCE_MASK),
 		    str_from_array(rates, ARRAY_SIZE(rates),
 				   (buf.global.clock_select & CLOCK_RATE_MASK)
 				   >> CLOCK_RATE_SHIFT));
 	snd_iprintf(buffer, "  enable: %u\n", buf.global.enable);
 	snd_iprintf(buffer, "  status: %slocked %s\n",
 		    buf.global.status & STATUS_SOURCE_LOCKED ? "" : "un",
 		    str_from_array(rates, ARRAY_SIZE(rates),
 				   (buf.global.status &
 				    STATUS_NOMINAL_RATE_MASK)
 				   >> CLOCK_RATE_SHIFT));
 	snd_iprintf(buffer, "  ext status: %08x\n", buf.global.extended_status);
 	snd_iprintf(buffer, "  sample rate: %u\n", buf.global.sample_rate);
 	snd_iprintf(buffer, "  version: %u.%u.%u.%u\n",
 		    (buf.global.version >> 24) & 0xff,
 		    (buf.global.version >> 16) & 0xff,
 		    (buf.global.version >>  8) & 0xff,
 		    (buf.global.version >>  0) & 0xff);
 	if (quadlets >= 90) {
 		snd_iprintf(buffer, "  clock caps:");
 		for (i = 0; i <= 6; ++i)
 			if (buf.global.clock_caps & (1 << i))
 				snd_iprintf(buffer, " %s", rates[i]);
 		for (i = 0; i <= 12; ++i)
 			if (buf.global.clock_caps & (1 << (16 + i)))
 				snd_iprintf(buffer, " %s", clock_sources[i]);
 		snd_iprintf(buffer, "\n");
 		dice_proc_fixup_string(buf.global.clock_source_names,
 				       CLOCK_SOURCE_NAMES_SIZE);
 		snd_iprintf(buffer, "  clock source names: %s\n",
 			    buf.global.clock_source_names);
 	}

 	if (dice_proc_read_mem(dice, &tx_rx_header, sections[2], 2) < 0)
 		return;
 	quadlets = min_t(u32, tx_rx_header.size, sizeof(buf.tx) / 4);
 	for (stream = 0; stream < tx_rx_header.number; ++stream) {
 		if (dice_proc_read_mem(dice, &buf.tx, sections[2] + 2 +
 				       stream * tx_rx_header.size,
 				       quadlets) < 0)
 			break;
 		snd_iprintf(buffer, "tx %u:\n", stream);
 		snd_iprintf(buffer, "  iso channel: %d\n", (int)buf.tx.iso);
 		snd_iprintf(buffer, "  audio channels: %u\n",
 			    buf.tx.number_audio);
 		snd_iprintf(buffer, "  midi ports: %u\n", buf.tx.number_midi);
 		snd_iprintf(buffer, "  speed: S%u\n", 100u << buf.tx.speed);
 		if (quadlets >= 68) {
 			dice_proc_fixup_string(buf.tx.names, TX_NAMES_SIZE);
 			snd_iprintf(buffer, "  names: %s\n", buf.tx.names);
 		}
 		if (quadlets >= 70) {
 			snd_iprintf(buffer, "  ac3 caps: %08x\n",
 				    buf.tx.ac3_caps);
 			snd_iprintf(buffer, "  ac3 enable: %08x\n",
 				    buf.tx.ac3_enable);
 		}
 	}

 	if (dice_proc_read_mem(dice, &tx_rx_header, sections[4], 2) < 0)
 		return;
 	quadlets = min_t(u32, tx_rx_header.size, sizeof(buf.rx) / 4);
 	for (stream = 0; stream < tx_rx_header.number; ++stream) {
 		if (dice_proc_read_mem(dice, &buf.rx, sections[4] + 2 +
 				       stream * tx_rx_header.size,
 				       quadlets) < 0)
 			break;
 		snd_iprintf(buffer, "rx %u:\n", stream);
 		snd_iprintf(buffer, "  iso channel: %d\n", (int)buf.rx.iso);
 		snd_iprintf(buffer, "  sequence start: %u\n", buf.rx.seq_start);
 		snd_iprintf(buffer, "  audio channels: %u\n",
 			    buf.rx.number_audio);
 		snd_iprintf(buffer, "  midi ports: %u\n", buf.rx.number_midi);
 		if (quadlets >= 68) {
 			dice_proc_fixup_string(buf.rx.names, RX_NAMES_SIZE);
 			snd_iprintf(buffer, "  names: %s\n", buf.rx.names);
 		}
 		if (quadlets >= 70) {
 			snd_iprintf(buffer, "  ac3 caps: %08x\n",
 				    buf.rx.ac3_caps);
 			snd_iprintf(buffer, "  ac3 enable: %08x\n",
 				    buf.rx.ac3_enable);
 		}
 	}

 	quadlets = min_t(u32, sections[7], sizeof(buf.ext_sync) / 4);
 	if (quadlets >= 4) {
 		if (dice_proc_read_mem(dice, &buf.ext_sync,
 				       sections[6], 4) < 0)
 			return;
 		snd_iprintf(buffer, "ext status:\n");
 		snd_iprintf(buffer, "  clock source: %s\n",
 			    str_from_array(clock_sources,
 					   ARRAY_SIZE(clock_sources),
 					   buf.ext_sync.clock_source));
 		snd_iprintf(buffer, "  locked: %u\n", buf.ext_sync.locked);
 		snd_iprintf(buffer, "  rate: %s\n",
 			    str_from_array(rates, ARRAY_SIZE(rates),
 					   buf.ext_sync.rate));
 		snd_iprintf(buffer, "  adat user data: ");
 		if (buf.ext_sync.adat_user_data & ADAT_USER_DATA_NO_DATA)
 			snd_iprintf(buffer, "-\n");
 		else
 			snd_iprintf(buffer, "%x\n",
 				    buf.ext_sync.adat_user_data);
 	}
 }

 static void dice_create_proc(struct snd_dice *dice)
 {
 	struct snd_info_entry *entry;

 	if (!snd_card_proc_new(dice->card, "dice", &entry))
 		snd_info_set_text_ops(entry, dice, dice_proc_read);
 }

 #define OUI_WEISS		0x001c6a

 #define DICE_CATEGORY_ID	0x04
 #define WEISS_CATEGORY_ID	0x00

 static int dice_interface_check(struct fw_unit *unit)
 {
 	static const int min_values[10] = {
 		10, 0x64 / 4,
 		10, 0x18 / 4,
 		10, 0x18 / 4,
 		0, 0,
 		0, 0,
 	};
 	struct fw_device *device = fw_parent_device(unit);
 	struct fw_csr_iterator it;
 	int key, val, vendor = -1, model = -1, err;
 	unsigned int category, i;
 	__be32 *pointers, value;
 	__be32 tx_data[4];
 	__be32 version;

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

 	/*
 	 * Check that GUID and unit directory are constructed according to DICE
 	 * rules, i.e., that the specifier ID is the GUID's OUI, and that the
 	 * GUID chip ID consists of the 8-bit category ID, the 10-bit product
 	 * ID, and a 22-bit serial number.
 	 */
 	fw_csr_iterator_init(&it, unit->directory);
 	while (fw_csr_iterator_next(&it, &key, &val)) {
 		switch (key) {
 		case CSR_SPECIFIER_ID:
 			vendor = val;
 			break;
 		case CSR_MODEL:
 			model = val;
 			break;
 		}
 	}
 	if (vendor == OUI_WEISS)
 		category = WEISS_CATEGORY_ID;
 	else
 		category = DICE_CATEGORY_ID;
 	if (device->config_rom[3] != ((vendor << 8) | category) ||
 	    device->config_rom[4] >> 22 != model) {
 		err = -ENODEV;
 		goto end;
 	}

 	/*
 	 * 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(unit, TCODE_READ_BLOCK_REQUEST,
 				 DICE_PRIVATE_SPACE, pointers,
 				 sizeof(__be32) * ARRAY_SIZE(min_values), 0);
 	if (err < 0) {
 		err = -ENODEV;
 		goto end;
 	}
 	for (i = 0; i < ARRAY_SIZE(min_values); ++i) {
 		value = be32_to_cpu(pointers[i]);
 		if (value < min_values[i] || value >= 0x40000) {
 			err = -ENODEV;
 			goto end;
 		}
 	}

 	/* We support playback only. Let capture devices be handled by FFADO. */
 	err = snd_fw_transaction(unit, TCODE_READ_BLOCK_REQUEST,
 				 DICE_PRIVATE_SPACE +
 				 be32_to_cpu(pointers[2]) * 4,
 				 tx_data, sizeof(tx_data), 0);
 	if (err < 0 || (tx_data[0] && tx_data[3])) {
 		err = -ENODEV;
 		goto end;
 	}

 	/*
 	 * Check that the implemented DICE driver specification major version
 	 * number matches.
 	 */
 	err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST,
 				 DICE_PRIVATE_SPACE +
 				 be32_to_cpu(pointers[0]) * 4 + GLOBAL_VERSION,
 				 &version, 4, 0);
 	if (err < 0) {
 		err = -ENODEV;
 		goto end;
 	}
 	if ((version & cpu_to_be32(0xff000000)) != cpu_to_be32(0x01000000)) {
 		dev_err(&unit->device,
 			"unknown DICE version: 0x%08x\n", be32_to_cpu(version));
 		err = -ENODEV;
 		goto end;
 	}
 end:
 	return err;
 }

 static int highest_supported_mode_rate(struct snd_dice *dice,
 				       unsigned int mode, unsigned int *rate)
 {
 	unsigned int i, m;

 	for (i = ARRAY_SIZE(snd_dice_rates); i > 0; i--) {
 		*rate = snd_dice_rates[i - 1];
 		if (snd_dice_stream_get_rate_mode(dice, *rate, &m) < 0)
 			continue;
 		if (mode == m)
 			break;
 	}
 	if (i == 0)
 		return -EINVAL;

 	return 0;
 }

 static int dice_read_mode_params(struct snd_dice *dice, unsigned int mode)
 {
 	__be32 values[2];
 	unsigned int rate;
 	int err;

 	if (highest_supported_mode_rate(dice, mode, &rate) < 0) {
 		dice->rx_channels[mode] = 0;
 		dice->rx_midi_ports[mode] = 0;
 		return 0;
 	}

 	err = snd_dice_transaction_set_rate(dice, rate);
 	if (err < 0)
 		return err;

 	err = snd_dice_transaction_read_rx(dice, RX_NUMBER_AUDIO,
 					   values, sizeof(values));
 	if (err < 0)
 		return err;

 	dice->rx_channels[mode]   = be32_to_cpu(values[0]);
 	dice->rx_midi_ports[mode] = be32_to_cpu(values[1]);

 	return 0;
 }

 static int dice_read_params(struct snd_dice *dice)
 {
 	__be32 value;
 	int mode, err;

 	/* some very old firmwares don't tell about their clock support */
 	if (dice->clock_caps > 0) {
 		err = snd_dice_transaction_read_global(dice,
 						GLOBAL_CLOCK_CAPABILITIES,
 						&value, 4);
 		if (err < 0)
 			return err;
 		dice->clock_caps = be32_to_cpu(value);
 	} else {
 		/* this should be supported by any device */
 		dice->clock_caps = CLOCK_CAP_RATE_44100 |
 				   CLOCK_CAP_RATE_48000 |
 				   CLOCK_CAP_SOURCE_ARX1 |
 				   CLOCK_CAP_SOURCE_INTERNAL;
 	}

 	for (mode = 2; mode >= 0; --mode) {
 		err = dice_read_mode_params(dice, mode);
 		if (err < 0)
 			return err;
 	}

 	return 0;
 }

 static void dice_card_strings(struct snd_dice *dice)
 {
 	struct snd_card *card = dice->card;
 	struct fw_device *dev = fw_parent_device(dice->unit);
 	char vendor[32], model[32];
 	unsigned int i;
 	int err;

 	strcpy(card->driver, "DICE");

 	strcpy(card->shortname, "DICE");
 	BUILD_BUG_ON(NICK_NAME_SIZE < sizeof(card->shortname));
 	err = snd_dice_transaction_read_global(dice, GLOBAL_NICK_NAME,
 					       card->shortname,
 					       sizeof(card->shortname));
 	if (err >= 0) {
 		/* DICE strings are returned in "always-wrong" endianness */
 		BUILD_BUG_ON(sizeof(card->shortname) % 4 != 0);
 		for (i = 0; i < sizeof(card->shortname); i += 4)
 			swab32s((u32 *)&card->shortname[i]);
 		card->shortname[sizeof(card->shortname) - 1] = '\0';
 	}

 	strcpy(vendor, "?");
 	fw_csr_string(dev->config_rom + 5, CSR_VENDOR, vendor, sizeof(vendor));
 	strcpy(model, "?");
 	fw_csr_string(dice->unit->directory, CSR_MODEL, model, sizeof(model));
 	snprintf(card->longname, sizeof(card->longname),
 		 "%s %s (serial %u) at %s, S%d",
 		 vendor, model, dev->config_rom[4] & 0x3fffff,
 		 dev_name(&dice->unit->device), 100 << dev->max_speed);

 	strcpy(card->mixername, "DICE");
 }

 static void dice_card_free(struct snd_card *card)
 {
 	struct snd_dice *dice = card->private_data;

 	snd_dice_transaction_destroy(dice);
 	mutex_destroy(&dice->mutex);
 }

 static int dice_probe(struct fw_unit *unit, const struct ieee1394_device_id *id)
 {
 	struct snd_card *card;
 	struct snd_dice *dice;
 	int err;

 	err = dice_interface_check(unit);
 	if (err < 0)
 		goto end;

 	err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
 			   sizeof(*dice), &card);
 	if (err < 0)
 		goto end;

 	dice = card->private_data;
 	dice->card = card;
 	dice->unit = unit;
 	card->private_free = dice_card_free;

 	spin_lock_init(&dice->lock);
 	mutex_init(&dice->mutex);
 	init_completion(&dice->clock_accepted);
 	init_waitqueue_head(&dice->hwdep_wait);

 	err = snd_dice_transaction_init(dice);
 	if (err < 0)
 		goto error;

 	err = dice_read_params(dice);
 	if (err < 0)
 		goto error;

 	dice_card_strings(dice);

 	err = snd_dice_create_pcm(dice);
 	if (err < 0)
 		goto error;

 	err = snd_dice_create_hwdep(dice);
 	if (err < 0)
 		goto error;

 	dice_create_proc(dice);

 	err = snd_dice_stream_init(dice);
 	if (err < 0)
 		goto error;

 	err = snd_card_register(card);
 	if (err < 0) {
 		snd_dice_stream_destroy(dice);
 		goto error;
 	}

 	dev_set_drvdata(&unit->device, dice);
 end:
 	return err;
 error:
 	snd_card_free(card);
 	return err;
 }

 static void dice_remove(struct fw_unit *unit)
 {
 	struct snd_dice *dice = dev_get_drvdata(&unit->device);

 	snd_card_disconnect(dice->card);

 	mutex_lock(&dice->mutex);

 	snd_dice_stream_destroy(dice);

 	mutex_unlock(&dice->mutex);

 	snd_card_free_when_closed(dice->card);
 }

 static void dice_bus_reset(struct fw_unit *unit)
 {
 	struct snd_dice *dice = dev_get_drvdata(&unit->device);

 	/* The handler address register becomes initialized. */
 	snd_dice_transaction_reinit(dice);

 	mutex_lock(&dice->mutex);
 	snd_dice_stream_update(dice);
 	mutex_unlock(&dice->mutex);
 }

 #define DICE_INTERFACE	0x000001

 static const struct ieee1394_device_id dice_id_table[] = {
 	{
 		.match_flags = IEEE1394_MATCH_VERSION,
 		.version     = DICE_INTERFACE,
 	},
 	{ }
 };
 MODULE_DEVICE_TABLE(ieee1394, dice_id_table);

 static struct fw_driver dice_driver = {
 	.driver   = {
 		.owner	= THIS_MODULE,
 		.name	= KBUILD_MODNAME,
 		.bus	= &fw_bus_type,
 	},
 	.probe    = dice_probe,
 	.update   = dice_bus_reset,
 	.remove   = dice_remove,
 	.id_table = dice_id_table,
 };

 static int __init alsa_dice_init(void)
 {
 	return driver_register(&dice_driver.driver);
 }

 static void __exit alsa_dice_exit(void)
 {
 	driver_unregister(&dice_driver.driver);
 }

 module_init(alsa_dice_init);
 module_exit(alsa_dice_exit);
	/*
	* TC Applied Technologies Digital Interface Communications Engine driver
	*
	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	* Licensed under the terms of the GNU General Public License, version 2.
	*/

	#include "dice.h"

	MODULE_DESCRIPTION("DICE driver");
	MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
	MODULE_LICENSE("GPL v2");

	static int dice_proc_read_mem(struct snd_dice dice, void buffer,
	unsigned int offset_q, unsigned int quadlets)
	{
	unsigned int i;
	int err;

	err = snd_fw_transaction(dice->unit, TCODE_READ_BLOCK_REQUEST,
	DICE_PRIVATE_SPACE + 4 * offset_q,
	buffer, 4 * quadlets, 0);
	if (err < 0)
	return err;

	for (i = 0; i < quadlets; ++i)
	be32_to_cpus(&((u32 *)buffer)[i]);

	return 0;
	}

	static const char str_from_array(const char const strs[], unsigned int count,
	unsigned int i)
	{
	if (i < count)
	return strs[i];

	return "(unknown)";
	}

	static void dice_proc_fixup_string(char *s, unsigned int size)
	{
	unsigned int i;

	for (i = 0; i < size; i += 4)
	cpu_to_le32s((u32 *)(s + i));

	for (i = 0; i < size - 2; ++i) {
	if (s[i] == '\0')
	return;
	if (s[i] == '\\' && s[i + 1] == '\\') {
	s[i + 2] = '\0';
	return;
	}
	}
	s[size - 1] = '\0';
	}

	static void dice_proc_read(struct snd_info_entry *entry,
	struct snd_info_buffer *buffer)
	{
	static const char *const section_names[5] = {
	"global", "tx", "rx", "ext_sync", "unused2"
	};
	static const char *const clock_sources[] = {
	"aes1", "aes2", "aes3", "aes4", "aes", "adat", "tdif",
	"wc", "arx1", "arx2", "arx3", "arx4", "internal"
	};
	static const char *const rates[] = {
	"32000", "44100", "48000", "88200", "96000", "176400", "192000",
	"any low", "any mid", "any high", "none"
	};
	struct snd_dice *dice = entry->private_data;
	u32 sections[ARRAY_SIZE(section_names) * 2];
	struct {
	u32 number;
	u32 size;
	} tx_rx_header;
	union {
	struct {
	u32 owner_hi, owner_lo;
	u32 notification;
	char nick_name[NICK_NAME_SIZE];
	u32 clock_select;
	u32 enable;
	u32 status;
	u32 extended_status;
	u32 sample_rate;
	u32 version;
	u32 clock_caps;
	char clock_source_names[CLOCK_SOURCE_NAMES_SIZE];
	} global;
	struct {
	u32 iso;
	u32 number_audio;
	u32 number_midi;
	u32 speed;
	char names[TX_NAMES_SIZE];
	u32 ac3_caps;
	u32 ac3_enable;
	} tx;
	struct {
	u32 iso;
	u32 seq_start;
	u32 number_audio;
	u32 number_midi;
	char names[RX_NAMES_SIZE];
	u32 ac3_caps;
	u32 ac3_enable;
	} rx;
	struct {
	u32 clock_source;
	u32 locked;
	u32 rate;
	u32 adat_user_data;
	} ext_sync;
	} buf;
	unsigned int quadlets, stream, i;

	if (dice_proc_read_mem(dice, sections, 0, ARRAY_SIZE(sections)) < 0)
	return;
	snd_iprintf(buffer, "sections:\n");
	for (i = 0; i < ARRAY_SIZE(section_names); ++i)
	snd_iprintf(buffer, " %s: offset %u, size %u\n",
	section_names[i],
	sections[i * 2], sections[i * 2 + 1]);

	quadlets = min_t(u32, sections[1], sizeof(buf.global) / 4);
	if (dice_proc_read_mem(dice, &buf.global, sections[0], quadlets) < 0)
	return;
	snd_iprintf(buffer, "global:\n");
	snd_iprintf(buffer, " owner: %04x:%04x%08x\n",
	buf.global.owner_hi >> 16,
	buf.global.owner_hi & 0xffff, buf.global.owner_lo);
	snd_iprintf(buffer, " notification: %08x\n", buf.global.notification);
	dice_proc_fixup_string(buf.global.nick_name, NICK_NAME_SIZE);
	snd_iprintf(buffer, " nick name: %s\n", buf.global.nick_name);
	snd_iprintf(buffer, " clock select: %s %s\n",
	str_from_array(clock_sources, ARRAY_SIZE(clock_sources),
	buf.global.clock_select & CLOCK_SOURCE_MASK),
	str_from_array(rates, ARRAY_SIZE(rates),
	(buf.global.clock_select & CLOCK_RATE_MASK)
	>> CLOCK_RATE_SHIFT));
	snd_iprintf(buffer, " enable: %u\n", buf.global.enable);
	snd_iprintf(buffer, " status: %slocked %s\n",
	buf.global.status & STATUS_SOURCE_LOCKED ? "" : "un",
	str_from_array(rates, ARRAY_SIZE(rates),
	(buf.global.status &
	STATUS_NOMINAL_RATE_MASK)
	>> CLOCK_RATE_SHIFT));
	snd_iprintf(buffer, " ext status: %08x\n", buf.global.extended_status);
	snd_iprintf(buffer, " sample rate: %u\n", buf.global.sample_rate);
	snd_iprintf(buffer, " version: %u.%u.%u.%u\n",
	(buf.global.version >> 24) & 0xff,
	(buf.global.version >> 16) & 0xff,
	(buf.global.version >> 8) & 0xff,
	(buf.global.version >> 0) & 0xff);
	if (quadlets >= 90) {
	snd_iprintf(buffer, " clock caps:");
	for (i = 0; i <= 6; ++i)
	if (buf.global.clock_caps & (1 << i))
	snd_iprintf(buffer, " %s", rates[i]);
	for (i = 0; i <= 12; ++i)
	if (buf.global.clock_caps & (1 << (16 + i)))
	snd_iprintf(buffer, " %s", clock_sources[i]);
	snd_iprintf(buffer, "\n");
	dice_proc_fixup_string(buf.global.clock_source_names,
	CLOCK_SOURCE_NAMES_SIZE);
	snd_iprintf(buffer, " clock source names: %s\n",
	buf.global.clock_source_names);
	}

	if (dice_proc_read_mem(dice, &tx_rx_header, sections[2], 2) < 0)
	return;
	quadlets = min_t(u32, tx_rx_header.size, sizeof(buf.tx) / 4);
	for (stream = 0; stream < tx_rx_header.number; ++stream) {
	if (dice_proc_read_mem(dice, &buf.tx, sections[2] + 2 +
	stream * tx_rx_header.size,
	quadlets) < 0)
	break;
	snd_iprintf(buffer, "tx %u:\n", stream);
	snd_iprintf(buffer, " iso channel: %d\n", (int)buf.tx.iso);
	snd_iprintf(buffer, " audio channels: %u\n",
	buf.tx.number_audio);
	snd_iprintf(buffer, " midi ports: %u\n", buf.tx.number_midi);
	snd_iprintf(buffer, " speed: S%u\n", 100u << buf.tx.speed);
	if (quadlets >= 68) {
	dice_proc_fixup_string(buf.tx.names, TX_NAMES_SIZE);
	snd_iprintf(buffer, " names: %s\n", buf.tx.names);
	}
	if (quadlets >= 70) {
	snd_iprintf(buffer, " ac3 caps: %08x\n",
	buf.tx.ac3_caps);
	snd_iprintf(buffer, " ac3 enable: %08x\n",
	buf.tx.ac3_enable);
	}
	}

	if (dice_proc_read_mem(dice, &tx_rx_header, sections[4], 2) < 0)
	return;
	quadlets = min_t(u32, tx_rx_header.size, sizeof(buf.rx) / 4);
	for (stream = 0; stream < tx_rx_header.number; ++stream) {
	if (dice_proc_read_mem(dice, &buf.rx, sections[4] + 2 +
	stream * tx_rx_header.size,
	quadlets) < 0)
	break;
	snd_iprintf(buffer, "rx %u:\n", stream);
	snd_iprintf(buffer, " iso channel: %d\n", (int)buf.rx.iso);
	snd_iprintf(buffer, " sequence start: %u\n", buf.rx.seq_start);
	snd_iprintf(buffer, " audio channels: %u\n",
	buf.rx.number_audio);
	snd_iprintf(buffer, " midi ports: %u\n", buf.rx.number_midi);
	if (quadlets >= 68) {
	dice_proc_fixup_string(buf.rx.names, RX_NAMES_SIZE);
	snd_iprintf(buffer, " names: %s\n", buf.rx.names);
	}
	if (quadlets >= 70) {
	snd_iprintf(buffer, " ac3 caps: %08x\n",
	buf.rx.ac3_caps);
	snd_iprintf(buffer, " ac3 enable: %08x\n",
	buf.rx.ac3_enable);
	}
	}

	quadlets = min_t(u32, sections[7], sizeof(buf.ext_sync) / 4);
	if (quadlets >= 4) {
	if (dice_proc_read_mem(dice, &buf.ext_sync,
	sections[6], 4) < 0)
	return;
	snd_iprintf(buffer, "ext status:\n");
	snd_iprintf(buffer, " clock source: %s\n",
	str_from_array(clock_sources,
	ARRAY_SIZE(clock_sources),
	buf.ext_sync.clock_source));
	snd_iprintf(buffer, " locked: %u\n", buf.ext_sync.locked);
	snd_iprintf(buffer, " rate: %s\n",
	str_from_array(rates, ARRAY_SIZE(rates),
	buf.ext_sync.rate));
	snd_iprintf(buffer, " adat user data: ");
	if (buf.ext_sync.adat_user_data & ADAT_USER_DATA_NO_DATA)
	snd_iprintf(buffer, "-\n");
	else
	snd_iprintf(buffer, "%x\n",
	buf.ext_sync.adat_user_data);
	}
	}

	static void dice_create_proc(struct snd_dice *dice)
	{
	struct snd_info_entry *entry;

	if (!snd_card_proc_new(dice->card, "dice", &entry))
	snd_info_set_text_ops(entry, dice, dice_proc_read);
	}

	#define OUI_WEISS 0x001c6a

	#define DICE_CATEGORY_ID 0x04
	#define WEISS_CATEGORY_ID 0x00

	static int dice_interface_check(struct fw_unit *unit)
	{
	static const int min_values[10] = {
	10, 0x64 / 4,
	10, 0x18 / 4,
	10, 0x18 / 4,
	0, 0,
	0, 0,
	};
	struct fw_device *device = fw_parent_device(unit);
	struct fw_csr_iterator it;
	int key, val, vendor = -1, model = -1, err;
	unsigned int category, i;
	__be32 *pointers, value;
	__be32 tx_data[4];
	__be32 version;

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

	/*
	* Check that GUID and unit directory are constructed according to DICE
	* rules, i.e., that the specifier ID is the GUID's OUI, and that the
	* GUID chip ID consists of the 8-bit category ID, the 10-bit product
	* ID, and a 22-bit serial number.
	*/
	fw_csr_iterator_init(&it, unit->directory);
	while (fw_csr_iterator_next(&it, &key, &val)) {
	switch (key) {
	case CSR_SPECIFIER_ID:
	vendor = val;
	break;
	case CSR_MODEL:
	model = val;
	break;
	}
	}
	if (vendor == OUI_WEISS)
	category = WEISS_CATEGORY_ID;
	else
	category = DICE_CATEGORY_ID;
	if (device->config_rom[3] != ((vendor << 8) \| category) \|\|
	device->config_rom[4] >> 22 != model) {
	err = -ENODEV;
	goto end;
	}

	/*
	* 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(unit, TCODE_READ_BLOCK_REQUEST,
	DICE_PRIVATE_SPACE, pointers,
	sizeof(__be32) * ARRAY_SIZE(min_values), 0);
	if (err < 0) {
	err = -ENODEV;
	goto end;
	}
	for (i = 0; i < ARRAY_SIZE(min_values); ++i) {
	value = be32_to_cpu(pointers[i]);
	if (value < min_values[i] \|\| value >= 0x40000) {
	err = -ENODEV;
	goto end;
	}
	}

	/* We support playback only. Let capture devices be handled by FFADO. */
	err = snd_fw_transaction(unit, TCODE_READ_BLOCK_REQUEST,
	DICE_PRIVATE_SPACE +
	be32_to_cpu(pointers[2]) * 4,
	tx_data, sizeof(tx_data), 0);
	if (err < 0 \|\| (tx_data[0] && tx_data[3])) {
	err = -ENODEV;
	goto end;
	}

	/*
	* Check that the implemented DICE driver specification major version
	* number matches.
	*/
	err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST,
	DICE_PRIVATE_SPACE +
	be32_to_cpu(pointers[0]) * 4 + GLOBAL_VERSION,
	&version, 4, 0);
	if (err < 0) {
	err = -ENODEV;
	goto end;
	}
	if ((version & cpu_to_be32(0xff000000)) != cpu_to_be32(0x01000000)) {
	dev_err(&unit->device,
	"unknown DICE version: 0x%08x\n", be32_to_cpu(version));
	err = -ENODEV;
	goto end;
	}
	end:
	return err;
	}

	static int highest_supported_mode_rate(struct snd_dice *dice,
	unsigned int mode, unsigned int *rate)
	{
	unsigned int i, m;

	for (i = ARRAY_SIZE(snd_dice_rates); i > 0; i--) {
	*rate = snd_dice_rates[i - 1];
	if (snd_dice_stream_get_rate_mode(dice, *rate, &m) < 0)
	continue;
	if (mode == m)
	break;
	}
	if (i == 0)
	return -EINVAL;

	return 0;
	}

	static int dice_read_mode_params(struct snd_dice *dice, unsigned int mode)
	{
	__be32 values[2];
	unsigned int rate;
	int err;

	if (highest_supported_mode_rate(dice, mode, &rate) < 0) {
	dice->rx_channels[mode] = 0;
	dice->rx_midi_ports[mode] = 0;
	return 0;
	}

	err = snd_dice_transaction_set_rate(dice, rate);
	if (err < 0)
	return err;

	err = snd_dice_transaction_read_rx(dice, RX_NUMBER_AUDIO,
	values, sizeof(values));
	if (err < 0)
	return err;

	dice->rx_channels[mode] = be32_to_cpu(values[0]);
	dice->rx_midi_ports[mode] = be32_to_cpu(values[1]);

	return 0;
	}

	static int dice_read_params(struct snd_dice *dice)
	{
	__be32 value;
	int mode, err;

	/* some very old firmwares don't tell about their clock support */
	if (dice->clock_caps > 0) {
	err = snd_dice_transaction_read_global(dice,
	GLOBAL_CLOCK_CAPABILITIES,
	&value, 4);
	if (err < 0)
	return err;
	dice->clock_caps = be32_to_cpu(value);
	} else {
	/* this should be supported by any device */
	dice->clock_caps = CLOCK_CAP_RATE_44100 \|
	CLOCK_CAP_RATE_48000 \|
	CLOCK_CAP_SOURCE_ARX1 \|
	CLOCK_CAP_SOURCE_INTERNAL;
	}

	for (mode = 2; mode >= 0; --mode) {
	err = dice_read_mode_params(dice, mode);
	if (err < 0)
	return err;
	}

	return 0;
	}

	static void dice_card_strings(struct snd_dice *dice)
	{
	struct snd_card *card = dice->card;
	struct fw_device *dev = fw_parent_device(dice->unit);
	char vendor[32], model[32];
	unsigned int i;
	int err;

	strcpy(card->driver, "DICE");

	strcpy(card->shortname, "DICE");
	BUILD_BUG_ON(NICK_NAME_SIZE < sizeof(card->shortname));
	err = snd_dice_transaction_read_global(dice, GLOBAL_NICK_NAME,
	card->shortname,
	sizeof(card->shortname));
	if (err >= 0) {
	/* DICE strings are returned in "always-wrong" endianness */
	BUILD_BUG_ON(sizeof(card->shortname) % 4 != 0);
	for (i = 0; i < sizeof(card->shortname); i += 4)
	swab32s((u32 *)&card->shortname[i]);
	card->shortname[sizeof(card->shortname) - 1] = '\0';
	}

	strcpy(vendor, "?");
	fw_csr_string(dev->config_rom + 5, CSR_VENDOR, vendor, sizeof(vendor));
	strcpy(model, "?");
	fw_csr_string(dice->unit->directory, CSR_MODEL, model, sizeof(model));
	snprintf(card->longname, sizeof(card->longname),
	"%s %s (serial %u) at %s, S%d",
	vendor, model, dev->config_rom[4] & 0x3fffff,
	dev_name(&dice->unit->device), 100 << dev->max_speed);

	strcpy(card->mixername, "DICE");
	}

	static void dice_card_free(struct snd_card *card)
	{
	struct snd_dice *dice = card->private_data;

	snd_dice_transaction_destroy(dice);
	mutex_destroy(&dice->mutex);
	}

	static int dice_probe(struct fw_unit unit, const struct ieee1394_device_id id)
	{
	struct snd_card *card;
	struct snd_dice *dice;
	int err;

	err = dice_interface_check(unit);
	if (err < 0)
	goto end;

	err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
	sizeof(*dice), &card);
	if (err < 0)
	goto end;

	dice = card->private_data;
	dice->card = card;
	dice->unit = unit;
	card->private_free = dice_card_free;

	spin_lock_init(&dice->lock);
	mutex_init(&dice->mutex);
	init_completion(&dice->clock_accepted);
	init_waitqueue_head(&dice->hwdep_wait);

	err = snd_dice_transaction_init(dice);
	if (err < 0)
	goto error;

	err = dice_read_params(dice);
	if (err < 0)
	goto error;

	dice_card_strings(dice);

	err = snd_dice_create_pcm(dice);
	if (err < 0)
	goto error;

	err = snd_dice_create_hwdep(dice);
	if (err < 0)
	goto error;

	dice_create_proc(dice);

	err = snd_dice_stream_init(dice);
	if (err < 0)
	goto error;

	err = snd_card_register(card);
	if (err < 0) {
	snd_dice_stream_destroy(dice);
	goto error;
	}

	dev_set_drvdata(&unit->device, dice);
	end:
	return err;
	error:
	snd_card_free(card);
	return err;
	}

	static void dice_remove(struct fw_unit *unit)
	{
	struct snd_dice *dice = dev_get_drvdata(&unit->device);

	snd_card_disconnect(dice->card);

	mutex_lock(&dice->mutex);

	snd_dice_stream_destroy(dice);

	mutex_unlock(&dice->mutex);

	snd_card_free_when_closed(dice->card);
	}

	static void dice_bus_reset(struct fw_unit *unit)
	{
	struct snd_dice *dice = dev_get_drvdata(&unit->device);

	/* The handler address register becomes initialized. */
	snd_dice_transaction_reinit(dice);

	mutex_lock(&dice->mutex);
	snd_dice_stream_update(dice);
	mutex_unlock(&dice->mutex);
	}

	#define DICE_INTERFACE 0x000001

	static const struct ieee1394_device_id dice_id_table[] = {
	{
	.match_flags = IEEE1394_MATCH_VERSION,
	.version = DICE_INTERFACE,
	},
	{ }
	};
	MODULE_DEVICE_TABLE(ieee1394, dice_id_table);

	static struct fw_driver dice_driver = {
	.driver = {
	.owner = THIS_MODULE,
	.name = KBUILD_MODNAME,
	.bus = &fw_bus_type,
	},
	.probe = dice_probe,
	.update = dice_bus_reset,
	.remove = dice_remove,
	.id_table = dice_id_table,
	};

	static int __init alsa_dice_init(void)
	{
	return driver_register(&dice_driver.driver);
	}

	static void __exit alsa_dice_exit(void)
	{
	driver_unregister(&dice_driver.driver);
	}

	module_init(alsa_dice_init);
	module_exit(alsa_dice_exit);