sound/firewire/oxfw/oxfw-stream.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * oxfw_stream.c - a part of driver for OXFW970/971 based devices
   4  *
   5  * Copyright (c) 2014 Takashi Sakamoto
   6  */
   7
   8 #include "oxfw.h"
   9 #include <linux/delay.h>
  10
  11 #define AVC_GENERIC_FRAME_MAXIMUM_BYTES 512
  12 #define READY_TIMEOUT_MS        600
  13
  14 /*
  15  * According to datasheet of Oxford Semiconductor:
  16  *  OXFW970: 32.0/44.1/48.0/96.0 Khz, 8 audio channels I/O
  17  *  OXFW971: 32.0/44.1/48.0/88.2/96.0/192.0 kHz, 16 audio channels I/O, MIDI I/O
  18  */
  19 static const unsigned int oxfw_rate_table[] = {
  20         [0] = 32000,
  21         [1] = 44100,
  22         [2] = 48000,
  23         [3] = 88200,
  24         [4] = 96000,
  25         [5] = 192000,
  26 };
  27
  28 /*
  29  * See Table 5.7 – Sampling frequency for Multi-bit Audio
  30  * in AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA)
  31  */
  32 static const unsigned int avc_stream_rate_table[] = {
  33         [0] = 0x02,
  34         [1] = 0x03,
  35         [2] = 0x04,
  36         [3] = 0x0a,
  37         [4] = 0x05,
  38         [5] = 0x07,
  39 };
  40
  41 static int set_rate(struct snd_oxfw *oxfw, unsigned int rate)
  42 {
  43         int err;
  44
  45         err = avc_general_set_sig_fmt(oxfw->unit, rate,
  46                                       AVC_GENERAL_PLUG_DIR_IN, 0);
  47         if (err < 0)
  48                 goto end;
  49
  50         if (oxfw->has_output)
  51                 err = avc_general_set_sig_fmt(oxfw->unit, rate,
  52                                               AVC_GENERAL_PLUG_DIR_OUT, 0);
  53 end:
  54         return err;
  55 }
  56
  57 static int set_stream_format(struct snd_oxfw *oxfw, struct amdtp_stream *s,
  58                              unsigned int rate, unsigned int pcm_channels)
  59 {
  60         u8 **formats;
  61         struct snd_oxfw_stream_formation formation;
  62         enum avc_general_plug_dir dir;
  63         unsigned int len;
  64         int i, err;
  65
  66         if (s == &oxfw->tx_stream) {
  67                 formats = oxfw->tx_stream_formats;
  68                 dir = AVC_GENERAL_PLUG_DIR_OUT;
  69         } else {
  70                 formats = oxfw->rx_stream_formats;
  71                 dir = AVC_GENERAL_PLUG_DIR_IN;
  72         }
  73
  74         /* Seek stream format for requirements. */
  75         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
  76                 err = snd_oxfw_stream_parse_format(formats[i], &formation);
  77                 if (err < 0)
  78                         return err;
  79
  80                 if ((formation.rate == rate) && (formation.pcm == pcm_channels))
  81                         break;
  82         }
  83         if (i == SND_OXFW_STREAM_FORMAT_ENTRIES)
  84                 return -EINVAL;
  85
  86         /* If assumed, just change rate. */
  87         if (oxfw->assumed)
  88                 return set_rate(oxfw, rate);
  89
  90         /* Calculate format length. */
  91         len = 5 + formats[i][4] * 2;
  92
  93         err = avc_stream_set_format(oxfw->unit, dir, 0, formats[i], len);
  94         if (err < 0)
  95                 return err;
  96
  97         /* Some requests just after changing format causes freezing. */
  98         msleep(100);
  99
 100         return 0;
 101 }
 102
 103 static int start_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
 104 {
 105         struct cmp_connection *conn;
 106         int err;
 107
 108         if (stream == &oxfw->rx_stream)
 109                 conn = &oxfw->in_conn;
 110         else
 111                 conn = &oxfw->out_conn;
 112
 113         err = cmp_connection_establish(conn);
 114         if (err < 0)
 115                 return err;
 116
 117         err = amdtp_domain_add_stream(&oxfw->domain, stream,
 118                                       conn->resources.channel, conn->speed);
 119         if (err < 0) {
 120                 cmp_connection_break(conn);
 121                 return err;
 122         }
 123
 124         return 0;
 125 }
 126
 127 static int check_connection_used_by_others(struct snd_oxfw *oxfw,
 128                                            struct amdtp_stream *stream)
 129 {
 130         struct cmp_connection *conn;
 131         bool used;
 132         int err;
 133
 134         if (stream == &oxfw->tx_stream)
 135                 conn = &oxfw->out_conn;
 136         else
 137                 conn = &oxfw->in_conn;
 138
 139         err = cmp_connection_check_used(conn, &used);
 140         if ((err >= 0) && used && !amdtp_stream_running(stream)) {
 141                 dev_err(&oxfw->unit->device,
 142                         "Connection established by others: %cPCR[%d]\n",
 143                         (conn->direction == CMP_OUTPUT) ? 'o' : 'i',
 144                         conn->pcr_index);
 145                 err = -EBUSY;
 146         }
 147
 148         return err;
 149 }
 150
 151 static int init_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
 152 {
 153         struct cmp_connection *conn;
 154         enum cmp_direction c_dir;
 155         enum amdtp_stream_direction s_dir;
 156         unsigned int flags = 0;
 157         int err;
 158
 159         if (!(oxfw->quirks & SND_OXFW_QUIRK_BLOCKING_TRANSMISSION))
 160                 flags |= CIP_NONBLOCKING;
 161         else
 162                 flags |= CIP_BLOCKING;
 163
 164         // OXFW 970/971 has no function to generate playback timing according to the sequence
 165         // of value in syt field, thus the packet should include NO_INFO value in the field.
 166         // However, some models just ignore data blocks in packet with NO_INFO for audio data
 167         // processing.
 168         if (!(oxfw->quirks & SND_OXFW_QUIRK_IGNORE_NO_INFO_PACKET))
 169                 flags |= CIP_UNAWARE_SYT;
 170
 171         if (stream == &oxfw->tx_stream) {
 172                 conn = &oxfw->out_conn;
 173                 c_dir = CMP_OUTPUT;
 174                 s_dir = AMDTP_IN_STREAM;
 175
 176                 if (oxfw->quirks & SND_OXFW_QUIRK_JUMBO_PAYLOAD)
 177                         flags |= CIP_JUMBO_PAYLOAD;
 178                 if (oxfw->quirks & SND_OXFW_QUIRK_WRONG_DBS)
 179                         flags |= CIP_WRONG_DBS;
 180         } else {
 181                 conn = &oxfw->in_conn;
 182                 c_dir = CMP_INPUT;
 183                 s_dir = AMDTP_OUT_STREAM;
 184         }
 185
 186         err = cmp_connection_init(conn, oxfw->unit, c_dir, 0);
 187         if (err < 0)
 188                 return err;
 189
 190         err = amdtp_am824_init(stream, oxfw->unit, s_dir, flags);
 191         if (err < 0) {
 192                 cmp_connection_destroy(conn);
 193                 return err;
 194         }
 195
 196         return 0;
 197 }
 198
 199 static int keep_resources(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
 200 {
 201         enum avc_general_plug_dir dir;
 202         u8 **formats;
 203         struct snd_oxfw_stream_formation formation;
 204         struct cmp_connection *conn;
 205         int i;
 206         int err;
 207
 208         if (stream == &oxfw->rx_stream) {
 209                 dir = AVC_GENERAL_PLUG_DIR_IN;
 210                 formats = oxfw->rx_stream_formats;
 211                 conn = &oxfw->in_conn;
 212         } else {
 213                 dir = AVC_GENERAL_PLUG_DIR_OUT;
 214                 formats = oxfw->tx_stream_formats;
 215                 conn = &oxfw->out_conn;
 216         }
 217
 218         err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
 219         if (err < 0)
 220                 return err;
 221
 222         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
 223                 struct snd_oxfw_stream_formation fmt;
 224
 225                 if (formats[i] == NULL)
 226                         break;
 227
 228                 err = snd_oxfw_stream_parse_format(formats[i], &fmt);
 229                 if (err < 0)
 230                         return err;
 231
 232                 if (fmt.rate == formation.rate && fmt.pcm == formation.pcm &&
 233                     fmt.midi == formation.midi)
 234                         break;
 235         }
 236         if (i == SND_OXFW_STREAM_FORMAT_ENTRIES)
 237                 return -EINVAL;
 238
 239         // The stream should have one pcm channels at least.
 240         if (formation.pcm == 0)
 241                 return -EINVAL;
 242
 243         err = amdtp_am824_set_parameters(stream, formation.rate, formation.pcm,
 244                                          formation.midi * 8, false);
 245         if (err < 0)
 246                 return err;
 247
 248         return cmp_connection_reserve(conn, amdtp_stream_get_max_payload(stream));
 249 }
 250
 251 int snd_oxfw_stream_reserve_duplex(struct snd_oxfw *oxfw,
 252                                    struct amdtp_stream *stream,
 253                                    unsigned int rate, unsigned int pcm_channels,
 254                                    unsigned int frames_per_period,
 255                                    unsigned int frames_per_buffer)
 256 {
 257         struct snd_oxfw_stream_formation formation;
 258         enum avc_general_plug_dir dir;
 259         int err;
 260
 261         // Considering JACK/FFADO streaming:
 262         // TODO: This can be removed hwdep functionality becomes popular.
 263         err = check_connection_used_by_others(oxfw, &oxfw->rx_stream);
 264         if (err < 0)
 265                 return err;
 266         if (oxfw->has_output) {
 267                 err = check_connection_used_by_others(oxfw, &oxfw->tx_stream);
 268                 if (err < 0)
 269                         return err;
 270         }
 271
 272         if (stream == &oxfw->tx_stream)
 273                 dir = AVC_GENERAL_PLUG_DIR_OUT;
 274         else
 275                 dir = AVC_GENERAL_PLUG_DIR_IN;
 276
 277         err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
 278         if (err < 0)
 279                 return err;
 280         if (rate == 0) {
 281                 rate = formation.rate;
 282                 pcm_channels = formation.pcm;
 283         }
 284         if (formation.rate != rate || formation.pcm != pcm_channels) {
 285                 amdtp_domain_stop(&oxfw->domain);
 286
 287                 cmp_connection_break(&oxfw->in_conn);
 288                 cmp_connection_release(&oxfw->in_conn);
 289
 290                 if (oxfw->has_output) {
 291                         cmp_connection_break(&oxfw->out_conn);
 292                         cmp_connection_release(&oxfw->out_conn);
 293                 }
 294         }
 295
 296         if (oxfw->substreams_count == 0 ||
 297             formation.rate != rate || formation.pcm != pcm_channels) {
 298                 err = set_stream_format(oxfw, stream, rate, pcm_channels);
 299                 if (err < 0) {
 300                         dev_err(&oxfw->unit->device,
 301                                 "fail to set stream format: %d\n", err);
 302                         return err;
 303                 }
 304
 305                 err = keep_resources(oxfw, &oxfw->rx_stream);
 306                 if (err < 0)
 307                         return err;
 308
 309                 if (oxfw->has_output) {
 310                         err = keep_resources(oxfw, &oxfw->tx_stream);
 311                         if (err < 0) {
 312                                 cmp_connection_release(&oxfw->in_conn);
 313                                 return err;
 314                         }
 315                 }
 316
 317                 err = amdtp_domain_set_events_per_period(&oxfw->domain,
 318                                         frames_per_period, frames_per_buffer);
 319                 if (err < 0) {
 320                         cmp_connection_release(&oxfw->in_conn);
 321                         if (oxfw->has_output)
 322                                 cmp_connection_release(&oxfw->out_conn);
 323                         return err;
 324                 }
 325         }
 326
 327         return 0;
 328 }
 329
 330 int snd_oxfw_stream_start_duplex(struct snd_oxfw *oxfw)
 331 {
 332         int err;
 333
 334         if (oxfw->substreams_count == 0)
 335                 return -EIO;
 336
 337         if (amdtp_streaming_error(&oxfw->rx_stream) ||
 338             amdtp_streaming_error(&oxfw->tx_stream)) {
 339                 amdtp_domain_stop(&oxfw->domain);
 340
 341                 cmp_connection_break(&oxfw->in_conn);
 342                 if (oxfw->has_output)
 343                         cmp_connection_break(&oxfw->out_conn);
 344         }
 345
 346         if (!amdtp_stream_running(&oxfw->rx_stream)) {
 347                 unsigned int tx_init_skip_cycles = 0;
 348                 bool replay_seq = false;
 349
 350                 err = start_stream(oxfw, &oxfw->rx_stream);
 351                 if (err < 0) {
 352                         dev_err(&oxfw->unit->device,
 353                                 "fail to prepare rx stream: %d\n", err);
 354                         goto error;
 355                 }
 356
 357                 if (oxfw->has_output &&
 358                     !amdtp_stream_running(&oxfw->tx_stream)) {
 359                         err = start_stream(oxfw, &oxfw->tx_stream);
 360                         if (err < 0) {
 361                                 dev_err(&oxfw->unit->device,
 362                                         "fail to prepare tx stream: %d\n", err);
 363                                 goto error;
 364                         }
 365
 366                         if (oxfw->quirks & SND_OXFW_QUIRK_JUMBO_PAYLOAD) {
 367                                 // Just after changing sampling transfer frequency, many cycles are
 368                                 // skipped for packet transmission.
 369                                 tx_init_skip_cycles = 400;
 370                         } else if (oxfw->quirks & SND_OXFW_QUIRK_VOLUNTARY_RECOVERY) {
 371                                 // It takes a bit time for target device to adjust event frequency
 372                                 // according to nominal event frequency in isochronous packets from
 373                                 // ALSA oxfw driver.
 374                                 tx_init_skip_cycles = 4000;
 375                         } else {
 376                                 replay_seq = true;
 377                         }
 378                 }
 379
 380                 // NOTE: The device ignores presentation time expressed by the value of syt field
 381                 // of CIP header in received packets. The sequence of the number of data blocks per
 382                 // packet is important for media clock recovery.
 383                 err = amdtp_domain_start(&oxfw->domain, tx_init_skip_cycles, replay_seq, false);
 384                 if (err < 0)
 385                         goto error;
 386
 387                 if (!amdtp_domain_wait_ready(&oxfw->domain, READY_TIMEOUT_MS)) {
 388                         err = -ETIMEDOUT;
 389                         goto error;
 390                 }
 391         }
 392
 393         return 0;
 394 error:
 395         amdtp_domain_stop(&oxfw->domain);
 396
 397         cmp_connection_break(&oxfw->in_conn);
 398         if (oxfw->has_output)
 399                 cmp_connection_break(&oxfw->out_conn);
 400
 401         return err;
 402 }
 403
 404 void snd_oxfw_stream_stop_duplex(struct snd_oxfw *oxfw)
 405 {
 406         if (oxfw->substreams_count == 0) {
 407                 amdtp_domain_stop(&oxfw->domain);
 408
 409                 cmp_connection_break(&oxfw->in_conn);
 410                 cmp_connection_release(&oxfw->in_conn);
 411
 412                 if (oxfw->has_output) {
 413                         cmp_connection_break(&oxfw->out_conn);
 414                         cmp_connection_release(&oxfw->out_conn);
 415                 }
 416         }
 417 }
 418
 419 static void destroy_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
 420 {
 421         struct cmp_connection *conn;
 422
 423         if (stream == &oxfw->tx_stream)
 424                 conn = &oxfw->out_conn;
 425         else
 426                 conn = &oxfw->in_conn;
 427
 428         amdtp_stream_destroy(stream);
 429         cmp_connection_destroy(conn);
 430 }
 431
 432 int snd_oxfw_stream_init_duplex(struct snd_oxfw *oxfw)
 433 {
 434         int err;
 435
 436         err = init_stream(oxfw, &oxfw->rx_stream);
 437         if (err < 0)
 438                 return err;
 439
 440         if (oxfw->has_output) {
 441                 err = init_stream(oxfw, &oxfw->tx_stream);
 442                 if (err < 0) {
 443                         destroy_stream(oxfw, &oxfw->rx_stream);
 444                         return err;
 445                 }
 446         }
 447
 448         err = amdtp_domain_init(&oxfw->domain);
 449         if (err < 0) {
 450                 destroy_stream(oxfw, &oxfw->rx_stream);
 451                 if (oxfw->has_output)
 452                         destroy_stream(oxfw, &oxfw->tx_stream);
 453         }
 454
 455         return err;
 456 }
 457
 458 // This function should be called before starting the stream or after stopping
 459 // the streams.
 460 void snd_oxfw_stream_destroy_duplex(struct snd_oxfw *oxfw)
 461 {
 462         amdtp_domain_destroy(&oxfw->domain);
 463
 464         destroy_stream(oxfw, &oxfw->rx_stream);
 465
 466         if (oxfw->has_output)
 467                 destroy_stream(oxfw, &oxfw->tx_stream);
 468 }
 469
 470 void snd_oxfw_stream_update_duplex(struct snd_oxfw *oxfw)
 471 {
 472         amdtp_domain_stop(&oxfw->domain);
 473
 474         cmp_connection_break(&oxfw->in_conn);
 475
 476         amdtp_stream_pcm_abort(&oxfw->rx_stream);
 477
 478         if (oxfw->has_output) {
 479                 cmp_connection_break(&oxfw->out_conn);
 480
 481                 amdtp_stream_pcm_abort(&oxfw->tx_stream);
 482         }
 483 }
 484
 485 int snd_oxfw_stream_get_current_formation(struct snd_oxfw *oxfw,
 486                                 enum avc_general_plug_dir dir,
 487                                 struct snd_oxfw_stream_formation *formation)
 488 {
 489         u8 *format;
 490         unsigned int len;
 491         int err;
 492
 493         len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 494         format = kmalloc(len, GFP_KERNEL);
 495         if (format == NULL)
 496                 return -ENOMEM;
 497
 498         err = avc_stream_get_format_single(oxfw->unit, dir, 0, format, &len);
 499         if (err < 0)
 500                 goto end;
 501         if (len < 3) {
 502                 err = -EIO;
 503                 goto end;
 504         }
 505
 506         err = snd_oxfw_stream_parse_format(format, formation);
 507 end:
 508         kfree(format);
 509         return err;
 510 }
 511
 512 /*
 513  * See Table 6.16 - AM824 Stream Format
 514  *     Figure 6.19 - format_information field for AM824 Compound
 515  * in AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA)
 516  * Also 'Clause 12 AM824 sequence adaption layers' in IEC 61883-6:2005
 517  */
 518 int snd_oxfw_stream_parse_format(u8 *format,
 519                                  struct snd_oxfw_stream_formation *formation)
 520 {
 521         unsigned int i, e, channels, type;
 522
 523         memset(formation, 0, sizeof(struct snd_oxfw_stream_formation));
 524
 525         /*
 526          * this module can support a hierarchy combination that:
 527          *  Root:       Audio and Music (0x90)
 528          *  Level 1:    AM824 Compound  (0x40)
 529          */
 530         if ((format[0] != 0x90) || (format[1] != 0x40))
 531                 return -ENXIO;
 532
 533         /* check the sampling rate */
 534         for (i = 0; i < ARRAY_SIZE(avc_stream_rate_table); i++) {
 535                 if (format[2] == avc_stream_rate_table[i])
 536                         break;
 537         }
 538         if (i == ARRAY_SIZE(avc_stream_rate_table))
 539                 return -ENXIO;
 540
 541         formation->rate = oxfw_rate_table[i];
 542
 543         for (e = 0; e < format[4]; e++) {
 544                 channels = format[5 + e * 2];
 545                 type = format[6 + e * 2];
 546
 547                 switch (type) {
 548                 /* IEC 60958 Conformant, currently handled as MBLA */
 549                 case 0x00:
 550                 /* Multi Bit Linear Audio (Raw) */
 551                 case 0x06:
 552                         formation->pcm += channels;
 553                         break;
 554                 /* MIDI Conformant */
 555                 case 0x0d:
 556                         formation->midi = channels;
 557                         break;
 558                 /* IEC 61937-3 to 7 */
 559                 case 0x01:
 560                 case 0x02:
 561                 case 0x03:
 562                 case 0x04:
 563                 case 0x05:
 564                 /* Multi Bit Linear Audio */
 565                 case 0x07:      /* DVD-Audio */
 566                 case 0x0c:      /* High Precision */
 567                 /* One Bit Audio */
 568                 case 0x08:      /* (Plain) Raw */
 569                 case 0x09:      /* (Plain) SACD */
 570                 case 0x0a:      /* (Encoded) Raw */
 571                 case 0x0b:      /* (Encoded) SACD */
 572                 /* SMPTE Time-Code conformant */
 573                 case 0x0e:
 574                 /* Sample Count */
 575                 case 0x0f:
 576                 /* Anciliary Data */
 577                 case 0x10:
 578                 /* Synchronization Stream (Stereo Raw audio) */
 579                 case 0x40:
 580                 /* Don't care */
 581                 case 0xff:
 582                 default:
 583                         return -ENXIO;  /* not supported */
 584                 }
 585         }
 586
 587         if (formation->pcm  > AM824_MAX_CHANNELS_FOR_PCM ||
 588             formation->midi > AM824_MAX_CHANNELS_FOR_MIDI)
 589                 return -ENXIO;
 590
 591         return 0;
 592 }
 593
 594 static int
 595 assume_stream_formats(struct snd_oxfw *oxfw, enum avc_general_plug_dir dir,
 596                       unsigned int pid, u8 *buf, unsigned int *len,
 597                       u8 **formats)
 598 {
 599         struct snd_oxfw_stream_formation formation;
 600         unsigned int i, eid;
 601         int err;
 602
 603         /* get format at current sampling rate */
 604         err = avc_stream_get_format_single(oxfw->unit, dir, pid, buf, len);
 605         if (err < 0) {
 606                 dev_err(&oxfw->unit->device,
 607                 "fail to get current stream format for isoc %s plug %d:%d\n",
 608                         (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
 609                         pid, err);
 610                 goto end;
 611         }
 612
 613         /* parse and set stream format */
 614         eid = 0;
 615         err = snd_oxfw_stream_parse_format(buf, &formation);
 616         if (err < 0)
 617                 goto end;
 618
 619         formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, *len,
 620                                     GFP_KERNEL);
 621         if (!formats[eid]) {
 622                 err = -ENOMEM;
 623                 goto end;
 624         }
 625
 626         /* apply the format for each available sampling rate */
 627         for (i = 0; i < ARRAY_SIZE(oxfw_rate_table); i++) {
 628                 if (formation.rate == oxfw_rate_table[i])
 629                         continue;
 630
 631                 err = avc_general_inquiry_sig_fmt(oxfw->unit,
 632                                                   oxfw_rate_table[i],
 633                                                   dir, pid);
 634                 if (err < 0)
 635                         continue;
 636
 637                 eid++;
 638                 formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, *len,
 639                                             GFP_KERNEL);
 640                 if (formats[eid] == NULL) {
 641                         err = -ENOMEM;
 642                         goto end;
 643                 }
 644                 formats[eid][2] = avc_stream_rate_table[i];
 645         }
 646
 647         err = 0;
 648         oxfw->assumed = true;
 649 end:
 650         return err;
 651 }
 652
 653 static int fill_stream_formats(struct snd_oxfw *oxfw,
 654                                enum avc_general_plug_dir dir,
 655                                unsigned short pid)
 656 {
 657         u8 *buf, **formats;
 658         unsigned int len, eid = 0;
 659         struct snd_oxfw_stream_formation dummy;
 660         int err;
 661
 662         buf = kmalloc(AVC_GENERIC_FRAME_MAXIMUM_BYTES, GFP_KERNEL);
 663         if (buf == NULL)
 664                 return -ENOMEM;
 665
 666         if (dir == AVC_GENERAL_PLUG_DIR_OUT)
 667                 formats = oxfw->tx_stream_formats;
 668         else
 669                 formats = oxfw->rx_stream_formats;
 670
 671         /* get first entry */
 672         len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 673         err = avc_stream_get_format_list(oxfw->unit, dir, 0, buf, &len, 0);
 674         if (err == -ENXIO) {
 675                 /* LIST subfunction is not implemented */
 676                 len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 677                 err = assume_stream_formats(oxfw, dir, pid, buf, &len,
 678                                             formats);
 679                 goto end;
 680         } else if (err < 0) {
 681                 dev_err(&oxfw->unit->device,
 682                         "fail to get stream format %d for isoc %s plug %d:%d\n",
 683                         eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
 684                         pid, err);
 685                 goto end;
 686         }
 687
 688         /* LIST subfunction is implemented */
 689         while (eid < SND_OXFW_STREAM_FORMAT_ENTRIES) {
 690                 /* The format is too short. */
 691                 if (len < 3) {
 692                         err = -EIO;
 693                         break;
 694                 }
 695
 696                 /* parse and set stream format */
 697                 err = snd_oxfw_stream_parse_format(buf, &dummy);
 698                 if (err < 0)
 699                         break;
 700
 701                 formats[eid] = devm_kmemdup(&oxfw->card->card_dev, buf, len,
 702                                             GFP_KERNEL);
 703                 if (!formats[eid]) {
 704                         err = -ENOMEM;
 705                         break;
 706                 }
 707
 708                 /* get next entry */
 709                 len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 710                 err = avc_stream_get_format_list(oxfw->unit, dir, 0,
 711                                                  buf, &len, ++eid);
 712                 /* No entries remained. */
 713                 if (err == -EINVAL) {
 714                         err = 0;
 715                         break;
 716                 } else if (err < 0) {
 717                         dev_err(&oxfw->unit->device,
 718                         "fail to get stream format %d for isoc %s plug %d:%d\n",
 719                                 eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" :
 720                                                                         "out",
 721                                 pid, err);
 722                         break;
 723                 }
 724         }
 725 end:
 726         kfree(buf);
 727         return err;
 728 }
 729
 730 int snd_oxfw_stream_discover(struct snd_oxfw *oxfw)
 731 {
 732         u8 plugs[AVC_PLUG_INFO_BUF_BYTES];
 733         struct snd_oxfw_stream_formation formation;
 734         u8 *format;
 735         unsigned int i;
 736         int err;
 737
 738         /* the number of plugs for isoc in/out, ext in/out  */
 739         err = avc_general_get_plug_info(oxfw->unit, 0x1f, 0x07, 0x00, plugs);
 740         if (err < 0) {
 741                 dev_err(&oxfw->unit->device,
 742                 "fail to get info for isoc/external in/out plugs: %d\n",
 743                         err);
 744                 goto end;
 745         } else if ((plugs[0] == 0) && (plugs[1] == 0)) {
 746                 err = -ENXIO;
 747                 goto end;
 748         }
 749
 750         /* use oPCR[0] if exists */
 751         if (plugs[1] > 0) {
 752                 err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_OUT, 0);
 753                 if (err < 0) {
 754                         if (err != -ENXIO)
 755                                 return err;
 756
 757                         // The oPCR is not available for isoc communication.
 758                         err = 0;
 759                 } else {
 760                         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
 761                                 format = oxfw->tx_stream_formats[i];
 762                                 if (format == NULL)
 763                                         continue;
 764                                 err = snd_oxfw_stream_parse_format(format,
 765                                                                    &formation);
 766                                 if (err < 0)
 767                                         continue;
 768
 769                                 /* Add one MIDI port. */
 770                                 if (formation.midi > 0)
 771                                         oxfw->midi_input_ports = 1;
 772                         }
 773
 774                         oxfw->has_output = true;
 775                 }
 776         }
 777
 778         /* use iPCR[0] if exists */
 779         if (plugs[0] > 0) {
 780                 err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_IN, 0);
 781                 if (err < 0) {
 782                         if (err != -ENXIO)
 783                                 return err;
 784
 785                         // The iPCR is not available for isoc communication.
 786                         err = 0;
 787                 } else {
 788                         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
 789                                 format = oxfw->rx_stream_formats[i];
 790                                 if (format == NULL)
 791                                         continue;
 792                                 err = snd_oxfw_stream_parse_format(format,
 793                                                                    &formation);
 794                                 if (err < 0)
 795                                         continue;
 796
 797                                 /* Add one MIDI port. */
 798                                 if (formation.midi > 0)
 799                                         oxfw->midi_output_ports = 1;
 800                         }
 801
 802                         oxfw->has_input = true;
 803                 }
 804         }
 805 end:
 806         return err;
 807 }
 808
 809 void snd_oxfw_stream_lock_changed(struct snd_oxfw *oxfw)
 810 {
 811         oxfw->dev_lock_changed = true;
 812         wake_up(&oxfw->hwdep_wait);
 813 }
 814
 815 int snd_oxfw_stream_lock_try(struct snd_oxfw *oxfw)
 816 {
 817         int err;
 818
 819         spin_lock_irq(&oxfw->lock);
 820
 821         /* user land lock this */
 822         if (oxfw->dev_lock_count < 0) {
 823                 err = -EBUSY;
 824                 goto end;
 825         }
 826
 827         /* this is the first time */
 828         if (oxfw->dev_lock_count++ == 0)
 829                 snd_oxfw_stream_lock_changed(oxfw);
 830         err = 0;
 831 end:
 832         spin_unlock_irq(&oxfw->lock);
 833         return err;
 834 }
 835
 836 void snd_oxfw_stream_lock_release(struct snd_oxfw *oxfw)
 837 {
 838         spin_lock_irq(&oxfw->lock);
 839
 840         if (WARN_ON(oxfw->dev_lock_count <= 0))
 841                 goto end;
 842         if (--oxfw->dev_lock_count == 0)
 843                 snd_oxfw_stream_lock_changed(oxfw);
 844 end:
 845         spin_unlock_irq(&oxfw->lock);
 846 }