Followed commits add much codes. I'll split them to some files. In this reason, this commit make own directory and move current source to it.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/Makefile | 3 +- sound/firewire/speakers.c | 801 ------------------------------------- sound/firewire/speakers/Makefile | 2 + sound/firewire/speakers/speakers.c | 801 +++++++++++++++++++++++++++++++++++++ 4 files changed, 804 insertions(+), 803 deletions(-) delete mode 100644 sound/firewire/speakers.c create mode 100644 sound/firewire/speakers/Makefile create mode 100644 sound/firewire/speakers/speakers.c

diff --git a/sound/firewire/Makefile b/sound/firewire/Makefile index fad8d49..e2cd79f 100644 --- a/sound/firewire/Makefile +++ b/sound/firewire/Makefile @@ -1,13 +1,12 @@ snd-firewire-lib-objs := lib.o iso-resources.o packets-buffer.o \ fcp.o cmp.o amdtp.o snd-dice-objs := dice.o -snd-firewire-speakers-objs := speakers.o snd-isight-objs := isight.o snd-scs1x-objs := scs1x.o

obj-$(CONFIG_SND_FIREWIRE_LIB) += snd-firewire-lib.o obj-$(CONFIG_SND_DICE) += snd-dice.o -obj-$(CONFIG_SND_FIREWIRE_SPEAKERS) += snd-firewire-speakers.o +obj-$(CONFIG_SND_FIREWIRE_SPEAKERS) += speakers/ obj-$(CONFIG_SND_ISIGHT) += snd-isight.o obj-$(CONFIG_SND_SCS1X) += snd-scs1x.o obj-$(CONFIG_SND_FIREWORKS) += fireworks/ diff --git a/sound/firewire/speakers.c b/sound/firewire/speakers.c deleted file mode 100644 index abb2eb1..0000000 --- a/sound/firewire/speakers.c +++ /dev/null @@ -1,801 +0,0 @@ -/* - * OXFW970-based speakers driver - * - * Copyright (c) Clemens Ladisch clemens@ladisch.de - * Licensed under the terms of the GNU General Public License, version 2. - */ - -#include <linux/device.h> -#include <linux/firewire.h> -#include <linux/firewire-constants.h> -#include <linux/module.h> -#include <linux/mod_devicetable.h> -#include <linux/mutex.h> -#include <linux/slab.h> -#include <sound/control.h> -#include <sound/core.h> -#include <sound/initval.h> -#include <sound/pcm.h> -#include <sound/pcm_params.h> -#include "cmp.h" -#include "fcp.h" -#include "amdtp.h" -#include "lib.h" - -#define OXFORD_FIRMWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x50000) -/* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */ - -#define OXFORD_HARDWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x90020) -#define OXFORD_HARDWARE_ID_OXFW970 0x39443841 -#define OXFORD_HARDWARE_ID_OXFW971 0x39373100 - -#define VENDOR_GRIFFIN 0x001292 -#define VENDOR_LACIE 0x00d04b - -#define SPECIFIER_1394TA 0x00a02d -#define VERSION_AVC 0x010001 - -struct device_info { - const char *driver_name; - const char *short_name; - const char *long_name; - int (*pcm_constraints)(struct snd_pcm_runtime *runtime); - unsigned int mixer_channels; - u8 mute_fb_id; - u8 volume_fb_id; -}; - -struct fwspk { - struct snd_card *card; - struct fw_unit *unit; - const struct device_info *device_info; - struct mutex mutex; - struct cmp_connection connection; - struct amdtp_stream stream; - bool mute; - s16 volume[6]; - s16 volume_min; - s16 volume_max; -}; - -MODULE_DESCRIPTION("FireWire speakers driver"); -MODULE_AUTHOR("Clemens Ladisch clemens@ladisch.de"); -MODULE_LICENSE("GPL v2"); - -static int firewave_rate_constraint(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) -{ - static unsigned int stereo_rates[] = { 48000, 96000 }; - struct snd_interval *channels = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *rate = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); - - /* two channels work only at 48/96 kHz */ - if (snd_interval_max(channels) < 6) - return snd_interval_list(rate, 2, stereo_rates, 0); - return 0; -} - -static int firewave_channels_constraint(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) -{ - static const struct snd_interval all_channels = { .min = 6, .max = 6 }; - struct snd_interval *rate = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); - struct snd_interval *channels = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - - /* 32/44.1 kHz work only with all six channels */ - if (snd_interval_max(rate) < 48000) - return snd_interval_refine(channels, &all_channels); - return 0; -} - -static int firewave_constraints(struct snd_pcm_runtime *runtime) -{ - static unsigned int channels_list[] = { 2, 6 }; - static struct snd_pcm_hw_constraint_list channels_list_constraint = { - .count = 2, - .list = channels_list, - }; - int err; - - runtime->hw.rates = SNDRV_PCM_RATE_32000 | - SNDRV_PCM_RATE_44100 | - SNDRV_PCM_RATE_48000 | - SNDRV_PCM_RATE_96000; - runtime->hw.channels_max = 6; - - err = snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_CHANNELS, - &channels_list_constraint); - if (err < 0) - return err; - err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, - firewave_rate_constraint, NULL, - SNDRV_PCM_HW_PARAM_CHANNELS, -1); - if (err < 0) - return err; - err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, - firewave_channels_constraint, NULL, - SNDRV_PCM_HW_PARAM_RATE, -1); - if (err < 0) - return err; - - return 0; -} - -static int lacie_speakers_constraints(struct snd_pcm_runtime *runtime) -{ - runtime->hw.rates = SNDRV_PCM_RATE_32000 | - SNDRV_PCM_RATE_44100 | - SNDRV_PCM_RATE_48000 | - SNDRV_PCM_RATE_88200 | - SNDRV_PCM_RATE_96000; - - return 0; -} - -static int fwspk_open(struct snd_pcm_substream *substream) -{ - static const struct snd_pcm_hardware hardware = { - .info = SNDRV_PCM_INFO_MMAP | - SNDRV_PCM_INFO_MMAP_VALID | - SNDRV_PCM_INFO_BATCH | - SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER, - .formats = AMDTP_OUT_PCM_FORMAT_BITS, - .channels_min = 2, - .channels_max = 2, - .buffer_bytes_max = 4 * 1024 * 1024, - .period_bytes_min = 1, - .period_bytes_max = UINT_MAX, - .periods_min = 1, - .periods_max = UINT_MAX, - }; - struct fwspk *fwspk = substream->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; - int err; - - runtime->hw = hardware; - - err = fwspk->device_info->pcm_constraints(runtime); - if (err < 0) - return err; - err = snd_pcm_limit_hw_rates(runtime); - if (err < 0) - return err; - - err = snd_pcm_hw_constraint_minmax(runtime, - SNDRV_PCM_HW_PARAM_PERIOD_TIME, - 5000, UINT_MAX); - if (err < 0) - return err; - - err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); - if (err < 0) - return err; - - return 0; -} - -static int fwspk_close(struct snd_pcm_substream *substream) -{ - return 0; -} - -static void fwspk_stop_stream(struct fwspk *fwspk) -{ - if (amdtp_stream_running(&fwspk->stream)) { - amdtp_stream_stop(&fwspk->stream); - cmp_connection_break(&fwspk->connection); - } -} - -static int fwspk_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - struct fwspk *fwspk = substream->private_data; - int err; - - mutex_lock(&fwspk->mutex); - fwspk_stop_stream(fwspk); - mutex_unlock(&fwspk->mutex); - - err = snd_pcm_lib_alloc_vmalloc_buffer(substream, - params_buffer_bytes(hw_params)); - if (err < 0) - goto error; - - amdtp_stream_set_parameters(&fwspk->stream, - params_rate(hw_params), - params_channels(hw_params), - 0); - - amdtp_stream_set_pcm_format(&fwspk->stream, - params_format(hw_params)); - - err = avc_general_set_sig_fmt(fwspk->unit, params_rate(hw_params), - AVC_GENERAL_PLUG_DIR_IN, 0); - if (err < 0) - goto err_buffer; - if (err != 0x09 /* ACCEPTED */) { - dev_err(&fwspk->unit->device, "failed to set sample rate\n"); - err = -EIO; - goto error; - } - - return 0; - -err_buffer: - snd_pcm_lib_free_vmalloc_buffer(substream); -error: - return err; -} - -static int fwspk_hw_free(struct snd_pcm_substream *substream) -{ - struct fwspk *fwspk = substream->private_data; - - mutex_lock(&fwspk->mutex); - fwspk_stop_stream(fwspk); - mutex_unlock(&fwspk->mutex); - - return snd_pcm_lib_free_vmalloc_buffer(substream); -} - -static int fwspk_prepare(struct snd_pcm_substream *substream) -{ - struct fwspk *fwspk = substream->private_data; - int err; - - mutex_lock(&fwspk->mutex); - - if (amdtp_streaming_error(&fwspk->stream)) - fwspk_stop_stream(fwspk); - - if (!amdtp_stream_running(&fwspk->stream)) { - err = cmp_connection_establish(&fwspk->connection, - amdtp_stream_get_max_payload(&fwspk->stream)); - if (err < 0) - goto err_mutex; - - err = amdtp_stream_start(&fwspk->stream, - fwspk->connection.resources.channel, - fwspk->connection.speed); - if (err < 0) - goto err_connection; - } - - mutex_unlock(&fwspk->mutex); - - amdtp_stream_pcm_prepare(&fwspk->stream); - - return 0; - -err_connection: - cmp_connection_break(&fwspk->connection); -err_mutex: - mutex_unlock(&fwspk->mutex); - - return err; -} - -static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd) -{ - struct fwspk *fwspk = substream->private_data; - struct snd_pcm_substream *pcm; - - switch (cmd) { - case SNDRV_PCM_TRIGGER_START: - pcm = substream; - break; - case SNDRV_PCM_TRIGGER_STOP: - pcm = NULL; - break; - default: - return -EINVAL; - } - amdtp_stream_pcm_trigger(&fwspk->stream, pcm); - return 0; -} - -static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream) -{ - struct fwspk *fwspk = substream->private_data; - - return amdtp_stream_pcm_pointer(&fwspk->stream); -} - -static int fwspk_create_pcm(struct fwspk *fwspk) -{ - static struct snd_pcm_ops ops = { - .open = fwspk_open, - .close = fwspk_close, - .ioctl = snd_pcm_lib_ioctl, - .hw_params = fwspk_hw_params, - .hw_free = fwspk_hw_free, - .prepare = fwspk_prepare, - .trigger = fwspk_trigger, - .pointer = fwspk_pointer, - .page = snd_pcm_lib_get_vmalloc_page, - .mmap = snd_pcm_lib_mmap_vmalloc, - }; - struct snd_pcm *pcm; - int err; - - err = snd_pcm_new(fwspk->card, "OXFW970", 0, 1, 0, &pcm); - if (err < 0) - return err; - pcm->private_data = fwspk; - strcpy(pcm->name, fwspk->device_info->short_name); - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops); - return 0; -} - -enum control_action { CTL_READ, CTL_WRITE }; -enum control_attribute { - CTL_MIN = 0x02, - CTL_MAX = 0x03, - CTL_CURRENT = 0x10, -}; - -static int fwspk_mute_command(struct fwspk *fwspk, bool *value, - enum control_action action) -{ - u8 *buf; - u8 response_ok; - int err; - - buf = kmalloc(11, GFP_KERNEL); - if (!buf) - return -ENOMEM; - - if (action == CTL_READ) { - buf[0] = 0x01; /* AV/C, STATUS */ - response_ok = 0x0c; /* STABLE */ - } else { - buf[0] = 0x00; /* AV/C, CONTROL */ - response_ok = 0x09; /* ACCEPTED */ - } - buf[1] = 0x08; /* audio unit 0 */ - buf[2] = 0xb8; /* FUNCTION BLOCK */ - buf[3] = 0x81; /* function block type: feature */ - buf[4] = fwspk->device_info->mute_fb_id; /* function block ID */ - buf[5] = 0x10; /* control attribute: current */ - buf[6] = 0x02; /* selector length */ - buf[7] = 0x00; /* audio channel number */ - buf[8] = 0x01; /* control selector: mute */ - buf[9] = 0x01; /* control data length */ - if (action == CTL_READ) - buf[10] = 0xff; - else - buf[10] = *value ? 0x70 : 0x60; - - err = fcp_avc_transaction(fwspk->unit, buf, 11, buf, 11, 0x3fe); - if (err < 0) - goto error; - if (err < 11) { - dev_err(&fwspk->unit->device, "short FCP response\n"); - err = -EIO; - goto error; - } - if (buf[0] != response_ok) { - dev_err(&fwspk->unit->device, "mute command failed\n"); - err = -EIO; - goto error; - } - if (action == CTL_READ) - *value = buf[10] == 0x70; - - err = 0; - -error: - kfree(buf); - - return err; -} - -static int fwspk_volume_command(struct fwspk *fwspk, s16 *value, - unsigned int channel, - enum control_attribute attribute, - enum control_action action) -{ - u8 *buf; - u8 response_ok; - int err; - - buf = kmalloc(12, GFP_KERNEL); - if (!buf) - return -ENOMEM; - - if (action == CTL_READ) { - buf[0] = 0x01; /* AV/C, STATUS */ - response_ok = 0x0c; /* STABLE */ - } else { - buf[0] = 0x00; /* AV/C, CONTROL */ - response_ok = 0x09; /* ACCEPTED */ - } - buf[1] = 0x08; /* audio unit 0 */ - buf[2] = 0xb8; /* FUNCTION BLOCK */ - buf[3] = 0x81; /* function block type: feature */ - buf[4] = fwspk->device_info->volume_fb_id; /* function block ID */ - buf[5] = attribute; /* control attribute */ - buf[6] = 0x02; /* selector length */ - buf[7] = channel; /* audio channel number */ - buf[8] = 0x02; /* control selector: volume */ - buf[9] = 0x02; /* control data length */ - if (action == CTL_READ) { - buf[10] = 0xff; - buf[11] = 0xff; - } else { - buf[10] = *value >> 8; - buf[11] = *value; - } - - err = fcp_avc_transaction(fwspk->unit, buf, 12, buf, 12, 0x3fe); - if (err < 0) - goto error; - if (err < 12) { - dev_err(&fwspk->unit->device, "short FCP response\n"); - err = -EIO; - goto error; - } - if (buf[0] != response_ok) { - dev_err(&fwspk->unit->device, "volume command failed\n"); - err = -EIO; - goto error; - } - if (action == CTL_READ) - *value = (buf[10] << 8) | buf[11]; - - err = 0; - -error: - kfree(buf); - - return err; -} - -static int fwspk_mute_get(struct snd_kcontrol *control, - struct snd_ctl_elem_value *value) -{ - struct fwspk *fwspk = control->private_data; - - value->value.integer.value[0] = !fwspk->mute; - - return 0; -} - -static int fwspk_mute_put(struct snd_kcontrol *control, - struct snd_ctl_elem_value *value) -{ - struct fwspk *fwspk = control->private_data; - bool mute; - int err; - - mute = !value->value.integer.value[0]; - - if (mute == fwspk->mute) - return 0; - - err = fwspk_mute_command(fwspk, &mute, CTL_WRITE); - if (err < 0) - return err; - fwspk->mute = mute; - - return 1; -} - -static int fwspk_volume_info(struct snd_kcontrol *control, - struct snd_ctl_elem_info *info) -{ - struct fwspk *fwspk = control->private_data; - - info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - info->count = fwspk->device_info->mixer_channels; - info->value.integer.min = fwspk->volume_min; - info->value.integer.max = fwspk->volume_max; - - return 0; -} - -static const u8 channel_map[6] = { 0, 1, 4, 5, 2, 3 }; - -static int fwspk_volume_get(struct snd_kcontrol *control, - struct snd_ctl_elem_value *value) -{ - struct fwspk *fwspk = control->private_data; - unsigned int i; - - for (i = 0; i < fwspk->device_info->mixer_channels; ++i) - value->value.integer.value[channel_map[i]] = fwspk->volume[i]; - - return 0; -} - -static int fwspk_volume_put(struct snd_kcontrol *control, - struct snd_ctl_elem_value *value) -{ - struct fwspk *fwspk = control->private_data; - unsigned int i, changed_channels; - bool equal_values = true; - s16 volume; - int err; - - for (i = 0; i < fwspk->device_info->mixer_channels; ++i) { - if (value->value.integer.value[i] < fwspk->volume_min || - value->value.integer.value[i] > fwspk->volume_max) - return -EINVAL; - if (value->value.integer.value[i] != - value->value.integer.value[0]) - equal_values = false; - } - - changed_channels = 0; - for (i = 0; i < fwspk->device_info->mixer_channels; ++i) - if (value->value.integer.value[channel_map[i]] != - fwspk->volume[i]) - changed_channels |= 1 << (i + 1); - - if (equal_values && changed_channels != 0) - changed_channels = 1 << 0; - - for (i = 0; i <= fwspk->device_info->mixer_channels; ++i) { - volume = value->value.integer.value[channel_map[i ? i - 1 : 0]]; - if (changed_channels & (1 << i)) { - err = fwspk_volume_command(fwspk, &volume, i, - CTL_CURRENT, CTL_WRITE); - if (err < 0) - return err; - } - if (i > 0) - fwspk->volume[i - 1] = volume; - } - - return changed_channels != 0; -} - -static int fwspk_create_mixer(struct fwspk *fwspk) -{ - static const struct snd_kcontrol_new controls[] = { - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "PCM Playback Switch", - .info = snd_ctl_boolean_mono_info, - .get = fwspk_mute_get, - .put = fwspk_mute_put, - }, - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "PCM Playback Volume", - .info = fwspk_volume_info, - .get = fwspk_volume_get, - .put = fwspk_volume_put, - }, - }; - unsigned int i, first_ch; - int err; - - err = fwspk_volume_command(fwspk, &fwspk->volume_min, - 0, CTL_MIN, CTL_READ); - if (err < 0) - return err; - err = fwspk_volume_command(fwspk, &fwspk->volume_max, - 0, CTL_MAX, CTL_READ); - if (err < 0) - return err; - - err = fwspk_mute_command(fwspk, &fwspk->mute, CTL_READ); - if (err < 0) - return err; - - first_ch = fwspk->device_info->mixer_channels == 1 ? 0 : 1; - for (i = 0; i < fwspk->device_info->mixer_channels; ++i) { - err = fwspk_volume_command(fwspk, &fwspk->volume[i], - first_ch + i, CTL_CURRENT, CTL_READ); - if (err < 0) - return err; - } - - for (i = 0; i < ARRAY_SIZE(controls); ++i) { - err = snd_ctl_add(fwspk->card, - snd_ctl_new1(&controls[i], fwspk)); - if (err < 0) - return err; - } - - return 0; -} - -static u32 fwspk_read_firmware_version(struct fw_unit *unit) -{ - __be32 data; - int err; - - err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST, - OXFORD_FIRMWARE_ID_ADDRESS, &data, 4, 0); - return err >= 0 ? be32_to_cpu(data) : 0; -} - -static void fwspk_card_free(struct snd_card *card) -{ - struct fwspk *fwspk = card->private_data; - - amdtp_stream_destroy(&fwspk->stream); - cmp_connection_destroy(&fwspk->connection); - fw_unit_put(fwspk->unit); - mutex_destroy(&fwspk->mutex); -} - -static int fwspk_probe(struct fw_unit *unit, - const struct ieee1394_device_id *id) -{ - struct fw_device *fw_dev = fw_parent_device(unit); - struct snd_card *card; - struct fwspk *fwspk; - u32 firmware; - int err; - - err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card); - if (err < 0) - return err; - snd_card_set_dev(card, &unit->device); - - fwspk = card->private_data; - fwspk->card = card; - mutex_init(&fwspk->mutex); - fwspk->unit = fw_unit_get(unit); - fwspk->device_info = (const struct device_info *)id->driver_data; - - err = cmp_connection_init(&fwspk->connection, unit, CMP_INPUT, 0); - if (err < 0) - goto err_unit; - - err = amdtp_stream_init(&fwspk->stream, unit, AMDTP_OUT_STREAM, - CIP_NONBLOCKING); - if (err < 0) - goto err_connection; - - card->private_free = fwspk_card_free; - - strcpy(card->driver, fwspk->device_info->driver_name); - strcpy(card->shortname, fwspk->device_info->short_name); - firmware = fwspk_read_firmware_version(unit); - snprintf(card->longname, sizeof(card->longname), - "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d", - fwspk->device_info->long_name, - firmware >> 20, firmware & 0xffff, - fw_dev->config_rom[3], fw_dev->config_rom[4], - dev_name(&unit->device), 100 << fw_dev->max_speed); - strcpy(card->mixername, "OXFW970"); - - err = fwspk_create_pcm(fwspk); - if (err < 0) - goto error; - - err = fwspk_create_mixer(fwspk); - if (err < 0) - goto error; - - err = snd_card_register(card); - if (err < 0) - goto error; - - dev_set_drvdata(&unit->device, fwspk); - - return 0; - -err_connection: - cmp_connection_destroy(&fwspk->connection); -err_unit: - fw_unit_put(fwspk->unit); - mutex_destroy(&fwspk->mutex); -error: - snd_card_free(card); - return err; -} - -static void fwspk_bus_reset(struct fw_unit *unit) -{ - struct fwspk *fwspk = dev_get_drvdata(&unit->device); - - fcp_bus_reset(fwspk->unit); - - if (cmp_connection_update(&fwspk->connection) < 0) { - amdtp_stream_pcm_abort(&fwspk->stream); - mutex_lock(&fwspk->mutex); - fwspk_stop_stream(fwspk); - mutex_unlock(&fwspk->mutex); - return; - } - - amdtp_stream_update(&fwspk->stream); -} - -static void fwspk_remove(struct fw_unit *unit) -{ - struct fwspk *fwspk = dev_get_drvdata(&unit->device); - - amdtp_stream_pcm_abort(&fwspk->stream); - snd_card_disconnect(fwspk->card); - - mutex_lock(&fwspk->mutex); - fwspk_stop_stream(fwspk); - mutex_unlock(&fwspk->mutex); - - snd_card_free_when_closed(fwspk->card); -} - -static const struct device_info griffin_firewave = { - .driver_name = "FireWave", - .short_name = "FireWave", - .long_name = "Griffin FireWave Surround", - .pcm_constraints = firewave_constraints, - .mixer_channels = 6, - .mute_fb_id = 0x01, - .volume_fb_id = 0x02, -}; - -static const struct device_info lacie_speakers = { - .driver_name = "FWSpeakers", - .short_name = "FireWire Speakers", - .long_name = "LaCie FireWire Speakers", - .pcm_constraints = lacie_speakers_constraints, - .mixer_channels = 1, - .mute_fb_id = 0x01, - .volume_fb_id = 0x01, -}; - -static const struct ieee1394_device_id fwspk_id_table[] = { - { - .match_flags = IEEE1394_MATCH_VENDOR_ID | - IEEE1394_MATCH_MODEL_ID | - IEEE1394_MATCH_SPECIFIER_ID | - IEEE1394_MATCH_VERSION, - .vendor_id = VENDOR_GRIFFIN, - .model_id = 0x00f970, - .specifier_id = SPECIFIER_1394TA, - .version = VERSION_AVC, - .driver_data = (kernel_ulong_t)&griffin_firewave, - }, - { - .match_flags = IEEE1394_MATCH_VENDOR_ID | - IEEE1394_MATCH_MODEL_ID | - IEEE1394_MATCH_SPECIFIER_ID | - IEEE1394_MATCH_VERSION, - .vendor_id = VENDOR_LACIE, - .model_id = 0x00f970, - .specifier_id = SPECIFIER_1394TA, - .version = VERSION_AVC, - .driver_data = (kernel_ulong_t)&lacie_speakers, - }, - { } -}; -MODULE_DEVICE_TABLE(ieee1394, fwspk_id_table); - -static struct fw_driver fwspk_driver = { - .driver = { - .owner = THIS_MODULE, - .name = KBUILD_MODNAME, - .bus = &fw_bus_type, - }, - .probe = fwspk_probe, - .update = fwspk_bus_reset, - .remove = fwspk_remove, - .id_table = fwspk_id_table, -}; - -static int __init alsa_fwspk_init(void) -{ - return driver_register(&fwspk_driver.driver); -} - -static void __exit alsa_fwspk_exit(void) -{ - driver_unregister(&fwspk_driver.driver); -} - -module_init(alsa_fwspk_init); -module_exit(alsa_fwspk_exit); diff --git a/sound/firewire/speakers/Makefile b/sound/firewire/speakers/Makefile new file mode 100644 index 0000000..3db3c56a --- /dev/null +++ b/sound/firewire/speakers/Makefile @@ -0,0 +1,2 @@ +snd-firewire-speakers-objs := speakers.o +obj-m += snd-firewire-speakers.o diff --git a/sound/firewire/speakers/speakers.c b/sound/firewire/speakers/speakers.c new file mode 100644 index 0000000..78eaec1 --- /dev/null +++ b/sound/firewire/speakers/speakers.c @@ -0,0 +1,801 @@ +/* + * OXFW970-based speakers driver + * + * Copyright (c) Clemens Ladisch clemens@ladisch.de + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include <linux/device.h> +#include <linux/firewire.h> +#include <linux/firewire-constants.h> +#include <linux/module.h> +#include <linux/mod_devicetable.h> +#include <linux/mutex.h> +#include <linux/slab.h> +#include <sound/control.h> +#include <sound/core.h> +#include <sound/initval.h> +#include <sound/pcm.h> +#include <sound/pcm_params.h> +#include "../cmp.h" +#include "../fcp.h" +#include "../amdtp.h" +#include "../lib.h" + +#define OXFORD_FIRMWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x50000) +/* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */ + +#define OXFORD_HARDWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x90020) +#define OXFORD_HARDWARE_ID_OXFW970 0x39443841 +#define OXFORD_HARDWARE_ID_OXFW971 0x39373100 + +#define VENDOR_GRIFFIN 0x001292 +#define VENDOR_LACIE 0x00d04b + +#define SPECIFIER_1394TA 0x00a02d +#define VERSION_AVC 0x010001 + +struct device_info { + const char *driver_name; + const char *short_name; + const char *long_name; + int (*pcm_constraints)(struct snd_pcm_runtime *runtime); + unsigned int mixer_channels; + u8 mute_fb_id; + u8 volume_fb_id; +}; + +struct fwspk { + struct snd_card *card; + struct fw_unit *unit; + const struct device_info *device_info; + struct mutex mutex; + struct cmp_connection connection; + struct amdtp_stream stream; + bool mute; + s16 volume[6]; + s16 volume_min; + s16 volume_max; +}; + +MODULE_DESCRIPTION("FireWire speakers driver"); +MODULE_AUTHOR("Clemens Ladisch clemens@ladisch.de"); +MODULE_LICENSE("GPL v2"); + +static int firewave_rate_constraint(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + static unsigned int stereo_rates[] = { 48000, 96000 }; + struct snd_interval *channels = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + struct snd_interval *rate = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + + /* two channels work only at 48/96 kHz */ + if (snd_interval_max(channels) < 6) + return snd_interval_list(rate, 2, stereo_rates, 0); + return 0; +} + +static int firewave_channels_constraint(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + static const struct snd_interval all_channels = { .min = 6, .max = 6 }; + struct snd_interval *rate = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + struct snd_interval *channels = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + + /* 32/44.1 kHz work only with all six channels */ + if (snd_interval_max(rate) < 48000) + return snd_interval_refine(channels, &all_channels); + return 0; +} + +static int firewave_constraints(struct snd_pcm_runtime *runtime) +{ + static unsigned int channels_list[] = { 2, 6 }; + static struct snd_pcm_hw_constraint_list channels_list_constraint = { + .count = 2, + .list = channels_list, + }; + int err; + + runtime->hw.rates = SNDRV_PCM_RATE_32000 | + SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_96000; + runtime->hw.channels_max = 6; + + err = snd_pcm_hw_constraint_list(runtime, 0, + SNDRV_PCM_HW_PARAM_CHANNELS, + &channels_list_constraint); + if (err < 0) + return err; + err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, + firewave_rate_constraint, NULL, + SNDRV_PCM_HW_PARAM_CHANNELS, -1); + if (err < 0) + return err; + err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, + firewave_channels_constraint, NULL, + SNDRV_PCM_HW_PARAM_RATE, -1); + if (err < 0) + return err; + + return 0; +} + +static int lacie_speakers_constraints(struct snd_pcm_runtime *runtime) +{ + runtime->hw.rates = SNDRV_PCM_RATE_32000 | + SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_88200 | + SNDRV_PCM_RATE_96000; + + return 0; +} + +static int fwspk_open(struct snd_pcm_substream *substream) +{ + static const struct snd_pcm_hardware hardware = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_BATCH | + SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_BLOCK_TRANSFER, + .formats = AMDTP_OUT_PCM_FORMAT_BITS, + .channels_min = 2, + .channels_max = 2, + .buffer_bytes_max = 4 * 1024 * 1024, + .period_bytes_min = 1, + .period_bytes_max = UINT_MAX, + .periods_min = 1, + .periods_max = UINT_MAX, + }; + struct fwspk *fwspk = substream->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; + int err; + + runtime->hw = hardware; + + err = fwspk->device_info->pcm_constraints(runtime); + if (err < 0) + return err; + err = snd_pcm_limit_hw_rates(runtime); + if (err < 0) + return err; + + err = snd_pcm_hw_constraint_minmax(runtime, + SNDRV_PCM_HW_PARAM_PERIOD_TIME, + 5000, UINT_MAX); + if (err < 0) + return err; + + err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); + if (err < 0) + return err; + + return 0; +} + +static int fwspk_close(struct snd_pcm_substream *substream) +{ + return 0; +} + +static void fwspk_stop_stream(struct fwspk *fwspk) +{ + if (amdtp_stream_running(&fwspk->stream)) { + amdtp_stream_stop(&fwspk->stream); + cmp_connection_break(&fwspk->connection); + } +} + +static int fwspk_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *hw_params) +{ + struct fwspk *fwspk = substream->private_data; + int err; + + mutex_lock(&fwspk->mutex); + fwspk_stop_stream(fwspk); + mutex_unlock(&fwspk->mutex); + + err = snd_pcm_lib_alloc_vmalloc_buffer(substream, + params_buffer_bytes(hw_params)); + if (err < 0) + goto error; + + amdtp_stream_set_parameters(&fwspk->stream, + params_rate(hw_params), + params_channels(hw_params), + 0); + + amdtp_stream_set_pcm_format(&fwspk->stream, + params_format(hw_params)); + + err = avc_general_set_sig_fmt(fwspk->unit, params_rate(hw_params), + AVC_GENERAL_PLUG_DIR_IN, 0); + if (err < 0) + goto err_buffer; + if (err != 0x09 /* ACCEPTED */) { + dev_err(&fwspk->unit->device, "failed to set sample rate\n"); + err = -EIO; + goto error; + } + + return 0; + +err_buffer: + snd_pcm_lib_free_vmalloc_buffer(substream); +error: + return err; +} + +static int fwspk_hw_free(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + + mutex_lock(&fwspk->mutex); + fwspk_stop_stream(fwspk); + mutex_unlock(&fwspk->mutex); + + return snd_pcm_lib_free_vmalloc_buffer(substream); +} + +static int fwspk_prepare(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + int err; + + mutex_lock(&fwspk->mutex); + + if (amdtp_streaming_error(&fwspk->stream)) + fwspk_stop_stream(fwspk); + + if (!amdtp_stream_running(&fwspk->stream)) { + err = cmp_connection_establish(&fwspk->connection, + amdtp_stream_get_max_payload(&fwspk->stream)); + if (err < 0) + goto err_mutex; + + err = amdtp_stream_start(&fwspk->stream, + fwspk->connection.resources.channel, + fwspk->connection.speed); + if (err < 0) + goto err_connection; + } + + mutex_unlock(&fwspk->mutex); + + amdtp_stream_pcm_prepare(&fwspk->stream); + + return 0; + +err_connection: + cmp_connection_break(&fwspk->connection); +err_mutex: + mutex_unlock(&fwspk->mutex); + + return err; +} + +static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd) +{ + struct fwspk *fwspk = substream->private_data; + struct snd_pcm_substream *pcm; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + pcm = substream; + break; + case SNDRV_PCM_TRIGGER_STOP: + pcm = NULL; + break; + default: + return -EINVAL; + } + amdtp_stream_pcm_trigger(&fwspk->stream, pcm); + return 0; +} + +static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + + return amdtp_stream_pcm_pointer(&fwspk->stream); +} + +static int fwspk_create_pcm(struct fwspk *fwspk) +{ + static struct snd_pcm_ops ops = { + .open = fwspk_open, + .close = fwspk_close, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = fwspk_hw_params, + .hw_free = fwspk_hw_free, + .prepare = fwspk_prepare, + .trigger = fwspk_trigger, + .pointer = fwspk_pointer, + .page = snd_pcm_lib_get_vmalloc_page, + .mmap = snd_pcm_lib_mmap_vmalloc, + }; + struct snd_pcm *pcm; + int err; + + err = snd_pcm_new(fwspk->card, "OXFW970", 0, 1, 0, &pcm); + if (err < 0) + return err; + pcm->private_data = fwspk; + strcpy(pcm->name, fwspk->device_info->short_name); + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops); + return 0; +} + +enum control_action { CTL_READ, CTL_WRITE }; +enum control_attribute { + CTL_MIN = 0x02, + CTL_MAX = 0x03, + CTL_CURRENT = 0x10, +}; + +static int fwspk_mute_command(struct fwspk *fwspk, bool *value, + enum control_action action) +{ + u8 *buf; + u8 response_ok; + int err; + + buf = kmalloc(11, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + if (action == CTL_READ) { + buf[0] = 0x01; /* AV/C, STATUS */ + response_ok = 0x0c; /* STABLE */ + } else { + buf[0] = 0x00; /* AV/C, CONTROL */ + response_ok = 0x09; /* ACCEPTED */ + } + buf[1] = 0x08; /* audio unit 0 */ + buf[2] = 0xb8; /* FUNCTION BLOCK */ + buf[3] = 0x81; /* function block type: feature */ + buf[4] = fwspk->device_info->mute_fb_id; /* function block ID */ + buf[5] = 0x10; /* control attribute: current */ + buf[6] = 0x02; /* selector length */ + buf[7] = 0x00; /* audio channel number */ + buf[8] = 0x01; /* control selector: mute */ + buf[9] = 0x01; /* control data length */ + if (action == CTL_READ) + buf[10] = 0xff; + else + buf[10] = *value ? 0x70 : 0x60; + + err = fcp_avc_transaction(fwspk->unit, buf, 11, buf, 11, 0x3fe); + if (err < 0) + goto error; + if (err < 11) { + dev_err(&fwspk->unit->device, "short FCP response\n"); + err = -EIO; + goto error; + } + if (buf[0] != response_ok) { + dev_err(&fwspk->unit->device, "mute command failed\n"); + err = -EIO; + goto error; + } + if (action == CTL_READ) + *value = buf[10] == 0x70; + + err = 0; + +error: + kfree(buf); + + return err; +} + +static int fwspk_volume_command(struct fwspk *fwspk, s16 *value, + unsigned int channel, + enum control_attribute attribute, + enum control_action action) +{ + u8 *buf; + u8 response_ok; + int err; + + buf = kmalloc(12, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + if (action == CTL_READ) { + buf[0] = 0x01; /* AV/C, STATUS */ + response_ok = 0x0c; /* STABLE */ + } else { + buf[0] = 0x00; /* AV/C, CONTROL */ + response_ok = 0x09; /* ACCEPTED */ + } + buf[1] = 0x08; /* audio unit 0 */ + buf[2] = 0xb8; /* FUNCTION BLOCK */ + buf[3] = 0x81; /* function block type: feature */ + buf[4] = fwspk->device_info->volume_fb_id; /* function block ID */ + buf[5] = attribute; /* control attribute */ + buf[6] = 0x02; /* selector length */ + buf[7] = channel; /* audio channel number */ + buf[8] = 0x02; /* control selector: volume */ + buf[9] = 0x02; /* control data length */ + if (action == CTL_READ) { + buf[10] = 0xff; + buf[11] = 0xff; + } else { + buf[10] = *value >> 8; + buf[11] = *value; + } + + err = fcp_avc_transaction(fwspk->unit, buf, 12, buf, 12, 0x3fe); + if (err < 0) + goto error; + if (err < 12) { + dev_err(&fwspk->unit->device, "short FCP response\n"); + err = -EIO; + goto error; + } + if (buf[0] != response_ok) { + dev_err(&fwspk->unit->device, "volume command failed\n"); + err = -EIO; + goto error; + } + if (action == CTL_READ) + *value = (buf[10] << 8) | buf[11]; + + err = 0; + +error: + kfree(buf); + + return err; +} + +static int fwspk_mute_get(struct snd_kcontrol *control, + struct snd_ctl_elem_value *value) +{ + struct fwspk *fwspk = control->private_data; + + value->value.integer.value[0] = !fwspk->mute; + + return 0; +} + +static int fwspk_mute_put(struct snd_kcontrol *control, + struct snd_ctl_elem_value *value) +{ + struct fwspk *fwspk = control->private_data; + bool mute; + int err; + + mute = !value->value.integer.value[0]; + + if (mute == fwspk->mute) + return 0; + + err = fwspk_mute_command(fwspk, &mute, CTL_WRITE); + if (err < 0) + return err; + fwspk->mute = mute; + + return 1; +} + +static int fwspk_volume_info(struct snd_kcontrol *control, + struct snd_ctl_elem_info *info) +{ + struct fwspk *fwspk = control->private_data; + + info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + info->count = fwspk->device_info->mixer_channels; + info->value.integer.min = fwspk->volume_min; + info->value.integer.max = fwspk->volume_max; + + return 0; +} + +static const u8 channel_map[6] = { 0, 1, 4, 5, 2, 3 }; + +static int fwspk_volume_get(struct snd_kcontrol *control, + struct snd_ctl_elem_value *value) +{ + struct fwspk *fwspk = control->private_data; + unsigned int i; + + for (i = 0; i < fwspk->device_info->mixer_channels; ++i) + value->value.integer.value[channel_map[i]] = fwspk->volume[i]; + + return 0; +} + +static int fwspk_volume_put(struct snd_kcontrol *control, + struct snd_ctl_elem_value *value) +{ + struct fwspk *fwspk = control->private_data; + unsigned int i, changed_channels; + bool equal_values = true; + s16 volume; + int err; + + for (i = 0; i < fwspk->device_info->mixer_channels; ++i) { + if (value->value.integer.value[i] < fwspk->volume_min || + value->value.integer.value[i] > fwspk->volume_max) + return -EINVAL; + if (value->value.integer.value[i] != + value->value.integer.value[0]) + equal_values = false; + } + + changed_channels = 0; + for (i = 0; i < fwspk->device_info->mixer_channels; ++i) + if (value->value.integer.value[channel_map[i]] != + fwspk->volume[i]) + changed_channels |= 1 << (i + 1); + + if (equal_values && changed_channels != 0) + changed_channels = 1 << 0; + + for (i = 0; i <= fwspk->device_info->mixer_channels; ++i) { + volume = value->value.integer.value[channel_map[i ? i - 1 : 0]]; + if (changed_channels & (1 << i)) { + err = fwspk_volume_command(fwspk, &volume, i, + CTL_CURRENT, CTL_WRITE); + if (err < 0) + return err; + } + if (i > 0) + fwspk->volume[i - 1] = volume; + } + + return changed_channels != 0; +} + +static int fwspk_create_mixer(struct fwspk *fwspk) +{ + static const struct snd_kcontrol_new controls[] = { + { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "PCM Playback Switch", + .info = snd_ctl_boolean_mono_info, + .get = fwspk_mute_get, + .put = fwspk_mute_put, + }, + { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "PCM Playback Volume", + .info = fwspk_volume_info, + .get = fwspk_volume_get, + .put = fwspk_volume_put, + }, + }; + unsigned int i, first_ch; + int err; + + err = fwspk_volume_command(fwspk, &fwspk->volume_min, + 0, CTL_MIN, CTL_READ); + if (err < 0) + return err; + err = fwspk_volume_command(fwspk, &fwspk->volume_max, + 0, CTL_MAX, CTL_READ); + if (err < 0) + return err; + + err = fwspk_mute_command(fwspk, &fwspk->mute, CTL_READ); + if (err < 0) + return err; + + first_ch = fwspk->device_info->mixer_channels == 1 ? 0 : 1; + for (i = 0; i < fwspk->device_info->mixer_channels; ++i) { + err = fwspk_volume_command(fwspk, &fwspk->volume[i], + first_ch + i, CTL_CURRENT, CTL_READ); + if (err < 0) + return err; + } + + for (i = 0; i < ARRAY_SIZE(controls); ++i) { + err = snd_ctl_add(fwspk->card, + snd_ctl_new1(&controls[i], fwspk)); + if (err < 0) + return err; + } + + return 0; +} + +static u32 fwspk_read_firmware_version(struct fw_unit *unit) +{ + __be32 data; + int err; + + err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST, + OXFORD_FIRMWARE_ID_ADDRESS, &data, 4, 0); + return err >= 0 ? be32_to_cpu(data) : 0; +} + +static void fwspk_card_free(struct snd_card *card) +{ + struct fwspk *fwspk = card->private_data; + + amdtp_stream_destroy(&fwspk->stream); + cmp_connection_destroy(&fwspk->connection); + fw_unit_put(fwspk->unit); + mutex_destroy(&fwspk->mutex); +} + +static int fwspk_probe(struct fw_unit *unit, + const struct ieee1394_device_id *id) +{ + struct fw_device *fw_dev = fw_parent_device(unit); + struct snd_card *card; + struct fwspk *fwspk; + u32 firmware; + int err; + + err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card); + if (err < 0) + return err; + snd_card_set_dev(card, &unit->device); + + fwspk = card->private_data; + fwspk->card = card; + mutex_init(&fwspk->mutex); + fwspk->unit = fw_unit_get(unit); + fwspk->device_info = (const struct device_info *)id->driver_data; + + err = cmp_connection_init(&fwspk->connection, unit, CMP_INPUT, 0); + if (err < 0) + goto err_unit; + + err = amdtp_stream_init(&fwspk->stream, unit, AMDTP_OUT_STREAM, + CIP_NONBLOCKING); + if (err < 0) + goto err_connection; + + card->private_free = fwspk_card_free; + + strcpy(card->driver, fwspk->device_info->driver_name); + strcpy(card->shortname, fwspk->device_info->short_name); + firmware = fwspk_read_firmware_version(unit); + snprintf(card->longname, sizeof(card->longname), + "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d", + fwspk->device_info->long_name, + firmware >> 20, firmware & 0xffff, + fw_dev->config_rom[3], fw_dev->config_rom[4], + dev_name(&unit->device), 100 << fw_dev->max_speed); + strcpy(card->mixername, "OXFW970"); + + err = fwspk_create_pcm(fwspk); + if (err < 0) + goto error; + + err = fwspk_create_mixer(fwspk); + if (err < 0) + goto error; + + err = snd_card_register(card); + if (err < 0) + goto error; + + dev_set_drvdata(&unit->device, fwspk); + + return 0; + +err_connection: + cmp_connection_destroy(&fwspk->connection); +err_unit: + fw_unit_put(fwspk->unit); + mutex_destroy(&fwspk->mutex); +error: + snd_card_free(card); + return err; +} + +static void fwspk_bus_reset(struct fw_unit *unit) +{ + struct fwspk *fwspk = dev_get_drvdata(&unit->device); + + fcp_bus_reset(fwspk->unit); + + if (cmp_connection_update(&fwspk->connection) < 0) { + amdtp_stream_pcm_abort(&fwspk->stream); + mutex_lock(&fwspk->mutex); + fwspk_stop_stream(fwspk); + mutex_unlock(&fwspk->mutex); + return; + } + + amdtp_stream_update(&fwspk->stream); +} + +static void fwspk_remove(struct fw_unit *unit) +{ + struct fwspk *fwspk = dev_get_drvdata(&unit->device); + + amdtp_stream_pcm_abort(&fwspk->stream); + snd_card_disconnect(fwspk->card); + + mutex_lock(&fwspk->mutex); + fwspk_stop_stream(fwspk); + mutex_unlock(&fwspk->mutex); + + snd_card_free_when_closed(fwspk->card); +} + +static const struct device_info griffin_firewave = { + .driver_name = "FireWave", + .short_name = "FireWave", + .long_name = "Griffin FireWave Surround", + .pcm_constraints = firewave_constraints, + .mixer_channels = 6, + .mute_fb_id = 0x01, + .volume_fb_id = 0x02, +}; + +static const struct device_info lacie_speakers = { + .driver_name = "FWSpeakers", + .short_name = "FireWire Speakers", + .long_name = "LaCie FireWire Speakers", + .pcm_constraints = lacie_speakers_constraints, + .mixer_channels = 1, + .mute_fb_id = 0x01, + .volume_fb_id = 0x01, +}; + +static const struct ieee1394_device_id fwspk_id_table[] = { + { + .match_flags = IEEE1394_MATCH_VENDOR_ID | + IEEE1394_MATCH_MODEL_ID | + IEEE1394_MATCH_SPECIFIER_ID | + IEEE1394_MATCH_VERSION, + .vendor_id = VENDOR_GRIFFIN, + .model_id = 0x00f970, + .specifier_id = SPECIFIER_1394TA, + .version = VERSION_AVC, + .driver_data = (kernel_ulong_t)&griffin_firewave, + }, + { + .match_flags = IEEE1394_MATCH_VENDOR_ID | + IEEE1394_MATCH_MODEL_ID | + IEEE1394_MATCH_SPECIFIER_ID | + IEEE1394_MATCH_VERSION, + .vendor_id = VENDOR_LACIE, + .model_id = 0x00f970, + .specifier_id = SPECIFIER_1394TA, + .version = VERSION_AVC, + .driver_data = (kernel_ulong_t)&lacie_speakers, + }, + { } +}; +MODULE_DEVICE_TABLE(ieee1394, fwspk_id_table); + +static struct fw_driver fwspk_driver = { + .driver = { + .owner = THIS_MODULE, + .name = KBUILD_MODNAME, + .bus = &fw_bus_type, + }, + .probe = fwspk_probe, + .update = fwspk_bus_reset, + .remove = fwspk_remove, + .id_table = fwspk_id_table, +}; + +static int __init alsa_fwspk_init(void) +{ + return driver_register(&fwspk_driver.driver); +} + +static void __exit alsa_fwspk_exit(void) +{ + driver_unregister(&fwspk_driver.driver); +} + +module_init(alsa_fwspk_init); +module_exit(alsa_fwspk_exit);

