This commit add a new driver with no functionality. This driver just reacts to Firewire bus events and create/remove card instance.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/Kconfig | 20 +++ sound/firewire/Makefile | 1 + sound/firewire/bebob/Makefile | 2 + sound/firewire/bebob/bebob.c | 274 ++++++++++++++++++++++++++++++++++++++++++ sound/firewire/bebob/bebob.h | 74 ++++++++++++ 5 files changed, 371 insertions(+) create mode 100644 sound/firewire/bebob/Makefile create mode 100644 sound/firewire/bebob/bebob.c create mode 100644 sound/firewire/bebob/bebob.h

diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig index b3e274f..5349652 100644 --- a/sound/firewire/Kconfig +++ b/sound/firewire/Kconfig @@ -61,4 +61,24 @@ config SND_SCS1X To compile this driver as a module, choose M here: the module will be called snd-scs1x.

+config SND_BEBOB + tristate "BridgeCo BeBoB chipset support" + select SND_FIREWIRE_LIB + help + Say Y here to include support for FireWire devices based + on BridgeCo BeBoB chipset: + * Edirol FA-66/FA-101 + * Mackie OnyxFirewire + * Tascam IF-FW/DM + * Behringer X32 + * Apogee Rosetta200 + * ESI Quotafire610 + * AcousticReality eARMasterOne + * CME MatrixKFW + * Phonic HB24U + * BridgeCo RDAudio1/Audio5 + + To compile this driver as a module, choose M here: the module + will be called snd-fireworks. + endif # SND_FIREWIRE diff --git a/sound/firewire/Makefile b/sound/firewire/Makefile index 5099550..f2d1c5c 100644 --- a/sound/firewire/Makefile +++ b/sound/firewire/Makefile @@ -10,3 +10,4 @@ obj-$(CONFIG_SND_DICE) += snd-dice.o obj-$(CONFIG_SND_FIREWIRE_SPEAKERS) += snd-firewire-speakers.o obj-$(CONFIG_SND_ISIGHT) += snd-isight.o obj-$(CONFIG_SND_SCS1X) += snd-scs1x.o +obj-$(CONFIG_SND_BEBOB) += bebob/ diff --git a/sound/firewire/bebob/Makefile b/sound/firewire/bebob/Makefile new file mode 100644 index 0000000..c6f0141 --- /dev/null +++ b/sound/firewire/bebob/Makefile @@ -0,0 +1,2 @@ +snd-bebob-objs := bebob.o +obj-m += snd-bebob.o diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c new file mode 100644 index 0000000..bec4b6f --- /dev/null +++ b/sound/firewire/bebob/bebob.c @@ -0,0 +1,274 @@ +/* + * bebob.c - a part of driver for BeBoB based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +#include "bebob.h" + +MODULE_DESCRIPTION("bridgeCo BeBoB 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 BeBoB sound card"); + +static DEFINE_MUTEX(devices_mutex); +static unsigned int devices_used; + +/* Offsets from information register. */ +#define INFO_OFFSET_GUID 0x10 +#define INFO_OFFSET_HW_MODEL_ID 0x18 +#define INFO_OFFSET_HW_MODEL_REVISION 0x1c + +#define VEN_EDIROL 0x000040ab +#define VEN_BRIDGECO 0x000007f5 +#define VEN_MACKIE 0x0000000f +#define VEN_TASCOM 0x0000022e +#define VEN_BEHRINGER 0x00001564 +#define VEN_APOGEE 0x000003db +#define VEN_ESI 0x00000f1b +#define VEN_ACOUSTIC 0x00000002 +#define VEN_CME 0x0000000a +#define VEN_PHONIC 0x00001496 + +static int +name_device(struct snd_bebob *bebob, unsigned int vendor_id) +{ + char vendor[24] = {}; + char model[24] = {}; + u32 id; + u32 data[2] = {}; + u32 revision; + int err; + + /* get vendor name */ + if (vendor_id == VEN_EDIROL) + strcpy(vendor, "Edirol"); + else if (vendor_id == VEN_BRIDGECO) + strcpy(vendor, "BridgeCo"); + else if (vendor_id == VEN_MACKIE) + strcpy(vendor, "Mackie"); + else if (vendor_id == VEN_TASCOM) + strcpy(vendor, "Tacsom"); + else if (vendor_id == VEN_BEHRINGER) + strcpy(vendor, "Behringer"); + else if (vendor_id == VEN_APOGEE) + strcpy(vendor, "Apogee"); + else if (vendor_id == VEN_ESI) + strcpy(vendor, "ESI"); + else if (vendor_id == VEN_ACOUSTIC) + strcpy(vendor, "AcousticReality"); + else if (vendor_id == VEN_CME) + strcpy(vendor, "CME"); + else if (vendor_id == VEN_PHONIC) + strcpy(vendor, "Phonic"); + + /* get model name */ + err = fw_csr_string(bebob->unit->directory, CSR_MODEL, + model, sizeof(model)); + if (err < 0) + goto end; + + /* get hardware id */ + err = snd_bebob_read_quad(bebob, INFO_OFFSET_HW_MODEL_ID, + &id, sizeof(id)); + if (err < 0) + goto end; + + /* get hardware revision */ + err = snd_bebob_read_quad(bebob, INFO_OFFSET_HW_MODEL_REVISION, + &revision, sizeof(revision)); + if (err < 0) + goto end; + + /* get GUID */ + err = snd_bebob_read_block(bebob, INFO_OFFSET_GUID, + data, sizeof(data)); + if (err < 0) + goto end; + + strcpy(bebob->card->driver, "BeBoB"); + strcpy(bebob->card->shortname, model); + snprintf(bebob->card->longname, sizeof(bebob->card->longname), + "%s %s (id:%d, rev:%d), GUID %08x%08x at %s, S%d", + vendor, model, id, revision, + data[0], data[1], + dev_name(&bebob->unit->device), + 100 << bebob->device->max_speed); +end: + return err; +} + +static void +snd_bebob_card_free(struct snd_card *card) +{ + struct snd_bebob *bebob = card->private_data; + + if (bebob->card_index >= 0) { + mutex_lock(&devices_mutex); + devices_used &= ~BIT(bebob->card_index); + mutex_unlock(&devices_mutex); + } + + mutex_destroy(&bebob->mutex); + + return; +} + +static int +snd_bebob_probe(struct fw_unit *unit, + const struct ieee1394_device_id *entry) +{ + struct snd_card *card; + struct snd_bebob *bebob; + unsigned int card_index; + int err; + + mutex_lock(&devices_mutex); + + /* check registered cards */ + for (card_index = 0; card_index < SNDRV_CARDS; card_index++) { + if (!(devices_used & BIT(card_index)) && enable[card_index]) + break; + } + if (card_index >= SNDRV_CARDS) { + err = -ENOENT; + goto end; + } + + /* create card */ + err = snd_card_create(index[card_index], id[card_index], + THIS_MODULE, sizeof(struct snd_bebob), &card); + if (err < 0) + goto end; + card->private_free = snd_bebob_card_free; + + /* initialize myself */ + bebob = card->private_data; + bebob->card = card; + bebob->device = fw_parent_device(unit); + bebob->unit = unit; + bebob->card_index = -1; + mutex_init(&bebob->mutex); + spin_lock_init(&bebob->lock); + + /* name device with communication */ + err = name_device(bebob, entry->vendor_id); + if (err < 0) + goto error; + + /* register card and device */ + snd_card_set_dev(card, &unit->device); + err = snd_card_register(card); + if (err < 0) { + snd_card_free(card); + goto error; + } + dev_set_drvdata(&unit->device, bebob); + devices_used |= BIT(card_index); + bebob->card_index = card_index; + + /* proved */ + err = 0; +end: + mutex_unlock(&devices_mutex); + return err; +error: + snd_card_free(card); + mutex_unlock(&devices_mutex); + return err; +} + +static void +snd_bebob_update(struct fw_unit *unit) +{ + struct snd_bebob *bebob = dev_get_drvdata(&unit->device); + fcp_bus_reset(bebob->unit); +} + + +static void snd_bebob_remove(struct fw_unit *unit) +{ + struct snd_bebob *bebob = dev_get_drvdata(&unit->device); + snd_card_disconnect(bebob->card); + snd_card_free_when_closed(bebob->card); +} + +static const struct ieee1394_device_id snd_bebob_id_table[] = { + /* Edirol, FA-66 */ + SND_BEBOB_DEV_ENTRY(VEN_EDIROL, 0x00010049), + /* Edirol, FA-101 */ + SND_BEBOB_DEV_ENTRY(VEN_EDIROL, 0x00010048), + /* BridgeCo, RDAudio1 */ + SND_BEBOB_DEV_ENTRY(VEN_BRIDGECO, 0x00010048), + /* BridgeCo, Audio5 */ + SND_BEBOB_DEV_ENTRY(VEN_BRIDGECO, 0x00010049), + /* Mackie, OnyxFirewire */ + SND_BEBOB_DEV_ENTRY(VEN_MACKIE, 0x00010065), + /* Mackie, OnyxFirewire */ + SND_BEBOB_DEV_ENTRY(VEN_MACKIE, 0x00010067), + /* Tascam, IF-FW/DM */ + SND_BEBOB_DEV_ENTRY(VEN_TASCOM, 0x00010067), + /* Behringer, X32 */ + SND_BEBOB_DEV_ENTRY(VEN_BEHRINGER, 0x00000006), + /* ApogeeElectronics, Rosetta200 */ + SND_BEBOB_DEV_ENTRY(VEN_APOGEE, 0x00010048), + /* ESI, Quatafire610 */ + SND_BEBOB_DEV_ENTRY(VEN_ESI, 0x00010064), + /* AcousticReality, eARMasterOne */ + SND_BEBOB_DEV_ENTRY(VEN_ACOUSTIC, 0x00000002), + /* CME, MatrixKFW */ + SND_BEBOB_DEV_ENTRY(VEN_CME, 0x00030000), + /* Phonic, HB24U */ + SND_BEBOB_DEV_ENTRY(VEN_PHONIC, 0x00000000), + {} +}; +MODULE_DEVICE_TABLE(ieee1394, snd_bebob_id_table); + +static struct fw_driver snd_bebob_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "snd-bebob", + .bus = &fw_bus_type, + }, + .probe = snd_bebob_probe, + .update = snd_bebob_update, + .remove = snd_bebob_remove, + .id_table = snd_bebob_id_table, +}; + +static int __init +snd_bebob_init(void) +{ + return driver_register(&snd_bebob_driver.driver); +} + +static void __exit +snd_bebob_exit(void) +{ + driver_unregister(&snd_bebob_driver.driver); + mutex_destroy(&devices_mutex); +} + +module_init(snd_bebob_init); +module_exit(snd_bebob_exit); diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h new file mode 100644 index 0000000..60d875e --- /dev/null +++ b/sound/firewire/bebob/bebob.h @@ -0,0 +1,74 @@ +/* + * bebob.h - a part of driver for BeBoB based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +#ifndef SOUND_BEBOB_H_INCLUDED +#define SOUND_BEBOB_H_INCLUDED + +#include <linux/compat.h> +#include <linux/device.h> +#include <linux/firewire.h> +#include <linux/firewire-constants.h> +#include <linux/module.h> +#include <linux/mod_devicetable.h> +#include <linux/delay.h> +#include <linux/slab.h> + +#include <sound/core.h> +#include <sound/initval.h> + +#include "../lib.h" +#include "../fcp.h" + +/* basic register addresses on bebob chip */ +#define BEBOB_ADDR_REG_INFO 0xffffc8020000 +#define BEBOB_ADDR_REG_REQ 0xffffc8021000 + +struct snd_bebob { + struct snd_card *card; + struct fw_device *device; + struct fw_unit *unit; + int card_index; + + struct mutex mutex; + spinlock_t lock; +}; + +static inline int +snd_bebob_read_block(struct snd_bebob *bebob, u64 addr, void *buf, int size) +{ + return snd_fw_transaction(bebob->unit, TCODE_READ_BLOCK_REQUEST, + BEBOB_ADDR_REG_INFO + addr, + buf, size, 0); +} + +static inline int +snd_bebob_read_quad(struct snd_bebob *bebob, u64 addr, void *buf, int size) +{ + return snd_fw_transaction(bebob->unit, TCODE_READ_QUADLET_REQUEST, + BEBOB_ADDR_REG_INFO + addr, + buf, size, 0); +} + +#define SND_BEBOB_DEV_ENTRY(vendor, model) \ +{ \ + .match_flags = IEEE1394_MATCH_VENDOR_ID | \ + IEEE1394_MATCH_MODEL_ID, \ + .vendor_id = vendor, \ + .model_id = model, \ +} + +#endif

This commit adds proc interface to get chipset information and stream formation for debug.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/bebob/Makefile | 2 +- sound/firewire/bebob/bebob.c | 2 + sound/firewire/bebob/bebob.h | 3 + sound/firewire/bebob/bebob_proc.c | 123 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 129 insertions(+), 1 deletion(-) create mode 100644 sound/firewire/bebob/bebob_proc.c

