[linux-2.6-block.git] / sound / firewire / fireworks / fireworks.c

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

/*
 * Fireworks is a board module which Echo Audio produced. This module consists
 * of three chipsets:
 *  - Communication chipset for IEEE1394 PHY/Link and IEC 61883-1/6
 *  - DSP or/and FPGA for signal processing
 *  - Flash Memory to store firmwares
 */

#include "fireworks.h"

MODULE_DESCRIPTION("Echo Fireworks driver");
MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
MODULE_LICENSE("GPL v2");

static int index[SNDRV_CARDS]	= SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS]	= SNDRV_DEFAULT_STR;
static bool enable[SNDRV_CARDS]	= SNDRV_DEFAULT_ENABLE_PNP;

module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "card index");
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string");
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "enable Fireworks sound card");

static DEFINE_MUTEX(devices_mutex);
static DECLARE_BITMAP(devices_used, SNDRV_CARDS);

#define VENDOR_LOUD			0x000ff2
#define  MODEL_MACKIE_400F		0x00400f
#define  MODEL_MACKIE_1200F		0x01200f

#define VENDOR_ECHO			0x001486
#define  MODEL_ECHO_AUDIOFIRE_12	0x00af12
#define  MODEL_ECHO_AUDIOFIRE_12HD	0x0af12d
#define  MODEL_ECHO_AUDIOFIRE_12_APPLE	0x0af12a
/* This is applied for AudioFire8 (until 2009 July) */
#define  MODEL_ECHO_AUDIOFIRE_8		0x000af8
#define  MODEL_ECHO_AUDIOFIRE_2		0x000af2
#define  MODEL_ECHO_AUDIOFIRE_4		0x000af4
/* AudioFire9 is applied for AudioFire8(since 2009 July) and AudioFirePre8 */
#define  MODEL_ECHO_AUDIOFIRE_9		0x000af9
/* unknown as product */
#define  MODEL_ECHO_FIREWORKS_8		0x0000f8
#define  MODEL_ECHO_FIREWORKS_HDMI	0x00afd1

#define VENDOR_GIBSON			0x00075b
/* for Robot Interface Pack of Dark Fire, Dusk Tiger, Les Paul Standard 2010 */
#define  MODEL_GIBSON_RIP		0x00afb2
/* unknown as product */
#define  MODEL_GIBSON_GOLDTOP		0x00afb9

/* part of hardware capability flags */
#define FLAG_RESP_ADDR_CHANGABLE	0

static int
get_hardware_info(struct snd_efw *efw)
{
	struct fw_device *fw_dev = fw_parent_device(efw->unit);
	struct snd_efw_hwinfo *hwinfo;
	char version[12] = {0};
	int err;

	hwinfo = kzalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL);
	if (hwinfo == NULL)
		return -ENOMEM;

	err = snd_efw_command_get_hwinfo(efw, hwinfo);
	if (err < 0)
		goto end;

	/* firmware version for communication chipset */
	snprintf(version, sizeof(version), "%u.%u",
		 (hwinfo->arm_version >> 24) & 0xff,
		 (hwinfo->arm_version >> 16) & 0xff);
	if (err < 0)
		goto end;

	strcpy(efw->card->driver, "Fireworks");
	strcpy(efw->card->shortname, hwinfo->model_name);
	strcpy(efw->card->mixername, hwinfo->model_name);
	snprintf(efw->card->longname, sizeof(efw->card->longname),
		 "%s %s v%s, GUID %08x%08x at %s, S%d",
		 hwinfo->vendor_name, hwinfo->model_name, version,
		 hwinfo->guid_hi, hwinfo->guid_lo,
		 dev_name(&efw->unit->device), 100 << fw_dev->max_speed);
	if (err < 0)
		goto end;

	if (hwinfo->flags & BIT(FLAG_RESP_ADDR_CHANGABLE))
		efw->resp_addr_changable = true;
end:
	kfree(hwinfo);
	return err;
}

