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

static void oxfw_free(struct snd_oxfw *oxfw)
{
	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);
}

/*
 * 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)
{
	oxfw_free(card->private_data);
}

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 void do_registration(struct work_struct *work)
{
	struct snd_oxfw *oxfw = container_of(work, struct snd_oxfw, dwork.work);
	int err;

	if (oxfw->registered)
		return;

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

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

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

	err = snd_oxfw_stream_discover(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_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_card_register(oxfw->card);
	if (err < 0)
		goto error;

	/*
	 * After registered, oxfw instance can be released corresponding to
	 * releasing the sound card instance.
	 */
	oxfw->card->private_free = oxfw_card_free;
	oxfw->card->private_data = oxfw;
	oxfw->registered = true;

	return;
error:
	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
	if (oxfw->has_output)
		snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
	snd_card_free(oxfw->card);
	dev_info(&oxfw->unit->device,
		 "Sound card registration failed: %d\n", err);
}

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

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

	/* Allocate this independent of sound card instance. */
	oxfw = kzalloc(sizeof(struct snd_oxfw), GFP_KERNEL);
	if (oxfw == NULL)
		return -ENOMEM;

	oxfw->entry = entry;
	oxfw->unit = fw_unit_get(unit);
	dev_set_drvdata(&unit->device, oxfw);

	mutex_init(&oxfw->mutex);
	spin_lock_init(&oxfw->lock);
	init_waitqueue_head(&oxfw->hwdep_wait);

	/* Allocate and register this sound card later. */
	INIT_DEFERRABLE_WORK(&oxfw->dwork, do_registration);
	snd_fw_schedule_registration(unit, &oxfw->dwork);

	return 0;
}

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

	if (!oxfw->registered)
		snd_fw_schedule_registration(unit, &oxfw->dwork);

	fcp_bus_reset(oxfw->unit);

	if (oxfw->registered) {
		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);

	/*
	 * Confirm to stop the work for registration before the sound card is
	 * going to be released. The work is not scheduled again because bus
	 * reset handler is not called anymore.
	 */
	cancel_delayed_work_sync(&oxfw->dwork);

	if (oxfw->registered) {
		/* No need to wait for releasing card object in this context. */
		snd_card_free_when_closed(oxfw->card);
	} else {
		/* Don't forget this case. */
		oxfw_free(oxfw);
	}
}

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
6c29230e	121	static void oxfw_free(struct snd_oxfw *oxfw)
31ef9134	122	{
5cd1d3f4 TS	123	unsigned int i;
5cd1d3f4 TS	124
dec84316 TS	125	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
	126	if (oxfw->has_output)
	127	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
	128
12ed7192 TS	129	fw_unit_put(oxfw->unit);
12ed7192 TS	130
b0ac0009 TS	131	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
b0ac0009 TS	132	kfree(oxfw->tx_stream_formats[i]);
5cd1d3f4	133	kfree(oxfw->rx_stream_formats[i]);
b0ac0009	134	}
31ef9134	135
c582cc66	136	kfree(oxfw->spec);
8832c5a7	137	mutex_destroy(&oxfw->mutex);
31ef9134 CL	138	}
31ef9134 CL	139
6c29230e TS	140	/*
	141	* This module releases the FireWire unit data after all ALSA character devices
	142	* are released by applications. This is for releasing stream data or finishing
	143	* transactions safely. Thus at returning from .remove(), this module still keep
	144	* references for the unit.
	145	*/
	146	static void oxfw_card_free(struct snd_card *card)
	147	{
	148	oxfw_free(card->private_data);
	149	}
	150