diff --git a/sound/firewire/bebob/Makefile b/sound/firewire/bebob/Makefile index b29ca99..6e44fa0 100644 --- a/sound/firewire/bebob/Makefile +++ b/sound/firewire/bebob/Makefile @@ -1,3 +1,3 @@ -snd-bebob-objs := bebob_command.o bebob_stream.o \ +snd-bebob-objs := bebob_command.o bebob_stream.o bebob_proc.o \ bebob.o obj-m += snd-bebob.o diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c index 3597a3e..e5aa96e 100644 --- a/sound/firewire/bebob/bebob.c +++ b/sound/firewire/bebob/bebob.c @@ -177,6 +177,8 @@ snd_bebob_probe(struct fw_unit *unit, if (err < 0) goto error;

+ snd_bebob_proc_init(bebob); + err = snd_bebob_stream_discover(bebob); if (err < 0) goto error; diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h index f8f3025..2d60165 100644 --- a/sound/firewire/bebob/bebob.h +++ b/sound/firewire/bebob/bebob.h @@ -29,6 +29,7 @@

#include <sound/core.h> #include <sound/initval.h> +#include <sound/info.h>

#include "../packets-buffer.h" #include "../iso-resources.h" @@ -146,6 +147,8 @@ int snd_bebob_stream_stop_duplex(struct snd_bebob *bebob); void snd_bebob_stream_update_duplex(struct snd_bebob *bebob); void snd_bebob_stream_destroy_duplex(struct snd_bebob *bebob);

+void snd_bebob_proc_init(struct snd_bebob *bebob); + #define SND_BEBOB_DEV_ENTRY(vendor, model) \ { \ .match_flags = IEEE1394_MATCH_VENDOR_ID | \ diff --git a/sound/firewire/bebob/bebob_proc.c b/sound/firewire/bebob/bebob_proc.c new file mode 100644 index 0000000..ca7c1a7 --- /dev/null +++ b/sound/firewire/bebob/bebob_proc.c @@ -0,0 +1,123 @@ +/* + * bebob_proc.c - a part of driver for BeBoB based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +#include "./bebob.h" + +/* contents of information register */ +struct hw_info { + u64 manufacturer; + u32 protocol_ver; + u32 bld_ver; + u32 guid[2]; + u32 model_id; + u32 model_rev; + u64 fw_date; + u64 fw_time; + u32 fw_id; + u32 fw_ver; + u32 base_addr; + u32 max_size; + u64 bld_date; + u64 bld_time; +/* may not used in product + u64 dbg_date; + u64 dbg_time; + u32 dbg_id; + u32 dbg_version; +*/ +} __packed; + +static void +proc_read_hw_info(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) +{ + struct snd_bebob *bebob = entry->private_data; + struct hw_info *info; + int err; + + info = kzalloc(sizeof(struct hw_info), GFP_KERNEL); + if (info == NULL) + return; + + err = snd_bebob_read_block(bebob, 0, + info, sizeof(struct hw_info)); + if (err < 0) + goto end; + + snd_iprintf(buffer, "Manufacturer:\t%.8s\n", + (char *)&info->manufacturer); + snd_iprintf(buffer, "Protocol Ver:\t%d\n", info->protocol_ver); + snd_iprintf(buffer, "Build Ver:\t%d\n", info->bld_ver); + snd_iprintf(buffer, "GUID:\t\t0x%.8X%.8X\n", + info->guid[0], info->guid[1]); + snd_iprintf(buffer, "Model ID:\t0x%02X\n", info->model_id); + snd_iprintf(buffer, "Model Rev:\t%d\n", info->model_rev); + snd_iprintf(buffer, "Firmware Date:\t%.8s\n", (char *)&info->fw_date); + snd_iprintf(buffer, "Firmware Time:\t%.8s\n", (char *)&info->fw_time); + snd_iprintf(buffer, "Firmware ID:\t0x%X\n", info->fw_id); + snd_iprintf(buffer, "Firmware Ver:\t%d\n", info->fw_ver); + snd_iprintf(buffer, "Base Addr:\t0x%X\n", info->base_addr); + snd_iprintf(buffer, "Max Size:\t%d\n", info->max_size); + snd_iprintf(buffer, "Loader Date:\t%.8s\n", (char *)&info->bld_date); + snd_iprintf(buffer, "Loader Time:\t%.8s\n", (char *)&info->bld_time); + +end: + kfree(info); + return; +} + +static void +proc_read_formation(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) +{ + struct snd_bebob *bebob = entry->private_data; + struct snd_bebob_stream_formation *formation; + unsigned int i; + + snd_iprintf(buffer, "Output Stream from device:\n"); + snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n"); + formation = bebob->tx_stream_formations; + for (i = 0; i < 9; i += 1) { + snd_iprintf(buffer, + "\t%d\t%d\t%d\n", snd_bebob_rate_table[i], + formation[i].pcm, formation[i].midi); + } + + snd_iprintf(buffer, "Input Stream to device:\n"); + snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n"); + formation = bebob->rx_stream_formations; + for (i = 0; i < 9; i += 1) { + snd_iprintf(buffer, + "\t%d\t%d\t%d\n", snd_bebob_rate_table[i], + formation[i].pcm, formation[i].midi); + } + + return; +} + +void snd_bebob_proc_init(struct snd_bebob *bebob) +{ + struct snd_info_entry *entry; + + if (!snd_card_proc_new(bebob->card, "#hardware", &entry)) + snd_info_set_text_ops(entry, bebob, proc_read_hw_info); + + if (!snd_card_proc_new(bebob->card, "#formation", &entry)) + snd_info_set_text_ops(entry, bebob, proc_read_formation); + + return; +}

This commit adds the functionality to capture/playback MIDI message. MIDI message is multiplexed/demultiplexed into AMDTP stream.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/Kconfig | 1 + sound/firewire/bebob/Makefile | 1 + sound/firewire/bebob/bebob.c | 7 ++ sound/firewire/bebob/bebob.h | 3 + sound/firewire/bebob/bebob_midi.c | 172 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 184 insertions(+) create mode 100644 sound/firewire/bebob/bebob_midi.c

diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig index 5349652..c7987a0 100644 --- a/sound/firewire/Kconfig +++ b/sound/firewire/Kconfig @@ -63,6 +63,7 @@ config SND_SCS1X

config SND_BEBOB tristate "BridgeCo BeBoB chipset support" + select SND_RAWMIDI select SND_FIREWIRE_LIB help Say Y here to include support for FireWire devices based diff --git a/sound/firewire/bebob/Makefile b/sound/firewire/bebob/Makefile index bec01cd..c7aeef7 100644 --- a/sound/firewire/bebob/Makefile +++ b/sound/firewire/bebob/Makefile @@ -1,3 +1,4 @@ snd-bebob-objs := bebob_command.o bebob_stream.o bebob_proc.o bebob_control.o \ + bebob_midi.o \ bebob.o obj-m += snd-bebob.o diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c index 71a3896..89dc45b 100644 --- a/sound/firewire/bebob/bebob.c +++ b/sound/firewire/bebob/bebob.c @@ -177,6 +177,13 @@ snd_bebob_probe(struct fw_unit *unit, if (err < 0) goto error;

+ if ((bebob->midi_input_ports > 0) || + (bebob->midi_output_ports > 0)) { + err = snd_bebob_create_midi_devices(bebob); + if (err < 0) + goto error; + } + err = snd_bebob_create_control_devices(bebob); if (err < 0) goto error; diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h index d87999e..2775a73 100644 --- a/sound/firewire/bebob/bebob.h +++ b/sound/firewire/bebob/bebob.h @@ -31,6 +31,7 @@ #include <sound/initval.h> #include <sound/info.h> #include <sound/control.h> +#include <sound/rawmidi.h>

#include "../packets-buffer.h" #include "../iso-resources.h" @@ -153,6 +154,8 @@ void snd_bebob_proc_init(struct snd_bebob *bebob);

int snd_bebob_create_control_devices(struct snd_bebob *bebob);

+int snd_bebob_create_midi_devices(struct snd_bebob *bebob); + #define SND_BEBOB_DEV_ENTRY(vendor, model) \ { \ .match_flags = IEEE1394_MATCH_VENDOR_ID | \ diff --git a/sound/firewire/bebob/bebob_midi.c b/sound/firewire/bebob/bebob_midi.c new file mode 100644 index 0000000..56c7115 --- /dev/null +++ b/sound/firewire/bebob/bebob_midi.c @@ -0,0 +1,172 @@ +/* + * bebob_midi.c - a part of driver for BeBoB based devices + * Copyright (c) 2013 Takashi Sakamoto + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +#include "bebob.h" + +/* + * According to MMA/AMEI-027, MIDI stream is multiplexed with PCM stream in + * AMDTP packet. The data rate of MIDI message is much less than PCM so there + * is a little problem to suspend MIDI streams. + */ +static int midi_capture_open(struct snd_rawmidi_substream *substream) +{ + struct snd_bebob *bebob = substream->rmidi->private_data; + int err; + + err = snd_bebob_stream_start_duplex(bebob, &bebob->tx_stream, 0); + if (err < 0) + goto end; + + amdtp_stream_midi_add(&bebob->tx_stream, substream); +end: + return err; +} + +static int midi_playback_open(struct snd_rawmidi_substream *substream) +{ + struct snd_bebob *bebob = substream->rmidi->private_data; + int err; + + err = snd_bebob_stream_start_duplex(bebob, &bebob->rx_stream, 0); + if (err < 0) + goto end; + + amdtp_stream_midi_add(&bebob->rx_stream, substream); +end: + return err; +} + +static int midi_capture_close(struct snd_rawmidi_substream *substream) +{ + struct snd_bebob *bebob = substream->rmidi->private_data; + + amdtp_stream_midi_remove(&bebob->tx_stream, substream); + snd_bebob_stream_stop_duplex(bebob); + + return 0; +} + +static int midi_playback_close(struct snd_rawmidi_substream *substream) +{ + struct snd_bebob *bebob = substream->rmidi->private_data; + + amdtp_stream_midi_remove(&bebob->rx_stream, substream); + snd_bebob_stream_stop_duplex(bebob); + + return 0; +} + +static void midi_capture_trigger(struct snd_rawmidi_substream *substrm, int up) +{ + struct snd_bebob *bebob = substrm->rmidi->private_data; + unsigned long flags; + + spin_lock_irqsave(&bebob->lock, flags); + + if (up) + __set_bit(substrm->number, &bebob->tx_stream.midi_triggered); + else + __clear_bit(substrm->number, &bebob->tx_stream.midi_triggered); + + spin_unlock_irqrestore(&bebob->lock, flags); + + return; +} + +static void midi_playback_trigger(struct snd_rawmidi_substream *substrm, int up) +{ + struct snd_bebob *bebob = substrm->rmidi->private_data; + unsigned long flags; + + spin_lock_irqsave(&bebob->lock, flags); + + if (up) + __set_bit(substrm->number, &bebob->rx_stream.midi_triggered); + else + __clear_bit(substrm->number, &bebob->rx_stream.midi_triggered); + + spin_unlock_irqrestore(&bebob->lock, flags); + + return; +} + +static struct snd_rawmidi_ops midi_capture_ops = { + .open = midi_capture_open, + .close = midi_capture_close, + .trigger = midi_capture_trigger, +}; + +static struct snd_rawmidi_ops midi_playback_ops = { + .open = midi_playback_open, + .close = midi_playback_close, + .trigger = midi_playback_trigger, +}; + +static void set_midi_substream_names(struct snd_bebob *bebob, + struct snd_rawmidi_str *str) +{ + struct snd_rawmidi_substream *subs; + + list_for_each_entry(subs, &str->substreams, list) { + snprintf(subs->name, sizeof(subs->name), + "%s MIDI %d", bebob->card->shortname, subs->number + 1); + } +} + +int snd_bebob_create_midi_devices(struct snd_bebob *bebob) +{ + struct snd_rawmidi *rmidi; + struct snd_rawmidi_str *str; + int err; + + /* create midi ports */ + err = snd_rawmidi_new(bebob->card, bebob->card->driver, 0, + bebob->midi_output_ports, bebob->midi_input_ports, + &rmidi); + if (err < 0) + return err; + + snprintf(rmidi->name, sizeof(rmidi->name), + "%s MIDI", bebob->card->shortname); + rmidi->private_data = bebob; + + if (bebob->midi_input_ports > 0) { + rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT; + + snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, + &midi_capture_ops); + + str = &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]; + + set_midi_substream_names(bebob, str); + } + + if (bebob->midi_output_ports > 0) { + rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT; + + snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, + &midi_playback_ops); + + str = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]; + + set_midi_substream_names(bebob, str); + } + + if ((bebob->midi_output_ports > 0) && (bebob->midi_input_ports > 0)) + rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX; + + return 0; +}

This is for mixer/control application in user land. The application can lock/unlock kernel streaming or get notification at starting kernel streaming to use hwdep interface.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- include/uapi/sound/asound.h | 3 +- include/uapi/sound/firewire.h | 1 + sound/firewire/Kconfig | 1 + sound/firewire/bebob/Makefile | 2 +- sound/firewire/bebob/bebob.c | 5 + sound/firewire/bebob/bebob.h | 13 +++ sound/firewire/bebob/bebob_hwdep.c | 207 ++++++++++++++++++++++++++++++++++++ sound/firewire/bebob/bebob_midi.c | 10 ++ sound/firewire/bebob/bebob_pcm.c | 14 ++- sound/firewire/bebob/bebob_stream.c | 39 +++++++ 10 files changed, 290 insertions(+), 5 deletions(-) create mode 100644 sound/firewire/bebob/bebob_hwdep.c

diff --git a/include/uapi/sound/asound.h b/include/uapi/sound/asound.h index 9fc6219..d8bc723 100644 --- a/include/uapi/sound/asound.h +++ b/include/uapi/sound/asound.h @@ -94,9 +94,10 @@ enum { SNDRV_HWDEP_IFACE_HDA, /* HD-audio */ SNDRV_HWDEP_IFACE_USB_STREAM, /* direct access to usb stream */ SNDRV_HWDEP_IFACE_FW_DICE, /* TC DICE FireWire device */ + SNDRV_HWDEP_IFACE_FW_BEBOB, /* BridgeCo BeBoB based Device */

/* Don't forget to change the following: */ - SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_DICE + SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_BEBOB };

struct snd_hwdep_info { diff --git a/include/uapi/sound/firewire.h b/include/uapi/sound/firewire.h index 59f5961..c600b143 100644 --- a/include/uapi/sound/firewire.h +++ b/include/uapi/sound/firewire.h @@ -34,6 +34,7 @@ union snd_firewire_event { #define SNDRV_FIREWIRE_IOCTL_UNLOCK _IO('H', 0xfa)

#define SNDRV_FIREWIRE_TYPE_DICE 1 +#define SNDRV_FIREWIRE_TYPE_BEBOB 2 /* Fireworks, AV/C, RME, MOTU, ... */

struct snd_firewire_get_info { diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig index 7641772..c46578e 100644 --- a/sound/firewire/Kconfig +++ b/sound/firewire/Kconfig @@ -65,6 +65,7 @@ config SND_BEBOB tristate "BridgeCo BeBoB chipset support" select SND_RAWMIDI select SND_PCM + select SND_HWDEP select SND_FIREWIRE_LIB help Say Y here to include support for FireWire devices based diff --git a/sound/firewire/bebob/Makefile b/sound/firewire/bebob/Makefile index 30e79e6..81e14fa 100644 --- a/sound/firewire/bebob/Makefile +++ b/sound/firewire/bebob/Makefile @@ -1,4 +1,4 @@ snd-bebob-objs := bebob_command.o bebob_stream.o bebob_proc.o bebob_control.o \ - bebob_midi.o bebob_pcm.o \ + bebob_midi.o bebob_pcm.o bebob_hwdep.o \ bebob.o obj-m += snd-bebob.o diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c index 2fdd14b..219eac7 100644 --- a/sound/firewire/bebob/bebob.c +++ b/sound/firewire/bebob/bebob.c @@ -171,12 +171,17 @@ snd_bebob_probe(struct fw_unit *unit, bebob->card_index = -1; mutex_init(&bebob->mutex); spin_lock_init(&bebob->lock); + init_waitqueue_head(&bebob->hwdep_wait);

/* name device with communication */ err = name_device(bebob, entry->vendor_id); if (err < 0) goto error;

+ err = snd_bebob_create_hwdep_device(bebob); + if (err < 0) + goto error; + err = snd_bebob_create_pcm_devices(bebob); if (err < 0) goto error; diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h index 04842b2..3950b02 100644 --- a/sound/firewire/bebob/bebob.h +++ b/sound/firewire/bebob/bebob.h @@ -34,6 +34,8 @@ #include <sound/rawmidi.h> #include <sound/pcm.h> #include <sound/pcm_params.h> +#include <sound/firewire.h> +#include <sound/hwdep.h>

#include "../packets-buffer.h" #include "../iso-resources.h" @@ -79,6 +81,11 @@ struct snd_bebob { rx_stream_formations[SND_BEBOB_STRM_FMT_ENTRIES];

struct snd_ctl_elem_id *ctl_id_freq; + + /* for uapi */ + int dev_lock_count; + bool dev_lock_changed; + wait_queue_head_t hwdep_wait; };

static inline int @@ -152,6 +159,10 @@ int snd_bebob_stream_stop_duplex(struct snd_bebob *bebob); void snd_bebob_stream_update_duplex(struct snd_bebob *bebob); void snd_bebob_stream_destroy_duplex(struct snd_bebob *bebob);

+void snd_bebob_stream_lock_changed(struct snd_bebob *bebob); +int snd_bebob_stream_lock_try(struct snd_bebob *bebob); +void snd_bebob_stream_lock_release(struct snd_bebob *bebob); + void snd_bebob_proc_init(struct snd_bebob *bebob);

int snd_bebob_create_control_devices(struct snd_bebob *bebob); @@ -160,6 +171,8 @@ int snd_bebob_create_midi_devices(struct snd_bebob *bebob);

int snd_bebob_create_pcm_devices(struct snd_bebob *bebob);

+int snd_bebob_create_hwdep_device(struct snd_bebob *bebob); + #define SND_BEBOB_DEV_ENTRY(vendor, model) \ { \ .match_flags = IEEE1394_MATCH_VENDOR_ID | \ diff --git a/sound/firewire/bebob/bebob_hwdep.c b/sound/firewire/bebob/bebob_hwdep.c new file mode 100644 index 0000000..be423b7 --- /dev/null +++ b/sound/firewire/bebob/bebob_hwdep.c @@ -0,0 +1,207 @@ +/* + * fireworks_hwdep.c - a part of driver for Fireworks based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +/* + * This codes give three functionality. + * + * 1.get firewire node reference + * 2.lock/unlock stream + * dice driver implements the same functionality. + */ + +#include "bebob.h" + +static long +hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count, + loff_t *offset) +{ + struct snd_bebob *bebob = hwdep->private_data; + DEFINE_WAIT(wait); + union snd_firewire_event event; + + spin_lock_irq(&bebob->lock); + + while (!bebob->dev_lock_changed) { + prepare_to_wait(&bebob->hwdep_wait, &wait, TASK_INTERRUPTIBLE); + spin_unlock_irq(&bebob->lock); + schedule(); + finish_wait(&bebob->hwdep_wait, &wait); + if (signal_pending(current)) + return -ERESTARTSYS; + spin_lock_irq(&bebob->lock); + } + + memset(&event, 0, sizeof(event)); + if (bebob->dev_lock_changed) { + event.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS; + event.lock_status.status = (bebob->dev_lock_count > 0); + bebob->dev_lock_changed = false; + + count = min(count, (long)sizeof(event.lock_status)); + } + + spin_unlock_irq(&bebob->lock); + + if (copy_to_user(buf, &event, count)) + return -EFAULT; + + return count; +} + +static unsigned int +hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait) +{ + struct snd_bebob *bebob = hwdep->private_data; + unsigned int events; + + poll_wait(file, &bebob->hwdep_wait, wait); + + spin_lock_irq(&bebob->lock); + if (bebob->dev_lock_changed) + events = POLLIN | POLLRDNORM; + else + events = 0; + spin_unlock_irq(&bebob->lock); + + return events; +} + +static int +hwdep_get_info(struct snd_bebob *bebob, void __user *arg) +{ + struct fw_device *dev = fw_parent_device(bebob->unit); + struct snd_firewire_get_info info; + + memset(&info, 0, sizeof(info)); + info.type = SNDRV_FIREWIRE_TYPE_BEBOB; + info.card = dev->card->index; + *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); + *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); + strlcpy(info.device_name, dev_name(&dev->device), + sizeof(info.device_name)); + + if (copy_to_user(arg, &info, sizeof(info))) + return -EFAULT; + + return 0; +} + +static int +hwdep_lock(struct snd_bebob *bebob) +{ + int err; + + spin_lock_irq(&bebob->lock); + + if (bebob->dev_lock_count == 0) { + bebob->dev_lock_count = -1; + err = 0; + } else + err = -EBUSY; + + spin_unlock_irq(&bebob->lock); + + return err; +} + +static int +hwdep_unlock(struct snd_bebob *bebob) +{ + int err; + + spin_lock_irq(&bebob->lock); + + if (bebob->dev_lock_count == -1) { + bebob->dev_lock_count = 0; + err = 0; + } else + err = -EBADFD; + + spin_unlock_irq(&bebob->lock); + + return err; +} + +static int +hwdep_release(struct snd_hwdep *hwdep, struct file *file) +{ + struct snd_bebob *bebob = hwdep->private_data; + + spin_lock_irq(&bebob->lock); + if (bebob->dev_lock_count == -1) + bebob->dev_lock_count = 0; + spin_unlock_irq(&bebob->lock); + + return 0; +} + +static int +hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file, + unsigned int cmd, unsigned long arg) +{ + struct snd_bebob *bebob = hwdep->private_data; + + switch (cmd) { + case SNDRV_FIREWIRE_IOCTL_GET_INFO: + return hwdep_get_info(bebob, (void __user *)arg); + case SNDRV_FIREWIRE_IOCTL_LOCK: + return hwdep_lock(bebob); + case SNDRV_FIREWIRE_IOCTL_UNLOCK: + return hwdep_unlock(bebob); + default: + return -ENOIOCTLCMD; + } +} + +#ifdef CONFIG_COMPAT +static int +hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file, + unsigned int cmd, unsigned long arg) +{ + return hwdep_ioctl(hwdep, file, cmd, + (unsigned long)compat_ptr(arg)); +} +#else +#define hwdep_compat_ioctl NULL +#endif + +static const struct snd_hwdep_ops hwdep_ops = { + .read = hwdep_read, + .release = hwdep_release, + .poll = hwdep_poll, + .ioctl = hwdep_ioctl, + .ioctl_compat = hwdep_compat_ioctl, +}; + +int snd_bebob_create_hwdep_device(struct snd_bebob *bebob) +{ + struct snd_hwdep *hwdep; + int err; + + err = snd_hwdep_new(bebob->card, "BeBoB", 0, &hwdep); + if (err < 0) + goto end; + strcpy(hwdep->name, "BeBoB"); + hwdep->iface = SNDRV_HWDEP_IFACE_FW_BEBOB; + hwdep->ops = hwdep_ops; + hwdep->private_data = bebob; + hwdep->exclusive = true; +end: + return err; +} + diff --git a/sound/firewire/bebob/bebob_midi.c b/sound/firewire/bebob/bebob_midi.c index 56c7115..a5a4028 100644 --- a/sound/firewire/bebob/bebob_midi.c +++ b/sound/firewire/bebob/bebob_midi.c @@ -26,6 +26,10 @@ static int midi_capture_open(struct snd_rawmidi_substream *substream) struct snd_bebob *bebob = substream->rmidi->private_data; int err;

+ err = snd_bebob_stream_lock_try(bebob); + if (err < 0) + goto end; + err = snd_bebob_stream_start_duplex(bebob, &bebob->tx_stream, 0); if (err < 0) goto end; @@ -40,6 +44,10 @@ static int midi_playback_open(struct snd_rawmidi_substream *substream) struct snd_bebob *bebob = substream->rmidi->private_data; int err;

+ err = snd_bebob_stream_lock_try(bebob); + if (err < 0) + goto end; + err = snd_bebob_stream_start_duplex(bebob, &bebob->rx_stream, 0); if (err < 0) goto end; @@ -55,6 +63,7 @@ static int midi_capture_close(struct snd_rawmidi_substream *substream)

amdtp_stream_midi_remove(&bebob->tx_stream, substream); snd_bebob_stream_stop_duplex(bebob); + snd_bebob_stream_lock_release(bebob);

return 0; } @@ -65,6 +74,7 @@ static int midi_playback_close(struct snd_rawmidi_substream *substream)

amdtp_stream_midi_remove(&bebob->rx_stream, substream); snd_bebob_stream_stop_duplex(bebob); + snd_bebob_stream_lock_release(bebob);

return 0; } diff --git a/sound/firewire/bebob/bebob_pcm.c b/sound/firewire/bebob/bebob_pcm.c index 04913b2..c7cca80 100644 --- a/sound/firewire/bebob/bebob_pcm.c +++ b/sound/firewire/bebob/bebob_pcm.c @@ -239,29 +239,37 @@ pcm_open(struct snd_pcm_substream *substream) unsigned int sampling_rate; int err;

- err = pcm_init_hw_params(bebob, substream); + err = snd_bebob_stream_lock_try(bebob); if (err < 0) goto end;

+ err = pcm_init_hw_params(bebob, substream); + if (err < 0) + goto err_locked; + if (amdtp_stream_pcm_running(&bebob->tx_stream) || amdtp_stream_pcm_running(&bebob->rx_stream)) { err = snd_bebob_stream_get_rate(bebob, &sampling_rate); if (err < 0) - goto end; + goto err_locked;

substream->runtime->hw.rate_min = sampling_rate; substream->runtime->hw.rate_max = sampling_rate; }

snd_pcm_set_sync(substream); - end: return err; +err_locked: + snd_bebob_stream_lock_release(bebob); + return err; }

static int pcm_close(struct snd_pcm_substream *substream) { + struct snd_bebob *bebob = substream->private_data; + snd_bebob_stream_lock_release(bebob); return 0; }

diff --git a/sound/firewire/bebob/bebob_stream.c b/sound/firewire/bebob/bebob_stream.c index 773dffb..f2527bf 100644 --- a/sound/firewire/bebob/bebob_stream.c +++ b/sound/firewire/bebob/bebob_stream.c @@ -666,3 +666,42 @@ int snd_bebob_stream_discover(struct snd_bebob *bebob) end: return err; } + +void snd_bebob_stream_lock_changed(struct snd_bebob *bebob) +{ + bebob->dev_lock_changed = true; + wake_up(&bebob->hwdep_wait); +} + +int snd_bebob_stream_lock_try(struct snd_bebob *bebob) +{ + int err; + + spin_lock_irq(&bebob->lock); + + /* user land lock this */ + if (bebob->dev_lock_count < 0) { + err = -EBUSY; + goto end; + } + + /* this is the first time */ + if (bebob->dev_lock_count++ == 0) + snd_bebob_stream_lock_changed(bebob); + err = 0; +end: + spin_unlock_irq(&bebob->lock); + return err; +} + +void snd_bebob_stream_lock_release(struct snd_bebob *bebob) +{ + spin_lock_irq(&bebob->lock); + + if (WARN_ON(bebob->dev_lock_count <= 0)) + goto end; + if (--bebob->dev_lock_count == 0) + snd_bebob_stream_lock_changed(bebob); +end: + spin_unlock_irq(&bebob->lock); +}

This commit allows this driver to support all of models which M-Audio produces with BeBoB chipset. They are: - Firewire Solo - Firewire AudioPhile - Firewire 410 - Firewire 1814 - Ozonic - NRV10 - ProjectMix I/O - FirewireLightBridge

This commit adds M-Audio specific operations, quirks and functionalities. They are categorized to three parts.

1. send cue to load firmware This is for 'Firewire Audiophile', 'Firewire410', 'Firewire1814' and 'ProjectMix I/O'. With firmware version 5058 or later, they wait to receive a cue to load firmware just after powering on. With less firmware version, they wait to upload firmware binary blob so this driver can't handle this versions. This functionality can be implemented in user land but currently in kernel land for my convinience.

2. switching source of clock This if for 'Firewire Solo', 'Firewire Audiophile', 'Firewire410', 'Firewire1814' and'ProjectMix I/O'. They can switch source of clock with signal source command but the value of parameters is a bit different.

3. handling metering information This is all of models, mainly for my debugging. This information includes information for clock synchronization.

Firewire1814 and ProjectMix I/O has heavily customized BeBoB chipset. The usual operation to handle BeBoB chipset cannot be applied for them. For this reason, this commit add some model specific members in 'struct snd_bebob' and model specific functions.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/Kconfig | 2 + sound/firewire/bebob/Makefile | 1 + sound/firewire/bebob/bebob.c | 75 +++ sound/firewire/bebob/bebob.h | 21 + sound/firewire/bebob/bebob_control.c | 3 + sound/firewire/bebob/bebob_maudio.c | 910 +++++++++++++++++++++++++++++++++++ sound/firewire/bebob/bebob_stream.c | 22 +- 7 files changed, 1031 insertions(+), 3 deletions(-) create mode 100644 sound/firewire/bebob/bebob_maudio.c

diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig index c46578e..427def7 100644 --- a/sound/firewire/Kconfig +++ b/sound/firewire/Kconfig @@ -80,6 +80,8 @@ config SND_BEBOB * CME MatrixKFW * Phonic HB24U * BridgeCo RDAudio1/Audio5 + * M-Audio Firewire410/AudioPhile/Solo/Ozonic/NRV10 + * M-Audio Firewire1814/ProjectMix IO/ProfireLightBridge

To compile this driver as a module, choose M here: the module will be called snd-fireworks. diff --git a/sound/firewire/bebob/Makefile b/sound/firewire/bebob/Makefile index 81e14fa..2e87d02 100644 --- a/sound/firewire/bebob/Makefile +++ b/sound/firewire/bebob/Makefile @@ -1,4 +1,5 @@ snd-bebob-objs := bebob_command.o bebob_stream.o bebob_proc.o bebob_control.o \ bebob_midi.o bebob_pcm.o bebob_hwdep.o \ + bebob_maudio.o \ bebob.o obj-m += snd-bebob.o diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c index 7c3f1b3..576d801 100644 --- a/sound/firewire/bebob/bebob.c +++ b/sound/firewire/bebob/bebob.c @@ -50,6 +50,12 @@ static unsigned int devices_used; #define VEN_ACOUSTIC 0x00000002 #define VEN_CME 0x0000000a #define VEN_PHONIC 0x00001496 +#define VEN_MAUDIO1 0x00000d6c +#define VEN_MAUDIO2 0x000007f5 + +#define MODEL_MAUDIO_AUDIOPHILE_BOTH 0x00010060 +#define MODEL_MAUDIO_FW1814 0x00010071 +#define MODEL_MAUDIO_PROJECTMIX 0x00010091

static int name_device(struct snd_bebob *bebob, unsigned int vendor_id) @@ -82,6 +88,8 @@ name_device(struct snd_bebob *bebob, unsigned int vendor_id) strcpy(vendor, "CME"); else if (vendor_id == VEN_PHONIC) strcpy(vendor, "Phonic"); + else if ((vendor_id == VEN_MAUDIO1) || (vendor_id == VEN_MAUDIO2)) + strcpy(vendor, "M-Audio");

/* get model name */ err = fw_csr_string(bebob->unit->directory, CSR_MODEL, @@ -135,6 +143,20 @@ snd_bebob_card_free(struct snd_card *card) return; }

+static bool +check_audiophile_booted(struct fw_unit *unit) +{ + char name[24] = {0}; + + if (fw_csr_string(unit->directory, CSR_MODEL, name, sizeof(name)) < 0) + return false; + + if (strncmp(name, "FW Audiophile Bootloader", 15) == 0) + return false; + else + return true; +} + static int snd_bebob_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry) @@ -159,6 +181,18 @@ snd_bebob_probe(struct fw_unit *unit,

spec = (const struct snd_bebob_spec *)entry->driver_data;

+ /* if needed, load firmware and exit */ + if ((spec->load) && + ((entry->model_id != MODEL_MAUDIO_AUDIOPHILE_BOTH) || + (!check_audiophile_booted(unit)))) { + spec->load(unit, entry); + dev_info(&unit->device, + "loading firmware for 0x%08X:0x%08X\n", + entry->vendor_id, entry->model_id); + err = 0; + goto end; + } + /* create card */ err = snd_card_create(index[card_index], id[card_index], THIS_MODULE, sizeof(struct snd_bebob), &card); @@ -177,6 +211,16 @@ snd_bebob_probe(struct fw_unit *unit, spin_lock_init(&bebob->lock); init_waitqueue_head(&bebob->hwdep_wait);

+ /* discover */ + if (entry->model_id == MODEL_MAUDIO_FW1814) + err = snd_bebob_maudio_special_discover(bebob, true); + else if (entry->model_id == MODEL_MAUDIO_PROJECTMIX) + err = snd_bebob_maudio_special_discover(bebob, false); + else + err = snd_bebob_stream_discover(bebob); + if (err < 0) + goto error; + /* name device with communication */ err = name_device(bebob, entry->vendor_id); if (err < 0) @@ -237,6 +281,11 @@ static void snd_bebob_update(struct fw_unit *unit) { struct snd_bebob *bebob = dev_get_drvdata(&unit->device); + + /* this is for firmware bootloader */ + if (bebob == NULL) + return; + fcp_bus_reset(bebob->unit); snd_bebob_stream_update_duplex(bebob); } @@ -245,6 +294,11 @@ snd_bebob_update(struct fw_unit *unit) static void snd_bebob_remove(struct fw_unit *unit) { struct snd_bebob *bebob = dev_get_drvdata(&unit->device); + + /* this is for firmware bootloader */ + if (bebob == NULL) + return; + snd_bebob_stream_destroy_duplex(bebob); snd_card_disconnect(bebob->card); snd_card_free_when_closed(bebob->card); @@ -287,6 +341,27 @@ static const struct ieee1394_device_id snd_bebob_id_table[] = { SND_BEBOB_DEV_ENTRY(VEN_CME, 0x00030000, spec_normal), /* Phonic, HB24U */ SND_BEBOB_DEV_ENTRY(VEN_PHONIC, 0x00000000, spec_normal), + /* M-Audio, Ozonic */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, 0x0000000a, maudio_ozonic_spec), + /* M-Audio, Firewire 410. */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO2, 0x00010058, maudio_bootloader_spec), + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO2, 0x00010046, maudio_fw410_spec), + /* M-Audio, Firewire Audiophile, both of bootloader and firmware */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, MODEL_MAUDIO_AUDIOPHILE_BOTH, + maudio_audiophile_spec), + /* M-Audio, Firewire Solo */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, 0x00010062, maudio_solo_spec), + /* M-Audio NRV10 */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, 0x00010081, maudio_nrv10_spec), + /* Firewire 1814 */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, 0x00010070, maudio_bootloader_spec), + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, MODEL_MAUDIO_FW1814, + maudio_special_spec), + /* M-Audio ProjectMix */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, MODEL_MAUDIO_PROJECTMIX, + maudio_special_spec), + /* M-Audio, ProFireLightbridge */ + SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, 0x000100a1, spec_normal), {} }; MODULE_DEVICE_TABLE(ieee1394, snd_bebob_id_table); diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h index b35fc52..fb9d99d 100644 --- a/sound/firewire/bebob/bebob.h +++ b/sound/firewire/bebob/bebob.h @@ -113,6 +113,15 @@ struct snd_bebob { int dev_lock_count; bool dev_lock_changed; wait_queue_head_t hwdep_wait; + + /* for M-Audio special devices */ + bool maudio_special_quirk; + bool maudio_is1814; + unsigned int clk_src; + unsigned int dig_in_iface; + unsigned int dig_in_fmt; + unsigned int dig_out_fmt; + unsigned int clk_lock; };

