kernel/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         __be32 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, sizeof(channel));
  54         else
  55                 snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
  56                                               &channel, sizeof(channel));
  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         __be32 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, sizeof(channel));
  78         else
  79                 err = snd_dice_transaction_write_rx(dice, RX_ISOCHRONOUS,
  80                                                     &channel, sizeof(channel));
  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                         amdtp_am824_set_pcm_position(stream, i, i * 2);
 145                         amdtp_am824_set_pcm_position(stream, i + pcm_chs,
 146                                                      i * 2 + 1);
 147                 }
 148         }
 149
 150         err = keep_resources(dice, resources,
 151                              amdtp_stream_get_max_payload(stream));
 152         if (err < 0) {
 153                 dev_err(&dice->unit->device,
 154                         "fail to keep isochronous resources\n");
 155                 goto end;
 156         }
 157
 158         err = amdtp_stream_start(stream, resources->channel,
 159                                  fw_parent_device(dice->unit)->max_speed);
 160         if (err < 0)
 161                 release_resources(dice, resources);
 162 end:
 163         return err;
 164 }
 165
 166 static int get_sync_mode(struct snd_dice *dice, enum cip_flags *sync_mode)
 167 {
 168         u32 source;
 169         int err;
 170
 171         err = snd_dice_transaction_get_clock_source(dice, &source);
 172         if (err < 0)
 173                 goto end;
 174
 175         switch (source) {
 176         /* So-called 'SYT Match' modes, sync_to_syt value of packets received */
 177         case CLOCK_SOURCE_ARX4: /* in 4th stream */
 178         case CLOCK_SOURCE_ARX3: /* in 3rd stream */
 179         case CLOCK_SOURCE_ARX2: /* in 2nd stream */
 180                 err = -ENOSYS;
 181                 break;
 182         case CLOCK_SOURCE_ARX1: /* in 1st stream, which this driver uses */
 183                 *sync_mode = 0;
 184                 break;
 185         default:
 186                 *sync_mode = CIP_SYNC_TO_DEVICE;
 187                 break;
 188         }
 189 end:
 190         return err;
 191 }
 192
 193 int snd_dice_stream_start_duplex(struct snd_dice *dice, unsigned int rate)
 194 {
 195         struct amdtp_stream *master, *slave;
 196         unsigned int curr_rate;
 197         enum cip_flags sync_mode;
 198         int err = 0;
 199
 200         if (dice->substreams_counter == 0)
 201                 goto end;
 202
 203         err = get_sync_mode(dice, &sync_mode);
 204         if (err < 0)
 205                 goto end;
 206         if (sync_mode == CIP_SYNC_TO_DEVICE) {
 207                 master = &dice->tx_stream;
 208                 slave  = &dice->rx_stream;
 209         } else {
 210                 master = &dice->rx_stream;
 211                 slave  = &dice->tx_stream;
 212         }
 213
 214         /* Some packet queueing errors. */
 215         if (amdtp_streaming_error(master) || amdtp_streaming_error(slave))
 216                 stop_stream(dice, master);
 217
 218         /* Stop stream if rate is different. */
 219         err = snd_dice_transaction_get_rate(dice, &curr_rate);
 220         if (err < 0) {
 221                 dev_err(&dice->unit->device,
 222                         "fail to get sampling rate\n");
 223                 goto end;
 224         }
 225         if (rate == 0)
 226                 rate = curr_rate;
 227         if (rate != curr_rate)
 228                 stop_stream(dice, master);
 229
 230         if (!amdtp_stream_running(master)) {
 231                 stop_stream(dice, slave);
 232                 snd_dice_transaction_clear_enable(dice);
 233
 234                 amdtp_stream_set_sync(sync_mode, master, slave);
 235
 236                 err = snd_dice_transaction_set_rate(dice, rate);
 237                 if (err < 0) {
 238                         dev_err(&dice->unit->device,
 239                                 "fail to set sampling rate\n");
 240                         goto end;
 241                 }
 242
 243                 /* Start both streams. */
 244                 err = start_stream(dice, master, rate);
 245                 if (err < 0) {
 246                         dev_err(&dice->unit->device,
 247                                 "fail to start AMDTP master stream\n");
 248                         goto end;
 249                 }
 250                 err = start_stream(dice, slave, rate);
 251                 if (err < 0) {
 252                         dev_err(&dice->unit->device,
 253                                 "fail to start AMDTP slave stream\n");
 254                         stop_stream(dice, master);
 255                         goto end;
 256                 }
 257                 err = snd_dice_transaction_set_enable(dice);
 258                 if (err < 0) {
 259                         dev_err(&dice->unit->device,
 260                                 "fail to enable interface\n");
 261                         stop_stream(dice, master);
 262                         stop_stream(dice, slave);
 263                         goto end;
 264                 }
 265
 266                 /* Wait first callbacks */
 267                 if (!amdtp_stream_wait_callback(master, CALLBACK_TIMEOUT) ||
 268                     !amdtp_stream_wait_callback(slave, CALLBACK_TIMEOUT)) {
 269                         snd_dice_transaction_clear_enable(dice);
 270                         stop_stream(dice, master);
 271                         stop_stream(dice, slave);
 272                         err = -ETIMEDOUT;
 273                 }
 274         }
 275 end:
 276         return err;
 277 }
 278
 279 void snd_dice_stream_stop_duplex(struct snd_dice *dice)
 280 {
 281         if (dice->substreams_counter > 0)
 282                 return;
 283
 284         snd_dice_transaction_clear_enable(dice);
 285
 286         stop_stream(dice, &dice->tx_stream);
 287         stop_stream(dice, &dice->rx_stream);
 288 }
 289
 290 static int init_stream(struct snd_dice *dice, struct amdtp_stream *stream)
 291 {
 292         int err;
 293         struct fw_iso_resources *resources;
 294         enum amdtp_stream_direction dir;
 295
 296         if (stream == &dice->tx_stream) {
 297                 resources = &dice->tx_resources;
 298                 dir = AMDTP_IN_STREAM;
 299         } else {
 300                 resources = &dice->rx_resources;
 301                 dir = AMDTP_OUT_STREAM;
 302         }
 303
 304         err = fw_iso_resources_init(resources, dice->unit);
 305         if (err < 0)
 306                 goto end;
 307         resources->channels_mask = 0x00000000ffffffffuLL;
 308
 309         err = amdtp_am824_init(stream, dice->unit, dir, CIP_BLOCKING);
 310         if (err < 0) {
 311                 amdtp_stream_destroy(stream);
 312                 fw_iso_resources_destroy(resources);
 313         }
 314 end:
 315         return err;
 316 }
 317
 318 /*
 319  * This function should be called before starting streams or after stopping
 320  * streams.
 321  */
 322 static void destroy_stream(struct snd_dice *dice, struct amdtp_stream *stream)
 323 {
 324         struct fw_iso_resources *resources;
 325
 326         if (stream == &dice->tx_stream)
 327                 resources = &dice->tx_resources;
 328         else
 329                 resources = &dice->rx_resources;
 330
 331         amdtp_stream_destroy(stream);
 332         fw_iso_resources_destroy(resources);
 333 }
 334
 335 int snd_dice_stream_init_duplex(struct snd_dice *dice)
 336 {
 337         int err;
 338
 339         dice->substreams_counter = 0;
 340
 341         err = init_stream(dice, &dice->tx_stream);
 342         if (err < 0)
 343                 goto end;
 344
 345         err = init_stream(dice, &dice->rx_stream);
 346         if (err < 0)
 347                 destroy_stream(dice, &dice->tx_stream);
 348 end:
 349         return err;
 350 }
 351
 352 void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
 353 {
 354         snd_dice_transaction_clear_enable(dice);
 355
 356         destroy_stream(dice, &dice->tx_stream);
 357         destroy_stream(dice, &dice->rx_stream);
 358
 359         dice->substreams_counter = 0;
 360 }
 361
 362 void snd_dice_stream_update_duplex(struct snd_dice *dice)
 363 {
 364         /*
 365          * On a bus reset, the DICE firmware disables streaming and then goes
 366          * off contemplating its own navel for hundreds of milliseconds before
 367          * it can react to any of our attempts to reenable streaming.  This
 368          * means that we lose synchronization anyway, so we force our streams
 369          * to stop so that the application can restart them in an orderly
 370          * manner.
 371          */
 372         dice->global_enabled = false;
 373
 374         stop_stream(dice, &dice->rx_stream);
 375         stop_stream(dice, &dice->tx_stream);
 376
 377         fw_iso_resources_update(&dice->rx_resources);
 378         fw_iso_resources_update(&dice->tx_resources);
 379 }
 380
 381 static void dice_lock_changed(struct snd_dice *dice)
 382 {
 383         dice->dev_lock_changed = true;
 384         wake_up(&dice->hwdep_wait);
 385 }
 386
 387 int snd_dice_stream_lock_try(struct snd_dice *dice)
 388 {
 389         int err;
 390
 391         spin_lock_irq(&dice->lock);
 392
 393         if (dice->dev_lock_count < 0) {
 394                 err = -EBUSY;
 395                 goto out;
 396         }
 397
 398         if (dice->dev_lock_count++ == 0)
 399                 dice_lock_changed(dice);
 400         err = 0;
 401 out:
 402         spin_unlock_irq(&dice->lock);
 403         return err;
 404 }
 405
 406 void snd_dice_stream_lock_release(struct snd_dice *dice)
 407 {
 408         spin_lock_irq(&dice->lock);
 409
 410         if (WARN_ON(dice->dev_lock_count <= 0))
 411                 goto out;
 412
 413         if (--dice->dev_lock_count == 0)
 414                 dice_lock_changed(dice);
 415 out:
 416         spin_unlock_irq(&dice->lock);
 417 }