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 | |
101 | int snd_motu_register_dsp_message_parser_new(struct snd_motu *motu) |
102 | { |
103 | struct msg_parser *parser; |
104 | parser = devm_kzalloc(dev: &motu->card->card_dev, size: 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 | |
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. |
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 | |
145 | void snd_motu_register_dsp_message_parser_parse(const struct amdtp_stream *s, |
146 | const struct pkt_desc *desc, unsigned int count) |
147 | { |
148 | struct snd_motu *motu = container_of(s, struct snd_motu, tx_stream); |
149 | unsigned int data_block_quadlets = s->data_block_quadlets; |
150 | struct msg_parser *parser = motu->message_parser; |
151 | bool meter_pos_quirk = parser->meter_pos_quirk; |
152 | unsigned int pos = parser->push_pos; |
153 | unsigned long flags; |
154 | int i; |
155 | |
156 | spin_lock_irqsave(&parser->lock, flags); |
157 | |
158 | for (i = 0; i < count; ++i) { |
159 | __be32 *buffer = desc->ctx_payload; |
160 | unsigned int data_blocks = desc->data_blocks; |
161 | int j; |
162 | |
163 | desc = amdtp_stream_next_packet_desc(s, desc); |
164 | |
165 | for (j = 0; j < data_blocks; ++j) { |
166 | u8 *b = (u8 *)buffer; |
167 | u8 msg_type = (b[MSG_FLAG_POS] & MSG_FLAG_TYPE_MASK) >> MSG_FLAG_TYPE_SHIFT; |
168 | u8 val = b[MSG_VALUE_POS]; |
169 | |
170 | buffer += data_block_quadlets; |
171 | |
172 | switch (msg_type) { |
173 | case MIXER_SELECT: |
174 | { |
175 | u8 mixer_ch = val / 0x20; |
176 | if (mixer_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT) { |
177 | parser->mixer_src_ch = 0; |
178 | parser->mixer_ch = mixer_ch; |
179 | } |
180 | break; |
181 | } |
182 | case MIXER_SRC_GAIN: |
183 | case MIXER_SRC_PAN: |
184 | case MIXER_SRC_FLAG: |
185 | case MIXER_SRC_PAIRED_BALANCE: |
186 | case MIXER_SRC_PAIRED_WIDTH: |
187 | { |
188 | struct snd_firewire_motu_register_dsp_parameter *param = &parser->param; |
189 | u8 mixer_ch = parser->mixer_ch; |
190 | u8 mixer_src_ch = parser->mixer_src_ch; |
191 | |
192 | if (msg_type != parser->prev_mixer_src_type) |
193 | mixer_src_ch = 0; |
194 | else |
195 | ++mixer_src_ch; |
196 | parser->prev_mixer_src_type = msg_type; |
197 | |
198 | if (mixer_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT && |
199 | mixer_src_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT) { |
200 | u8 mixer_ch = parser->mixer_ch; |
201 | |
202 | switch (msg_type) { |
203 | case MIXER_SRC_GAIN: |
204 | if (param->mixer.source[mixer_ch].gain[mixer_src_ch] != val) { |
205 | queue_event(motu, msg_type, identifier0: mixer_ch, identifier1: mixer_src_ch, val); |
206 | param->mixer.source[mixer_ch].gain[mixer_src_ch] = val; |
207 | } |
208 | break; |
209 | case MIXER_SRC_PAN: |
210 | if (param->mixer.source[mixer_ch].pan[mixer_src_ch] != val) { |
211 | queue_event(motu, msg_type, identifier0: mixer_ch, identifier1: mixer_src_ch, val); |
212 | param->mixer.source[mixer_ch].pan[mixer_src_ch] = val; |
213 | } |
214 | break; |
215 | case MIXER_SRC_FLAG: |
216 | if (param->mixer.source[mixer_ch].flag[mixer_src_ch] != val) { |
217 | queue_event(motu, msg_type, identifier0: mixer_ch, identifier1: mixer_src_ch, val); |
218 | param->mixer.source[mixer_ch].flag[mixer_src_ch] = val; |
219 | } |
220 | break; |
221 | case MIXER_SRC_PAIRED_BALANCE: |
222 | if (param->mixer.source[mixer_ch].paired_balance[mixer_src_ch] != val) { |
223 | queue_event(motu, msg_type, identifier0: mixer_ch, identifier1: mixer_src_ch, val); |
224 | param->mixer.source[mixer_ch].paired_balance[mixer_src_ch] = val; |
225 | } |
226 | break; |
227 | case MIXER_SRC_PAIRED_WIDTH: |
228 | if (param->mixer.source[mixer_ch].paired_width[mixer_src_ch] != val) { |
229 | queue_event(motu, msg_type, identifier0: mixer_ch, identifier1: mixer_src_ch, val); |
230 | param->mixer.source[mixer_ch].paired_width[mixer_src_ch] = val; |
231 | } |
232 | break; |
233 | default: |
234 | break; |
235 | } |
236 | |
237 | parser->mixer_src_ch = mixer_src_ch; |
238 | } |
239 | break; |
240 | } |
241 | case MIXER_OUTPUT_PAIRED_VOLUME: |
242 | case MIXER_OUTPUT_PAIRED_FLAG: |
243 | { |
244 | struct snd_firewire_motu_register_dsp_parameter *param = &parser->param; |
245 | u8 mixer_ch = parser->mixer_ch; |
246 | |
247 | if (mixer_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT) { |
248 | switch (msg_type) { |
249 | case MIXER_OUTPUT_PAIRED_VOLUME: |
250 | if (param->mixer.output.paired_volume[mixer_ch] != val) { |
251 | queue_event(motu, msg_type, identifier0: mixer_ch, identifier1: 0, val); |
252 | param->mixer.output.paired_volume[mixer_ch] = val; |
253 | } |
254 | break; |
255 | case MIXER_OUTPUT_PAIRED_FLAG: |
256 | if (param->mixer.output.paired_flag[mixer_ch] != val) { |
257 | queue_event(motu, msg_type, identifier0: mixer_ch, identifier1: 0, val); |
258 | param->mixer.output.paired_flag[mixer_ch] = val; |
259 | } |
260 | break; |
261 | default: |
262 | break; |
263 | } |
264 | } |
265 | break; |
266 | } |
267 | case MAIN_OUTPUT_PAIRED_VOLUME: |
268 | if (parser->param.output.main_paired_volume != val) { |
269 | queue_event(motu, msg_type, identifier0: 0, identifier1: 0, val); |
270 | parser->param.output.main_paired_volume = val; |
271 | } |
272 | break; |
273 | case HP_OUTPUT_PAIRED_VOLUME: |
274 | if (parser->param.output.hp_paired_volume != val) { |
275 | queue_event(motu, msg_type, identifier0: 0, identifier1: 0, val); |
276 | parser->param.output.hp_paired_volume = val; |
277 | } |
278 | break; |
279 | case HP_OUTPUT_PAIRED_ASSIGNMENT: |
280 | if (parser->param.output.hp_paired_assignment != val) { |
281 | queue_event(motu, msg_type, identifier0: 0, identifier1: 0, val); |
282 | parser->param.output.hp_paired_assignment = val; |
283 | } |
284 | break; |
285 | case LINE_INPUT_BOOST: |
286 | if (parser->param.line_input.boost_flag != val) { |
287 | queue_event(motu, msg_type, identifier0: 0, identifier1: 0, val); |
288 | parser->param.line_input.boost_flag = val; |
289 | } |
290 | break; |
291 | case LINE_INPUT_NOMINAL_LEVEL: |
292 | if (parser->param.line_input.nominal_level_flag != val) { |
293 | queue_event(motu, msg_type, identifier0: 0, identifier1: 0, val); |
294 | parser->param.line_input.nominal_level_flag = val; |
295 | } |
296 | break; |
297 | case INPUT_GAIN_AND_INVERT: |
298 | case INPUT_FLAG: |
299 | { |
300 | struct snd_firewire_motu_register_dsp_parameter *param = &parser->param; |
301 | u8 input_ch = parser->input_ch; |
302 | |
303 | if (parser->prev_msg_type != msg_type) |
304 | input_ch = 0; |
305 | else |
306 | ++input_ch; |
307 | |
308 | if (input_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT) { |
309 | switch (msg_type) { |
310 | case INPUT_GAIN_AND_INVERT: |
311 | if (param->input.gain_and_invert[input_ch] != val) { |
312 | queue_event(motu, msg_type, identifier0: input_ch, identifier1: 0, val); |
313 | param->input.gain_and_invert[input_ch] = val; |
314 | } |
315 | break; |
316 | case INPUT_FLAG: |
317 | if (param->input.flag[input_ch] != val) { |
318 | queue_event(motu, msg_type, identifier0: input_ch, identifier1: 0, val); |
319 | param->input.flag[input_ch] = val; |
320 | } |
321 | break; |
322 | default: |
323 | break; |
324 | } |
325 | parser->input_ch = input_ch; |
326 | } |
327 | break; |
328 | } |
329 | case UNKNOWN_0: |
330 | case UNKNOWN_2: |
331 | break; |
332 | case METER: |
333 | { |
334 | u8 pos; |
335 | |
336 | if (!meter_pos_quirk) |
337 | pos = b[MSG_METER_IDX_POS]; |
338 | else |
339 | pos = b[MSG_METER_IDX_POS_4PRE_AE]; |
340 | |
341 | if (pos < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT) { |
342 | parser->meter.data[pos] = val; |
343 | } else if (pos >= 0x80) { |
344 | pos -= (0x80 - SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT); |
345 | |
346 | if (pos < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT) |
347 | parser->meter.data[pos] = val; |
348 | } |
349 | |
350 | // The message for meter is interruptible to the series of other |
351 | // types of messages. Don't cache it. |
352 | fallthrough; |
353 | } |
354 | case INVALID: |
355 | default: |
356 | // Don't cache it. |
357 | continue; |
358 | } |
359 | |
360 | parser->prev_msg_type = msg_type; |
361 | } |
362 | } |
363 | |
364 | if (pos != parser->push_pos) |
365 | wake_up(&motu->hwdep_wait); |
366 | |
367 | spin_unlock_irqrestore(lock: &parser->lock, flags); |
368 | } |
369 | |
370 | void snd_motu_register_dsp_message_parser_copy_meter(struct snd_motu *motu, |
371 | struct snd_firewire_motu_register_dsp_meter *meter) |
372 | { |
373 | struct msg_parser *parser = motu->message_parser; |
374 | unsigned long flags; |
375 | |
376 | spin_lock_irqsave(&parser->lock, flags); |
377 | memcpy(meter, &parser->meter, sizeof(*meter)); |
378 | spin_unlock_irqrestore(lock: &parser->lock, flags); |
379 | } |
380 | |
381 | void snd_motu_register_dsp_message_parser_copy_parameter(struct snd_motu *motu, |
382 | struct snd_firewire_motu_register_dsp_parameter *param) |
383 | { |
384 | struct msg_parser *parser = motu->message_parser; |
385 | unsigned long flags; |
386 | |
387 | spin_lock_irqsave(&parser->lock, flags); |
388 | memcpy(param, &parser->param, sizeof(*param)); |
389 | spin_unlock_irqrestore(lock: &parser->lock, flags); |
390 | } |
391 | |
392 | unsigned int snd_motu_register_dsp_message_parser_count_event(struct snd_motu *motu) |
393 | { |
394 | struct msg_parser *parser = motu->message_parser; |
395 | |
396 | if (parser->pull_pos > parser->push_pos) |
397 | return EVENT_QUEUE_SIZE - parser->pull_pos + parser->push_pos; |
398 | else |
399 | return parser->push_pos - parser->pull_pos; |
400 | } |
401 | |
402 | bool snd_motu_register_dsp_message_parser_copy_event(struct snd_motu *motu, u32 *event) |
403 | { |
404 | struct msg_parser *parser = motu->message_parser; |
405 | unsigned int pos = parser->pull_pos; |
406 | unsigned long flags; |
407 | |
408 | if (pos == parser->push_pos) |
409 | return false; |
410 | |
411 | spin_lock_irqsave(&parser->lock, flags); |
412 | |
413 | *event = parser->event_queue[pos]; |
414 | |
415 | ++pos; |
416 | if (pos >= EVENT_QUEUE_SIZE) |
417 | pos = 0; |
418 | parser->pull_pos = pos; |
419 | |
420 | spin_unlock_irqrestore(lock: &parser->lock, flags); |
421 | |
422 | return true; |
423 | } |
424 | |