~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/usb/caiaq/audio.c

Version: ~ [ linux-5.3-rc4 ] ~ [ linux-5.2.8 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.66 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.138 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.71 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *   Copyright (c) 2006-2008 Daniel Mack, Karsten Wiese
  3  *
  4  *   This program is free software; you can redistribute it and/or modify
  5  *   it under the terms of the GNU General Public License as published by
  6  *   the Free Software Foundation; either version 2 of the License, or
  7  *   (at your option) any later version.
  8  *
  9  *   This program is distributed in the hope that it will be useful,
 10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12  *   GNU General Public License for more details.
 13  *
 14  *   You should have received a copy of the GNU General Public License
 15  *   along with this program; if not, write to the Free Software
 16  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 17 */
 18 
 19 #include <linux/device.h>
 20 #include <linux/spinlock.h>
 21 #include <linux/slab.h>
 22 #include <linux/init.h>
 23 #include <linux/usb.h>
 24 #include <sound/core.h>
 25 #include <sound/pcm.h>
 26 
 27 #include "device.h"
 28 #include "audio.h"
 29 
 30 #define N_URBS                  32
 31 #define CLOCK_DRIFT_TOLERANCE   5
 32 #define FRAMES_PER_URB          8
 33 #define BYTES_PER_FRAME         512
 34 #define CHANNELS_PER_STREAM     2
 35 #define BYTES_PER_SAMPLE        3
 36 #define BYTES_PER_SAMPLE_USB    4
 37 #define MAX_BUFFER_SIZE         (128*1024)
 38 #define MAX_ENDPOINT_SIZE       512
 39 
 40 #define ENDPOINT_CAPTURE        2
 41 #define ENDPOINT_PLAYBACK       6
 42 
 43 #define MAKE_CHECKBYTE(cdev,stream,i) \
 44         (stream << 1) | (~(i / (cdev->n_streams * BYTES_PER_SAMPLE_USB)) & 1)
 45 
 46 static struct snd_pcm_hardware snd_usb_caiaq_pcm_hardware = {
 47         .info           = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 48                            SNDRV_PCM_INFO_BLOCK_TRANSFER),
 49         .formats        = SNDRV_PCM_FMTBIT_S24_3BE,
 50         .rates          = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
 51                            SNDRV_PCM_RATE_96000),
 52         .rate_min       = 44100,
 53         .rate_max       = 0, /* will overwrite later */
 54         .channels_min   = CHANNELS_PER_STREAM,
 55         .channels_max   = CHANNELS_PER_STREAM,
 56         .buffer_bytes_max = MAX_BUFFER_SIZE,
 57         .period_bytes_min = 128,
 58         .period_bytes_max = MAX_BUFFER_SIZE,
 59         .periods_min    = 1,
 60         .periods_max    = 1024,
 61 };
 62 
 63 static void
 64 activate_substream(struct snd_usb_caiaqdev *cdev,
 65                    struct snd_pcm_substream *sub)
 66 {
 67         spin_lock(&cdev->spinlock);
 68 
 69         if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
 70                 cdev->sub_playback[sub->number] = sub;
 71         else
 72                 cdev->sub_capture[sub->number] = sub;
 73 
 74         spin_unlock(&cdev->spinlock);
 75 }
 76 
 77 static void
 78 deactivate_substream(struct snd_usb_caiaqdev *cdev,
 79                      struct snd_pcm_substream *sub)
 80 {
 81         unsigned long flags;
 82         spin_lock_irqsave(&cdev->spinlock, flags);
 83 
 84         if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
 85                 cdev->sub_playback[sub->number] = NULL;
 86         else
 87                 cdev->sub_capture[sub->number] = NULL;
 88 
 89         spin_unlock_irqrestore(&cdev->spinlock, flags);
 90 }
 91 
 92 static int
 93 all_substreams_zero(struct snd_pcm_substream **subs)
 94 {
 95         int i;
 96         for (i = 0; i < MAX_STREAMS; i++)
 97                 if (subs[i] != NULL)
 98                         return 0;
 99         return 1;
100 }
101 
102 static int stream_start(struct snd_usb_caiaqdev *cdev)
103 {
104         int i, ret;
105         struct device *dev = caiaqdev_to_dev(cdev);
106 
107         dev_dbg(dev, "%s(%p)\n", __func__, cdev);
108 
109         if (cdev->streaming)
110                 return -EINVAL;
111 
112         memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));
113         memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));
114         cdev->input_panic = 0;
115         cdev->output_panic = 0;
116         cdev->first_packet = 4;
117         cdev->streaming = 1;
118         cdev->warned = 0;
119 
120         for (i = 0; i < N_URBS; i++) {
121                 ret = usb_submit_urb(cdev->data_urbs_in[i], GFP_ATOMIC);
122                 if (ret) {
123                         dev_err(dev, "unable to trigger read #%d! (ret %d)\n",
124                                 i, ret);
125                         cdev->streaming = 0;
126                         return -EPIPE;
127                 }
128         }
129 
130         return 0;
131 }
132 
133 static void stream_stop(struct snd_usb_caiaqdev *cdev)
134 {
135         int i;
136         struct device *dev = caiaqdev_to_dev(cdev);
137 
138         dev_dbg(dev, "%s(%p)\n", __func__, cdev);
139         if (!cdev->streaming)
140                 return;
141 
142         cdev->streaming = 0;
143 
144         for (i = 0; i < N_URBS; i++) {
145                 usb_kill_urb(cdev->data_urbs_in[i]);
146 
147                 if (test_bit(i, &cdev->outurb_active_mask))
148                         usb_kill_urb(cdev->data_urbs_out[i]);
149         }
150 
151         cdev->outurb_active_mask = 0;
152 }
153 
154 static int snd_usb_caiaq_substream_open(struct snd_pcm_substream *substream)
155 {
156         struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
157         struct device *dev = caiaqdev_to_dev(cdev);
158 
159         dev_dbg(dev, "%s(%p)\n", __func__, substream);
160         substream->runtime->hw = cdev->pcm_info;
161         snd_pcm_limit_hw_rates(substream->runtime);
162 
163         return 0;
164 }
165 
166 static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream)
167 {
168         struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
169         struct device *dev = caiaqdev_to_dev(cdev);
170 
171         dev_dbg(dev, "%s(%p)\n", __func__, substream);
172         if (all_substreams_zero(cdev->sub_playback) &&
173             all_substreams_zero(cdev->sub_capture)) {
174                 /* when the last client has stopped streaming,
175                  * all sample rates are allowed again */
176                 stream_stop(cdev);
177                 cdev->pcm_info.rates = cdev->samplerates;
178         }
179 
180         return 0;
181 }
182 
183 static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream *sub,
184                                        struct snd_pcm_hw_params *hw_params)
185 {
186         return snd_pcm_lib_alloc_vmalloc_buffer(sub,
187                                                 params_buffer_bytes(hw_params));
188 }
189 
190 static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub)
191 {
192         struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
193         deactivate_substream(cdev, sub);
194         return snd_pcm_lib_free_vmalloc_buffer(sub);
195 }
196 
197 /* this should probably go upstream */
198 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
199 #error "Change this table"
200 #endif
201 
202 static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
203                                 48000, 64000, 88200, 96000, 176400, 192000 };
204 
205 static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
206 {
207         int bytes_per_sample, bpp, ret, i;
208         int index = substream->number;
209         struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
210         struct snd_pcm_runtime *runtime = substream->runtime;
211         struct device *dev = caiaqdev_to_dev(cdev);
212 
213         dev_dbg(dev, "%s(%p)\n", __func__, substream);
214 
215         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
216                 int out_pos;
217 
218                 switch (cdev->spec.data_alignment) {
219                 case 0:
220                 case 2:
221                         out_pos = BYTES_PER_SAMPLE + 1;
222                         break;
223                 case 3:
224                 default:
225                         out_pos = 0;
226                         break;
227                 }
228 
229                 cdev->period_out_count[index] = out_pos;
230                 cdev->audio_out_buf_pos[index] = out_pos;
231         } else {
232                 int in_pos;
233 
234                 switch (cdev->spec.data_alignment) {
235                 case 0:
236                         in_pos = BYTES_PER_SAMPLE + 2;
237                         break;
238                 case 2:
239                         in_pos = BYTES_PER_SAMPLE;
240                         break;
241                 case 3:
242                 default:
243                         in_pos = 0;
244                         break;
245                 }
246 
247                 cdev->period_in_count[index] = in_pos;
248                 cdev->audio_in_buf_pos[index] = in_pos;
249         }
250 
251         if (cdev->streaming)
252                 return 0;
253 
254         /* the first client that opens a stream defines the sample rate
255          * setting for all subsequent calls, until the last client closed. */
256         for (i=0; i < ARRAY_SIZE(rates); i++)
257                 if (runtime->rate == rates[i])
258                         cdev->pcm_info.rates = 1 << i;
259 
260         snd_pcm_limit_hw_rates(runtime);
261 
262         bytes_per_sample = BYTES_PER_SAMPLE;
263         if (cdev->spec.data_alignment >= 2)
264                 bytes_per_sample++;
265 
266         bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE)
267                 * bytes_per_sample * CHANNELS_PER_STREAM * cdev->n_streams;
268 
269         if (bpp > MAX_ENDPOINT_SIZE)
270                 bpp = MAX_ENDPOINT_SIZE;
271 
272         ret = snd_usb_caiaq_set_audio_params(cdev, runtime->rate,
273                                              runtime->sample_bits, bpp);
274         if (ret)
275                 return ret;
276 
277         ret = stream_start(cdev);
278         if (ret)
279                 return ret;
280 
281         cdev->output_running = 0;
282         wait_event_timeout(cdev->prepare_wait_queue, cdev->output_running, HZ);
283         if (!cdev->output_running) {
284                 stream_stop(cdev);
285                 return -EPIPE;
286         }
287 
288         return 0;
289 }
290 
291 static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd)
292 {
293         struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
294         struct device *dev = caiaqdev_to_dev(cdev);
295 
296         dev_dbg(dev, "%s(%p) cmd %d\n", __func__, sub, cmd);
297 
298         switch (cmd) {
299         case SNDRV_PCM_TRIGGER_START:
300         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
301                 activate_substream(cdev, sub);
302                 break;
303         case SNDRV_PCM_TRIGGER_STOP:
304         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
305                 deactivate_substream(cdev, sub);
306                 break;
307         default:
308                 return -EINVAL;
309         }
310 
311         return 0;
312 }
313 
314 static snd_pcm_uframes_t
315 snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub)
316 {
317         int index = sub->number;
318         struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
319         snd_pcm_uframes_t ptr;
320 
321         spin_lock(&cdev->spinlock);
322 
323         if (cdev->input_panic || cdev->output_panic) {
324                 ptr = SNDRV_PCM_POS_XRUN;
325                 goto unlock;
326         }
327 
328         if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
329                 ptr = bytes_to_frames(sub->runtime,
330                                         cdev->audio_out_buf_pos[index]);
331         else
332                 ptr = bytes_to_frames(sub->runtime,
333                                         cdev->audio_in_buf_pos[index]);
334 
335 unlock:
336         spin_unlock(&cdev->spinlock);
337         return ptr;
338 }
339 
340 /* operators for both playback and capture */
341 static struct snd_pcm_ops snd_usb_caiaq_ops = {
342         .open =         snd_usb_caiaq_substream_open,
343         .close =        snd_usb_caiaq_substream_close,
344         .ioctl =        snd_pcm_lib_ioctl,
345         .hw_params =    snd_usb_caiaq_pcm_hw_params,
346         .hw_free =      snd_usb_caiaq_pcm_hw_free,
347         .prepare =      snd_usb_caiaq_pcm_prepare,
348         .trigger =      snd_usb_caiaq_pcm_trigger,
349         .pointer =      snd_usb_caiaq_pcm_pointer,
350         .page =         snd_pcm_lib_get_vmalloc_page,
351         .mmap =         snd_pcm_lib_mmap_vmalloc,
352 };
353 
354 static void check_for_elapsed_periods(struct snd_usb_caiaqdev *cdev,
355                                       struct snd_pcm_substream **subs)
356 {
357         int stream, pb, *cnt;
358         struct snd_pcm_substream *sub;
359 
360         for (stream = 0; stream < cdev->n_streams; stream++) {
361                 sub = subs[stream];
362                 if (!sub)
363                         continue;
364 
365                 pb = snd_pcm_lib_period_bytes(sub);
366                 cnt = (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
367                                         &cdev->period_out_count[stream] :
368                                         &cdev->period_in_count[stream];
369 
370                 if (*cnt >= pb) {
371                         snd_pcm_period_elapsed(sub);
372                         *cnt %= pb;
373                 }
374         }
375 }
376 
377 static void read_in_urb_mode0(struct snd_usb_caiaqdev *cdev,
378                               const struct urb *urb,
379                               const struct usb_iso_packet_descriptor *iso)
380 {
381         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
382         struct snd_pcm_substream *sub;
383         int stream, i;
384 
385         if (all_substreams_zero(cdev->sub_capture))
386                 return;
387 
388         for (i = 0; i < iso->actual_length;) {
389                 for (stream = 0; stream < cdev->n_streams; stream++, i++) {
390                         sub = cdev->sub_capture[stream];
391                         if (sub) {
392                                 struct snd_pcm_runtime *rt = sub->runtime;
393                                 char *audio_buf = rt->dma_area;
394                                 int sz = frames_to_bytes(rt, rt->buffer_size);
395                                 audio_buf[cdev->audio_in_buf_pos[stream]++]
396                                         = usb_buf[i];
397                                 cdev->period_in_count[stream]++;
398                                 if (cdev->audio_in_buf_pos[stream] == sz)
399                                         cdev->audio_in_buf_pos[stream] = 0;
400                         }
401                 }
402         }
403 }
404 
405 static void read_in_urb_mode2(struct snd_usb_caiaqdev *cdev,
406                               const struct urb *urb,
407                               const struct usb_iso_packet_descriptor *iso)
408 {
409         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
410         unsigned char check_byte;
411         struct snd_pcm_substream *sub;
412         int stream, i;
413 
414         for (i = 0; i < iso->actual_length;) {
415                 if (i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) == 0) {
416                         for (stream = 0;
417                              stream < cdev->n_streams;
418                              stream++, i++) {
419                                 if (cdev->first_packet)
420                                         continue;
421 
422                                 check_byte = MAKE_CHECKBYTE(cdev, stream, i);
423 
424                                 if ((usb_buf[i] & 0x3f) != check_byte)
425                                         cdev->input_panic = 1;
426 
427                                 if (usb_buf[i] & 0x80)
428                                         cdev->output_panic = 1;
429                         }
430                 }
431                 cdev->first_packet = 0;
432 
433                 for (stream = 0; stream < cdev->n_streams; stream++, i++) {
434                         sub = cdev->sub_capture[stream];
435                         if (cdev->input_panic)
436                                 usb_buf[i] = 0;
437 
438                         if (sub) {
439                                 struct snd_pcm_runtime *rt = sub->runtime;
440                                 char *audio_buf = rt->dma_area;
441                                 int sz = frames_to_bytes(rt, rt->buffer_size);
442                                 audio_buf[cdev->audio_in_buf_pos[stream]++] =
443                                         usb_buf[i];
444                                 cdev->period_in_count[stream]++;
445                                 if (cdev->audio_in_buf_pos[stream] == sz)
446                                         cdev->audio_in_buf_pos[stream] = 0;
447                         }
448                 }
449         }
450 }
451 
452 static void read_in_urb_mode3(struct snd_usb_caiaqdev *cdev,
453                               const struct urb *urb,
454                               const struct usb_iso_packet_descriptor *iso)
455 {
456         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
457         struct device *dev = caiaqdev_to_dev(cdev);
458         int stream, i;
459 
460         /* paranoia check */
461         if (iso->actual_length % (BYTES_PER_SAMPLE_USB * CHANNELS_PER_STREAM))
462                 return;
463 
464         for (i = 0; i < iso->actual_length;) {
465                 for (stream = 0; stream < cdev->n_streams; stream++) {
466                         struct snd_pcm_substream *sub = cdev->sub_capture[stream];
467                         char *audio_buf = NULL;
468                         int c, n, sz = 0;
469 
470                         if (sub && !cdev->input_panic) {
471                                 struct snd_pcm_runtime *rt = sub->runtime;
472                                 audio_buf = rt->dma_area;
473                                 sz = frames_to_bytes(rt, rt->buffer_size);
474                         }
475 
476                         for (c = 0; c < CHANNELS_PER_STREAM; c++) {
477                                 /* 3 audio data bytes, followed by 1 check byte */
478                                 if (audio_buf) {
479                                         for (n = 0; n < BYTES_PER_SAMPLE; n++) {
480                                                 audio_buf[cdev->audio_in_buf_pos[stream]++] = usb_buf[i+n];
481 
482                                                 if (cdev->audio_in_buf_pos[stream] == sz)
483                                                         cdev->audio_in_buf_pos[stream] = 0;
484                                         }
485 
486                                         cdev->period_in_count[stream] += BYTES_PER_SAMPLE;
487                                 }
488 
489                                 i += BYTES_PER_SAMPLE;
490 
491                                 if (usb_buf[i] != ((stream << 1) | c) &&
492                                     !cdev->first_packet) {
493                                         if (!cdev->input_panic)
494                                                 dev_warn(dev, " EXPECTED: %02x got %02x, c %d, stream %d, i %d\n",
495                                                          ((stream << 1) | c), usb_buf[i], c, stream, i);
496                                         cdev->input_panic = 1;
497                                 }
498 
499                                 i++;
500                         }
501                 }
502         }
503 
504         if (cdev->first_packet > 0)
505                 cdev->first_packet--;
506 }
507 
508 static void read_in_urb(struct snd_usb_caiaqdev *cdev,
509                         const struct urb *urb,
510                         const struct usb_iso_packet_descriptor *iso)
511 {
512         struct device *dev = caiaqdev_to_dev(cdev);
513 
514         if (!cdev->streaming)
515                 return;
516 
517         if (iso->actual_length < cdev->bpp)
518                 return;
519 
520         switch (cdev->spec.data_alignment) {
521         case 0:
522                 read_in_urb_mode0(cdev, urb, iso);
523                 break;
524         case 2:
525                 read_in_urb_mode2(cdev, urb, iso);
526                 break;
527         case 3:
528                 read_in_urb_mode3(cdev, urb, iso);
529                 break;
530         }
531 
532         if ((cdev->input_panic || cdev->output_panic) && !cdev->warned) {
533                 dev_warn(dev, "streaming error detected %s %s\n",
534                                 cdev->input_panic ? "(input)" : "",
535                                 cdev->output_panic ? "(output)" : "");
536                 cdev->warned = 1;
537         }
538 }
539 
540 static void fill_out_urb_mode_0(struct snd_usb_caiaqdev *cdev,
541                                 struct urb *urb,
542                                 const struct usb_iso_packet_descriptor *iso)
543 {
544         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
545         struct snd_pcm_substream *sub;
546         int stream, i;
547 
548         for (i = 0; i < iso->length;) {
549                 for (stream = 0; stream < cdev->n_streams; stream++, i++) {
550                         sub = cdev->sub_playback[stream];
551                         if (sub) {
552                                 struct snd_pcm_runtime *rt = sub->runtime;
553                                 char *audio_buf = rt->dma_area;
554                                 int sz = frames_to_bytes(rt, rt->buffer_size);
555                                 usb_buf[i] =
556                                         audio_buf[cdev->audio_out_buf_pos[stream]];
557                                 cdev->period_out_count[stream]++;
558                                 cdev->audio_out_buf_pos[stream]++;
559                                 if (cdev->audio_out_buf_pos[stream] == sz)
560                                         cdev->audio_out_buf_pos[stream] = 0;
561                         } else
562                                 usb_buf[i] = 0;
563                 }
564 
565                 /* fill in the check bytes */
566                 if (cdev->spec.data_alignment == 2 &&
567                     i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) ==
568                         (cdev->n_streams * CHANNELS_PER_STREAM))
569                         for (stream = 0; stream < cdev->n_streams; stream++, i++)
570                                 usb_buf[i] = MAKE_CHECKBYTE(cdev, stream, i);
571         }
572 }
573 
574 static void fill_out_urb_mode_3(struct snd_usb_caiaqdev *cdev,
575                                 struct urb *urb,
576                                 const struct usb_iso_packet_descriptor *iso)
577 {
578         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
579         int stream, i;
580 
581         for (i = 0; i < iso->length;) {
582                 for (stream = 0; stream < cdev->n_streams; stream++) {
583                         struct snd_pcm_substream *sub = cdev->sub_playback[stream];
584                         char *audio_buf = NULL;
585                         int c, n, sz = 0;
586 
587                         if (sub) {
588                                 struct snd_pcm_runtime *rt = sub->runtime;
589                                 audio_buf = rt->dma_area;
590                                 sz = frames_to_bytes(rt, rt->buffer_size);
591                         }
592 
593                         for (c = 0; c < CHANNELS_PER_STREAM; c++) {
594                                 for (n = 0; n < BYTES_PER_SAMPLE; n++) {
595                                         if (audio_buf) {
596                                                 usb_buf[i+n] = audio_buf[cdev->audio_out_buf_pos[stream]++];
597 
598                                                 if (cdev->audio_out_buf_pos[stream] == sz)
599                                                         cdev->audio_out_buf_pos[stream] = 0;
600                                         } else {
601                                                 usb_buf[i+n] = 0;
602                                         }
603                                 }
604 
605                                 if (audio_buf)
606                                         cdev->period_out_count[stream] += BYTES_PER_SAMPLE;
607 
608                                 i += BYTES_PER_SAMPLE;
609 
610                                 /* fill in the check byte pattern */
611                                 usb_buf[i++] = (stream << 1) | c;
612                         }
613                 }
614         }
615 }
616 
617 static inline void fill_out_urb(struct snd_usb_caiaqdev *cdev,
618                                 struct urb *urb,
619                                 const struct usb_iso_packet_descriptor *iso)
620 {
621         switch (cdev->spec.data_alignment) {
622         case 0:
623         case 2:
624                 fill_out_urb_mode_0(cdev, urb, iso);
625                 break;
626         case 3:
627                 fill_out_urb_mode_3(cdev, urb, iso);
628                 break;
629         }
630 }
631 
632 static void read_completed(struct urb *urb)
633 {
634         struct snd_usb_caiaq_cb_info *info = urb->context;
635         struct snd_usb_caiaqdev *cdev;
636         struct device *dev;
637         struct urb *out = NULL;
638         int i, frame, len, send_it = 0, outframe = 0;
639         size_t offset = 0;
640 
641         if (urb->status || !info)
642                 return;
643 
644         cdev = info->cdev;
645         dev = caiaqdev_to_dev(cdev);
646 
647         if (!cdev->streaming)
648                 return;
649 
650         /* find an unused output urb that is unused */
651         for (i = 0; i < N_URBS; i++)
652                 if (test_and_set_bit(i, &cdev->outurb_active_mask) == 0) {
653                         out = cdev->data_urbs_out[i];
654                         break;
655                 }
656 
657         if (!out) {
658                 dev_err(dev, "Unable to find an output urb to use\n");
659                 goto requeue;
660         }
661 
662         /* read the recently received packet and send back one which has
663          * the same layout */
664         for (frame = 0; frame < FRAMES_PER_URB; frame++) {
665                 if (urb->iso_frame_desc[frame].status)
666                         continue;
667 
668                 len = urb->iso_frame_desc[outframe].actual_length;
669                 out->iso_frame_desc[outframe].length = len;
670                 out->iso_frame_desc[outframe].actual_length = 0;
671                 out->iso_frame_desc[outframe].offset = offset;
672                 offset += len;
673 
674                 if (len > 0) {
675                         spin_lock(&cdev->spinlock);
676                         fill_out_urb(cdev, out, &out->iso_frame_desc[outframe]);
677                         read_in_urb(cdev, urb, &urb->iso_frame_desc[frame]);
678                         spin_unlock(&cdev->spinlock);
679                         check_for_elapsed_periods(cdev, cdev->sub_playback);
680                         check_for_elapsed_periods(cdev, cdev->sub_capture);
681                         send_it = 1;
682                 }
683 
684                 outframe++;
685         }
686 
687         if (send_it) {
688                 out->number_of_packets = outframe;
689                 usb_submit_urb(out, GFP_ATOMIC);
690         } else {
691                 struct snd_usb_caiaq_cb_info *oinfo = out->context;
692                 clear_bit(oinfo->index, &cdev->outurb_active_mask);
693         }
694 
695 requeue:
696         /* re-submit inbound urb */
697         for (frame = 0; frame < FRAMES_PER_URB; frame++) {
698                 urb->iso_frame_desc[frame].offset = BYTES_PER_FRAME * frame;
699                 urb->iso_frame_desc[frame].length = BYTES_PER_FRAME;
700                 urb->iso_frame_desc[frame].actual_length = 0;
701         }
702 
703         urb->number_of_packets = FRAMES_PER_URB;
704         usb_submit_urb(urb, GFP_ATOMIC);
705 }
706 
707 static void write_completed(struct urb *urb)
708 {
709         struct snd_usb_caiaq_cb_info *info = urb->context;
710         struct snd_usb_caiaqdev *cdev = info->cdev;
711 
712         if (!cdev->output_running) {
713                 cdev->output_running = 1;
714                 wake_up(&cdev->prepare_wait_queue);
715         }
716 
717         clear_bit(info->index, &cdev->outurb_active_mask);
718 }
719 
720 static struct urb **alloc_urbs(struct snd_usb_caiaqdev *cdev, int dir, int *ret)
721 {
722         int i, frame;
723         struct urb **urbs;
724         struct usb_device *usb_dev = cdev->chip.dev;
725         struct device *dev = caiaqdev_to_dev(cdev);
726         unsigned int pipe;
727 
728         pipe = (dir == SNDRV_PCM_STREAM_PLAYBACK) ?
729                 usb_sndisocpipe(usb_dev, ENDPOINT_PLAYBACK) :
730                 usb_rcvisocpipe(usb_dev, ENDPOINT_CAPTURE);
731 
732         urbs = kmalloc(N_URBS * sizeof(*urbs), GFP_KERNEL);
733         if (!urbs) {
734                 dev_err(dev, "unable to kmalloc() urbs, OOM!?\n");
735                 *ret = -ENOMEM;
736                 return NULL;
737         }
738 
739         for (i = 0; i < N_URBS; i++) {
740                 urbs[i] = usb_alloc_urb(FRAMES_PER_URB, GFP_KERNEL);
741                 if (!urbs[i]) {
742                         dev_err(dev, "unable to usb_alloc_urb(), OOM!?\n");
743                         *ret = -ENOMEM;
744                         return urbs;
745                 }
746 
747                 urbs[i]->transfer_buffer =
748                         kmalloc(FRAMES_PER_URB * BYTES_PER_FRAME, GFP_KERNEL);
749                 if (!urbs[i]->transfer_buffer) {
750                         dev_err(dev, "unable to kmalloc() transfer buffer, OOM!?\n");
751                         *ret = -ENOMEM;
752                         return urbs;
753                 }
754 
755                 for (frame = 0; frame < FRAMES_PER_URB; frame++) {
756                         struct usb_iso_packet_descriptor *iso =
757                                 &urbs[i]->iso_frame_desc[frame];
758 
759                         iso->offset = BYTES_PER_FRAME * frame;
760                         iso->length = BYTES_PER_FRAME;
761                 }
762 
763                 urbs[i]->dev = usb_dev;
764                 urbs[i]->pipe = pipe;
765                 urbs[i]->transfer_buffer_length = FRAMES_PER_URB
766                                                 * BYTES_PER_FRAME;
767                 urbs[i]->context = &cdev->data_cb_info[i];
768                 urbs[i]->interval = 1;
769                 urbs[i]->number_of_packets = FRAMES_PER_URB;
770                 urbs[i]->complete = (dir == SNDRV_PCM_STREAM_CAPTURE) ?
771                                         read_completed : write_completed;
772         }
773 
774         *ret = 0;
775         return urbs;
776 }
777 
778 static void free_urbs(struct urb **urbs)
779 {
780         int i;
781 
782         if (!urbs)
783                 return;
784 
785         for (i = 0; i < N_URBS; i++) {
786                 if (!urbs[i])
787                         continue;
788 
789                 usb_kill_urb(urbs[i]);
790                 kfree(urbs[i]->transfer_buffer);
791                 usb_free_urb(urbs[i]);
792         }
793 
794         kfree(urbs);
795 }
796 
797 int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *cdev)
798 {
799         int i, ret;
800         struct device *dev = caiaqdev_to_dev(cdev);
801 
802         cdev->n_audio_in  = max(cdev->spec.num_analog_audio_in,
803                                cdev->spec.num_digital_audio_in) /
804                                 CHANNELS_PER_STREAM;
805         cdev->n_audio_out = max(cdev->spec.num_analog_audio_out,
806                                cdev->spec.num_digital_audio_out) /
807                                 CHANNELS_PER_STREAM;
808         cdev->n_streams = max(cdev->n_audio_in, cdev->n_audio_out);
809 
810         dev_dbg(dev, "cdev->n_audio_in = %d\n", cdev->n_audio_in);
811         dev_dbg(dev, "cdev->n_audio_out = %d\n", cdev->n_audio_out);
812         dev_dbg(dev, "cdev->n_streams = %d\n", cdev->n_streams);
813 
814         if (cdev->n_streams > MAX_STREAMS) {
815                 dev_err(dev, "unable to initialize device, too many streams.\n");
816                 return -EINVAL;
817         }
818 
819         if (cdev->n_streams < 1) {
820                 dev_err(dev, "bogus number of streams: %d\n", cdev->n_streams);
821                 return -EINVAL;
822         }
823 
824         ret = snd_pcm_new(cdev->chip.card, cdev->product_name, 0,
825                         cdev->n_audio_out, cdev->n_audio_in, &cdev->pcm);
826 
827         if (ret < 0) {
828                 dev_err(dev, "snd_pcm_new() returned %d\n", ret);
829                 return ret;
830         }
831 
832         cdev->pcm->private_data = cdev;
833         strlcpy(cdev->pcm->name, cdev->product_name, sizeof(cdev->pcm->name));
834 
835         memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));
836         memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));
837 
838         memcpy(&cdev->pcm_info, &snd_usb_caiaq_pcm_hardware,
839                         sizeof(snd_usb_caiaq_pcm_hardware));
840 
841         /* setup samplerates */
842         cdev->samplerates = cdev->pcm_info.rates;
843         switch (cdev->chip.usb_id) {
844         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
845         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
846         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_SESSIONIO):
847         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE):
848                 cdev->samplerates |= SNDRV_PCM_RATE_192000;
849                 /* fall thru */
850         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO2DJ):
851         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
852         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
853         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORAUDIO2):
854                 cdev->samplerates |= SNDRV_PCM_RATE_88200;
855                 break;
856         }
857 
858         snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_PLAYBACK,
859                                 &snd_usb_caiaq_ops);
860         snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_CAPTURE,
861                                 &snd_usb_caiaq_ops);
862 
863         cdev->data_cb_info =
864                 kmalloc(sizeof(struct snd_usb_caiaq_cb_info) * N_URBS,
865                                         GFP_KERNEL);
866 
867         if (!cdev->data_cb_info)
868                 return -ENOMEM;
869 
870         cdev->outurb_active_mask = 0;
871         BUILD_BUG_ON(N_URBS > (sizeof(cdev->outurb_active_mask) * 8));
872 
873         for (i = 0; i < N_URBS; i++) {
874                 cdev->data_cb_info[i].cdev = cdev;
875                 cdev->data_cb_info[i].index = i;
876         }
877 
878         cdev->data_urbs_in = alloc_urbs(cdev, SNDRV_PCM_STREAM_CAPTURE, &ret);
879         if (ret < 0) {
880                 kfree(cdev->data_cb_info);
881                 free_urbs(cdev->data_urbs_in);
882                 return ret;
883         }
884 
885         cdev->data_urbs_out = alloc_urbs(cdev, SNDRV_PCM_STREAM_PLAYBACK, &ret);
886         if (ret < 0) {
887                 kfree(cdev->data_cb_info);
888                 free_urbs(cdev->data_urbs_in);
889                 free_urbs(cdev->data_urbs_out);
890                 return ret;
891         }
892 
893         return 0;
894 }
895 
896 void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev *cdev)
897 {
898         struct device *dev = caiaqdev_to_dev(cdev);
899 
900         dev_dbg(dev, "%s(%p)\n", __func__, cdev);
901         stream_stop(cdev);
902         free_urbs(cdev->data_urbs_in);
903         free_urbs(cdev->data_urbs_out);
904         kfree(cdev->data_cb_info);
905 }
906 
907 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp