sound/firewire/tascam/tascam-stream.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * tascam-stream.c - a part of driver for TASCAM FireWire series
   4  *
   5  * Copyright (c) 2015 Takashi Sakamoto
   6  */
   7
   8 #include <linux/delay.h>
   9 #include "tascam.h"
  10
  11 #define CALLBACK_TIMEOUT 500
  12
  13 static int get_clock(struct snd_tscm *tscm, u32 *data)
  14 {
  15         __be32 reg;
  16         int err;
  17
  18         err = snd_fw_transaction(tscm->unit, TCODE_READ_QUADLET_REQUEST,
  19                                  TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
  20                                  &reg, sizeof(reg), 0);
  21         if (err >= 0)
  22                 *data = be32_to_cpu(reg);
  23
  24         return err;
  25 }
  26
  27 static int set_clock(struct snd_tscm *tscm, unsigned int rate,
  28                      enum snd_tscm_clock clock)
  29 {
  30         u32 data;
  31         __be32 reg;
  32         int err;
  33
  34         err = get_clock(tscm, &data);
  35         if (err < 0)
  36                 return err;
  37         data &= 0x0000ffff;
  38
  39         if (rate > 0) {
  40                 data &= 0x000000ff;
  41                 /* Base rate. */
  42                 if ((rate % 44100) == 0) {
  43                         data |= 0x00000100;
  44                         /* Multiplier. */
  45                         if (rate / 44100 == 2)
  46                                 data |= 0x00008000;
  47                 } else if ((rate % 48000) == 0) {
  48                         data |= 0x00000200;
  49                         /* Multiplier. */
  50                         if (rate / 48000 == 2)
  51                                 data |= 0x00008000;
  52                 } else {
  53                         return -EAGAIN;
  54                 }
  55         }
  56
  57         if (clock != INT_MAX) {
  58                 data &= 0x0000ff00;
  59                 data |= clock + 1;
  60         }
  61
  62         reg = cpu_to_be32(data);
  63
  64         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
  65                                  TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
  66                                  &reg, sizeof(reg), 0);
  67         if (err < 0)
  68                 return err;
  69
  70         if (data & 0x00008000)
  71                 reg = cpu_to_be32(0x0000001a);
  72         else
  73                 reg = cpu_to_be32(0x0000000d);
  74
  75         return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
  76                                   TSCM_ADDR_BASE + TSCM_OFFSET_MULTIPLEX_MODE,
  77                                   &reg, sizeof(reg), 0);
  78 }
  79
  80 int snd_tscm_stream_get_rate(struct snd_tscm *tscm, unsigned int *rate)
  81 {
  82         u32 data = 0x0;
  83         unsigned int trials = 0;
  84         int err;
  85
  86         while (data == 0x0 || trials++ < 5) {
  87                 err = get_clock(tscm, &data);
  88                 if (err < 0)
  89                         return err;
  90
  91                 data = (data & 0xff000000) >> 24;
  92         }
  93
  94         /* Check base rate. */
  95         if ((data & 0x0f) == 0x01)
  96                 *rate = 44100;
  97         else if ((data & 0x0f) == 0x02)
  98                 *rate = 48000;
  99         else
 100                 return -EAGAIN;
 101
 102         /* Check multiplier. */
 103         if ((data & 0xf0) == 0x80)
 104                 *rate *= 2;
 105         else if ((data & 0xf0) != 0x00)
 106                 return -EAGAIN;
 107
 108         return err;
 109 }
 110
 111 int snd_tscm_stream_get_clock(struct snd_tscm *tscm, enum snd_tscm_clock *clock)
 112 {
 113         u32 data;
 114         int err;
 115
 116         err = get_clock(tscm, &data);
 117         if (err < 0)
 118                 return err;
 119
 120         *clock = ((data & 0x00ff0000) >> 16) - 1;
 121         if (*clock < 0 || *clock > SND_TSCM_CLOCK_ADAT)
 122                 return -EIO;
 123
 124         return 0;
 125 }
 126
 127 static int enable_data_channels(struct snd_tscm *tscm)
 128 {
 129         __be32 reg;
 130         u32 data;
 131         unsigned int i;
 132         int err;
 133
 134         data = 0;
 135         for (i = 0; i < tscm->spec->pcm_capture_analog_channels; ++i)
 136                 data |= BIT(i);
 137         if (tscm->spec->has_adat)
 138                 data |= 0x0000ff00;
 139         if (tscm->spec->has_spdif)
 140                 data |= 0x00030000;
 141
 142         reg = cpu_to_be32(data);
 143         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 144                                  TSCM_ADDR_BASE + TSCM_OFFSET_TX_PCM_CHANNELS,
 145                                  &reg, sizeof(reg), 0);
 146         if (err < 0)
 147                 return err;
 148
 149         data = 0;
 150         for (i = 0; i < tscm->spec->pcm_playback_analog_channels; ++i)
 151                 data |= BIT(i);
 152         if (tscm->spec->has_adat)
 153                 data |= 0x0000ff00;
 154         if (tscm->spec->has_spdif)
 155                 data |= 0x00030000;
 156
 157         reg = cpu_to_be32(data);
 158         return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 159                                   TSCM_ADDR_BASE + TSCM_OFFSET_RX_PCM_CHANNELS,
 160                                   &reg, sizeof(reg), 0);
 161 }
 162
 163 static int set_stream_formats(struct snd_tscm *tscm, unsigned int rate)
 164 {
 165         __be32 reg;
 166         int err;
 167
 168         // Set an option for unknown purpose.
 169         reg = cpu_to_be32(0x00200000);
 170         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 171                                  TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
 172                                  &reg, sizeof(reg), 0);
 173         if (err < 0)
 174                 return err;
 175
 176         return enable_data_channels(tscm);
 177 }
 178
 179 static void finish_session(struct snd_tscm *tscm)
 180 {
 181         __be32 reg;
 182
 183         reg = 0;
 184         snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 185                            TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
 186                            &reg, sizeof(reg), 0);
 187
 188         reg = 0;
 189         snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 190                            TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
 191                            &reg, sizeof(reg), 0);
 192
 193         // Unregister channels.
 194         reg = cpu_to_be32(0x00000000);
 195         snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 196                            TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
 197                            &reg, sizeof(reg), 0);
 198         reg = cpu_to_be32(0x00000000);
 199         snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 200                            TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
 201                            &reg, sizeof(reg), 0);
 202         reg = cpu_to_be32(0x00000000);
 203         snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 204                            TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
 205                            &reg, sizeof(reg), 0);
 206 }
 207
 208 static int begin_session(struct snd_tscm *tscm)
 209 {
 210         __be32 reg;
 211         int err;
 212
 213         // Register the isochronous channel for transmitting stream.
 214         reg = cpu_to_be32(tscm->tx_resources.channel);
 215         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 216                                  TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
 217                                  &reg, sizeof(reg), 0);
 218         if (err < 0)
 219                 return err;
 220
 221         // Unknown.
 222         reg = cpu_to_be32(0x00000002);
 223         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 224                                  TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
 225                                  &reg, sizeof(reg), 0);
 226         if (err < 0)
 227                 return err;
 228
 229         // Register the isochronous channel for receiving stream.
 230         reg = cpu_to_be32(tscm->rx_resources.channel);
 231         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 232                                  TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
 233                                  &reg, sizeof(reg), 0);
 234         if (err < 0)
 235                 return err;
 236
 237         reg = cpu_to_be32(0x00000001);
 238         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 239                                  TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
 240                                  &reg, sizeof(reg), 0);
 241         if (err < 0)
 242                 return err;
 243
 244         reg = cpu_to_be32(0x00000001);
 245         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 246                                  TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
 247                                  &reg, sizeof(reg), 0);
 248         if (err < 0)
 249                 return err;
 250
 251         // Set an option for unknown purpose.
 252         reg = cpu_to_be32(0x00002000);
 253         err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
 254                                  TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
 255                                  &reg, sizeof(reg), 0);
 256         if (err < 0)
 257                 return err;
 258
 259         // Start multiplexing PCM samples on packets.
 260         reg = cpu_to_be32(0x00000001);
 261         return snd_fw_transaction(tscm->unit,
 262                                   TCODE_WRITE_QUADLET_REQUEST,
 263                                   TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_ON,
 264                                   &reg, sizeof(reg), 0);
 265 }
 266
 267 static int keep_resources(struct snd_tscm *tscm, unsigned int rate,
 268                           struct amdtp_stream *stream)
 269 {
 270         struct fw_iso_resources *resources;
 271         int err;
 272
 273         if (stream == &tscm->tx_stream)
 274                 resources = &tscm->tx_resources;
 275         else
 276                 resources = &tscm->rx_resources;
 277
 278         err = amdtp_tscm_set_parameters(stream, rate);
 279         if (err < 0)
 280                 return err;
 281
 282         return fw_iso_resources_allocate(resources,
 283                                 amdtp_stream_get_max_payload(stream),
 284                                 fw_parent_device(tscm->unit)->max_speed);
 285 }
 286
 287 static int init_stream(struct snd_tscm *tscm, struct amdtp_stream *s)
 288 {
 289         struct fw_iso_resources *resources;
 290         enum amdtp_stream_direction dir;
 291         unsigned int pcm_channels;
 292         int err;
 293
 294         if (s == &tscm->tx_stream) {
 295                 resources = &tscm->tx_resources;
 296                 dir = AMDTP_IN_STREAM;
 297                 pcm_channels = tscm->spec->pcm_capture_analog_channels;
 298         } else {
 299                 resources = &tscm->rx_resources;
 300                 dir = AMDTP_OUT_STREAM;
 301                 pcm_channels = tscm->spec->pcm_playback_analog_channels;
 302         }
 303
 304         if (tscm->spec->has_adat)
 305                 pcm_channels += 8;
 306         if (tscm->spec->has_spdif)
 307                 pcm_channels += 2;
 308
 309         err = fw_iso_resources_init(resources, tscm->unit);
 310         if (err < 0)
 311                 return err;
 312
 313         err = amdtp_tscm_init(s, tscm->unit, dir, pcm_channels);
 314         if (err < 0)
 315                 fw_iso_resources_free(resources);
 316
 317         return err;
 318 }
 319
 320 static void destroy_stream(struct snd_tscm *tscm, struct amdtp_stream *s)
 321 {
 322         amdtp_stream_destroy(s);
 323
 324         if (s == &tscm->tx_stream)
 325                 fw_iso_resources_destroy(&tscm->tx_resources);
 326         else
 327                 fw_iso_resources_destroy(&tscm->rx_resources);
 328 }
 329
 330 int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
 331 {
 332         int err;
 333
 334         err = init_stream(tscm, &tscm->tx_stream);
 335         if (err < 0)
 336                 return err;
 337
 338         err = init_stream(tscm, &tscm->rx_stream);
 339         if (err < 0) {
 340                 destroy_stream(tscm, &tscm->tx_stream);
 341                 return err;
 342         }
 343
 344         err = amdtp_domain_init(&tscm->domain);
 345         if (err < 0) {
 346                 destroy_stream(tscm, &tscm->tx_stream);
 347                 destroy_stream(tscm, &tscm->rx_stream);
 348         }
 349
 350         return err;
 351 }
 352
 353 // At bus reset, streaming is stopped and some registers are clear.
 354 void snd_tscm_stream_update_duplex(struct snd_tscm *tscm)
 355 {
 356         amdtp_domain_stop(&tscm->domain);
 357
 358         amdtp_stream_pcm_abort(&tscm->tx_stream);
 359         amdtp_stream_pcm_abort(&tscm->rx_stream);
 360 }
 361
 362 // This function should be called before starting streams or after stopping
 363 // streams.
 364 void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm)
 365 {
 366         amdtp_domain_destroy(&tscm->domain);
 367
 368         destroy_stream(tscm, &tscm->rx_stream);
 369         destroy_stream(tscm, &tscm->tx_stream);
 370 }
 371
 372 int snd_tscm_stream_reserve_duplex(struct snd_tscm *tscm, unsigned int rate)
 373 {
 374         unsigned int curr_rate;
 375         int err;
 376
 377         err = snd_tscm_stream_get_rate(tscm, &curr_rate);
 378         if (err < 0)
 379                 return err;
 380
 381         if (tscm->substreams_counter == 0 || rate != curr_rate) {
 382                 amdtp_domain_stop(&tscm->domain);
 383
 384                 finish_session(tscm);
 385
 386                 fw_iso_resources_free(&tscm->tx_resources);
 387                 fw_iso_resources_free(&tscm->rx_resources);
 388
 389                 err = set_clock(tscm, rate, INT_MAX);
 390                 if (err < 0)
 391                         return err;
 392
 393                 err = keep_resources(tscm, rate, &tscm->tx_stream);
 394                 if (err < 0)
 395                         return err;
 396
 397                 err = keep_resources(tscm, rate, &tscm->rx_stream);
 398                 if (err < 0) {
 399                         fw_iso_resources_free(&tscm->tx_resources);
 400                         return err;
 401                 }
 402         }
 403
 404         return 0;
 405 }
 406
 407 int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
 408 {
 409         unsigned int generation = tscm->rx_resources.generation;
 410         int err;
 411
 412         if (tscm->substreams_counter == 0)
 413                 return 0;
 414
 415         if (amdtp_streaming_error(&tscm->rx_stream) ||
 416             amdtp_streaming_error(&tscm->tx_stream)) {
 417                 amdtp_domain_stop(&tscm->domain);
 418                 finish_session(tscm);
 419         }
 420
 421         if (generation != fw_parent_device(tscm->unit)->card->generation) {
 422                 err = fw_iso_resources_update(&tscm->tx_resources);
 423                 if (err < 0)
 424                         goto error;
 425
 426                 err = fw_iso_resources_update(&tscm->rx_resources);
 427                 if (err < 0)
 428                         goto error;
 429         }
 430
 431         if (!amdtp_stream_running(&tscm->rx_stream)) {
 432                 int spd = fw_parent_device(tscm->unit)->max_speed;
 433
 434                 err = set_stream_formats(tscm, rate);
 435                 if (err < 0)
 436                         goto error;
 437
 438                 err = begin_session(tscm);
 439                 if (err < 0)
 440                         goto error;
 441
 442                 err = amdtp_domain_add_stream(&tscm->domain, &tscm->rx_stream,
 443                                               tscm->rx_resources.channel, spd);
 444                 if (err < 0)
 445                         goto error;
 446
 447                 err = amdtp_domain_add_stream(&tscm->domain, &tscm->tx_stream,
 448                                               tscm->tx_resources.channel, spd);
 449                 if (err < 0)
 450                         goto error;
 451
 452                 err = amdtp_domain_start(&tscm->domain);
 453                 if (err < 0)
 454                         return err;
 455
 456                 if (!amdtp_stream_wait_callback(&tscm->rx_stream,
 457                                                 CALLBACK_TIMEOUT) ||
 458                     !amdtp_stream_wait_callback(&tscm->tx_stream,
 459                                                 CALLBACK_TIMEOUT)) {
 460                         err = -ETIMEDOUT;
 461                         goto error;
 462                 }
 463         }
 464
 465         return 0;
 466 error:
 467         amdtp_domain_stop(&tscm->domain);
 468         finish_session(tscm);
 469
 470         return err;
 471 }
 472
 473 void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm)
 474 {
 475         if (tscm->substreams_counter == 0) {
 476                 amdtp_domain_stop(&tscm->domain);
 477                 finish_session(tscm);
 478
 479                 fw_iso_resources_free(&tscm->tx_resources);
 480                 fw_iso_resources_free(&tscm->rx_resources);
 481         }
 482 }
 483
 484 void snd_tscm_stream_lock_changed(struct snd_tscm *tscm)
 485 {
 486         tscm->dev_lock_changed = true;
 487         wake_up(&tscm->hwdep_wait);
 488 }
 489
 490 int snd_tscm_stream_lock_try(struct snd_tscm *tscm)
 491 {
 492         int err;
 493
 494         spin_lock_irq(&tscm->lock);
 495
 496         /* user land lock this */
 497         if (tscm->dev_lock_count < 0) {
 498                 err = -EBUSY;
 499                 goto end;
 500         }
 501
 502         /* this is the first time */
 503         if (tscm->dev_lock_count++ == 0)
 504                 snd_tscm_stream_lock_changed(tscm);
 505         err = 0;
 506 end:
 507         spin_unlock_irq(&tscm->lock);
 508         return err;
 509 }
 510
 511 void snd_tscm_stream_lock_release(struct snd_tscm *tscm)
 512 {
 513         spin_lock_irq(&tscm->lock);
 514
 515         if (WARN_ON(tscm->dev_lock_count <= 0))
 516                 goto end;
 517         if (--tscm->dev_lock_count == 0)
 518                 snd_tscm_stream_lock_changed(tscm);
 519 end:
 520         spin_unlock_irq(&tscm->lock);
 521 }