sound/firewire/digi00x/digi00x-stream.c

   1 /*
   2  * digi00x-stream.c - a part of driver for Digidesign Digi 002/003 family
   3  *
   4  * Copyright (c) 2014-2015 Takashi Sakamoto
   5  *
   6  * Licensed under the terms of the GNU General Public License, version 2.
   7  */
   8
   9 #include "digi00x.h"
  10
  11 #define CALLBACK_TIMEOUT 500
  12
  13 const unsigned int snd_dg00x_stream_rates[SND_DG00X_RATE_COUNT] = {
  14         [SND_DG00X_RATE_44100] = 44100,
  15         [SND_DG00X_RATE_48000] = 48000,
  16         [SND_DG00X_RATE_88200] = 88200,
  17         [SND_DG00X_RATE_96000] = 96000,
  18 };
  19
  20 /* Multi Bit Linear Audio data channels for each sampling transfer frequency. */
  21 const unsigned int
  22 snd_dg00x_stream_pcm_channels[SND_DG00X_RATE_COUNT] = {
  23         /* Analog/ADAT/SPDIF */
  24         [SND_DG00X_RATE_44100] = (8 + 8 + 2),
  25         [SND_DG00X_RATE_48000] = (8 + 8 + 2),
  26         /* Analog/SPDIF */
  27         [SND_DG00X_RATE_88200] = (8 + 2),
  28         [SND_DG00X_RATE_96000] = (8 + 2),
  29 };
  30
  31 int snd_dg00x_stream_get_local_rate(struct snd_dg00x *dg00x, unsigned int *rate)
  32 {
  33         u32 data;
  34         __be32 reg;
  35         int err;
  36
  37         err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
  38                                  DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
  39                                  &reg, sizeof(reg), 0);
  40         if (err < 0)
  41                 return err;
  42
  43         data = be32_to_cpu(reg) & 0x0f;
  44         if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
  45                 *rate = snd_dg00x_stream_rates[data];
  46         else
  47                 err = -EIO;
  48
  49         return err;
  50 }
  51
  52 int snd_dg00x_stream_set_local_rate(struct snd_dg00x *dg00x, unsigned int rate)
  53 {
  54         __be32 reg;
  55         unsigned int i;
  56
  57         for (i = 0; i < ARRAY_SIZE(snd_dg00x_stream_rates); i++) {
  58                 if (rate == snd_dg00x_stream_rates[i])
  59                         break;
  60         }
  61         if (i == ARRAY_SIZE(snd_dg00x_stream_rates))
  62                 return -EINVAL;
  63
  64         reg = cpu_to_be32(i);
  65         return snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
  66                                   DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
  67                                   &reg, sizeof(reg), 0);
  68 }
  69
  70 int snd_dg00x_stream_get_clock(struct snd_dg00x *dg00x,
  71                                enum snd_dg00x_clock *clock)
  72 {
  73         __be32 reg;
  74         int err;
  75
  76         err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
  77                                  DG00X_ADDR_BASE + DG00X_OFFSET_CLOCK_SOURCE,
  78                                  &reg, sizeof(reg), 0);
  79         if (err < 0)
  80                 return err;
  81
  82         *clock = be32_to_cpu(reg) & 0x0f;
  83         if (*clock >= SND_DG00X_CLOCK_COUNT)
  84                 err = -EIO;
  85
  86         return err;
  87 }
  88
  89 int snd_dg00x_stream_check_external_clock(struct snd_dg00x *dg00x, bool *detect)
  90 {
  91         __be32 reg;
  92         int err;
  93
  94         err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
  95                                  DG00X_ADDR_BASE + DG00X_OFFSET_DETECT_EXTERNAL,
  96                                  &reg, sizeof(reg), 0);
  97         if (err >= 0)
  98                 *detect = be32_to_cpu(reg) > 0;
  99
 100         return err;
 101 }
 102
 103 int snd_dg00x_stream_get_external_rate(struct snd_dg00x *dg00x,
 104                                        unsigned int *rate)
 105 {
 106         u32 data;
 107         __be32 reg;
 108         int err;
 109
 110         err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
 111                                  DG00X_ADDR_BASE + DG00X_OFFSET_EXTERNAL_RATE,
 112                                  &reg, sizeof(reg), 0);
 113         if (err < 0)
 114                 return err;
 115
 116         data = be32_to_cpu(reg) & 0x0f;
 117         if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
 118                 *rate = snd_dg00x_stream_rates[data];
 119         /* This means desync. */
 120         else
 121                 err = -EBUSY;
 122
 123         return err;
 124 }
 125
 126 static void finish_session(struct snd_dg00x *dg00x)
 127 {
 128         __be32 data = cpu_to_be32(0x00000003);
 129
 130         snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
 131                            DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_SET,
 132                            &data, sizeof(data), 0);
 133 }
 134
 135 static int begin_session(struct snd_dg00x *dg00x)
 136 {
 137         __be32 data;
 138         u32 curr;
 139         int err;
 140
 141         err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
 142                                  DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_STATE,
 143                                  &data, sizeof(data), 0);
 144         if (err < 0)
 145                 goto error;
 146         curr = be32_to_cpu(data);
 147
 148         if (curr == 0)
 149                 curr = 2;
 150
 151         curr--;
 152         while (curr > 0) {
 153                 data = cpu_to_be32(curr);
 154                 err = snd_fw_transaction(dg00x->unit,
 155                                          TCODE_WRITE_QUADLET_REQUEST,
 156                                          DG00X_ADDR_BASE +
 157                                          DG00X_OFFSET_STREAMING_SET,
 158                                          &data, sizeof(data), 0);
 159                 if (err < 0)
 160                         goto error;
 161
 162                 msleep(20);
 163                 curr--;
 164         }
 165
 166         return 0;
 167 error:
 168         finish_session(dg00x);
 169         return err;
 170 }
 171
 172 static void release_resources(struct snd_dg00x *dg00x)
 173 {
 174         __be32 data = 0;
 175
 176         /* Unregister isochronous channels for both direction. */
 177         snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
 178                            DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
 179                            &data, sizeof(data), 0);
 180
 181         /* Release isochronous resources. */
 182         fw_iso_resources_free(&dg00x->tx_resources);
 183         fw_iso_resources_free(&dg00x->rx_resources);
 184 }
 185
 186 static int keep_resources(struct snd_dg00x *dg00x, unsigned int rate)
 187 {
 188         unsigned int i;
 189         __be32 data;
 190         int err;
 191
 192         /* Check sampling rate. */
 193         for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
 194                 if (snd_dg00x_stream_rates[i] == rate)
 195                         break;
 196         }
 197         if (i == SND_DG00X_RATE_COUNT)
 198                 return -EINVAL;
 199
 200         /* Keep resources for out-stream. */
 201         err = amdtp_dot_set_parameters(&dg00x->rx_stream, rate,
 202                                        snd_dg00x_stream_pcm_channels[i]);
 203         if (err < 0)
 204                 return err;
 205         err = fw_iso_resources_allocate(&dg00x->rx_resources,
 206                                 amdtp_stream_get_max_payload(&dg00x->rx_stream),
 207                                 fw_parent_device(dg00x->unit)->max_speed);
 208         if (err < 0)
 209                 return err;
 210
 211         /* Keep resources for in-stream. */
 212         err = amdtp_dot_set_parameters(&dg00x->tx_stream, rate,
 213                                        snd_dg00x_stream_pcm_channels[i]);
 214         if (err < 0)
 215                 return err;
 216         err = fw_iso_resources_allocate(&dg00x->tx_resources,
 217                                 amdtp_stream_get_max_payload(&dg00x->tx_stream),
 218                                 fw_parent_device(dg00x->unit)->max_speed);
 219         if (err < 0)
 220                 goto error;
 221
 222         /* Register isochronous channels for both direction. */
 223         data = cpu_to_be32((dg00x->tx_resources.channel << 16) |
 224                            dg00x->rx_resources.channel);
 225         err = snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
 226                                  DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
 227                                  &data, sizeof(data), 0);
 228         if (err < 0)
 229                 goto error;
 230
 231         return 0;
 232 error:
 233         release_resources(dg00x);
 234         return err;
 235 }
 236
 237 int snd_dg00x_stream_init_duplex(struct snd_dg00x *dg00x)
 238 {
 239         int err;
 240
 241         /* For out-stream. */
 242         err = fw_iso_resources_init(&dg00x->rx_resources, dg00x->unit);
 243         if (err < 0)
 244                 goto error;
 245         err = amdtp_dot_init(&dg00x->rx_stream, dg00x->unit, AMDTP_OUT_STREAM);
 246         if (err < 0)
 247                 goto error;
 248
 249         /* For in-stream. */
 250         err = fw_iso_resources_init(&dg00x->tx_resources, dg00x->unit);
 251         if (err < 0)
 252                 goto error;
 253         err = amdtp_dot_init(&dg00x->tx_stream, dg00x->unit, AMDTP_IN_STREAM);
 254         if (err < 0)
 255                 goto error;
 256
 257         return 0;
 258 error:
 259         snd_dg00x_stream_destroy_duplex(dg00x);
 260         return err;
 261 }
 262
 263 /*
 264  * This function should be called before starting streams or after stopping
 265  * streams.
 266  */
 267 void snd_dg00x_stream_destroy_duplex(struct snd_dg00x *dg00x)
 268 {
 269         amdtp_stream_destroy(&dg00x->rx_stream);
 270         fw_iso_resources_destroy(&dg00x->rx_resources);
 271
 272         amdtp_stream_destroy(&dg00x->tx_stream);
 273         fw_iso_resources_destroy(&dg00x->tx_resources);
 274 }
 275
 276 int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x, unsigned int rate)
 277 {
 278         unsigned int curr_rate;
 279         int err = 0;
 280
 281         if (dg00x->substreams_counter == 0)
 282                 goto end;
 283
 284         /* Check current sampling rate. */
 285         err = snd_dg00x_stream_get_local_rate(dg00x, &curr_rate);
 286         if (err < 0)
 287                 goto error;
 288         if (rate == 0)
 289                 rate = curr_rate;
 290         if (curr_rate != rate ||
 291             amdtp_streaming_error(&dg00x->tx_stream) ||
 292             amdtp_streaming_error(&dg00x->rx_stream)) {
 293                 finish_session(dg00x);
 294
 295                 amdtp_stream_stop(&dg00x->tx_stream);
 296                 amdtp_stream_stop(&dg00x->rx_stream);
 297                 release_resources(dg00x);
 298         }
 299
 300         /*
 301          * No packets are transmitted without receiving packets, reagardless of
 302          * which source of clock is used.
 303          */
 304         if (!amdtp_stream_running(&dg00x->rx_stream)) {
 305                 err = snd_dg00x_stream_set_local_rate(dg00x, rate);
 306                 if (err < 0)
 307                         goto error;
 308
 309                 err = keep_resources(dg00x, rate);
 310                 if (err < 0)
 311                         goto error;
 312
 313                 err = begin_session(dg00x);
 314                 if (err < 0)
 315                         goto error;
 316
 317                 err = amdtp_stream_start(&dg00x->rx_stream,
 318                                 dg00x->rx_resources.channel,
 319                                 fw_parent_device(dg00x->unit)->max_speed);
 320                 if (err < 0)
 321                         goto error;
 322
 323                 if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
 324                                               CALLBACK_TIMEOUT)) {
 325                         err = -ETIMEDOUT;
 326                         goto error;
 327                 }
 328         }
 329
 330         /*
 331          * The value of SYT field in transmitted packets is always 0x0000. Thus,
 332          * duplex streams with timestamp synchronization cannot be built.
 333          */
 334         if (!amdtp_stream_running(&dg00x->tx_stream)) {
 335                 err = amdtp_stream_start(&dg00x->tx_stream,
 336                                 dg00x->tx_resources.channel,
 337                                 fw_parent_device(dg00x->unit)->max_speed);
 338                 if (err < 0)
 339                         goto error;
 340
 341                 if (!amdtp_stream_wait_callback(&dg00x->tx_stream,
 342                                               CALLBACK_TIMEOUT)) {
 343                         err = -ETIMEDOUT;
 344                         goto error;
 345                 }
 346         }
 347 end:
 348         return err;
 349 error:
 350         finish_session(dg00x);
 351
 352         amdtp_stream_stop(&dg00x->tx_stream);
 353         amdtp_stream_stop(&dg00x->rx_stream);
 354         release_resources(dg00x);
 355
 356         return err;
 357 }
 358
 359 void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
 360 {
 361         if (dg00x->substreams_counter > 0)
 362                 return;
 363
 364         amdtp_stream_stop(&dg00x->tx_stream);
 365         amdtp_stream_stop(&dg00x->rx_stream);
 366         finish_session(dg00x);
 367         release_resources(dg00x);
 368
 369         /*
 370          * Just after finishing the session, the device may lost transmitting
 371          * functionality for a short time.
 372          */
 373         msleep(50);
 374 }
 375
 376 void snd_dg00x_stream_update_duplex(struct snd_dg00x *dg00x)
 377 {
 378         fw_iso_resources_update(&dg00x->tx_resources);
 379         fw_iso_resources_update(&dg00x->rx_resources);
 380
 381         amdtp_stream_update(&dg00x->tx_stream);
 382         amdtp_stream_update(&dg00x->rx_stream);
 383 }
 384
 385 void snd_dg00x_stream_lock_changed(struct snd_dg00x *dg00x)
 386 {
 387         dg00x->dev_lock_changed = true;
 388         wake_up(&dg00x->hwdep_wait);
 389 }
 390
 391 int snd_dg00x_stream_lock_try(struct snd_dg00x *dg00x)
 392 {
 393         int err;
 394
 395         spin_lock_irq(&dg00x->lock);
 396
 397         /* user land lock this */
 398         if (dg00x->dev_lock_count < 0) {
 399                 err = -EBUSY;
 400                 goto end;
 401         }
 402
 403         /* this is the first time */
 404         if (dg00x->dev_lock_count++ == 0)
 405                 snd_dg00x_stream_lock_changed(dg00x);
 406         err = 0;
 407 end:
 408         spin_unlock_irq(&dg00x->lock);
 409         return err;
 410 }
 411
 412 void snd_dg00x_stream_lock_release(struct snd_dg00x *dg00x)
 413 {
 414         spin_lock_irq(&dg00x->lock);
 415
 416         if (WARN_ON(dg00x->dev_lock_count <= 0))
 417                 goto end;
 418         if (--dg00x->dev_lock_count == 0)
 419                 snd_dg00x_stream_lock_changed(dg00x);
 420 end:
 421         spin_unlock_irq(&dg00x->lock);
 422 }