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