[deliverable/linux.git] / sound / firewire / oxfw / oxfw.c

/*
 * oxfw.c - a part of driver for OXFW970/971 based devices
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include "oxfw.h"

#define OXFORD_FIRMWARE_ID_ADDRESS	(CSR_REGISTER_BASE + 0x50000)
/* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */

#define OXFORD_HARDWARE_ID_ADDRESS	(CSR_REGISTER_BASE + 0x90020)
#define OXFORD_HARDWARE_ID_OXFW970	0x39443841
#define OXFORD_HARDWARE_ID_OXFW971	0x39373100

#define VENDOR_LOUD		0x000ff2
#define VENDOR_GRIFFIN		0x001292
#define VENDOR_BEHRINGER	0x001564
#define VENDOR_LACIE		0x00d04b
#define VENDOR_TASCAM		0x00022e
#define OUI_STANTON		0x001260

#define MODEL_SATELLITE		0x00200f

#define SPECIFIER_1394TA	0x00a02d
#define VERSION_AVC		0x010001

MODULE_DESCRIPTION("Oxford Semiconductor FW970/971 driver");
MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("snd-firewire-speakers");
MODULE_ALIAS("snd-scs1x");

struct compat_info {
	const char *driver_name;
	const char *vendor_name;
	const char *model_name;
};

static bool detect_loud_models(struct fw_unit *unit)
{
	const char *const models[] = {
		"Onyxi",
		"Onyx-i",
		"d.Pro",
		"Mackie Onyx Satellite",
		"Tapco LINK.firewire 4x6",
		"U.420"};
	char model[32];
	unsigned int i;
	int err;

	err = fw_csr_string(unit->directory, CSR_MODEL,
			    model, sizeof(model));
	if (err < 0)
		return false;

	for (i = 0; i < ARRAY_SIZE(models); i++) {
		if (strcmp(models[i], model) == 0)
			break;
	}

	return (i < ARRAY_SIZE(models));
}

static int name_card(struct snd_oxfw *oxfw)
{
	struct fw_device *fw_dev = fw_parent_device(oxfw->unit);
	const struct compat_info *info;
	char vendor[24];
	char model[32];
	const char *d, *v, *m;
	u32 firmware;
	int err;

	/* get vendor name from root directory */
	err = fw_csr_string(fw_dev->config_rom + 5, CSR_VENDOR,
			    vendor, sizeof(vendor));
	if (err < 0)
		goto end;

	/* get model name from unit directory */
	err = fw_csr_string(oxfw->unit->directory, CSR_MODEL,
			    model, sizeof(model));
	if (err < 0)
		goto end;

	err = snd_fw_transaction(oxfw->unit, TCODE_READ_QUADLET_REQUEST,
				 OXFORD_FIRMWARE_ID_ADDRESS, &firmware, 4, 0);
	if (err < 0)
		goto end;
	be32_to_cpus(&firmware);

	/* to apply card definitions */
	if (oxfw->entry->vendor_id == VENDOR_GRIFFIN ||
	    oxfw->entry->vendor_id == VENDOR_LACIE) {
		info = (const struct compat_info *)oxfw->entry->driver_data;
		d = info->driver_name;
		v = info->vendor_name;
		m = info->model_name;
	} else {
		d = "OXFW";
		v = vendor;
		m = model;
	}

	strcpy(oxfw->card->driver, d);
	strcpy(oxfw->card->mixername, m);
	strcpy(oxfw->card->shortname, m);

	snprintf(oxfw->card->longname, sizeof(oxfw->card->longname),
		 "%s %s (OXFW%x %04x), GUID %08x%08x at %s, S%d",
		 v, m, firmware >> 20, firmware & 0xffff,
		 fw_dev->config_rom[3], fw_dev->config_rom[4],
		 dev_name(&oxfw->unit->device), 100 << fw_dev->max_speed);
end:
	return err;
}