static void
efw_card_free(struct snd_card *card)
{
	struct snd_efw *efw = card->private_data;

	if (efw->card_index >= 0) {
		mutex_lock(&devices_mutex);
		clear_bit(efw->card_index, devices_used);
		mutex_unlock(&devices_mutex);
	}

	mutex_destroy(&efw->mutex);
}

static int
efw_probe(struct fw_unit *unit,
	  const struct ieee1394_device_id *entry)
{
	struct snd_card *card;
	struct snd_efw *efw;
	int card_index, err;

	mutex_lock(&devices_mutex);

	/* check registered cards */
	for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) {
		if (!test_bit(card_index, devices_used) && enable[card_index])
			break;
	}
	if (card_index >= SNDRV_CARDS) {
		err = -ENOENT;
		goto end;
	}

	err = snd_card_new(&unit->device, index[card_index], id[card_index],
			   THIS_MODULE, sizeof(struct snd_efw), &card);
	if (err < 0)
		goto end;
	efw = card->private_data;
	efw->card_index = card_index;
	set_bit(card_index, devices_used);
	card->private_free = efw_card_free;

	efw->card = card;
	efw->unit = unit;
	mutex_init(&efw->mutex);
	spin_lock_init(&efw->lock);

	err = get_hardware_info(efw);
	if (err < 0)
		goto error;

	err = snd_card_register(card);
	if (err < 0)
		goto error;

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

static void efw_update(struct fw_unit *unit)
{
	struct snd_efw *efw = dev_get_drvdata(&unit->device);
	snd_efw_transaction_bus_reset(efw->unit);
}

static void efw_remove(struct fw_unit *unit)
{
	struct snd_efw *efw = dev_get_drvdata(&unit->device);
	snd_card_disconnect(efw->card);
	snd_card_free_when_closed(efw->card);
}

static const struct ieee1394_device_id efw_id_table[] = {
	SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F),
	SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8),
	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI),
	SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP),
	SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP),
	{}
};
MODULE_DEVICE_TABLE(ieee1394, efw_id_table);

static struct fw_driver efw_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = "snd-fireworks",
		.bus = &fw_bus_type,
	},
	.probe    = efw_probe,
	.update   = efw_update,
	.remove   = efw_remove,
	.id_table = efw_id_table,
};

static int __init snd_efw_init(void)
{
	int err;

	err = snd_efw_transaction_register();
	if (err < 0)
		goto end;

	err = driver_register(&efw_driver.driver);
	if (err < 0)
		snd_efw_transaction_unregister();

end:
	return err;
}

static void __exit snd_efw_exit(void)
{
	snd_efw_transaction_unregister();
	driver_unregister(&efw_driver.driver);
	mutex_destroy(&devices_mutex);
}