To make it easy to work in followed commit.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/speakers/Makefile | 2 +- sound/firewire/speakers/speakers.c | 248 +------------------------------ sound/firewire/speakers/speakers.h | 5 + sound/firewire/speakers/speakers_pcm.c | 259 +++++++++++++++++++++++++++++++++ 4 files changed, 266 insertions(+), 248 deletions(-) create mode 100644 sound/firewire/speakers/speakers_pcm.c

diff --git a/sound/firewire/speakers/Makefile b/sound/firewire/speakers/Makefile index f46ae1d..a970ccf 100644 --- a/sound/firewire/speakers/Makefile +++ b/sound/firewire/speakers/Makefile @@ -1,2 +1,2 @@ -snd-firewire-speakers-objs := speakers_stream.o speakers.o +snd-firewire-speakers-objs := speakers_stream.o speakers_pcm.o speakers.o obj-m += snd-firewire-speakers.o diff --git a/sound/firewire/speakers/speakers.c b/sound/firewire/speakers/speakers.c index 47d3cc0..20bba46 100644 --- a/sound/firewire/speakers/speakers.c +++ b/sound/firewire/speakers/speakers.c @@ -24,252 +24,6 @@ MODULE_DESCRIPTION("FireWire speakers driver"); MODULE_AUTHOR("Clemens Ladisch clemens@ladisch.de"); MODULE_LICENSE("GPL v2");

