sound/firewire/dice/dice-stream.c

   1 /*
   2  * dice_stream.c - a part of driver for DICE based devices
   3  *
   4  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
   5  * Copyright (c) 2014 Takashi Sakamoto <o-takashi@sakamocchi.jp>
   6  *
   7  * Licensed under the terms of the GNU General Public License, version 2.
   8  */
   9
  10 #include "dice.h"
  11
  12 #define CALLBACK_TIMEOUT        200
  13 #define NOTIFICATION_TIMEOUT_MS (2 * MSEC_PER_SEC)
  14
  15 struct reg_params {
  16         unsigned int count;
  17         unsigned int size;
  18 };
  19
  20 const unsigned int snd_dice_rates[SND_DICE_RATES_COUNT] = {
  21         /* mode 0 */
  22         [0] =  32000,
  23         [1] =  44100,
  24         [2] =  48000,
  25         /* mode 1 */
  26         [3] =  88200,
  27         [4] =  96000,
  28         /* mode 2 */
  29         [5] = 176400,
  30         [6] = 192000,
  31 };
  32
  33 /*
  34  * This operation has an effect to synchronize GLOBAL_STATUS/GLOBAL_SAMPLE_RATE
  35  * to GLOBAL_STATUS. Especially, just after powering on, these are different.
  36  */
  37 static int ensure_phase_lock(struct snd_dice *dice)
  38 {
  39         __be32 reg, nominal;
  40         int err;
  41
  42         err = snd_dice_transaction_read_global(dice, GLOBAL_CLOCK_SELECT,
  43                                                &reg, sizeof(reg));
  44         if (err < 0)
  45                 return err;
  46
  47         if (completion_done(&dice->clock_accepted))
  48                 reinit_completion(&dice->clock_accepted);
  49
  50         err = snd_dice_transaction_write_global(dice, GLOBAL_CLOCK_SELECT,
  51                                                 &reg, sizeof(reg));
  52         if (err < 0)
  53                 return err;
  54
  55         if (wait_for_completion_timeout(&dice->clock_accepted,
  56                         msecs_to_jiffies(NOTIFICATION_TIMEOUT_MS)) == 0) {
  57                 /*
  58                  * Old versions of Dice firmware transfer no notification when
  59                  * the same clock status as current one is set. In this case,
  60                  * just check current clock status.
  61                  */
  62                 err = snd_dice_transaction_read_global(dice, GLOBAL_STATUS,
  63                                                 &nominal, sizeof(nominal));
  64                 if (err < 0)
  65                         return err;
  66                 if (!(be32_to_cpu(nominal) & STATUS_SOURCE_LOCKED))
  67                         return -ETIMEDOUT;
  68         }
  69
  70         return 0;
  71 }
  72
  73 static int get_register_params(struct snd_dice *dice,
  74                                struct reg_params *tx_params,
  75                                struct reg_params *rx_params)
  76 {
  77         __be32 reg[2];
  78         int err;
  79
  80         err = snd_dice_transaction_read_tx(dice, TX_NUMBER, reg, sizeof(reg));
  81         if (err < 0)
  82                 return err;
  83         tx_params->count =
  84                         min_t(unsigned int, be32_to_cpu(reg[0]), MAX_STREAMS);
  85         tx_params->size = be32_to_cpu(reg[1]) * 4;
  86
  87         err = snd_dice_transaction_read_rx(dice, RX_NUMBER, reg, sizeof(reg));
  88         if (err < 0)
  89                 return err;
  90         rx_params->count =
  91                         min_t(unsigned int, be32_to_cpu(reg[0]), MAX_STREAMS);
  92         rx_params->size = be32_to_cpu(reg[1]) * 4;
  93
  94         return 0;
  95 }
  96
  97 static void release_resources(struct snd_dice *dice)
  98 {
  99         unsigned int i;
 100
 101         for (i = 0; i < MAX_STREAMS; i++) {
 102                 if (amdtp_stream_running(&dice->tx_stream[i])) {
 103                         amdtp_stream_pcm_abort(&dice->tx_stream[i]);
 104                         amdtp_stream_stop(&dice->tx_stream[i]);
 105                 }
 106                 if (amdtp_stream_running(&dice->rx_stream[i])) {
 107                         amdtp_stream_pcm_abort(&dice->rx_stream[i]);
 108                         amdtp_stream_stop(&dice->rx_stream[i]);
 109                 }
 110
 111                 fw_iso_resources_free(&dice->tx_resources[i]);
 112                 fw_iso_resources_free(&dice->rx_resources[i]);
 113         }
 114 }
 115
 116 static void stop_streams(struct snd_dice *dice, enum amdtp_stream_direction dir,
 117                          struct reg_params *params)
 118 {
 119         __be32 reg;
 120         unsigned int i;
 121
 122         for (i = 0; i < params->count; i++) {
 123                 reg = cpu_to_be32((u32)-1);
 124                 if (dir == AMDTP_IN_STREAM) {
 125                         snd_dice_transaction_write_tx(dice,
 126                                         params->size * i + TX_ISOCHRONOUS,
 127                                         &reg, sizeof(reg));
 128                 } else {
 129                         snd_dice_transaction_write_rx(dice,
 130                                         params->size * i + RX_ISOCHRONOUS,
 131                                         &reg, sizeof(reg));
 132                 }
 133         }
 134 }
 135
 136 static int keep_resources(struct snd_dice *dice,
 137                           enum amdtp_stream_direction dir, unsigned int index,
 138                           unsigned int rate, unsigned int pcm_chs,
 139                           unsigned int midi_ports)
 140 {
 141         struct amdtp_stream *stream;
 142         struct fw_iso_resources *resources;
 143         bool double_pcm_frames;
 144         unsigned int i;
 145         int err;
 146
 147         if (dir == AMDTP_IN_STREAM) {
 148                 stream = &dice->tx_stream[index];
 149                 resources = &dice->tx_resources[index];
 150         } else {
 151                 stream = &dice->rx_stream[index];
 152                 resources = &dice->rx_resources[index];
 153         }
 154
 155         /*
 156          * At 176.4/192.0 kHz, Dice has a quirk to transfer two PCM frames in
 157          * one data block of AMDTP packet. Thus sampling transfer frequency is
 158          * a half of PCM sampling frequency, i.e. PCM frames at 192.0 kHz are
 159          * transferred on AMDTP packets at 96 kHz. Two successive samples of a
 160          * channel are stored consecutively in the packet. This quirk is called
 161          * as 'Dual Wire'.
 162          * For this quirk, blocking mode is required and PCM buffer size should
 163          * be aligned to SYT_INTERVAL.
 164          */
 165         double_pcm_frames = rate > 96000;
 166         if (double_pcm_frames) {
 167                 rate /= 2;
 168                 pcm_chs *= 2;
 169         }
 170
 171         err = amdtp_am824_set_parameters(stream, rate, pcm_chs, midi_ports,
 172                                          double_pcm_frames);
 173         if (err < 0)
 174                 return err;
 175
 176         if (double_pcm_frames) {
 177                 pcm_chs /= 2;
 178
 179                 for (i = 0; i < pcm_chs; i++) {
 180                         amdtp_am824_set_pcm_position(stream, i, i * 2);
 181                         amdtp_am824_set_pcm_position(stream, i + pcm_chs,
 182                                                      i * 2 + 1);
 183                 }
 184         }
 185
 186         return fw_iso_resources_allocate(resources,
 187                                 amdtp_stream_get_max_payload(stream),
 188                                 fw_parent_device(dice->unit)->max_speed);
 189 }
 190
 191 static int start_streams(struct snd_dice *dice, enum amdtp_stream_direction dir,
 192                          unsigned int rate, struct reg_params *params)
 193 {
 194         __be32 reg[2];
 195         unsigned int i, pcm_chs, midi_ports;
 196         struct amdtp_stream *streams;
 197         struct fw_iso_resources *resources;
 198         struct fw_device *fw_dev = fw_parent_device(dice->unit);
 199         int err = 0;
 200
 201         if (dir == AMDTP_IN_STREAM) {
 202                 streams = dice->tx_stream;
 203                 resources = dice->tx_resources;
 204         } else {
 205                 streams = dice->rx_stream;
 206                 resources = dice->rx_resources;
 207         }
 208
 209         for (i = 0; i < params->count; i++) {
 210                 if (dir == AMDTP_IN_STREAM) {
 211                         err = snd_dice_transaction_read_tx(dice,
 212                                         params->size * i + TX_NUMBER_AUDIO,
 213                                         reg, sizeof(reg));
 214                 } else {
 215                         err = snd_dice_transaction_read_rx(dice,
 216                                         params->size * i + RX_NUMBER_AUDIO,
 217                                         reg, sizeof(reg));
 218                 }
 219                 if (err < 0)
 220                         return err;
 221                 pcm_chs = be32_to_cpu(reg[0]);
 222                 midi_ports = be32_to_cpu(reg[1]);
 223
 224                 err = keep_resources(dice, dir, i, rate, pcm_chs, midi_ports);
 225                 if (err < 0)
 226                         return err;
 227
 228                 reg[0] = cpu_to_be32(resources[i].channel);
 229                 if (dir == AMDTP_IN_STREAM) {
 230                         err = snd_dice_transaction_write_tx(dice,
 231                                         params->size * i + TX_ISOCHRONOUS,
 232                                         reg, sizeof(reg[0]));
 233                 } else {
 234                         err = snd_dice_transaction_write_rx(dice,
 235                                         params->size * i + RX_ISOCHRONOUS,
 236                                         reg, sizeof(reg[0]));
 237                 }
 238                 if (err < 0)
 239                         return err;
 240
 241                 if (dir == AMDTP_IN_STREAM) {
 242                         reg[0] = cpu_to_be32(fw_dev->max_speed);
 243                         err = snd_dice_transaction_write_tx(dice,
 244                                         params->size * i + TX_SPEED,
 245                                         reg, sizeof(reg[0]));
 246                         if (err < 0)
 247                                 return err;
 248                 }
 249
 250                 err = amdtp_stream_start(&streams[i], resources[i].channel,
 251                                          fw_dev->max_speed);
 252                 if (err < 0)
 253                         return err;
 254         }
 255
 256         return err;
 257 }
 258
 259 /*
 260  * MEMO: After this function, there're two states of streams:
 261  *  - None streams are running.
 262  *  - All streams are running.
 263  */
 264 int snd_dice_stream_start_duplex(struct snd_dice *dice, unsigned int rate)
 265 {
 266         unsigned int curr_rate;
 267         unsigned int i;
 268         struct reg_params tx_params, rx_params;
 269         bool need_to_start;
 270         int err;
 271
 272         if (dice->substreams_counter == 0)
 273                 return -EIO;
 274
 275         err = get_register_params(dice, &tx_params, &rx_params);
 276         if (err < 0)
 277                 return err;
 278
 279         err = snd_dice_transaction_get_rate(dice, &curr_rate);
 280         if (err < 0) {
 281                 dev_err(&dice->unit->device,
 282                         "fail to get sampling rate\n");
 283                 return err;
 284         }
 285         if (rate == 0)
 286                 rate = curr_rate;
 287         if (rate != curr_rate)
 288                 return -EINVAL;
 289
 290         /* Judge to need to restart streams. */
 291         for (i = 0; i < MAX_STREAMS; i++) {
 292                 if (i < tx_params.count) {
 293                         if (amdtp_streaming_error(&dice->tx_stream[i]) ||
 294                             !amdtp_stream_running(&dice->tx_stream[i]))
 295                                 break;
 296                 }
 297                 if (i < rx_params.count) {
 298                         if (amdtp_streaming_error(&dice->rx_stream[i]) ||
 299                             !amdtp_stream_running(&dice->rx_stream[i]))
 300                                 break;
 301                 }
 302         }
 303         need_to_start = (i < MAX_STREAMS);
 304
 305         if (need_to_start) {
 306                 /* Stop transmission. */
 307                 snd_dice_transaction_clear_enable(dice);
 308                 stop_streams(dice, AMDTP_IN_STREAM, &tx_params);
 309                 stop_streams(dice, AMDTP_OUT_STREAM, &rx_params);
 310                 release_resources(dice);
 311
 312                 err = ensure_phase_lock(dice);
 313                 if (err < 0) {
 314                         dev_err(&dice->unit->device,
 315                                 "fail to ensure phase lock\n");
 316                         return err;
 317                 }
 318
 319                 /* Start both streams. */
 320                 err = start_streams(dice, AMDTP_IN_STREAM, rate, &tx_params);
 321                 if (err < 0)
 322                         goto error;
 323                 err = start_streams(dice, AMDTP_OUT_STREAM, rate, &rx_params);
 324                 if (err < 0)
 325                         goto error;
 326
 327                 err = snd_dice_transaction_set_enable(dice);
 328                 if (err < 0) {
 329                         dev_err(&dice->unit->device,
 330                                 "fail to enable interface\n");
 331                         goto error;
 332                 }
 333
 334                 for (i = 0; i < MAX_STREAMS; i++) {
 335                         if ((i < tx_params.count &&
 336                             !amdtp_stream_wait_callback(&dice->tx_stream[i],
 337                                                         CALLBACK_TIMEOUT)) ||
 338                             (i < rx_params.count &&
 339                              !amdtp_stream_wait_callback(&dice->rx_stream[i],
 340                                                          CALLBACK_TIMEOUT))) {
 341                                 err = -ETIMEDOUT;
 342                                 goto error;
 343                         }
 344                 }
 345         }
 346
 347         return err;
 348 error:
 349         snd_dice_transaction_clear_enable(dice);
 350         stop_streams(dice, AMDTP_IN_STREAM, &tx_params);
 351         stop_streams(dice, AMDTP_OUT_STREAM, &rx_params);
 352         release_resources(dice);
 353         return err;
 354 }
 355
 356 /*
 357  * MEMO: After this function, there're two states of streams:
 358  *  - None streams are running.
 359  *  - All streams are running.
 360  */
 361 void snd_dice_stream_stop_duplex(struct snd_dice *dice)
 362 {
 363         struct reg_params tx_params, rx_params;
 364
 365         if (dice->substreams_counter > 0)
 366                 return;
 367
 368         snd_dice_transaction_clear_enable(dice);
 369
 370         if (get_register_params(dice, &tx_params, &rx_params) == 0) {
 371                 stop_streams(dice, AMDTP_IN_STREAM, &tx_params);
 372                 stop_streams(dice, AMDTP_OUT_STREAM, &rx_params);
 373         }
 374
 375         release_resources(dice);
 376 }
 377
 378 static int init_stream(struct snd_dice *dice, enum amdtp_stream_direction dir,
 379                        unsigned int index)
 380 {
 381         struct amdtp_stream *stream;
 382         struct fw_iso_resources *resources;
 383         int err;
 384
 385         if (dir == AMDTP_IN_STREAM) {
 386                 stream = &dice->tx_stream[index];
 387                 resources = &dice->tx_resources[index];
 388         } else {
 389                 stream = &dice->rx_stream[index];
 390                 resources = &dice->rx_resources[index];
 391         }
 392
 393         err = fw_iso_resources_init(resources, dice->unit);
 394         if (err < 0)
 395                 goto end;
 396         resources->channels_mask = 0x00000000ffffffffuLL;
 397
 398         err = amdtp_am824_init(stream, dice->unit, dir, CIP_BLOCKING);
 399         if (err < 0) {
 400                 amdtp_stream_destroy(stream);
 401                 fw_iso_resources_destroy(resources);
 402         }
 403 end:
 404         return err;
 405 }
 406
 407 /*
 408  * This function should be called before starting streams or after stopping
 409  * streams.
 410  */
 411 static void destroy_stream(struct snd_dice *dice,
 412                            enum amdtp_stream_direction dir,
 413                            unsigned int index)
 414 {
 415         struct amdtp_stream *stream;
 416         struct fw_iso_resources *resources;
 417
 418         if (dir == AMDTP_IN_STREAM) {
 419                 stream = &dice->tx_stream[index];
 420                 resources = &dice->tx_resources[index];
 421         } else {
 422                 stream = &dice->rx_stream[index];
 423                 resources = &dice->rx_resources[index];
 424         }
 425
 426         amdtp_stream_destroy(stream);
 427         fw_iso_resources_destroy(resources);
 428 }
 429
 430 int snd_dice_stream_init_duplex(struct snd_dice *dice)
 431 {
 432         int i, err;
 433
 434         for (i = 0; i < MAX_STREAMS; i++) {
 435                 err = init_stream(dice, AMDTP_IN_STREAM, i);
 436                 if (err < 0) {
 437                         for (; i >= 0; i--)
 438                                 destroy_stream(dice, AMDTP_OUT_STREAM, i);
 439                         goto end;
 440                 }
 441         }
 442
 443         for (i = 0; i < MAX_STREAMS; i++) {
 444                 err = init_stream(dice, AMDTP_OUT_STREAM, i);
 445                 if (err < 0) {
 446                         for (; i >= 0; i--)
 447                                 destroy_stream(dice, AMDTP_OUT_STREAM, i);
 448                         for (i = 0; i < MAX_STREAMS; i++)
 449                                 destroy_stream(dice, AMDTP_IN_STREAM, i);
 450                         break;
 451                 }
 452         }
 453 end:
 454         return err;
 455 }
 456
 457 void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
 458 {
 459         unsigned int i;
 460
 461         for (i = 0; i < MAX_STREAMS; i++) {
 462                 destroy_stream(dice, AMDTP_IN_STREAM, i);
 463                 destroy_stream(dice, AMDTP_OUT_STREAM, i);
 464         }
 465 }
 466
 467 void snd_dice_stream_update_duplex(struct snd_dice *dice)
 468 {
 469         struct reg_params tx_params, rx_params;
 470
 471         /*
 472          * On a bus reset, the DICE firmware disables streaming and then goes
 473          * off contemplating its own navel for hundreds of milliseconds before
 474          * it can react to any of our attempts to reenable streaming.  This
 475          * means that we lose synchronization anyway, so we force our streams
 476          * to stop so that the application can restart them in an orderly
 477          * manner.
 478          */
 479         dice->global_enabled = false;
 480
 481         if (get_register_params(dice, &tx_params, &rx_params) == 0) {
 482                 stop_streams(dice, AMDTP_IN_STREAM, &tx_params);
 483                 stop_streams(dice, AMDTP_OUT_STREAM, &rx_params);
 484         }
 485 }
 486
 487 static void dice_lock_changed(struct snd_dice *dice)
 488 {
 489         dice->dev_lock_changed = true;
 490         wake_up(&dice->hwdep_wait);
 491 }
 492
 493 int snd_dice_stream_lock_try(struct snd_dice *dice)
 494 {
 495         int err;
 496
 497         spin_lock_irq(&dice->lock);
 498
 499         if (dice->dev_lock_count < 0) {
 500                 err = -EBUSY;
 501                 goto out;
 502         }
 503
 504         if (dice->dev_lock_count++ == 0)
 505                 dice_lock_changed(dice);
 506         err = 0;
 507 out:
 508         spin_unlock_irq(&dice->lock);
 509         return err;
 510 }
 511
 512 void snd_dice_stream_lock_release(struct snd_dice *dice)
 513 {
 514         spin_lock_irq(&dice->lock);
 515
 516         if (WARN_ON(dice->dev_lock_count <= 0))
 517                 goto out;
 518
 519         if (--dice->dev_lock_count == 0)
 520                 dice_lock_changed(dice);
 521 out:
 522         spin_unlock_irq(&dice->lock);
 523 }