sound/firewire/motu/motu-register-dsp-message-parser.c

   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(&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
 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, mixer_ch, 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, mixer_ch, 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, mixer_ch, 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, mixer_ch, 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, mixer_ch, 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, mixer_ch, 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, mixer_ch, 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, 0, 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, 0, 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, 0, 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, 0, 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, 0, 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, input_ch, 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, input_ch, 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(&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(&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(&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(&parser->lock, flags);
 421
 422         return true;
 423 }