-static int firewave_rate_constraint(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) -{ - static unsigned int stereo_rates[] = { 48000, 96000 }; - struct snd_interval *channels = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *rate = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); - - /* two channels work only at 48/96 kHz */ - if (snd_interval_max(channels) < 6) - return snd_interval_list(rate, 2, stereo_rates, 0); - return 0; -} - -static int firewave_channels_constraint(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) -{ - static const struct snd_interval all_channels = { .min = 6, .max = 6 }; - struct snd_interval *rate = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); - struct snd_interval *channels = - hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - - /* 32/44.1 kHz work only with all six channels */ - if (snd_interval_max(rate) < 48000) - return snd_interval_refine(channels, &all_channels); - return 0; -} - -static int firewave_constraints(struct snd_pcm_runtime *runtime) -{ - static unsigned int channels_list[] = { 2, 6 }; - static struct snd_pcm_hw_constraint_list channels_list_constraint = { - .count = 2, - .list = channels_list, - }; - int err; - - runtime->hw.rates = SNDRV_PCM_RATE_32000 | - SNDRV_PCM_RATE_44100 | - SNDRV_PCM_RATE_48000 | - SNDRV_PCM_RATE_96000; - runtime->hw.channels_max = 6; - - err = snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_CHANNELS, - &channels_list_constraint); - if (err < 0) - return err; - err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, - firewave_rate_constraint, NULL, - SNDRV_PCM_HW_PARAM_CHANNELS, -1); - if (err < 0) - return err; - err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, - firewave_channels_constraint, NULL, - SNDRV_PCM_HW_PARAM_RATE, -1); - if (err < 0) - return err; - - return 0; -} - -static int lacie_speakers_constraints(struct snd_pcm_runtime *runtime) -{ - runtime->hw.rates = SNDRV_PCM_RATE_32000 | - SNDRV_PCM_RATE_44100 | - SNDRV_PCM_RATE_48000 | - SNDRV_PCM_RATE_88200 | - SNDRV_PCM_RATE_96000; - - return 0; -} - -static int fwspk_open(struct snd_pcm_substream *substream) -{ - static const struct snd_pcm_hardware hardware = { - .info = SNDRV_PCM_INFO_MMAP | - SNDRV_PCM_INFO_MMAP_VALID | - SNDRV_PCM_INFO_BATCH | - SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER, - .formats = AMDTP_OUT_PCM_FORMAT_BITS, - .channels_min = 2, - .channels_max = 2, - .buffer_bytes_max = 4 * 1024 * 1024, - .period_bytes_min = 1, - .period_bytes_max = UINT_MAX, - .periods_min = 1, - .periods_max = UINT_MAX, - }; - struct fwspk *fwspk = substream->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; - int err; - - runtime->hw = hardware; - - err = fwspk->device_info->pcm_constraints(runtime); - if (err < 0) - return err; - err = snd_pcm_limit_hw_rates(runtime); - if (err < 0) - return err; - - err = snd_pcm_hw_constraint_minmax(runtime, - SNDRV_PCM_HW_PARAM_PERIOD_TIME, - 5000, UINT_MAX); - if (err < 0) - return err; - - err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); - if (err < 0) - return err; - - return 0; -} - -static int fwspk_close(struct snd_pcm_substream *substream) -{ - return 0; -} - -static int fwspk_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - struct fwspk *fwspk = substream->private_data; - int err; - - mutex_lock(&fwspk->mutex); - snd_fwspk_stream_stop(fwspk); - mutex_unlock(&fwspk->mutex); - - err = snd_pcm_lib_alloc_vmalloc_buffer(substream, - params_buffer_bytes(hw_params)); - if (err < 0) - goto error; - - amdtp_stream_set_parameters(&fwspk->rx_stream, - params_rate(hw_params), - params_channels(hw_params), - 0); - - amdtp_stream_set_pcm_format(&fwspk->rx_stream, - params_format(hw_params)); - - err = avc_general_set_sig_fmt(fwspk->unit, params_rate(hw_params), - AVC_GENERAL_PLUG_DIR_IN, 0); - if (err < 0) - goto err_buffer; - if (err != 0x09 /* ACCEPTED */) { - dev_err(&fwspk->unit->device, "failed to set sample rate\n"); - err = -EIO; - goto error; - } - - return 0; - -err_buffer: - snd_pcm_lib_free_vmalloc_buffer(substream); -error: - return err; -} - -static int fwspk_hw_free(struct snd_pcm_substream *substream) -{ - struct fwspk *fwspk = substream->private_data; - - mutex_lock(&fwspk->mutex); - snd_fwspk_stream_stop(fwspk); - mutex_unlock(&fwspk->mutex); - - return snd_pcm_lib_free_vmalloc_buffer(substream); -} - -static int fwspk_prepare(struct snd_pcm_substream *substream) -{ - struct fwspk *fwspk = substream->private_data; - int err; - - mutex_lock(&fwspk->mutex); - - snd_fwspk_stream_stop(fwspk); - - err = snd_fwspk_stream_start(fwspk); - if (err < 0) - goto end; - - amdtp_stream_pcm_prepare(&fwspk->rx_stream); -end: - mutex_unlock(&fwspk->mutex); - return err; -} - -static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd) -{ - struct fwspk *fwspk = substream->private_data; - struct snd_pcm_substream *pcm; - - switch (cmd) { - case SNDRV_PCM_TRIGGER_START: - pcm = substream; - break; - case SNDRV_PCM_TRIGGER_STOP: - pcm = NULL; - break; - default: - return -EINVAL; - } - amdtp_stream_pcm_trigger(&fwspk->rx_stream, pcm); - return 0; -} - -static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream) -{ - struct fwspk *fwspk = substream->private_data; - - return amdtp_stream_pcm_pointer(&fwspk->rx_stream); -} - -static int fwspk_create_pcm(struct fwspk *fwspk) -{ - static struct snd_pcm_ops ops = { - .open = fwspk_open, - .close = fwspk_close, - .ioctl = snd_pcm_lib_ioctl, - .hw_params = fwspk_hw_params, - .hw_free = fwspk_hw_free, - .prepare = fwspk_prepare, - .trigger = fwspk_trigger, - .pointer = fwspk_pointer, - .page = snd_pcm_lib_get_vmalloc_page, - .mmap = snd_pcm_lib_mmap_vmalloc, - }; - struct snd_pcm *pcm; - int err; - - err = snd_pcm_new(fwspk->card, "OXFW970", 0, 1, 0, &pcm); - if (err < 0) - return err; - pcm->private_data = fwspk; - strcpy(pcm->name, fwspk->device_info->short_name); - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops); - return 0; -} - enum control_action { CTL_READ, CTL_WRITE }; enum control_attribute { CTL_MIN = 0x02, @@ -602,7 +356,7 @@ static int fwspk_probe(struct fw_unit *unit, if (err < 0) goto err_card;

- err = fwspk_create_pcm(fwspk); + err = snd_fwspk_create_pcm(fwspk); if (err < 0) goto err_card;

diff --git a/sound/firewire/speakers/speakers.h b/sound/firewire/speakers/speakers.h index d322b8b..379196d 100644 --- a/sound/firewire/speakers/speakers.h +++ b/sound/firewire/speakers/speakers.h @@ -52,3 +52,8 @@ int snd_fwspk_stream_start(struct fwspk *fwspk); void snd_fwspk_stream_stop(struct fwspk *fwspk); void snd_fwspk_stream_destroy(struct fwspk *fwspk); void snd_fwspk_stream_update(struct fwspk *fwspk); + +int snd_fwspk_create_pcm(struct fwspk *fwspk); + +int firewave_constraints(struct snd_pcm_runtime *runtime); +int lacie_speakers_constraints(struct snd_pcm_runtime *runtime); diff --git a/sound/firewire/speakers/speakers_pcm.c b/sound/firewire/speakers/speakers_pcm.c new file mode 100644 index 0000000..8fa437f --- /dev/null +++ b/sound/firewire/speakers/speakers_pcm.c @@ -0,0 +1,259 @@ +/* + * speakers_pcm.c - a part of OXFW970/971-based speakers driver + * + * Copyright (c) Clemens Ladisch clemens@ladisch.de + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "speakers.h" + +static int firewave_rate_constraint(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + static unsigned int stereo_rates[] = { 48000, 96000 }; + struct snd_interval *channels = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + struct snd_interval *rate = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + + /* two channels work only at 48/96 kHz */ + if (snd_interval_max(channels) < 6) + return snd_interval_list(rate, 2, stereo_rates, 0); + return 0; +} + +static int firewave_channels_constraint(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + static const struct snd_interval all_channels = { .min = 6, .max = 6 }; + struct snd_interval *rate = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + struct snd_interval *channels = + hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + + /* 32/44.1 kHz work only with all six channels */ + if (snd_interval_max(rate) < 48000) + return snd_interval_refine(channels, &all_channels); + return 0; +} + +int firewave_constraints(struct snd_pcm_runtime *runtime) +{ + static unsigned int channels_list[] = { 2, 6 }; + static struct snd_pcm_hw_constraint_list channels_list_constraint = { + .count = 2, + .list = channels_list, + }; + int err; + + runtime->hw.rates = SNDRV_PCM_RATE_32000 | + SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_96000; + runtime->hw.channels_max = 6; + + err = snd_pcm_hw_constraint_list(runtime, 0, + SNDRV_PCM_HW_PARAM_CHANNELS, + &channels_list_constraint); + if (err < 0) + return err; + err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, + firewave_rate_constraint, NULL, + SNDRV_PCM_HW_PARAM_CHANNELS, -1); + if (err < 0) + return err; + err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, + firewave_channels_constraint, NULL, + SNDRV_PCM_HW_PARAM_RATE, -1); + if (err < 0) + return err; + + return 0; +} + +int lacie_speakers_constraints(struct snd_pcm_runtime *runtime) +{ + runtime->hw.rates = SNDRV_PCM_RATE_32000 | + SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_88200 | + SNDRV_PCM_RATE_96000; + + return 0; +} + +static int fwspk_open(struct snd_pcm_substream *substream) +{ + static const struct snd_pcm_hardware hardware = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_BATCH | + SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_BLOCK_TRANSFER, + .formats = AMDTP_OUT_PCM_FORMAT_BITS, + .channels_min = 2, + .channels_max = 2, + .buffer_bytes_max = 4 * 1024 * 1024, + .period_bytes_min = 1, + .period_bytes_max = UINT_MAX, + .periods_min = 1, + .periods_max = UINT_MAX, + }; + struct fwspk *fwspk = substream->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; + bool used; + int err; + + err = cmp_connection_check_used(&fwspk->in_conn, &used); + if ((err < 0) || used) + goto end; + + runtime->hw = hardware; + + err = fwspk->device_info->pcm_constraints(runtime); + if (err < 0) + goto end; + err = snd_pcm_limit_hw_rates(runtime); + if (err < 0) + goto end; + + err = snd_pcm_hw_constraint_minmax(runtime, + SNDRV_PCM_HW_PARAM_PERIOD_TIME, + 5000, UINT_MAX); + if (err < 0) + goto end; + + err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); + if (err < 0) + goto end; +end: + return err; +} + +static int fwspk_close(struct snd_pcm_substream *substream) +{ + return 0; +} + +static int fwspk_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *hw_params) +{ + struct fwspk *fwspk = substream->private_data; + int err; + + mutex_lock(&fwspk->mutex); + snd_fwspk_stream_stop(fwspk); + mutex_unlock(&fwspk->mutex); + + err = snd_pcm_lib_alloc_vmalloc_buffer(substream, + params_buffer_bytes(hw_params)); + if (err < 0) + goto error; + + amdtp_stream_set_parameters(&fwspk->rx_stream, + params_rate(hw_params), + params_channels(hw_params), + 0); + + amdtp_stream_set_pcm_format(&fwspk->rx_stream, + params_format(hw_params)); + + err = avc_general_set_sig_fmt(fwspk->unit, params_rate(hw_params), + AVC_GENERAL_PLUG_DIR_IN, 0); + if (err < 0) + goto err_buffer; + if (err != 0x09 /* ACCEPTED */) { + dev_err(&fwspk->unit->device, "failed to set sample rate\n"); + err = -EIO; + goto error; + } + + return 0; + +err_buffer: + snd_pcm_lib_free_vmalloc_buffer(substream); +error: + return err; +} + +static int fwspk_hw_free(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + + mutex_lock(&fwspk->mutex); + snd_fwspk_stream_stop(fwspk); + mutex_unlock(&fwspk->mutex); + + return snd_pcm_lib_free_vmalloc_buffer(substream); +} + +static int fwspk_prepare(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + int err; + + mutex_lock(&fwspk->mutex); + + snd_fwspk_stream_stop(fwspk); + + err = snd_fwspk_stream_start(fwspk); + if (err < 0) + goto end; + + amdtp_stream_pcm_prepare(&fwspk->rx_stream); +end: + mutex_unlock(&fwspk->mutex); + return err; +} + +static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd) +{ + struct fwspk *fwspk = substream->private_data; + struct snd_pcm_substream *pcm; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + pcm = substream; + break; + case SNDRV_PCM_TRIGGER_STOP: + pcm = NULL; + break; + default: + return -EINVAL; + } + amdtp_stream_pcm_trigger(&fwspk->rx_stream, pcm); + return 0; +} + +static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + + return amdtp_stream_pcm_pointer(&fwspk->rx_stream); +} + +int snd_fwspk_create_pcm(struct fwspk *fwspk) +{ + static struct snd_pcm_ops ops = { + .open = fwspk_open, + .close = fwspk_close, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = fwspk_hw_params, + .hw_free = fwspk_hw_free, + .prepare = fwspk_prepare, + .trigger = fwspk_trigger, + .pointer = fwspk_pointer, + .page = snd_pcm_lib_get_vmalloc_page, + .mmap = snd_pcm_lib_mmap_vmalloc, + }; + struct snd_pcm *pcm; + int err; + + err = snd_pcm_new(fwspk->card, fwspk->card->driver, 0, 1, 0, &pcm); + if (err < 0) + return err; + pcm->private_data = fwspk; + strcpy(pcm->name, fwspk->card->shortname); + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops); + return 0; +}