static inline int @@ -214,6 +223,18 @@ int snd_bebob_create_pcm_devices(struct snd_bebob *bebob);

int snd_bebob_create_hwdep_device(struct snd_bebob *bebob);

+/* device specific operations */ +int snd_bebob_maudio_special_discover(struct snd_bebob *bebob, bool is1814); +int snd_bebob_maudio_special_add_controls(struct snd_bebob *bebob); + +extern struct snd_bebob_spec maudio_bootloader_spec; +extern struct snd_bebob_spec maudio_special_spec; +extern struct snd_bebob_spec maudio_nrv10_spec; +extern struct snd_bebob_spec maudio_fw410_spec; +extern struct snd_bebob_spec maudio_audiophile_spec; +extern struct snd_bebob_spec maudio_solo_spec; +extern struct snd_bebob_spec maudio_ozonic_spec; + #define SND_BEBOB_DEV_ENTRY(vendor, model, private_data) \ { \ .match_flags = IEEE1394_MATCH_VENDOR_ID | \ diff --git a/sound/firewire/bebob/bebob_control.c b/sound/firewire/bebob/bebob_control.c index 3b311c3..87c50a37 100644 --- a/sound/firewire/bebob/bebob_control.c +++ b/sound/firewire/bebob/bebob_control.c @@ -323,6 +323,9 @@ int snd_bebob_create_control_devices(struct snd_bebob *bebob) if (err < 0) goto end; } + + if (bebob->maudio_special_quirk) + err = snd_bebob_maudio_special_add_controls(bebob); end: return err; } diff --git a/sound/firewire/bebob/bebob_maudio.c b/sound/firewire/bebob/bebob_maudio.c new file mode 100644 index 0000000..8afc835 --- /dev/null +++ b/sound/firewire/bebob/bebob_maudio.c @@ -0,0 +1,910 @@ +/* + * bebob_maudio.c - a part of driver for BeBoB based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +#include "./bebob.h" + +/* + * NOTE: + * For Firewire 410 and Firewire Audiophile, this module requests firmware + * version 5058 or later. With former version, BeBoB chipset needs downloading + * firmware and the driver should do this. To do this with ALSA, I need to + * examinate whether it's OK or not to include firmware binary blob to + * alsa-firmware package. With later version, the firmware is in ROM of chipset + * and the driver just send a cue to load it when probing the device. This cue + * is sent just once. + * + * For streaming, both of output and input streams are needed for Firewire 410 + * and Ozonic. The single stream is OK for the other devices even if the clock + * source is not SYT-Match (I note no devices use SYT-Match). + * + * Without streaming, the devices except for Firewire Audiophile can mix any + * input and output. For this purpose, use ffado-mixer. Audiophile need to + * any stream for this purpose. + * + * Firewire 1814 and ProjectMix I/O uses special firmware. It will be freezed + * if receiving any commands which the firmware can't understand. These devices + * utilize completely different system to control. It is write transaction + * directly into a certain address. All of addresses for mixer functionality is + * between 0xffc700700000 to 0xffc70070009c. + */ + +#define MAUDIO_BOOTLOADER_CUE1 0x01000000 +#define MAUDIO_BOOTLOADER_CUE2 0x00001101 +#define MAUDIO_BOOTLOADER_CUE3 0x00000000 + +#define MAUDIO_SPECIFIC_ADDRESS 0xffc700000000 + +#define METER_OFFSET 0x00600000 + +/* some device has sync info after metering data */ +#define METER_SIZE_SPECIAL 84 /* with sync info */ +#define METER_SIZE_FW410 76 /* with sync info */ +#define METER_SIZE_AUDIOPHILE 60 /* with sync info */ +#define METER_SIZE_SOLO 52 /* with sync info */ +#define METER_SIZE_OZONIC 48 +#define METER_SIZE_NRV10 80 + +/* labels for metering */ +#define ANA_IN "Analog In" +#define ANA_OUT "Analog Out" +#define DIG_IN "Digital In" +#define SPDIF_IN "S/PDIF In" +#define ADAT_IN "ADAT In" +#define DIG_OUT "Digital Out" +#define SPDIF_OUT "S/PDIF Out" +#define ADAT_OUT "ADAT Out" +#define STRM_IN "Stream In" +#define AUX_OUT "Aux Out" +#define HP_OUT "HP Out" +/* for NRV */ +#define UNKNOWN_METER "Unknown" + +/* + * FW1814/ProjectMix don't use AVC for control. The driver cannot refer to + * current parameters by asynchronous transaction. The driver is allowed to + * write transaction so MUST remember the current values. + */ +#define MAUDIO_CONTROL_OFFSET 0x00700000 + +/* If we make any transaction to load firmware, the operation may failed. */ +/* TODO: change snd-firewire-lib and use it */ +static int +run_a_transaction(struct fw_unit *unit, int tcode, + u64 offset, void *buffer, size_t length) +{ + struct fw_device *device = fw_parent_device(unit); + int generation, rcode; + + generation = device->generation; + smp_rmb(); /* node id vs. generation*/ + rcode = fw_run_transaction(device->card, tcode, + device->node_id, generation, + device->max_speed, offset, + buffer, length); + if (rcode == RCODE_COMPLETE) + return 0; + + dev_err(&unit->device, "Failed to send a queue to load firmware\n"); + return -EIO; +} + +/* + * For some M-Audio devices, this module just send cue to load + * firmware. After loading, the device generates bus reset and + * newly detected. + */ +static int +firmware_load(struct fw_unit *unit, const struct ieee1394_device_id *entry) +{ + __be32 cues[3]; + + cues[0] = cpu_to_be32(MAUDIO_BOOTLOADER_CUE1); + cues[1] = cpu_to_be32(MAUDIO_BOOTLOADER_CUE2); + cues[2] = cpu_to_be32(MAUDIO_BOOTLOADER_CUE3); + + return run_a_transaction(unit, TCODE_WRITE_BLOCK_REQUEST, + BEBOB_ADDR_REG_REQ, cues, sizeof(cues)); +} + +static inline int +get_meter(struct snd_bebob *bebob, void *buf, unsigned int size) +{ + return snd_fw_transaction(bebob->unit, TCODE_READ_BLOCK_REQUEST, + MAUDIO_SPECIFIC_ADDRESS + METER_OFFSET, + buf, size, 0); +} + +/* + * BeBoB don't tell drivers to detect digital input, just show clock sync or not. + */ +static int +check_clk_sync(struct snd_bebob *bebob, unsigned int size, bool *sync) +{ + int err; + u8 *buf; + + buf = kmalloc(size, GFP_KERNEL); + if (buf == NULL) + return -ENOMEM; + + err = get_meter(bebob, buf, size); + if (err < 0) + goto end; + + /* if synced, this value is the same of SFC of FDF in CIP header */ + *sync = (buf[size - 2] != 0xff); + err = 0; +end: + kfree(buf); + return err; +} + +/* + * dig_fmt: 0x00:S/PDIF, 0x01:ADAT + * clk_lock: 0x00:unlock, 0x01:lock + */ +static int +special_clk_set_params(struct snd_bebob *bebob, unsigned int clk_src, + unsigned int dig_in_fmt, unsigned int dig_out_fmt, + unsigned int clk_lock) +{ + int err; + u8 *buf; + + buf = kmalloc(12, GFP_KERNEL); + if (buf == NULL) + return -ENOMEM; + + buf[0] = 0x00; /* CONTROL */ + buf[1] = 0xff; /* UNIT */ + buf[2] = 0x00; /* vendor dependent */ + buf[3] = 0x04; /* company ID high */ + buf[4] = 0x00; /* company ID middle */ + buf[5] = 0x04; /* company ID low */ + buf[6] = 0xff & clk_src; /* clock source */ + buf[7] = 0xff & dig_in_fmt; /* input digital format */ + buf[8] = 0xff & dig_out_fmt; /* output digital format */ + buf[9] = 0xff & clk_lock; /* lock these settings */ + buf[10] = 0x00; /* padding */ + buf[11] = 0x00; /* padding */ + + /* do transaction and check buf[1-9] are the same against command */ + err = fcp_avc_transaction(bebob->unit, buf, 12, buf, 12, + BIT(1) | BIT(2) | BIT(3) | BIT(4) | + BIT(5) | BIT(6) | BIT(7) | BIT(8) | + BIT(9)); + if (err < 0) + goto end; + if ((err < 6) || (buf[0] != 0x09)) { + dev_err(&bebob->unit->device, + "failed to set clock params\n"); + err = -EIO; + goto end; + } + + bebob->clk_src = buf[6]; + /* handle both of input and output in this member */ + bebob->dig_in_fmt = buf[7]; + bebob->dig_out_fmt = buf[8]; + bebob->clk_lock = buf[9]; + + err = 0; +end: + kfree(buf); + return err; +} +/* + * For special customized devices. + * The driver can't receive response from this firmware frequently. + * So need to reduce execution of command. + */ +static void +special_stream_formation_set(struct snd_bebob *bebob) +{ + unsigned int i; + + /* + * the stream formation is different depending on digital interface + */ + if (bebob->dig_in_fmt== 0x01) { + bebob->tx_stream_formations[3].pcm = 16; + bebob->tx_stream_formations[4].pcm = 16; + bebob->tx_stream_formations[5].pcm = 12; + bebob->tx_stream_formations[6].pcm = 12; + if (bebob->maudio_is1814) { + bebob->tx_stream_formations[7].pcm = 2; + bebob->tx_stream_formations[8].pcm = 2; + } + } else { + bebob->tx_stream_formations[3].pcm = 10; + bebob->tx_stream_formations[4].pcm = 10; + bebob->tx_stream_formations[5].pcm = 10; + bebob->tx_stream_formations[6].pcm = 10; + if (bebob->maudio_is1814) { + bebob->tx_stream_formations[7].pcm = 2; + bebob->tx_stream_formations[8].pcm = 2; + } + } + + if (bebob->dig_out_fmt == 0x01) { + bebob->rx_stream_formations[3].pcm = 12; + bebob->rx_stream_formations[4].pcm = 12; + bebob->rx_stream_formations[5].pcm = 8; + bebob->rx_stream_formations[6].pcm = 8; + if (bebob->maudio_is1814) { + bebob->rx_stream_formations[7].pcm = 4; + bebob->rx_stream_formations[8].pcm = 4; + } + } else { + bebob->rx_stream_formations[3].pcm = 6; + bebob->rx_stream_formations[4].pcm = 6; + bebob->rx_stream_formations[5].pcm = 6; + bebob->rx_stream_formations[6].pcm = 6; + if (bebob->maudio_is1814) { + bebob->rx_stream_formations[7].pcm = 4; + bebob->rx_stream_formations[8].pcm = 4; + } + } + + for (i = 3; i < SND_BEBOB_STRM_FMT_ENTRIES; i++) { + bebob->tx_stream_formations[i].midi = 1; + bebob->rx_stream_formations[i].midi = 1; + if ((i > 7) && (bebob->maudio_is1814)) + break; + } +} + +int +snd_bebob_maudio_special_discover(struct snd_bebob *bebob, bool is1814) +{ + int err; + + bebob->maudio_is1814 = is1814; + + /* initialize these parameters because doesn't allow driver to ask */ + err = special_clk_set_params(bebob, 0x03, 0x00, 0x00, 0x00); + if (err < 0) { + dev_err(&bebob->unit->device, + "failed to initialize clock params\n"); + } + + err = avc_audio_get_selector(bebob->unit, 0x00, 0x04, + &bebob->dig_in_iface); + if (err < 0) { + dev_err(&bebob->unit->device, + "failed to get current dig iface."); + } + + special_stream_formation_set(bebob); + + if (bebob->maudio_is1814) { + bebob->midi_input_ports = 1; + bebob->midi_output_ports = 1; + } else { + bebob->midi_input_ports = 2; + bebob->midi_output_ports = 2; + } + + bebob->maudio_special_quirk = true; + + return 0; +} +/* + * Input plug shows actual rate. Output plug is needless for this purpose. + */ +static int special_clk_get_freq(struct snd_bebob *bebob, unsigned int *rate) +{ + return snd_bebob_get_rate(bebob, rate, AVC_GENERAL_PLUG_DIR_IN); +} +static char *special_clk_src_labels[] = { + SND_BEBOB_CLOCK_INTERNAL " with Digital Mute", "Digital", + "Word Clock", SND_BEBOB_CLOCK_INTERNAL}; +static int +special_clk_src_get(struct snd_bebob *bebob, unsigned int *id) +{ + *id = bebob->clk_src; + return 0; +} +static int +special_clk_src_set(struct snd_bebob *bebob, unsigned int id) +{ + return special_clk_set_params(bebob, id, + bebob->dig_in_fmt, bebob->dig_out_fmt, + bebob->clk_lock); +} +static int +special_clk_synced(struct snd_bebob *bebob, bool *synced) +{ + return check_clk_sync(bebob, METER_SIZE_SPECIAL, synced); +} + +static char *special_meter_labels[] = { + ANA_IN, ANA_IN, ANA_IN, ANA_IN, + SPDIF_IN, + ADAT_IN, ADAT_IN, ADAT_IN, ADAT_IN, + ANA_OUT, ANA_OUT, + SPDIF_OUT, + ADAT_OUT, ADAT_OUT, ADAT_OUT, ADAT_OUT, + HP_OUT, HP_OUT, + AUX_OUT +}; +static int +special_meter_get(struct snd_bebob *bebob, u32 *target, unsigned int size) +{ + u16 *buf; + unsigned int i, c, channels; + int err; + + channels = ARRAY_SIZE(special_meter_labels) * 2; + if (size < channels * sizeof(u32)) + return -EINVAL; + + /* omit last 5 bytes because it's clock info. */ + buf = kmalloc(METER_SIZE_SPECIAL - 4, GFP_KERNEL); + if (buf == NULL) + return -ENOMEM; + + err = get_meter(bebob, (void *)buf, METER_SIZE_SPECIAL - 4); + if (err < 0) + goto end; + + /* some channels are not used and convert u16 to u32 */ + for (i = 0, c = 2; c < channels + 2; c++) + target[i++] = be16_to_cpu(buf[c]) << 8; +end: + kfree(buf); + return err; +} + +static char *special_dig_iface_labels[] = { + """S/PDIF Optical", "S/PDIF Coaxial", "ADAT Optical" +}; +static int special_dig_in_iface_info(struct snd_kcontrol *kctl, + struct snd_ctl_elem_info *einf) +{ + einf->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; + einf->count = 1; + einf->value.enumerated.items = ARRAY_SIZE(special_dig_iface_labels); + + if (einf->value.enumerated.item >= einf->value.enumerated.items) + einf->value.enumerated.item = einf->value.enumerated.items - 1; + + strcpy(einf->value.enumerated.name, + special_dig_iface_labels[einf->value.enumerated.item]); + + return 0; +} +static int special_dig_in_iface_get(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *uval) +{ + struct snd_bebob *bebob = snd_kcontrol_chip(kctl); + + /* encoded id for user value */ + uval->value.enumerated.item[0] = + (bebob->dig_in_fmt << 1) | (bebob->dig_in_iface & 0x01); + + return 0; +} +static int special_dig_in_iface_set(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *uval) +{ + struct snd_bebob *bebob = snd_kcontrol_chip(kctl); + unsigned int id, dig_in_fmt, dig_in_iface; + int err; + + id = uval->value.enumerated.item[0]; + + /* decode user value */ + dig_in_fmt = (id >> 1) & 0x01; + dig_in_iface = id & 0x01; + + err = special_clk_set_params(bebob, bebob->clk_src, dig_in_fmt, + bebob->dig_out_fmt, bebob->clk_lock); + if ((err < 0) || (bebob->dig_in_fmt > 0)) /* ADAT */ + goto end; + + err = avc_audio_set_selector(bebob->unit, 0x00, 0x04, dig_in_iface); + if (err < 0) + goto end; + + bebob->dig_in_iface = dig_in_iface; +end: + special_stream_formation_set(bebob); + return err; +} +static struct snd_kcontrol_new special_dig_in_iface = { + .name = "Digital Input Interface", + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, + .info = special_dig_in_iface_info, + .get = special_dig_in_iface_get, + .put = special_dig_in_iface_set +}; + +static int special_dig_out_iface_info(struct snd_kcontrol *kctl, + struct snd_ctl_elem_info *einf) +{ + einf->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; + einf->count = 1; + einf->value.enumerated.items = ARRAY_SIZE(special_dig_iface_labels) - 1; + + if (einf->value.enumerated.item >= einf->value.enumerated.items) + einf->value.enumerated.item = einf->value.enumerated.items - 1; + + strcpy(einf->value.enumerated.name, + special_dig_iface_labels[einf->value.enumerated.item + 1]); + + return 0; +} +static int special_dig_out_iface_get(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *uval) +{ + struct snd_bebob *bebob = snd_kcontrol_chip(kctl); + uval->value.enumerated.item[0] = bebob->dig_out_fmt; + return 0; +} +static int special_dig_out_iface_set(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *uval) +{ + struct snd_bebob *bebob = snd_kcontrol_chip(kctl); + unsigned int id; + int err; + + id = uval->value.enumerated.item[0]; + + err = special_clk_set_params(bebob, bebob->clk_src, bebob->dig_in_fmt, + id, bebob->clk_lock); + if (err < 0) + goto end; + + special_stream_formation_set(bebob); +end: + return err; +} +static struct snd_kcontrol_new special_dig_out_iface = { + .name = "Digital Output Interface", + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, + .info = special_dig_out_iface_info, + .get = special_dig_out_iface_get, + .put = special_dig_out_iface_set +}; + +int snd_bebob_maudio_special_add_controls(struct snd_bebob *bebob) +{ + struct snd_kcontrol *kctl; + int err; + + kctl = snd_ctl_new1(&special_dig_in_iface, bebob); + err = snd_ctl_add(bebob->card, kctl); + if (err < 0) + goto end; + + kctl = snd_ctl_new1(&special_dig_out_iface, bebob); + err = snd_ctl_add(bebob->card, kctl); +end: + return err; +} + +/* Firewire 410 specific controls */ +static char *fw410_clk_src_labels[] = { + SND_BEBOB_CLOCK_INTERNAL, "Digital Optical", "Digital Coaxial" +}; +static int +fw410_clk_src_get(struct snd_bebob *bebob, unsigned int *id) +{ + int err; + unsigned int stype, sid, pid; + + err = avc_ccm_get_sig_src(bebob->unit, + &stype, &sid, &pid, 0x0c, 0x00, 0x01); + if (err < 0) + goto end; + + *id = 0; + if ((stype == 0x1f) && (sid == 0x07)) { + if (pid == 0x82) + *id = 2; + else if (pid == 0x83) + *id = 1; + } +end: + return err; +} +static int +fw410_clk_src_set(struct snd_bebob *bebob, unsigned int id) +{ + unsigned int stype, sid, pid; + + if (id == 0) { + stype = 0x0c; + sid = 0x00; + pid = 0x01; + } else if (id == 1) { + stype = 0x1f; + sid = 0x07; + pid = 0x83; + } else { + stype = 0x1f; + sid = 0x07; + pid = 0x82; + } + + return avc_ccm_set_sig_src(bebob->unit, + stype, sid, pid, 0x0c, 0x00, 0x01); +} +static int +fw410_clk_synced(struct snd_bebob *bebob, bool *synced) +{ + return check_clk_sync(bebob, METER_SIZE_FW410, synced); +} +static char *fw410_meter_labels[] = { + ANA_IN, DIG_IN, + ANA_OUT, ANA_OUT, ANA_OUT, ANA_OUT, DIG_OUT, + HP_OUT +}; +static int +fw410_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size) +{ + + unsigned int c, channels; + int err; + + channels = ARRAY_SIZE(fw410_meter_labels) * 2; + if (size < channels * sizeof(u32)) + return -EINVAL; + + /* omit last 4 bytes because it's clock info. */ + err = get_meter(bebob, (void *)buf, size); + if (err < 0) + goto end; + + for (c = 0; c < channels; c++) + buf[c] = be32_to_cpu(buf[c]); +end: + return err; +} + +/* Firewire Audiophile specific controls */ +static char *audiophile_clk_src_labels[] = { + SND_BEBOB_CLOCK_INTERNAL, "Digital Coaxial" +}; +static int +audiophile_clk_src_get(struct snd_bebob *bebob, unsigned int *id) +{ + unsigned int stype, sid, pid; + int err; + + err = avc_ccm_get_sig_src(bebob->unit, + &stype, &sid, &pid, 0x0c, 0x00, 0x01); + if (err < 0) + goto end; + + if ((stype == 0x1f) && (sid == 0x07) && (pid == 0x82)) + *id = 1; + else + *id = 0; +end: + return err; +} +static int +audiophile_clk_src_set(struct snd_bebob *bebob, unsigned int id) +{ + unsigned int stype, sid, pid; + + if (id == 0) { + stype = 0x0c; + sid = 0x00; + pid = 0x01; + } else { + stype = 0x1f; + sid = 0x07; + pid = 0x82; + } + + return avc_ccm_set_sig_src(bebob->unit, + stype, sid, pid, 0x0c, 0x00, 0x01); +} +static int +audiophile_clk_synced(struct snd_bebob *bebob, bool *synced) +{ + return check_clk_sync(bebob, METER_SIZE_AUDIOPHILE, synced); +} +static char *audiophile_meter_labels[] = { + ANA_IN, DIG_IN, + ANA_OUT, ANA_OUT, DIG_OUT, + HP_OUT, AUX_OUT, +}; +static int +audiophile_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size) +{ + unsigned int c, channels; + int err; + + channels = ARRAY_SIZE(audiophile_meter_labels) * 2; + if (size < channels * sizeof(u32)) + return -EINVAL; + + /* omit last 4 bytes because it's clock info. */ + err = get_meter(bebob, (void *)buf, size); + if (err < 0) + goto end; + + for (c = 0; c < channels; c++) + buf[c] = be32_to_cpu(buf[c]); +end: + return err; +} + +/* Firewire Solo specific controls */ +static char *solo_clk_src_labels[] = { + SND_BEBOB_CLOCK_INTERNAL, "Digital Coaxial" +}; +static int +solo_clk_src_get(struct snd_bebob *bebob, unsigned int *id) +{ + unsigned int stype, sid, pid; + int err; + + err = avc_ccm_get_sig_src(bebob->unit, + &stype, &sid, &pid, 0x0c, 0x00, 0x01); + if (err < 0) + goto end; + + if ((stype == 0x1f) && (sid = 0x07) && (pid== 0x81)) + *id = 1; + else + *id = 0; +end: + return err; +} +static int +solo_clk_src_set(struct snd_bebob *bebob, unsigned int id) +{ + unsigned int stype, sid, pid; + + if (id == 0) { + stype = 0x0c; + sid = 0x00; + pid = 0x01; + } else { + stype = 0x1f; + sid = 0x07; + pid = 0x81; + } + + return avc_ccm_set_sig_src(bebob->unit, + stype, sid, pid, 0x0c, 0x00, 0x01); +} +static int +solo_clk_synced(struct snd_bebob *bebob, bool *synced) +{ + return check_clk_sync(bebob, METER_SIZE_SOLO, synced); +} +static char *solo_meter_labels[] = { + ANA_IN, DIG_IN, + STRM_IN, STRM_IN, + ANA_OUT, DIG_OUT +}; +static int +solo_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size) +{ + unsigned int c; + int err; + u32 tmp; + + if (size < ARRAY_SIZE(solo_meter_labels) * 2 * sizeof(u32)) + return -ENOMEM; + + /* omit last 4 bytes because it's clock info. */ + err = get_meter(bebob, (void *)buf, size); + if (err < 0) + goto end; + + c = 0; + do + buf[c] = be32_to_cpu(buf[c]); + while (++c < 4); + + /* swap stream channels because inverted */ + tmp = be32_to_cpu(buf[c]); + buf[c] = be32_to_cpu(buf[c + 2]); + buf[c + 2] = tmp; + tmp = be32_to_cpu(buf[c + 1]); + buf[c + 1] = be32_to_cpu(buf[c + 3]); + buf[c + 3] = tmp; + + c += 4; + do + buf[c] = be32_to_cpu(buf[c]); + while (++c < 12); +end: + return err; +} + +/* Ozonic specific controls */ +static char *ozonic_meter_labels[] = { + ANA_IN, ANA_IN, + STRM_IN, STRM_IN, + ANA_OUT, ANA_OUT +}; +static int +ozonic_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size) +{ + unsigned int c, channels; + int err; + + channels = ARRAY_SIZE(ozonic_meter_labels) * 2; + if (size < channels * sizeof(u32)) + return -EINVAL; + + err = get_meter(bebob, (void *)buf, size); + if (err < 0) + goto end; + + for (c = 0; c < channels; c++) + buf[c] = be32_to_cpu(buf[c]); +end: + return err; +} + +/* NRV10 specific controls */ +/* TODO: need testers. this is based on my assumption */ +static char *nrv10_meter_labels[] = { + ANA_IN, ANA_IN, ANA_IN, ANA_IN, + DIG_IN, + ANA_OUT, ANA_OUT, ANA_OUT, ANA_OUT, + DIG_IN +}; +static int +nrv10_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size) +{ + unsigned int c, channels; + int err; + + channels = ARRAY_SIZE(nrv10_meter_labels) * 2; + if (size < channels * sizeof(u32)) + return -EINVAL; + + err = get_meter(bebob, (void *)buf, size); + if (err < 0) + goto end; + + for (c = 0; c < channels; c++) + buf[c] = be32_to_cpu(buf[c]); +end: + return err; +} + + +/* BeBoB bootloader specification */ +struct snd_bebob_spec maudio_bootloader_spec = { + .load = &firmware_load, + .clock = NULL, +}; + +/* for special customized devices */ +static struct snd_bebob_clock_spec special_clk_spec = { + .num = ARRAY_SIZE(special_clk_src_labels), + .labels = special_clk_src_labels, + .get_src = &special_clk_src_get, + .set_src = &special_clk_src_set, + .get_freq = &special_clk_get_freq, + .set_freq = &snd_bebob_stream_set_rate, + .synced = &special_clk_synced +}; +static struct snd_bebob_meter_spec special_meter_spec = { + .num = ARRAY_SIZE(special_meter_labels), + .labels = special_meter_labels, + .get = &special_meter_get +}; +struct snd_bebob_spec maudio_special_spec = { + .load = NULL, + .clock = &special_clk_spec, + .meter = &special_meter_spec +}; + +/* Firewire 410 specification */ +static struct snd_bebob_clock_spec fw410_clk_spec = { + .num = ARRAY_SIZE(fw410_clk_src_labels), + .labels = fw410_clk_src_labels, + .get_src = &fw410_clk_src_get, + .set_src = &fw410_clk_src_set, + .get_freq = &snd_bebob_stream_get_rate, + .set_freq = &snd_bebob_stream_set_rate, + .synced = &fw410_clk_synced +}; +static struct snd_bebob_meter_spec fw410_meter_spec = { + .num = ARRAY_SIZE(fw410_meter_labels), + .labels = fw410_meter_labels, + .get = &fw410_meter_get +}; +struct snd_bebob_spec maudio_fw410_spec = { + .load = NULL, + .clock = &fw410_clk_spec, + .meter = &fw410_meter_spec +}; + +/* Firewire Audiophile specification */ +static struct snd_bebob_clock_spec audiophile_clk_spec = { + .num = ARRAY_SIZE(audiophile_clk_src_labels), + .labels = audiophile_clk_src_labels, + .get_src = &audiophile_clk_src_get, + .set_src = &audiophile_clk_src_set, + .get_freq = &snd_bebob_stream_get_rate, + .set_freq = &snd_bebob_stream_set_rate, + .synced = &audiophile_clk_synced +}; +static struct snd_bebob_meter_spec audiophile_meter_spec = { + .num = ARRAY_SIZE(audiophile_meter_labels), + .labels = audiophile_meter_labels, + .get = &audiophile_meter_get +}; +struct snd_bebob_spec maudio_audiophile_spec = { + .load = &firmware_load, + .clock = &audiophile_clk_spec, + .meter = &audiophile_meter_spec +}; + +/* Firewire Solo specification */ +static struct snd_bebob_clock_spec solo_clk_spec = { + .num = ARRAY_SIZE(solo_clk_src_labels), + .labels = solo_clk_src_labels, + .get_src = &solo_clk_src_get, + .set_src = &solo_clk_src_set, + .get_freq = &snd_bebob_stream_get_rate, + .set_freq = &snd_bebob_stream_set_rate, + .synced = &solo_clk_synced +}; +static struct snd_bebob_meter_spec solo_meter_spec = { + .num = ARRAY_SIZE(solo_meter_labels), + .labels = solo_meter_labels, + .get = &solo_meter_get +}; +struct snd_bebob_spec maudio_solo_spec = { + .load = NULL, + .clock = &solo_clk_spec, + .meter = &solo_meter_spec +}; + +/* Ozonic specification */ +struct snd_bebob_clock_spec usual_clk_spec = { + .get_freq = &snd_bebob_stream_get_rate, + .set_freq = &snd_bebob_stream_set_rate +}; +static struct snd_bebob_meter_spec ozonic_meter_spec = { + .num = ARRAY_SIZE(ozonic_meter_labels), + .labels = ozonic_meter_labels, + .get = &ozonic_meter_get +}; +struct snd_bebob_spec maudio_ozonic_spec = { + .load = NULL, + .clock = &usual_clk_spec, + .meter = &ozonic_meter_spec +}; + +/* NRV10 specification */ +static struct snd_bebob_meter_spec nrv10_meter_spec = { + .num = ARRAY_SIZE(nrv10_meter_labels), + .labels = nrv10_meter_labels, + .get = &nrv10_meter_get +}; +struct snd_bebob_spec maudio_nrv10_spec = { + .load = NULL, + .clock = &usual_clk_spec, + .meter = &nrv10_meter_spec +}; diff --git a/sound/firewire/bebob/bebob_stream.c b/sound/firewire/bebob/bebob_stream.c index faa235e..078de08 100644 --- a/sound/firewire/bebob/bebob_stream.c +++ b/sound/firewire/bebob/bebob_stream.c @@ -261,9 +261,11 @@ start_stream(struct snd_bebob *bebob, struct amdtp_stream *stream, conn = &bebob->out_conn;

