mirror of
https://github.com/torvalds/linux.git
synced 2024-12-24 03:42:52 +00:00
6d1ef1bbfe
As a result of investigation for Fireface 800, 'struct snd_ff_spec.regs' is just for higher address to receive tx asynchronous packets of MIDI messages, thus it can be simplified. This commit simplifies it. Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp> Signed-off-by: Takashi Iwai <tiwai@suse.de>
327 lines
8.6 KiB
C
327 lines
8.6 KiB
C
/*
|
|
* ff-transaction.c - a part of driver for RME Fireface series
|
|
*
|
|
* Copyright (c) 2015-2017 Takashi Sakamoto
|
|
*
|
|
* Licensed under the terms of the GNU General Public License, version 2.
|
|
*/
|
|
|
|
#include "ff.h"
|
|
|
|
#define SND_FF_REG_MIDI_RX_PORT_0 0x000080180000ull
|
|
#define SND_FF_REG_MIDI_RX_PORT_1 0x000080190000ull
|
|
|
|
int snd_ff_transaction_get_clock(struct snd_ff *ff, unsigned int *rate,
|
|
enum snd_ff_clock_src *src)
|
|
{
|
|
__le32 reg;
|
|
u32 data;
|
|
int err;
|
|
|
|
err = snd_fw_transaction(ff->unit, TCODE_READ_QUADLET_REQUEST,
|
|
SND_FF_REG_CLOCK_CONFIG, ®, sizeof(reg), 0);
|
|
if (err < 0)
|
|
return err;
|
|
data = le32_to_cpu(reg);
|
|
|
|
/* Calculate sampling rate. */
|
|
switch ((data >> 1) & 0x03) {
|
|
case 0x01:
|
|
*rate = 32000;
|
|
break;
|
|
case 0x00:
|
|
*rate = 44100;
|
|
break;
|
|
case 0x03:
|
|
*rate = 48000;
|
|
break;
|
|
case 0x02:
|
|
default:
|
|
return -EIO;
|
|
}
|
|
|
|
if (data & 0x08)
|
|
*rate *= 2;
|
|
else if (data & 0x10)
|
|
*rate *= 4;
|
|
|
|
/* Calculate source of clock. */
|
|
if (data & 0x01) {
|
|
*src = SND_FF_CLOCK_SRC_INTERNAL;
|
|
} else {
|
|
/* TODO: 0x02, 0x06, 0x07? */
|
|
switch ((data >> 10) & 0x07) {
|
|
case 0x00:
|
|
*src = SND_FF_CLOCK_SRC_ADAT1;
|
|
break;
|
|
case 0x01:
|
|
*src = SND_FF_CLOCK_SRC_ADAT2;
|
|
break;
|
|
case 0x03:
|
|
*src = SND_FF_CLOCK_SRC_SPDIF;
|
|
break;
|
|
case 0x04:
|
|
*src = SND_FF_CLOCK_SRC_WORD;
|
|
break;
|
|
case 0x05:
|
|
*src = SND_FF_CLOCK_SRC_LTC;
|
|
break;
|
|
default:
|
|
return -EIO;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void finish_transmit_midi_msg(struct snd_ff *ff, unsigned int port,
|
|
int rcode)
|
|
{
|
|
struct snd_rawmidi_substream *substream =
|
|
READ_ONCE(ff->rx_midi_substreams[port]);
|
|
|
|
if (rcode_is_permanent_error(rcode)) {
|
|
ff->rx_midi_error[port] = true;
|
|
return;
|
|
}
|
|
|
|
if (rcode != RCODE_COMPLETE) {
|
|
/* Transfer the message again, immediately. */
|
|
ff->next_ktime[port] = 0;
|
|
schedule_work(&ff->rx_midi_work[port]);
|
|
return;
|
|
}
|
|
|
|
snd_rawmidi_transmit_ack(substream, ff->rx_bytes[port]);
|
|
ff->rx_bytes[port] = 0;
|
|
|
|
if (!snd_rawmidi_transmit_empty(substream))
|
|
schedule_work(&ff->rx_midi_work[port]);
|
|
}
|
|
|
|
static void finish_transmit_midi0_msg(struct fw_card *card, int rcode,
|
|
void *data, size_t length,
|
|
void *callback_data)
|
|
{
|
|
struct snd_ff *ff =
|
|
container_of(callback_data, struct snd_ff, transactions[0]);
|
|
finish_transmit_midi_msg(ff, 0, rcode);
|
|
}
|
|
|
|
static void finish_transmit_midi1_msg(struct fw_card *card, int rcode,
|
|
void *data, size_t length,
|
|
void *callback_data)
|
|
{
|
|
struct snd_ff *ff =
|
|
container_of(callback_data, struct snd_ff, transactions[1]);
|
|
finish_transmit_midi_msg(ff, 1, rcode);
|
|
}
|
|
|
|
static inline void fill_midi_buf(struct snd_ff *ff, unsigned int port,
|
|
unsigned int index, u8 byte)
|
|
{
|
|
ff->msg_buf[port][index] = cpu_to_le32(byte);
|
|
}
|
|
|
|
static void transmit_midi_msg(struct snd_ff *ff, unsigned int port)
|
|
{
|
|
struct snd_rawmidi_substream *substream =
|
|
READ_ONCE(ff->rx_midi_substreams[port]);
|
|
u8 *buf = (u8 *)ff->msg_buf[port];
|
|
int i, len;
|
|
|
|
struct fw_device *fw_dev = fw_parent_device(ff->unit);
|
|
unsigned long long addr;
|
|
int generation;
|
|
fw_transaction_callback_t callback;
|
|
|
|
if (substream == NULL || snd_rawmidi_transmit_empty(substream))
|
|
return;
|
|
|
|
if (ff->rx_bytes[port] > 0 || ff->rx_midi_error[port])
|
|
return;
|
|
|
|
/* Do it in next chance. */
|
|
if (ktime_after(ff->next_ktime[port], ktime_get())) {
|
|
schedule_work(&ff->rx_midi_work[port]);
|
|
return;
|
|
}
|
|
|
|
len = snd_rawmidi_transmit_peek(substream, buf,
|
|
SND_FF_MAXIMIM_MIDI_QUADS);
|
|
if (len <= 0)
|
|
return;
|
|
|
|
for (i = len - 1; i >= 0; i--)
|
|
fill_midi_buf(ff, port, i, buf[i]);
|
|
|
|
if (port == 0) {
|
|
addr = SND_FF_REG_MIDI_RX_PORT_0;
|
|
callback = finish_transmit_midi0_msg;
|
|
} else {
|
|
addr = SND_FF_REG_MIDI_RX_PORT_1;
|
|
callback = finish_transmit_midi1_msg;
|
|
}
|
|
|
|
/* Set interval to next transaction. */
|
|
ff->next_ktime[port] = ktime_add_ns(ktime_get(),
|
|
len * 8 * NSEC_PER_SEC / 31250);
|
|
ff->rx_bytes[port] = len;
|
|
|
|
/*
|
|
* In Linux FireWire core, when generation is updated with memory
|
|
* barrier, node id has already been updated. In this module, After
|
|
* this smp_rmb(), load/store instructions to memory are completed.
|
|
* Thus, both of generation and node id are available with recent
|
|
* values. This is a light-serialization solution to handle bus reset
|
|
* events on IEEE 1394 bus.
|
|
*/
|
|
generation = fw_dev->generation;
|
|
smp_rmb();
|
|
fw_send_request(fw_dev->card, &ff->transactions[port],
|
|
TCODE_WRITE_BLOCK_REQUEST,
|
|
fw_dev->node_id, generation, fw_dev->max_speed,
|
|
addr, &ff->msg_buf[port], len * 4,
|
|
callback, &ff->transactions[port]);
|
|
}
|
|
|
|
static void transmit_midi0_msg(struct work_struct *work)
|
|
{
|
|
struct snd_ff *ff = container_of(work, struct snd_ff, rx_midi_work[0]);
|
|
|
|
transmit_midi_msg(ff, 0);
|
|
}
|
|
|
|
static void transmit_midi1_msg(struct work_struct *work)
|
|
{
|
|
struct snd_ff *ff = container_of(work, struct snd_ff, rx_midi_work[1]);
|
|
|
|
transmit_midi_msg(ff, 1);
|
|
}
|
|
|
|
static void handle_midi_msg(struct fw_card *card, struct fw_request *request,
|
|
int tcode, int destination, int source,
|
|
int generation, unsigned long long offset,
|
|
void *data, size_t length, void *callback_data)
|
|
{
|
|
struct snd_ff *ff = callback_data;
|
|
__le32 *buf = data;
|
|
|
|
fw_send_response(card, request, RCODE_COMPLETE);
|
|
|
|
ff->spec->protocol->handle_midi_msg(ff, buf, length);
|
|
}
|
|
|
|
static int allocate_own_address(struct snd_ff *ff, int i)
|
|
{
|
|
struct fw_address_region midi_msg_region;
|
|
int err;
|
|
|
|
ff->async_handler.length = SND_FF_MAXIMIM_MIDI_QUADS * 4;
|
|
ff->async_handler.address_callback = handle_midi_msg;
|
|
ff->async_handler.callback_data = ff;
|
|
|
|
midi_msg_region.start = 0x000100000000ull * i;
|
|
midi_msg_region.end = midi_msg_region.start + ff->async_handler.length;
|
|
|
|
err = fw_core_add_address_handler(&ff->async_handler, &midi_msg_region);
|
|
if (err >= 0) {
|
|
/* Controllers are allowed to register this region. */
|
|
if (ff->async_handler.offset & 0x0000ffffffff) {
|
|
fw_core_remove_address_handler(&ff->async_handler);
|
|
err = -EAGAIN;
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Controllers are allowed to register higher 4 bytes of address to receive
|
|
* the transactions. Different models have different registers for this purpose;
|
|
* e.g. 0x'0000'8010'03f4 for Fireface 400.
|
|
* The controllers are not allowed to register lower 4 bytes of the address.
|
|
* They are forced to select one of 4 options for the part of address by writing
|
|
* corresponding bits to 0x'0000'8010'051f.
|
|
*
|
|
* The 3rd-6th bits of this register are flags to indicate lower 4 bytes of
|
|
* address to which the device transferrs the transactions. In short:
|
|
* - 0x20: 0x'....'....'0000'0180
|
|
* - 0x10: 0x'....'....'0000'0100
|
|
* - 0x08: 0x'....'....'0000'0080
|
|
* - 0x04: 0x'....'....'0000'0000
|
|
*
|
|
* This driver configure 0x'....'....'0000'0000 to receive MIDI messages from
|
|
* units. The 3rd bit of the register should be configured, however this driver
|
|
* deligates this task to userspace applications due to a restriction that this
|
|
* register is write-only and the other bits have own effects.
|
|
*
|
|
* Unlike Fireface 800, Fireface 400 cancels transferring asynchronous
|
|
* transactions when the 1st and 2nd of the register stand. These two bits have
|
|
* the same effect.
|
|
* - 0x02, 0x01: cancel transferring
|
|
*
|
|
* On the other hand, the bits have no effect on Fireface 800. This model
|
|
* cancels asynchronous transactions when the higher 4 bytes of address is
|
|
* overwritten with zero.
|
|
*/
|
|
int snd_ff_transaction_reregister(struct snd_ff *ff)
|
|
{
|
|
struct fw_card *fw_card = fw_parent_device(ff->unit)->card;
|
|
u32 addr;
|
|
__le32 reg;
|
|
|
|
/*
|
|
* Controllers are allowed to register its node ID and upper 2 byte of
|
|
* local address to listen asynchronous transactions.
|
|
*/
|
|
addr = (fw_card->node_id << 16) | (ff->async_handler.offset >> 32);
|
|
reg = cpu_to_le32(addr);
|
|
return snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
|
|
ff->spec->midi_high_addr,
|
|
®, sizeof(reg), 0);
|
|
}
|
|
|
|
int snd_ff_transaction_register(struct snd_ff *ff)
|
|
{
|
|
int i, err;
|
|
|
|
/*
|
|
* Allocate in Memory Space of IEC 13213, but lower 4 byte in LSB should
|
|
* be zero due to device specification.
|
|
*/
|
|
for (i = 0; i < 0xffff; i++) {
|
|
err = allocate_own_address(ff, i);
|
|
if (err != -EBUSY && err != -EAGAIN)
|
|
break;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_ff_transaction_reregister(ff);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
INIT_WORK(&ff->rx_midi_work[0], transmit_midi0_msg);
|
|
INIT_WORK(&ff->rx_midi_work[1], transmit_midi1_msg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void snd_ff_transaction_unregister(struct snd_ff *ff)
|
|
{
|
|
__le32 reg;
|
|
|
|
if (ff->async_handler.callback_data == NULL)
|
|
return;
|
|
ff->async_handler.callback_data = NULL;
|
|
|
|
/* Release higher 4 bytes of address. */
|
|
reg = cpu_to_le32(0x00000000);
|
|
snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
|
|
ff->spec->midi_high_addr,
|
|
®, sizeof(reg), 0);
|
|
|
|
fw_core_remove_address_handler(&ff->async_handler);
|
|
}
|