5ce8cc48	151	static int detect_quirks(struct snd_oxfw *oxfw)
13f3a46d TS	152	{
	153	struct fw_device *fw_dev = fw_parent_device(oxfw->unit);
	154	struct fw_csr_iterator it;
	155	int key, val;
	156	int vendor, model;
	157
5ce8cc48 TS	158	/*
	159	* Add ALSA control elements for two models to keep compatibility to
	160	* old firewire-speaker module.
	161	*/
3e2f4570 TS	162	if (oxfw->entry->vendor_id == VENDOR_GRIFFIN)
	163	return snd_oxfw_add_spkr(oxfw, false);
	164	if (oxfw->entry->vendor_id == VENDOR_LACIE)
	165	return snd_oxfw_add_spkr(oxfw, true);
5ce8cc48	166
9e2004f9 TS	167	/*
	168	* Stanton models supports asynchronous transactions for unique MIDI
	169	* messages.
	170	*/
de5126cc TS	171	if (oxfw->entry->vendor_id == OUI_STANTON) {
	172	/* No physical MIDI ports. */
	173	oxfw->midi_input_ports = 0;
	174	oxfw->midi_output_ports = 0;
	175
	176	/* Output stream exists but no data channels are useful. */
	177	oxfw->has_output = false;
	178
9e2004f9	179	return snd_oxfw_scs1x_add(oxfw);
de5126cc	180	}
9e2004f9	181
27e66635 TS	182	/*
	183	* TASCAM FireOne has physical control and requires a pair of additional
	184	* MIDI ports.
	185	*/
	186	if (oxfw->entry->vendor_id == VENDOR_TASCAM) {
	187	oxfw->midi_input_ports++;
	188	oxfw->midi_output_ports++;
5ce8cc48	189	return 0;
27e66635 TS	190	}
27e66635 TS	191
13f3a46d TS	192	/* Seek from Root Directory of Config ROM. */
	193	vendor = model = 0;
	194	fw_csr_iterator_init(&it, fw_dev->config_rom + 5);
	195	while (fw_csr_iterator_next(&it, &key, &val)) {
	196	if (key == CSR_VENDOR)
	197	vendor = val;
	198	else if (key == CSR_MODEL)
	199	model = val;
	200	}
	201
	202	/*
	203	* Mackie Onyx Satellite with base station has a quirk to report a wrong
	204	* value in 'dbs' field of CIP header against its format information.
	205	*/
	206	if (vendor == VENDOR_LOUD && model == MODEL_SATELLITE)
	207	oxfw->wrong_dbs = true;
5ce8cc48 TS	208
5ce8cc48 TS	209	return 0;
13f3a46d TS	210	}
13f3a46d TS	211
6c29230e	212	static void do_registration(struct work_struct *work)
31ef9134	213	{
6c29230e	214	struct snd_oxfw *oxfw = container_of(work, struct snd_oxfw, dwork.work);
31ef9134 CL	215	int err;
31ef9134 CL	216
6c29230e TS	217	if (oxfw->registered)
6c29230e TS	218	return;
ec4dba50	219
6c29230e TS	220	err = snd_card_new(&oxfw->unit->device, -1, NULL, THIS_MODULE, 0,
6c29230e TS	221	&oxfw->card);
31ef9134	222	if (err < 0)
6c29230e	223	return;
31ef9134	224
6c29230e TS	225	err = name_card(oxfw);
	226	if (err < 0)
	227	goto error;
31ef9134	228
6c29230e	229	err = detect_quirks(oxfw);
5cd1d3f4 TS	230	if (err < 0)
	231	goto error;
	232
6c29230e	233	err = snd_oxfw_stream_discover(oxfw);
5ce8cc48 TS	234	if (err < 0)
5ce8cc48 TS	235	goto error;
13f3a46d	236
6c29230e	237	err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->rx_stream);
fec7b753 TS	238	if (err < 0)
fec7b753 TS	239	goto error;
6c29230e TS	240	if (oxfw->has_output) {
	241	err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->tx_stream);
	242	if (err < 0)
	243	goto error;
	244	}
31ef9134	245
3713d93a	246	err = snd_oxfw_create_pcm(oxfw);
31ef9134 CL	247	if (err < 0)
	248	goto error;
	249
3c96101f TS	250	snd_oxfw_proc_init(oxfw);
3c96101f TS	251
05588d34 TS	252	err = snd_oxfw_create_midi(oxfw);
	253	if (err < 0)
	254	goto error;
	255
8985f4ac TS	256	err = snd_oxfw_create_hwdep(oxfw);
	257	if (err < 0)
	258	goto error;
	259
6c29230e	260	err = snd_card_register(oxfw->card);
31ef9134 CL	261	if (err < 0)
	262	goto error;
	263
