| /* | |
| * bebob_stream.c - a part of driver for BeBoB based devices | |
| * | |
| * Copyright (c) 2013-2014 Takashi Sakamoto | |
| * | |
| * Licensed under the terms of the GNU General Public License, version 2. | |
| */ | |
| #include "./bebob.h" | |
| #define CALLBACK_TIMEOUT 1000 | |
| #define FW_ISO_RESOURCE_DELAY 1000 | |
| /* | |
| * NOTE; | |
| * For BeBoB streams, Both of input and output CMP connection are important. | |
| * | |
| * For most devices, each CMP connection starts to transmit/receive a | |
| * corresponding stream. But for a few devices, both of CMP connection needs | |
| * to start transmitting stream. An example is 'M-Audio Firewire 410'. | |
| */ | |
| /* 128 is an arbitrary length but it seems to be enough */ | |
| #define FORMAT_MAXIMUM_LENGTH 128 | |
| const unsigned int snd_bebob_rate_table[SND_BEBOB_STRM_FMT_ENTRIES] = { | |
| [0] = 32000, | |
| [1] = 44100, | |
| [2] = 48000, | |
| [3] = 88200, | |
| [4] = 96000, | |
| [5] = 176400, | |
| [6] = 192000, | |
| }; | |
| /* | |
| * See: Table 51: Extended Stream Format Info ‘Sampling Frequency’ | |
| * in Additional AVC commands (Nov 2003, BridgeCo) | |
| */ | |
| static const unsigned int bridgeco_freq_table[] = { | |
| [0] = 0x02, | |
| [1] = 0x03, | |
| [2] = 0x04, | |
| [3] = 0x0a, | |
| [4] = 0x05, | |
| [5] = 0x06, | |
| [6] = 0x07, | |
| }; | |
| static unsigned int | |
| get_formation_index(unsigned int rate) | |
| { | |
| unsigned int i; | |
| for (i = 0; i < ARRAY_SIZE(snd_bebob_rate_table); i++) { | |
| if (snd_bebob_rate_table[i] == rate) | |
| return i; | |
| } | |
| return -EINVAL; | |
| } | |
| int | |
| snd_bebob_stream_get_rate(struct snd_bebob *bebob, unsigned int *curr_rate) | |
| { | |
| unsigned int tx_rate, rx_rate, trials; | |
| int err; | |
| trials = 0; | |
| do { | |
| err = avc_general_get_sig_fmt(bebob->unit, &tx_rate, | |
| AVC_GENERAL_PLUG_DIR_OUT, 0); | |
| } while (err == -EAGAIN && ++trials < 3); | |
| if (err < 0) | |
| goto end; | |
| trials = 0; | |
| do { | |
| err = avc_general_get_sig_fmt(bebob->unit, &rx_rate, | |
| AVC_GENERAL_PLUG_DIR_IN, 0); | |
| } while (err == -EAGAIN && ++trials < 3); | |
| if (err < 0) | |
| goto end; | |
| *curr_rate = rx_rate; | |
| if (rx_rate == tx_rate) | |
| goto end; | |
| /* synchronize receive stream rate to transmit stream rate */ | |
| err = avc_general_set_sig_fmt(bebob->unit, rx_rate, | |
| AVC_GENERAL_PLUG_DIR_IN, 0); | |
| end: | |
| return err; | |
| } | |
| int | |
| snd_bebob_stream_set_rate(struct snd_bebob *bebob, unsigned int rate) | |
| { | |
| int err; | |
| err = avc_general_set_sig_fmt(bebob->unit, rate, | |
| AVC_GENERAL_PLUG_DIR_OUT, 0); | |
| if (err < 0) | |
| goto end; | |
| err = avc_general_set_sig_fmt(bebob->unit, rate, | |
| AVC_GENERAL_PLUG_DIR_IN, 0); | |
| if (err < 0) | |
| goto end; | |
| /* | |
| * Some devices need a bit time for transition. | |
| * 300msec is got by some experiments. | |
| */ | |
| msleep(300); | |
| end: | |
| return err; | |
| } | |
| int | |
| snd_bebob_stream_check_internal_clock(struct snd_bebob *bebob, bool *internal) | |
| { | |
| struct snd_bebob_clock_spec *clk_spec = bebob->spec->clock; | |
| u8 addr[AVC_BRIDGECO_ADDR_BYTES], input[7]; | |
| unsigned int id; | |
| int err = 0; | |
| *internal = false; | |
| /* 1.The device has its own operation to switch source of clock */ | |
| if (clk_spec) { | |
| err = clk_spec->get(bebob, &id); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get clock source: %d\n", err); | |
| goto end; | |
| } | |
| if (id >= clk_spec->num) { | |
| dev_err(&bebob->unit->device, | |
| "clock source %d out of range 0..%d\n", | |
| id, clk_spec->num - 1); | |
| err = -EIO; | |
| goto end; | |
| } | |
| if (strncmp(clk_spec->labels[id], SND_BEBOB_CLOCK_INTERNAL, | |
| strlen(SND_BEBOB_CLOCK_INTERNAL)) == 0) | |
| *internal = true; | |
| goto end; | |
| } | |
| /* | |
| * 2.The device don't support to switch source of clock then assumed | |
| * to use internal clock always | |
| */ | |
| if (bebob->sync_input_plug < 0) { | |
| *internal = true; | |
| goto end; | |
| } | |
| /* | |
| * 3.The device supports to switch source of clock by an usual way. | |
| * Let's check input for 'Music Sub Unit Sync Input' plug. | |
| */ | |
| avc_bridgeco_fill_msu_addr(addr, AVC_BRIDGECO_PLUG_DIR_IN, | |
| bebob->sync_input_plug); | |
| err = avc_bridgeco_get_plug_input(bebob->unit, addr, input); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get an input for MSU in plug %d: %d\n", | |
| bebob->sync_input_plug, err); | |
| goto end; | |
| } | |
| /* | |
| * If there are no input plugs, all of fields are 0xff. | |
| * Here check the first field. This field is used for direction. | |
| */ | |
| if (input[0] == 0xff) { | |
| *internal = true; | |
| goto end; | |
| } | |
| /* | |
| * If source of clock is internal CSR, Music Sub Unit Sync Input is | |
| * a destination of Music Sub Unit Sync Output. | |
| */ | |
| *internal = ((input[0] == AVC_BRIDGECO_PLUG_DIR_OUT) && | |
| (input[1] == AVC_BRIDGECO_PLUG_MODE_SUBUNIT) && | |
| (input[2] == 0x0c) && | |
| (input[3] == 0x00)); | |
| end: | |
| return err; | |
| } | |
| static unsigned int | |
| map_data_channels(struct snd_bebob *bebob, struct amdtp_stream *s) | |
| { | |
| unsigned int sec, sections, ch, channels; | |
| unsigned int pcm, midi, location; | |
| unsigned int stm_pos, sec_loc, pos; | |
| u8 *buf, addr[AVC_BRIDGECO_ADDR_BYTES], type; | |
| enum avc_bridgeco_plug_dir dir; | |
| int err; | |
| /* | |
| * The length of return value of this command cannot be expected. Here | |
| * use the maximum length of FCP. | |
| */ | |
| buf = kzalloc(256, GFP_KERNEL); | |
| if (buf == NULL) | |
| return -ENOMEM; | |
| if (s == &bebob->tx_stream) | |
| dir = AVC_BRIDGECO_PLUG_DIR_OUT; | |
| else | |
| dir = AVC_BRIDGECO_PLUG_DIR_IN; | |
| avc_bridgeco_fill_unit_addr(addr, dir, AVC_BRIDGECO_PLUG_UNIT_ISOC, 0); | |
| err = avc_bridgeco_get_plug_ch_pos(bebob->unit, addr, buf, 256); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get channel position for isoc %s plug 0: %d\n", | |
| (dir == AVC_BRIDGECO_PLUG_DIR_IN) ? "in" : "out", | |
| err); | |
| goto end; | |
| } | |
| pos = 0; | |
| /* positions in I/O buffer */ | |
| pcm = 0; | |
| midi = 0; | |
| /* the number of sections in AMDTP packet */ | |
| sections = buf[pos++]; | |
| for (sec = 0; sec < sections; sec++) { | |
| /* type of this section */ | |
| avc_bridgeco_fill_unit_addr(addr, dir, | |
| AVC_BRIDGECO_PLUG_UNIT_ISOC, 0); | |
| err = avc_bridgeco_get_plug_section_type(bebob->unit, addr, | |
| sec, &type); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get section type for isoc %s plug 0: %d\n", | |
| (dir == AVC_BRIDGECO_PLUG_DIR_IN) ? "in" : | |
| "out", | |
| err); | |
| goto end; | |
| } | |
| /* NoType */ | |
| if (type == 0xff) { | |
| err = -ENOSYS; | |
| goto end; | |
| } | |
| /* the number of channels in this section */ | |
| channels = buf[pos++]; | |
| for (ch = 0; ch < channels; ch++) { | |
| /* position of this channel in AMDTP packet */ | |
| stm_pos = buf[pos++] - 1; | |
| /* location of this channel in this section */ | |
| sec_loc = buf[pos++] - 1; | |
| /* | |
| * Basically the number of location is within the | |
| * number of channels in this section. But some models | |
| * of M-Audio don't follow this. Its location for MIDI | |
| * is the position of MIDI channels in AMDTP packet. | |
| */ | |
| if (sec_loc >= channels) | |
| sec_loc = ch; | |
| switch (type) { | |
| /* for MIDI conformant data channel */ | |
| case 0x0a: | |
| /* AMDTP_MAX_CHANNELS_FOR_MIDI is 1. */ | |
| if ((midi > 0) && (stm_pos != midi)) { | |
| err = -ENOSYS; | |
| goto end; | |
| } | |
| s->midi_position = stm_pos; | |
| midi = stm_pos; | |
| break; | |
| /* for PCM data channel */ | |
| case 0x01: /* Headphone */ | |
| case 0x02: /* Microphone */ | |
| case 0x03: /* Line */ | |
| case 0x04: /* SPDIF */ | |
| case 0x05: /* ADAT */ | |
| case 0x06: /* TDIF */ | |
| case 0x07: /* MADI */ | |
| /* for undefined/changeable signal */ | |
| case 0x08: /* Analog */ | |
| case 0x09: /* Digital */ | |
| default: | |
| location = pcm + sec_loc; | |
| if (location >= AMDTP_MAX_CHANNELS_FOR_PCM) { | |
| err = -ENOSYS; | |
| goto end; | |
| } | |
| s->pcm_positions[location] = stm_pos; | |
| break; | |
| } | |
| } | |
| if (type != 0x0a) | |
| pcm += channels; | |
| else | |
| midi += channels; | |
| } | |
| end: | |
| kfree(buf); | |
| return err; | |
| } | |
| static int | |
| init_both_connections(struct snd_bebob *bebob) | |
| { | |
| int err; | |
| err = cmp_connection_init(&bebob->in_conn, | |
| bebob->unit, CMP_INPUT, 0); | |
| if (err < 0) | |
| goto end; | |
| err = cmp_connection_init(&bebob->out_conn, | |
| bebob->unit, CMP_OUTPUT, 0); | |
| if (err < 0) | |
| cmp_connection_destroy(&bebob->in_conn); | |
| end: | |
| return err; | |
| } | |
| static int | |
| check_connection_used_by_others(struct snd_bebob *bebob, struct amdtp_stream *s) | |
| { | |
| struct cmp_connection *conn; | |
| bool used; | |
| int err; | |
| if (s == &bebob->tx_stream) | |
| conn = &bebob->out_conn; | |
| else | |
| conn = &bebob->in_conn; | |
| err = cmp_connection_check_used(conn, &used); | |
| if ((err >= 0) && used && !amdtp_stream_running(s)) { | |
| dev_err(&bebob->unit->device, | |
| "Connection established by others: %cPCR[%d]\n", | |
| (conn->direction == CMP_OUTPUT) ? 'o' : 'i', | |
| conn->pcr_index); | |
| err = -EBUSY; | |
| } | |
| return err; | |
| } | |
| static int | |
| make_both_connections(struct snd_bebob *bebob, unsigned int rate) | |
| { | |
| int index, pcm_channels, midi_channels, err = 0; | |
| if (bebob->connected) | |
| goto end; | |
| /* confirm params for both streams */ | |
| index = get_formation_index(rate); | |
| pcm_channels = bebob->tx_stream_formations[index].pcm; | |
| midi_channels = bebob->tx_stream_formations[index].midi; | |
| amdtp_stream_set_parameters(&bebob->tx_stream, | |
| rate, pcm_channels, midi_channels * 8); | |
| pcm_channels = bebob->rx_stream_formations[index].pcm; | |
| midi_channels = bebob->rx_stream_formations[index].midi; | |
| amdtp_stream_set_parameters(&bebob->rx_stream, | |
| rate, pcm_channels, midi_channels * 8); | |
| /* establish connections for both streams */ | |
| err = cmp_connection_establish(&bebob->out_conn, | |
| amdtp_stream_get_max_payload(&bebob->tx_stream)); | |
| if (err < 0) | |
| goto end; | |
| err = cmp_connection_establish(&bebob->in_conn, | |
| amdtp_stream_get_max_payload(&bebob->rx_stream)); | |
| if (err < 0) { | |
| cmp_connection_break(&bebob->out_conn); | |
| goto end; | |
| } | |
| bebob->connected = true; | |
| end: | |
| return err; | |
| } | |
| static void | |
| break_both_connections(struct snd_bebob *bebob) | |
| { | |
| cmp_connection_break(&bebob->in_conn); | |
| cmp_connection_break(&bebob->out_conn); | |
| bebob->connected = false; | |
| /* These models seems to be in transition state for a longer time. */ | |
| if (bebob->maudio_special_quirk != NULL) | |
| msleep(200); | |
| } | |
| static void | |
| destroy_both_connections(struct snd_bebob *bebob) | |
| { | |
| break_both_connections(bebob); | |
| cmp_connection_destroy(&bebob->in_conn); | |
| cmp_connection_destroy(&bebob->out_conn); | |
| } | |
| static int | |
| get_sync_mode(struct snd_bebob *bebob, enum cip_flags *sync_mode) | |
| { | |
| /* currently this module doesn't support SYT-Match mode */ | |
| *sync_mode = CIP_SYNC_TO_DEVICE; | |
| return 0; | |
| } | |
| static int | |
| start_stream(struct snd_bebob *bebob, struct amdtp_stream *stream, | |
| unsigned int rate) | |
| { | |
| struct cmp_connection *conn; | |
| int err = 0; | |
| if (stream == &bebob->rx_stream) | |
| conn = &bebob->in_conn; | |
| else | |
| conn = &bebob->out_conn; | |
| /* channel mapping */ | |
| if (bebob->maudio_special_quirk == NULL) { | |
| err = map_data_channels(bebob, stream); | |
| if (err < 0) | |
| goto end; | |
| } | |
| /* start amdtp stream */ | |
| err = amdtp_stream_start(stream, | |
| conn->resources.channel, | |
| conn->speed); | |
| end: | |
| return err; | |
| } | |
| int snd_bebob_stream_init_duplex(struct snd_bebob *bebob) | |
| { | |
| int err; | |
| err = init_both_connections(bebob); | |
| if (err < 0) | |
| goto end; | |
| err = amdtp_stream_init(&bebob->tx_stream, bebob->unit, | |
| AMDTP_IN_STREAM, CIP_BLOCKING); | |
| if (err < 0) { | |
| amdtp_stream_destroy(&bebob->tx_stream); | |
| destroy_both_connections(bebob); | |
| goto end; | |
| } | |
| /* See comments in next function */ | |
| init_completion(&bebob->bus_reset); | |
| bebob->tx_stream.flags |= CIP_SKIP_INIT_DBC_CHECK; | |
| /* | |
| * At high sampling rate, M-Audio special firmware transmits empty | |
| * packet with the value of dbc incremented by 8 but the others are | |
| * valid to IEC 61883-1. | |
| */ | |
| if (bebob->maudio_special_quirk) | |
| bebob->tx_stream.flags |= CIP_EMPTY_HAS_WRONG_DBC; | |
| err = amdtp_stream_init(&bebob->rx_stream, bebob->unit, | |
| AMDTP_OUT_STREAM, CIP_BLOCKING); | |
| if (err < 0) { | |
| amdtp_stream_destroy(&bebob->tx_stream); | |
| amdtp_stream_destroy(&bebob->rx_stream); | |
| destroy_both_connections(bebob); | |
| } | |
| /* | |
| * The firmware for these devices ignore MIDI messages in more than | |
| * first 8 data blocks of an received AMDTP packet. | |
| */ | |
| if (bebob->spec == &maudio_fw410_spec || | |
| bebob->spec == &maudio_special_spec) | |
| bebob->rx_stream.rx_blocks_for_midi = 8; | |
| end: | |
| return err; | |
| } | |
| int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate) | |
| { | |
| struct snd_bebob_rate_spec *rate_spec = bebob->spec->rate; | |
| struct amdtp_stream *master, *slave; | |
| atomic_t *slave_substreams; | |
| enum cip_flags sync_mode; | |
| unsigned int curr_rate; | |
| bool updated = false; | |
| int err = 0; | |
| /* | |
| * Normal BeBoB firmware has a quirk at bus reset to transmits packets | |
| * with discontinuous value in dbc field. | |
| * | |
| * This 'struct completion' is used to call .update() at first to update | |
| * connections/streams. Next following codes handle streaming error. | |
| */ | |
| if (amdtp_streaming_error(&bebob->tx_stream)) { | |
| if (completion_done(&bebob->bus_reset)) | |
| reinit_completion(&bebob->bus_reset); | |
| updated = (wait_for_completion_interruptible_timeout( | |
| &bebob->bus_reset, | |
| msecs_to_jiffies(FW_ISO_RESOURCE_DELAY)) > 0); | |
| } | |
| mutex_lock(&bebob->mutex); | |
| /* Need no substreams */ | |
| if (atomic_read(&bebob->playback_substreams) == 0 && | |
| atomic_read(&bebob->capture_substreams) == 0) | |
| goto end; | |
| err = get_sync_mode(bebob, &sync_mode); | |
| if (err < 0) | |
| goto end; | |
| if (sync_mode == CIP_SYNC_TO_DEVICE) { | |
| master = &bebob->tx_stream; | |
| slave = &bebob->rx_stream; | |
| slave_substreams = &bebob->playback_substreams; | |
| } else { | |
| master = &bebob->rx_stream; | |
| slave = &bebob->tx_stream; | |
| slave_substreams = &bebob->capture_substreams; | |
| } | |
| /* | |
| * Considering JACK/FFADO streaming: | |
| * TODO: This can be removed hwdep functionality becomes popular. | |
| */ | |
| err = check_connection_used_by_others(bebob, master); | |
| if (err < 0) | |
| goto end; | |
| /* | |
| * packet queueing error or detecting discontinuity | |
| * | |
| * At bus reset, connections should not be broken here. So streams need | |
| * to be re-started. This is a reason to use SKIP_INIT_DBC_CHECK flag. | |
| */ | |
| if (amdtp_streaming_error(master)) | |
| amdtp_stream_stop(master); | |
| if (amdtp_streaming_error(slave)) | |
| amdtp_stream_stop(slave); | |
| if (!updated && | |
| !amdtp_stream_running(master) && !amdtp_stream_running(slave)) | |
| break_both_connections(bebob); | |
| /* stop streams if rate is different */ | |
| err = rate_spec->get(bebob, &curr_rate); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get sampling rate: %d\n", err); | |
| goto end; | |
| } | |
| if (rate == 0) | |
| rate = curr_rate; | |
| if (rate != curr_rate) { | |
| amdtp_stream_stop(master); | |
| amdtp_stream_stop(slave); | |
| break_both_connections(bebob); | |
| } | |
| /* master should be always running */ | |
| if (!amdtp_stream_running(master)) { | |
| amdtp_stream_set_sync(sync_mode, master, slave); | |
| bebob->master = master; | |
| /* | |
| * NOTE: | |
| * If establishing connections at first, Yamaha GO46 | |
| * (and maybe Terratec X24) don't generate sound. | |
| * | |
| * For firmware customized by M-Audio, refer to next NOTE. | |
| */ | |
| if (bebob->maudio_special_quirk == NULL) { | |
| err = rate_spec->set(bebob, rate); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to set sampling rate: %d\n", | |
| err); | |
| goto end; | |
| } | |
| } | |
| err = make_both_connections(bebob, rate); | |
| if (err < 0) | |
| goto end; | |
| err = start_stream(bebob, master, rate); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to run AMDTP master stream:%d\n", err); | |
| break_both_connections(bebob); | |
| goto end; | |
| } | |
| /* | |
| * NOTE: | |
| * The firmware customized by M-Audio uses these commands to | |
| * start transmitting stream. This is not usual way. | |
| */ | |
| if (bebob->maudio_special_quirk != NULL) { | |
| err = rate_spec->set(bebob, rate); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to ensure sampling rate: %d\n", | |
| err); | |
| amdtp_stream_stop(master); | |
| break_both_connections(bebob); | |
| goto end; | |
| } | |
| } | |
| /* wait first callback */ | |
| if (!amdtp_stream_wait_callback(master, CALLBACK_TIMEOUT)) { | |
| amdtp_stream_stop(master); | |
| break_both_connections(bebob); | |
| err = -ETIMEDOUT; | |
| goto end; | |
| } | |
| } | |
| /* start slave if needed */ | |
| if (atomic_read(slave_substreams) > 0 && !amdtp_stream_running(slave)) { | |
| err = start_stream(bebob, slave, rate); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to run AMDTP slave stream:%d\n", err); | |
| amdtp_stream_stop(master); | |
| break_both_connections(bebob); | |
| goto end; | |
| } | |
| /* wait first callback */ | |
| if (!amdtp_stream_wait_callback(slave, CALLBACK_TIMEOUT)) { | |
| amdtp_stream_stop(slave); | |
| amdtp_stream_stop(master); | |
| break_both_connections(bebob); | |
| err = -ETIMEDOUT; | |
| } | |
| } | |
| end: | |
| mutex_unlock(&bebob->mutex); | |
| return err; | |
| } | |
| void snd_bebob_stream_stop_duplex(struct snd_bebob *bebob) | |
| { | |
| struct amdtp_stream *master, *slave; | |
| atomic_t *master_substreams, *slave_substreams; | |
| if (bebob->master == &bebob->rx_stream) { | |
| slave = &bebob->tx_stream; | |
| master = &bebob->rx_stream; | |
| slave_substreams = &bebob->capture_substreams; | |
| master_substreams = &bebob->playback_substreams; | |
| } else { | |
| slave = &bebob->rx_stream; | |
| master = &bebob->tx_stream; | |
| slave_substreams = &bebob->playback_substreams; | |
| master_substreams = &bebob->capture_substreams; | |
| } | |
| mutex_lock(&bebob->mutex); | |
| if (atomic_read(slave_substreams) == 0) { | |
| amdtp_stream_pcm_abort(slave); | |
| amdtp_stream_stop(slave); | |
| if (atomic_read(master_substreams) == 0) { | |
| amdtp_stream_pcm_abort(master); | |
| amdtp_stream_stop(master); | |
| break_both_connections(bebob); | |
| } | |
| } | |
| mutex_unlock(&bebob->mutex); | |
| } | |
| void snd_bebob_stream_update_duplex(struct snd_bebob *bebob) | |
| { | |
| /* vs. XRUN recovery due to discontinuity at bus reset */ | |
| mutex_lock(&bebob->mutex); | |
| if ((cmp_connection_update(&bebob->in_conn) < 0) || | |
| (cmp_connection_update(&bebob->out_conn) < 0)) { | |
| amdtp_stream_pcm_abort(&bebob->rx_stream); | |
| amdtp_stream_pcm_abort(&bebob->tx_stream); | |
| amdtp_stream_stop(&bebob->rx_stream); | |
| amdtp_stream_stop(&bebob->tx_stream); | |
| break_both_connections(bebob); | |
| } else { | |
| amdtp_stream_update(&bebob->rx_stream); | |
| amdtp_stream_update(&bebob->tx_stream); | |
| } | |
| /* wake up stream_start_duplex() */ | |
| if (!completion_done(&bebob->bus_reset)) | |
| complete_all(&bebob->bus_reset); | |
| mutex_unlock(&bebob->mutex); | |
| } | |
| void snd_bebob_stream_destroy_duplex(struct snd_bebob *bebob) | |
| { | |
| mutex_lock(&bebob->mutex); | |
| amdtp_stream_pcm_abort(&bebob->rx_stream); | |
| amdtp_stream_pcm_abort(&bebob->tx_stream); | |
| amdtp_stream_stop(&bebob->rx_stream); | |
| amdtp_stream_stop(&bebob->tx_stream); | |
| amdtp_stream_destroy(&bebob->rx_stream); | |
| amdtp_stream_destroy(&bebob->tx_stream); | |
| destroy_both_connections(bebob); | |
| mutex_unlock(&bebob->mutex); | |
| } | |
| /* | |
| * See: Table 50: Extended Stream Format Info Format Hierarchy Level 2’ | |
| * in Additional AVC commands (Nov 2003, BridgeCo) | |
| * Also 'Clause 12 AM824 sequence adaption layers' in IEC 61883-6:2005 | |
| */ | |
| static int | |
| parse_stream_formation(u8 *buf, unsigned int len, | |
| struct snd_bebob_stream_formation *formation) | |
| { | |
| unsigned int i, e, channels, format; | |
| /* | |
| * this module can support a hierarchy combination that: | |
| * Root: Audio and Music (0x90) | |
| * Level 1: AM824 Compound (0x40) | |
| */ | |
| if ((buf[0] != 0x90) || (buf[1] != 0x40)) | |
| return -ENOSYS; | |
| /* check sampling rate */ | |
| for (i = 0; i < ARRAY_SIZE(bridgeco_freq_table); i++) { | |
| if (buf[2] == bridgeco_freq_table[i]) | |
| break; | |
| } | |
| if (i == ARRAY_SIZE(bridgeco_freq_table)) | |
| return -ENOSYS; | |
| /* Avoid double count by different entries for the same rate. */ | |
| memset(&formation[i], 0, sizeof(struct snd_bebob_stream_formation)); | |
| for (e = 0; e < buf[4]; e++) { | |
| channels = buf[5 + e * 2]; | |
| format = buf[6 + e * 2]; | |
| switch (format) { | |
| /* IEC 60958 Conformant, currently handled as MBLA */ | |
| case 0x00: | |
| /* Multi bit linear audio */ | |
| case 0x06: /* Raw */ | |
| formation[i].pcm += channels; | |
| break; | |
| /* MIDI Conformant */ | |
| case 0x0d: | |
| formation[i].midi += channels; | |
| break; | |
| /* IEC 61937-3 to 7 */ | |
| case 0x01: | |
| case 0x02: | |
| case 0x03: | |
| case 0x04: | |
| case 0x05: | |
| /* Multi bit linear audio */ | |
| case 0x07: /* DVD-Audio */ | |
| case 0x0c: /* High Precision */ | |
| /* One Bit Audio */ | |
| case 0x08: /* (Plain) Raw */ | |
| case 0x09: /* (Plain) SACD */ | |
| case 0x0a: /* (Encoded) Raw */ | |
| case 0x0b: /* (Encoded) SACD */ | |
| /* Synchronization Stream (Stereo Raw audio) */ | |
| case 0x40: | |
| /* Don't care */ | |
| case 0xff: | |
| default: | |
| return -ENOSYS; /* not supported */ | |
| } | |
| } | |
| if (formation[i].pcm > AMDTP_MAX_CHANNELS_FOR_PCM || | |
| formation[i].midi > AMDTP_MAX_CHANNELS_FOR_MIDI) | |
| return -ENOSYS; | |
| return 0; | |
| } | |
| static int | |
| fill_stream_formations(struct snd_bebob *bebob, enum avc_bridgeco_plug_dir dir, | |
| unsigned short pid) | |
| { | |
| u8 *buf; | |
| struct snd_bebob_stream_formation *formations; | |
| unsigned int len, eid; | |
| u8 addr[AVC_BRIDGECO_ADDR_BYTES]; | |
| int err; | |
| buf = kmalloc(FORMAT_MAXIMUM_LENGTH, GFP_KERNEL); | |
| if (buf == NULL) | |
| return -ENOMEM; | |
| if (dir == AVC_BRIDGECO_PLUG_DIR_IN) | |
| formations = bebob->rx_stream_formations; | |
| else | |
| formations = bebob->tx_stream_formations; | |
| for (eid = 0; eid < SND_BEBOB_STRM_FMT_ENTRIES; eid++) { | |
| len = FORMAT_MAXIMUM_LENGTH; | |
| avc_bridgeco_fill_unit_addr(addr, dir, | |
| AVC_BRIDGECO_PLUG_UNIT_ISOC, pid); | |
| err = avc_bridgeco_get_plug_strm_fmt(bebob->unit, addr, buf, | |
| &len, eid); | |
| /* No entries remained. */ | |
| if (err == -EINVAL && eid > 0) { | |
| err = 0; | |
| break; | |
| } else if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get stream format %d for isoc %s plug %d:%d\n", | |
| eid, | |
| (dir == AVC_BRIDGECO_PLUG_DIR_IN) ? "in" : | |
| "out", | |
| pid, err); | |
| break; | |
| } | |
| err = parse_stream_formation(buf, len, formations); | |
| if (err < 0) | |
| break; | |
| } | |
| kfree(buf); | |
| return err; | |
| } | |
| static int | |
| seek_msu_sync_input_plug(struct snd_bebob *bebob) | |
| { | |
| u8 plugs[AVC_PLUG_INFO_BUF_BYTES], addr[AVC_BRIDGECO_ADDR_BYTES]; | |
| unsigned int i; | |
| enum avc_bridgeco_plug_type type; | |
| int err; | |
| /* Get the number of Music Sub Unit for both direction. */ | |
| err = avc_general_get_plug_info(bebob->unit, 0x0c, 0x00, 0x00, plugs); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get info for MSU in/out plugs: %d\n", | |
| err); | |
| goto end; | |
| } | |
| /* seek destination plugs for 'MSU sync input' */ | |
| bebob->sync_input_plug = -1; | |
| for (i = 0; i < plugs[0]; i++) { | |
| avc_bridgeco_fill_msu_addr(addr, AVC_BRIDGECO_PLUG_DIR_IN, i); | |
| err = avc_bridgeco_get_plug_type(bebob->unit, addr, &type); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get type for MSU in plug %d: %d\n", | |
| i, err); | |
| goto end; | |
| } | |
| if (type == AVC_BRIDGECO_PLUG_TYPE_SYNC) { | |
| bebob->sync_input_plug = i; | |
| break; | |
| } | |
| } | |
| end: | |
| return err; | |
| } | |
| int snd_bebob_stream_discover(struct snd_bebob *bebob) | |
| { | |
| struct snd_bebob_clock_spec *clk_spec = bebob->spec->clock; | |
| u8 plugs[AVC_PLUG_INFO_BUF_BYTES], addr[AVC_BRIDGECO_ADDR_BYTES]; | |
| enum avc_bridgeco_plug_type type; | |
| unsigned int i; | |
| int err; | |
| /* the number of plugs for isoc in/out, ext in/out */ | |
| err = avc_general_get_plug_info(bebob->unit, 0x1f, 0x07, 0x00, plugs); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get info for isoc/external in/out plugs: %d\n", | |
| err); | |
| goto end; | |
| } | |
| /* | |
| * This module supports at least one isoc input plug and one isoc | |
| * output plug. | |
| */ | |
| if ((plugs[0] == 0) || (plugs[1] == 0)) { | |
| err = -ENOSYS; | |
| goto end; | |
| } | |
| avc_bridgeco_fill_unit_addr(addr, AVC_BRIDGECO_PLUG_DIR_IN, | |
| AVC_BRIDGECO_PLUG_UNIT_ISOC, 0); | |
| err = avc_bridgeco_get_plug_type(bebob->unit, addr, &type); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get type for isoc in plug 0: %d\n", err); | |
| goto end; | |
| } else if (type != AVC_BRIDGECO_PLUG_TYPE_ISOC) { | |
| err = -ENOSYS; | |
| goto end; | |
| } | |
| err = fill_stream_formations(bebob, AVC_BRIDGECO_PLUG_DIR_IN, 0); | |
| if (err < 0) | |
| goto end; | |
| avc_bridgeco_fill_unit_addr(addr, AVC_BRIDGECO_PLUG_DIR_OUT, | |
| AVC_BRIDGECO_PLUG_UNIT_ISOC, 0); | |
| err = avc_bridgeco_get_plug_type(bebob->unit, addr, &type); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get type for isoc out plug 0: %d\n", err); | |
| goto end; | |
| } else if (type != AVC_BRIDGECO_PLUG_TYPE_ISOC) { | |
| err = -ENOSYS; | |
| goto end; | |
| } | |
| err = fill_stream_formations(bebob, AVC_BRIDGECO_PLUG_DIR_OUT, 0); | |
| if (err < 0) | |
| goto end; | |
| /* count external input plugs for MIDI */ | |
| bebob->midi_input_ports = 0; | |
| for (i = 0; i < plugs[2]; i++) { | |
| avc_bridgeco_fill_unit_addr(addr, AVC_BRIDGECO_PLUG_DIR_IN, | |
| AVC_BRIDGECO_PLUG_UNIT_EXT, i); | |
| err = avc_bridgeco_get_plug_type(bebob->unit, addr, &type); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get type for external in plug %d: %d\n", | |
| i, err); | |
| goto end; | |
| } else if (type == AVC_BRIDGECO_PLUG_TYPE_MIDI) { | |
| bebob->midi_input_ports++; | |
| } | |
| } | |
| /* count external output plugs for MIDI */ | |
| bebob->midi_output_ports = 0; | |
| for (i = 0; i < plugs[3]; i++) { | |
| avc_bridgeco_fill_unit_addr(addr, AVC_BRIDGECO_PLUG_DIR_OUT, | |
| AVC_BRIDGECO_PLUG_UNIT_EXT, i); | |
| err = avc_bridgeco_get_plug_type(bebob->unit, addr, &type); | |
| if (err < 0) { | |
| dev_err(&bebob->unit->device, | |
| "fail to get type for external out plug %d: %d\n", | |
| i, err); | |
| goto end; | |
| } else if (type == AVC_BRIDGECO_PLUG_TYPE_MIDI) { | |
| bebob->midi_output_ports++; | |
| } | |
| } | |
| /* for check source of clock later */ | |
| if (!clk_spec) | |
| err = seek_msu_sync_input_plug(bebob); | |
| end: | |
| return err; | |
| } | |
| void snd_bebob_stream_lock_changed(struct snd_bebob *bebob) | |
| { | |
| bebob->dev_lock_changed = true; | |
| wake_up(&bebob->hwdep_wait); | |
| } | |
| int snd_bebob_stream_lock_try(struct snd_bebob *bebob) | |
| { | |
| int err; | |
| spin_lock_irq(&bebob->lock); | |
| /* user land lock this */ | |
| if (bebob->dev_lock_count < 0) { | |
| err = -EBUSY; | |
| goto end; | |
| } | |
| /* this is the first time */ | |
| if (bebob->dev_lock_count++ == 0) | |
| snd_bebob_stream_lock_changed(bebob); | |
| err = 0; | |
| end: | |
| spin_unlock_irq(&bebob->lock); | |
| return err; | |
| } | |
| void snd_bebob_stream_lock_release(struct snd_bebob *bebob) | |
| { | |
| spin_lock_irq(&bebob->lock); | |
| if (WARN_ON(bebob->dev_lock_count <= 0)) | |
| goto end; | |
| if (--bebob->dev_lock_count == 0) | |
| snd_bebob_stream_lock_changed(bebob); | |
| end: | |
| spin_unlock_irq(&bebob->lock); | |
| } |