[linux-2.6-block.git] / sound / firewire / tascam / tascam-transaction.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * tascam-transaction.c - a part of driver for TASCAM FireWire series
 *
 * Copyright (c) 2015 Takashi Sakamoto
 */

#include "tascam.h"

/*
 * When return minus value, given argument is not MIDI status.
 * When return 0, given argument is a beginning of system exclusive.
 * When return the others, given argument is MIDI data.
 */
static inline int calculate_message_bytes(u8 status)
{
	switch (status) {
	case 0xf6:	/* Tune request. */
	case 0xf8:	/* Timing clock. */
	case 0xfa:	/* Start. */
	case 0xfb:	/* Continue. */
	case 0xfc:	/* Stop. */
	case 0xfe:	/* Active sensing. */
	case 0xff:	/* System reset. */
		return 1;
	case 0xf1:	/* MIDI time code quarter frame. */
	case 0xf3:	/* Song select. */
		return 2;
	case 0xf2:	/* Song position pointer. */
		return 3;
	case 0xf0:	/* Exclusive. */
		return 0;
	case 0xf7:	/* End of exclusive. */
		break;
	case 0xf4:	/* Undefined. */
	case 0xf5:	/* Undefined. */
	case 0xf9:	/* Undefined. */
	case 0xfd:	/* Undefined. */
		break;
	default:
		switch (status & 0xf0) {
		case 0x80:	/* Note on. */
		case 0x90:	/* Note off. */
		case 0xa0:	/* Polyphonic key pressure. */
		case 0xb0:	/* Control change and Mode change. */
		case 0xe0:	/* Pitch bend change. */
			return 3;
		case 0xc0:	/* Program change. */
		case 0xd0:	/* Channel pressure. */
			return 2;
		default:
		break;
		}
	break;
	}

	return -EINVAL;
}

static int fill_message(struct snd_fw_async_midi_port *port,
			struct snd_rawmidi_substream *substream)
{
	int i, len, consume;
	u8 *label, *msg;
	u8 status;

	/* The first byte is used for label, the rest for MIDI bytes. */
	label = port->buf;
	msg = port->buf + 1;

	consume = snd_rawmidi_transmit_peek(substream, msg, 3);
	if (consume == 0)
		return 0;

	/* On exclusive message. */
	if (port->on_sysex) {
		/* Seek the end of exclusives. */
		for (i = 0; i < consume; ++i) {
			if (msg[i] == 0xf7) {
				port->on_sysex = false;
				break;
			}
		}

		/* At the end of exclusive message, use label 0x07. */
		if (!port->on_sysex) {
			consume = i + 1;
			*label = (substream->number << 4) | 0x07;
		/* During exclusive message, use label 0x04. */
		} else if (consume == 3) {
			*label = (substream->number << 4) | 0x04;
		/* We need to fill whole 3 bytes. Go to next change. */
		} else {
			return 0;
		}

		len = consume;
	} else {
		/* The beginning of exclusives. */
		if (msg[0] == 0xf0) {
			/* Transfer it in next chance in another condition. */
			port->on_sysex = true;
			return 0;
		} else {
			/* On running-status. */
			if ((msg[0] & 0x80) != 0x80)
				status = port->running_status;
			else
				status = msg[0];

			/* Calculate consume bytes. */
			len = calculate_message_bytes(status);
			if (len <= 0)
				return 0;

			/* On running-status. */
			if ((msg[0] & 0x80) != 0x80) {
				/* Enough MIDI bytes were not retrieved. */
				if (consume < len - 1)
					return 0;
				consume = len - 1;

				msg[2] = msg[1];
				msg[1] = msg[0];
				msg[0] = port->running_status;
			} else {
				/* Enough MIDI bytes were not retrieved. */
				if (consume < len)
					return 0;
				consume = len;

				port->running_status = msg[0];
			}
		}

		*label = (substream->number << 4) | (msg[0] >> 4);
	}

	if (len > 0 && len < 3)
		memset(msg + len, 0, 3 - len);

	return consume;
}

