sound/usb/usx2y/usx2yhwdeppcm.c

   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
  50 static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs)
  51 {
  52         struct urb      *urb = subs->completed_urb;
  53         struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
  54         int             i, lens = 0, hwptr_done = subs->hwptr_done;
  55         struct usX2Ydev *usX2Y = subs->usX2Y;
  56         if (0 > usX2Y->hwdep_pcm_shm->capture_iso_start) { //FIXME
  57                 int head = usX2Y->hwdep_pcm_shm->captured_iso_head + 1;
  58                 if (head >= ARRAY_SIZE(usX2Y->hwdep_pcm_shm->captured_iso))
  59                         head = 0;
  60                 usX2Y->hwdep_pcm_shm->capture_iso_start = head;
  61                 snd_printdd("cap start %i\n", head);
  62         }
  63         for (i = 0; i < nr_of_packs(); i++) {
  64                 if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */
  65                         snd_printk(KERN_ERR "active frame status %i. Most probably some hardware problem.\n", urb->iso_frame_desc[i].status);
  66                         return urb->iso_frame_desc[i].status;
  67                 }
  68                 lens += urb->iso_frame_desc[i].actual_length / usX2Y->stride;
  69         }
  70         if ((hwptr_done += lens) >= runtime->buffer_size)
  71                 hwptr_done -= runtime->buffer_size;
  72         subs->hwptr_done = hwptr_done;
  73         subs->transfer_done += lens;
  74         /* update the pointer, call callback if necessary */
  75         if (subs->transfer_done >= runtime->period_size) {
  76                 subs->transfer_done -= runtime->period_size;
  77                 snd_pcm_period_elapsed(subs->pcm_substream);
  78         }
  79         return 0;
  80 }
  81
  82 static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime,
  83                                               struct usX2Ydev * usX2Y)
  84 {
  85         return (runtime->buffer_size * 1000) / usX2Y->rate + 1; //FIXME: so far only correct period_size == 2^x ?
  86 }
  87
  88 /*
  89  * prepare urb for playback data pipe
  90  *
  91  * we copy the data directly from the pcm buffer.
  92  * the current position to be copied is held in hwptr field.
  93  * since a urb can handle only a single linear buffer, if the total
  94  * transferred area overflows the buffer boundary, we cannot send
  95  * it directly from the buffer.  thus the data is once copied to
  96  * a temporary buffer and urb points to that.
  97  */
  98 static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs,
  99                                         struct urb *urb)
 100 {
 101         int count, counts, pack;
 102         struct usX2Ydev *usX2Y = subs->usX2Y;
 103         struct snd_usX2Y_hwdep_pcm_shm *shm = usX2Y->hwdep_pcm_shm;
 104         struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
 105
 106         if (0 > shm->playback_iso_start) {
 107                 shm->playback_iso_start = shm->captured_iso_head -
 108                         usX2Y_iso_frames_per_buffer(runtime, usX2Y);
 109                 if (0 > shm->playback_iso_start)
 110                         shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso);
 111                 shm->playback_iso_head = shm->playback_iso_start;
 112         }
 113
 114         count = 0;
 115         for (pack = 0; pack < nr_of_packs(); pack++) {
 116                 /* calculate the size of a packet */
 117                 counts = shm->captured_iso[shm->playback_iso_head].length / usX2Y->stride;
 118                 if (counts < 43 || counts > 50) {
 119                         snd_printk(KERN_ERR "should not be here with counts=%i\n", counts);
 120                         return -EPIPE;
 121                 }
 122                 /* set up descriptor */
 123                 urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset;
 124                 urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length;
 125                 if (atomic_read(&subs->state) != state_RUNNING)
 126                         memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0,
 127                                urb->iso_frame_desc[pack].length);
 128                 if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso))
 129                         shm->playback_iso_head = 0;
 130                 count += counts;
 131         }
 132         urb->transfer_buffer_length = count * usX2Y->stride;
 133         return 0;
 134 }
 135
 136
 137 static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream *subs,
 138                                                      struct urb *urb)
 139 {
 140         int pack;
 141         for (pack = 0; pack < nr_of_packs(); ++pack) {
 142                 struct usb_iso_packet_descriptor *desc = urb->iso_frame_desc + pack;
 143                 if (NULL != subs) {
 144                         struct snd_usX2Y_hwdep_pcm_shm *shm = subs->usX2Y->hwdep_pcm_shm;
 145                         int head = shm->captured_iso_head + 1;
 146                         if (head >= ARRAY_SIZE(shm->captured_iso))
 147                                 head = 0;
 148                         shm->captured_iso[head].frame = urb->start_frame + pack;
 149                         shm->captured_iso[head].offset = desc->offset;
 150                         shm->captured_iso[head].length = desc->actual_length;
 151                         shm->captured_iso_head = head;
 152                         shm->captured_iso_frames++;
 153                 }
 154                 if ((desc->offset += desc->length * NRURBS*nr_of_packs()) +
 155                     desc->length >= SSS)
 156                         desc->offset -= (SSS - desc->length);
 157         }
 158 }
 159
 160 static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *capsubs,
 161                                                  struct snd_usX2Y_substream *capsubs2,
 162                                                  struct snd_usX2Y_substream *playbacksubs,
 163                                                  int frame)
 164 {
 165         int err, state;
 166         struct urb *urb = playbacksubs->completed_urb;
 167
 168         state = atomic_read(&playbacksubs->state);
 169         if (NULL != urb) {
 170                 if (state == state_RUNNING)
 171                         usX2Y_urb_play_retire(playbacksubs, urb);
 172                 else if (state >= state_PRERUNNING)
 173                         atomic_inc(&playbacksubs->state);
 174         } else {
 175                 switch (state) {
 176                 case state_STARTING1:
 177                         urb = playbacksubs->urb[0];
 178                         atomic_inc(&playbacksubs->state);
 179                         break;
 180                 case state_STARTING2:
 181                         urb = playbacksubs->urb[1];
 182                         atomic_inc(&playbacksubs->state);
 183                         break;
 184                 }
 185         }
 186         if (urb) {
 187                 if ((err = usX2Y_hwdep_urb_play_prepare(playbacksubs, urb)) ||
 188                     (err = usX2Y_urb_submit(playbacksubs, urb, frame))) {
 189                         return err;
 190                 }
 191         }
 192
 193         playbacksubs->completed_urb = NULL;
 194
 195         state = atomic_read(&capsubs->state);
 196         if (state >= state_PREPARED) {
 197                 if (state == state_RUNNING) {
 198                         if ((err = usX2Y_usbpcm_urb_capt_retire(capsubs)))
 199                                 return err;
 200                 } else if (state >= state_PRERUNNING)
 201                         atomic_inc(&capsubs->state);
 202                 usX2Y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb);
 203                 if (NULL != capsubs2)
 204                         usX2Y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb);
 205                 if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame)))
 206                         return err;
 207                 if (NULL != capsubs2)
 208                         if ((err = usX2Y_urb_submit(capsubs2, capsubs2->completed_urb, frame)))
 209                                 return err;
 210         }
 211         capsubs->completed_urb = NULL;
 212         if (NULL != capsubs2)
 213                 capsubs2->completed_urb = NULL;
 214         return 0;
 215 }
 216
 217
 218 static void i_usX2Y_usbpcm_urb_complete(struct urb *urb)
 219 {
 220         struct snd_usX2Y_substream *subs = urb->context;
 221         struct usX2Ydev *usX2Y = subs->usX2Y;
 222         struct snd_usX2Y_substream *capsubs, *capsubs2, *playbacksubs;
 223
 224         if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
 225                 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
 226                             usb_get_current_frame_number(usX2Y->dev),
 227                             subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
 228                             urb->status, urb->start_frame);
 229                 return;
 230         }
 231         if (unlikely(urb->status)) {
 232                 usX2Y_error_urb_status(usX2Y, subs, urb);
 233                 return;
 234         }
 235
 236         subs->completed_urb = urb;
 237         capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
 238         capsubs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
 239         playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
 240         if (capsubs->completed_urb && atomic_read(&capsubs->state) >= state_PREPARED &&
 241             (NULL == capsubs2 || capsubs2->completed_urb) &&
 242             (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < state_PREPARED)) {
 243                 if (!usX2Y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame))
 244                         usX2Y->wait_iso_frame += nr_of_packs();
 245                 else {
 246                         snd_printdd("\n");
 247                         usX2Y_clients_stop(usX2Y);
 248                 }
 249         }
 250 }
 251
 252
 253 static void usX2Y_hwdep_urb_release(struct urb **urb)
 254 {
 255         usb_kill_urb(*urb);
 256         usb_free_urb(*urb);
 257         *urb = NULL;
 258 }
 259
 260 /*
 261  * release a substream
 262  */
 263 static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs)
 264 {
 265         int i;
 266         snd_printdd("snd_usX2Y_urbs_release() %i\n", subs->endpoint);
 267         for (i = 0; i < NRURBS; i++)
 268                 usX2Y_hwdep_urb_release(subs->urb + i);
 269 }
 270
 271 static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y)
 272 {
 273         usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_urb_complete);
 274         usX2Y->prepare_subs = NULL;
 275 }
 276
 277 static void i_usX2Y_usbpcm_subs_startup(struct urb *urb)
 278 {
 279         struct snd_usX2Y_substream *subs = urb->context;
 280         struct usX2Ydev *usX2Y = subs->usX2Y;
 281         struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs;
 282         if (NULL != prepare_subs &&
 283             urb->start_frame == prepare_subs->urb[0]->start_frame) {
 284                 atomic_inc(&prepare_subs->state);
 285                 if (prepare_subs == usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]) {
 286                         struct snd_usX2Y_substream *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
 287                         if (cap_subs2 != NULL)
 288                                 atomic_inc(&cap_subs2->state);
 289                 }
 290                 usX2Y_usbpcm_subs_startup_finish(usX2Y);
 291                 wake_up(&usX2Y->prepare_wait_queue);
 292         }
 293
 294         i_usX2Y_usbpcm_urb_complete(urb);
 295 }
 296
 297 /*
 298  * initialize a substream's urbs
 299  */
 300 static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs)
 301 {
 302         int i;
 303         unsigned int pipe;
 304         int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
 305         struct usb_device *dev = subs->usX2Y->dev;
 306
 307         pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
 308                         usb_rcvisocpipe(dev, subs->endpoint);
 309         subs->maxpacksize = usb_maxpacket(dev, pipe, is_playback);
 310         if (!subs->maxpacksize)
 311                 return -EINVAL;
 312
 313         /* allocate and initialize data urbs */
 314         for (i = 0; i < NRURBS; i++) {
 315                 struct urb **purb = subs->urb + i;
 316                 if (*purb) {
 317                         usb_kill_urb(*purb);
 318                         continue;
 319                 }
 320                 *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL);
 321                 if (NULL == *purb) {
 322                         usX2Y_usbpcm_urbs_release(subs);
 323                         return -ENOMEM;
 324                 }
 325                 (*purb)->transfer_buffer = is_playback ?
 326                         subs->usX2Y->hwdep_pcm_shm->playback : (
 327                                 subs->endpoint == 0x8 ?
 328                                 subs->usX2Y->hwdep_pcm_shm->capture0x8 :
 329                                 subs->usX2Y->hwdep_pcm_shm->capture0xA);
 330
 331                 (*purb)->dev = dev;
 332                 (*purb)->pipe = pipe;
 333                 (*purb)->number_of_packets = nr_of_packs();
 334                 (*purb)->context = subs;
 335                 (*purb)->interval = 1;
 336                 (*purb)->complete = i_usX2Y_usbpcm_subs_startup;
 337         }
 338         return 0;
 339 }
 340
 341 /*
 342  * free the buffer
 343  */
 344 static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream)
 345 {
 346         struct snd_pcm_runtime *runtime = substream->runtime;
 347         struct snd_usX2Y_substream *subs = runtime->private_data,
 348                 *cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
 349         mutex_lock(&subs->usX2Y->pcm_mutex);
 350         snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream);
 351
 352         if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) {
 353                 struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
 354                 atomic_set(&subs->state, state_STOPPED);
 355                 usX2Y_usbpcm_urbs_release(subs);
 356                 if (!cap_subs->pcm_substream ||
 357                     !cap_subs->pcm_substream->runtime ||
 358                     !cap_subs->pcm_substream->runtime->status ||
 359                     cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) {
 360                         atomic_set(&cap_subs->state, state_STOPPED);
 361                         if (NULL != cap_subs2)
 362                                 atomic_set(&cap_subs2->state, state_STOPPED);
 363                         usX2Y_usbpcm_urbs_release(cap_subs);
 364                         if (NULL != cap_subs2)
 365                                 usX2Y_usbpcm_urbs_release(cap_subs2);
 366                 }
 367         } else {
 368                 struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
 369                 if (atomic_read(&playback_subs->state) < state_PREPARED) {
 370                         atomic_set(&subs->state, state_STOPPED);
 371                         if (NULL != cap_subs2)
 372                                 atomic_set(&cap_subs2->state, state_STOPPED);
 373                         usX2Y_usbpcm_urbs_release(subs);
 374                         if (NULL != cap_subs2)
 375                                 usX2Y_usbpcm_urbs_release(cap_subs2);
 376                 }
 377         }
 378         mutex_unlock(&subs->usX2Y->pcm_mutex);
 379         return 0;
 380 }
 381
 382 static void usX2Y_usbpcm_subs_startup(struct snd_usX2Y_substream *subs)
 383 {
 384         struct usX2Ydev * usX2Y = subs->usX2Y;
 385         usX2Y->prepare_subs = subs;
 386         subs->urb[0]->start_frame = -1;
 387         smp_wmb();      // Make sure above modifications are seen by i_usX2Y_subs_startup()
 388         usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_subs_startup);
 389 }
 390
 391 static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs)
 392 {
 393         int     p, u, err,
 394                 stream = subs->pcm_substream->stream;
 395         struct usX2Ydev *usX2Y = subs->usX2Y;
 396
 397         if (SNDRV_PCM_STREAM_CAPTURE == stream) {
 398                 usX2Y->hwdep_pcm_shm->captured_iso_head = -1;
 399                 usX2Y->hwdep_pcm_shm->captured_iso_frames = 0;
 400         }
 401
 402         for (p = 0; 3 >= (stream + p); p += 2) {
 403                 struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p];
 404                 if (subs != NULL) {
 405                         if ((err = usX2Y_usbpcm_urbs_allocate(subs)) < 0)
 406                                 return err;
 407                         subs->completed_urb = NULL;
 408                 }
 409         }
 410
 411         for (p = 0; p < 4; p++) {
 412                 struct snd_usX2Y_substream *subs = usX2Y->subs[p];
 413                 if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED)
 414                         goto start;
 415         }
 416
 417  start:
 418         usX2Y_usbpcm_subs_startup(subs);
 419         for (u = 0; u < NRURBS; u++) {
 420                 for (p = 0; 3 >= (stream + p); p += 2) {
 421                         struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p];
 422                         if (subs != NULL) {
 423                                 struct urb *urb = subs->urb[u];
 424                                 if (usb_pipein(urb->pipe)) {
 425                                         unsigned long pack;
 426                                         if (0 == u)
 427                                                 atomic_set(&subs->state, state_STARTING3);
 428                                         urb->dev = usX2Y->dev;
 429                                         for (pack = 0; pack < nr_of_packs(); pack++) {
 430                                                 urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs());
 431                                                 urb->iso_frame_desc[pack].length = subs->maxpacksize;
 432                                         }
 433                                         urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs();
 434                                         if ((err = usb_submit_urb(urb, GFP_KERNEL)) < 0) {
 435                                                 snd_printk (KERN_ERR "cannot usb_submit_urb() for urb %d, err = %d\n", u, err);
 436                                                 err = -EPIPE;
 437                                                 goto cleanup;
 438                                         }  else {
 439                                                 snd_printdd("%i\n", urb->start_frame);
 440                                                 if (u == 0)
 441                                                         usX2Y->wait_iso_frame = urb->start_frame;
 442                                         }
 443                                         urb->transfer_flags = 0;
 444                                 } else {
 445                                         atomic_set(&subs->state, state_STARTING1);
 446                                         break;
 447                                 }
 448                         }
 449                 }
 450         }
 451         err = 0;
 452         wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs);
 453         if (atomic_read(&subs->state) != state_PREPARED)
 454                 err = -EPIPE;
 455
 456  cleanup:
 457         if (err) {
 458                 usX2Y_subs_startup_finish(usX2Y);       // Call it now
 459                 usX2Y_clients_stop(usX2Y);              // something is completely wroong > stop evrything
 460         }
 461         return err;
 462 }
 463
 464 /*
 465  * prepare callback
 466  *
 467  * set format and initialize urbs
 468  */
 469 static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream)
 470 {
 471         struct snd_pcm_runtime *runtime = substream->runtime;
 472         struct snd_usX2Y_substream *subs = runtime->private_data;
 473         struct usX2Ydev *usX2Y = subs->usX2Y;
 474         struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
 475         int err = 0;
 476         snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream);
 477
 478         if (NULL == usX2Y->hwdep_pcm_shm) {
 479                 usX2Y->hwdep_pcm_shm = alloc_pages_exact(sizeof(struct snd_usX2Y_hwdep_pcm_shm),
 480                                                          GFP_KERNEL);
 481                 if (!usX2Y->hwdep_pcm_shm)
 482                         return -ENOMEM;
 483                 memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm));
 484         }
 485
 486         mutex_lock(&usX2Y->pcm_mutex);
 487         usX2Y_subs_prepare(subs);
 488 // Start hardware streams
 489 // SyncStream first....
 490         if (atomic_read(&capsubs->state) < state_PREPARED) {
 491                 if (usX2Y->format != runtime->format)
 492                         if ((err = usX2Y_format_set(usX2Y, runtime->format)) < 0)
 493                                 goto up_prepare_mutex;
 494                 if (usX2Y->rate != runtime->rate)
 495                         if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0)
 496                                 goto up_prepare_mutex;
 497                 snd_printdd("starting capture pipe for %s\n", subs == capsubs ?
 498                             "self" : "playpipe");
 499                 if (0 > (err = usX2Y_usbpcm_urbs_start(capsubs)))
 500                         goto up_prepare_mutex;
 501         }
 502
 503         if (subs != capsubs) {
 504                 usX2Y->hwdep_pcm_shm->playback_iso_start = -1;
 505                 if (atomic_read(&subs->state) < state_PREPARED) {
 506                         while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) >
 507                                usX2Y->hwdep_pcm_shm->captured_iso_frames) {
 508                                 snd_printdd("Wait: iso_frames_per_buffer=%i,"
 509                                             "captured_iso_frames=%i\n",
 510                                             usX2Y_iso_frames_per_buffer(runtime, usX2Y),
 511                                             usX2Y->hwdep_pcm_shm->captured_iso_frames);
 512                                 if (msleep_interruptible(10)) {
 513                                         err = -ERESTARTSYS;
 514                                         goto up_prepare_mutex;
 515                                 }
 516                         }
 517                         if (0 > (err = usX2Y_usbpcm_urbs_start(subs)))
 518                                 goto up_prepare_mutex;
 519                 }
 520                 snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n",
 521                             usX2Y_iso_frames_per_buffer(runtime, usX2Y),
 522                             usX2Y->hwdep_pcm_shm->captured_iso_frames);
 523         } else
 524                 usX2Y->hwdep_pcm_shm->capture_iso_start = -1;
 525
 526  up_prepare_mutex:
 527         mutex_unlock(&usX2Y->pcm_mutex);
 528         return err;
 529 }
 530
 531 static const struct snd_pcm_hardware snd_usX2Y_4c =
 532 {
 533         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 534                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
 535                                  SNDRV_PCM_INFO_MMAP_VALID),
 536         .formats =                 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
 537         .rates =                   SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
 538         .rate_min =                44100,
 539         .rate_max =                48000,
 540         .channels_min =            2,
 541         .channels_max =            4,
 542         .buffer_bytes_max =     (2*128*1024),
 543         .period_bytes_min =     64,
 544         .period_bytes_max =     (128*1024),
 545         .periods_min =          2,
 546         .periods_max =          1024,
 547         .fifo_size =              0
 548 };
 549
 550
 551
 552 static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream)
 553 {
 554         struct snd_usX2Y_substream      *subs = ((struct snd_usX2Y_substream **)
 555                                          snd_pcm_substream_chip(substream))[substream->stream];
 556         struct snd_pcm_runtime  *runtime = substream->runtime;
 557
 558         if (!(subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS))
 559                 return -EBUSY;
 560
 561         runtime->hw = SNDRV_PCM_STREAM_PLAYBACK == substream->stream ? snd_usX2Y_2c :
 562                 (subs->usX2Y->subs[3] ? snd_usX2Y_4c : snd_usX2Y_2c);
 563         runtime->private_data = subs;
 564         subs->pcm_substream = substream;
 565         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000);
 566         return 0;
 567 }
 568
 569
 570 static int snd_usX2Y_usbpcm_close(struct snd_pcm_substream *substream)
 571 {
 572         struct snd_pcm_runtime *runtime = substream->runtime;
 573         struct snd_usX2Y_substream *subs = runtime->private_data;
 574
 575         subs->pcm_substream = NULL;
 576         return 0;
 577 }
 578
 579
 580 static const struct snd_pcm_ops snd_usX2Y_usbpcm_ops =
 581 {
 582         .open =         snd_usX2Y_usbpcm_open,
 583         .close =        snd_usX2Y_usbpcm_close,
 584         .hw_params =    snd_usX2Y_pcm_hw_params,
 585         .hw_free =      snd_usX2Y_usbpcm_hw_free,
 586         .prepare =      snd_usX2Y_usbpcm_prepare,
 587         .trigger =      snd_usX2Y_pcm_trigger,
 588         .pointer =      snd_usX2Y_pcm_pointer,
 589 };
 590
 591
 592 static int usX2Y_pcms_busy_check(struct snd_card *card)
 593 {
 594         struct usX2Ydev *dev = usX2Y(card);
 595         int i;
 596
 597         for (i = 0; i < dev->pcm_devs * 2; i++) {
 598                 struct snd_usX2Y_substream *subs = dev->subs[i];
 599                 if (subs && subs->pcm_substream &&
 600                     SUBSTREAM_BUSY(subs->pcm_substream))
 601                         return -EBUSY;
 602         }
 603         return 0;
 604 }
 605
 606 static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file)
 607 {
 608         struct snd_card *card = hw->card;
 609         int err;
 610
 611         mutex_lock(&usX2Y(card)->pcm_mutex);
 612         err = usX2Y_pcms_busy_check(card);
 613         if (!err)
 614                 usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS;
 615         mutex_unlock(&usX2Y(card)->pcm_mutex);
 616         return err;
 617 }
 618
 619
 620 static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file)
 621 {
 622         struct snd_card *card = hw->card;
 623         int err;
 624
 625         mutex_lock(&usX2Y(card)->pcm_mutex);
 626         err = usX2Y_pcms_busy_check(card);
 627         if (!err)
 628                 usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS;
 629         mutex_unlock(&usX2Y(card)->pcm_mutex);
 630         return err;
 631 }
 632
 633
 634 static void snd_usX2Y_hwdep_pcm_vm_open(struct vm_area_struct *area)
 635 {
 636 }
 637
 638
 639 static void snd_usX2Y_hwdep_pcm_vm_close(struct vm_area_struct *area)
 640 {
 641 }
 642
 643
 644 static vm_fault_t snd_usX2Y_hwdep_pcm_vm_fault(struct vm_fault *vmf)
 645 {
 646         unsigned long offset;
 647         void *vaddr;
 648
 649         offset = vmf->pgoff << PAGE_SHIFT;
 650         vaddr = (char *)((struct usX2Ydev *)vmf->vma->vm_private_data)->hwdep_pcm_shm + offset;
 651         vmf->page = virt_to_page(vaddr);
 652         get_page(vmf->page);
 653         return 0;
 654 }
 655
 656
 657 static const struct vm_operations_struct snd_usX2Y_hwdep_pcm_vm_ops = {
 658         .open = snd_usX2Y_hwdep_pcm_vm_open,
 659         .close = snd_usX2Y_hwdep_pcm_vm_close,
 660         .fault = snd_usX2Y_hwdep_pcm_vm_fault,
 661 };
 662
 663
 664 static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area)
 665 {
 666         unsigned long   size = (unsigned long)(area->vm_end - area->vm_start);
 667         struct usX2Ydev *usX2Y = hw->private_data;
 668
 669         if (!(usX2Y->chip_status & USX2Y_STAT_CHIP_INIT))
 670                 return -EBUSY;
 671
 672         /* if userspace tries to mmap beyond end of our buffer, fail */
 673         if (size > PAGE_ALIGN(sizeof(struct snd_usX2Y_hwdep_pcm_shm))) {
 674                 snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usX2Y_hwdep_pcm_shm));
 675                 return -EINVAL;
 676         }
 677
 678         if (!usX2Y->hwdep_pcm_shm) {
 679                 return -ENODEV;
 680         }
 681         area->vm_ops = &snd_usX2Y_hwdep_pcm_vm_ops;
 682         area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
 683         area->vm_private_data = hw->private_data;
 684         return 0;
 685 }
 686
 687
 688 static void snd_usX2Y_hwdep_pcm_private_free(struct snd_hwdep *hwdep)
 689 {
 690         struct usX2Ydev *usX2Y = hwdep->private_data;
 691         if (NULL != usX2Y->hwdep_pcm_shm)
 692                 free_pages_exact(usX2Y->hwdep_pcm_shm, sizeof(struct snd_usX2Y_hwdep_pcm_shm));
 693 }
 694
 695
 696 int usX2Y_hwdep_pcm_new(struct snd_card *card)
 697 {
 698         int err;
 699         struct snd_hwdep *hw;
 700         struct snd_pcm *pcm;
 701         struct usb_device *dev = usX2Y(card)->dev;
 702         if (1 != nr_of_packs())
 703                 return 0;
 704
 705         if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0)
 706                 return err;
 707
 708         hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM;
 709         hw->private_data = usX2Y(card);
 710         hw->private_free = snd_usX2Y_hwdep_pcm_private_free;
 711         hw->ops.open = snd_usX2Y_hwdep_pcm_open;
 712         hw->ops.release = snd_usX2Y_hwdep_pcm_release;
 713         hw->ops.mmap = snd_usX2Y_hwdep_pcm_mmap;
 714         hw->exclusive = 1;
 715         sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum);
 716
 717         err = snd_pcm_new(card, NAME_ALLCAPS" hwdep Audio", 2, 1, 1, &pcm);
 718         if (err < 0) {
 719                 return err;
 720         }
 721         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usX2Y_usbpcm_ops);
 722         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_usbpcm_ops);
 723
 724         pcm->private_data = usX2Y(card)->subs;
 725         pcm->info_flags = 0;
 726
 727         sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio");
 728         snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
 729                                    SNDRV_DMA_TYPE_CONTINUOUS,
 730                                    NULL,
 731                                    64*1024, 128*1024);
 732         snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
 733                                    SNDRV_DMA_TYPE_CONTINUOUS,
 734                                    NULL,
 735                                    64*1024, 128*1024);
 736
 737         return 0;
 738 }
 739
 740 #else
 741
 742 int usX2Y_hwdep_pcm_new(struct snd_card *card)
 743 {
 744         return 0;
 745 }
 746
 747 #endif