module_init(snd_efw_init);
module_exit(snd_efw_exit);
Commit	Line	Data
b5b04336 TS	1	/*
	2	* fireworks.c - a part of driver for Fireworks based devices
	3	*
	4	* Copyright (c) 2009-2010 Clemens Ladisch
	5	* Copyright (c) 2013-2014 Takashi Sakamoto
	6	*
	7	* Licensed under the terms of the GNU General Public License, version 2.
	8	*/
	9
	10	/*
	11	* Fireworks is a board module which Echo Audio produced. This module consists
	12	* of three chipsets:
	13	* - Communication chipset for IEEE1394 PHY/Link and IEC 61883-1/6
	14	* - DSP or/and FPGA for signal processing
	15	* - Flash Memory to store firmwares
	16	*/
	17
	18	#include "fireworks.h"
	19
	20	MODULE_DESCRIPTION("Echo Fireworks driver");
	21	MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
	22	MODULE_LICENSE("GPL v2");
	23
	24	static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
	25	static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
	26	static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
	27
	28	module_param_array(index, int, NULL, 0444);
	29	MODULE_PARM_DESC(index, "card index");
	30	module_param_array(id, charp, NULL, 0444);
	31	MODULE_PARM_DESC(id, "ID string");
	32	module_param_array(enable, bool, NULL, 0444);
	33	MODULE_PARM_DESC(enable, "enable Fireworks sound card");
	34
	35	static DEFINE_MUTEX(devices_mutex);
	36	static DECLARE_BITMAP(devices_used, SNDRV_CARDS);
	37
	38	#define VENDOR_LOUD 0x000ff2
	39	#define MODEL_MACKIE_400F 0x00400f
	40	#define MODEL_MACKIE_1200F 0x01200f
	41
	42	#define VENDOR_ECHO 0x001486
	43	#define MODEL_ECHO_AUDIOFIRE_12 0x00af12
	44	#define MODEL_ECHO_AUDIOFIRE_12HD 0x0af12d
	45	#define MODEL_ECHO_AUDIOFIRE_12_APPLE 0x0af12a
	46	/* This is applied for AudioFire8 (until 2009 July) */
	47	#define MODEL_ECHO_AUDIOFIRE_8 0x000af8
	48	#define MODEL_ECHO_AUDIOFIRE_2 0x000af2
	49	#define MODEL_ECHO_AUDIOFIRE_4 0x000af4
	50	/* AudioFire9 is applied for AudioFire8(since 2009 July) and AudioFirePre8 */
	51	#define MODEL_ECHO_AUDIOFIRE_9 0x000af9
	52	/* unknown as product */
	53	#define MODEL_ECHO_FIREWORKS_8 0x0000f8
	54	#define MODEL_ECHO_FIREWORKS_HDMI 0x00afd1
	55
	56	#define VENDOR_GIBSON 0x00075b
	57	/* for Robot Interface Pack of Dark Fire, Dusk Tiger, Les Paul Standard 2010 */
	58	#define MODEL_GIBSON_RIP 0x00afb2
	59	/* unknown as product */
	60	#define MODEL_GIBSON_GOLDTOP 0x00afb9
	61
bde8a8f2 TS	62	/* part of hardware capability flags */
	63	#define FLAG_RESP_ADDR_CHANGABLE 0
	64
	65	static int
	66	get_hardware_info(struct snd_efw *efw)
	67	{
	68	struct fw_device *fw_dev = fw_parent_device(efw->unit);
	69	struct snd_efw_hwinfo *hwinfo;
	70	char version[12] = {0};
	71	int err;
	72
	73	hwinfo = kzalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL);
	74	if (hwinfo == NULL)
	75	return -ENOMEM;
	76
	77	err = snd_efw_command_get_hwinfo(efw, hwinfo);
	78	if (err < 0)
	79	goto end;
	80
	81	/* firmware version for communication chipset */
	82	snprintf(version, sizeof(version), "%u.%u",
	83	(hwinfo->arm_version >> 24) & 0xff,
	84	(hwinfo->arm_version >> 16) & 0xff);
	85	if (err < 0)
	86	goto end;
	87
	88	strcpy(efw->card->driver, "Fireworks");
	89	strcpy(efw->card->shortname, hwinfo->model_name);
	90	strcpy(efw->card->mixername, hwinfo->model_name);
	91	snprintf(efw->card->longname, sizeof(efw->card->longname),
	92	"%s %s v%s, GUID %08x%08x at %s, S%d",
	93	hwinfo->vendor_name, hwinfo->model_name, version,
	94	hwinfo->guid_hi, hwinfo->guid_lo,
	95	dev_name(&efw->unit->device), 100 << fw_dev->max_speed);
	96	if (err < 0)
	97	goto end;
	98
	99	if (hwinfo->flags & BIT(FLAG_RESP_ADDR_CHANGABLE))
	100	efw->resp_addr_changable = true;
	101	end:
	102	kfree(hwinfo);
	103	return err;
	104	}
	105