/*
 * This module releases the FireWire unit data after all ALSA character devices
 * are released by applications. This is for releasing stream data or finishing
 * transactions safely. Thus at returning from .remove(), this module still keep
 * references for the unit.
 */
static void oxfw_card_free(struct snd_card *card)
{
	struct snd_oxfw *oxfw = card->private_data;
	unsigned int i;

	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
	if (oxfw->has_output)
		snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);

	fw_unit_put(oxfw->unit);

	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
		kfree(oxfw->tx_stream_formats[i]);
		kfree(oxfw->rx_stream_formats[i]);
	}

	kfree(oxfw->spec);
	mutex_destroy(&oxfw->mutex);
}

static int detect_quirks(struct snd_oxfw *oxfw)
{
	struct fw_device *fw_dev = fw_parent_device(oxfw->unit);
	struct fw_csr_iterator it;
	int key, val;
	int vendor, model;

	/*
	 * Add ALSA control elements for two models to keep compatibility to
	 * old firewire-speaker module.
	 */
	if (oxfw->entry->vendor_id == VENDOR_GRIFFIN)
		return snd_oxfw_add_spkr(oxfw, false);
	if (oxfw->entry->vendor_id == VENDOR_LACIE)
		return snd_oxfw_add_spkr(oxfw, true);

	/*
	 * Stanton models supports asynchronous transactions for unique MIDI
	 * messages.
	 */
	if (oxfw->entry->vendor_id == OUI_STANTON) {
		/* No physical MIDI ports. */
		oxfw->midi_input_ports = 0;
		oxfw->midi_output_ports = 0;

		/* Output stream exists but no data channels are useful. */
		oxfw->has_output = false;

		return snd_oxfw_scs1x_add(oxfw);
	}

	/*
	 * TASCAM FireOne has physical control and requires a pair of additional
	 * MIDI ports.
	 */
	if (oxfw->entry->vendor_id == VENDOR_TASCAM) {
		oxfw->midi_input_ports++;
		oxfw->midi_output_ports++;
		return 0;
	}

	/* Seek from Root Directory of Config ROM. */
	vendor = model = 0;
	fw_csr_iterator_init(&it, fw_dev->config_rom + 5);
	while (fw_csr_iterator_next(&it, &key, &val)) {
		if (key == CSR_VENDOR)
			vendor = val;
		else if (key == CSR_MODEL)
			model = val;
	}

	/*
	 * Mackie Onyx Satellite with base station has a quirk to report a wrong
	 * value in 'dbs' field of CIP header against its format information.
	 */
	if (vendor == VENDOR_LOUD && model == MODEL_SATELLITE)
		oxfw->wrong_dbs = true;

	return 0;
}

static int oxfw_probe(struct fw_unit *unit,
		      const struct ieee1394_device_id *entry)
{
	struct snd_card *card;
	struct snd_oxfw *oxfw;
	int err;

	if (entry->vendor_id == VENDOR_LOUD && !detect_loud_models(unit))
		return -ENODEV;

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

	card->private_free = oxfw_card_free;
	oxfw = card->private_data;
	oxfw->card = card;
	mutex_init(&oxfw->mutex);
	oxfw->unit = fw_unit_get(unit);
	oxfw->entry = entry;
	spin_lock_init(&oxfw->lock);
	init_waitqueue_head(&oxfw->hwdep_wait);

	err = snd_oxfw_stream_discover(oxfw);
	if (err < 0)
		goto error;

	err = name_card(oxfw);
	if (err < 0)
		goto error;

	err = detect_quirks(oxfw);
	if (err < 0)
		goto error;

	err = snd_oxfw_create_pcm(oxfw);
	if (err < 0)
		goto error;

	snd_oxfw_proc_init(oxfw);

	err = snd_oxfw_create_midi(oxfw);
	if (err < 0)
		goto error;

	err = snd_oxfw_create_hwdep(oxfw);
	if (err < 0)
		goto error;

	err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->rx_stream);
	if (err < 0)
		goto error;
	if (oxfw->has_output) {
		err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->tx_stream);
		if (err < 0)
			goto error;
	}

	err = snd_card_register(card);
	if (err < 0) {
		snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
		if (oxfw->has_output)
			snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
		goto error;
	}
	dev_set_drvdata(&unit->device, oxfw);

	return 0;