static void async_midi_port_callback(struct fw_card *card, int rcode,
				     void *data, size_t length,
				     void *callback_data)
{
	struct snd_fw_async_midi_port *port = callback_data;
	struct snd_rawmidi_substream *substream = READ_ONCE(port->substream);

	/* This port is closed. */
	if (substream == NULL)
		return;

	if (rcode == RCODE_COMPLETE)
		snd_rawmidi_transmit_ack(substream, port->consume_bytes);
	else if (!rcode_is_permanent_error(rcode))
		/* To start next transaction immediately for recovery. */
		port->next_ktime = 0;
	else
		/* Don't continue processing. */
		port->error = true;

	port->idling = true;

	if (!snd_rawmidi_transmit_empty(substream))
		schedule_work(&port->work);
}

static void midi_port_work(struct work_struct *work)
{
	struct snd_fw_async_midi_port *port =
			container_of(work, struct snd_fw_async_midi_port, work);
	struct snd_rawmidi_substream *substream = READ_ONCE(port->substream);
	int generation;

	/* Under transacting or error state. */
	if (!port->idling || port->error)
		return;

	/* Nothing to do. */
	if (substream == NULL || snd_rawmidi_transmit_empty(substream))
		return;

	/* Do it in next chance. */
	if (ktime_after(port->next_ktime, ktime_get())) {
		schedule_work(&port->work);
		return;
	}

	/*
	 * Fill the buffer. The callee must use snd_rawmidi_transmit_peek().
	 * Later, snd_rawmidi_transmit_ack() is called.
	 */
	memset(port->buf, 0, 4);
	port->consume_bytes = fill_message(port, substream);
	if (port->consume_bytes <= 0) {
		/* Do it in next chance, immediately. */
		if (port->consume_bytes == 0) {
			port->next_ktime = 0;
			schedule_work(&port->work);
		} else {
			/* Fatal error. */
			port->error = true;
		}
		return;
	}

	/* Set interval to next transaction. */
	port->next_ktime = ktime_add_ns(ktime_get(),
				port->consume_bytes * 8 * NSEC_PER_SEC / 31250);

	/* Start this transaction. */
	port->idling = false;

	/*
	 * 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 = port->parent->generation;
	smp_rmb();

	fw_send_request(port->parent->card, &port->transaction,
			TCODE_WRITE_QUADLET_REQUEST,
			port->parent->node_id, generation,
			port->parent->max_speed,
			TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_RX_QUAD,
			port->buf, 4, async_midi_port_callback,
			port);
}

void snd_fw_async_midi_port_init(struct snd_fw_async_midi_port *port)
{
	port->idling = true;
	port->error = false;
	port->running_status = 0;
	port->on_sysex = false;
}

static void handle_midi_tx(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_tscm *tscm = callback_data;
	u32 *buf = (u32 *)data;
	unsigned int messages;
	unsigned int i;
	unsigned int port;
	struct snd_rawmidi_substream *substream;
	u8 *b;
	int bytes;

	if (offset != tscm->async_handler.offset)
		goto end;

	messages = length / 8;
	for (i = 0; i < messages; i++) {
		b = (u8 *)(buf + i * 2);

		port = b[0] >> 4;
		/* TODO: support virtual MIDI ports. */
		if (port >= tscm->spec->midi_capture_ports)
			goto end;

		/* Assume the message length. */
		bytes = calculate_message_bytes(b[1]);
		/* On MIDI data or exclusives. */
		if (bytes <= 0) {
			/* Seek the end of exclusives. */
			for (bytes = 1; bytes < 4; bytes++) {
				if (b[bytes] == 0xf7)
					break;
			}
			if (bytes == 4)
				bytes = 3;
		}

		substream = READ_ONCE(tscm->tx_midi_substreams[port]);
		if (substream != NULL)
			snd_rawmidi_receive(substream, b + 1, bytes);
	}
end:
	fw_send_response(card, request, RCODE_COMPLETE);
}

int snd_tscm_transaction_register(struct snd_tscm *tscm)
{
	static const struct fw_address_region resp_register_region = {
		.start	= 0xffffe0000000ull,
		.end	= 0xffffe000ffffull,
	};
	unsigned int i;
	int err;

	/*
	 * Usually, two quadlets are transferred by one transaction. The first
	 * quadlet has MIDI messages, the rest includes timestamp.
	 * Sometimes, 8 set of the data is transferred by a block transaction.
	 */
	tscm->async_handler.length = 8 * 8;
	tscm->async_handler.address_callback = handle_midi_tx;
	tscm->async_handler.callback_data = tscm;

	err = fw_core_add_address_handler(&tscm->async_handler,
					  &resp_register_region);
	if (err < 0)
		return err;

	err = snd_tscm_transaction_reregister(tscm);
	if (err < 0)
		goto error;

	for (i = 0; i < TSCM_MIDI_OUT_PORT_MAX; i++) {
		tscm->out_ports[i].parent = fw_parent_device(tscm->unit);
		tscm->out_ports[i].next_ktime = 0;
		INIT_WORK(&tscm->out_ports[i].work, midi_port_work);
	}

	return err;
error:
	fw_core_remove_address_handler(&tscm->async_handler);
	tscm->async_handler.callback_data = NULL;
	return err;
}