b5b04336 TS	106	static void
	107	efw_card_free(struct snd_card *card)
	108	{
	109	struct snd_efw *efw = card->private_data;
	110
	111	if (efw->card_index >= 0) {
	112	mutex_lock(&devices_mutex);
	113	clear_bit(efw->card_index, devices_used);
	114	mutex_unlock(&devices_mutex);
	115	}
	116
	117	mutex_destroy(&efw->mutex);
	118	}
	119
	120	static int
	121	efw_probe(struct fw_unit *unit,
	122	const struct ieee1394_device_id *entry)
	123	{
	124	struct snd_card *card;
	125	struct snd_efw *efw;
	126	int card_index, err;
	127
	128	mutex_lock(&devices_mutex);
	129
	130	/* check registered cards */
	131	for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) {
	132	if (!test_bit(card_index, devices_used) && enable[card_index])
	133	break;
	134	}
	135	if (card_index >= SNDRV_CARDS) {
	136	err = -ENOENT;
	137	goto end;
	138	}
	139
	140	err = snd_card_new(&unit->device, index[card_index], id[card_index],
	141	THIS_MODULE, sizeof(struct snd_efw), &card);
	142	if (err < 0)
	143	goto end;
	144	efw = card->private_data;
	145	efw->card_index = card_index;
	146	set_bit(card_index, devices_used);
	147	card->private_free = efw_card_free;
	148
	149	efw->card = card;
	150	efw->unit = unit;
	151	mutex_init(&efw->mutex);
	152	spin_lock_init(&efw->lock);
	153
bde8a8f2 TS	154	err = get_hardware_info(efw);
	155	if (err < 0)
	156	goto error;
b5b04336 TS	157
	158	err = snd_card_register(card);
	159	if (err < 0)
	160	goto error;
bde8a8f2	161
b5b04336 TS	162	dev_set_drvdata(&unit->device, efw);
	163	end:
	164	mutex_unlock(&devices_mutex);
	165	return err;
	166	error:
	167	mutex_unlock(&devices_mutex);
	168	snd_card_free(card);
	169	return err;
	170	}
	171
	172	static void efw_update(struct fw_unit *unit)
	173	{
bde8a8f2 TS	174	struct snd_efw *efw = dev_get_drvdata(&unit->device);
bde8a8f2 TS	175	snd_efw_transaction_bus_reset(efw->unit);
b5b04336 TS	176	}
	177
	178	static void efw_remove(struct fw_unit *unit)
	179	{
	180	struct snd_efw *efw = dev_get_drvdata(&unit->device);
	181	snd_card_disconnect(efw->card);
	182	snd_card_free_when_closed(efw->card);
	183	}
	184
	185	static const struct ieee1394_device_id efw_id_table[] = {
	186	SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F),
	187	SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F),
	188	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8),
	189	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12),
	190	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD),
	191	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE),
	192	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2),
	193	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4),
	194	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9),
	195	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8),
	196	SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI),
	197	SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP),
	198	SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP),
	199	{}
	200	};
	201	MODULE_DEVICE_TABLE(ieee1394, efw_id_table);
	202
	203	static struct fw_driver efw_driver = {
	204	.driver = {
	205	.owner = THIS_MODULE,
	206	.name = "snd-fireworks",
	207	.bus = &fw_bus_type,
	208	},
	209	.probe = efw_probe,
	210	.update = efw_update,
	211	.remove = efw_remove,
	212	.id_table = efw_id_table,
	213	};
	214
	215	static int __init snd_efw_init(void)
	216	{
bde8a8f2 TS	217	int err;
	218
	219	err = snd_efw_transaction_register();
	220	if (err < 0)
	221	goto end;
	222
	223	err = driver_register(&efw_driver.driver);
	224	if (err < 0)
	225	snd_efw_transaction_unregister();
	226
	227	end:
	228	return err;
b5b04336 TS	229	}
	230
	231	static void __exit snd_efw_exit(void)
	232	{
bde8a8f2	233	snd_efw_transaction_unregister();
b5b04336 TS	234	driver_unregister(&efw_driver.driver);
	235	mutex_destroy(&devices_mutex);
	236	}
	237
	238	module_init(snd_efw_init);
	239	module_exit(snd_efw_exit);