error:
	snd_card_free(card);
	return err;
}

static void oxfw_bus_reset(struct fw_unit *unit)
{
	struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);

	fcp_bus_reset(oxfw->unit);

	mutex_lock(&oxfw->mutex);

	snd_oxfw_stream_update_simplex(oxfw, &oxfw->rx_stream);
	if (oxfw->has_output)
		snd_oxfw_stream_update_simplex(oxfw, &oxfw->tx_stream);

	mutex_unlock(&oxfw->mutex);

	if (oxfw->entry->vendor_id == OUI_STANTON)
		snd_oxfw_scs1x_update(oxfw);
}

static void oxfw_remove(struct fw_unit *unit)
{
	struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);

	/* No need to wait for releasing card object in this context. */
	snd_card_free_when_closed(oxfw->card);
}

static const struct compat_info griffin_firewave = {
	.driver_name = "FireWave",
	.vendor_name = "Griffin",
	.model_name = "FireWave",
};

static const struct compat_info lacie_speakers = {
	.driver_name = "FWSpeakers",
	.vendor_name = "LaCie",
	.model_name = "FireWire Speakers",
};

static const struct ieee1394_device_id oxfw_id_table[] = {
	{
		.match_flags  = IEEE1394_MATCH_VENDOR_ID |
				IEEE1394_MATCH_MODEL_ID |
				IEEE1394_MATCH_SPECIFIER_ID |
				IEEE1394_MATCH_VERSION,
		.vendor_id    = VENDOR_GRIFFIN,
		.model_id     = 0x00f970,
		.specifier_id = SPECIFIER_1394TA,
		.version      = VERSION_AVC,
		.driver_data  = (kernel_ulong_t)&griffin_firewave,
	},
	{
		.match_flags  = IEEE1394_MATCH_VENDOR_ID |
				IEEE1394_MATCH_MODEL_ID |
				IEEE1394_MATCH_SPECIFIER_ID |
				IEEE1394_MATCH_VERSION,
		.vendor_id    = VENDOR_LACIE,
		.model_id     = 0x00f970,
		.specifier_id = SPECIFIER_1394TA,
		.version      = VERSION_AVC,
		.driver_data  = (kernel_ulong_t)&lacie_speakers,
	},
	/* Behringer,F-Control Audio 202 */
	{
		.match_flags	= IEEE1394_MATCH_VENDOR_ID |
				  IEEE1394_MATCH_MODEL_ID,
		.vendor_id	= VENDOR_BEHRINGER,
		.model_id	= 0x00fc22,
	},
	/*
	 * Any Mackie(Loud) models (name string/model id):
	 *  Onyx-i series (former models):	0x081216
	 *  Mackie Onyx Satellite:		0x00200f
	 *  Tapco LINK.firewire 4x6:		0x000460
	 *  d.2 pro:				Unknown
	 *  d.4 pro:				Unknown
	 *  U.420:				Unknown
	 *  U.420d:				Unknown
	 */
	{
		.match_flags	= IEEE1394_MATCH_VENDOR_ID |
				  IEEE1394_MATCH_SPECIFIER_ID |
				  IEEE1394_MATCH_VERSION,
		.vendor_id	= VENDOR_LOUD,
		.specifier_id	= SPECIFIER_1394TA,
		.version	= VERSION_AVC,
	},
	/* TASCAM, FireOne */
	{
		.match_flags	= IEEE1394_MATCH_VENDOR_ID |
				  IEEE1394_MATCH_MODEL_ID,
		.vendor_id	= VENDOR_TASCAM,
		.model_id	= 0x800007,
	},
	/* Stanton, Stanton Controllers & Systems 1 Mixer (SCS.1m) */
	{
		.match_flags	= IEEE1394_MATCH_VENDOR_ID |
				  IEEE1394_MATCH_MODEL_ID,
		.vendor_id	= OUI_STANTON,
		.model_id	= 0x001000,
	},
	/* Stanton, Stanton Controllers & Systems 1 Deck (SCS.1d) */
	{
		.match_flags	= IEEE1394_MATCH_VENDOR_ID |
				  IEEE1394_MATCH_MODEL_ID,
		.vendor_id	= OUI_STANTON,
		.model_id	= 0x002000,
	},
	{ }
};
MODULE_DEVICE_TABLE(ieee1394, oxfw_id_table);

