1 // SPDX-License-Identifier: GPL-2.0-only
3 // motu-register-dsp-message-parser.c - a part of driver for MOTU FireWire series
5 // Copyright (c) 2021 Takashi Sakamoto <o-takashi@sakamocchi.jp>
7 // Below models allow software to configure their DSP functions by asynchronous transaction
8 // to access their internal registers.
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.
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
40 // In 4 pre and Audio express, meter index is in 6th byte. MIDI flag is in 8th byte and MIDI 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
46 enum register_dsp_msg_type {
47 // Used for messages with no information.
50 MIXER_SRC_GAIN = 0x02,
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.
60 // Specific to 828mk2, 896hd, Traveler.
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.
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.
81 #define EVENT_QUEUE_SIZE 16
85 struct snd_firewire_motu_register_dsp_meter meter;
88 struct snd_firewire_motu_register_dsp_parameter param;
89 u8 prev_mixer_src_type;
96 u32 event_queue[EVENT_QUEUE_SIZE];
97 unsigned int push_pos;
98 unsigned int pull_pos;
101 int snd_motu_register_dsp_message_parser_new(struct snd_motu *motu)
103 struct msg_parser *parser;
104 parser = devm_kzalloc(&motu->card->card_dev, sizeof(*parser), GFP_KERNEL);
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;
114 int snd_motu_register_dsp_message_parser_init(struct snd_motu *motu)
116 struct msg_parser *parser = motu->message_parser;
118 parser->prev_mixer_src_type = INVALID;
119 parser->mixer_ch = 0xff;
120 parser->mixer_src_ch = 0xff;
121 parser->prev_msg_type = INVALID;
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)
129 struct msg_parser *parser = motu->message_parser;
130 unsigned int pos = parser->push_pos;
133 if (!motu->hwdep || motu->hwdep->used == 0)
136 entry = (msg_type << 24) | (identifier0 << 16) | (identifier1 << 8) | val;
137 parser->event_queue[pos] = entry;
140 if (pos >= EVENT_QUEUE_SIZE)
142 parser->push_pos = pos;
145 void snd_motu_register_dsp_message_parser_parse(const struct amdtp_stream *s,
146 const struct pkt_desc *desc, unsigned int count)
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;
156 spin_lock_irqsave(&parser->lock, flags);
158 for (i = 0; i < count; ++i) {
159 __be32 *buffer = desc->ctx_payload;
160 unsigned int data_blocks = desc->data_blocks;
163 desc = amdtp_stream_next_packet_desc(s, desc);
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];
170 buffer += data_block_quadlets;
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;
185 case MIXER_SRC_PAIRED_BALANCE:
186 case MIXER_SRC_PAIRED_WIDTH:
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;
192 if (msg_type != parser->prev_mixer_src_type)
196 parser->prev_mixer_src_type = msg_type;
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;
204 if (param->mixer.source[mixer_ch].gain[mixer_src_ch] != val) {
205 queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
206 param->mixer.source[mixer_ch].gain[mixer_src_ch] = val;
210 if (param->mixer.source[mixer_ch].pan[mixer_src_ch] != val) {
211 queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
212 param->mixer.source[mixer_ch].pan[mixer_src_ch] = val;
216 if (param->mixer.source[mixer_ch].flag[mixer_src_ch] != val) {
217 queue_event(motu, msg_type, mixer_ch, mixer_src_ch, val);
218 param->mixer.source[mixer_ch].flag[mixer_src_ch] = val;
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, mixer_ch, mixer_src_ch, val);
224 param->mixer.source[mixer_ch].paired_balance[mixer_src_ch] = val;
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, mixer_ch, mixer_src_ch, val);
230 param->mixer.source[mixer_ch].paired_width[mixer_src_ch] = val;
237 parser->mixer_src_ch = mixer_src_ch;
241 case MIXER_OUTPUT_PAIRED_VOLUME:
242 case MIXER_OUTPUT_PAIRED_FLAG:
244 struct snd_firewire_motu_register_dsp_parameter *param = &parser->param;
245 u8 mixer_ch = parser->mixer_ch;
247 if (mixer_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT) {
249 case MIXER_OUTPUT_PAIRED_VOLUME:
250 if (param->mixer.output.paired_volume[mixer_ch] != val) {
251 queue_event(motu, msg_type, mixer_ch, 0, val);
252 param->mixer.output.paired_volume[mixer_ch] = val;
255 case MIXER_OUTPUT_PAIRED_FLAG:
256 if (param->mixer.output.paired_flag[mixer_ch] != val) {
257 queue_event(motu, msg_type, mixer_ch, 0, val);
258 param->mixer.output.paired_flag[mixer_ch] = val;
267 case MAIN_OUTPUT_PAIRED_VOLUME:
268 if (parser->param.output.main_paired_volume != val) {
269 queue_event(motu, msg_type, 0, 0, val);
270 parser->param.output.main_paired_volume = val;
273 case HP_OUTPUT_PAIRED_VOLUME:
274 if (parser->param.output.hp_paired_volume != val) {
275 queue_event(motu, msg_type, 0, 0, val);
276 parser->param.output.hp_paired_volume = val;
279 case HP_OUTPUT_PAIRED_ASSIGNMENT:
280 if (parser->param.output.hp_paired_assignment != val) {
281 queue_event(motu, msg_type, 0, 0, val);
282 parser->param.output.hp_paired_assignment = val;
285 case LINE_INPUT_BOOST:
286 if (parser->param.line_input.boost_flag != val) {
287 queue_event(motu, msg_type, 0, 0, val);
288 parser->param.line_input.boost_flag = val;
291 case LINE_INPUT_NOMINAL_LEVEL:
292 if (parser->param.line_input.nominal_level_flag != val) {
293 queue_event(motu, msg_type, 0, 0, val);
294 parser->param.line_input.nominal_level_flag = val;
297 case INPUT_GAIN_AND_INVERT:
300 struct snd_firewire_motu_register_dsp_parameter *param = &parser->param;
301 u8 input_ch = parser->input_ch;
303 if (parser->prev_msg_type != msg_type)
308 if (input_ch < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT) {
310 case INPUT_GAIN_AND_INVERT:
311 if (param->input.gain_and_invert[input_ch] != val) {
312 queue_event(motu, msg_type, input_ch, 0, val);
313 param->input.gain_and_invert[input_ch] = val;
317 if (param->input.flag[input_ch] != val) {
318 queue_event(motu, msg_type, input_ch, 0, val);
319 param->input.flag[input_ch] = val;
325 parser->input_ch = input_ch;
336 if (!meter_pos_quirk)
337 pos = b[MSG_METER_IDX_POS];
339 pos = b[MSG_METER_IDX_POS_4PRE_AE];
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);
346 if (pos < SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT)
347 parser->meter.data[pos] = val;
350 // The message for meter is interruptible to the series of other
351 // types of messages. Don't cache it.
360 parser->prev_msg_type = msg_type;
364 if (pos != parser->push_pos)
365 wake_up(&motu->hwdep_wait);
367 spin_unlock_irqrestore(&parser->lock, flags);
370 void snd_motu_register_dsp_message_parser_copy_meter(struct snd_motu *motu,
371 struct snd_firewire_motu_register_dsp_meter *meter)
373 struct msg_parser *parser = motu->message_parser;
376 spin_lock_irqsave(&parser->lock, flags);
377 memcpy(meter, &parser->meter, sizeof(*meter));
378 spin_unlock_irqrestore(&parser->lock, flags);
381 void snd_motu_register_dsp_message_parser_copy_parameter(struct snd_motu *motu,
382 struct snd_firewire_motu_register_dsp_parameter *param)
384 struct msg_parser *parser = motu->message_parser;
387 spin_lock_irqsave(&parser->lock, flags);
388 memcpy(param, &parser->param, sizeof(*param));
389 spin_unlock_irqrestore(&parser->lock, flags);
392 unsigned int snd_motu_register_dsp_message_parser_count_event(struct snd_motu *motu)
394 struct msg_parser *parser = motu->message_parser;
396 if (parser->pull_pos > parser->push_pos)
397 return EVENT_QUEUE_SIZE - parser->pull_pos + parser->push_pos;
399 return parser->push_pos - parser->pull_pos;
402 bool snd_motu_register_dsp_message_parser_copy_event(struct snd_motu *motu, u32 *event)
404 struct msg_parser *parser = motu->message_parser;
405 unsigned int pos = parser->pull_pos;
408 if (pos == parser->push_pos)
411 spin_lock_irqsave(&parser->lock, flags);
413 *event = parser->event_queue[pos];
416 if (pos >= EVENT_QUEUE_SIZE)
418 parser->pull_pos = pos;
420 spin_unlock_irqrestore(&parser->lock, flags);