/* channel mapping */ - err = snd_bebob_stream_map(bebob, stream); - if (err < 0) - goto end; + if (!bebob->maudio_special_quirk) { + err = snd_bebob_stream_map(bebob, stream); + if (err < 0) + goto end; + }

/* start amdtp stream */ err = amdtp_stream_start(stream, @@ -384,6 +386,20 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, goto end; }

+ /* + * NOTE: + * The firmware customized by M-Audio uses this cue to start + * transmit stream. This is not in specification. + */ + if (bebob->maudio_special_quirk) { + err = spec->set_freq(bebob, rate); + if (err < 0) { + amdtp_stream_stop(master); + break_both_connections(bebob); + goto end; + } + } + /* wait first callback */ if (!amdtp_stream_wait_callback(master)) { amdtp_stream_stop(master);

This commit allows this driver to support all of models which Focusrite produces with BeBoB chipset. They are: - Saffire - Saffire LE - SaffirePro 10 - SaffirePro26

This commit adds Focusrite specific operations, quirks for its four functionalities.

1. Switching source of clock 2. Change sampling frequency 3. Check clock synchronization 4. Get metering information

The driver uses these functionalities to read/write specific address by async transaction.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/Kconfig | 1 + sound/firewire/bebob/Makefile | 2 +- sound/firewire/bebob/bebob.c | 34 ++- sound/firewire/bebob/bebob.h | 4 + sound/firewire/bebob/bebob_focusrite.c | 390 +++++++++++++++++++++++++++++++++ 5 files changed, 429 insertions(+), 2 deletions(-) create mode 100644 sound/firewire/bebob/bebob_focusrite.c

diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig index 427def7..b8d7fb5 100644 --- a/sound/firewire/Kconfig +++ b/sound/firewire/Kconfig @@ -82,6 +82,7 @@ config SND_BEBOB * BridgeCo RDAudio1/Audio5 * M-Audio Firewire410/AudioPhile/Solo/Ozonic/NRV10 * M-Audio Firewire1814/ProjectMix IO/ProfireLightBridge + * Focusrite Saffire/Saffire LE/SaffirePro10 IO/SaffirePro26 IO

To compile this driver as a module, choose M here: the module will be called snd-fireworks. diff --git a/sound/firewire/bebob/Makefile b/sound/firewire/bebob/Makefile index 2e87d02..96f8e92 100644 --- a/sound/firewire/bebob/Makefile +++ b/sound/firewire/bebob/Makefile @@ -1,5 +1,5 @@ snd-bebob-objs := bebob_command.o bebob_stream.o bebob_proc.o bebob_control.o \ bebob_midi.o bebob_pcm.o bebob_hwdep.o \ - bebob_maudio.o \ + bebob_maudio.o bebob_focusrite.o \ bebob.o obj-m += snd-bebob.o diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c index 576d801..6382b49 100644 --- a/sound/firewire/bebob/bebob.c +++ b/sound/firewire/bebob/bebob.c @@ -52,10 +52,12 @@ static unsigned int devices_used; #define VEN_PHONIC 0x00001496 #define VEN_MAUDIO1 0x00000d6c #define VEN_MAUDIO2 0x000007f5 +#define VEN_FOCUSRITE 0x0000130e

#define MODEL_MAUDIO_AUDIOPHILE_BOTH 0x00010060 #define MODEL_MAUDIO_FW1814 0x00010071 #define MODEL_MAUDIO_PROJECTMIX 0x00010091 +#define MODEL_FOCUSRITE_SAFFIRE_BOTH 0x00000000

static int name_device(struct snd_bebob *bebob, unsigned int vendor_id) @@ -157,6 +159,21 @@ check_audiophile_booted(struct fw_unit *unit) return true; }