static struct fw_driver oxfw_driver = {
	.driver   = {
		.owner	= THIS_MODULE,
		.name	= KBUILD_MODNAME,
		.bus	= &fw_bus_type,
	},
	.probe    = oxfw_probe,
	.update   = oxfw_bus_reset,
	.remove   = oxfw_remove,
	.id_table = oxfw_id_table,
};

static int __init snd_oxfw_init(void)
{
	return driver_register(&oxfw_driver.driver);
}

static void __exit snd_oxfw_exit(void)
{
	driver_unregister(&oxfw_driver.driver);
}

module_init(snd_oxfw_init);
module_exit(snd_oxfw_exit);
Commit	Line	Data
31ef9134	1	/*
8832c5a7	2	* oxfw.c - a part of driver for OXFW970/971 based devices
31ef9134 CL	3	*
	4	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	5	* Licensed under the terms of the GNU General Public License, version 2.
	6	*/
	7
e2786ca6	8	#include "oxfw.h"
31ef9134 CL	9
	10	#define OXFORD_FIRMWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x50000)
	11	/* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */
	12
	13	#define OXFORD_HARDWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x90020)
	14	#define OXFORD_HARDWARE_ID_OXFW970 0x39443841
	15	#define OXFORD_HARDWARE_ID_OXFW971 0x39373100
	16
ec4dba50	17	#define VENDOR_LOUD 0x000ff2
31ef9134	18	#define VENDOR_GRIFFIN 0x001292
ec4dba50	19	#define VENDOR_BEHRINGER 0x001564
31ef9134	20	#define VENDOR_LACIE 0x00d04b
759a2f40	21	#define VENDOR_TASCAM 0x00022e
9e2004f9	22	#define OUI_STANTON 0x001260
31ef9134	23
13f3a46d TS	24	#define MODEL_SATELLITE 0x00200f
13f3a46d TS	25
31ef9134 CL	26	#define SPECIFIER_1394TA 0x00a02d
	27	#define VERSION_AVC 0x010001
	28
8832c5a7	29	MODULE_DESCRIPTION("Oxford Semiconductor FW970/971 driver");
31ef9134 CL	30	MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
31ef9134 CL	31	MODULE_LICENSE("GPL v2");
8832c5a7	32	MODULE_ALIAS("snd-firewire-speakers");
9e2004f9	33	MODULE_ALIAS("snd-scs1x");
31ef9134	34
d6ce6bbd TS	35	struct compat_info {
	36	const char *driver_name;
	37	const char *vendor_name;
	38	const char *model_name;
	39	};
	40
ec4dba50 TS	41	static bool detect_loud_models(struct fw_unit *unit)
	42	{
	43	const char *const models[] = {
	44	"Onyxi",
	45	"Onyx-i",
	46	"d.Pro",
	47	"Mackie Onyx Satellite",
	48	"Tapco LINK.firewire 4x6",
	49	"U.420"};
	50	char model[32];
	51	unsigned int i;
	52	int err;
	53
	54	err = fw_csr_string(unit->directory, CSR_MODEL,
	55	model, sizeof(model));
	56	if (err < 0)
0d3aba30	57	return false;
ec4dba50 TS	58
	59	for (i = 0; i < ARRAY_SIZE(models); i++) {
	60	if (strcmp(models[i], model) == 0)
	61	break;
	62	}
	63
	64	return (i < ARRAY_SIZE(models));
	65	}
	66
