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
  14 const unsigned int snd_dice_rates[SND_DICE_RATES_COUNT] = {
  15         /* mode 0 */
  16         [0] =  32000,
  17         [1] =  44100,
  18         [2] =  48000,
  19         /* mode 1 */
  20         [3] =  88200,
  21         [4] =  96000,
  22         /* mode 2 */
  23         [5] = 176400,
  24         [6] = 192000,
  25 };
  26
  27 int snd_dice_stream_get_rate_mode(struct snd_dice *dice, unsigned int rate,
  28                                   unsigned int *mode)
  29 {
  30         int i;
  31
  32         for (i = 0; i < ARRAY_SIZE(snd_dice_rates); i++) {
  33                 if (!(dice->clock_caps & BIT(i)))
  34                         continue;
  35                 if (snd_dice_rates[i] != rate)
  36                         continue;
  37
  38                 *mode = (i - 1) / 2;
  39                 return 0;
  40         }
  41         return -EINVAL;
  42 }
  43
  44 static void release_resources(struct snd_dice *dice,
  45                               struct fw_iso_resources *resources)
  46 {
  47         unsigned int channel;
  48
  49         /* Reset channel number */
  50         channel = cpu_to_be32((u32)-1);
  51         if (resources == &dice->tx_resources)
  52                 snd_dice_transaction_write_tx(dice, TX_ISOCHRONOUS,
  53                                               &channel, 4);
  54         else
  55                 snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
  56                                               &channel, 4);
  57
  58         fw_iso_resources_free(resources);
  59 }
  60
  61 static int keep_resources(struct snd_dice *dice,
  62                           struct fw_iso_resources *resources,
  63                           unsigned int max_payload_bytes)
  64 {
  65         unsigned int channel;
  66         int err;
  67
  68         err = fw_iso_resources_allocate(resources, max_payload_bytes,
  69                                 fw_parent_device(dice->unit)->max_speed);
  70         if (err < 0)
  71                 goto end;
  72
  73         /* Set channel number */
  74         channel = cpu_to_be32(resources->channel);
  75         if (resources == &dice->tx_resources)
  76                 err = snd_dice_transaction_write_tx(dice, TX_ISOCHRONOUS,
  77                                                     &channel, 4);
  78         else
  79                 err = snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
  80                                                     &channel, 4);
  81         if (err < 0)
  82                 release_resources(dice, resources);
  83 end:
  84         return err;
  85 }
  86
  87 static void stop_stream(struct snd_dice *dice, struct amdtp_stream *stream)
  88 {
  89         amdtp_stream_pcm_abort(stream);
  90         amdtp_stream_stop(stream);
  91
  92         if (stream == &dice->tx_stream)
  93                 release_resources(dice, &dice->tx_resources);
  94         else
  95                 release_resources(dice, &dice->rx_resources);
  96 }
  97
  98 static int start_stream(struct snd_dice *dice, struct amdtp_stream *stream,
  99                         unsigned int rate)
 100 {
 101         struct fw_iso_resources *resources;
 102         unsigned int i, mode, pcm_chs, midi_ports;
 103         bool double_pcm_frames;
 104         int err;
 105
 106         err = snd_dice_stream_get_rate_mode(dice, rate, &mode);
 107         if (err < 0)
 108                 goto end;
 109         if (stream == &dice->tx_stream) {
 110                 resources = &dice->tx_resources;
 111                 pcm_chs = dice->tx_channels[mode];
 112                 midi_ports = dice->tx_midi_ports[mode];
 113         } else {
 114                 resources = &dice->rx_resources;
 115                 pcm_chs = dice->rx_channels[mode];
 116                 midi_ports = dice->rx_midi_ports[mode];
 117         }
 118
 119         /*
 120          * At 176.4/192.0 kHz, Dice has a quirk to transfer two PCM frames in
 121          * one data block of AMDTP packet. Thus sampling transfer frequency is
 122          * a half of PCM sampling frequency, i.e. PCM frames at 192.0 kHz are
 123          * transferred on AMDTP packets at 96 kHz. Two successive samples of a
 124          * channel are stored consecutively in the packet. This quirk is called
 125          * as 'Dual Wire'.
 126          * For this quirk, blocking mode is required and PCM buffer size should
 127          * be aligned to SYT_INTERVAL.
 128          */
 129         double_pcm_frames = mode > 1;
 130         if (double_pcm_frames) {
 131                 rate /= 2;
 132                 pcm_chs *= 2;
 133         }
 134
 135         err = amdtp_am824_set_parameters(stream, rate, pcm_chs, midi_ports,
 136                                          double_pcm_frames);
 137         if (err < 0)
 138                 goto end;
 139
 140         if (double_pcm_frames) {
 141                 pcm_chs /= 2;
 142
 143                 for (i = 0; i < pcm_chs; i++) {
 144                         stream->pcm_positions[i] = i * 2;
 145                         stream->pcm_positions[i + pcm_chs] = i * 2 + 1;
 146                 }
 147         }
 148
 149         err = keep_resources(dice, resources,
 150                              amdtp_stream_get_max_payload(stream));
 151         if (err < 0) {
 152                 dev_err(&dice->unit->device,
 153                         "fail to keep isochronous resources\n");
 154                 goto end;
 155         }
 156
 157         err = amdtp_stream_start(stream, resources->channel,
 158                                  fw_parent_device(dice->unit)->max_speed);
 159         if (err < 0)
 160                 release_resources(dice, resources);
 161 end:
 162         return err;
 163 }
 164
 165 static int get_sync_mode(struct snd_dice *dice, enum cip_flags *sync_mode)
 166 {
 167         u32 source;
 168         int err;
 169
 170         err = snd_dice_transaction_get_clock_source(dice, &source);
 171         if (err < 0)
 172                 goto end;
 173
 174         switch (source) {
 175         /* So-called 'SYT Match' modes, sync_to_syt value of packets received */
 176         case CLOCK_SOURCE_ARX4: /* in 4th stream */
 177         case CLOCK_SOURCE_ARX3: /* in 3rd stream */
 178         case CLOCK_SOURCE_ARX2: /* in 2nd stream */
 179                 err = -ENOSYS;
 180                 break;
 181         case CLOCK_SOURCE_ARX1: /* in 1st stream, which this driver uses */
 182                 *sync_mode = 0;
 183                 break;
 184         default:
 185                 *sync_mode = CIP_SYNC_TO_DEVICE;
 186                 break;
 187         }
 188 end:
 189         return err;
 190 }
 191
 192 int snd_dice_stream_start_duplex(struct snd_dice *dice, unsigned int rate)
 193 {
 194         struct amdtp_stream *master, *slave;
 195         unsigned int curr_rate;
 196         enum cip_flags sync_mode;
 197         int err = 0;
 198
 199         if (dice->substreams_counter == 0)
 200                 goto end;
 201
 202         err = get_sync_mode(dice, &sync_mode);
 203         if (err < 0)
 204                 goto end;
 205         if (sync_mode == CIP_SYNC_TO_DEVICE) {
 206                 master = &dice->tx_stream;
 207                 slave  = &dice->rx_stream;
 208         } else {
 209                 master = &dice->rx_stream;
 210                 slave  = &dice->tx_stream;
 211         }
 212
 213         /* Some packet queueing errors. */
 214         if (amdtp_streaming_error(master) || amdtp_streaming_error(slave))
 215                 stop_stream(dice, master);
 216
 217         /* Stop stream if rate is different. */
 218         err = snd_dice_transaction_get_rate(dice, &curr_rate);
 219         if (err < 0) {
 220                 dev_err(&dice->unit->device,
 221                         "fail to get sampling rate\n");
 222                 goto end;
 223         }
 224         if (rate == 0)
 225                 rate = curr_rate;
 226         if (rate != curr_rate)
 227                 stop_stream(dice, master);
 228
 229         if (!amdtp_stream_running(master)) {
 230                 stop_stream(dice, slave);
 231                 snd_dice_transaction_clear_enable(dice);
 232
 233                 amdtp_stream_set_sync(sync_mode, master, slave);
 234
 235                 err = snd_dice_transaction_set_rate(dice, rate);
 236                 if (err < 0) {
 237                         dev_err(&dice->unit->device,
 238                                 "fail to set sampling rate\n");
 239                         goto end;
 240                 }
 241
 242                 /* Start both streams. */
 243                 err = start_stream(dice, master, rate);
 244                 if (err < 0) {
 245                         dev_err(&dice->unit->device,
 246                                 "fail to start AMDTP master stream\n");
 247                         goto end;
 248                 }
 249                 err = start_stream(dice, slave, rate);
 250                 if (err < 0) {
 251                         dev_err(&dice->unit->device,
 252                                 "fail to start AMDTP slave stream\n");
 253                         stop_stream(dice, master);
 254                         goto end;
 255                 }
 256                 err = snd_dice_transaction_set_enable(dice);
 257                 if (err < 0) {
 258                         dev_err(&dice->unit->device,
 259                                 "fail to enable interface\n");
 260                         stop_stream(dice, master);
 261                         stop_stream(dice, slave);
 262                         goto end;
 263                 }
 264
 265                 /* Wait first callbacks */
 266                 if (!amdtp_stream_wait_callback(master, CALLBACK_TIMEOUT) ||
 267                     !amdtp_stream_wait_callback(slave, CALLBACK_TIMEOUT)) {
 268                         snd_dice_transaction_clear_enable(dice);
 269                         stop_stream(dice, master);
 270                         stop_stream(dice, slave);
 271                         err = -ETIMEDOUT;
 272                 }
 273         }
 274 end:
 275         return err;
 276 }
 277
 278 void snd_dice_stream_stop_duplex(struct snd_dice *dice)
 279 {
 280         if (dice->substreams_counter > 0)
 281                 return;
 282
 283         snd_dice_transaction_clear_enable(dice);
 284
 285         stop_stream(dice, &dice->tx_stream);
 286         stop_stream(dice, &dice->rx_stream);
 287 }
 288
 289 static int init_stream(struct snd_dice *dice, struct amdtp_stream *stream)
 290 {
 291         int err;
 292         struct fw_iso_resources *resources;
 293         enum amdtp_stream_direction dir;
 294
 295         if (stream == &dice->tx_stream) {
 296                 resources = &dice->tx_resources;
 297                 dir = AMDTP_IN_STREAM;
 298         } else {
 299                 resources = &dice->rx_resources;
 300                 dir = AMDTP_OUT_STREAM;
 301         }
 302
 303         err = fw_iso_resources_init(resources, dice->unit);
 304         if (err < 0)
 305                 goto end;
 306         resources->channels_mask = 0x00000000ffffffffuLL;
 307
 308         err = amdtp_am824_init(stream, dice->unit, dir, CIP_BLOCKING);
 309         if (err < 0) {
 310                 amdtp_stream_destroy(stream);
 311                 fw_iso_resources_destroy(resources);
 312         }
 313 end:
 314         return err;
 315 }
 316
 317 /*
 318  * This function should be called before starting streams or after stopping
 319  * streams.
 320  */
 321 static void destroy_stream(struct snd_dice *dice, struct amdtp_stream *stream)
 322 {
 323         struct fw_iso_resources *resources;
 324
 325         if (stream == &dice->tx_stream)
 326                 resources = &dice->tx_resources;
 327         else
 328                 resources = &dice->rx_resources;
 329
 330         amdtp_stream_destroy(stream);
 331         fw_iso_resources_destroy(resources);
 332 }
 333
 334 int snd_dice_stream_init_duplex(struct snd_dice *dice)
 335 {
 336         int err;
 337
 338         dice->substreams_counter = 0;
 339
 340         err = init_stream(dice, &dice->tx_stream);
 341         if (err < 0)
 342                 goto end;
 343
 344         err = init_stream(dice, &dice->rx_stream);
 345         if (err < 0)
 346                 destroy_stream(dice, &dice->tx_stream);
 347 end:
 348         return err;
 349 }
 350
 351 void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
 352 {
 353         snd_dice_transaction_clear_enable(dice);
 354
 355         destroy_stream(dice, &dice->tx_stream);
 356         destroy_stream(dice, &dice->rx_stream);
 357
 358         dice->substreams_counter = 0;
 359 }
 360
 361 void snd_dice_stream_update_duplex(struct snd_dice *dice)
 362 {
 363         /*
 364          * On a bus reset, the DICE firmware disables streaming and then goes
 365          * off contemplating its own navel for hundreds of milliseconds before
 366          * it can react to any of our attempts to reenable streaming.  This
 367          * means that we lose synchronization anyway, so we force our streams
 368          * to stop so that the application can restart them in an orderly
 369          * manner.
 370          */
 371         dice->global_enabled = false;
 372
 373         stop_stream(dice, &dice->rx_stream);
 374         stop_stream(dice, &dice->tx_stream);
 375
 376         fw_iso_resources_update(&dice->rx_resources);
 377         fw_iso_resources_update(&dice->tx_resources);
 378 }
 379
 380 static void dice_lock_changed(struct snd_dice *dice)
 381 {
 382         dice->dev_lock_changed = true;
 383         wake_up(&dice->hwdep_wait);
 384 }
 385
 386 int snd_dice_stream_lock_try(struct snd_dice *dice)
 387 {
 388         int err;
 389
 390         spin_lock_irq(&dice->lock);
 391
 392         if (dice->dev_lock_count < 0) {
 393                 err = -EBUSY;
 394                 goto out;
 395         }
 396
 397         if (dice->dev_lock_count++ == 0)
 398                 dice_lock_changed(dice);
 399         err = 0;
 400 out:
 401         spin_unlock_irq(&dice->lock);
 402         return err;
 403 }
 404
 405 void snd_dice_stream_lock_release(struct snd_dice *dice)
 406 {
 407         spin_lock_irq(&dice->lock);
 408
 409         if (WARN_ON(dice->dev_lock_count <= 0))
 410                 goto out;
 411
 412         if (--dice->dev_lock_count == 0)
 413                 dice_lock_changed(dice);
 414 out:
 415         spin_unlock_irq(&dice->lock);
 416 }