6c29230e TS	264	/*
	265	* After registered, oxfw instance can be released corresponding to
	266	* releasing the sound card instance.
	267	*/
	268	oxfw->card->private_free = oxfw_card_free;
	269	oxfw->card->private_data = oxfw;
	270	oxfw->registered = true;
	271
	272	return;
	273	error:
	274	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
	275	if (oxfw->has_output)
	276	snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
	277	snd_card_free(oxfw->card);
	278	dev_info(&oxfw->unit->device,
	279	"Sound card registration failed: %d\n", err);
	280	}
	281
	282	static int oxfw_probe(struct fw_unit *unit,
	283	const struct ieee1394_device_id *entry)
	284	{
	285	struct snd_oxfw *oxfw;
	286
	287	if (entry->vendor_id == VENDOR_LOUD && !detect_loud_models(unit))
	288	return -ENODEV;
	289
	290	/* Allocate this independent of sound card instance. */
	291	oxfw = kzalloc(sizeof(struct snd_oxfw), GFP_KERNEL);
	292	if (oxfw == NULL)
	293	return -ENOMEM;
	294
	295	oxfw->entry = entry;
	296	oxfw->unit = fw_unit_get(unit);
8832c5a7	297	dev_set_drvdata(&unit->device, oxfw);
31ef9134	298
6c29230e TS	299	mutex_init(&oxfw->mutex);
	300	spin_lock_init(&oxfw->lock);
	301	init_waitqueue_head(&oxfw->hwdep_wait);
	302
	303	/* Allocate and register this sound card later. */
	304	INIT_DEFERRABLE_WORK(&oxfw->dwork, do_registration);
	305	snd_fw_schedule_registration(unit, &oxfw->dwork);
	306
31ef9134	307	return 0;
31ef9134 CL	308	}
31ef9134 CL	309
8832c5a7	310	static void oxfw_bus_reset(struct fw_unit *unit)
31ef9134	311	{
8832c5a7	312	struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
31ef9134	313
6c29230e TS	314	if (!oxfw->registered)
	315	snd_fw_schedule_registration(unit, &oxfw->dwork);
	316
8832c5a7	317	fcp_bus_reset(oxfw->unit);
31ef9134	318
6c29230e TS	319	if (oxfw->registered) {
6c29230e TS	320	mutex_lock(&oxfw->mutex);
b0ac0009	321
6c29230e TS	322	snd_oxfw_stream_update_simplex(oxfw, &oxfw->rx_stream);
	323	if (oxfw->has_output)
	324	snd_oxfw_stream_update_simplex(oxfw, &oxfw->tx_stream);
b0ac0009	325
6c29230e	326	mutex_unlock(&oxfw->mutex);
9e2004f9	327
6c29230e TS	328	if (oxfw->entry->vendor_id == OUI_STANTON)
	329	snd_oxfw_scs1x_update(oxfw);
	330	}
31ef9134 CL	331	}
31ef9134 CL	332
8832c5a7	333	static void oxfw_remove(struct fw_unit *unit)
94a87157	334	{
8832c5a7	335	struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
94a87157	336
6c29230e TS	337	/*
	338	* Confirm to stop the work for registration before the sound card is
	339	* going to be released. The work is not scheduled again because bus
	340	* reset handler is not called anymore.
	341	*/
	342	cancel_delayed_work_sync(&oxfw->dwork);
	343
	344	if (oxfw->registered) {
	345	/* No need to wait for releasing card object in this context. */
	346	snd_card_free_when_closed(oxfw->card);
	347	} else {
	348	/* Don't forget this case. */
	349	oxfw_free(oxfw);
	350	}
94a87157 SR	351	}
94a87157 SR	352
d6ce6bbd	353	static const struct compat_info griffin_firewave = {
94a87157	354	.driver_name = "FireWave",
fec7b753 TS	355	.vendor_name = "Griffin",
fec7b753 TS	356	.model_name = "FireWave",
94a87157 SR	357	};
94a87157 SR	358
d6ce6bbd	359	static const struct compat_info lacie_speakers = {
94a87157	360	.driver_name = "FWSpeakers",
fec7b753 TS	361	.vendor_name = "LaCie",
fec7b753 TS	362	.model_name = "FireWire Speakers",
94a87157 SR	363	};
94a87157 SR	364
8832c5a7	365	static const struct ieee1394_device_id oxfw_id_table[] = {
31ef9134 CL	366	{
	367	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	368	IEEE1394_MATCH_MODEL_ID \|
	369	IEEE1394_MATCH_SPECIFIER_ID \|
	370	IEEE1394_MATCH_VERSION,
	371	.vendor_id = VENDOR_GRIFFIN,
	372	.model_id = 0x00f970,
	373	.specifier_id = SPECIFIER_1394TA,
	374	.version = VERSION_AVC,
94a87157	375	.driver_data = (kernel_ulong_t)&griffin_firewave,
31ef9134 CL	376	},
	377	{
	378	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	379	IEEE1394_MATCH_MODEL_ID \|
	380	IEEE1394_MATCH_SPECIFIER_ID \|
	381	IEEE1394_MATCH_VERSION,
	382	.vendor_id = VENDOR_LACIE,
	383	.model_id = 0x00f970,
	384	.specifier_id = SPECIFIER_1394TA,
	385	.version = VERSION_AVC,
94a87157	386	.driver_data = (kernel_ulong_t)&lacie_speakers,
31ef9134	387	},
ec4dba50 TS	388	/* Behringer,F-Control Audio 202 */
	389	{
	390	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	391	IEEE1394_MATCH_MODEL_ID,
	392	.vendor_id = VENDOR_BEHRINGER,
	393	.model_id = 0x00fc22,
	394	},
	395	/*
	396	* Any Mackie(Loud) models (name string/model id):
	397	* Onyx-i series (former models): 0x081216
	398	* Mackie Onyx Satellite: 0x00200f
	399	* Tapco LINK.firewire 4x6: 0x000460
	400	* d.2 pro: Unknown
	401	* d.4 pro: Unknown
	402	* U.420: Unknown
	403	* U.420d: Unknown
	404	*/
	405	{
	406	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	407	IEEE1394_MATCH_SPECIFIER_ID \|
	408	IEEE1394_MATCH_VERSION,
	409	.vendor_id = VENDOR_LOUD,
	410	.specifier_id = SPECIFIER_1394TA,
	411	.version = VERSION_AVC,
	412	},
759a2f40 TS	413	/* TASCAM, FireOne */
	414	{
	415	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	416	IEEE1394_MATCH_MODEL_ID,
	417	.vendor_id = VENDOR_TASCAM,
	418	.model_id = 0x800007,
	419	},
9e2004f9 TS	420	/* Stanton, Stanton Controllers & Systems 1 Mixer (SCS.1m) */
	421	{
	422	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	423	IEEE1394_MATCH_MODEL_ID,
	424	.vendor_id = OUI_STANTON,
	425	.model_id = 0x001000,
	426	},
	427	/* Stanton, Stanton Controllers & Systems 1 Deck (SCS.1d) */
	428	{
	429	.match_flags = IEEE1394_MATCH_VENDOR_ID \|
	430	IEEE1394_MATCH_MODEL_ID,
	431	.vendor_id = OUI_STANTON,
	432	.model_id = 0x002000,
	433	},
31ef9134 CL	434	{ }
31ef9134 CL	435	};
8832c5a7	436	MODULE_DEVICE_TABLE(ieee1394, oxfw_id_table);
31ef9134	437
8832c5a7	438	static struct fw_driver oxfw_driver = {
31ef9134 CL	439	.driver = {
	440	.owner = THIS_MODULE,
	441	.name = KBUILD_MODNAME,
	442	.bus = &fw_bus_type,
31ef9134	443	},
8832c5a7 TS	444	.probe = oxfw_probe,
	445	.update = oxfw_bus_reset,
	446	.remove = oxfw_remove,
	447	.id_table = oxfw_id_table,
31ef9134 CL	448	};
31ef9134 CL	449
8832c5a7	450	static int __init snd_oxfw_init(void)
31ef9134	451	{
8832c5a7	452	return driver_register(&oxfw_driver.driver);
31ef9134 CL	453	}
31ef9134 CL	454
8832c5a7	455	static void __exit snd_oxfw_exit(void)
31ef9134	456	{
8832c5a7	457	driver_unregister(&oxfw_driver.driver);
31ef9134 CL	458	}
31ef9134 CL	459
8832c5a7 TS	460	module_init(snd_oxfw_init);
8832c5a7 TS	461	module_exit(snd_oxfw_exit);