/* At bus reset, these registers are cleared. */
int snd_tscm_transaction_reregister(struct snd_tscm *tscm)
{
	struct fw_device *device = fw_parent_device(tscm->unit);
	__be32 reg;
	int err;

	/* Register messaging address. Block transaction is not allowed. */
	reg = cpu_to_be32((device->card->node_id << 16) |
			  (tscm->async_handler.offset >> 32));
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	reg = cpu_to_be32(tscm->async_handler.offset);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	/* Turn on messaging. */
	reg = cpu_to_be32(0x00000001);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				  TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
				  &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	/* Turn on FireWire LED. */
	reg = cpu_to_be32(0x0001008e);
	return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				  TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
				  &reg, sizeof(reg), 0);
}

void snd_tscm_transaction_unregister(struct snd_tscm *tscm)
{
	__be32 reg;

	if (tscm->async_handler.callback_data == NULL)
		return;

	/* Turn off FireWire LED. */
	reg = cpu_to_be32(0x0000008e);
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
			   &reg, sizeof(reg), 0);

	/* Turn off messaging. */
	reg = cpu_to_be32(0x00000000);
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
			   &reg, sizeof(reg), 0);

	/* Unregister the address. */
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
			   &reg, sizeof(reg), 0);
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
			   &reg, sizeof(reg), 0);

	fw_core_remove_address_handler(&tscm->async_handler);
	tscm->async_handler.callback_data = NULL;
}
Commit	Line	Data
da607e19	1	// SPDX-License-Identifier: GPL-2.0-only
107cc012 TS	2	/*
	3	* tascam-transaction.c - a part of driver for TASCAM FireWire series
	4	*
	5	* Copyright (c) 2015 Takashi Sakamoto
107cc012 TS	6	*/
	7
	8	#include "tascam.h"
	9
	10	/*
	11	* When return minus value, given argument is not MIDI status.
	12	* When return 0, given argument is a beginning of system exclusive.
	13	* When return the others, given argument is MIDI data.
	14	*/
	15	static inline int calculate_message_bytes(u8 status)
	16	{
	17	switch (status) {
	18	case 0xf6: /* Tune request. */
	19	case 0xf8: /* Timing clock. */
	20	case 0xfa: /* Start. */
	21	case 0xfb: /* Continue. */
	22	case 0xfc: /* Stop. */
	23	case 0xfe: /* Active sensing. */
	24	case 0xff: /* System reset. */
	25	return 1;
	26	case 0xf1: /* MIDI time code quarter frame. */
	27	case 0xf3: /* Song select. */
	28	return 2;
	29	case 0xf2: /* Song position pointer. */
	30	return 3;
	31	case 0xf0: /* Exclusive. */
	32	return 0;
	33	case 0xf7: /* End of exclusive. */
	34	break;
	35	case 0xf4: /* Undefined. */
	36	case 0xf5: /* Undefined. */
	37	case 0xf9: /* Undefined. */
	38	case 0xfd: /* Undefined. */
	39	break;
	40	default:
	41	switch (status & 0xf0) {
	42	case 0x80: /* Note on. */
	43	case 0x90: /* Note off. */
	44	case 0xa0: /* Polyphonic key pressure. */
	45	case 0xb0: /* Control change and Mode change. */
	46	case 0xe0: /* Pitch bend change. */
	47	return 3;
	48	case 0xc0: /* Program change. */
	49	case 0xd0: /* Channel pressure. */
	50	return 2;
	51	default:
	52	break;
	53	}
	54	break;
	55	}
	56
	57	return -EINVAL;
	58	}
	59
