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