1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // motu-register-dsp-message-parser.c - a part of driver for MOTU FireWire series
4 //
5 // Copyright (c) 2021 Takashi Sakamoto <o-takashi@sakamocchi.jp>
6 
7 // Below models allow software to configure their DSP functions by asynchronous transaction
8 // to access their internal registers.
9 // * 828 mk2
10 // * 896hd
11 // * Traveler
12 // * 8 pre
13 // * Ultralite
14 // * 4 pre
15 // * Audio Express
16 //
17 // Additionally, isochronous packets from the above models include messages to notify state of
18 // DSP. The messages are two set of 3 byte data in 2nd and 3rd quadlet of data block. When user
19 // operates hardware components such as dial and switch, corresponding messages are transferred.
20 // The messages include Hardware metering and MIDI messages as well.
21 
22 #include "motu.h"
23 
24 #define MSG_FLAG_POS                    4
25 #define MSG_FLAG_TYPE_MASK              0xf8
26 #define MSG_FLAG_MIDI_MASK              0x01
27 #define MSG_FLAG_MODEL_SPECIFIC_MASK    0x06
28 #define   MSG_FLAG_8PRE                 0x00
29 #define   MSG_FLAG_ULTRALITE            0x04
30 #define   MSG_FLAG_TRAVELER             0x04
31 #define   MSG_FLAG_828MK2               0x04
32 #define   MSG_FLAG_896HD                0x04
33 #define   MSG_FLAG_4PRE                 0x05 // MIDI mask is in 8th byte.
34 #define   MSG_FLAG_AUDIOEXPRESS         0x05 // MIDI mask is in 8th byte.
35 #define MSG_FLAG_TYPE_SHIFT             3
36 #define MSG_VALUE_POS                   5
37 #define MSG_MIDI_BYTE_POS		6
38 #define MSG_METER_IDX_POS               7
39 
40 // In 4 pre and Audio express, meter index is in 6th byte. MIDI flag is in 8th byte and MIDI byte
41 // is in 7th byte.
42 #define MSG_METER_IDX_POS_4PRE_AE	6
43 #define MSG_MIDI_BYTE_POS_4PRE_AE	7
44 #define MSG_FLAG_MIDI_POS_4PRE_AE	8
45 
46 enum register_dsp_msg_type {
47 	// Used for messages with no information.
48 	INVALID = 0x00,
49 	MIXER_SELECT = 0x01,
50 	MIXER_SRC_GAIN = 0x02,
51 	MIXER_SRC_PAN = 0x03,
52 	MIXER_SRC_FLAG = 0x04,
53 	MIXER_OUTPUT_PAIRED_VOLUME = 0x05,
54 	MIXER_OUTPUT_PAIRED_FLAG = 0x06,
55 	MAIN_OUTPUT_PAIRED_VOLUME = 0x07,
56 	HP_OUTPUT_PAIRED_VOLUME = 0x08,
57 	HP_OUTPUT_PAIRED_ASSIGNMENT = 0x09,
58 	// Transferred by all models but the purpose is still unknown.
59 	UNKNOWN_0 = 0x0a,
60 	// Specific to 828mk2, 896hd, Traveler.
61 	UNKNOWN_2 = 0x0c,
62 	// Specific to 828mk2, Traveler, and 896hd (not functional).
63 	LINE_INPUT_BOOST = 0x0d,
64 	// Specific to 828mk2, Traveler, and 896hd (not functional).
65 	LINE_INPUT_NOMINAL_LEVEL = 0x0e,
66 	// Specific to Ultralite, 4 pre, Audio express, and 8 pre (not functional).
67 	INPUT_GAIN_AND_INVERT = 0x15,
68 	// Specific to 4 pre, and Audio express.
69 	INPUT_FLAG = 0x16,
70 	// Specific to 4 pre, and Audio express.
71 	MIXER_SRC_PAIRED_BALANCE = 0x17,
72 	// Specific to 4 pre, and Audio express.
73 	MIXER_SRC_PAIRED_WIDTH = 0x18,
74 	// Transferred by all models. This type of message interposes the series of the other
75 	// messages. The message delivers signal level up to 96.0 kHz. In 828mk2, 896hd, and
76 	// Traveler, one of physical outputs is selected for the message. The selection is done
77 	// by LSB one byte in asynchronous write quadlet transaction to 0x'ffff'f000'0b2c.
78 	METER = 0x1f,
79 };
80 
81 #define EVENT_QUEUE_SIZE	16
82 
83 struct msg_parser {
84 	spinlock_t lock;
85 	struct snd_firewire_motu_register_dsp_meter meter;
86 	bool meter_pos_quirk;
87 
88 	struct snd_firewire_motu_register_dsp_parameter param;
89 	u8 prev_mixer_src_type;
90 	u8 mixer_ch;
91 	u8 mixer_src_ch;
92 
93 	u8 input_ch;
94 	u8 prev_msg_type;
95 
96 	u32 event_queue[EVENT_QUEUE_SIZE];
97 	unsigned int push_pos;
98 	unsigned int pull_pos;
99 };
100 
snd_motu_register_dsp_message_parser_new(struct snd_motu * motu)101 int snd_motu_register_dsp_message_parser_new(struct snd_motu *motu)
102 {
103 	struct msg_parser *parser;
104 	parser = devm_kzalloc(&motu->card->card_dev, sizeof(*parser), GFP_KERNEL);
105 	if (!parser)
106 		return -ENOMEM;
107 	spin_lock_init(&parser->lock);
108 	if (motu->spec == &snd_motu_spec_4pre || motu->spec == &snd_motu_spec_audio_express)
109 		parser->meter_pos_quirk = true;
110 	motu->message_parser = parser;
111 	return 0;
112 }
113 
snd_motu_register_dsp_message_parser_init(struct snd_motu * motu)114 int snd_motu_register_dsp_message_parser_init(struct snd_motu *motu)
115 {
116 	struct msg_parser *parser = motu->message_parser;
117 
118 	parser->prev_mixer_src_type = INVALID;
119 	parser->mixer_ch = 0xff;
120 	parser->mixer_src_ch = 0xff;
121 	parser->prev_msg_type = INVALID;
122 
123 	return 0;
124 }
125 
126 // Rough implementaion of queue without overrun check.
queue_event(struct snd_motu * motu,u8 msg_type,u8 identifier0,u8 identifier1,u8 val)127 static void queue_event(struct snd_motu *motu, u8 msg_type, u8 identifier0, u8 identifier1, u8 val)
128 {
129 	struct msg_parser *parser = motu->message_parser;
130 	unsigned int pos = parser->push_pos;
131 	u32 entry;
132 
133 	if (!motu->hwdep || motu->hwdep->used == 0)
134 		return;
135 
136 	entry = (msg_type << 24) | (identifier0 << 16) | (identifier1 << 8) | val;
137 	parser->event_queue[pos] = entry;
138 
139 	++pos;
140 	if (pos >= EVENT_QUEUE_SIZE)
141 		pos = 0;
142 	parser->push_pos = pos;
143 }
144 
snd_motu_register_dsp_message_parser_parse(struct snd_motu * motu,const struct pkt_desc * descs,unsigned int desc_count,unsigned int data_block_quadlets)145 void snd_motu_register_dsp_message_parser_parse(struct snd_motu *motu, const struct pkt_desc *descs,
146 					unsigned int desc_count, unsigned int data_block_quadlets)
147 {
148 	struct msg_parser *parser = motu->message_parser;
149 	bool meter_pos_quirk = parser->meter_pos_quirk;
150 	unsigned int pos = parser->push_pos;
151 	unsigned long flags;
152 	int i;
153 
154 	spin_lock_irqsave(&parser->lock, flags);
155 
156 	for (i = 0; i < desc_count; ++i) {
157 		const struct pkt_desc *desc = descs + i;
158 		__be32 *buffer = desc->ctx_payload;
159 		unsigned int data_blocks = desc->data_blocks;
160 		int j;
161 
162 		for (j = 0; j < data_blocks; ++j) {
163 			u8 *b = (u8 *)buffer;
164 			u8 msg_type = (b[MSG_FLAG_POS] & MSG_FLAG_TYPE_MASK) >> MSG_FLAG_TYPE_SHIFT;
165 			u8 val = b[MSG_VALUE_POS];
166 
167 			buffer += data_block_quadlets;
168 
169 			switch (msg_type) {
170 			case MIXER_SELECT:
171 			{
172 				u8 mixer_ch = val / 0x20;
173 				if (mixer_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT) {
174 					parser->mixer_src_ch = 0;
175 					parser->mixer_ch = mixer_ch;
176 				}
177 				break;
178 			}
179 			case MIXER_SRC_GAIN:
180 			case MIXER_SRC_PAN:
181 			case MIXER_SRC_FLAG:
182 			case MIXER_SRC_PAIRED_BALANCE:
183 			case MIXER_SRC_PAIRED_WIDTH:
184 			{
185 				struct snd_firewire_motu_register_dsp_parameter *param = &parser->param;
186 				u8 mixer_ch = parser->mixer_ch;
187 				u8 mixer_src_ch = parser->mixer_src_ch;
188 
189 				if (msg_type != parser->prev_mixer_src_type)
190 					mixer_src_ch = 0;
191 				else
192 					++mixer_src_ch;
193 				parser->prev_mixer_src_type = msg_type;
194 
195 				if (mixer_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT &&
196 				    mixer_src_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT) {
197 					u8 mixer_ch = parser->mixer_ch;
198 
199 					switch (msg_type) {
200 					case MIXER_SRC_GAIN:
201 						if (param->mixer.source[mixer_ch].gain[mixer_src_ch] != val) {
202 							queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
203 							param->mixer.source[mixer_ch].gain[mixer_src_ch] = val;
204 						}
205 						break;
206 					case MIXER_SRC_PAN:
207 						if (param->mixer.source[mixer_ch].pan[mixer_src_ch] != val) {
208 							queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
209 							param->mixer.source[mixer_ch].pan[mixer_src_ch] = val;
210 						}
211 						break;
212 					case MIXER_SRC_FLAG:
213 						if (param->mixer.source[mixer_ch].flag[mixer_src_ch] != val) {
214 							queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
215 							param->mixer.source[mixer_ch].flag[mixer_src_ch] = val;
216 						}
217 						break;
218 					case MIXER_SRC_PAIRED_BALANCE:
219 						if (param->mixer.source[mixer_ch].paired_balance[mixer_src_ch] != val) {
220 							queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
221 							param->mixer.source[mixer_ch].paired_balance[mixer_src_ch] = val;
222 						}
223 						break;
224 					case MIXER_SRC_PAIRED_WIDTH:
225 						if (param->mixer.source[mixer_ch].paired_width[mixer_src_ch] != val) {
226 							queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
227 							param->mixer.source[mixer_ch].paired_width[mixer_src_ch] = val;
228 						}
229 						break;
230 					default:
231 						break;
232 					}
233 
234 					parser->mixer_src_ch = mixer_src_ch;
235 				}
236 				break;
237 			}
238 			case MIXER_OUTPUT_PAIRED_VOLUME:
239 			case MIXER_OUTPUT_PAIRED_FLAG:
240 			{
241 				struct snd_firewire_motu_register_dsp_parameter *param = &parser->param;
242 				u8 mixer_ch = parser->mixer_ch;
243 
244 				if (mixer_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT) {
245 					switch (msg_type) {
246 					case MIXER_OUTPUT_PAIRED_VOLUME:
247 						if (param->mixer.output.paired_volume[mixer_ch] != val) {
248 							queue_event(motu, msg_type, mixer_ch, 0, val);
249 							param->mixer.output.paired_volume[mixer_ch] = val;
250 						}
251 						break;
252 					case MIXER_OUTPUT_PAIRED_FLAG:
253 						if (param->mixer.output.paired_flag[mixer_ch] != val) {
254 							queue_event(motu, msg_type, mixer_ch, 0, val);
255 							param->mixer.output.paired_flag[mixer_ch] = val;
256 						}
257 						break;
258 					default:
259 						break;
260 					}
261 				}
262 				break;
263 			}
264 			case MAIN_OUTPUT_PAIRED_VOLUME:
265 				if (parser->param.output.main_paired_volume != val) {
266 					queue_event(motu, msg_type, 0, 0, val);
267 					parser->param.output.main_paired_volume = val;
268 				}
269 				break;
270 			case HP_OUTPUT_PAIRED_VOLUME:
271 				if (parser->param.output.hp_paired_volume != val) {
272 					queue_event(motu, msg_type, 0, 0, val);
273 					parser->param.output.hp_paired_volume = val;
274 				}
275 				break;
276 			case HP_OUTPUT_PAIRED_ASSIGNMENT:
277 				if (parser->param.output.hp_paired_assignment != val) {
278 					queue_event(motu, msg_type, 0, 0, val);
279 					parser->param.output.hp_paired_assignment = val;
280 				}
281 				break;
282 			case LINE_INPUT_BOOST:
283 				if (parser->param.line_input.boost_flag != val) {
284 					queue_event(motu, msg_type, 0, 0, val);
285 					parser->param.line_input.boost_flag = val;
286 				}
287 				break;
288 			case LINE_INPUT_NOMINAL_LEVEL:
289 				if (parser->param.line_input.nominal_level_flag != val) {
290 					queue_event(motu, msg_type, 0, 0, val);
291 					parser->param.line_input.nominal_level_flag = val;
292 				}
293 				break;
294 			case INPUT_GAIN_AND_INVERT:
295 			case INPUT_FLAG:
296 			{
297 				struct snd_firewire_motu_register_dsp_parameter *param = &parser->param;
298 				u8 input_ch = parser->input_ch;
299 
300 				if (parser->prev_msg_type != msg_type)
301 					input_ch = 0;
302 				else
303 					++input_ch;
304 
305 				if (input_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT) {
306 					switch (msg_type) {
307 					case INPUT_GAIN_AND_INVERT:
308 						if (param->input.gain_and_invert[input_ch] != val) {
309 							queue_event(motu, msg_type, input_ch, 0, val);
310 							param->input.gain_and_invert[input_ch] = val;
311 						}
312 						break;
313 					case INPUT_FLAG:
314 						if (param->input.flag[input_ch] != val) {
315 							queue_event(motu, msg_type, input_ch, 0, val);
316 							param->input.flag[input_ch] = val;
317 						}
318 						break;
319 					default:
320 						break;
321 					}
322 					parser->input_ch = input_ch;
323 				}
324 				break;
325 			}
326 			case UNKNOWN_0:
327 			case UNKNOWN_2:
328 				break;
329 			case METER:
330 			{
331 				u8 pos;
332 
333 				if (!meter_pos_quirk)
334 					pos = b[MSG_METER_IDX_POS];
335 				else
336 					pos = b[MSG_METER_IDX_POS_4PRE_AE];
337 
338 				if (pos < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT) {
339 					parser->meter.data[pos] = val;
340 				} else if (pos >= 0x80) {
341 					pos -= (0x80 - SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT);
342 
343 					if (pos < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT)
344 						parser->meter.data[pos] = val;
345 				}
346 
347 				// The message for meter is interruptible to the series of other
348 				// types of messages. Don't cache it.
349 				fallthrough;
350 			}
351 			case INVALID:
352 			default:
353 				// Don't cache it.
354 				continue;
355 			}
356 
357 			parser->prev_msg_type = msg_type;
358 		}
359 	}
360 
361 	if (pos != parser->push_pos)
362 		wake_up(&motu->hwdep_wait);
363 
364 	spin_unlock_irqrestore(&parser->lock, flags);
365 }
366 
snd_motu_register_dsp_message_parser_copy_meter(struct snd_motu * motu,struct snd_firewire_motu_register_dsp_meter * meter)367 void snd_motu_register_dsp_message_parser_copy_meter(struct snd_motu *motu,
368 						struct snd_firewire_motu_register_dsp_meter *meter)
369 {
370 	struct msg_parser *parser = motu->message_parser;
371 	unsigned long flags;
372 
373 	spin_lock_irqsave(&parser->lock, flags);
374 	memcpy(meter, &parser->meter, sizeof(*meter));
375 	spin_unlock_irqrestore(&parser->lock, flags);
376 }
377 
snd_motu_register_dsp_message_parser_copy_parameter(struct snd_motu * motu,struct snd_firewire_motu_register_dsp_parameter * param)378 void snd_motu_register_dsp_message_parser_copy_parameter(struct snd_motu *motu,
379 					struct snd_firewire_motu_register_dsp_parameter *param)
380 {
381 	struct msg_parser *parser = motu->message_parser;
382 	unsigned long flags;
383 
384 	spin_lock_irqsave(&parser->lock, flags);
385 	memcpy(param, &parser->param, sizeof(*param));
386 	spin_unlock_irqrestore(&parser->lock, flags);
387 }
388 
snd_motu_register_dsp_message_parser_count_event(struct snd_motu * motu)389 unsigned int snd_motu_register_dsp_message_parser_count_event(struct snd_motu *motu)
390 {
391 	struct msg_parser *parser = motu->message_parser;
392 
393 	if (parser->pull_pos > parser->push_pos)
394 		return EVENT_QUEUE_SIZE - parser->pull_pos + parser->push_pos;
395 	else
396 		return parser->push_pos - parser->pull_pos;
397 }
398 
snd_motu_register_dsp_message_parser_copy_event(struct snd_motu * motu,u32 * event)399 bool snd_motu_register_dsp_message_parser_copy_event(struct snd_motu *motu, u32 *event)
400 {
401 	struct msg_parser *parser = motu->message_parser;
402 	unsigned int pos = parser->pull_pos;
403 	unsigned long flags;
404 
405 	if (pos == parser->push_pos)
406 		return false;
407 
408 	spin_lock_irqsave(&parser->lock, flags);
409 
410 	*event = parser->event_queue[pos];
411 
412 	++pos;
413 	if (pos >= EVENT_QUEUE_SIZE)
414 		pos = 0;
415 	parser->pull_pos = pos;
416 
417 	spin_unlock_irqrestore(&parser->lock, flags);
418 
419 	return true;
420 }
421