'struct snd_card' has four members for name, 'driver', 'shortname', 'longname' and 'mixername'. The 'driver' is used to detect card configuration file but the others are not used for important functionality. So I name them with the information from config ROM.

This commit adds 'name_card()' function and change the way to name card. The 'driver' is still given by 'struct device_info'. The 'shortname' and 'mixername' is given by 'model' and the 'longname' is given by 'vendor' and 'model'.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/speakers/speakers.c | 59 ++++++++++++++++++++++++-------------- 1 file changed, 38 insertions(+), 21 deletions(-)

diff --git a/sound/firewire/speakers/speakers.c b/sound/firewire/speakers/speakers.c index 187377e..1b5556b 100644 --- a/sound/firewire/speakers/speakers.c +++ b/sound/firewire/speakers/speakers.c @@ -24,14 +24,44 @@ MODULE_DESCRIPTION("FireWire speakers driver"); MODULE_AUTHOR("Clemens Ladisch clemens@ladisch.de"); MODULE_LICENSE("GPL v2");

-static u32 fwspk_read_firmware_version(struct fw_unit *unit) +static int name_card(struct fwspk *fwspk) { - __be32 data; + struct fw_device *fw_dev = fw_parent_device(fwspk->unit); + char vendor[24] = {0}; + char model[24] = {0}; + u32 firmware; int err;

- err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST, - OXFORD_FIRMWARE_ID_ADDRESS, &data, 4, 0); - return err >= 0 ? be32_to_cpu(data) : 0; + /* get vendor name from root directory */ + err = fw_csr_string(fw_dev->config_rom + 5, CSR_VENDOR, + vendor, sizeof(vendor)); + if (err < 0) + goto end; + + /* get model name from unit directory */ + err = fw_csr_string(fwspk->unit->directory, CSR_MODEL, + model, sizeof(model)); + if (err < 0) + goto end; + + err = snd_fw_transaction(fwspk->unit, TCODE_READ_QUADLET_REQUEST, + OXFORD_FIRMWARE_ID_ADDRESS, &firmware, 4, 0); + if (err < 0) + goto end; + be32_to_cpus(&firmware); + + strcpy(fwspk->card->driver, fwspk->device_info->driver_name); + strcpy(fwspk->card->shortname, model); + + snprintf(fwspk->card->longname, sizeof(fwspk->card->longname), + "%s %s (OXFW%x %04x), GUID %08x%08x at %s, S%d", + vendor, model, firmware >> 20, firmware & 0xffff, + fw_dev->config_rom[3], fw_dev->config_rom[4], + dev_name(&fwspk->unit->device), 100 << fw_dev->max_speed); + + strcpy(fwspk->card->mixername, fwspk->card->shortname); +end: + return err; }

