[mirror_ubuntu-bionic-kernel.git] / sound / firewire / tascam / tascam-transaction.c

/*
 * tascam-transaction.c - a part of driver for TASCAM FireWire series
 *
 * Copyright (c) 2015 Takashi Sakamoto
 *
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#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_rawmidi_substream *substream, u8 *buf)
{
	struct snd_tscm *tscm = substream->rmidi->private_data;
	unsigned int port = substream->number;
	int i, len, consume;
	u8 *label, *msg;
	u8 status;

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

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

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

		/* At the end of exclusive message, use label 0x07. */
		if (!tscm->on_sysex[port]) {
			consume = i + 1;
			*label = (port << 4) | 0x07;
		/* During exclusive message, use label 0x04. */
		} else if (consume == 3) {
			*label = (port << 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. */
			tscm->on_sysex[port] = true;
			return 0;
		} else {
			/* On running-status. */
			if ((msg[0] & 0x80) != 0x80)
				status = tscm->running_status[port];
			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] = tscm->running_status[port];
			} else {
				/* Enough MIDI bytes were not retrieved. */
				if (consume < len)
					return 0;
				consume = len;

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

		*label = (port << 4) | (msg[0] >> 4);
	}

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

	return consume;
}

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 = ACCESS_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++) {
		err = snd_fw_async_midi_port_init(
				&tscm->out_ports[i], tscm->unit,
				TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_RX_QUAD,
				4, fill_message);
		if (err < 0)
			goto error;
	}

	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;
	unsigned int i;

	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;

	for (i = 0; i < TSCM_MIDI_OUT_PORT_MAX; i++)
		snd_fw_async_midi_port_destroy(&tscm->out_ports[i]);
}
Commit	Line	Data
107cc012 TS	1	/*
	2	* tascam-transaction.c - a part of driver for TASCAM FireWire series
	3	*
	4	* Copyright (c) 2015 Takashi Sakamoto
	5	*
	6	* Licensed under the terms of the GNU General Public License, version 2.
	7	*/
	8
	9	#include "tascam.h"
	10
	11	/*
	12	* When return minus value, given argument is not MIDI status.
	13	* When return 0, given argument is a beginning of system exclusive.
	14	* When return the others, given argument is MIDI data.
	15	*/
	16	static inline int calculate_message_bytes(u8 status)
	17	{
	18	switch (status) {
	19	case 0xf6: /* Tune request. */
	20	case 0xf8: /* Timing clock. */
	21	case 0xfa: /* Start. */
	22	case 0xfb: /* Continue. */
	23	case 0xfc: /* Stop. */
	24	case 0xfe: /* Active sensing. */
	25	case 0xff: /* System reset. */
	26	return 1;
	27	case 0xf1: /* MIDI time code quarter frame. */
	28	case 0xf3: /* Song select. */
	29	return 2;
	30	case 0xf2: /* Song position pointer. */
	31	return 3;
	32	case 0xf0: /* Exclusive. */
	33	return 0;
	34	case 0xf7: /* End of exclusive. */
	35	break;
	36	case 0xf4: /* Undefined. */
	37	case 0xf5: /* Undefined. */
	38	case 0xf9: /* Undefined. */
	39	case 0xfd: /* Undefined. */
	40	break;
	41	default:
	42	switch (status & 0xf0) {
	43	case 0x80: /* Note on. */
	44	case 0x90: /* Note off. */
	45	case 0xa0: /* Polyphonic key pressure. */
	46	case 0xb0: /* Control change and Mode change. */
	47	case 0xe0: /* Pitch bend change. */
	48	return 3;
	49	case 0xc0: /* Program change. */
	50	case 0xd0: /* Channel pressure. */
	51	return 2;
	52	default:
	53	break;
	54	}
	55	break;
	56	}
	57
	58	return -EINVAL;
	59	}
	60
