Skip to content

Commit

Permalink
ALSA: oxfw: copy handlers of asynchronous transaction for MIDI playback
Browse files Browse the repository at this point in the history
This commit copies some functions of asynchronous transactions for MIDI
playback, to merge scs1x module. The features of payload in asynchronous
transaction are the same as captured MIDI messages.

Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
  • Loading branch information
Takashi Sakamoto authored and Takashi Iwai committed Dec 22, 2015
1 parent 8250427 commit d7d20e7
Showing 1 changed file with 161 additions and 0 deletions.
161 changes: 161 additions & 0 deletions sound/firewire/oxfw/oxfw-scs1x.c
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,20 @@ struct fw_scs1x {
struct fw_address_handler hss_handler;
u8 input_escape_count;
struct snd_rawmidi_substream *input;

/* For MIDI playback. */
struct snd_rawmidi_substream *output;
bool output_idle;
u8 output_status;
u8 output_bytes;
bool output_escaped;
bool output_escape_high_nibble;
struct tasklet_struct tasklet;
wait_queue_head_t idle_wait;
u8 buffer[HSS1394_MAX_PACKET_SIZE];
bool transaction_running;
struct fw_transaction transaction;
struct fw_device *fw_dev;
};

static const u8 sysex_escape_prefix[] = {
Expand Down Expand Up @@ -106,6 +120,148 @@ static void handle_hss(struct fw_card *card, struct fw_request *request,
fw_send_response(card, request, rcode);
}

static void scs_write_callback(struct fw_card *card, int rcode,
void *data, size_t length, void *callback_data)
{
struct fw_scs1x *scs = callback_data;

if (rcode == RCODE_GENERATION)
; /* TODO: retry this packet */

scs->transaction_running = false;
tasklet_schedule(&scs->tasklet);
}

static bool is_valid_running_status(u8 status)
{
return status >= 0x80 && status <= 0xef;
}

static bool is_one_byte_cmd(u8 status)
{
return status == 0xf6 ||
status >= 0xf8;
}

static bool is_two_bytes_cmd(u8 status)
{
return (status >= 0xc0 && status <= 0xdf) ||
status == 0xf1 ||
status == 0xf3;
}

static bool is_three_bytes_cmd(u8 status)
{
return (status >= 0x80 && status <= 0xbf) ||
(status >= 0xe0 && status <= 0xef) ||
status == 0xf2;
}

static bool is_invalid_cmd(u8 status)
{
return status == 0xf4 ||
status == 0xf5 ||
status == 0xf9 ||
status == 0xfd;
}

static void scs_output_tasklet(unsigned long data)
{
struct fw_scs1x *scs = (struct fw_scs1x *)data;
struct snd_rawmidi_substream *stream;
unsigned int i;
u8 byte;
int generation;

if (scs->transaction_running)
return;

stream = ACCESS_ONCE(scs->output);
if (!stream) {
scs->output_idle = true;
wake_up(&scs->idle_wait);
return;
}

i = scs->output_bytes;
for (;;) {
if (snd_rawmidi_transmit(stream, &byte, 1) != 1) {
scs->output_bytes = i;
scs->output_idle = true;
wake_up(&scs->idle_wait);
return;
}
/*
* Convert from real MIDI to what I think the device expects (no
* running status, one command per packet, unescaped SysExs).
*/
if (scs->output_escaped && byte < 0x80) {
if (scs->output_escape_high_nibble) {
if (i < HSS1394_MAX_PACKET_SIZE) {
scs->buffer[i] = byte << 4;
scs->output_escape_high_nibble = false;
}
} else {
scs->buffer[i++] |= byte & 0x0f;
scs->output_escape_high_nibble = true;
}
} else if (byte < 0x80) {
if (i == 1) {
if (!is_valid_running_status(
scs->output_status))
continue;
scs->buffer[0] = HSS1394_TAG_USER_DATA;
scs->buffer[i++] = scs->output_status;
}
scs->buffer[i++] = byte;
if ((i == 3 && is_two_bytes_cmd(scs->output_status)) ||
(i == 4 && is_three_bytes_cmd(scs->output_status)))
break;
if (i == 1 + ARRAY_SIZE(sysex_escape_prefix) &&
!memcmp(scs->buffer + 1, sysex_escape_prefix,
ARRAY_SIZE(sysex_escape_prefix))) {
scs->output_escaped = true;
scs->output_escape_high_nibble = true;
i = 0;
}
if (i >= HSS1394_MAX_PACKET_SIZE)
i = 1;
} else if (byte == 0xf7) {
if (scs->output_escaped) {
if (i >= 1 && scs->output_escape_high_nibble &&
scs->buffer[0] !=
HSS1394_TAG_CHANGE_ADDRESS)
break;
} else {
if (i > 1 && scs->output_status == 0xf0) {
scs->buffer[i++] = 0xf7;
break;
}
}
i = 1;
scs->output_escaped = false;
} else if (!is_invalid_cmd(byte) && byte < 0xf8) {
i = 1;
scs->buffer[0] = HSS1394_TAG_USER_DATA;
scs->buffer[i++] = byte;
scs->output_status = byte;
scs->output_escaped = false;
if (is_one_byte_cmd(byte))
break;
}
}
scs->output_bytes = 1;
scs->output_escaped = false;

scs->transaction_running = true;
generation = scs->fw_dev->generation;
smp_rmb(); /* node_id vs. generation */
fw_send_request(scs->fw_dev->card, &scs->transaction,
TCODE_WRITE_BLOCK_REQUEST, scs->fw_dev->node_id,
generation, scs->fw_dev->max_speed, HSS1394_ADDRESS,
scs->buffer, i, scs_write_callback, scs);
}

static int midi_capture_open(struct snd_rawmidi_substream *stream)
{
return 0;
Expand Down Expand Up @@ -166,6 +322,7 @@ int snd_oxfw_scs1x_add(struct snd_oxfw *oxfw)
scs = kzalloc(sizeof(struct fw_scs1x), GFP_KERNEL);
if (scs == NULL)
return -ENOMEM;
scs->fw_dev = fw_parent_device(oxfw->unit);
oxfw->spec = scs;

/* Allocate own handler for imcoming asynchronous transaction. */
Expand Down Expand Up @@ -195,6 +352,10 @@ int snd_oxfw_scs1x_add(struct snd_oxfw *oxfw)
snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
&midi_capture_ops);

tasklet_init(&scs->tasklet, scs_output_tasklet, (unsigned long)scs);
init_waitqueue_head(&scs->idle_wait);
scs->output_idle = true;

return 0;
err_allocated:
fw_core_remove_address_handler(&scs->hss_handler);
Expand Down

0 comments on commit d7d20e7

Please sign in to comment.