1f94205d TS	60	static int fill_message(struct snd_fw_async_midi_port *port,
1f94205d TS	61	struct snd_rawmidi_substream *substream)
3beab0f8	62	{
516a3061	63	int i, len, consume;
123990e9	64	u8 label, msg;
3beab0f8	65	u8 status;
3beab0f8	66
123990e9	67	/* The first byte is used for label, the rest for MIDI bytes. */
1f94205d TS	68	label = port->buf;
1f94205d TS	69	msg = port->buf + 1;
123990e9 TS	70
123990e9 TS	71	consume = snd_rawmidi_transmit_peek(substream, msg, 3);
b7ab614f	72	if (consume == 0)
3beab0f8 TS	73	return 0;
	74
	75	/* On exclusive message. */
1f94205d	76	if (port->on_sysex) {
3beab0f8	77	/* Seek the end of exclusives. */
123990e9 TS	78	for (i = 0; i < consume; ++i) {
123990e9 TS	79	if (msg[i] == 0xf7) {
1f94205d	80	port->on_sysex = false;
3beab0f8 TS	81	break;
	82	}
	83	}
	84
	85	/* At the end of exclusive message, use label 0x07. */
1f94205d	86	if (!port->on_sysex) {
123990e9	87	consume = i + 1;
1f94205d	88	*label = (substream->number << 4) \| 0x07;
3beab0f8	89	/* During exclusive message, use label 0x04. */
b7ab614f	90	} else if (consume == 3) {
1f94205d	91	*label = (substream->number << 4) \| 0x04;
3beab0f8 TS	92	/* We need to fill whole 3 bytes. Go to next change. */
3beab0f8 TS	93	} else {
f937b43d	94	return 0;
3beab0f8	95	}
f937b43d TS	96
f937b43d TS	97	len = consume;
3beab0f8 TS	98	} else {
3beab0f8 TS	99	/* The beginning of exclusives. */
123990e9	100	if (msg[0] == 0xf0) {
3beab0f8	101	/* Transfer it in next chance in another condition. */
1f94205d	102	port->on_sysex = true;
3beab0f8 TS	103	return 0;
	104	} else {
	105	/* On running-status. */
123990e9	106	if ((msg[0] & 0x80) != 0x80)
1f94205d	107	status = port->running_status;
3beab0f8	108	else
123990e9	109	status = msg[0];
3beab0f8 TS	110
3beab0f8 TS	111	/* Calculate consume bytes. */
b7ab614f TS	112	len = calculate_message_bytes(status);
b7ab614f TS	113	if (len <= 0)
3beab0f8 TS	114	return 0;
	115
	116	/* On running-status. */
123990e9	117	if ((msg[0] & 0x80) != 0x80) {
f937b43d TS	118	/* Enough MIDI bytes were not retrieved. */
	119	if (consume < len - 1)
	120	return 0;
	121	consume = len - 1;
	122
123990e9 TS	123	msg[2] = msg[1];
123990e9 TS	124	msg[1] = msg[0];
1f94205d	125	msg[0] = port->running_status;
3beab0f8	126	} else {
f937b43d TS	127	/* Enough MIDI bytes were not retrieved. */
	128	if (consume < len)
	129	return 0;
	130	consume = len;
	131
1f94205d	132	port->running_status = msg[0];
3beab0f8	133	}
3beab0f8 TS	134	}
3beab0f8 TS	135
1f94205d	136	*label = (substream->number << 4) \| (msg[0] >> 4);
3beab0f8 TS	137	}
3beab0f8 TS	138
f937b43d TS	139	if (len > 0 && len < 3)
	140	memset(msg + len, 0, 3 - len);
	141
b7ab614f	142	return consume;
3beab0f8 TS	143	}
3beab0f8 TS	144
531f4718 TS	145	static void async_midi_port_callback(struct fw_card *card, int rcode,
	146	void *data, size_t length,
	147	void *callback_data)
	148	{
	149	struct snd_fw_async_midi_port *port = callback_data;
6aa7de05	150	struct snd_rawmidi_substream *substream = READ_ONCE(port->substream);
531f4718 TS	151
	152	/* This port is closed. */
	153	if (substream == NULL)
	154	return;
	155
	156	if (rcode == RCODE_COMPLETE)
	157	snd_rawmidi_transmit_ack(substream, port->consume_bytes);
	158	else if (!rcode_is_permanent_error(rcode))
	159	/* To start next transaction immediately for recovery. */
	160	port->next_ktime = 0;
	161	else
	162	/* Don't continue processing. */
	163	port->error = true;
	164
	165	port->idling = true;
	166
	167	if (!snd_rawmidi_transmit_empty(substream))
	168	schedule_work(&port->work);
	169	}
	170
	171	static void midi_port_work(struct work_struct *work)
	172	{
	173	struct snd_fw_async_midi_port *port =
	174	container_of(work, struct snd_fw_async_midi_port, work);
6aa7de05	175	struct snd_rawmidi_substream *substream = READ_ONCE(port->substream);
531f4718	176	int generation;
531f4718 TS	177
	178	/* Under transacting or error state. */
	179	if (!port->idling \|\| port->error)
	180	return;
	181
	182	/* Nothing to do. */
	183	if (substream == NULL \|\| snd_rawmidi_transmit_empty(substream))
	184	return;
	185
	186	/* Do it in next chance. */
	187	if (ktime_after(port->next_ktime, ktime_get())) {
	188	schedule_work(&port->work);
	189	return;
	190	}
	191
	192	/*
	193	* Fill the buffer. The callee must use snd_rawmidi_transmit_peek().
	194	* Later, snd_rawmidi_transmit_ack() is called.
	195	*/
38d58261	196	memset(port->buf, 0, 4);
1f94205d	197	port->consume_bytes = fill_message(port, substream);
531f4718 TS	198	if (port->consume_bytes <= 0) {
	199	/* Do it in next chance, immediately. */
	200	if (port->consume_bytes == 0) {
	201	port->next_ktime = 0;
	202	schedule_work(&port->work);
	203	} else {
	204	/* Fatal error. */
	205	port->error = true;
	206	}
	207	return;
	208	}
	209
531f4718 TS	210	/* Set interval to next transaction. */
	211	port->next_ktime = ktime_add_ns(ktime_get(),
	212	port->consume_bytes * 8 * NSEC_PER_SEC / 31250);
	213
	214	/* Start this transaction. */
	215	port->idling = false;
	216
	217	/*
	218	* In Linux FireWire core, when generation is updated with memory
	219	* barrier, node id has already been updated. In this module, After
	220	* this smp_rmb(), load/store instructions to memory are completed.
	221	* Thus, both of generation and node id are available with recent
	222	* values. This is a light-serialization solution to handle bus reset
	223	* events on IEEE 1394 bus.
	224	*/
	225	generation = port->parent->generation;
	226	smp_rmb();
	227
38d58261 TS	228	fw_send_request(port->parent->card, &port->transaction,
38d58261 TS	229	TCODE_WRITE_QUADLET_REQUEST,
531f4718	230	port->parent->node_id, generation,
27badc4c TS	231	port->parent->max_speed,
27badc4c TS	232	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_RX_QUAD,
38d58261	233	port->buf, 4, async_midi_port_callback,
531f4718 TS	234	port);
	235	}
	236