3beab0f8 TS	61	static int fill_message(struct snd_rawmidi_substream substream, u8 buf)
	62	{
	63	struct snd_tscm *tscm = substream->rmidi->private_data;
	64	unsigned int port = substream->number;
516a3061	65	int i, len, consume;
123990e9	66	u8 label, msg;
3beab0f8	67	u8 status;
3beab0f8	68
123990e9 TS	69	/* The first byte is used for label, the rest for MIDI bytes. */
	70	label = buf;
	71	msg = buf + 1;
	72
	73	consume = snd_rawmidi_transmit_peek(substream, msg, 3);
b7ab614f	74	if (consume == 0)
3beab0f8 TS	75	return 0;
	76
	77	/* On exclusive message. */
	78	if (tscm->on_sysex[port]) {
	79	/* Seek the end of exclusives. */
123990e9 TS	80	for (i = 0; i < consume; ++i) {
123990e9 TS	81	if (msg[i] == 0xf7) {
3beab0f8 TS	82	tscm->on_sysex[port] = false;
	83	break;
	84	}
	85	}
	86
	87	/* At the end of exclusive message, use label 0x07. */
	88	if (!tscm->on_sysex[port]) {
123990e9 TS	89	consume = i + 1;
123990e9 TS	90	*label = (port << 4) \| 0x07;
3beab0f8	91	/* During exclusive message, use label 0x04. */
b7ab614f	92	} else if (consume == 3) {
123990e9	93	*label = (port << 4) \| 0x04;
3beab0f8 TS	94	/* We need to fill whole 3 bytes. Go to next change. */
3beab0f8 TS	95	} else {
f937b43d	96	return 0;
3beab0f8	97	}
f937b43d TS	98
f937b43d TS	99	len = consume;
3beab0f8 TS	100	} else {
3beab0f8 TS	101	/* The beginning of exclusives. */
123990e9	102	if (msg[0] == 0xf0) {
3beab0f8 TS	103	/* Transfer it in next chance in another condition. */
	104	tscm->on_sysex[port] = true;
	105	return 0;
	106	} else {
	107	/* On running-status. */
123990e9	108	if ((msg[0] & 0x80) != 0x80)
3beab0f8 TS	109	status = tscm->running_status[port];
3beab0f8 TS	110	else
123990e9	111	status = msg[0];
3beab0f8 TS	112
3beab0f8 TS	113	/* Calculate consume bytes. */
b7ab614f TS	114	len = calculate_message_bytes(status);
b7ab614f TS	115	if (len <= 0)
3beab0f8 TS	116	return 0;
	117
	118	/* On running-status. */
123990e9	119	if ((msg[0] & 0x80) != 0x80) {
f937b43d TS	120	/* Enough MIDI bytes were not retrieved. */
	121	if (consume < len - 1)
	122	return 0;
	123	consume = len - 1;
	124
123990e9 TS	125	msg[2] = msg[1];
	126	msg[1] = msg[0];
	127	msg[0] = tscm->running_status[port];
3beab0f8	128	} else {
f937b43d TS	129	/* Enough MIDI bytes were not retrieved. */
	130	if (consume < len)
	131	return 0;
	132	consume = len;
	133
123990e9	134	tscm->running_status[port] = msg[0];
3beab0f8	135	}
3beab0f8 TS	136	}
3beab0f8 TS	137
123990e9	138	*label = (port << 4) \| (msg[0] >> 4);
3beab0f8 TS	139	}
3beab0f8 TS	140
f937b43d TS	141	if (len > 0 && len < 3)
	142	memset(msg + len, 0, 3 - len);
	143
b7ab614f	144	return consume;
3beab0f8 TS	145	}
3beab0f8 TS	146
107cc012 TS	147	static void handle_midi_tx(struct fw_card card, struct fw_request request,
	148	int tcode, int destination, int source,
	149	int generation, unsigned long long offset,
	150	void data, size_t length, void callback_data)
	151	{
	152	struct snd_tscm *tscm = callback_data;
	153	u32 buf = (u32 )data;
	154	unsigned int messages;
	155	unsigned int i;
	156	unsigned int port;
	157	struct snd_rawmidi_substream *substream;
	158	u8 *b;
	159	int bytes;
	160
	161	if (offset != tscm->async_handler.offset)
	162	goto end;
	163
	164	messages = length / 8;
	165	for (i = 0; i < messages; i++) {
	166	b = (u8 )(buf + i 2);
	167
	168	port = b[0] >> 4;
	169	/* TODO: support virtual MIDI ports. */
72409705	170	if (port >= tscm->spec->midi_capture_ports)
107cc012 TS	171	goto end;
	172
	173	/* Assume the message length. */
	174	bytes = calculate_message_bytes(b[1]);
	175	/* On MIDI data or exclusives. */
	176	if (bytes <= 0) {
	177	/* Seek the end of exclusives. */
	178	for (bytes = 1; bytes < 4; bytes++) {
	179	if (b[bytes] == 0xf7)
	180	break;
	181	}
	182	if (bytes == 4)
	183	bytes = 3;
	184	}
	185
	186	substream = ACCESS_ONCE(tscm->tx_midi_substreams[port]);
	187	if (substream != NULL)
	188	snd_rawmidi_receive(substream, b + 1, bytes);
	189	}
	190	end:
	191	fw_send_response(card, request, RCODE_COMPLETE);
	192	}
	193
	194	int snd_tscm_transaction_register(struct snd_tscm *tscm)
	195	{
	196	static const struct fw_address_region resp_register_region = {
	197	.start = 0xffffe0000000ull,
	198	.end = 0xffffe000ffffull,
	199	};
3beab0f8	200	unsigned int i;
107cc012 TS	201	int err;
	202
	203	/*
	204	* Usually, two quadlets are transferred by one transaction. The first
	205	* quadlet has MIDI messages, the rest includes timestamp.
	206	* Sometimes, 8 set of the data is transferred by a block transaction.
	207	*/
	208	tscm->async_handler.length = 8 * 8;
	209	tscm->async_handler.address_callback = handle_midi_tx;
	210	tscm->async_handler.callback_data = tscm;
	211
	212	err = fw_core_add_address_handler(&tscm->async_handler,
	213	&resp_register_region);
	214	if (err < 0)
	215	return err;
	216
	217	err = snd_tscm_transaction_reregister(tscm);
	218	if (err < 0)
3beab0f8 TS	219	goto error;
	220
	221	for (i = 0; i < TSCM_MIDI_OUT_PORT_MAX; i++) {
	222	err = snd_fw_async_midi_port_init(
	223	&tscm->out_ports[i], tscm->unit,
	224	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_RX_QUAD,
	225	4, fill_message);
	226	if (err < 0)
	227	goto error;
	228	}
107cc012	229
3beab0f8 TS	230	return err;
	231	error:
	232	fw_core_remove_address_handler(&tscm->async_handler);
5d2560a4	233	tscm->async_handler.callback_data = NULL;
107cc012 TS	234	return err;
	235	}
	236
	237	/* At bus reset, these registers are cleared. */
	238	int snd_tscm_transaction_reregister(struct snd_tscm *tscm)
	239	{
	240	struct fw_device *device = fw_parent_device(tscm->unit);
	241	__be32 reg;
	242	int err;
	243
	244	/* Register messaging address. Block transaction is not allowed. */
	245	reg = cpu_to_be32((device->card->node_id << 16) \|
	246	(tscm->async_handler.offset >> 32));
	247	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	248	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
	249	&reg, sizeof(reg), 0);
	250	if (err < 0)
	251	return err;
	252
	253	reg = cpu_to_be32(tscm->async_handler.offset);
	254	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	255	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
	256	&reg, sizeof(reg), 0);
	257	if (err < 0)
	258	return err;
	259
	260	/* Turn on messaging. */
	261	reg = cpu_to_be32(0x00000001);