fec7b753	67	static int name_card(struct snd_oxfw *oxfw)
31ef9134	68	{
fec7b753	69	struct fw_device *fw_dev = fw_parent_device(oxfw->unit);
d6ce6bbd	70	const struct compat_info *info;
ec4dba50 TS	71	char vendor[24];
ec4dba50 TS	72	char model[32];
fec7b753 TS	73	const char d, v, *m;
fec7b753 TS	74	u32 firmware;
31ef9134 CL	75	int err;
31ef9134 CL	76
ec4dba50 TS	77	/* get vendor name from root directory */
	78	err = fw_csr_string(fw_dev->config_rom + 5, CSR_VENDOR,
	79	vendor, sizeof(vendor));
	80	if (err < 0)
	81	goto end;
	82
	83	/* get model name from unit directory */
	84	err = fw_csr_string(oxfw->unit->directory, CSR_MODEL,
	85	model, sizeof(model));
	86	if (err < 0)
	87	goto end;
	88
fec7b753 TS	89	err = snd_fw_transaction(oxfw->unit, TCODE_READ_QUADLET_REQUEST,
	90	OXFORD_FIRMWARE_ID_ADDRESS, &firmware, 4, 0);
	91	if (err < 0)
	92	goto end;
	93	be32_to_cpus(&firmware);
	94
ec4dba50	95	/* to apply card definitions */
27e66635 TS	96	if (oxfw->entry->vendor_id == VENDOR_GRIFFIN \|\|
27e66635 TS	97	oxfw->entry->vendor_id == VENDOR_LACIE) {
d6ce6bbd	98	info = (const struct compat_info *)oxfw->entry->driver_data;
27e66635 TS	99	d = info->driver_name;
	100	v = info->vendor_name;
	101	m = info->model_name;
ec4dba50 TS	102	} else {
	103	d = "OXFW";
	104	v = vendor;
	105	m = model;
	106	}
fec7b753 TS	107
	108	strcpy(oxfw->card->driver, d);
	109	strcpy(oxfw->card->mixername, m);
	110	strcpy(oxfw->card->shortname, m);
	111
	112	snprintf(oxfw->card->longname, sizeof(oxfw->card->longname),
	113	"%s %s (OXFW%x %04x), GUID %08x%08x at %s, S%d",
	114	v, m, firmware >> 20, firmware & 0xffff,
	115	fw_dev->config_rom[3], fw_dev->config_rom[4],
	116	dev_name(&oxfw->unit->device), 100 << fw_dev->max_speed);
	117	end:
	118	return err;
31ef9134 CL	119	}
31ef9134 CL	120
12ed7192 TS	121	/*
	122	* This module releases the FireWire unit data after all ALSA character devices
	123	* are released by applications. This is for releasing stream data or finishing
	124	* transactions safely. Thus at returning from .remove(), this module still keep
	125	* references for the unit.
	126	*/