+static const struct snd_bebob_spec * +get_saffire_spec(struct fw_unit *unit) +{ + char name[24] = {0}; + + if (fw_csr_string(unit->directory, CSR_MODEL, name, sizeof(name)) < 0) + return NULL; + + if (strcmp(name, "SaffireLE") == 0) + return &saffire_le_spec; + else + return &saffire_spec; +} + + static int snd_bebob_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry) @@ -179,7 +196,15 @@ snd_bebob_probe(struct fw_unit *unit, goto end; }

- spec = (const struct snd_bebob_spec *)entry->driver_data; + if (entry->model_id == MODEL_FOCUSRITE_SAFFIRE_BOTH) + spec = get_saffire_spec(unit); + else + spec = (const struct snd_bebob_spec *)entry->driver_data; + + if (spec == NULL) { + err = -EIO; + goto end; + }

/* if needed, load firmware and exit */ if ((spec->load) && @@ -362,6 +387,13 @@ static const struct ieee1394_device_id snd_bebob_id_table[] = { maudio_special_spec), /* M-Audio, ProFireLightbridge */ SND_BEBOB_DEV_ENTRY(VEN_MAUDIO1, 0x000100a1, spec_normal), + /* Focusrite, SaffirePro 26 I/O */ + SND_BEBOB_DEV_ENTRY(VEN_FOCUSRITE, 0x00000003, saffirepro_26_spec), + /* Focusrite, SaffirePro 10 I/O */ + SND_BEBOB_DEV_ENTRY(VEN_FOCUSRITE, 0x00000006, saffirepro_10_spec), + /* Focusrite, Saffire(no label and LE) */ + SND_BEBOB_DEV_ENTRY(VEN_FOCUSRITE, MODEL_FOCUSRITE_SAFFIRE_BOTH, + saffire_spec), {} }; MODULE_DEVICE_TABLE(ieee1394, snd_bebob_id_table); diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h index fb9d99d..90b37eb 100644 --- a/sound/firewire/bebob/bebob.h +++ b/sound/firewire/bebob/bebob.h @@ -234,6 +234,10 @@ extern struct snd_bebob_spec maudio_fw410_spec; extern struct snd_bebob_spec maudio_audiophile_spec; extern struct snd_bebob_spec maudio_solo_spec; extern struct snd_bebob_spec maudio_ozonic_spec; +extern struct snd_bebob_spec saffirepro_26_spec; +extern struct snd_bebob_spec saffirepro_10_spec; +extern struct snd_bebob_spec saffire_le_spec; +extern struct snd_bebob_spec saffire_spec;

