sound/firewire/fireface/ff-protocol-latter.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // ff-protocol-latter - a part of driver for RME Fireface series
   3 //
   4 // Copyright (c) 2019 Takashi Sakamoto
   5 //
   6 // Licensed under the terms of the GNU General Public License, version 2.
   7
   8 #include <linux/delay.h>
   9
  10 #include "ff.h"
  11
  12 #define LATTER_STF              0xffff00000004ULL
  13 #define LATTER_ISOC_CHANNELS    0xffff00000008ULL
  14 #define LATTER_ISOC_START       0xffff0000000cULL
  15 #define LATTER_FETCH_MODE       0xffff00000010ULL
  16 #define LATTER_SYNC_STATUS      0x0000801c0000ULL
  17
  18 // The content of sync status register differs between models.
  19 //
  20 // Fireface UCX:
  21 //  0xf0000000: (unidentified)
  22 //  0x0f000000: effective rate of sampling clock
  23 //  0x00f00000: detected rate of word clock on BNC interface
  24 //  0x000f0000: detected rate of ADAT or S/PDIF on optical interface
  25 //  0x0000f000: detected rate of S/PDIF on coaxial interface
  26 //  0x00000e00: effective source of sampling clock
  27 //    0x00000e00: Internal
  28 //    0x00000800: (unidentified)
  29 //    0x00000600: Word clock on BNC interface
  30 //    0x00000400: ADAT on optical interface
  31 //    0x00000200: S/PDIF on coaxial or optical interface
  32 //  0x00000100: Optical interface is used for ADAT signal
  33 //  0x00000080: (unidentified)
  34 //  0x00000040: Synchronized to word clock on BNC interface
  35 //  0x00000020: Synchronized to ADAT or S/PDIF on optical interface
  36 //  0x00000010: Synchronized to S/PDIF on coaxial interface
  37 //  0x00000008: (unidentified)
  38 //  0x00000004: Lock word clock on BNC interface
  39 //  0x00000002: Lock ADAT or S/PDIF on optical interface
  40 //  0x00000001: Lock S/PDIF on coaxial interface
  41 //
  42 // Fireface 802 (and perhaps UFX):
  43 //   0xf0000000: effective rate of sampling clock
  44 //   0x0f000000: detected rate of ADAT-B on 2nd optical interface
  45 //   0x00f00000: detected rate of ADAT-A on 1st optical interface
  46 //   0x000f0000: detected rate of AES/EBU on XLR or coaxial interface
  47 //   0x0000f000: detected rate of word clock on BNC interface
  48 //   0x00000e00: effective source of sampling clock
  49 //     0x00000e00: internal
  50 //     0x00000800: ADAT-B
  51 //     0x00000600: ADAT-A
  52 //     0x00000400: AES/EBU
  53 //     0x00000200: Word clock
  54 //   0x00000080: Synchronized to ADAT-B on 2nd optical interface
  55 //   0x00000040: Synchronized to ADAT-A on 1st optical interface
  56 //   0x00000020: Synchronized to AES/EBU on XLR or 2nd optical interface
  57 //   0x00000010: Synchronized to word clock on BNC interface
  58 //   0x00000008: Lock ADAT-B on 2nd optical interface
  59 //   0x00000004: Lock ADAT-A on 1st optical interface
  60 //   0x00000002: Lock AES/EBU on XLR or 2nd optical interface
  61 //   0x00000001: Lock word clock on BNC interface
  62 //
  63 // The pattern for rate bits:
  64 //   0x00: 32.0 kHz
  65 //   0x01: 44.1 kHz
  66 //   0x02: 48.0 kHz
  67 //   0x04: 64.0 kHz
  68 //   0x05: 88.2 kHz
  69 //   0x06: 96.0 kHz
  70 //   0x08: 128.0 kHz
  71 //   0x09: 176.4 kHz
  72 //   0x0a: 192.0 kHz
  73 static int parse_clock_bits(u32 data, unsigned int *rate,
  74                             enum snd_ff_clock_src *src,
  75                             enum snd_ff_unit_version unit_version)
  76 {
  77         static const struct {
  78                 unsigned int rate;
  79                 u32 flag;
  80         } *rate_entry, rate_entries[] = {
  81                 { 32000,        0x00, },
  82                 { 44100,        0x01, },
  83                 { 48000,        0x02, },
  84                 { 64000,        0x04, },
  85                 { 88200,        0x05, },
  86                 { 96000,        0x06, },
  87                 { 128000,       0x08, },
  88                 { 176400,       0x09, },
  89                 { 192000,       0x0a, },
  90         };
  91         static const struct {
  92                 enum snd_ff_clock_src src;
  93                 u32 flag;
  94         } *clk_entry, *clk_entries, ucx_clk_entries[] = {
  95                 { SND_FF_CLOCK_SRC_SPDIF,       0x00000200, },
  96                 { SND_FF_CLOCK_SRC_ADAT1,       0x00000400, },
  97                 { SND_FF_CLOCK_SRC_WORD,        0x00000600, },
  98                 { SND_FF_CLOCK_SRC_INTERNAL,    0x00000e00, },
  99         }, ufx_ff802_clk_entries[] = {
 100                 { SND_FF_CLOCK_SRC_WORD,        0x00000200, },
 101                 { SND_FF_CLOCK_SRC_SPDIF,       0x00000400, },
 102                 { SND_FF_CLOCK_SRC_ADAT1,       0x00000600, },
 103                 { SND_FF_CLOCK_SRC_ADAT2,       0x00000800, },
 104                 { SND_FF_CLOCK_SRC_INTERNAL,    0x00000e00, },
 105         };
 106         u32 rate_bits;
 107         unsigned int clk_entry_count;
 108         int i;
 109
 110         if (unit_version == SND_FF_UNIT_VERSION_UCX) {
 111                 rate_bits = (data & 0x0f000000) >> 24;
 112                 clk_entries = ucx_clk_entries;
 113                 clk_entry_count = ARRAY_SIZE(ucx_clk_entries);
 114         } else {
 115                 rate_bits = (data & 0xf0000000) >> 28;
 116                 clk_entries = ufx_ff802_clk_entries;
 117                 clk_entry_count = ARRAY_SIZE(ufx_ff802_clk_entries);
 118         }
 119
 120         for (i = 0; i < ARRAY_SIZE(rate_entries); ++i) {
 121                 rate_entry = rate_entries + i;
 122                 if (rate_bits == rate_entry->flag) {
 123                         *rate = rate_entry->rate;
 124                         break;
 125                 }
 126         }
 127         if (i == ARRAY_SIZE(rate_entries))
 128                 return -EIO;
 129
 130         for (i = 0; i < clk_entry_count; ++i) {
 131                 clk_entry = clk_entries + i;
 132                 if ((data & 0x000e00) == clk_entry->flag) {
 133                         *src = clk_entry->src;
 134                         break;
 135                 }
 136         }
 137         if (i == clk_entry_count)
 138                 return -EIO;
 139
 140         return 0;
 141 }
 142
 143 static int latter_get_clock(struct snd_ff *ff, unsigned int *rate,
 144                            enum snd_ff_clock_src *src)
 145 {
 146         __le32 reg;
 147         u32 data;
 148         int err;
 149
 150         err = snd_fw_transaction(ff->unit, TCODE_READ_QUADLET_REQUEST,
 151                                  LATTER_SYNC_STATUS, &reg, sizeof(reg), 0);
 152         if (err < 0)
 153                 return err;
 154         data = le32_to_cpu(reg);
 155
 156         return parse_clock_bits(data, rate, src, ff->unit_version);
 157 }
 158
 159 static int latter_switch_fetching_mode(struct snd_ff *ff, bool enable)
 160 {
 161         u32 data;
 162         __le32 reg;
 163
 164         if (enable)
 165                 data = 0x00000000;
 166         else
 167                 data = 0xffffffff;
 168         reg = cpu_to_le32(data);
 169
 170         return snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
 171                                   LATTER_FETCH_MODE, &reg, sizeof(reg), 0);
 172 }
 173
 174 static int latter_allocate_resources(struct snd_ff *ff, unsigned int rate)
 175 {
 176         enum snd_ff_stream_mode mode;
 177         unsigned int code;
 178         __le32 reg;
 179         unsigned int count;
 180         int i;
 181         int err;
 182
 183         // Set the number of data blocks transferred in a second.
 184         if (rate % 48000 == 0)
 185                 code = 0x04;
 186         else if (rate % 44100 == 0)
 187                 code = 0x02;
 188         else if (rate % 32000 == 0)
 189                 code = 0x00;
 190         else
 191                 return -EINVAL;
 192
 193         if (rate >= 64000 && rate < 128000)
 194                 code |= 0x08;
 195         else if (rate >= 128000)
 196                 code |= 0x10;
 197
 198         reg = cpu_to_le32(code);
 199         err = snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
 200                                  LATTER_STF, &reg, sizeof(reg), 0);
 201         if (err < 0)
 202                 return err;
 203
 204         // Confirm to shift transmission clock.
 205         count = 0;
 206         while (count++ < 10) {
 207                 unsigned int curr_rate;
 208                 enum snd_ff_clock_src src;
 209
 210                 err = latter_get_clock(ff, &curr_rate, &src);
 211                 if (err < 0)
 212                         return err;
 213
 214                 if (curr_rate == rate)
 215                         break;
 216         }
 217         if (count > 10)
 218                 return -ETIMEDOUT;
 219
 220         for (i = 0; i < ARRAY_SIZE(amdtp_rate_table); ++i) {
 221                 if (rate == amdtp_rate_table[i])
 222                         break;
 223         }
 224         if (i == ARRAY_SIZE(amdtp_rate_table))
 225                 return -EINVAL;
 226
 227         err = snd_ff_stream_get_multiplier_mode(i, &mode);
 228         if (err < 0)
 229                 return err;
 230
 231         // Keep resources for in-stream.
 232         ff->tx_resources.channels_mask = 0x00000000000000ffuLL;
 233         err = fw_iso_resources_allocate(&ff->tx_resources,
 234                         amdtp_stream_get_max_payload(&ff->tx_stream),
 235                         fw_parent_device(ff->unit)->max_speed);
 236         if (err < 0)
 237                 return err;
 238
 239         // Keep resources for out-stream.
 240         ff->rx_resources.channels_mask = 0x00000000000000ffuLL;
 241         err = fw_iso_resources_allocate(&ff->rx_resources,
 242                         amdtp_stream_get_max_payload(&ff->rx_stream),
 243                         fw_parent_device(ff->unit)->max_speed);
 244         if (err < 0)
 245                 fw_iso_resources_free(&ff->tx_resources);
 246
 247         return err;
 248 }
 249
 250 static int latter_begin_session(struct snd_ff *ff, unsigned int rate)
 251 {
 252         unsigned int generation = ff->rx_resources.generation;
 253         unsigned int flag;
 254         u32 data;
 255         __le32 reg;
 256         int err;
 257
 258         if (ff->unit_version == SND_FF_UNIT_VERSION_UCX) {
 259                 // For Fireface UCX. Always use the maximum number of data
 260                 // channels in data block of packet.
 261                 if (rate >= 32000 && rate <= 48000)
 262                         flag = 0x92;
 263                 else if (rate >= 64000 && rate <= 96000)
 264                         flag = 0x8e;
 265                 else if (rate >= 128000 && rate <= 192000)
 266                         flag = 0x8c;
 267                 else
 268                         return -EINVAL;
 269         } else {
 270                 // For Fireface UFX and 802. Due to bandwidth limitation on
 271                 // IEEE 1394a (400 Mbps), Analog 1-12 and AES are available
 272                 // without any ADAT at quadruple speed.
 273                 if (rate >= 32000 && rate <= 48000)
 274                         flag = 0x9e;
 275                 else if (rate >= 64000 && rate <= 96000)
 276                         flag = 0x96;
 277                 else if (rate >= 128000 && rate <= 192000)
 278                         flag = 0x8e;
 279                 else
 280                         return -EINVAL;
 281         }
 282
 283         if (generation != fw_parent_device(ff->unit)->card->generation) {
 284                 err = fw_iso_resources_update(&ff->tx_resources);
 285                 if (err < 0)
 286                         return err;
 287
 288                 err = fw_iso_resources_update(&ff->rx_resources);
 289                 if (err < 0)
 290                         return err;
 291         }
 292
 293         data = (ff->tx_resources.channel << 8) | ff->rx_resources.channel;
 294         reg = cpu_to_le32(data);
 295         err = snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
 296                                  LATTER_ISOC_CHANNELS, &reg, sizeof(reg), 0);
 297         if (err < 0)
 298                 return err;
 299
 300         reg = cpu_to_le32(flag);
 301         return snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
 302                                   LATTER_ISOC_START, &reg, sizeof(reg), 0);
 303 }
 304
 305 static void latter_finish_session(struct snd_ff *ff)
 306 {
 307         __le32 reg;
 308
 309         reg = cpu_to_le32(0x00000000);
 310         snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
 311                            LATTER_ISOC_START, &reg, sizeof(reg), 0);
 312 }
 313
 314 static void latter_dump_status(struct snd_ff *ff, struct snd_info_buffer *buffer)
 315 {
 316         static const struct {
 317                 char *const label;
 318                 u32 locked_mask;
 319                 u32 synced_mask;
 320         } *clk_entry, *clk_entries, ucx_clk_entries[] = {
 321                 { "S/PDIF",     0x00000001, 0x00000010, },
 322                 { "ADAT",       0x00000002, 0x00000020, },
 323                 { "WDClk",      0x00000004, 0x00000040, },
 324         }, ufx_ff802_clk_entries[] = {
 325                 { "WDClk",      0x00000001, 0x00000010, },
 326                 { "AES/EBU",    0x00000002, 0x00000020, },
 327                 { "ADAT-A",     0x00000004, 0x00000040, },
 328                 { "ADAT-B",     0x00000008, 0x00000080, },
 329         };
 330         __le32 reg;
 331         u32 data;
 332         unsigned int rate;
 333         enum snd_ff_clock_src src;
 334         const char *label;
 335         unsigned int clk_entry_count;
 336         int i;
 337         int err;
 338
 339         err = snd_fw_transaction(ff->unit, TCODE_READ_QUADLET_REQUEST,
 340                                  LATTER_SYNC_STATUS, &reg, sizeof(reg), 0);
 341         if (err < 0)
 342                 return;
 343         data = le32_to_cpu(reg);
 344
 345         snd_iprintf(buffer, "External source detection:\n");
 346
 347         if (ff->unit_version == SND_FF_UNIT_VERSION_UCX) {
 348                 clk_entries = ucx_clk_entries;
 349                 clk_entry_count = ARRAY_SIZE(ucx_clk_entries);
 350         } else {
 351                 clk_entries = ufx_ff802_clk_entries;
 352                 clk_entry_count = ARRAY_SIZE(ufx_ff802_clk_entries);
 353         }
 354
 355         for (i = 0; i < clk_entry_count; ++i) {
 356                 clk_entry = clk_entries + i;
 357                 snd_iprintf(buffer, "%s: ", clk_entry->label);
 358                 if (data & clk_entry->locked_mask) {
 359                         if (data & clk_entry->synced_mask)
 360                                 snd_iprintf(buffer, "sync\n");
 361                         else
 362                                 snd_iprintf(buffer, "lock\n");
 363                 } else {
 364                         snd_iprintf(buffer, "none\n");
 365                 }
 366         }
 367
 368         err = parse_clock_bits(data, &rate, &src, ff->unit_version);
 369         if (err < 0)
 370                 return;
 371         label = snd_ff_proc_get_clk_label(src);
 372         if (!label)
 373                 return;
 374
 375         snd_iprintf(buffer, "Referred clock: %s %d\n", label, rate);
 376 }
 377
 378 // NOTE: transactions are transferred within 0x00-0x7f in allocated range of
 379 // address. This seems to be for check of discontinuity in receiver side.
 380 //
 381 // Like Fireface 400, drivers can select one of 4 options for lower 4 bytes of
 382 // destination address by bit flags in quadlet register (little endian) at
 383 // 0x'ffff'0000'0014:
 384 //
 385 // bit flags: offset of destination address
 386 // - 0x00002000: 0x'....'....'0000'0000
 387 // - 0x00004000: 0x'....'....'0000'0080
 388 // - 0x00008000: 0x'....'....'0000'0100
 389 // - 0x00010000: 0x'....'....'0000'0180
 390 //
 391 // Drivers can suppress the device to transfer asynchronous transactions by
 392 // clear these bit flags.
 393 //
 394 // Actually, the register is write-only and includes the other settings such as
 395 // input attenuation. This driver allocates for the first option
 396 // (0x'....'....'0000'0000) and expects userspace application to configure the
 397 // register for it.
 398 static void latter_handle_midi_msg(struct snd_ff *ff, unsigned int offset,
 399                                    __le32 *buf, size_t length)
 400 {
 401         u32 data = le32_to_cpu(*buf);
 402         unsigned int index = (data & 0x000000f0) >> 4;
 403         u8 byte[3];
 404         struct snd_rawmidi_substream *substream;
 405         unsigned int len;
 406
 407         if (index >= ff->spec->midi_in_ports)
 408                 return;
 409
 410         switch (data & 0x0000000f) {
 411         case 0x00000008:
 412         case 0x00000009:
 413         case 0x0000000a:
 414         case 0x0000000b:
 415         case 0x0000000e:
 416                 len = 3;
 417                 break;
 418         case 0x0000000c:
 419         case 0x0000000d:
 420                 len = 2;
 421                 break;
 422         default:
 423                 len = data & 0x00000003;
 424                 if (len == 0)
 425                         len = 3;
 426                 break;
 427         }
 428
 429         byte[0] = (data & 0x0000ff00) >> 8;
 430         byte[1] = (data & 0x00ff0000) >> 16;
 431         byte[2] = (data & 0xff000000) >> 24;
 432
 433         substream = READ_ONCE(ff->tx_midi_substreams[index]);
 434         if (substream)
 435                 snd_rawmidi_receive(substream, byte, len);
 436 }
 437
 438 /*
 439  * When return minus value, given argument is not MIDI status.
 440  * When return 0, given argument is a beginning of system exclusive.
 441  * When return the others, given argument is MIDI data.
 442  */
 443 static inline int calculate_message_bytes(u8 status)
 444 {
 445         switch (status) {
 446         case 0xf6:      /* Tune request. */
 447         case 0xf8:      /* Timing clock. */
 448         case 0xfa:      /* Start. */
 449         case 0xfb:      /* Continue. */
 450         case 0xfc:      /* Stop. */
 451         case 0xfe:      /* Active sensing. */
 452         case 0xff:      /* System reset. */
 453                 return 1;
 454         case 0xf1:      /* MIDI time code quarter frame. */
 455         case 0xf3:      /* Song select. */
 456                 return 2;
 457         case 0xf2:      /* Song position pointer. */
 458                 return 3;
 459         case 0xf0:      /* Exclusive. */
 460                 return 0;
 461         case 0xf7:      /* End of exclusive. */
 462                 break;
 463         case 0xf4:      /* Undefined. */
 464         case 0xf5:      /* Undefined. */
 465         case 0xf9:      /* Undefined. */
 466         case 0xfd:      /* Undefined. */
 467                 break;
 468         default:
 469                 switch (status & 0xf0) {
 470                 case 0x80:      /* Note on. */
 471                 case 0x90:      /* Note off. */
 472                 case 0xa0:      /* Polyphonic key pressure. */
 473                 case 0xb0:      /* Control change and Mode change. */
 474                 case 0xe0:      /* Pitch bend change. */
 475                         return 3;
 476                 case 0xc0:      /* Program change. */
 477                 case 0xd0:      /* Channel pressure. */
 478                         return 2;
 479                 default:
 480                 break;
 481                 }
 482         break;
 483         }
 484
 485         return -EINVAL;
 486 }
 487
 488 static int latter_fill_midi_msg(struct snd_ff *ff,
 489                                 struct snd_rawmidi_substream *substream,
 490                                 unsigned int port)
 491 {
 492         u32 data = {0};
 493         u8 *buf = (u8 *)&data;
 494         int consumed;
 495
 496         buf[0] = port << 4;
 497         consumed = snd_rawmidi_transmit_peek(substream, buf + 1, 3);
 498         if (consumed <= 0)
 499                 return consumed;
 500
 501         if (!ff->on_sysex[port]) {
 502                 if (buf[1] != 0xf0) {
 503                         if (consumed < calculate_message_bytes(buf[1]))
 504                                 return 0;
 505                 } else {
 506                         // The beginning of exclusives.
 507                         ff->on_sysex[port] = true;
 508                 }
 509
 510                 buf[0] |= consumed;
 511         } else {
 512                 if (buf[1] != 0xf7) {
 513                         if (buf[2] == 0xf7 || buf[3] == 0xf7) {
 514                                 // Transfer end code at next time.
 515                                 consumed -= 1;
 516                         }
 517
 518                         buf[0] |= consumed;
 519                 } else {
 520                         // The end of exclusives.
 521                         ff->on_sysex[port] = false;
 522                         consumed = 1;
 523                         buf[0] |= 0x0f;
 524                 }
 525         }
 526
 527         ff->msg_buf[port][0] = cpu_to_le32(data);
 528         ff->rx_bytes[port] = consumed;
 529
 530         return 1;
 531 }
 532
 533 const struct snd_ff_protocol snd_ff_protocol_latter = {
 534         .handle_midi_msg        = latter_handle_midi_msg,
 535         .fill_midi_msg          = latter_fill_midi_msg,
 536         .get_clock              = latter_get_clock,
 537         .switch_fetching_mode   = latter_switch_fetching_mode,
 538         .allocate_resources     = latter_allocate_resources,
 539         .begin_session          = latter_begin_session,
 540         .finish_session         = latter_finish_session,
 541         .dump_status            = latter_dump_status,
 542 };