8832c5a7	127	static void oxfw_card_free(struct snd_card *card)
31ef9134	128	{
8832c5a7	129	struct snd_oxfw *oxfw = card->private_data;
5cd1d3f4 TS	130	unsigned int i;
5cd1d3f4 TS	131
dec84316 TS	132	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
	133	if (oxfw->has_output)
	134	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
	135
12ed7192 TS	136	fw_unit_put(oxfw->unit);
12ed7192 TS	137
b0ac0009 TS	138	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
b0ac0009 TS	139	kfree(oxfw->tx_stream_formats[i]);
5cd1d3f4	140	kfree(oxfw->rx_stream_formats[i]);
b0ac0009	141	}
31ef9134	142
c582cc66	143	kfree(oxfw->spec);
8832c5a7	144	mutex_destroy(&oxfw->mutex);
31ef9134 CL	145	}
31ef9134 CL	146
5ce8cc48	147	static int detect_quirks(struct snd_oxfw *oxfw)
13f3a46d TS	148	{
	149	struct fw_device *fw_dev = fw_parent_device(oxfw->unit);
	150	struct fw_csr_iterator it;
	151	int key, val;
	152	int vendor, model;
	153
5ce8cc48 TS	154	/*
	155	* Add ALSA control elements for two models to keep compatibility to
	156	* old firewire-speaker module.
	157	*/
3e2f4570 TS	158	if (oxfw->entry->vendor_id == VENDOR_GRIFFIN)
	159	return snd_oxfw_add_spkr(oxfw, false);
	160	if (oxfw->entry->vendor_id == VENDOR_LACIE)
	161	return snd_oxfw_add_spkr(oxfw, true);
5ce8cc48	162
9e2004f9 TS	163	/*
	164	* Stanton models supports asynchronous transactions for unique MIDI
	165	* messages.
	166	*/
de5126cc TS	167	if (oxfw->entry->vendor_id == OUI_STANTON) {
	168	/* No physical MIDI ports. */
	169	oxfw->midi_input_ports = 0;
	170	oxfw->midi_output_ports = 0;
	171
	172	/* Output stream exists but no data channels are useful. */
	173	oxfw->has_output = false;
	174
9e2004f9	175	return snd_oxfw_scs1x_add(oxfw);
de5126cc	176	}
9e2004f9	177
27e66635 TS	178	/*
	179	* TASCAM FireOne has physical control and requires a pair of additional
	180	* MIDI ports.
	181	*/
	182	if (oxfw->entry->vendor_id == VENDOR_TASCAM) {
	183	oxfw->midi_input_ports++;
	184	oxfw->midi_output_ports++;
5ce8cc48	185	return 0;
27e66635 TS	186	}
27e66635 TS	187
13f3a46d TS	188	/* Seek from Root Directory of Config ROM. */
	189	vendor = model = 0;
	190	fw_csr_iterator_init(&it, fw_dev->config_rom + 5);
	191	while (fw_csr_iterator_next(&it, &key, &val)) {
	192	if (key == CSR_VENDOR)
	193	vendor = val;
	194	else if (key == CSR_MODEL)
	195	model = val;
	196	}
	197
	198	/*
	199	* Mackie Onyx Satellite with base station has a quirk to report a wrong
	200	* value in 'dbs' field of CIP header against its format information.
	201	*/
	202	if (vendor == VENDOR_LOUD && model == MODEL_SATELLITE)
	203	oxfw->wrong_dbs = true;
5ce8cc48 TS	204
5ce8cc48 TS	205	return 0;
13f3a46d TS	206	}
13f3a46d TS	207
8832c5a7	208	static int oxfw_probe(struct fw_unit *unit,
27e66635	209	const struct ieee1394_device_id *entry)
31ef9134	210	{
31ef9134	211	struct snd_card *card;
8832c5a7	212	struct snd_oxfw *oxfw;
31ef9134 CL	213	int err;
31ef9134 CL	214
27e66635	215	if (entry->vendor_id == VENDOR_LOUD && !detect_loud_models(unit))
ec4dba50 TS	216	return -ENODEV;
ec4dba50 TS	217
06b45f00	218	err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
8832c5a7	219	sizeof(*oxfw), &card);
31ef9134 CL	220	if (err < 0)
31ef9134 CL	221	return err;
31ef9134	222
e2786ca6	223	card->private_free = oxfw_card_free;
8832c5a7 TS	224	oxfw = card->private_data;
	225	oxfw->card = card;
	226	mutex_init(&oxfw->mutex);
12ed7192	227	oxfw->unit = fw_unit_get(unit);
27e66635	228	oxfw->entry = entry;
05588d34	229	spin_lock_init(&oxfw->lock);
8985f4ac	230	init_waitqueue_head(&oxfw->hwdep_wait);
31ef9134	231
5cd1d3f4 TS	232	err = snd_oxfw_stream_discover(oxfw);
	233	if (err < 0)
	234	goto error;
	235