#define SND_BEBOB_DEV_ENTRY(vendor, model, private_data) \ { \ diff --git a/sound/firewire/bebob/bebob_focusrite.c b/sound/firewire/bebob/bebob_focusrite.c new file mode 100644 index 0000000..c4c7805 --- /dev/null +++ b/sound/firewire/bebob/bebob_focusrite.c @@ -0,0 +1,390 @@ +/* + * bebob_focusrite.c - a part of driver for BeBoB based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +#include "./bebob.h" + +#define ANA_IN "Analog In" +#define DIG_IN "Digital In" +#define ANA_OUT "Analog Out" +#define DIG_OUT "Digital Out" +#define STM_IN "Stream In" + +#define SAFFIRE_ADDRESS_BASE 0x000100000000 + +#define SAFFIRE_OFFSET_CLOCK_SOURCE 0x0000000000f8 +#define SAFFIREPRO_OFFSET_CLOCK_SOURCE 0x000000000174 + +/* whether sync to external device or not */ +#define SAFFIRE_OFFSET_CLOCK_SYNC_EXT 0x00000000013c +#define SAFFIRE_LE_OFFSET_CLOCK_SYNC_EXT 0x000000000432 +#define SAFFIREPRO_OFFSET_CLOCK_SYNC_EXT 0x000000000164 + +#define SAFFIRE_CLOCK_SOURCE_INTERNAL 0 +#define SAFFIRE_CLOCK_SOURCE_SPDIF 1 + +/* '1' is absent, why... */ +#define SAFFIREPRO_CLOCK_SOURCE_INTERNAL 0 +#define SAFFIREPRO_CLOCK_SOURCE_SPDIF 2 +#define SAFFIREPRO_CLOCK_SOURCE_ADAT1 3 +#define SAFFIREPRO_CLOCK_SOURCE_ADAT2 4 +#define SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK 5 + +/* S/PDIF, ADAT1, ADAT2 is enabled or not. three quadlets */ +#define SAFFIREPRO_ENABLE_DIG_IFACES 0x0000000001a4 + +/* saffirepro has its own parameter for sampling frequency */ +#define SAFFIREPRO_RATE_NOREBOOT 0x0000000001cc +/* index is the value for this register */ +const static unsigned int rates[] = { + [0] = 0, + [1] = 44100, + [2] = 48000, + [3] = 88200, + [4] = 96000, + [5] = 176400, + [6] = 192000 +}; + +/* saffire(no label)/saffire LE has metering */ +#define SAFFIRE_OFFSET_METER 0x000000000100 +#define SAFFIRE_LE_OFFSET_METER 0x000000000168 + +static inline int +saffire_read_block(struct snd_bebob *bebob, u64 offset, + u32 *buf, unsigned int size) +{ + unsigned int i; + int err; + __be32 *tmp = (__be32 *)buf; + + err = snd_fw_transaction(bebob->unit, TCODE_READ_BLOCK_REQUEST, + SAFFIRE_ADDRESS_BASE + offset, + tmp, size, 0); + if (err < 0) + goto end; + + for (i = 0; i < size / sizeof(u32); i++) + buf[i] = be32_to_cpu(tmp[i]); +end: + return err; +} + +static inline int +saffire_read_quad(struct snd_bebob *bebob, u64 offset, u32 *value) +{ + int err; + __be32 tmp; + + err = snd_fw_transaction(bebob->unit, TCODE_READ_QUADLET_REQUEST, + SAFFIRE_ADDRESS_BASE + offset, + &tmp, sizeof(u32), 0); + if (err < 0) + goto end; + + *value = be32_to_cpu(tmp); +end: + return err; +} + +static inline int +saffire_write_quad(struct snd_bebob *bebob, u64 offset, u32 value) +{ + value = cpu_to_be32(value); + + return snd_fw_transaction(bebob->unit, TCODE_WRITE_QUADLET_REQUEST, + SAFFIRE_ADDRESS_BASE + offset, + &value, sizeof(u32), 0); +} + +static char *saffirepro_26_clk_src_labels[] = { + SND_BEBOB_CLOCK_INTERNAL, "S/PDIF", "ADAT1", "ADAT2", "Word Clock" +}; + +static char *saffirepro_10_clk_src_labels[] = { + SND_BEBOB_CLOCK_INTERNAL, "S/PDIF", "Word Clock" +}; +static int +saffirepro_both_clk_freq_get(struct snd_bebob *bebob, unsigned int *rate) +{ + u32 id; + int err; + + err = saffire_read_quad(bebob, SAFFIREPRO_RATE_NOREBOOT, &id); + if (err < 0) + goto end; + if (id >= ARRAY_SIZE(rates)) { + err = -EIO; + goto end; + } + + *rate = rates[id]; +end: + return err; +} +static int +saffirepro_both_clk_freq_set(struct snd_bebob *bebob, unsigned int rate) +{ + u32 id; + bool flag; + + flag = false; + for (id = 0; id < ARRAY_SIZE(rates); id++) { + if (rates[id] == rate) + flag = true; + } + if (!flag) + return -EINVAL; + + return saffire_write_quad(bebob, SAFFIREPRO_RATE_NOREBOOT, id); +} +static int +saffirepro_both_clk_src_get(struct snd_bebob *bebob, unsigned int *id) +{ + int err; + u32 value; + + err = saffire_read_quad(bebob, SAFFIREPRO_OFFSET_CLOCK_SOURCE, &value); + if (err < 0) + goto end; + + if (bebob->spec->clock->labels == saffirepro_10_clk_src_labels) { + if (value == SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK) + *id = 2; + else if (value == SAFFIREPRO_CLOCK_SOURCE_SPDIF) + *id = 1; + } else if (value > 1) + *id = value - 1; +end: + return err; +} +static int +saffirepro_both_clk_src_set(struct snd_bebob *bebob, unsigned int id) +{ + int err; + u32 values[3]; + + if (bebob->spec->clock->labels == saffirepro_10_clk_src_labels) { + if (id == 2) + id = 5; + else if (id == 1) + id = 2; + } else if (id > 0) + id++; + + /* if requesting digital input, check whether it's enabled or not */ + /* TODO: consider to add switch for these digital inputs */ + if ((id > 1) && (id < 5)) { + err = saffire_read_block(bebob, SAFFIREPRO_ENABLE_DIG_IFACES, + values, sizeof(values)); + if (err < 0) + goto end; + if (values[id - 2] == 0) + goto end; + } + + err = saffire_write_quad(bebob, SAFFIREPRO_OFFSET_CLOCK_SOURCE, id); +end: + return err; +} +static int +saffirepro_both_clk_synced(struct snd_bebob *bebob, bool *synced) +{ + unsigned int clock; + u32 value; + int err; + + err = saffirepro_both_clk_src_get(bebob, &clock); + if (err < 0) + goto end; + /* internal */ + if (clock == 0) { + *synced = true; + goto end; + } + + err = saffire_read_quad(bebob, + SAFFIREPRO_OFFSET_CLOCK_SYNC_EXT, &value); + if (err < 0) + goto end; + + *synced = (value & 0x01); +end: + return err; +} + +struct snd_bebob_spec saffire_le_spec; +static char *saffire_both_clk_src_labels[] = { + SND_BEBOB_CLOCK_INTERNAL, "S/PDIF" +}; +static int +saffire_both_clk_src_get(struct snd_bebob *bebob, unsigned int *id) +{ + int err; + u32 value; + + err = saffire_read_quad(bebob, SAFFIRE_OFFSET_CLOCK_SOURCE, &value); + if (err < 0) + goto end; + + *id = 0xff & value; +end: + return err; +}; +static int +saffire_both_clk_src_set(struct snd_bebob *bebob, unsigned int id) +{ + return saffire_write_quad(bebob, SAFFIRE_OFFSET_CLOCK_SOURCE, id); +}; +static int +saffire_both_clk_synced(struct snd_bebob *bebob, bool *synced) +{ + int err; + u64 offset; + u32 value; + + err = saffire_both_clk_src_get(bebob, &value); + if (err < 0) + goto end; + /* internal */ + if (value == 0) { + *synced = true; + goto end; + } + + if (bebob->spec == &saffire_le_spec) + offset = SAFFIRE_LE_OFFSET_CLOCK_SYNC_EXT; + else + offset = SAFFIRE_OFFSET_CLOCK_SYNC_EXT; + + err = saffire_read_quad(bebob, offset, &value); + if (err < 0) + goto end; + + *synced = (0x01 & value); +end: + return err; +} +static char *saffire_le_meter_labels[] = { + ANA_IN, ANA_IN, DIG_IN, + ANA_OUT, ANA_OUT, ANA_OUT, ANA_OUT, + STM_IN, STM_IN +}; +#define SWAP(a, b) \ + tmp = a; \ + a = b; \ + b = tmp +static int +saffire_le_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size) +{ + int err; + u32 tmp; + + if (size < sizeof(saffire_le_meter_labels) * sizeof(u32)) + return -EIO; + + err = saffire_read_block(bebob, SAFFIRE_LE_OFFSET_METER, buf, size); + if (err < 0) + goto end; + + SWAP(buf[1], buf[3]); + SWAP(buf[2], buf[3]); + SWAP(buf[3], buf[4]); + + SWAP(buf[7], buf[10]); + SWAP(buf[8], buf[10]); + SWAP(buf[9], buf[11]); + SWAP(buf[11], buf[12]); + + SWAP(buf[15], buf[16]); + +end: + return err; +} +static char *saffire_meter_labels[] = { + ANA_IN, ANA_IN, + STM_IN, STM_IN, STM_IN, STM_IN, STM_IN, +}; +static int +saffire_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size) +{ + return saffire_read_block(bebob, SAFFIRE_OFFSET_METER, buf, size); +} + +/* Saffire Pro 26 I/O */ +static struct snd_bebob_clock_spec saffirepro_26_clk_spec = { + .num = ARRAY_SIZE(saffirepro_26_clk_src_labels), + .labels = saffirepro_26_clk_src_labels, + .get_src = &saffirepro_both_clk_src_get, + .set_src = &saffirepro_both_clk_src_set, + .get_freq = &saffirepro_both_clk_freq_get, + .set_freq = &saffirepro_both_clk_freq_set, + .synced = &saffirepro_both_clk_synced +}; +struct snd_bebob_spec saffirepro_26_spec = { + .load = NULL, + .clock = &saffirepro_26_clk_spec, + .meter = NULL +}; + +/* Saffire Pro 10 I/O */ +static struct snd_bebob_clock_spec saffirepro_10_clk_spec = { + .num = ARRAY_SIZE(saffirepro_10_clk_src_labels), + .labels = saffirepro_10_clk_src_labels, + .get_src = &saffirepro_both_clk_src_get, + .set_src = &saffirepro_both_clk_src_set, + .get_freq = &saffirepro_both_clk_freq_get, + .set_freq = &saffirepro_both_clk_freq_set, + .synced = &saffirepro_both_clk_synced +}; +struct snd_bebob_spec saffirepro_10_spec = { + .load = NULL, + .clock = &saffirepro_10_clk_spec, + .meter = NULL +}; + +struct snd_bebob_clock_spec saffire_both_clk_spec= { + .num = ARRAY_SIZE(saffire_both_clk_src_labels), + .labels = saffire_both_clk_src_labels, + .get_src = &saffire_both_clk_src_get, + .set_src = &saffire_both_clk_src_set, + .get_freq = &snd_bebob_stream_get_rate, + .set_freq = &snd_bebob_stream_set_rate, + .synced = &saffire_both_clk_synced +}; + +/* Saffire LE */ +struct snd_bebob_meter_spec saffire_le_meter_spec = { + .num = ARRAY_SIZE(saffire_le_meter_labels), + .labels = saffire_le_meter_labels, + .get = &saffire_le_meter_get, +}; +struct snd_bebob_spec saffire_le_spec = { + .load = NULL, + .clock = &saffire_both_clk_spec, + .meter = &saffire_le_meter_spec +}; +/* Saffire */ +struct snd_bebob_meter_spec saffire_meter_spec = { + .num = ARRAY_SIZE(saffire_meter_labels), + .labels = saffire_meter_labels, + .get = &saffire_meter_get, +}; +struct snd_bebob_spec saffire_spec ={ + .load = NULL, + .clock = &saffire_both_clk_spec, + .meter = &saffire_meter_spec +};

