sound/firewire/oxfw/oxfw-stream.c

   1 /*
   2  * oxfw_stream.c - a part of driver for OXFW970/971 based devices
   3  *
   4  * Copyright (c) 2014 Takashi Sakamoto
   5  *
   6  * Licensed under the terms of the GNU General Public License, version 2.
   7  */
   8
   9 #include "oxfw.h"
  10 #include <linux/delay.h>
  11
  12 #define AVC_GENERIC_FRAME_MAXIMUM_BYTES 512
  13 #define CALLBACK_TIMEOUT        200
  14
  15 /*
  16  * According to datasheet of Oxford Semiconductor:
  17  *  OXFW970: 32.0/44.1/48.0/96.0 Khz, 8 audio channels I/O
  18  *  OXFW971: 32.0/44.1/48.0/88.2/96.0/192.0 kHz, 16 audio channels I/O, MIDI I/O
  19  */
  20 static const unsigned int oxfw_rate_table[] = {
  21         [0] = 32000,
  22         [1] = 44100,
  23         [2] = 48000,
  24         [3] = 88200,
  25         [4] = 96000,
  26         [5] = 192000,
  27 };
  28
  29 /*
  30  * See Table 5.7 – Sampling frequency for Multi-bit Audio
  31  * in AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA)
  32  */
  33 static const unsigned int avc_stream_rate_table[] = {
  34         [0] = 0x02,
  35         [1] = 0x03,
  36         [2] = 0x04,
  37         [3] = 0x0a,
  38         [4] = 0x05,
  39         [5] = 0x07,
  40 };
  41
  42 static int set_rate(struct snd_oxfw *oxfw, unsigned int rate)
  43 {
  44         int err;
  45
  46         err = avc_general_set_sig_fmt(oxfw->unit, rate,
  47                                       AVC_GENERAL_PLUG_DIR_IN, 0);
  48         if (err < 0)
  49                 goto end;
  50
  51         if (oxfw->has_output)
  52                 err = avc_general_set_sig_fmt(oxfw->unit, rate,
  53                                               AVC_GENERAL_PLUG_DIR_OUT, 0);
  54 end:
  55         return err;
  56 }
  57
  58 static int set_stream_format(struct snd_oxfw *oxfw, struct amdtp_stream *s,
  59                              unsigned int rate, unsigned int pcm_channels)
  60 {
  61         u8 **formats;
  62         struct snd_oxfw_stream_formation formation;
  63         enum avc_general_plug_dir dir;
  64         unsigned int len;
  65         int i, err;
  66
  67         if (s == &oxfw->tx_stream) {
  68                 formats = oxfw->tx_stream_formats;
  69                 dir = AVC_GENERAL_PLUG_DIR_OUT;
  70         } else {
  71                 formats = oxfw->rx_stream_formats;
  72                 dir = AVC_GENERAL_PLUG_DIR_IN;
  73         }
  74
  75         /* Seek stream format for requirements. */
  76         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
  77                 err = snd_oxfw_stream_parse_format(formats[i], &formation);
  78                 if (err < 0)
  79                         return err;
  80
  81                 if ((formation.rate == rate) && (formation.pcm == pcm_channels))
  82                         break;
  83         }
  84         if (i == SND_OXFW_STREAM_FORMAT_ENTRIES)
  85                 return -EINVAL;
  86
  87         /* If assumed, just change rate. */
  88         if (oxfw->assumed)
  89                 return set_rate(oxfw, rate);
  90
  91         /* Calculate format length. */
  92         len = 5 + formats[i][4] * 2;
  93
  94         err = avc_stream_set_format(oxfw->unit, dir, 0, formats[i], len);
  95         if (err < 0)
  96                 return err;
  97
  98         /* Some requests just after changing format causes freezing. */
  99         msleep(100);
 100
 101         return 0;
 102 }
 103
 104 static void stop_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
 105 {
 106         amdtp_stream_pcm_abort(stream);
 107         amdtp_stream_stop(stream);
 108
 109         if (stream == &oxfw->tx_stream)
 110                 cmp_connection_break(&oxfw->out_conn);
 111         else
 112                 cmp_connection_break(&oxfw->in_conn);
 113 }
 114
 115 static int start_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream,
 116                         unsigned int rate, unsigned int pcm_channels)
 117 {
 118         u8 **formats;
 119         struct cmp_connection *conn;
 120         struct snd_oxfw_stream_formation formation;
 121         unsigned int i, midi_ports;
 122         int err;
 123
 124         if (stream == &oxfw->rx_stream) {
 125                 formats = oxfw->rx_stream_formats;
 126                 conn = &oxfw->in_conn;
 127         } else {
 128                 formats = oxfw->tx_stream_formats;
 129                 conn = &oxfw->out_conn;
 130         }
 131
 132         /* Get stream format */
 133         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
 134                 if (formats[i] == NULL)
 135                         break;
 136
 137                 err = snd_oxfw_stream_parse_format(formats[i], &formation);
 138                 if (err < 0)
 139                         goto end;
 140                 if (rate != formation.rate)
 141                         continue;
 142                 if (pcm_channels == 0 ||  pcm_channels == formation.pcm)
 143                         break;
 144         }
 145         if (i == SND_OXFW_STREAM_FORMAT_ENTRIES) {
 146                 err = -EINVAL;
 147                 goto end;
 148         }
 149
 150         pcm_channels = formation.pcm;
 151         midi_ports = DIV_ROUND_UP(formation.midi, 8);
 152
 153         /* The stream should have one pcm channels at least */
 154         if (pcm_channels == 0) {
 155                 err = -EINVAL;
 156                 goto end;
 157         }
 158         amdtp_stream_set_parameters(stream, rate, pcm_channels, midi_ports);
 159
 160         err = cmp_connection_establish(conn,
 161                                        amdtp_stream_get_max_payload(stream));
 162         if (err < 0)
 163                 goto end;
 164
 165         err = amdtp_stream_start(stream,
 166                                  conn->resources.channel,
 167                                  conn->speed);
 168         if (err < 0) {
 169                 cmp_connection_break(conn);
 170                 goto end;
 171         }
 172
 173         /* Wait first packet */
 174         err = amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT);
 175         if (err < 0)
 176                 stop_stream(oxfw, stream);
 177 end:
 178         return err;
 179 }
 180
 181 static int check_connection_used_by_others(struct snd_oxfw *oxfw,
 182                                            struct amdtp_stream *stream)
 183 {
 184         struct cmp_connection *conn;
 185         bool used;
 186         int err;
 187
 188         if (stream == &oxfw->tx_stream)
 189                 conn = &oxfw->out_conn;
 190         else
 191                 conn = &oxfw->in_conn;
 192
 193         err = cmp_connection_check_used(conn, &used);
 194         if ((err >= 0) && used && !amdtp_stream_running(stream)) {
 195                 dev_err(&oxfw->unit->device,
 196                         "Connection established by others: %cPCR[%d]\n",
 197                         (conn->direction == CMP_OUTPUT) ? 'o' : 'i',
 198                         conn->pcr_index);
 199                 err = -EBUSY;
 200         }
 201
 202         return err;
 203 }
 204
 205 int snd_oxfw_stream_init_simplex(struct snd_oxfw *oxfw,
 206                                  struct amdtp_stream *stream)
 207 {
 208         struct cmp_connection *conn;
 209         enum cmp_direction c_dir;
 210         enum amdtp_stream_direction s_dir;
 211         int err;
 212
 213         if (stream == &oxfw->tx_stream) {
 214                 conn = &oxfw->out_conn;
 215                 c_dir = CMP_OUTPUT;
 216                 s_dir = AMDTP_IN_STREAM;
 217         } else {
 218                 conn = &oxfw->in_conn;
 219                 c_dir = CMP_INPUT;
 220                 s_dir = AMDTP_OUT_STREAM;
 221         }
 222
 223         err = cmp_connection_init(conn, oxfw->unit, c_dir, 0);
 224         if (err < 0)
 225                 goto end;
 226
 227         err = amdtp_stream_init(stream, oxfw->unit, s_dir, CIP_NONBLOCKING);
 228         if (err < 0) {
 229                 amdtp_stream_destroy(stream);
 230                 cmp_connection_destroy(conn);
 231                 goto end;
 232         }
 233
 234         /* OXFW starts to transmit packets with non-zero dbc. */
 235         if (stream == &oxfw->tx_stream)
 236                 oxfw->tx_stream.flags |= CIP_SKIP_INIT_DBC_CHECK;
 237 end:
 238         return err;
 239 }
 240
 241 int snd_oxfw_stream_start_simplex(struct snd_oxfw *oxfw,
 242                                   struct amdtp_stream *stream,
 243                                   unsigned int rate, unsigned int pcm_channels)
 244 {
 245         struct amdtp_stream *opposite;
 246         struct snd_oxfw_stream_formation formation;
 247         enum avc_general_plug_dir dir;
 248         unsigned int substreams, opposite_substreams;
 249         int err = 0;
 250
 251         if (stream == &oxfw->tx_stream) {
 252                 substreams = oxfw->capture_substreams;
 253                 opposite = &oxfw->rx_stream;
 254                 opposite_substreams = oxfw->playback_substreams;
 255                 dir = AVC_GENERAL_PLUG_DIR_OUT;
 256         } else {
 257                 substreams = oxfw->playback_substreams;
 258                 opposite_substreams = oxfw->capture_substreams;
 259
 260                 if (oxfw->has_output)
 261                         opposite = &oxfw->rx_stream;
 262                 else
 263                         opposite = NULL;
 264
 265                 dir = AVC_GENERAL_PLUG_DIR_IN;
 266         }
 267
 268         if (substreams == 0)
 269                 goto end;
 270
 271         /*
 272          * Considering JACK/FFADO streaming:
 273          * TODO: This can be removed hwdep functionality becomes popular.
 274          */
 275         err = check_connection_used_by_others(oxfw, stream);
 276         if (err < 0)
 277                 goto end;
 278
 279         /* packet queueing error */
 280         if (amdtp_streaming_error(stream))
 281                 stop_stream(oxfw, stream);
 282
 283         err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
 284         if (err < 0)
 285                 goto end;
 286         if (rate == 0)
 287                 rate = formation.rate;
 288         if (pcm_channels == 0)
 289                 pcm_channels = formation.pcm;
 290
 291         if ((formation.rate != rate) || (formation.pcm != pcm_channels)) {
 292                 if (opposite != NULL) {
 293                         err = check_connection_used_by_others(oxfw, opposite);
 294                         if (err < 0)
 295                                 goto end;
 296                         stop_stream(oxfw, opposite);
 297                 }
 298                 stop_stream(oxfw, stream);
 299
 300                 err = set_stream_format(oxfw, stream, rate, pcm_channels);
 301                 if (err < 0) {
 302                         dev_err(&oxfw->unit->device,
 303                                 "fail to set stream format: %d\n", err);
 304                         goto end;
 305                 }
 306
 307                 /* Start opposite stream if needed. */
 308                 if (opposite && !amdtp_stream_running(opposite) &&
 309                     (opposite_substreams > 0)) {
 310                         err = start_stream(oxfw, opposite, rate, 0);
 311                         if (err < 0) {
 312                                 dev_err(&oxfw->unit->device,
 313                                         "fail to restart stream: %d\n", err);
 314                                 goto end;
 315                         }
 316                 }
 317         }
 318
 319         /* Start requested stream. */
 320         if (!amdtp_stream_running(stream)) {
 321                 err = start_stream(oxfw, stream, rate, pcm_channels);
 322                 if (err < 0)
 323                         dev_err(&oxfw->unit->device,
 324                                 "fail to start stream: %d\n", err);
 325         }
 326 end:
 327         return err;
 328 }
 329
 330 void snd_oxfw_stream_stop_simplex(struct snd_oxfw *oxfw,
 331                                   struct amdtp_stream *stream)
 332 {
 333         if (((stream == &oxfw->tx_stream) && (oxfw->capture_substreams > 0)) ||
 334             ((stream == &oxfw->rx_stream) && (oxfw->playback_substreams > 0)))
 335                 return;
 336
 337         stop_stream(oxfw, stream);
 338 }
 339
 340 void snd_oxfw_stream_destroy_simplex(struct snd_oxfw *oxfw,
 341                                      struct amdtp_stream *stream)
 342 {
 343         struct cmp_connection *conn;
 344
 345         if (stream == &oxfw->tx_stream)
 346                 conn = &oxfw->out_conn;
 347         else
 348                 conn = &oxfw->in_conn;
 349
 350         stop_stream(oxfw, stream);
 351
 352         amdtp_stream_destroy(stream);
 353         cmp_connection_destroy(conn);
 354 }
 355
 356 void snd_oxfw_stream_update_simplex(struct snd_oxfw *oxfw,
 357                                     struct amdtp_stream *stream)
 358 {
 359         struct cmp_connection *conn;
 360
 361         if (stream == &oxfw->tx_stream)
 362                 conn = &oxfw->out_conn;
 363         else
 364                 conn = &oxfw->in_conn;
 365
 366         if (cmp_connection_update(conn) < 0)
 367                 stop_stream(oxfw, stream);
 368         else
 369                 amdtp_stream_update(stream);
 370 }
 371
 372 int snd_oxfw_stream_get_current_formation(struct snd_oxfw *oxfw,
 373                                 enum avc_general_plug_dir dir,
 374                                 struct snd_oxfw_stream_formation *formation)
 375 {
 376         u8 *format;
 377         unsigned int len;
 378         int err;
 379
 380         len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 381         format = kmalloc(len, GFP_KERNEL);
 382         if (format == NULL)
 383                 return -ENOMEM;
 384
 385         err = avc_stream_get_format_single(oxfw->unit, dir, 0, format, &len);
 386         if (err < 0)
 387                 goto end;
 388         if (len < 3) {
 389                 err = -EIO;
 390                 goto end;
 391         }
 392
 393         err = snd_oxfw_stream_parse_format(format, formation);
 394 end:
 395         kfree(format);
 396         return err;
 397 }
 398
 399 /*
 400  * See Table 6.16 - AM824 Stream Format
 401  *     Figure 6.19 - format_information field for AM824 Compound
 402  * in AV/C Stream Format Information Specification 1.1 (Apr 2005, 1394TA)
 403  * Also 'Clause 12 AM824 sequence adaption layers' in IEC 61883-6:2005
 404  */
 405 int snd_oxfw_stream_parse_format(u8 *format,
 406                                  struct snd_oxfw_stream_formation *formation)
 407 {
 408         unsigned int i, e, channels, type;
 409
 410         memset(formation, 0, sizeof(struct snd_oxfw_stream_formation));
 411
 412         /*
 413          * this module can support a hierarchy combination that:
 414          *  Root:       Audio and Music (0x90)
 415          *  Level 1:    AM824 Compound  (0x40)
 416          */
 417         if ((format[0] != 0x90) || (format[1] != 0x40))
 418                 return -ENOSYS;
 419
 420         /* check the sampling rate */
 421         for (i = 0; i < ARRAY_SIZE(avc_stream_rate_table); i++) {
 422                 if (format[2] == avc_stream_rate_table[i])
 423                         break;
 424         }
 425         if (i == ARRAY_SIZE(avc_stream_rate_table))
 426                 return -ENOSYS;
 427
 428         formation->rate = oxfw_rate_table[i];
 429
 430         for (e = 0; e < format[4]; e++) {
 431                 channels = format[5 + e * 2];
 432                 type = format[6 + e * 2];
 433
 434                 switch (type) {
 435                 /* IEC 60958 Conformant, currently handled as MBLA */
 436                 case 0x00:
 437                 /* Multi Bit Linear Audio (Raw) */
 438                 case 0x06:
 439                         formation->pcm += channels;
 440                         break;
 441                 /* MIDI Conformant */
 442                 case 0x0d:
 443                         formation->midi = channels;
 444                         break;
 445                 /* IEC 61937-3 to 7 */
 446                 case 0x01:
 447                 case 0x02:
 448                 case 0x03:
 449                 case 0x04:
 450                 case 0x05:
 451                 /* Multi Bit Linear Audio */
 452                 case 0x07:      /* DVD-Audio */
 453                 case 0x0c:      /* High Precision */
 454                 /* One Bit Audio */
 455                 case 0x08:      /* (Plain) Raw */
 456                 case 0x09:      /* (Plain) SACD */
 457                 case 0x0a:      /* (Encoded) Raw */
 458                 case 0x0b:      /* (Encoded) SACD */
 459                 /* SMPTE Time-Code conformant */
 460                 case 0x0e:
 461                 /* Sample Count */
 462                 case 0x0f:
 463                 /* Anciliary Data */
 464                 case 0x10:
 465                 /* Synchronization Stream (Stereo Raw audio) */
 466                 case 0x40:
 467                 /* Don't care */
 468                 case 0xff:
 469                 default:
 470                         return -ENOSYS; /* not supported */
 471                 }
 472         }
 473
 474         if (formation->pcm  > AMDTP_MAX_CHANNELS_FOR_PCM ||
 475             formation->midi > AMDTP_MAX_CHANNELS_FOR_MIDI)
 476                 return -ENOSYS;
 477
 478         return 0;
 479 }
 480
 481 static int
 482 assume_stream_formats(struct snd_oxfw *oxfw, enum avc_general_plug_dir dir,
 483                       unsigned int pid, u8 *buf, unsigned int *len,
 484                       u8 **formats)
 485 {
 486         struct snd_oxfw_stream_formation formation;
 487         unsigned int i, eid;
 488         int err;
 489
 490         /* get format at current sampling rate */
 491         err = avc_stream_get_format_single(oxfw->unit, dir, pid, buf, len);
 492         if (err < 0) {
 493                 dev_err(&oxfw->unit->device,
 494                 "fail to get current stream format for isoc %s plug %d:%d\n",
 495                         (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
 496                         pid, err);
 497                 goto end;
 498         }
 499
 500         /* parse and set stream format */
 501         eid = 0;
 502         err = snd_oxfw_stream_parse_format(buf, &formation);
 503         if (err < 0)
 504                 goto end;
 505
 506         formats[eid] = kmalloc(*len, GFP_KERNEL);
 507         if (formats[eid] == NULL) {
 508                 err = -ENOMEM;
 509                 goto end;
 510         }
 511         memcpy(formats[eid], buf, *len);
 512
 513         /* apply the format for each available sampling rate */
 514         for (i = 0; i < ARRAY_SIZE(oxfw_rate_table); i++) {
 515                 if (formation.rate == oxfw_rate_table[i])
 516                         continue;
 517
 518                 err = avc_general_inquiry_sig_fmt(oxfw->unit,
 519                                                   oxfw_rate_table[i],
 520                                                   dir, pid);
 521                 if (err < 0)
 522                         continue;
 523
 524                 eid++;
 525                 formats[eid] = kmalloc(*len, GFP_KERNEL);
 526                 if (formats[eid] == NULL) {
 527                         err = -ENOMEM;
 528                         goto end;
 529                 }
 530                 memcpy(formats[eid], buf, *len);
 531                 formats[eid][2] = avc_stream_rate_table[i];
 532         }
 533
 534         err = 0;
 535         oxfw->assumed = true;
 536 end:
 537         return err;
 538 }
 539
 540 static int fill_stream_formats(struct snd_oxfw *oxfw,
 541                                enum avc_general_plug_dir dir,
 542                                unsigned short pid)
 543 {
 544         u8 *buf, **formats;
 545         unsigned int len, eid = 0;
 546         struct snd_oxfw_stream_formation dummy;
 547         int err;
 548
 549         buf = kmalloc(AVC_GENERIC_FRAME_MAXIMUM_BYTES, GFP_KERNEL);
 550         if (buf == NULL)
 551                 return -ENOMEM;
 552
 553         if (dir == AVC_GENERAL_PLUG_DIR_OUT)
 554                 formats = oxfw->tx_stream_formats;
 555         else
 556                 formats = oxfw->rx_stream_formats;
 557
 558         /* get first entry */
 559         len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 560         err = avc_stream_get_format_list(oxfw->unit, dir, 0, buf, &len, 0);
 561         if (err == -ENOSYS) {
 562                 /* LIST subfunction is not implemented */
 563                 len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 564                 err = assume_stream_formats(oxfw, dir, pid, buf, &len,
 565                                             formats);
 566                 goto end;
 567         } else if (err < 0) {
 568                 dev_err(&oxfw->unit->device,
 569                         "fail to get stream format %d for isoc %s plug %d:%d\n",
 570                         eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" : "out",
 571                         pid, err);
 572                 goto end;
 573         }
 574
 575         /* LIST subfunction is implemented */
 576         while (eid < SND_OXFW_STREAM_FORMAT_ENTRIES) {
 577                 /* The format is too short. */
 578                 if (len < 3) {
 579                         err = -EIO;
 580                         break;
 581                 }
 582
 583                 /* parse and set stream format */
 584                 err = snd_oxfw_stream_parse_format(buf, &dummy);
 585                 if (err < 0)
 586                         break;
 587
 588                 formats[eid] = kmalloc(len, GFP_KERNEL);
 589                 if (formats[eid] == NULL) {
 590                         err = -ENOMEM;
 591                         break;
 592                 }
 593                 memcpy(formats[eid], buf, len);
 594
 595                 /* get next entry */
 596                 len = AVC_GENERIC_FRAME_MAXIMUM_BYTES;
 597                 err = avc_stream_get_format_list(oxfw->unit, dir, 0,
 598                                                  buf, &len, ++eid);
 599                 /* No entries remained. */
 600                 if (err == -EINVAL) {
 601                         err = 0;
 602                         break;
 603                 } else if (err < 0) {
 604                         dev_err(&oxfw->unit->device,
 605                         "fail to get stream format %d for isoc %s plug %d:%d\n",
 606                                 eid, (dir == AVC_GENERAL_PLUG_DIR_IN) ? "in" :
 607                                                                         "out",
 608                                 pid, err);
 609                         break;
 610                 }
 611         }
 612 end:
 613         kfree(buf);
 614         return err;
 615 }
 616
 617 int snd_oxfw_stream_discover(struct snd_oxfw *oxfw)
 618 {
 619         u8 plugs[AVC_PLUG_INFO_BUF_BYTES];
 620         int err;
 621
 622         /* the number of plugs for isoc in/out, ext in/out  */
 623         err = avc_general_get_plug_info(oxfw->unit, 0x1f, 0x07, 0x00, plugs);
 624         if (err < 0) {
 625                 dev_err(&oxfw->unit->device,
 626                 "fail to get info for isoc/external in/out plugs: %d\n",
 627                         err);
 628                 goto end;
 629         } else if ((plugs[0] == 0) && (plugs[1] == 0)) {
 630                 err = -ENOSYS;
 631                 goto end;
 632         }
 633
 634         /* use oPCR[0] if exists */
 635         if (plugs[1] > 0) {
 636                 err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_OUT, 0);
 637                 if (err < 0)
 638                         goto end;
 639                 oxfw->has_output = true;
 640         }
 641
 642         /* use iPCR[0] if exists */
 643         if (plugs[0] > 0)
 644                 err = fill_stream_formats(oxfw, AVC_GENERAL_PLUG_DIR_IN, 0);
 645 end:
 646         return err;
 647 }
 648
 649 void snd_oxfw_stream_lock_changed(struct snd_oxfw *oxfw)
 650 {
 651         oxfw->dev_lock_changed = true;
 652         wake_up(&oxfw->hwdep_wait);
 653 }
 654
 655 int snd_oxfw_stream_lock_try(struct snd_oxfw *oxfw)
 656 {
 657         int err;
 658
 659         spin_lock_irq(&oxfw->lock);
 660
 661         /* user land lock this */
 662         if (oxfw->dev_lock_count < 0) {
 663                 err = -EBUSY;
 664                 goto end;
 665         }
 666
 667         /* this is the first time */
 668         if (oxfw->dev_lock_count++ == 0)
 669                 snd_oxfw_stream_lock_changed(oxfw);
 670         err = 0;
 671 end:
 672         spin_unlock_irq(&oxfw->lock);
 673         return err;
 674 }
 675
 676 void snd_oxfw_stream_lock_release(struct snd_oxfw *oxfw)
 677 {
 678         spin_lock_irq(&oxfw->lock);
 679
 680         if (WARN_ON(oxfw->dev_lock_count <= 0))
 681                 goto end;
 682         if (--oxfw->dev_lock_count == 0)
 683                 snd_oxfw_stream_lock_changed(oxfw);
 684 end:
 685         spin_unlock_irq(&oxfw->lock);
 686 }