1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 */ 4 5 /* USX2Y "rawusb" aka hwdep_pcm implementation 6 7 Its usb's unableness to atomically handle power of 2 period sized data chuncs 8 at standard samplerates, 9 what led to this part of the usx2y module: 10 It provides the alsa kernel half of the usx2y-alsa-jack driver pair. 11 The pair uses a hardware dependent alsa-device for mmaped pcm transport. 12 Advantage achieved: 13 The usb_hc moves pcm data from/into memory via DMA. 14 That memory is mmaped by jack's usx2y driver. 15 Jack's usx2y driver is the first/last to read/write pcm data. 16 Read/write is a combination of power of 2 period shaping and 17 float/int conversation. 18 Compared to mainline alsa/jack we leave out power of 2 period shaping inside 19 snd-usb-usx2y which needs memcpy() and additional buffers. 20 As a side effect possible unwanted pcm-data coruption resulting of 21 standard alsa's snd-usb-usx2y period shaping scheme falls away. 22 Result is sane jack operation at buffering schemes down to 128frames, 23 2 periods. 24 plain usx2y alsa mode is able to achieve 64frames, 4periods, but only at the 25 cost of easier triggered i.e. aeolus xruns (128 or 256frames, 26 2periods works but is useless cause of crackling). 27 28 This is a first "proof of concept" implementation. 29 Later, functionalities should migrate to more appropriate places: 30 Userland: 31 - The jackd could mmap its float-pcm buffers directly from alsa-lib. 32 - alsa-lib could provide power of 2 period sized shaping combined with int/float 33 conversation. 34 Currently the usx2y jack driver provides above 2 services. 35 Kernel: 36 - rawusb dma pcm buffer transport should go to snd-usb-lib, so also snd-usb-audio 37 devices can use it. 38 Currently rawusb dma pcm buffer transport (this file) is only available to snd-usb-usx2y. 39 */ 40 41 #include <linux/delay.h> 42 #include <linux/gfp.h> 43 #include "usbusx2yaudio.c" 44 45 #if defined(USX2Y_NRPACKS_VARIABLE) || USX2Y_NRPACKS == 1 46 47 #include <sound/hwdep.h> 48 49 static int usx2y_usbpcm_urb_capt_retire(struct snd_usx2y_substream *subs) 50 { 51 struct urb *urb = subs->completed_urb; 52 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 53 int i, lens = 0, hwptr_done = subs->hwptr_done; 54 struct usx2ydev *usx2y = subs->usx2y; 55 int head; 56 57 if (usx2y->hwdep_pcm_shm->capture_iso_start < 0) { //FIXME 58 head = usx2y->hwdep_pcm_shm->captured_iso_head + 1; 59 if (head >= ARRAY_SIZE(usx2y->hwdep_pcm_shm->captured_iso)) 60 head = 0; 61 usx2y->hwdep_pcm_shm->capture_iso_start = head; 62 snd_printdd("cap start %i\n", head); 63 } 64 for (i = 0; i < nr_of_packs(); i++) { 65 if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */ 66 snd_printk(KERN_ERR 67 "active frame status %i. Most probably some hardware problem.\n", 68 urb->iso_frame_desc[i].status); 69 return urb->iso_frame_desc[i].status; 70 } 71 lens += urb->iso_frame_desc[i].actual_length / usx2y->stride; 72 } 73 hwptr_done += lens; 74 if (hwptr_done >= runtime->buffer_size) 75 hwptr_done -= runtime->buffer_size; 76 subs->hwptr_done = hwptr_done; 77 subs->transfer_done += lens; 78 /* update the pointer, call callback if necessary */ 79 if (subs->transfer_done >= runtime->period_size) { 80 subs->transfer_done -= runtime->period_size; 81 snd_pcm_period_elapsed(subs->pcm_substream); 82 } 83 return 0; 84 } 85 86 static int usx2y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, 87 struct usx2ydev *usx2y) 88 { 89 return (runtime->buffer_size * 1000) / usx2y->rate + 1; //FIXME: so far only correct period_size == 2^x ? 90 } 91 92 /* 93 * prepare urb for playback data pipe 94 * 95 * we copy the data directly from the pcm buffer. 96 * the current position to be copied is held in hwptr field. 97 * since a urb can handle only a single linear buffer, if the total 98 * transferred area overflows the buffer boundary, we cannot send 99 * it directly from the buffer. thus the data is once copied to 100 * a temporary buffer and urb points to that. 101 */ 102 static int usx2y_hwdep_urb_play_prepare(struct snd_usx2y_substream *subs, 103 struct urb *urb) 104 { 105 int count, counts, pack; 106 struct usx2ydev *usx2y = subs->usx2y; 107 struct snd_usx2y_hwdep_pcm_shm *shm = usx2y->hwdep_pcm_shm; 108 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 109 110 if (shm->playback_iso_start < 0) { 111 shm->playback_iso_start = shm->captured_iso_head - 112 usx2y_iso_frames_per_buffer(runtime, usx2y); 113 if (shm->playback_iso_start < 0) 114 shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso); 115 shm->playback_iso_head = shm->playback_iso_start; 116 } 117 118 count = 0; 119 for (pack = 0; pack < nr_of_packs(); pack++) { 120 /* calculate the size of a packet */ 121 counts = shm->captured_iso[shm->playback_iso_head].length / usx2y->stride; 122 if (counts < 43 || counts > 50) { 123 snd_printk(KERN_ERR "should not be here with counts=%i\n", counts); 124 return -EPIPE; 125 } 126 /* set up descriptor */ 127 urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset; 128 urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length; 129 if (atomic_read(&subs->state) != STATE_RUNNING) 130 memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0, 131 urb->iso_frame_desc[pack].length); 132 if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso)) 133 shm->playback_iso_head = 0; 134 count += counts; 135 } 136 urb->transfer_buffer_length = count * usx2y->stride; 137 return 0; 138 } 139 140 static void usx2y_usbpcm_urb_capt_iso_advance(struct snd_usx2y_substream *subs, 141 struct urb *urb) 142 { 143 struct usb_iso_packet_descriptor *desc; 144 struct snd_usx2y_hwdep_pcm_shm *shm; 145 int pack, head; 146 147 for (pack = 0; pack < nr_of_packs(); ++pack) { 148 desc = urb->iso_frame_desc + pack; 149 if (subs) { 150 shm = subs->usx2y->hwdep_pcm_shm; 151 head = shm->captured_iso_head + 1; 152 if (head >= ARRAY_SIZE(shm->captured_iso)) 153 head = 0; 154 shm->captured_iso[head].frame = urb->start_frame + pack; 155 shm->captured_iso[head].offset = desc->offset; 156 shm->captured_iso[head].length = desc->actual_length; 157 shm->captured_iso_head = head; 158 shm->captured_iso_frames++; 159 } 160 desc->offset += desc->length * NRURBS * nr_of_packs(); 161 if (desc->offset + desc->length >= SSS) 162 desc->offset -= (SSS - desc->length); 163 } 164 } 165 166 static int usx2y_usbpcm_usbframe_complete(struct snd_usx2y_substream *capsubs, 167 struct snd_usx2y_substream *capsubs2, 168 struct snd_usx2y_substream *playbacksubs, 169 int frame) 170 { 171 int err, state; 172 struct urb *urb = playbacksubs->completed_urb; 173 174 state = atomic_read(&playbacksubs->state); 175 if (urb) { 176 if (state == STATE_RUNNING) 177 usx2y_urb_play_retire(playbacksubs, urb); 178 else if (state >= STATE_PRERUNNING) 179 atomic_inc(&playbacksubs->state); 180 } else { 181 switch (state) { 182 case STATE_STARTING1: 183 urb = playbacksubs->urb[0]; 184 atomic_inc(&playbacksubs->state); 185 break; 186 case STATE_STARTING2: 187 urb = playbacksubs->urb[1]; 188 atomic_inc(&playbacksubs->state); 189 break; 190 } 191 } 192 if (urb) { 193 err = usx2y_hwdep_urb_play_prepare(playbacksubs, urb); 194 if (err) 195 return err; 196 err = usx2y_hwdep_urb_play_prepare(playbacksubs, urb); 197 if (err) 198 return err; 199 } 200 201 playbacksubs->completed_urb = NULL; 202 203 state = atomic_read(&capsubs->state); 204 if (state >= STATE_PREPARED) { 205 if (state == STATE_RUNNING) { 206 err = usx2y_usbpcm_urb_capt_retire(capsubs); 207 if (err) 208 return err; 209 } else if (state >= STATE_PRERUNNING) { 210 atomic_inc(&capsubs->state); 211 } 212 usx2y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb); 213 if (capsubs2) 214 usx2y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb); 215 err = usx2y_urb_submit(capsubs, capsubs->completed_urb, frame); 216 if (err) 217 return err; 218 if (capsubs2) { 219 err = usx2y_urb_submit(capsubs2, capsubs2->completed_urb, frame); 220 if (err) 221 return err; 222 } 223 } 224 capsubs->completed_urb = NULL; 225 if (capsubs2) 226 capsubs2->completed_urb = NULL; 227 return 0; 228 } 229 230 static void i_usx2y_usbpcm_urb_complete(struct urb *urb) 231 { 232 struct snd_usx2y_substream *subs = urb->context; 233 struct usx2ydev *usx2y = subs->usx2y; 234 struct snd_usx2y_substream *capsubs, *capsubs2, *playbacksubs; 235 236 if (unlikely(atomic_read(&subs->state) < STATE_PREPARED)) { 237 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", 238 usb_get_current_frame_number(usx2y->dev), 239 subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", 240 urb->status, urb->start_frame); 241 return; 242 } 243 if (unlikely(urb->status)) { 244 usx2y_error_urb_status(usx2y, subs, urb); 245 return; 246 } 247 248 subs->completed_urb = urb; 249 capsubs = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; 250 capsubs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 251 playbacksubs = usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 252 if (capsubs->completed_urb && atomic_read(&capsubs->state) >= STATE_PREPARED && 253 (!capsubs2 || capsubs2->completed_urb) && 254 (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < STATE_PREPARED)) { 255 if (!usx2y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame)) { 256 usx2y->wait_iso_frame += nr_of_packs(); 257 } else { 258 snd_printdd("\n"); 259 usx2y_clients_stop(usx2y); 260 } 261 } 262 } 263 264 static void usx2y_hwdep_urb_release(struct urb **urb) 265 { 266 usb_kill_urb(*urb); 267 usb_free_urb(*urb); 268 *urb = NULL; 269 } 270 271 /* 272 * release a substream 273 */ 274 static void usx2y_usbpcm_urbs_release(struct snd_usx2y_substream *subs) 275 { 276 int i; 277 278 snd_printdd("snd_usx2y_urbs_release() %i\n", subs->endpoint); 279 for (i = 0; i < NRURBS; i++) 280 usx2y_hwdep_urb_release(subs->urb + i); 281 } 282 283 static void usx2y_usbpcm_subs_startup_finish(struct usx2ydev *usx2y) 284 { 285 usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_urb_complete); 286 usx2y->prepare_subs = NULL; 287 } 288 289 static void i_usx2y_usbpcm_subs_startup(struct urb *urb) 290 { 291 struct snd_usx2y_substream *subs = urb->context; 292 struct usx2ydev *usx2y = subs->usx2y; 293 struct snd_usx2y_substream *prepare_subs = usx2y->prepare_subs; 294 struct snd_usx2y_substream *cap_subs2; 295 296 if (prepare_subs && 297 urb->start_frame == prepare_subs->urb[0]->start_frame) { 298 atomic_inc(&prepare_subs->state); 299 if (prepare_subs == usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]) { 300 cap_subs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 301 if (cap_subs2) 302 atomic_inc(&cap_subs2->state); 303 } 304 usx2y_usbpcm_subs_startup_finish(usx2y); 305 wake_up(&usx2y->prepare_wait_queue); 306 } 307 308 i_usx2y_usbpcm_urb_complete(urb); 309 } 310 311 /* 312 * initialize a substream's urbs 313 */ 314 static int usx2y_usbpcm_urbs_allocate(struct snd_usx2y_substream *subs) 315 { 316 int i; 317 unsigned int pipe; 318 int is_playback = subs == subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 319 struct usb_device *dev = subs->usx2y->dev; 320 struct urb **purb; 321 322 pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) : 323 usb_rcvisocpipe(dev, subs->endpoint); 324 subs->maxpacksize = usb_maxpacket(dev, pipe); 325 if (!subs->maxpacksize) 326 return -EINVAL; 327 328 /* allocate and initialize data urbs */ 329 for (i = 0; i < NRURBS; i++) { 330 purb = subs->urb + i; 331 if (*purb) { 332 usb_kill_urb(*purb); 333 continue; 334 } 335 *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL); 336 if (!*purb) { 337 usx2y_usbpcm_urbs_release(subs); 338 return -ENOMEM; 339 } 340 (*purb)->transfer_buffer = is_playback ? 341 subs->usx2y->hwdep_pcm_shm->playback : ( 342 subs->endpoint == 0x8 ? 343 subs->usx2y->hwdep_pcm_shm->capture0x8 : 344 subs->usx2y->hwdep_pcm_shm->capture0xA); 345 346 (*purb)->dev = dev; 347 (*purb)->pipe = pipe; 348 (*purb)->number_of_packets = nr_of_packs(); 349 (*purb)->context = subs; 350 (*purb)->interval = 1; 351 (*purb)->complete = i_usx2y_usbpcm_subs_startup; 352 } 353 return 0; 354 } 355 356 /* 357 * free the buffer 358 */ 359 static int snd_usx2y_usbpcm_hw_free(struct snd_pcm_substream *substream) 360 { 361 struct snd_pcm_runtime *runtime = substream->runtime; 362 struct snd_usx2y_substream *subs = runtime->private_data; 363 struct snd_usx2y_substream *cap_subs; 364 struct snd_usx2y_substream *playback_subs; 365 struct snd_usx2y_substream *cap_subs2; 366 367 mutex_lock(&subs->usx2y->pcm_mutex); 368 snd_printdd("%s(%p)\n", __func__, substream); 369 370 cap_subs2 = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; 371 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 372 cap_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; 373 atomic_set(&subs->state, STATE_STOPPED); 374 usx2y_usbpcm_urbs_release(subs); 375 if (!cap_subs->pcm_substream || 376 !cap_subs->pcm_substream->runtime || 377 !cap_subs->pcm_substream->runtime->status || 378 cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) { 379 atomic_set(&cap_subs->state, STATE_STOPPED); 380 if (cap_subs2) 381 atomic_set(&cap_subs2->state, STATE_STOPPED); 382 usx2y_usbpcm_urbs_release(cap_subs); 383 if (cap_subs2) 384 usx2y_usbpcm_urbs_release(cap_subs2); 385 } 386 } else { 387 playback_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; 388 if (atomic_read(&playback_subs->state) < STATE_PREPARED) { 389 atomic_set(&subs->state, STATE_STOPPED); 390 if (cap_subs2) 391 atomic_set(&cap_subs2->state, STATE_STOPPED); 392 usx2y_usbpcm_urbs_release(subs); 393 if (cap_subs2) 394 usx2y_usbpcm_urbs_release(cap_subs2); 395 } 396 } 397 mutex_unlock(&subs->usx2y->pcm_mutex); 398 return 0; 399 } 400 401 static void usx2y_usbpcm_subs_startup(struct snd_usx2y_substream *subs) 402 { 403 struct usx2ydev *usx2y = subs->usx2y; 404 405 usx2y->prepare_subs = subs; 406 subs->urb[0]->start_frame = -1; 407 smp_wmb(); // Make sure above modifications are seen by i_usx2y_subs_startup() 408 usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_subs_startup); 409 } 410 411 static int usx2y_usbpcm_urbs_start(struct snd_usx2y_substream *subs) 412 { 413 int p, u, err, stream = subs->pcm_substream->stream; 414 struct usx2ydev *usx2y = subs->usx2y; 415 struct urb *urb; 416 unsigned long pack; 417 418 if (stream == SNDRV_PCM_STREAM_CAPTURE) { 419 usx2y->hwdep_pcm_shm->captured_iso_head = -1; 420 usx2y->hwdep_pcm_shm->captured_iso_frames = 0; 421 } 422 423 for (p = 0; 3 >= (stream + p); p += 2) { 424 struct snd_usx2y_substream *subs = usx2y->subs[stream + p]; 425 if (subs) { 426 err = usx2y_usbpcm_urbs_allocate(subs); 427 if (err < 0) 428 return err; 429 subs->completed_urb = NULL; 430 } 431 } 432 433 for (p = 0; p < 4; p++) { 434 struct snd_usx2y_substream *subs = usx2y->subs[p]; 435 436 if (subs && atomic_read(&subs->state) >= STATE_PREPARED) 437 goto start; 438 } 439 440 start: 441 usx2y_usbpcm_subs_startup(subs); 442 for (u = 0; u < NRURBS; u++) { 443 for (p = 0; 3 >= (stream + p); p += 2) { 444 struct snd_usx2y_substream *subs = usx2y->subs[stream + p]; 445 446 if (!subs) 447 continue; 448 urb = subs->urb[u]; 449 if (usb_pipein(urb->pipe)) { 450 if (!u) 451 atomic_set(&subs->state, STATE_STARTING3); 452 urb->dev = usx2y->dev; 453 for (pack = 0; pack < nr_of_packs(); pack++) { 454 urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs()); 455 urb->iso_frame_desc[pack].length = subs->maxpacksize; 456 } 457 urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); 458 err = usb_submit_urb(urb, GFP_KERNEL); 459 if (err < 0) { 460 snd_printk(KERN_ERR "cannot usb_submit_urb() for urb %d, err = %d\n", u, err); 461 err = -EPIPE; 462 goto cleanup; 463 } else { 464 snd_printdd("%i\n", urb->start_frame); 465 if (!u) 466 usx2y->wait_iso_frame = urb->start_frame; 467 } 468 urb->transfer_flags = 0; 469 } else { 470 atomic_set(&subs->state, STATE_STARTING1); 471 break; 472 } 473 } 474 } 475 err = 0; 476 wait_event(usx2y->prepare_wait_queue, !usx2y->prepare_subs); 477 if (atomic_read(&subs->state) != STATE_PREPARED) 478 err = -EPIPE; 479 480 cleanup: 481 if (err) { 482 usx2y_subs_startup_finish(usx2y); // Call it now 483 usx2y_clients_stop(usx2y); // something is completely wrong > stop everything 484 } 485 return err; 486 } 487 488 #define USX2Y_HWDEP_PCM_PAGES \ 489 PAGE_ALIGN(sizeof(struct snd_usx2y_hwdep_pcm_shm)) 490 491 /* 492 * prepare callback 493 * 494 * set format and initialize urbs 495 */ 496 static int snd_usx2y_usbpcm_prepare(struct snd_pcm_substream *substream) 497 { 498 struct snd_pcm_runtime *runtime = substream->runtime; 499 struct snd_usx2y_substream *subs = runtime->private_data; 500 struct usx2ydev *usx2y = subs->usx2y; 501 struct snd_usx2y_substream *capsubs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; 502 int err = 0; 503 504 snd_printdd("snd_usx2y_pcm_prepare(%p)\n", substream); 505 506 mutex_lock(&usx2y->pcm_mutex); 507 508 if (!usx2y->hwdep_pcm_shm) { 509 usx2y->hwdep_pcm_shm = alloc_pages_exact(USX2Y_HWDEP_PCM_PAGES, 510 GFP_KERNEL); 511 if (!usx2y->hwdep_pcm_shm) { 512 err = -ENOMEM; 513 goto up_prepare_mutex; 514 } 515 memset(usx2y->hwdep_pcm_shm, 0, USX2Y_HWDEP_PCM_PAGES); 516 } 517 518 usx2y_subs_prepare(subs); 519 // Start hardware streams 520 // SyncStream first.... 521 if (atomic_read(&capsubs->state) < STATE_PREPARED) { 522 if (usx2y->format != runtime->format) { 523 err = usx2y_format_set(usx2y, runtime->format); 524 if (err < 0) 525 goto up_prepare_mutex; 526 } 527 if (usx2y->rate != runtime->rate) { 528 err = usx2y_rate_set(usx2y, runtime->rate); 529 if (err < 0) 530 goto up_prepare_mutex; 531 } 532 snd_printdd("starting capture pipe for %s\n", subs == capsubs ? 533 "self" : "playpipe"); 534 err = usx2y_usbpcm_urbs_start(capsubs); 535 if (err < 0) 536 goto up_prepare_mutex; 537 } 538 539 if (subs != capsubs) { 540 usx2y->hwdep_pcm_shm->playback_iso_start = -1; 541 if (atomic_read(&subs->state) < STATE_PREPARED) { 542 while (usx2y_iso_frames_per_buffer(runtime, usx2y) > 543 usx2y->hwdep_pcm_shm->captured_iso_frames) { 544 snd_printdd("Wait: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", 545 usx2y_iso_frames_per_buffer(runtime, usx2y), 546 usx2y->hwdep_pcm_shm->captured_iso_frames); 547 if (msleep_interruptible(10)) { 548 err = -ERESTARTSYS; 549 goto up_prepare_mutex; 550 } 551 } 552 err = usx2y_usbpcm_urbs_start(subs); 553 if (err < 0) 554 goto up_prepare_mutex; 555 } 556 snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", 557 usx2y_iso_frames_per_buffer(runtime, usx2y), 558 usx2y->hwdep_pcm_shm->captured_iso_frames); 559 } else { 560 usx2y->hwdep_pcm_shm->capture_iso_start = -1; 561 } 562 563 up_prepare_mutex: 564 mutex_unlock(&usx2y->pcm_mutex); 565 return err; 566 } 567 568 static const struct snd_pcm_hardware snd_usx2y_4c = { 569 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 570 SNDRV_PCM_INFO_BLOCK_TRANSFER | 571 SNDRV_PCM_INFO_MMAP_VALID), 572 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE, 573 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, 574 .rate_min = 44100, 575 .rate_max = 48000, 576 .channels_min = 2, 577 .channels_max = 4, 578 .buffer_bytes_max = (2*128*1024), 579 .period_bytes_min = 64, 580 .period_bytes_max = (128*1024), 581 .periods_min = 2, 582 .periods_max = 1024, 583 .fifo_size = 0 584 }; 585 586 static int snd_usx2y_usbpcm_open(struct snd_pcm_substream *substream) 587 { 588 struct snd_usx2y_substream *subs = 589 ((struct snd_usx2y_substream **) 590 snd_pcm_substream_chip(substream))[substream->stream]; 591 struct snd_pcm_runtime *runtime = substream->runtime; 592 593 if (!(subs->usx2y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)) 594 return -EBUSY; 595 596 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 597 runtime->hw = snd_usx2y_2c; 598 else 599 runtime->hw = (subs->usx2y->subs[3] ? snd_usx2y_4c : snd_usx2y_2c); 600 runtime->private_data = subs; 601 subs->pcm_substream = substream; 602 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000); 603 return 0; 604 } 605 606 static int snd_usx2y_usbpcm_close(struct snd_pcm_substream *substream) 607 { 608 struct snd_pcm_runtime *runtime = substream->runtime; 609 struct snd_usx2y_substream *subs = runtime->private_data; 610 611 subs->pcm_substream = NULL; 612 return 0; 613 } 614 615 static const struct snd_pcm_ops snd_usx2y_usbpcm_ops = { 616 .open = snd_usx2y_usbpcm_open, 617 .close = snd_usx2y_usbpcm_close, 618 .hw_params = snd_usx2y_pcm_hw_params, 619 .hw_free = snd_usx2y_usbpcm_hw_free, 620 .prepare = snd_usx2y_usbpcm_prepare, 621 .trigger = snd_usx2y_pcm_trigger, 622 .pointer = snd_usx2y_pcm_pointer, 623 }; 624 625 static int usx2y_pcms_busy_check(struct snd_card *card) 626 { 627 struct usx2ydev *dev = usx2y(card); 628 struct snd_usx2y_substream *subs; 629 int i; 630 631 for (i = 0; i < dev->pcm_devs * 2; i++) { 632 subs = dev->subs[i]; 633 if (subs && subs->pcm_substream && 634 SUBSTREAM_BUSY(subs->pcm_substream)) 635 return -EBUSY; 636 } 637 return 0; 638 } 639 640 static int snd_usx2y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) 641 { 642 struct snd_card *card = hw->card; 643 int err; 644 645 mutex_lock(&usx2y(card)->pcm_mutex); 646 err = usx2y_pcms_busy_check(card); 647 if (!err) 648 usx2y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS; 649 mutex_unlock(&usx2y(card)->pcm_mutex); 650 return err; 651 } 652 653 static int snd_usx2y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file) 654 { 655 struct snd_card *card = hw->card; 656 int err; 657 658 mutex_lock(&usx2y(card)->pcm_mutex); 659 err = usx2y_pcms_busy_check(card); 660 if (!err) 661 usx2y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS; 662 mutex_unlock(&usx2y(card)->pcm_mutex); 663 return err; 664 } 665 666 static void snd_usx2y_hwdep_pcm_vm_open(struct vm_area_struct *area) 667 { 668 } 669 670 static void snd_usx2y_hwdep_pcm_vm_close(struct vm_area_struct *area) 671 { 672 } 673 674 static vm_fault_t snd_usx2y_hwdep_pcm_vm_fault(struct vm_fault *vmf) 675 { 676 unsigned long offset; 677 void *vaddr; 678 679 offset = vmf->pgoff << PAGE_SHIFT; 680 vaddr = (char *)((struct usx2ydev *)vmf->vma->vm_private_data)->hwdep_pcm_shm + offset; 681 vmf->page = virt_to_page(vaddr); 682 get_page(vmf->page); 683 return 0; 684 } 685 686 static const struct vm_operations_struct snd_usx2y_hwdep_pcm_vm_ops = { 687 .open = snd_usx2y_hwdep_pcm_vm_open, 688 .close = snd_usx2y_hwdep_pcm_vm_close, 689 .fault = snd_usx2y_hwdep_pcm_vm_fault, 690 }; 691 692 static int snd_usx2y_hwdep_pcm_mmap(struct snd_hwdep *hw, struct file *filp, struct vm_area_struct *area) 693 { 694 unsigned long size = (unsigned long)(area->vm_end - area->vm_start); 695 struct usx2ydev *usx2y = hw->private_data; 696 697 if (!(usx2y->chip_status & USX2Y_STAT_CHIP_INIT)) 698 return -EBUSY; 699 700 /* if userspace tries to mmap beyond end of our buffer, fail */ 701 if (size > USX2Y_HWDEP_PCM_PAGES) { 702 snd_printd("%lu > %lu\n", size, (unsigned long)USX2Y_HWDEP_PCM_PAGES); 703 return -EINVAL; 704 } 705 706 if (!usx2y->hwdep_pcm_shm) 707 return -ENODEV; 708 709 area->vm_ops = &snd_usx2y_hwdep_pcm_vm_ops; 710 area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; 711 area->vm_private_data = hw->private_data; 712 return 0; 713 } 714 715 static void snd_usx2y_hwdep_pcm_private_free(struct snd_hwdep *hwdep) 716 { 717 struct usx2ydev *usx2y = hwdep->private_data; 718 719 if (usx2y->hwdep_pcm_shm) 720 free_pages_exact(usx2y->hwdep_pcm_shm, USX2Y_HWDEP_PCM_PAGES); 721 } 722 723 int usx2y_hwdep_pcm_new(struct snd_card *card) 724 { 725 int err; 726 struct snd_hwdep *hw; 727 struct snd_pcm *pcm; 728 struct usb_device *dev = usx2y(card)->dev; 729 730 if (nr_of_packs() != 1) 731 return 0; 732 733 err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw); 734 if (err < 0) 735 return err; 736 737 hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM; 738 hw->private_data = usx2y(card); 739 hw->private_free = snd_usx2y_hwdep_pcm_private_free; 740 hw->ops.open = snd_usx2y_hwdep_pcm_open; 741 hw->ops.release = snd_usx2y_hwdep_pcm_release; 742 hw->ops.mmap = snd_usx2y_hwdep_pcm_mmap; 743 hw->exclusive = 1; 744 sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum); 745 746 err = snd_pcm_new(card, NAME_ALLCAPS" hwdep Audio", 2, 1, 1, &pcm); 747 if (err < 0) 748 return err; 749 750 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usx2y_usbpcm_ops); 751 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usx2y_usbpcm_ops); 752 753 pcm->private_data = usx2y(card)->subs; 754 pcm->info_flags = 0; 755 756 sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio"); 757 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, 758 SNDRV_DMA_TYPE_CONTINUOUS, 759 NULL, 760 64*1024, 128*1024); 761 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, 762 SNDRV_DMA_TYPE_CONTINUOUS, 763 NULL, 764 64*1024, 128*1024); 765 766 return 0; 767 } 768 769 #else 770 771 int usx2y_hwdep_pcm_new(struct snd_card *card) 772 { 773 return 0; 774 } 775 776 #endif 777