This commit allows this driver to support all of models which Yamaha produced with BeBoB chipset. They are: - GO44 - GO46

This commit adds Yamaha specific operations, quirks for three functionalities.

1. Switching source of clock 2. Detecting signal in digital input 3. Check clock synchronization

The driver uses these functionalities with AV/C vendor specific commands and AV/C Audio Subunit commands.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/Kconfig | 1 + sound/firewire/bebob/Makefile | 1 + sound/firewire/bebob/bebob.c | 7 ++ sound/firewire/bebob/bebob.h | 1 + sound/firewire/bebob/bebob_yamaha.c | 176 ++++++++++++++++++++++++++++++++++++ 5 files changed, 186 insertions(+) create mode 100644 sound/firewire/bebob/bebob_yamaha.c

diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig index 502dce9..08ecc18 100644 --- a/sound/firewire/Kconfig +++ b/sound/firewire/Kconfig @@ -84,6 +84,7 @@ config SND_BEBOB * M-Audio Firewire1814/ProjectMix IO/ProfireLightBridge * Focusrite Saffire/Saffire LE/SaffirePro10 IO/SaffirePro26 IO * TerraTec PHASE 24 FW/PHASE X24 FW/PHASE 88 Rack FW + * Yamaha GO44/GO46

To compile this driver as a module, choose M here: the module will be called snd-fireworks. diff --git a/sound/firewire/bebob/Makefile b/sound/firewire/bebob/Makefile index 2fefcec..a81540b 100644 --- a/sound/firewire/bebob/Makefile +++ b/sound/firewire/bebob/Makefile @@ -1,5 +1,6 @@ snd-bebob-objs := bebob_command.o bebob_stream.o bebob_proc.o bebob_control.o \ bebob_midi.o bebob_pcm.o bebob_hwdep.o \ bebob_maudio.o bebob_focusrite.o bebob_terratec.o \ + bebob_yamaha.o \ bebob.o obj-m += snd-bebob.o diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c index 7c5576d..d871fae 100644 --- a/sound/firewire/bebob/bebob.c +++ b/sound/firewire/bebob/bebob.c @@ -54,6 +54,7 @@ static unsigned int devices_used; #define VEN_MAUDIO2 0x000007f5 #define VEN_FOCUSRITE 0x0000130e #define VEN_TERRATEC 0x00000aac +#define VEN_YAMAHA 0x0000a0de

