sound/usb/hiface/pcm.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Linux driver for M2Tech hiFace compatible devices
   4  *
   5  * Copyright 2012-2013 (C) M2TECH S.r.l and Amarula Solutions B.V.
   6  *
   7  * Authors:  Michael Trimarchi <michael@amarulasolutions.com>
   8  *           Antonio Ospite <ao2@amarulasolutions.com>
   9  *
  10  * The driver is based on the work done in TerraTec DMX 6Fire USB
  11  */
  12
  13 #include <linux/slab.h>
  14 #include <sound/pcm.h>
  15
  16 #include "pcm.h"
  17 #include "chip.h"
  18
  19 #define OUT_EP          0x2
  20 #define PCM_N_URBS      8
  21 #define PCM_PACKET_SIZE 4096
  22 #define PCM_BUFFER_SIZE (2 * PCM_N_URBS * PCM_PACKET_SIZE)
  23
  24 struct pcm_urb {
  25         struct hiface_chip *chip;
  26
  27         struct urb instance;
  28         struct usb_anchor submitted;
  29         u8 *buffer;
  30 };
  31
  32 struct pcm_substream {
  33         spinlock_t lock;
  34         struct snd_pcm_substream *instance;
  35
  36         bool active;
  37         snd_pcm_uframes_t dma_off;    /* current position in alsa dma_area */
  38         snd_pcm_uframes_t period_off; /* current position in current period */
  39 };
  40
  41 enum { /* pcm streaming states */
  42         STREAM_DISABLED, /* no pcm streaming */
  43         STREAM_STARTING, /* pcm streaming requested, waiting to become ready */
  44         STREAM_RUNNING,  /* pcm streaming running */
  45         STREAM_STOPPING
  46 };
  47
  48 struct pcm_runtime {
  49         struct hiface_chip *chip;
  50         struct snd_pcm *instance;
  51
  52         struct pcm_substream playback;
  53         bool panic; /* if set driver won't do anymore pcm on device */
  54
  55         struct pcm_urb out_urbs[PCM_N_URBS];
  56
  57         struct mutex stream_mutex;
  58         u8 stream_state; /* one of STREAM_XXX */
  59         u8 extra_freq;
  60         wait_queue_head_t stream_wait_queue;
  61         bool stream_wait_cond;
  62 };
  63
  64 static const unsigned int rates[] = { 44100, 48000, 88200, 96000, 176400, 192000,
  65                                       352800, 384000 };
  66 static const struct snd_pcm_hw_constraint_list constraints_extra_rates = {
  67         .count = ARRAY_SIZE(rates),
  68         .list = rates,
  69         .mask = 0,
  70 };
  71
  72 static const struct snd_pcm_hardware pcm_hw = {
  73         .info = SNDRV_PCM_INFO_MMAP |
  74                 SNDRV_PCM_INFO_INTERLEAVED |
  75                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  76                 SNDRV_PCM_INFO_PAUSE |
  77                 SNDRV_PCM_INFO_MMAP_VALID |
  78                 SNDRV_PCM_INFO_BATCH,
  79
  80         .formats = SNDRV_PCM_FMTBIT_S32_LE,
  81
  82         .rates = SNDRV_PCM_RATE_44100 |
  83                 SNDRV_PCM_RATE_48000 |
  84                 SNDRV_PCM_RATE_88200 |
  85                 SNDRV_PCM_RATE_96000 |
  86                 SNDRV_PCM_RATE_176400 |
  87                 SNDRV_PCM_RATE_192000,
  88
  89         .rate_min = 44100,
  90         .rate_max = 192000, /* changes in hiface_pcm_open to support extra rates */
  91         .channels_min = 2,
  92         .channels_max = 2,
  93         .buffer_bytes_max = PCM_BUFFER_SIZE,
  94         .period_bytes_min = PCM_PACKET_SIZE,
  95         .period_bytes_max = PCM_BUFFER_SIZE,
  96         .periods_min = 2,
  97         .periods_max = 1024
  98 };
  99
 100 /* message values used to change the sample rate */
 101 #define HIFACE_SET_RATE_REQUEST 0xb0
 102
 103 #define HIFACE_RATE_44100  0x43
 104 #define HIFACE_RATE_48000  0x4b
 105 #define HIFACE_RATE_88200  0x42
 106 #define HIFACE_RATE_96000  0x4a
 107 #define HIFACE_RATE_176400 0x40
 108 #define HIFACE_RATE_192000 0x48
 109 #define HIFACE_RATE_352800 0x58
 110 #define HIFACE_RATE_384000 0x68
 111
 112 static int hiface_pcm_set_rate(struct pcm_runtime *rt, unsigned int rate)
 113 {
 114         struct usb_device *device = rt->chip->dev;
 115         u16 rate_value;
 116         int ret;
 117
 118         /* We are already sure that the rate is supported here thanks to
 119          * ALSA constraints
 120          */
 121         switch (rate) {
 122         case 44100:
 123                 rate_value = HIFACE_RATE_44100;
 124                 break;
 125         case 48000:
 126                 rate_value = HIFACE_RATE_48000;
 127                 break;
 128         case 88200:
 129                 rate_value = HIFACE_RATE_88200;
 130                 break;
 131         case 96000:
 132                 rate_value = HIFACE_RATE_96000;
 133                 break;
 134         case 176400:
 135                 rate_value = HIFACE_RATE_176400;
 136                 break;
 137         case 192000:
 138                 rate_value = HIFACE_RATE_192000;
 139                 break;
 140         case 352800:
 141                 rate_value = HIFACE_RATE_352800;
 142                 break;
 143         case 384000:
 144                 rate_value = HIFACE_RATE_384000;
 145                 break;
 146         default:
 147                 dev_err(&device->dev, "Unsupported rate %d\n", rate);
 148                 return -EINVAL;
 149         }
 150
 151         /*
 152          * USBIO: Vendor 0xb0(wValue=0x0043, wIndex=0x0000)
 153          * 43 b0 43 00 00 00 00 00
 154          * USBIO: Vendor 0xb0(wValue=0x004b, wIndex=0x0000)
 155          * 43 b0 4b 00 00 00 00 00
 156          * This control message doesn't have any ack from the
 157          * other side
 158          */
 159         ret = usb_control_msg(device, usb_sndctrlpipe(device, 0),
 160                               HIFACE_SET_RATE_REQUEST,
 161                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 162                               rate_value, 0, NULL, 0, 100);
 163         if (ret < 0) {
 164                 dev_err(&device->dev, "Error setting samplerate %d.\n", rate);
 165                 return ret;
 166         }
 167
 168         return 0;
 169 }
 170
 171 static struct pcm_substream *hiface_pcm_get_substream(struct snd_pcm_substream
 172                                                       *alsa_sub)
 173 {
 174         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 175         struct device *device = &rt->chip->dev->dev;
 176
 177         if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
 178                 return &rt->playback;
 179
 180         dev_err(device, "Error getting pcm substream slot.\n");
 181         return NULL;
 182 }
 183
 184 /* call with stream_mutex locked */
 185 static void hiface_pcm_stream_stop(struct pcm_runtime *rt)
 186 {
 187         int i, time;
 188
 189         if (rt->stream_state != STREAM_DISABLED) {
 190                 rt->stream_state = STREAM_STOPPING;
 191
 192                 for (i = 0; i < PCM_N_URBS; i++) {
 193                         time = usb_wait_anchor_empty_timeout(
 194                                         &rt->out_urbs[i].submitted, 100);
 195                         if (!time)
 196                                 usb_kill_anchored_urbs(
 197                                         &rt->out_urbs[i].submitted);
 198                         usb_kill_urb(&rt->out_urbs[i].instance);
 199                 }
 200
 201                 rt->stream_state = STREAM_DISABLED;
 202         }
 203 }
 204
 205 /* call with stream_mutex locked */
 206 static int hiface_pcm_stream_start(struct pcm_runtime *rt)
 207 {
 208         int ret = 0;
 209         int i;
 210
 211         if (rt->stream_state == STREAM_DISABLED) {
 212
 213                 /* reset panic state when starting a new stream */
 214                 rt->panic = false;
 215
 216                 /* submit our out urbs zero init */
 217                 rt->stream_state = STREAM_STARTING;
 218                 for (i = 0; i < PCM_N_URBS; i++) {
 219                         memset(rt->out_urbs[i].buffer, 0, PCM_PACKET_SIZE);
 220                         usb_anchor_urb(&rt->out_urbs[i].instance,
 221                                        &rt->out_urbs[i].submitted);
 222                         ret = usb_submit_urb(&rt->out_urbs[i].instance,
 223                                              GFP_ATOMIC);
 224                         if (ret) {
 225                                 hiface_pcm_stream_stop(rt);
 226                                 return ret;
 227                         }
 228                 }
 229
 230                 /* wait for first out urb to return (sent in in urb handler) */
 231                 wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond,
 232                                    HZ);
 233                 if (rt->stream_wait_cond) {
 234                         struct device *device = &rt->chip->dev->dev;
 235                         dev_dbg(device, "%s: Stream is running wakeup event\n",
 236                                  __func__);
 237                         rt->stream_state = STREAM_RUNNING;
 238                 } else {
 239                         hiface_pcm_stream_stop(rt);
 240                         return -EIO;
 241                 }
 242         }
 243         return ret;
 244 }
 245
 246 /* The hardware wants word-swapped 32-bit values */
 247 static void memcpy_swahw32(u8 *dest, u8 *src, unsigned int n)
 248 {
 249         unsigned int i;
 250
 251         for (i = 0; i < n / 4; i++)
 252                 ((u32 *)dest)[i] = swahw32(((u32 *)src)[i]);
 253 }
 254
 255 /* call with substream locked */
 256 /* returns true if a period elapsed */
 257 static bool hiface_pcm_playback(struct pcm_substream *sub, struct pcm_urb *urb)
 258 {
 259         struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
 260         struct device *device = &urb->chip->dev->dev;
 261         u8 *source;
 262         unsigned int pcm_buffer_size;
 263
 264         WARN_ON(alsa_rt->format != SNDRV_PCM_FORMAT_S32_LE);
 265
 266         pcm_buffer_size = snd_pcm_lib_buffer_bytes(sub->instance);
 267
 268         if (sub->dma_off + PCM_PACKET_SIZE <= pcm_buffer_size) {
 269                 dev_dbg(device, "%s: (1) buffer_size %#x dma_offset %#x\n", __func__,
 270                          (unsigned int) pcm_buffer_size,
 271                          (unsigned int) sub->dma_off);
 272
 273                 source = alsa_rt->dma_area + sub->dma_off;
 274                 memcpy_swahw32(urb->buffer, source, PCM_PACKET_SIZE);
 275         } else {
 276                 /* wrap around at end of ring buffer */
 277                 unsigned int len;
 278
 279                 dev_dbg(device, "%s: (2) buffer_size %#x dma_offset %#x\n", __func__,
 280                          (unsigned int) pcm_buffer_size,
 281                          (unsigned int) sub->dma_off);
 282
 283                 len = pcm_buffer_size - sub->dma_off;
 284
 285                 source = alsa_rt->dma_area + sub->dma_off;
 286                 memcpy_swahw32(urb->buffer, source, len);
 287
 288                 source = alsa_rt->dma_area;
 289                 memcpy_swahw32(urb->buffer + len, source,
 290                                PCM_PACKET_SIZE - len);
 291         }
 292         sub->dma_off += PCM_PACKET_SIZE;
 293         if (sub->dma_off >= pcm_buffer_size)
 294                 sub->dma_off -= pcm_buffer_size;
 295
 296         sub->period_off += PCM_PACKET_SIZE;
 297         if (sub->period_off >= alsa_rt->period_size) {
 298                 sub->period_off %= alsa_rt->period_size;
 299                 return true;
 300         }
 301         return false;
 302 }
 303
 304 static void hiface_pcm_out_urb_handler(struct urb *usb_urb)
 305 {
 306         struct pcm_urb *out_urb = usb_urb->context;
 307         struct pcm_runtime *rt = out_urb->chip->pcm;
 308         struct pcm_substream *sub;
 309         bool do_period_elapsed = false;
 310         unsigned long flags;
 311         int ret;
 312
 313         if (rt->panic || rt->stream_state == STREAM_STOPPING)
 314                 return;
 315
 316         if (unlikely(usb_urb->status == -ENOENT ||      /* unlinked */
 317                      usb_urb->status == -ENODEV ||      /* device removed */
 318                      usb_urb->status == -ECONNRESET ||  /* unlinked */
 319                      usb_urb->status == -ESHUTDOWN)) {  /* device disabled */
 320                 goto out_fail;
 321         }
 322
 323         if (rt->stream_state == STREAM_STARTING) {
 324                 rt->stream_wait_cond = true;
 325                 wake_up(&rt->stream_wait_queue);
 326         }
 327
 328         /* now send our playback data (if a free out urb was found) */
 329         sub = &rt->playback;
 330         spin_lock_irqsave(&sub->lock, flags);
 331         if (sub->active)
 332                 do_period_elapsed = hiface_pcm_playback(sub, out_urb);
 333         else
 334                 memset(out_urb->buffer, 0, PCM_PACKET_SIZE);
 335
 336         spin_unlock_irqrestore(&sub->lock, flags);
 337
 338         if (do_period_elapsed)
 339                 snd_pcm_period_elapsed(sub->instance);
 340
 341         ret = usb_submit_urb(&out_urb->instance, GFP_ATOMIC);
 342         if (ret < 0)
 343                 goto out_fail;
 344
 345         return;
 346
 347 out_fail:
 348         rt->panic = true;
 349 }
 350
 351 static int hiface_pcm_open(struct snd_pcm_substream *alsa_sub)
 352 {
 353         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 354         struct pcm_substream *sub = NULL;
 355         struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
 356         int ret;
 357
 358         if (rt->panic)
 359                 return -EPIPE;
 360
 361         mutex_lock(&rt->stream_mutex);
 362         alsa_rt->hw = pcm_hw;
 363
 364         if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
 365                 sub = &rt->playback;
 366
 367         if (!sub) {
 368                 struct device *device = &rt->chip->dev->dev;
 369                 mutex_unlock(&rt->stream_mutex);
 370                 dev_err(device, "Invalid stream type\n");
 371                 return -EINVAL;
 372         }
 373
 374         if (rt->extra_freq) {
 375                 alsa_rt->hw.rates |= SNDRV_PCM_RATE_KNOT;
 376                 alsa_rt->hw.rate_max = 384000;
 377
 378                 /* explicit constraints needed as we added SNDRV_PCM_RATE_KNOT */
 379                 ret = snd_pcm_hw_constraint_list(alsa_sub->runtime, 0,
 380                                                  SNDRV_PCM_HW_PARAM_RATE,
 381                                                  &constraints_extra_rates);
 382                 if (ret < 0) {
 383                         mutex_unlock(&rt->stream_mutex);
 384                         return ret;
 385                 }
 386         }
 387
 388         sub->instance = alsa_sub;
 389         sub->active = false;
 390         mutex_unlock(&rt->stream_mutex);
 391         return 0;
 392 }
 393
 394 static int hiface_pcm_close(struct snd_pcm_substream *alsa_sub)
 395 {
 396         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 397         struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
 398         unsigned long flags;
 399
 400         if (rt->panic)
 401                 return 0;
 402
 403         mutex_lock(&rt->stream_mutex);
 404         if (sub) {
 405                 hiface_pcm_stream_stop(rt);
 406
 407                 /* deactivate substream */
 408                 spin_lock_irqsave(&sub->lock, flags);
 409                 sub->instance = NULL;
 410                 sub->active = false;
 411                 spin_unlock_irqrestore(&sub->lock, flags);
 412
 413         }
 414         mutex_unlock(&rt->stream_mutex);
 415         return 0;
 416 }
 417
 418 static int hiface_pcm_prepare(struct snd_pcm_substream *alsa_sub)
 419 {
 420         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 421         struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
 422         struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
 423         int ret;
 424
 425         if (rt->panic)
 426                 return -EPIPE;
 427         if (!sub)
 428                 return -ENODEV;
 429
 430         mutex_lock(&rt->stream_mutex);
 431
 432         hiface_pcm_stream_stop(rt);
 433
 434         sub->dma_off = 0;
 435         sub->period_off = 0;
 436
 437         if (rt->stream_state == STREAM_DISABLED) {
 438
 439                 ret = hiface_pcm_set_rate(rt, alsa_rt->rate);
 440                 if (ret) {
 441                         mutex_unlock(&rt->stream_mutex);
 442                         return ret;
 443                 }
 444                 ret = hiface_pcm_stream_start(rt);
 445                 if (ret) {
 446                         mutex_unlock(&rt->stream_mutex);
 447                         return ret;
 448                 }
 449         }
 450         mutex_unlock(&rt->stream_mutex);
 451         return 0;
 452 }
 453
 454 static int hiface_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd)
 455 {
 456         struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
 457         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 458
 459         if (rt->panic)
 460                 return -EPIPE;
 461         if (!sub)
 462                 return -ENODEV;
 463
 464         switch (cmd) {
 465         case SNDRV_PCM_TRIGGER_START:
 466         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 467                 spin_lock_irq(&sub->lock);
 468                 sub->active = true;
 469                 spin_unlock_irq(&sub->lock);
 470                 return 0;
 471
 472         case SNDRV_PCM_TRIGGER_STOP:
 473         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 474                 spin_lock_irq(&sub->lock);
 475                 sub->active = false;
 476                 spin_unlock_irq(&sub->lock);
 477                 return 0;
 478
 479         default:
 480                 return -EINVAL;
 481         }
 482 }
 483
 484 static snd_pcm_uframes_t hiface_pcm_pointer(struct snd_pcm_substream *alsa_sub)
 485 {
 486         struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
 487         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 488         unsigned long flags;
 489         snd_pcm_uframes_t dma_offset;
 490
 491         if (rt->panic || !sub)
 492                 return SNDRV_PCM_POS_XRUN;
 493
 494         spin_lock_irqsave(&sub->lock, flags);
 495         dma_offset = sub->dma_off;
 496         spin_unlock_irqrestore(&sub->lock, flags);
 497         return bytes_to_frames(alsa_sub->runtime, dma_offset);
 498 }
 499
 500 static const struct snd_pcm_ops pcm_ops = {
 501         .open = hiface_pcm_open,
 502         .close = hiface_pcm_close,
 503         .prepare = hiface_pcm_prepare,
 504         .trigger = hiface_pcm_trigger,
 505         .pointer = hiface_pcm_pointer,
 506 };
 507
 508 static int hiface_pcm_init_urb(struct pcm_urb *urb,
 509                                struct hiface_chip *chip,
 510                                unsigned int ep,
 511                                void (*handler)(struct urb *))
 512 {
 513         urb->chip = chip;
 514         usb_init_urb(&urb->instance);
 515
 516         urb->buffer = kzalloc(PCM_PACKET_SIZE, GFP_KERNEL);
 517         if (!urb->buffer)
 518                 return -ENOMEM;
 519
 520         usb_fill_bulk_urb(&urb->instance, chip->dev,
 521                           usb_sndbulkpipe(chip->dev, ep), (void *)urb->buffer,
 522                           PCM_PACKET_SIZE, handler, urb);
 523         if (usb_urb_ep_type_check(&urb->instance))
 524                 return -EINVAL;
 525         init_usb_anchor(&urb->submitted);
 526
 527         return 0;
 528 }
 529
 530 void hiface_pcm_abort(struct hiface_chip *chip)
 531 {
 532         struct pcm_runtime *rt = chip->pcm;
 533
 534         if (rt) {
 535                 rt->panic = true;
 536
 537                 mutex_lock(&rt->stream_mutex);
 538                 hiface_pcm_stream_stop(rt);
 539                 mutex_unlock(&rt->stream_mutex);
 540         }
 541 }
 542
 543 static void hiface_pcm_destroy(struct hiface_chip *chip)
 544 {
 545         struct pcm_runtime *rt = chip->pcm;
 546         int i;
 547
 548         for (i = 0; i < PCM_N_URBS; i++)
 549                 kfree(rt->out_urbs[i].buffer);
 550
 551         kfree(chip->pcm);
 552         chip->pcm = NULL;
 553 }
 554
 555 static void hiface_pcm_free(struct snd_pcm *pcm)
 556 {
 557         struct pcm_runtime *rt = pcm->private_data;
 558
 559         if (rt)
 560                 hiface_pcm_destroy(rt->chip);
 561 }
 562
 563 int hiface_pcm_init(struct hiface_chip *chip, u8 extra_freq)
 564 {
 565         int i;
 566         int ret;
 567         struct snd_pcm *pcm;
 568         struct pcm_runtime *rt;
 569
 570         rt = kzalloc(sizeof(*rt), GFP_KERNEL);
 571         if (!rt)
 572                 return -ENOMEM;
 573
 574         rt->chip = chip;
 575         rt->stream_state = STREAM_DISABLED;
 576         if (extra_freq)
 577                 rt->extra_freq = 1;
 578
 579         init_waitqueue_head(&rt->stream_wait_queue);
 580         mutex_init(&rt->stream_mutex);
 581         spin_lock_init(&rt->playback.lock);
 582
 583         for (i = 0; i < PCM_N_URBS; i++) {
 584                 ret = hiface_pcm_init_urb(&rt->out_urbs[i], chip, OUT_EP,
 585                                     hiface_pcm_out_urb_handler);
 586                 if (ret < 0)
 587                         goto error;
 588         }
 589
 590         ret = snd_pcm_new(chip->card, "USB-SPDIF Audio", 0, 1, 0, &pcm);
 591         if (ret < 0) {
 592                 dev_err(&chip->dev->dev, "Cannot create pcm instance\n");
 593                 goto error;
 594         }
 595
 596         pcm->private_data = rt;
 597         pcm->private_free = hiface_pcm_free;
 598
 599         strlcpy(pcm->name, "USB-SPDIF Audio", sizeof(pcm->name));
 600         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops);
 601         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC,
 602                                        NULL, 0, 0);
 603
 604         rt->instance = pcm;
 605
 606         chip->pcm = rt;
 607         return 0;
 608
 609 error:
 610         for (i = 0; i < PCM_N_URBS; i++)
 611                 kfree(rt->out_urbs[i].buffer);
 612         kfree(rt);
 613         return ret;
 614 }