3e7dc65c	237	void snd_fw_async_midi_port_init(struct snd_fw_async_midi_port *port)
531f4718	238	{
531f4718	239	port->idling = true;
531f4718	240	port->error = false;
1f94205d TS	241	port->running_status = 0;
1f94205d TS	242	port->on_sysex = false;
531f4718 TS	243	}
531f4718 TS	244
107cc012 TS	245	static void handle_midi_tx(struct fw_card card, struct fw_request request,
	246	int tcode, int destination, int source,
	247	int generation, unsigned long long offset,
	248	void data, size_t length, void callback_data)
	249	{
	250	struct snd_tscm *tscm = callback_data;
	251	u32 buf = (u32 )data;
	252	unsigned int messages;
	253	unsigned int i;
	254	unsigned int port;
	255	struct snd_rawmidi_substream *substream;
	256	u8 *b;
	257	int bytes;
	258
	259	if (offset != tscm->async_handler.offset)
	260	goto end;
	261
	262	messages = length / 8;
	263	for (i = 0; i < messages; i++) {
	264	b = (u8 )(buf + i 2);
	265
	266	port = b[0] >> 4;
	267	/* TODO: support virtual MIDI ports. */
72409705	268	if (port >= tscm->spec->midi_capture_ports)
107cc012 TS	269	goto end;
	270
	271	/* Assume the message length. */
	272	bytes = calculate_message_bytes(b[1]);
	273	/* On MIDI data or exclusives. */
	274	if (bytes <= 0) {
	275	/* Seek the end of exclusives. */
	276	for (bytes = 1; bytes < 4; bytes++) {
	277	if (b[bytes] == 0xf7)
	278	break;
	279	}
	280	if (bytes == 4)
	281	bytes = 3;
	282	}
	283
6aa7de05	284	substream = READ_ONCE(tscm->tx_midi_substreams[port]);
107cc012 TS	285	if (substream != NULL)
	286	snd_rawmidi_receive(substream, b + 1, bytes);
	287	}
	288	end:
	289	fw_send_response(card, request, RCODE_COMPLETE);
	290	}
	291
	292	int snd_tscm_transaction_register(struct snd_tscm *tscm)
	293	{
	294	static const struct fw_address_region resp_register_region = {
	295	.start = 0xffffe0000000ull,
	296	.end = 0xffffe000ffffull,
	297	};
3beab0f8	298	unsigned int i;
107cc012 TS	299	int err;
	300
	301	/*
	302	* Usually, two quadlets are transferred by one transaction. The first
	303	* quadlet has MIDI messages, the rest includes timestamp.
	304	* Sometimes, 8 set of the data is transferred by a block transaction.
	305	*/
	306	tscm->async_handler.length = 8 * 8;
	307	tscm->async_handler.address_callback = handle_midi_tx;
	308	tscm->async_handler.callback_data = tscm;
	309
	310	err = fw_core_add_address_handler(&tscm->async_handler,
	311	&resp_register_region);
	312	if (err < 0)
	313	return err;
	314
	315	err = snd_tscm_transaction_reregister(tscm);
	316	if (err < 0)
3beab0f8 TS	317	goto error;
	318
	319	for (i = 0; i < TSCM_MIDI_OUT_PORT_MAX; i++) {
3e7dc65c TS	320	tscm->out_ports[i].parent = fw_parent_device(tscm->unit);
	321	tscm->out_ports[i].next_ktime = 0;
	322	INIT_WORK(&tscm->out_ports[i].work, midi_port_work);
3beab0f8	323	}
107cc012	324
3beab0f8 TS	325	return err;
	326	error:
	327	fw_core_remove_address_handler(&tscm->async_handler);
5d2560a4	328	tscm->async_handler.callback_data = NULL;
107cc012 TS	329	return err;
	330	}
	331
	332	/* At bus reset, these registers are cleared. */
	333	int snd_tscm_transaction_reregister(struct snd_tscm *tscm)
	334	{
	335	struct fw_device *device = fw_parent_device(tscm->unit);
	336	__be32 reg;
	337	int err;
	338
	339	/* Register messaging address. Block transaction is not allowed. */
	340	reg = cpu_to_be32((device->card->node_id << 16) \|
	341	(tscm->async_handler.offset >> 32));
	342	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	343	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
	344	&reg, sizeof(reg), 0);
	345	if (err < 0)
	346	return err;
	347
	348	reg = cpu_to_be32(tscm->async_handler.offset);
	349	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	350	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
	351	&reg, sizeof(reg), 0);
	352	if (err < 0)
	353	return err;
	354
	355	/* Turn on messaging. */
	356	reg = cpu_to_be32(0x00000001);