#define MODEL_MAUDIO_AUDIOPHILE_BOTH 0x00010060 #define MODEL_MAUDIO_FW1814 0x00010071 @@ -95,6 +96,8 @@ name_device(struct snd_bebob *bebob, unsigned int vendor_id) strcpy(vendor, "M-Audio"); else if (vendor_id == VEN_TERRATEC) strcpy(vendor, "Terratec"); + else if (vendor_id == VEN_YAMAHA) + strcpy(vendor, "YAMAHA");

/* get model name */ err = fw_csr_string(bebob->unit->directory, CSR_MODEL, @@ -403,6 +406,10 @@ static const struct ieee1394_device_id snd_bebob_id_table[] = { SND_BEBOB_DEV_ENTRY(VEN_TERRATEC, 0x00000004, phase24_series_spec), /* TerraTecElectronic GmbH, Phase X24 FW */ SND_BEBOB_DEV_ENTRY(VEN_TERRATEC, 0x00000007, phase24_series_spec), + /* Yamaha, GO44 */ + SND_BEBOB_DEV_ENTRY(VEN_YAMAHA, 0x0010000b, yamaha_go_spec), + /* YAMAHA, GO46 */ + SND_BEBOB_DEV_ENTRY(VEN_YAMAHA, 0x0010000c, yamaha_go_spec), {} }; MODULE_DEVICE_TABLE(ieee1394, snd_bebob_id_table); diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h index 6a92f43..b3211b6 100644 --- a/sound/firewire/bebob/bebob.h +++ b/sound/firewire/bebob/bebob.h @@ -240,6 +240,7 @@ extern struct snd_bebob_spec saffire_le_spec; extern struct snd_bebob_spec saffire_spec; extern struct snd_bebob_spec phase88_rack_spec; extern struct snd_bebob_spec phase24_series_spec; +extern struct snd_bebob_spec yamaha_go_spec;

#define SND_BEBOB_DEV_ENTRY(vendor, model, private_data) \ { \ diff --git a/sound/firewire/bebob/bebob_yamaha.c b/sound/firewire/bebob/bebob_yamaha.c new file mode 100644 index 0000000..fc8a44f --- /dev/null +++ b/sound/firewire/bebob/bebob_yamaha.c @@ -0,0 +1,176 @@ +/* + * bebob_yamaha.c - a part of driver for BeBoB based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * This driver is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2. + * + * This driver is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this driver; if not, see http://www.gnu.org/licenses/. + */ + +#include "./bebob.h" + +/* + * NOTE: + * Yamaha GO44 is not considered to be used as stand-alone mixer. So any streams + * must be accompanied. If changing the state, a LED on the device starts to + * blink and its sync status is false. In this state, the device sounds nothing + * even if streaming. To start streaming at the current sampling rate is only + * way to revocer this state. GO46 is better for stand-alone mixer. + * + * Both of them have a capability to change its sampling rate up to 192.0kHz. + * At 192.0kHz, the device reports 4 PCM-in, 1 MIDI-in, 6 PCM-out, 1 MIDI-out. + * But Yamaha's driver reduce 2 PCM-in, 1 MIDI-in, 2 PCM-out, 1 MIDI-out to use + * 'Extended Stream Format Information Command - Single Request' in 'Additional + * AVC commands' defined by BridgeCo. + * This ALSA driver don't do this because a bit tiresome. Then isochronous + * streaming with many asynchronous transactions brings sounds with noises. + * Unfortunately current 'ffado-mixer' generated many asynchronous transaction + * to observe device's state, mainly check cmp connection and signal format. I + * reccomend users to close ffado-mixer at 192.0kHz if mixer is needless. + */ + +static int +detect_dig_in(struct snd_bebob *bebob, unsigned int *detect) +{ + int err; + u8 *buf; + + buf = kmalloc(12, GFP_KERNEL); + if (buf == NULL) + return -ENOMEM; + + /* This is a vendor dependent command */ + buf[0] = 0x01; /* STATUS */ + buf[1] = 0xff; /* UNIT */ + buf[2] = 0x00; /* Vendor Dependent command */ + buf[3] = 0x00; /* Company ID high */ + buf[4] = 0x07; /* Company ID middle */ + buf[5] = 0xf5; /* Company ID low */ + buf[6] = 0x00; /* Unknown Subfunction*/ + buf[7] = 0x00; /* Unknown */ + buf[8] = 0x01; /* Unknown */ + buf[9] = 0x00; /* Unknown */ + buf[10] = 0x00; /* Unknown */ + buf[11] = 0x00; /* Unknown */ + + /* do transaction and check buf[1-6] are the same against command */ + err = fcp_avc_transaction(bebob->unit, buf, 12, buf, 12, + BIT(1) | BIT(2) | BIT(3) | BIT(4) | + BIT(5) | BIT(6)); + if (err < 0) + goto end; + /* IMPLEMENTED/STABLE is OK */ + if ((err < 6) || (buf[0] != 0x0c)){ + dev_err(&bebob->unit->device, + "failed to detect clock source 0x%02X\n", + buf[0]); + err = -EIO; + goto end; + } + + /* when digital clock input exists, 10th byte is 0x01 */ + *detect = (buf[9] > 0); + err = 0; +end: + return err; +} + +static int +get_sync_status(struct snd_bebob *bebob, bool *sync) +{ + u8 *buf; + int err; + + buf = kmalloc(8, GFP_KERNEL); + if (buf == NULL) + return -ENOMEM; + + buf[0] = 0x01; /* AV/C STATUS */ + buf[1] = 0xFF; /* UNIT */ + buf[2] = 0x00; /* Vendor Specific Command */ + buf[3] = 0x01; /* Company ID high */ + buf[4] = 0x02; /* Company ID middle */ + buf[5] = 0x03; /* Company ID low */ + buf[6] = 0x21; /* unknown subfunction */ + buf[7] = 0xff; /* status */ + + err = fcp_avc_transaction(bebob->unit, buf, 8, buf, 8, + BIT(1) | BIT(2) | BIT(3) | BIT(4) | + BIT(5) | BIT(6)); + if (err < 0) + goto end; + if ((err < 6) || (buf[0] != 0x0c)) { + dev_err(&bebob->unit->device, + "failed to get sync status\n"); + err = -EIO; + goto end; + } + + /* 0x00 if losing sync */ + *sync = (buf[7] != 0x00); + err = 0; +end: + kfree(buf); + return err; +} + +static char *clk_src_labels[] = {SND_BEBOB_CLOCK_INTERNAL, "SPDIF"}; +static int +clk_src_set(struct snd_bebob *bebob, unsigned int id) +{ + int err; + unsigned int detect; + + if (id > 0) { + err = detect_dig_in(bebob, &detect); + if ((err < 0) || (detect == 0)) + return -EIO; + } + + err = avc_audio_set_selector(bebob->unit, 0, 4, id); + if (err < 0) + goto end; + + /* + * Yamaha BeBob returns 'IN TRANSITION' status just after returning to + * internal clock + */ + if (id == 0) + msleep(1500); + +end: + return err; +} +static int +clk_src_get(struct snd_bebob *bebob, unsigned int *id) +{ + return avc_audio_get_selector(bebob->unit, 0, 4, id); +} +static int +clk_synced(struct snd_bebob *bebob, bool *synced) +{ + return get_sync_status(bebob, synced); +} + +static struct snd_bebob_clock_spec clock_spec = { + .num = ARRAY_SIZE(clk_src_labels), + .labels = clk_src_labels, + .get_src = &clk_src_get, + .set_src = &clk_src_set, + .get_freq = &snd_bebob_stream_get_rate, + .set_freq = &snd_bebob_stream_set_rate, + .synced = &clk_synced +}; +struct snd_bebob_spec yamaha_go_spec = { + .load = NULL, + .clock = &clock_spec, + .meter = NULL +};