static void fwspk_card_free(struct snd_card *card) @@ -49,10 +79,8 @@ static void fwspk_card_free(struct snd_card *card) static int fwspk_probe(struct fw_unit *unit, const struct ieee1394_device_id *id) { - struct fw_device *fw_dev = fw_parent_device(unit); struct snd_card *card; struct fwspk *fwspk; - u32 firmware; int err;

err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card); @@ -66,16 +94,9 @@ static int fwspk_probe(struct fw_unit *unit, fwspk->device_info = (const struct device_info *)id->driver_data; mutex_init(&fwspk->mutex);

- strcpy(card->driver, fwspk->device_info->driver_name); - strcpy(card->shortname, fwspk->device_info->short_name); - firmware = fwspk_read_firmware_version(unit); - snprintf(card->longname, sizeof(card->longname), - "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d", - fwspk->device_info->long_name, - firmware >> 20, firmware & 0xffff, - fw_dev->config_rom[3], fw_dev->config_rom[4], - dev_name(&unit->device), 100 << fw_dev->max_speed); - strcpy(card->mixername, "OXFW970"); + err = name_card(fwspk); + if (err < 0) + goto err_card;

err = snd_fwspk_stream_init(fwspk); if (err < 0) @@ -124,8 +145,6 @@ static void fwspk_remove(struct fw_unit *unit)

static const struct device_info griffin_firewave = { .driver_name = "FireWave", - .short_name = "FireWave", - .long_name = "Griffin FireWave Surround", .pcm_constraints = firewave_constraints, .mixer_channels = 6, .mute_fb_id = 0x01, @@ -134,8 +153,6 @@ static const struct device_info griffin_firewave = {

static const struct device_info lacie_speakers = { .driver_name = "FWSpeakers", - .short_name = "FireWire Speakers", - .long_name = "LaCie FireWire Speakers", .pcm_constraints = lacie_speakers_constraints, .mixer_channels = 1, .mute_fb_id = 0x01,

The previous commit adds stream formation. This commit adds proc interface to get information about stream: - stream formation - current sampling rate

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/speakers/Makefile | 2 +- sound/firewire/speakers/speakers.c | 2 ++ sound/firewire/speakers/speakers.h | 2 ++ sound/firewire/speakers/speakers_proc.c | 54 +++++++++++++++++++++++++++++++++ 4 files changed, 59 insertions(+), 1 deletion(-) create mode 100644 sound/firewire/speakers/speakers_proc.c

diff --git a/sound/firewire/speakers/Makefile b/sound/firewire/speakers/Makefile index 8ee55ee..8936816 100644 --- a/sound/firewire/speakers/Makefile +++ b/sound/firewire/speakers/Makefile @@ -1,3 +1,3 @@ snd-firewire-speakers-objs := speakers_stream.o speakers_pcm.o speakers_control.o \ - speakers.o + speakers_proc.o speakers.o obj-m += snd-firewire-speakers.o diff --git a/sound/firewire/speakers/speakers.c b/sound/firewire/speakers/speakers.c index e07ed5f..8c3bf4a 100644 --- a/sound/firewire/speakers/speakers.c +++ b/sound/firewire/speakers/speakers.c @@ -131,6 +131,8 @@ static int fwspk_probe(struct fw_unit *unit, if (err < 0) goto err_card;

+ snd_fwspk_proc_init(fwspk); + snd_card_set_dev(card, &unit->device); err = snd_card_register(card); if (err < 0) diff --git a/sound/firewire/speakers/speakers.h b/sound/firewire/speakers/speakers.h index d3029f0..977db20 100644 --- a/sound/firewire/speakers/speakers.h +++ b/sound/firewire/speakers/speakers.h @@ -18,6 +18,7 @@ #include <sound/initval.h> #include <sound/pcm.h> #include <sound/pcm_params.h> +#include <sound/info.h>

#include "../cmp.h" #include "../fcp.h" @@ -69,3 +70,4 @@ int snd_fwspk_create_pcm(struct fwspk *fwspk);

int snd_fwspk_create_mixer(struct fwspk *fwspk);

+void snd_fwspk_proc_init(struct fwspk *fwspk); diff --git a/sound/firewire/speakers/speakers_proc.c b/sound/firewire/speakers/speakers_proc.c new file mode 100644 index 0000000..9721e52 --- /dev/null +++ b/sound/firewire/speakers/speakers_proc.c @@ -0,0 +1,54 @@ +/* + * speakers_proc.c - a part of driver for OXFW970/971 based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "./speakers.h" + +static void +proc_read_formation(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) +{ + struct fwspk *fwspk = entry->private_data; + struct fwspk_stream_formation *formation; + unsigned int i; + + snd_iprintf(buffer, "Input Stream to device:\n"); + snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n"); + formation = fwspk->rx_stream_formations; + for (i = 0; i < FWSPK_STREAM_TABLE_ENTRIES; i++) { + snd_iprintf(buffer, + "\t%d\t%d\t%d\n", fwspk_rate_table[i], + formation[i].pcm, formation[i].midi); + } +} + +static void +proc_read_clock(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) +{ + struct fwspk *fwspk = entry->private_data; + unsigned int rate; + int err; + + err = avc_general_get_sig_fmt(fwspk->unit, &rate, + AVC_GENERAL_PLUG_DIR_IN, 0); + if ((err < 0) && (err == 0x09)) + snd_iprintf(buffer, "Sampling rate: %d\n", rate); +} + +void snd_fwspk_proc_init(struct fwspk *fwspk) +{ + struct snd_info_entry *entry; + + if (!snd_card_proc_new(fwspk->card, "#formation", &entry)) + snd_info_set_text_ops(entry, fwspk, proc_read_formation); + + if (!snd_card_proc_new(fwspk->card, "#clock", &entry)) + snd_info_set_text_ops(entry, fwspk, proc_read_clock); + + return; +}

OXFW970/971 may supports AV/C Stream Format Information Specification 1.1 Working Draft (Apr 2005, 1394TA). So this driver uses 'EXTENDED STREAM FORMAT INFORMATION' command.

This command has two subfunctions, 'SINGLE' and 'LIST'. Drivers can use 'SINGLE' subfunction to know current formation of AMDTP stream, Drivers can use 'LIST' subfunction to know an available formation of AMDTP stream in a certain sampling rate. Followed commit adds parser for returned information.

This commit adds 'inquiry' version of 'PLUG SIGNAL FORMAT' command. When device doesn't support 'LIST' subfunction of 'AV/C Stream Format Information' command, drivers can use 'inquiry' command to get supported sampling rates.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/speakers/Makefile | 2 +- sound/firewire/speakers/speakers.h | 30 +++++++ sound/firewire/speakers/speakers_command.c | 122 +++++++++++++++++++++++++++++ 3 files changed, 153 insertions(+), 1 deletion(-) create mode 100644 sound/firewire/speakers/speakers_command.c

diff --git a/sound/firewire/speakers/Makefile b/sound/firewire/speakers/Makefile index 8936816..86b2b6c 100644 --- a/sound/firewire/speakers/Makefile +++ b/sound/firewire/speakers/Makefile @@ -1,3 +1,3 @@ -snd-firewire-speakers-objs := speakers_stream.o speakers_pcm.o speakers_control.o \ +snd-firewire-speakers-objs := speakers_command.o speakers_stream.o speakers_pcm.o speakers_control.o \ speakers_proc.o speakers.o obj-m += snd-firewire-speakers.o diff --git a/sound/firewire/speakers/speakers.h b/sound/firewire/speakers/speakers.h index 90c65f4..386e267 100644 --- a/sound/firewire/speakers/speakers.h +++ b/sound/firewire/speakers/speakers.h @@ -57,6 +57,36 @@ struct fwspk { s16 volume_max; };

+/* AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA) */ +#define AVC_GENERIC_FRAME_MAXIMUM_BYTES 512 +int avc_stream_get_format(struct fw_unit *unit, + enum avc_general_plug_dir dir, unsigned int pid, + u8 *buf, unsigned int *len, + unsigned int eid); +static inline int +avc_stream_get_format_single(struct fw_unit *unit, + enum avc_general_plug_dir dir, unsigned int pid, + u8 *buf, unsigned int *len) +{ + return avc_stream_get_format(unit, dir, pid, buf, len, 0xff); +} +static inline int +avc_stream_get_format_list(struct fw_unit *unit, + enum avc_general_plug_dir dir, unsigned int pid, + u8 *buf, unsigned int *len, + unsigned int eid) +{ + return avc_stream_get_format(unit, dir, pid, buf, len, eid); +} + +/* + * AV/C Digital Interface Command Set General Specification 4.2 + * (Sep 2004, 1394TA) + */ +int avc_general_inquiry_sig_fmt(struct fw_unit *unit, unsigned int rate, + enum avc_general_plug_dir dir, + unsigned short pid); + int snd_fwspk_stream_init(struct fwspk *fwspk); int snd_fwspk_stream_start(struct fwspk *fwspk, unsigned int rate); void snd_fwspk_stream_stop(struct fwspk *fwspk); diff --git a/sound/firewire/speakers/speakers_command.c b/sound/firewire/speakers/speakers_command.c new file mode 100644 index 0000000..a13bc9e --- /dev/null +++ b/sound/firewire/speakers/speakers_command.c @@ -0,0 +1,122 @@ +/* + * speakers_command.c - part of OXFW970/971-based speakers driver + * + * Copyright (c) Takashi Sakamoto o-takashi@sakamocchi.jp + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "speakers.h" + +int avc_stream_get_format(struct fw_unit *unit, + enum avc_general_plug_dir dir, unsigned int pid, + u8 *buf, unsigned int *len, + unsigned int eid) +{ + unsigned int subfunc; + int err; + + /* check given buffer */ + if ((buf == NULL) || (*len < 12)) { + err = -EINVAL; + goto end; + } + + if (eid == 0xff) + subfunc = 0xc0; /* SINGLE */ + else + subfunc = 0xc1; /* LIST */ + + buf[0] = 0x01; /* STATUS */ + buf[1] = 0xff; /* UNIT */ + buf[2] = 0xbf; /* EXTENDED STREAM FORMAT INFORMATION */ + buf[3] = subfunc; /* SINGLE or LIST */ + buf[4] = dir; /* Plug Direction */ + buf[5] = 0x00; /* Unit */ + buf[6] = 0x00; /* PCR (Isochronous Plug) */ + buf[7] = 0xff & pid; /* Plug ID */ + buf[8] = 0xff; /* Padding */ + buf[9] = 0xff; /* support status in response */ + buf[10] = 0xff & eid; /* entry ID */ + buf[11] = 0xff; /* padding */ + + /* do transaction and check buf[1-7] are the same against command */ + err = fcp_avc_transaction(unit, buf, 12, buf, *len, + BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5) | + BIT(6) | BIT(7)); + if (err < 0) { + goto end; + /* reach the end of entries */ + } else if (buf[0] == 0x0a) { + err = 0; + *len = 0; + goto end; + } else if (buf[0] != 0x0c) { + err = -EINVAL; + goto end; + /* the content starts at 11th bytes */ + } else if (err < 9) { + err = -EIO; + goto end; + } else if ((subfunc == 0xc1) && (buf[10] != eid)) { + err = -EIO; + goto end; + } + + /* strip */ + memmove(buf, buf + 10, err - 10); + *len = err - 10; + err = 0; +end: + return err; +} + +int avc_general_inquiry_sig_fmt(struct fw_unit *unit, unsigned int rate, + enum avc_general_plug_dir dir, + unsigned short pid) +{ + unsigned int sfc; + u8 *buf; + int err; + + for (sfc = 0; sfc < CIP_SFC_COUNT; sfc++) { + if (amdtp_rate_table[sfc] == rate) + break; + } + if (sfc == CIP_SFC_COUNT) + return -EINVAL; + + buf = kzalloc(8, GFP_KERNEL); + if (buf == NULL) + return -ENOMEM; + + buf[0] = 0x02; /* SPECIFIC INQUIRY */ + buf[1] = 0xff; /* UNIT */ + if (dir == AVC_GENERAL_PLUG_DIR_IN) + buf[2] = 0x19; /* INPUT PLUG SIGNAL FORMAT */ + else + buf[2] = 0x18; /* OUTPUT PLUG SIGNAL FORMAT */ + buf[3] = 0xff & pid; /* plug id */ + buf[4] = 0x90; /* EOH_1, Form_1, FMT. AM824 */ + buf[5] = 0x07 & sfc; /* FDF-hi. AM824, frequency */ + buf[6] = 0xff; /* FDF-mid. AM824, SYT hi (not used)*/ + buf[7] = 0xff; /* FDF-low. AM824, SYT lo (not used) */ + + /* do transaction and check buf[1-5] are the same against command */ + err = fcp_avc_transaction(unit, buf, 8, buf, 8, + BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5)); + if (err < 0) + goto end; + + /* check length */ + if (err != 8) { + dev_err(&unit->device, "failed to inquiry sample rate\n"); + err = -EIO; + goto end; + } + + /* return response code */ + err = buf[0]; +end: + kfree(buf); + return err; +}

Previous commit adds support for some devices which can capture PCM samples. They transmits AMDTP stream in non-blocking mode. This stream has a quirk for 'presentation timestamp'.

The sequence of 'presentation timestamp' is invalid even if header of packet shows 'CIP header with SYT field'. So this driver can't reuse it for out stream.

In this reason, this driver handles both streams separately.

For your information, I note the sequence of CIP headers in stream transmitted by Behringer F-Control Audio 202:

When this driver gives no out-stream: Index Payload CIP_Header_0 CIP_Header_1 38 14 00020092 900103D1 39 12 00020098 900102FF 40 12 0002009D 9001027F 41 14 000200A2 90010396 42 14 000200A8 900102E8 43 12 000200AE 90010219 44 14 000200B3 90010331 45 12 000200B9 9001025F 46 14 000200BE 90010376 47 12 000200C4 900102A1 00 12 000200C9 9001023E 01 14 000200CE 90010358 02 12 000200D4 90010289 03 16 000200D9 900103A3 04 12 000200E0 900102DD 05 14 000200E5 900103F1 06 12 000200EB 90010335 07 12 000200F0 90010263 08 14 000200F5 9001037C 09 12 000200FB 900102AE

When this driver gives out-stream: Index Payload CIP_Header_0 CIP_Header_1 38 12 000200BD 900104A8 39 14 000200C2 900104A8 40 12 000200C8 900104AC 41 14 000200CD 900104A9 42 12 000200D3 900104B1 43 14 000200D8 900104A8 44 12 000200DE 900104AA 45 14 000200E3 900104A9 46 14 000200E9 900104AE 47 12 000200EF 900104A8 00 14 000200F4 900104AD 01 12 000200FA 900104A7 02 14 000200FF 900104A9 03 12 00020005 900104A9 04 14 0002000A 900104B1 05 12 00020010 900104AA 06 14 00020015 900104AD 07 12 0002001B 900104A7 08 14 00020020 900104AC 09 12 00020026 900104A7

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- sound/firewire/speakers/speakers.c | 9 +- sound/firewire/speakers/speakers.h | 26 ++++- sound/firewire/speakers/speakers_command.c | 40 +++++++ sound/firewire/speakers/speakers_pcm.c | 179 +++++++++++++++++++++++++---- sound/firewire/speakers/speakers_proc.c | 14 ++- sound/firewire/speakers/speakers_stream.c | 171 +++++++++++++++++++++------ 6 files changed, 365 insertions(+), 74 deletions(-)

diff --git a/sound/firewire/speakers/speakers.c b/sound/firewire/speakers/speakers.c index e68046c..76afce9 100644 --- a/sound/firewire/speakers/speakers.c +++ b/sound/firewire/speakers/speakers.c @@ -90,7 +90,8 @@ static void fwspk_card_free(struct snd_card *card) struct fwspk *fwspk = card->private_data;

mutex_lock(&fwspk->mutex); - snd_fwspk_stream_destroy(fwspk); + snd_fwspk_stream_destroy(fwspk, &fwspk->rx_stream); + snd_fwspk_stream_destroy(fwspk, &fwspk->tx_stream); mutex_unlock(&fwspk->mutex);

fw_unit_put(fwspk->unit); /* dec reference counter */ @@ -163,7 +164,8 @@ static void fwspk_bus_reset(struct fw_unit *unit) mutex_lock(&fwspk->mutex);

fcp_bus_reset(fwspk->unit); - snd_fwspk_stream_update(fwspk); + snd_fwspk_stream_update(fwspk, &fwspk->rx_stream); + snd_fwspk_stream_update(fwspk, &fwspk->tx_stream);

mutex_unlock(&fwspk->mutex); } @@ -172,7 +174,8 @@ static void fwspk_remove(struct fw_unit *unit) { struct fwspk *fwspk = dev_get_drvdata(&unit->device);

- snd_fwspk_stream_destroy(fwspk); + snd_fwspk_stream_destroy(fwspk, &fwspk->rx_stream); + snd_fwspk_stream_destroy(fwspk, &fwspk->tx_stream); snd_card_disconnect(fwspk->card); snd_card_free_when_closed(fwspk->card); } diff --git a/sound/firewire/speakers/speakers.h b/sound/firewire/speakers/speakers.h index 017d972..5d6c8e8 100644 --- a/sound/firewire/speakers/speakers.h +++ b/sound/firewire/speakers/speakers.h @@ -47,8 +47,12 @@ struct fwspk { struct mutex mutex;

struct fwspk_stream_formation + tx_stream_formations[FWSPK_STREAM_TABLE_ENTRIES]; + struct fwspk_stream_formation rx_stream_formations[FWSPK_STREAM_TABLE_ENTRIES]; + struct cmp_connection out_conn; struct cmp_connection in_conn; + struct amdtp_stream tx_stream; struct amdtp_stream rx_stream;

bool mute; @@ -87,11 +91,23 @@ int avc_general_inquiry_sig_fmt(struct fw_unit *unit, unsigned int rate, enum avc_general_plug_dir dir, unsigned short pid);

-int snd_fwspk_stream_init(struct fwspk *fwspk); -int snd_fwspk_stream_start(struct fwspk *fwspk, unsigned int rate); -void snd_fwspk_stream_stop(struct fwspk *fwspk); -void snd_fwspk_stream_destroy(struct fwspk *fwspk); -void snd_fwspk_stream_update(struct fwspk *fwspk); +int snd_fwspk_command_set_rate(struct fwspk *fwspk, + enum avc_general_plug_dir dir, + unsigned int rate); +int snd_fwspk_command_get_rate(struct fwspk *fwspk, + enum avc_general_plug_dir dir, + unsigned int *rate); + +int snd_fwspk_stream_get_rate(struct fwspk *fwspk, unsigned int *rate); +int snd_fwspk_stream_set_rate(struct fwspk *fwspk, unsigned int rate); + +int snd_fwspk_stream_start(struct fwspk *fwspk, + struct amdtp_stream *stream, unsigned int rate); +void snd_fwspk_stream_stop(struct fwspk *fwspk, struct amdtp_stream *stream); +void snd_fwspk_stream_destroy(struct fwspk *fwspk, struct amdtp_stream *stream); +void snd_fwspk_stream_update(struct fwspk *fwspk, struct amdtp_stream *stream); + +int snd_fwspk_streams_init(struct fwspk *fwspk);

int firewave_stream_discover(struct fwspk *fwspk); int lacie_speakers_stream_discover(struct fwspk *fwspk); diff --git a/sound/firewire/speakers/speakers_command.c b/sound/firewire/speakers/speakers_command.c index a13bc9e..274683e 100644 --- a/sound/firewire/speakers/speakers_command.c +++ b/sound/firewire/speakers/speakers_command.c @@ -120,3 +120,43 @@ end: kfree(buf); return err; } + +int snd_fwspk_command_set_rate(struct fwspk *fwspk, + enum avc_general_plug_dir dir, + unsigned int rate) +{ + int err; + + err = avc_general_set_sig_fmt(fwspk->unit, rate, dir, 0); + if (err < 0) + goto end; + + /* ACCEPTED or INTERIM is OK */ + if ((err != 0x0f) && (err != 0x09)) { + dev_err(&fwspk->unit->device, + "failed to set sampling rate\n"); + err = -EIO; + } +end: + return err; +} + +int snd_fwspk_command_get_rate(struct fwspk *fwspk, + enum avc_general_plug_dir dir, + unsigned int *rate) +{ + int err; + + err = avc_general_get_sig_fmt(fwspk->unit, rate, dir, 0); + if (err < 0) + goto end; + + /* IMPLEMENTED/STABLE is OK */ + if (err != 0x0c) { + dev_err(&fwspk->unit->device, + "failed to get sampling rate\n"); + err = -EIO; + } +end: + return err; +} diff --git a/sound/firewire/speakers/speakers_pcm.c b/sound/firewire/speakers/speakers_pcm.c index 2258ddf..da777d2 100644 --- a/sound/firewire/speakers/speakers_pcm.c +++ b/sound/firewire/speakers/speakers_pcm.c @@ -66,6 +66,13 @@ static int hw_rule_channels(struct snd_pcm_hw_params *params, return snd_interval_refine(c, &t); }

+static inline int hw_rule_capture_rate(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + struct fwspk *fwspk = rule->private; + return hw_rule_rate(params, rule, fwspk, + fwspk->tx_stream_formations); +} static inline int hw_rule_playback_rate(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { @@ -74,6 +81,14 @@ static inline int hw_rule_playback_rate(struct snd_pcm_hw_params *params, fwspk->rx_stream_formations); }

+static inline int hw_rule_capture_channels(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + struct fwspk *fwspk = rule->private; + return hw_rule_channels(params, rule, fwspk, + fwspk->tx_stream_formations); +} + static inline int hw_rule_playback_channels(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { @@ -117,12 +132,14 @@ static void prepare_rates(struct snd_pcm_hardware *hw, return; }

-int fwspk_open(struct snd_pcm_substream *substream) +static int init_hw_params(struct fwspk *fwspk, + struct snd_pcm_substream *substream) { static const struct snd_pcm_hardware hw = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_BATCH | SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_JOINT_DUPLEX | /* for Open Sound System compatibility */ SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BLOCK_TRANSFER, @@ -139,22 +156,33 @@ int fwspk_open(struct snd_pcm_substream *substream) .periods_min = 1, .periods_max = UINT_MAX, }; - struct fwspk *fwspk = substream->private_data; struct snd_pcm_runtime *runtime = substream->runtime; int err;

runtime->hw = hw;

/* add rule between channels and sampling rate */ - prepare_rates(&runtime->hw, fwspk->rx_stream_formations); - prepare_channels(&runtime->hw, fwspk->rx_stream_formations); - runtime->hw.formats = AMDTP_OUT_PCM_FORMAT_BITS; - snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, - hw_rule_playback_channels, fwspk, - SNDRV_PCM_HW_PARAM_RATE, -1); - snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, - hw_rule_playback_rate, fwspk, - SNDRV_PCM_HW_PARAM_CHANNELS, -1); + if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + prepare_rates(&runtime->hw, fwspk->tx_stream_formations); + prepare_channels(&runtime->hw, fwspk->tx_stream_formations); + runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE; + snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, + hw_rule_capture_channels, fwspk, + SNDRV_PCM_HW_PARAM_RATE, -1); + snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, + hw_rule_capture_rate, fwspk, + SNDRV_PCM_HW_PARAM_CHANNELS, -1); + } else { + prepare_rates(&runtime->hw, fwspk->rx_stream_formations); + prepare_channels(&runtime->hw, fwspk->rx_stream_formations); + runtime->hw.formats = AMDTP_OUT_PCM_FORMAT_BITS; + snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, + hw_rule_playback_channels, fwspk, + SNDRV_PCM_HW_PARAM_RATE, -1); + snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, + hw_rule_playback_rate, fwspk, + SNDRV_PCM_HW_PARAM_CHANNELS, -1); + }

