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