69ec98d7	357	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
107cc012 TS	358	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
107cc012 TS	359	&reg, sizeof(reg), 0);
e65e2cb9 TS	360	if (err < 0)
	361	return err;
	362
	363	/* Turn on FireWire LED. */
	364	reg = cpu_to_be32(0x0001008e);
	365	return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	366	TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
	367	&reg, sizeof(reg), 0);
107cc012 TS	368	}
	369
	370	void snd_tscm_transaction_unregister(struct snd_tscm *tscm)
	371	{
	372	__be32 reg;
	373
5d2560a4 TS	374	if (tscm->async_handler.callback_data == NULL)
	375	return;
	376
e65e2cb9 TS	377	/* Turn off FireWire LED. */
	378	reg = cpu_to_be32(0x0000008e);
	379	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	380	TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
	381	&reg, sizeof(reg), 0);
	382
107cc012 TS	383	/* Turn off messaging. */
	384	reg = cpu_to_be32(0x00000000);
	385	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	386	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
	387	&reg, sizeof(reg), 0);
	388
	389	/* Unregister the address. */
	390	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	391	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
	392	&reg, sizeof(reg), 0);
	393	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	394	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
	395	&reg, sizeof(reg), 0);
	396
	397	fw_core_remove_address_handler(&tscm->async_handler);
5d2560a4	398	tscm->async_handler.callback_data = NULL;
107cc012	399	}