/* AM824 in IEC 61883-6 can deliver 24bit data */ err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); @@ -178,6 +206,34 @@ end: return err; }

+static int fwspk_open(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + unsigned int rate; + int err; + + err = init_hw_params(fwspk, substream); + if (err < 0) + goto end; + + /* + * When any PCM stream are already running, the available sampling rate + * is limited at current value. + */ + if (amdtp_stream_pcm_running(&fwspk->tx_stream) || + amdtp_stream_pcm_running(&fwspk->rx_stream)) { + err = snd_fwspk_stream_get_rate(fwspk, &rate); + if (err < 0) + goto end; + substream->runtime->hw.rate_min = rate; + substream->runtime->hw.rate_max = rate; + } + + snd_pcm_set_sync(substream); +end: + return err; +} + static int fwspk_close(struct snd_pcm_substream *substream) { return 0; @@ -190,18 +246,46 @@ static int fwspk_hw_params(struct snd_pcm_substream *substream, params_buffer_bytes(hw_params)); }

-static int fwspk_hw_free(struct snd_pcm_substream *substream) +static int fwspk_hw_free_capture(struct snd_pcm_substream *substream) { struct fwspk *fwspk = substream->private_data;

mutex_lock(&fwspk->mutex); - snd_fwspk_stream_stop(fwspk); + snd_fwspk_stream_stop(fwspk, &fwspk->tx_stream); mutex_unlock(&fwspk->mutex);

return snd_pcm_lib_free_vmalloc_buffer(substream); } +static int fwspk_hw_free_playback(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + + mutex_lock(&fwspk->mutex); + snd_fwspk_stream_stop(fwspk, &fwspk->rx_stream); + mutex_unlock(&fwspk->mutex); + + return snd_pcm_lib_free_vmalloc_buffer(substream); +} + +static int fwspk_prepare_capture(struct snd_pcm_substream *substream) +{ + struct fwspk *fwspk = substream->private_data; + struct snd_pcm_runtime *runtime = substream->runtime; + int err;

-static int fwspk_prepare(struct snd_pcm_substream *substream) + mutex_lock(&fwspk->mutex); + + err = snd_fwspk_stream_start(fwspk, &fwspk->tx_stream, runtime->rate); + if (err < 0) + goto end; + + amdtp_stream_set_pcm_format(&fwspk->tx_stream, runtime->format); + amdtp_stream_pcm_prepare(&fwspk->tx_stream); +end: + mutex_unlock(&fwspk->mutex); + return err; +} +static int fwspk_prepare_playback(struct snd_pcm_substream *substream) { struct fwspk *fwspk = substream->private_data; struct snd_pcm_runtime *runtime = substream->runtime; @@ -209,7 +293,7 @@ static int fwspk_prepare(struct snd_pcm_substream *substream)

mutex_lock(&fwspk->mutex);

- err = snd_fwspk_stream_start(fwspk, runtime->rate); + err = snd_fwspk_stream_start(fwspk, &fwspk->rx_stream, runtime->rate); if (err < 0) goto end;

@@ -220,7 +304,25 @@ end: return err; }

