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