69ec98d7	262	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
107cc012 TS	263	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
107cc012 TS	264	&reg, sizeof(reg), 0);
e65e2cb9 TS	265	if (err < 0)
	266	return err;
	267
	268	/* Turn on FireWire LED. */
	269	reg = cpu_to_be32(0x0001008e);
	270	return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	271	TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
	272	&reg, sizeof(reg), 0);
107cc012 TS	273	}
	274
	275	void snd_tscm_transaction_unregister(struct snd_tscm *tscm)
	276	{
	277	__be32 reg;
3beab0f8	278	unsigned int i;
107cc012	279
5d2560a4 TS	280	if (tscm->async_handler.callback_data == NULL)
	281	return;
	282
e65e2cb9 TS	283	/* Turn off FireWire LED. */
	284	reg = cpu_to_be32(0x0000008e);
	285	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	286	TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
	287	&reg, sizeof(reg), 0);
	288
107cc012 TS	289	/* Turn off messaging. */
	290	reg = cpu_to_be32(0x00000000);
	291	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	292	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
	293	&reg, sizeof(reg), 0);
	294
	295	/* Unregister the address. */
	296	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	297	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
	298	&reg, sizeof(reg), 0);
	299	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
	300	TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
	301	&reg, sizeof(reg), 0);
	302
	303	fw_core_remove_address_handler(&tscm->async_handler);
5d2560a4 TS	304	tscm->async_handler.callback_data = NULL;
5d2560a4 TS	305
3beab0f8 TS	306	for (i = 0; i < TSCM_MIDI_OUT_PORT_MAX; i++)
3beab0f8 TS	307	snd_fw_async_midi_port_destroy(&tscm->out_ports[i]);
107cc012	308	}