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