3f47152a	236	err = name_card(oxfw);
5ce8cc48 TS	237	if (err < 0)
5ce8cc48 TS	238	goto error;
13f3a46d	239
3f47152a	240	err = detect_quirks(oxfw);
fec7b753 TS	241	if (err < 0)
fec7b753 TS	242	goto error;
31ef9134	243
3713d93a	244	err = snd_oxfw_create_pcm(oxfw);
31ef9134 CL	245	if (err < 0)
	246	goto error;
	247
3c96101f TS	248	snd_oxfw_proc_init(oxfw);
3c96101f TS	249
05588d34 TS	250	err = snd_oxfw_create_midi(oxfw);
	251	if (err < 0)
	252	goto error;
	253
8985f4ac TS	254	err = snd_oxfw_create_hwdep(oxfw);
	255	if (err < 0)
	256	goto error;
	257
b0ac0009	258	err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->rx_stream);
31ef9134 CL	259	if (err < 0)
31ef9134 CL	260	goto error;
b0ac0009 TS	261	if (oxfw->has_output) {
	262	err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->tx_stream);
	263	if (err < 0)
	264	goto error;
	265	}
31ef9134	266
e2786ca6 TS	267	err = snd_card_register(card);
e2786ca6 TS	268	if (err < 0) {
b0ac0009 TS	269	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
	270	if (oxfw->has_output)
	271	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
e2786ca6 TS	272	goto error;
e2786ca6 TS	273	}
8832c5a7	274	dev_set_drvdata(&unit->device, oxfw);
31ef9134 CL	275
31ef9134 CL	276	return 0;
31ef9134 CL	277	error:
	278	snd_card_free(card);
	279	return err;
	280	}
	281