-static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd) +static int fwspk_trigger_capture(struct snd_pcm_substream *substream, int cmd) +{ + struct fwspk *fwspk = substream->private_data; + struct snd_pcm_substream *pcm; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + pcm = substream; + break; + case SNDRV_PCM_TRIGGER_STOP: + pcm = NULL; + break; + default: + return -EINVAL; + } + amdtp_stream_pcm_trigger(&fwspk->tx_stream, pcm); + return 0; +} +static int fwspk_trigger_playback(struct snd_pcm_substream *substream, int cmd) { struct fwspk *fwspk = substream->private_data; struct snd_pcm_substream *pcm; @@ -239,35 +341,62 @@ static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd) return 0; }

-static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t fwspk_pointer_capture(struct snd_pcm_substream *sbstm) { - struct fwspk *fwspk = substream->private_data; + struct fwspk *fwspk = sbstm->private_data; + + return amdtp_stream_pcm_pointer(&fwspk->tx_stream); +} +static snd_pcm_uframes_t fwspk_pointer_playback(struct snd_pcm_substream *sbstm) +{ + struct fwspk *fwspk = sbstm->private_data;

return amdtp_stream_pcm_pointer(&fwspk->rx_stream); }

int snd_fwspk_create_pcm(struct fwspk *fwspk) { - static struct snd_pcm_ops ops = { + static struct snd_pcm_ops capture_ops = { .open = fwspk_open, .close = fwspk_close, .ioctl = snd_pcm_lib_ioctl, .hw_params = fwspk_hw_params, - .hw_free = fwspk_hw_free, - .prepare = fwspk_prepare, - .trigger = fwspk_trigger, - .pointer = fwspk_pointer, + .hw_free = fwspk_hw_free_capture, + .prepare = fwspk_prepare_capture, + .trigger = fwspk_trigger_capture, + .pointer = fwspk_pointer_capture, + .page = snd_pcm_lib_get_vmalloc_page, + .mmap = snd_pcm_lib_mmap_vmalloc, + }; + static struct snd_pcm_ops playback_ops = { + .open = fwspk_open, + .close = fwspk_close, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = fwspk_hw_params, + .hw_free = fwspk_hw_free_playback, + .prepare = fwspk_prepare_playback, + .trigger = fwspk_trigger_playback, + .pointer = fwspk_pointer_playback, .page = snd_pcm_lib_get_vmalloc_page, .mmap = snd_pcm_lib_mmap_vmalloc, }; struct snd_pcm *pcm; + unsigned int cap = 0; int err;

- err = snd_pcm_new(fwspk->card, fwspk->card->driver, 0, 1, 0, &pcm); + /* 44.1kHz is the most popular */ + if (fwspk->tx_stream_formations[1].pcm > 0) + cap = 1; + + err = snd_pcm_new(fwspk->card, fwspk->card->driver, 0, 1, cap, &pcm); if (err < 0) return err; + pcm->private_data = fwspk; strcpy(pcm->name, fwspk->card->shortname); - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops); + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops); + if (cap > 0) + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops); + return 0; } diff --git a/sound/firewire/speakers/speakers_proc.c b/sound/firewire/speakers/speakers_proc.c index 9721e52..2865ce2 100644 --- a/sound/firewire/speakers/speakers_proc.c +++ b/sound/firewire/speakers/speakers_proc.c @@ -16,6 +16,15 @@ proc_read_formation(struct snd_info_entry *entry, struct fwspk_stream_formation *formation; unsigned int i;

+ snd_iprintf(buffer, "Output Stream from device:\n"); + snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n"); + formation = fwspk->tx_stream_formations; + for (i = 0; i < FWSPK_STREAM_TABLE_ENTRIES; i++) { + snd_iprintf(buffer, + "\t%d\t%d\t%d\n", fwspk_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 = fwspk->rx_stream_formations; @@ -32,11 +41,8 @@ proc_read_clock(struct snd_info_entry *entry, { struct fwspk *fwspk = entry->private_data; unsigned int rate; - int err;

- err = avc_general_get_sig_fmt(fwspk->unit, &rate, - AVC_GENERAL_PLUG_DIR_IN, 0); - if ((err < 0) && (err == 0x09)) + if (snd_fwspk_stream_get_rate(fwspk, &rate) >= 0) snd_iprintf(buffer, "Sampling rate: %d\n", rate); }

diff --git a/sound/firewire/speakers/speakers_stream.c b/sound/firewire/speakers/speakers_stream.c index 591e6bf..b02b03c 100644 --- a/sound/firewire/speakers/speakers_stream.c +++ b/sound/firewire/speakers/speakers_stream.c @@ -36,39 +36,101 @@ static const unsigned int avc_stream_rate_table[] = { [6] = 0x07, };

-int snd_fwspk_stream_init(struct fwspk *fwspk) +int snd_fwspk_stream_get_rate(struct fwspk *fwspk, unsigned int *rate) { + unsigned int tx_rate, rx_rate; int err;

- err = cmp_connection_init(&fwspk->in_conn, fwspk->unit, - CMP_INPUT, 0); + err = snd_fwspk_command_get_rate(fwspk, + AVC_GENERAL_PLUG_DIR_OUT, &tx_rate); + if (err < 0) + goto end; + + err = snd_fwspk_command_get_rate(fwspk, + AVC_GENERAL_PLUG_DIR_IN, &rx_rate); + if (err < 0) + goto end; + + *rate = rx_rate; + if (rx_rate == tx_rate) + goto end; + + /* synchronize receive stream rate to transmit stream rate */ + err = snd_fwspk_command_set_rate(fwspk, + AVC_GENERAL_PLUG_DIR_IN, rx_rate); +end: + return err; +} + +int snd_fwspk_stream_set_rate(struct fwspk *fwspk, unsigned int rate) +{ + int err; + + err = snd_fwspk_command_set_rate(fwspk, AVC_GENERAL_PLUG_DIR_OUT, rate); + if (err < 0) + goto end; + + err = snd_fwspk_command_set_rate(fwspk, AVC_GENERAL_PLUG_DIR_IN, rate); +end: + return err; +} + +static int stream_init(struct fwspk *fwspk, struct amdtp_stream *stream) +{ + struct cmp_connection *conn; + enum cmp_direction c_dir; + enum amdtp_stream_direction s_dir; + int err; + + if (stream == &fwspk->tx_stream) { + conn = &fwspk->out_conn; + c_dir = CMP_OUTPUT; + s_dir = AMDTP_IN_STREAM; + } else { + conn = &fwspk->in_conn; + c_dir = CMP_INPUT; + s_dir = AMDTP_OUT_STREAM; + } + + err = cmp_connection_init(conn, fwspk->unit, c_dir, 0); if (err < 0) { fw_unit_put(fwspk->unit); goto end; }

- err = amdtp_stream_init(&fwspk->rx_stream, fwspk->unit, - AMDTP_OUT_STREAM, CIP_NONBLOCKING); + err = amdtp_stream_init(stream, fwspk->unit, s_dir, CIP_NONBLOCKING); if (err < 0) - cmp_connection_destroy(&fwspk->in_conn); + cmp_connection_destroy(conn); end: return err; }