8832c5a7	282	static void oxfw_bus_reset(struct fw_unit *unit)
31ef9134	283	{
8832c5a7	284	struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
31ef9134	285
8832c5a7	286	fcp_bus_reset(oxfw->unit);
31ef9134	287
e2786ca6	288	mutex_lock(&oxfw->mutex);
b0ac0009 TS	289
	290	snd_oxfw_stream_update_simplex(oxfw, &oxfw->rx_stream);
	291	if (oxfw->has_output)
	292	snd_oxfw_stream_update_simplex(oxfw, &oxfw->tx_stream);
	293
e2786ca6	294	mutex_unlock(&oxfw->mutex);
9e2004f9 TS	295
	296	if (oxfw->entry->vendor_id == OUI_STANTON)
	297	snd_oxfw_scs1x_update(oxfw);
31ef9134 CL	298	}
31ef9134 CL	299
8832c5a7	300	static void oxfw_remove(struct fw_unit *unit)
94a87157	301	{
8832c5a7	302	struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
94a87157	303
12ed7192	304	/* No need to wait for releasing card object in this context. */
8832c5a7	305	snd_card_free_when_closed(oxfw->card);
94a87157 SR	306	}
94a87157 SR	307
d6ce6bbd	308	static const struct compat_info griffin_firewave = {
94a87157	309	.driver_name = "FireWave",
fec7b753 TS	310	.vendor_name = "Griffin",
fec7b753 TS	311	.model_name = "FireWave",
94a87157 SR	312	};
94a87157 SR	313
d6ce6bbd	314	static const struct compat_info lacie_speakers = {
94a87157	315	.driver_name = "FWSpeakers",
fec7b753 TS	316	.vendor_name = "LaCie",
fec7b753 TS	317	.model_name = "FireWire Speakers",
94a87157 SR	318	};
94a87157 SR	319
8832c5a7	320	static const struct ieee1394_device_id oxfw_id_table[] = {
31ef9134 CL	321	{
	322	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	323	IEEE1394_MATCH_MODEL_ID \|
	324	IEEE1394_MATCH_SPECIFIER_ID \|
	325	IEEE1394_MATCH_VERSION,
	326	.vendor_id = VENDOR_GRIFFIN,
	327	.model_id = 0x00f970,
	328	.specifier_id = SPECIFIER_1394TA,
	329	.version = VERSION_AVC,
94a87157	330	.driver_data = (kernel_ulong_t)&griffin_firewave,
31ef9134 CL	331	},
	332	{
	333	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	334	IEEE1394_MATCH_MODEL_ID \|
	335	IEEE1394_MATCH_SPECIFIER_ID \|
	336	IEEE1394_MATCH_VERSION,
	337	.vendor_id = VENDOR_LACIE,
	338	.model_id = 0x00f970,
	339	.specifier_id = SPECIFIER_1394TA,
	340	.version = VERSION_AVC,
94a87157	341	.driver_data = (kernel_ulong_t)&lacie_speakers,
31ef9134	342	},
ec4dba50 TS	343	/* Behringer,F-Control Audio 202 */
	344	{
	345	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	346	IEEE1394_MATCH_MODEL_ID,
	347	.vendor_id = VENDOR_BEHRINGER,
	348	.model_id = 0x00fc22,
	349	},
	350	/*
	351	* Any Mackie(Loud) models (name string/model id):
	352	* Onyx-i series (former models): 0x081216
	353	* Mackie Onyx Satellite: 0x00200f
	354	* Tapco LINK.firewire 4x6: 0x000460
	355	* d.2 pro: Unknown
	356	* d.4 pro: Unknown
	357	* U.420: Unknown
	358	* U.420d: Unknown
	359	*/
	360	{
	361	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	362	IEEE1394_MATCH_SPECIFIER_ID \|
	363	IEEE1394_MATCH_VERSION,
	364	.vendor_id = VENDOR_LOUD,
	365	.specifier_id = SPECIFIER_1394TA,
	366	.version = VERSION_AVC,
	367	},
759a2f40 TS	368	/* TASCAM, FireOne */
	369	{
	370	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	371	IEEE1394_MATCH_MODEL_ID,
	372	.vendor_id = VENDOR_TASCAM,
	373	.model_id = 0x800007,
	374	},
9e2004f9 TS	375	/* Stanton, Stanton Controllers & Systems 1 Mixer (SCS.1m) */
	376	{
	377	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	378	IEEE1394_MATCH_MODEL_ID,
	379	.vendor_id = OUI_STANTON,
	380	.model_id = 0x001000,
	381	},
	382	/* Stanton, Stanton Controllers & Systems 1 Deck (SCS.1d) */
	383	{
	384	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	385	IEEE1394_MATCH_MODEL_ID,
	386	.vendor_id = OUI_STANTON,
	387	.model_id = 0x002000,
	388	},
31ef9134 CL	389	{ }
31ef9134 CL	390	};
8832c5a7	391	MODULE_DEVICE_TABLE(ieee1394, oxfw_id_table);
31ef9134	392
8832c5a7	393	static struct fw_driver oxfw_driver = {
31ef9134 CL	394	.driver = {
	395	.owner = THIS_MODULE,
	396	.name = KBUILD_MODNAME,
	397	.bus = &fw_bus_type,
31ef9134	398	},
8832c5a7 TS	399	.probe = oxfw_probe,
	400	.update = oxfw_bus_reset,
	401	.remove = oxfw_remove,
	402	.id_table = oxfw_id_table,
31ef9134 CL	403	};
31ef9134 CL	404
8832c5a7	405	static int __init snd_oxfw_init(void)
31ef9134	406	{
8832c5a7	407	return driver_register(&oxfw_driver.driver);
31ef9134 CL	408	}
31ef9134 CL	409
8832c5a7	410	static void __exit snd_oxfw_exit(void)
31ef9134	411	{
8832c5a7	412	driver_unregister(&oxfw_driver.driver);
31ef9134 CL	413	}
31ef9134 CL	414
8832c5a7 TS	415	module_init(snd_oxfw_init);
8832c5a7 TS	416	module_exit(snd_oxfw_exit);