-int snd_fwspk_stream_start(struct fwspk *fwspk, unsigned int rate) +int snd_fwspk_stream_start(struct fwspk *fwspk, + struct amdtp_stream *stream, + unsigned int rate) { unsigned int i, curr_rate, pcm_channels, midi_ports; + struct cmp_connection *conn; + enum avc_general_plug_dir dir; bool used; int err;

/* already start or not */ - if (amdtp_stream_running(&fwspk->rx_stream)) { + if (amdtp_stream_running(stream)) { err = 0; goto end; }

+ if (stream == &fwspk->tx_stream) { + conn = &fwspk->out_conn; + dir = AVC_GENERAL_PLUG_DIR_OUT; + } else { + conn = &fwspk->in_conn; + dir = AVC_GENERAL_PLUG_DIR_IN; + } + /* check other's connection */ - err = cmp_connection_check_used(&fwspk->in_conn, &used); + err = cmp_connection_check_used(conn, &used); if (err < 0) goto end; else if (used) { @@ -77,8 +139,7 @@ int snd_fwspk_stream_start(struct fwspk *fwspk, unsigned int rate) };

/* arrange sampling rate */ - err = avc_general_get_sig_fmt(fwspk->unit, &curr_rate, - AVC_GENERAL_PLUG_DIR_IN, 0); + err = avc_general_get_sig_fmt(fwspk->unit, &curr_rate, dir, 0); if (err < 0) goto end; if (err != 0x0c /* IMPLEMENTED/STABLE */) { @@ -88,8 +149,7 @@ int snd_fwspk_stream_start(struct fwspk *fwspk, unsigned int rate) goto end; } if (curr_rate != rate) { - err = avc_general_set_sig_fmt(fwspk->unit, rate, - AVC_GENERAL_PLUG_DIR_IN, 0); + err = avc_general_set_sig_fmt(fwspk->unit, rate, dir, 0); if (err < 0) goto end; if (err != 0x09 /* ACCEPTED */) { @@ -109,52 +169,66 @@ int snd_fwspk_stream_start(struct fwspk *fwspk, unsigned int rate) err = -EINVAL; goto end; } - pcm_channels = fwspk->rx_stream_formations[i].pcm; - midi_ports = fwspk->rx_stream_formations[i].midi; - if ((pcm_channels == 0) && (midi_ports == 0)) { + if (stream == &fwspk->tx_stream) { + pcm_channels = fwspk->tx_stream_formations[i].pcm; + midi_ports = fwspk->tx_stream_formations[i].midi; + } else { + pcm_channels = fwspk->rx_stream_formations[i].pcm; + midi_ports = fwspk->rx_stream_formations[i].midi; + } + if (pcm_channels == 0) { err = -EINVAL; goto end; } - amdtp_stream_set_parameters(&fwspk->rx_stream, rate, - pcm_channels, midi_ports); + amdtp_stream_set_parameters(stream, rate, pcm_channels, midi_ports);

/* establish connection */ - err = cmp_connection_establish(&fwspk->in_conn, - amdtp_stream_get_max_payload(&fwspk->rx_stream)); + err = cmp_connection_establish(conn, + amdtp_stream_get_max_payload(stream)); if (err < 0) goto end;

/* start stream */ - err = amdtp_stream_start(&fwspk->rx_stream, - fwspk->in_conn.resources.channel, - fwspk->in_conn.speed); + err = amdtp_stream_start(stream, + conn->resources.channel, + conn->speed); if (err < 0) - cmp_connection_break(&fwspk->in_conn); + cmp_connection_break(conn); end: return err; }

-void snd_fwspk_stream_stop(struct fwspk *fwspk) +void snd_fwspk_stream_stop(struct fwspk *fwspk, struct amdtp_stream *stream) { - if (amdtp_stream_running(&fwspk->rx_stream)) - amdtp_stream_stop(&fwspk->rx_stream); + if (amdtp_stream_running(stream)) + amdtp_stream_stop(stream);

- cmp_connection_break(&fwspk->in_conn); + if (stream == &fwspk->tx_stream) + cmp_connection_break(&fwspk->out_conn); + else + cmp_connection_break(&fwspk->in_conn); }

-void snd_fwspk_stream_destroy(struct fwspk *fwspk) +void snd_fwspk_stream_destroy(struct fwspk *fwspk, struct amdtp_stream *stream) { - amdtp_stream_pcm_abort(&fwspk->rx_stream); - snd_fwspk_stream_stop(fwspk); + amdtp_stream_pcm_abort(stream); + snd_fwspk_stream_stop(fwspk, stream); }

-void snd_fwspk_stream_update(struct fwspk *fwspk) +void snd_fwspk_stream_update(struct fwspk *fwspk, struct amdtp_stream *stream) { - if (cmp_connection_update(&fwspk->in_conn) < 0) { - amdtp_stream_pcm_abort(&fwspk->rx_stream); - snd_fwspk_stream_stop(fwspk); + struct cmp_connection *conn; + + if (stream == &fwspk->tx_stream) + conn = &fwspk->out_conn; + else + conn = &fwspk->in_conn; + + if (cmp_connection_update(conn) < 0) { + amdtp_stream_pcm_abort(stream); + snd_fwspk_stream_stop(fwspk, stream); } else { - amdtp_stream_update(&fwspk->rx_stream); + amdtp_stream_update(stream); } }

@@ -304,7 +378,10 @@ fill_stream_formations(struct fwspk *fwspk, enum avc_general_plug_dir dir, if (buf == NULL) return -ENOMEM;

- formations = fwspk->rx_stream_formations; + if (dir == AVC_GENERAL_PLUG_DIR_OUT) + formations = fwspk->tx_stream_formations; + else + formations = fwspk->rx_stream_formations;

/* initialize parameters here because of checking implementation */ eid = 0; @@ -354,6 +431,11 @@ int snd_fwspk_stream_discover(struct fwspk *fwspk) goto end; }

+ /* use oPCR[0] */ + err = fill_stream_formations(fwspk, AVC_GENERAL_PLUG_DIR_OUT, 0); + if (err < 0) + goto end; + /* use iPCR[0] */ err = fill_stream_formations(fwspk, AVC_GENERAL_PLUG_DIR_IN, 0); if (err < 0) @@ -361,3 +443,18 @@ int snd_fwspk_stream_discover(struct fwspk *fwspk) end: return err; } + +int snd_fwspk_streams_init(struct fwspk *fwspk) +{ + int err; + + err = stream_init(fwspk, &fwspk->rx_stream); + if (err < 0) + goto end; + + /* 44.1kHz is the most popular */ + if (fwspk->tx_stream_formations[1].pcm > 0) + err = stream_init(fwspk, &fwspk->tx_stream); +end: + return err; +}

This interface is designed for mixer/control application. To use hwdep interface, the application can get information about firewire node, can lock/unlock kernel streaming and can get notification at starting/stopping kernel streaming.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- include/uapi/sound/asound.h | 3 +- include/uapi/sound/firewire.h | 3 +- sound/firewire/speakers/Makefile | 2 +- sound/firewire/speakers/speakers.c | 5 + sound/firewire/speakers/speakers.h | 13 ++ sound/firewire/speakers/speakers_hwdep.c | 195 ++++++++++++++++++++++++++++++ sound/firewire/speakers/speakers_stream.c | 39 ++++++ 7 files changed, 257 insertions(+), 3 deletions(-) create mode 100644 sound/firewire/speakers/speakers_hwdep.c

diff --git a/include/uapi/sound/asound.h b/include/uapi/sound/asound.h index 2249483..5d6fa42 100644 --- a/include/uapi/sound/asound.h +++ b/include/uapi/sound/asound.h @@ -96,9 +96,10 @@ enum { SNDRV_HWDEP_IFACE_FW_DICE, /* TC DICE FireWire device */ SNDRV_HWDEP_IFACE_FW_FIREWORKS, /* Echo Audio Fireworks based device */ SNDRV_HWDEP_IFACE_FW_BEBOB, /* BridgeCo BeBoB based device */ + SNDRV_HWDEP_IFACE_FW_FWSPK, /* Oxford FW970/971 based devices */

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

struct snd_hwdep_info { diff --git a/include/uapi/sound/firewire.h b/include/uapi/sound/firewire.h index d69c0b6..147349e 100644 --- a/include/uapi/sound/firewire.h +++ b/include/uapi/sound/firewire.h @@ -54,7 +54,8 @@ union snd_firewire_event { #define SNDRV_FIREWIRE_TYPE_DICE 1 #define SNDRV_FIREWIRE_TYPE_FIREWORKS 2 #define SNDRV_FIREWIRE_TYPE_BEBOB 3 -/* AV/C, RME, MOTU, ... */ +#define SNDRV_FIREWIRE_TYPE_FWSPK 4 +/* RME, MOTU, ... */

struct snd_firewire_get_info { unsigned int type; /* SNDRV_FIREWIRE_TYPE_xxx */ diff --git a/sound/firewire/speakers/Makefile b/sound/firewire/speakers/Makefile index d98d4f7..b7b1e45 100644 --- a/sound/firewire/speakers/Makefile +++ b/sound/firewire/speakers/Makefile @@ -1,3 +1,3 @@ snd-firewire-speakers-objs := speakers_command.o speakers_stream.o speakers_pcm.o speakers_control.o \ - speakers_proc.o speakers_midi.o speakers.o + speakers_proc.o speakers_midi.o speakers_hwdep.o speakers.o obj-m += snd-firewire-speakers.o diff --git a/sound/firewire/speakers/speakers.c b/sound/firewire/speakers/speakers.c index fd16e59..4eff180 100644 --- a/sound/firewire/speakers/speakers.c +++ b/sound/firewire/speakers/speakers.c @@ -116,6 +116,7 @@ static int fwspk_probe(struct fw_unit *unit, fwspk->device_info = (const struct device_info *)id->driver_data; mutex_init(&fwspk->mutex); spin_lock_init(&fwspk->lock); + init_waitqueue_head(&fwspk->hwdep_wait);

if (fwspk->device_info == &griffin_firewave) err = firewave_stream_discover(fwspk); @@ -152,6 +153,10 @@ static int fwspk_probe(struct fw_unit *unit, goto err_card; }

+ err = snd_fwspk_create_hwdep(fwspk); + if (err < 0) + goto err_card; + snd_card_set_dev(card, &unit->device); err = snd_card_register(card); if (err < 0) diff --git a/sound/firewire/speakers/speakers.h b/sound/firewire/speakers/speakers.h index 2c54946..73eecb0 100644 --- a/sound/firewire/speakers/speakers.h +++ b/sound/firewire/speakers/speakers.h @@ -12,6 +12,7 @@ #include <linux/mod_devicetable.h> #include <linux/mutex.h> #include <linux/slab.h> +#include <linux/compat.h>

#include <sound/control.h> #include <sound/core.h> @@ -20,6 +21,8 @@ #include <sound/pcm_params.h> #include <sound/info.h> #include <sound/rawmidi.h> +#include <sound/firewire.h> +#include <sound/hwdep.h>

#include "../cmp.h" #include "../fcp.h" @@ -64,6 +67,10 @@ struct fwspk { s16 volume[6]; s16 volume_min; s16 volume_max; + + int dev_lock_count; + bool dev_lock_changed; + wait_queue_head_t hwdep_wait; };

/* AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA) */ @@ -118,6 +125,10 @@ int firewave_stream_discover(struct fwspk *fwspk); int lacie_speakers_stream_discover(struct fwspk *fwspk); int snd_fwspk_stream_discover(struct fwspk *fwspk);

+void snd_fwspk_stream_lock_changed(struct fwspk *fwspk); +int snd_fwspk_stream_lock_try(struct fwspk *fwspk); +void snd_fwspk_stream_lock_release(struct fwspk *fwspk); + int snd_fwspk_create_pcm(struct fwspk *fwspk);

int snd_fwspk_create_mixer(struct fwspk *fwspk); @@ -125,3 +136,5 @@ int snd_fwspk_create_mixer(struct fwspk *fwspk); void snd_fwspk_proc_init(struct fwspk *fwspk);

int snd_fwspk_create_midi(struct fwspk *fwspk); + +int snd_fwspk_create_hwdep(struct fwspk *fwspk); diff --git a/sound/firewire/speakers/speakers_hwdep.c b/sound/firewire/speakers/speakers_hwdep.c new file mode 100644 index 0000000..eae7e184 --- /dev/null +++ b/sound/firewire/speakers/speakers_hwdep.c @@ -0,0 +1,195 @@ +/* + * speakers_hwdep.c - a part of driver for OXFW970/971 based devices + * + * Copyright (c) 2013 Takashi Sakamoto + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +/* + * This codes give three functionality. + * + * 1.get firewire node infomation + * 2.get notification about starting/stopping stream + * 3.lock/unlock stream + */ + +#include "speakers.h" + +static long +hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count, + loff_t *offset) +{ + struct fwspk *fwspk = hwdep->private_data; + DEFINE_WAIT(wait); + union snd_firewire_event event; + + spin_lock_irq(&fwspk->lock); + + while (!fwspk->dev_lock_changed) { + prepare_to_wait(&fwspk->hwdep_wait, &wait, TASK_INTERRUPTIBLE); + spin_unlock_irq(&fwspk->lock); + schedule(); + finish_wait(&fwspk->hwdep_wait, &wait); + if (signal_pending(current)) + return -ERESTARTSYS; + spin_lock_irq(&fwspk->lock); + } + + memset(&event, 0, sizeof(event)); + if (fwspk->dev_lock_changed) { + event.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS; + event.lock_status.status = (fwspk->dev_lock_count > 0); + fwspk->dev_lock_changed = false; + + count = min_t(long, count, sizeof(event.lock_status)); + } + + spin_unlock_irq(&fwspk->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 fwspk *fwspk = hwdep->private_data; + unsigned int events; + + poll_wait(file, &fwspk->hwdep_wait, wait); + + spin_lock_irq(&fwspk->lock); + if (fwspk->dev_lock_changed) + events = POLLIN | POLLRDNORM; + else + events = 0; + spin_unlock_irq(&fwspk->lock); + + return events; +} + +static int +hwdep_get_info(struct fwspk *fwspk, void __user *arg) +{ + struct fw_device *dev = fw_parent_device(fwspk->unit); + struct snd_firewire_get_info info; + + memset(&info, 0, sizeof(info)); + info.type = SNDRV_FIREWIRE_TYPE_FWSPK; + 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 fwspk *fwspk) +{ + int err; + + spin_lock_irq(&fwspk->lock); + + if (fwspk->dev_lock_count == 0) { + fwspk->dev_lock_count = -1; + err = 0; + } else + err = -EBUSY; + + spin_unlock_irq(&fwspk->lock); + + return err; +} + +static int +hwdep_unlock(struct fwspk *fwspk) +{ + int err; + + spin_lock_irq(&fwspk->lock); + + if (fwspk->dev_lock_count == -1) { + fwspk->dev_lock_count = 0; + err = 0; + } else + err = -EBADFD; + + spin_unlock_irq(&fwspk->lock); + + return err; +} + +static int +hwdep_release(struct snd_hwdep *hwdep, struct file *file) +{ + struct fwspk *fwspk = hwdep->private_data; + + spin_lock_irq(&fwspk->lock); + if (fwspk->dev_lock_count == -1) + fwspk->dev_lock_count = 0; + spin_unlock_irq(&fwspk->lock); + + return 0; +} + +static int +hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file, + unsigned int cmd, unsigned long arg) +{ + struct fwspk *fwspk = hwdep->private_data; + + switch (cmd) { + case SNDRV_FIREWIRE_IOCTL_GET_INFO: + return hwdep_get_info(fwspk, (void __user *)arg); + case SNDRV_FIREWIRE_IOCTL_LOCK: + return hwdep_lock(fwspk); + case SNDRV_FIREWIRE_IOCTL_UNLOCK: + return hwdep_unlock(fwspk); + 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 + +int snd_fwspk_create_hwdep(struct fwspk *fwspk) +{ + 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, + }; + struct snd_hwdep *hwdep; + int err; + + err = snd_hwdep_new(fwspk->card, fwspk->card->driver, 0, &hwdep); + if (err < 0) + goto end; + strcpy(hwdep->name, fwspk->card->driver); + hwdep->iface = SNDRV_HWDEP_IFACE_FW_FWSPK; + hwdep->ops = hwdep_ops; + hwdep->private_data = fwspk; + hwdep->exclusive = true; +end: + return err; +} diff --git a/sound/firewire/speakers/speakers_stream.c b/sound/firewire/speakers/speakers_stream.c index 2649f02..cc91160 100644 --- a/sound/firewire/speakers/speakers_stream.c +++ b/sound/firewire/speakers/speakers_stream.c @@ -493,3 +493,42 @@ int snd_fwspk_streams_init(struct fwspk *fwspk) end: return err; } + +void snd_fwspk_stream_lock_changed(struct fwspk *fwspk) +{ + fwspk->dev_lock_changed = true; + wake_up(&fwspk->hwdep_wait); +} + +int snd_fwspk_stream_lock_try(struct fwspk *fwspk) +{ + int err; + + spin_lock_irq(&fwspk->lock); + + /* user land lock this */ + if (fwspk->dev_lock_count < 0) { + err = -EBUSY; + goto end; + } + + /* this is the first time */ + if (fwspk->dev_lock_count++ == 0) + snd_fwspk_stream_lock_changed(fwspk); + err = 0; +end: + spin_unlock_irq(&fwspk->lock); + return err; +} + +void snd_fwspk_stream_lock_release(struct fwspk *fwspk) +{ + spin_lock_irq(&fwspk->lock); + + if (WARN_ON(fwspk->dev_lock_count <= 0)) + goto end; + if (--fwspk->dev_lock_count == 0) + snd_fwspk_stream_lock_changed(fwspk); +end: + spin_unlock_irq(&fwspk->lock); +}