2 * Copyright (C) 2007, 2008 Karsten Wiese <fzu@wemgehoertderstaat.de>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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 Foundation,
16 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 #include <linux/usb.h>
20 #include <linux/gfp.h>
22 #include "usb_stream.h"
27 static unsigned usb_stream_next_packet_size(struct usb_stream_kernel
*sk
)
29 struct usb_stream
*s
= sk
->s
;
30 sk
->out_phase_peeked
= (sk
->out_phase
& 0xffff) + sk
->freqn
;
31 return (sk
->out_phase_peeked
>> 16) * s
->cfg
.frame_size
;
34 static void playback_prep_freqn(struct usb_stream_kernel
*sk
, struct urb
*urb
)
36 struct usb_stream
*s
= sk
->s
;
39 for (pack
= 0; pack
< sk
->n_o_ps
; pack
++) {
40 int l
= usb_stream_next_packet_size(sk
);
41 if (s
->idle_outsize
+ lb
+ l
> s
->period_size
)
44 sk
->out_phase
= sk
->out_phase_peeked
;
45 urb
->iso_frame_desc
[pack
].offset
= lb
;
46 urb
->iso_frame_desc
[pack
].length
= l
;
49 snd_printdd(KERN_DEBUG
"%i\n", lb
);
52 urb
->number_of_packets
= pack
;
53 urb
->transfer_buffer_length
= lb
;
54 s
->idle_outsize
+= lb
- s
->period_size
;
55 snd_printdd(KERN_DEBUG
"idle=%i ul=%i ps=%i\n", s
->idle_outsize
,
59 static void init_pipe_urbs(struct usb_stream_kernel
*sk
, unsigned use_packsize
,
60 struct urb
**urbs
, char *transfer
,
61 struct usb_device
*dev
, int pipe
)
64 int maxpacket
= use_packsize
?
65 use_packsize
: usb_maxpacket(dev
, pipe
, usb_pipeout(pipe
));
66 int transfer_length
= maxpacket
* sk
->n_o_ps
;
68 for (u
= 0; u
< USB_STREAM_NURBS
;
69 ++u
, transfer
+= transfer_length
) {
70 struct urb
*urb
= urbs
[u
];
71 struct usb_iso_packet_descriptor
*desc
;
72 urb
->transfer_buffer
= transfer
;
75 urb
->number_of_packets
= sk
->n_o_ps
;
78 if (usb_pipeout(pipe
))
81 urb
->transfer_buffer_length
= transfer_length
;
82 desc
= urb
->iso_frame_desc
;
84 desc
->length
= maxpacket
;
85 for (p
= 1; p
< sk
->n_o_ps
; ++p
) {
86 desc
[p
].offset
= desc
[p
- 1].offset
+ maxpacket
;
87 desc
[p
].length
= maxpacket
;
92 static void init_urbs(struct usb_stream_kernel
*sk
, unsigned use_packsize
,
93 struct usb_device
*dev
, int in_pipe
, int out_pipe
)
95 struct usb_stream
*s
= sk
->s
;
96 char *indata
= (char *)s
+ sizeof(*s
) +
97 sizeof(struct usb_stream_packet
) *
101 for (u
= 0; u
< USB_STREAM_NURBS
; ++u
) {
102 sk
->inurb
[u
] = usb_alloc_urb(sk
->n_o_ps
, GFP_KERNEL
);
103 sk
->outurb
[u
] = usb_alloc_urb(sk
->n_o_ps
, GFP_KERNEL
);
106 init_pipe_urbs(sk
, use_packsize
, sk
->inurb
, indata
, dev
, in_pipe
);
107 init_pipe_urbs(sk
, use_packsize
, sk
->outurb
, sk
->write_page
, dev
,
113 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
114 * this will overflow at approx 524 kHz
116 static inline unsigned get_usb_full_speed_rate(unsigned rate
)
118 return ((rate
<< 13) + 62) / 125;
122 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
123 * this will overflow at approx 4 MHz
125 static inline unsigned get_usb_high_speed_rate(unsigned rate
)
127 return ((rate
<< 10) + 62) / 125;
130 void usb_stream_free(struct usb_stream_kernel
*sk
)
132 struct usb_stream
*s
;
135 for (u
= 0; u
< USB_STREAM_NURBS
; ++u
) {
136 usb_free_urb(sk
->inurb
[u
]);
138 usb_free_urb(sk
->outurb
[u
]);
139 sk
->outurb
[u
] = NULL
;
146 free_pages((unsigned long)sk
->write_page
, get_order(s
->write_size
));
147 sk
->write_page
= NULL
;
148 free_pages((unsigned long)s
, get_order(s
->read_size
));
152 struct usb_stream
*usb_stream_new(struct usb_stream_kernel
*sk
,
153 struct usb_device
*dev
,
154 unsigned in_endpoint
, unsigned out_endpoint
,
155 unsigned sample_rate
, unsigned use_packsize
,
156 unsigned period_frames
, unsigned frame_size
)
158 int packets
, max_packsize
;
159 int in_pipe
, out_pipe
;
160 int read_size
= sizeof(struct usb_stream
);
162 int usb_frames
= dev
->speed
== USB_SPEED_HIGH
? 8000 : 1000;
165 in_pipe
= usb_rcvisocpipe(dev
, in_endpoint
);
166 out_pipe
= usb_sndisocpipe(dev
, out_endpoint
);
168 max_packsize
= use_packsize
?
169 use_packsize
: usb_maxpacket(dev
, in_pipe
, 0);
172 t_period = period_frames / sample_rate
173 iso_packs = t_period / t_iso_frame
174 = (period_frames / sample_rate) * (1 / t_iso_frame)
177 packets
= period_frames
* usb_frames
/ sample_rate
+ 1;
179 if (dev
->speed
== USB_SPEED_HIGH
)
180 packets
= (packets
+ 7) & ~7;
182 read_size
+= packets
* USB_STREAM_URBDEPTH
*
183 (max_packsize
+ sizeof(struct usb_stream_packet
));
185 max_packsize
= usb_maxpacket(dev
, out_pipe
, 1);
186 write_size
= max_packsize
* packets
* USB_STREAM_URBDEPTH
;
188 if (read_size
>= 256*PAGE_SIZE
|| write_size
>= 256*PAGE_SIZE
) {
189 snd_printk(KERN_WARNING
"a size exceeds 128*PAGE_SIZE\n");
193 pg
= get_order(read_size
);
194 sk
->s
= (void *) __get_free_pages(GFP_KERNEL
|__GFP_COMP
|__GFP_ZERO
|
197 snd_printk(KERN_WARNING
"couldn't __get_free_pages()\n");
200 sk
->s
->cfg
.version
= USB_STREAM_INTERFACE_VERSION
;
202 sk
->s
->read_size
= read_size
;
204 sk
->s
->cfg
.sample_rate
= sample_rate
;
205 sk
->s
->cfg
.frame_size
= frame_size
;
206 sk
->n_o_ps
= packets
;
207 sk
->s
->inpackets
= packets
* USB_STREAM_URBDEPTH
;
208 sk
->s
->cfg
.period_frames
= period_frames
;
209 sk
->s
->period_size
= frame_size
* period_frames
;
211 sk
->s
->write_size
= write_size
;
212 pg
= get_order(write_size
);
215 (void *)__get_free_pages(GFP_KERNEL
|__GFP_COMP
|__GFP_ZERO
|
217 if (!sk
->write_page
) {
218 snd_printk(KERN_WARNING
"couldn't __get_free_pages()\n");
223 /* calculate the frequency in 16.16 format */
224 if (dev
->speed
== USB_SPEED_FULL
)
225 sk
->freqn
= get_usb_full_speed_rate(sample_rate
);
227 sk
->freqn
= get_usb_high_speed_rate(sample_rate
);
229 init_urbs(sk
, use_packsize
, dev
, in_pipe
, out_pipe
);
230 sk
->s
->state
= usb_stream_stopped
;
238 static bool balance_check(struct usb_stream_kernel
*sk
, struct urb
*urb
)
241 if (unlikely(urb
->status
)) {
242 if (urb
->status
!= -ESHUTDOWN
&& urb
->status
!= -ENOENT
)
243 snd_printk(KERN_WARNING
"status=%i\n", urb
->status
);
244 sk
->iso_frame_balance
= 0x7FFFFFFF;
247 r
= sk
->iso_frame_balance
== 0;
253 static bool balance_playback(struct usb_stream_kernel
*sk
, struct urb
*urb
)
255 sk
->iso_frame_balance
+= urb
->number_of_packets
;
256 return balance_check(sk
, urb
);
259 static bool balance_capture(struct usb_stream_kernel
*sk
, struct urb
*urb
)
261 sk
->iso_frame_balance
-= urb
->number_of_packets
;
262 return balance_check(sk
, urb
);
265 static void subs_set_complete(struct urb
**urbs
, void (*complete
)(struct urb
*))
269 for (u
= 0; u
< USB_STREAM_NURBS
; u
++) {
270 struct urb
*urb
= urbs
[u
];
271 urb
->complete
= complete
;
275 static int usb_stream_prepare_playback(struct usb_stream_kernel
*sk
,
278 struct usb_stream
*s
= sk
->s
;
280 struct usb_iso_packet_descriptor
*id
, *od
;
281 int p
= 0, lb
= 0, l
= 0;
283 io
= sk
->idle_outurb
;
284 od
= io
->iso_frame_desc
;
286 for (; s
->sync_packet
< 0; ++p
, ++s
->sync_packet
) {
287 struct urb
*ii
= sk
->completed_inurb
;
288 id
= ii
->iso_frame_desc
+
289 ii
->number_of_packets
+ s
->sync_packet
;
290 l
= id
->actual_length
;
298 s
->sync_packet
< inurb
->number_of_packets
&& p
< sk
->n_o_ps
;
299 ++p
, ++s
->sync_packet
) {
300 l
= inurb
->iso_frame_desc
[s
->sync_packet
].actual_length
;
302 if (s
->idle_outsize
+ lb
+ l
> s
->period_size
)
311 s
->sync_packet
-= inurb
->number_of_packets
;
312 if (unlikely(s
->sync_packet
< -2 || s
->sync_packet
> 0)) {
313 snd_printk(KERN_WARNING
"invalid sync_packet = %i;"
314 " p=%i nop=%i %i %x %x %x > %x\n",
315 s
->sync_packet
, p
, inurb
->number_of_packets
,
316 s
->idle_outsize
+ lb
+ l
,
317 s
->idle_outsize
, lb
, l
,
321 if (unlikely(lb
% s
->cfg
.frame_size
)) {
322 snd_printk(KERN_WARNING
"invalid outsize = %i\n",
326 s
->idle_outsize
+= lb
- s
->period_size
;
327 io
->number_of_packets
= p
;
328 io
->transfer_buffer_length
= lb
;
329 if (s
->idle_outsize
<= 0)
332 snd_printk(KERN_WARNING
"idle=%i\n", s
->idle_outsize
);
336 static void prepare_inurb(int number_of_packets
, struct urb
*iu
)
338 struct usb_iso_packet_descriptor
*id
;
341 iu
->number_of_packets
= number_of_packets
;
342 id
= iu
->iso_frame_desc
;
344 for (p
= 0; p
< iu
->number_of_packets
- 1; ++p
)
345 id
[p
+ 1].offset
= id
[p
].offset
+ id
[p
].length
;
347 iu
->transfer_buffer_length
=
348 id
[0].length
* iu
->number_of_packets
;
351 static int submit_urbs(struct usb_stream_kernel
*sk
,
352 struct urb
*inurb
, struct urb
*outurb
)
355 prepare_inurb(sk
->idle_outurb
->number_of_packets
, sk
->idle_inurb
);
356 err
= usb_submit_urb(sk
->idle_inurb
, GFP_ATOMIC
);
358 snd_printk(KERN_ERR
"%i\n", err
);
361 sk
->idle_inurb
= sk
->completed_inurb
;
362 sk
->completed_inurb
= inurb
;
363 err
= usb_submit_urb(sk
->idle_outurb
, GFP_ATOMIC
);
365 snd_printk(KERN_ERR
"%i\n", err
);
368 sk
->idle_outurb
= sk
->completed_outurb
;
369 sk
->completed_outurb
= outurb
;
373 #ifdef DEBUG_LOOP_BACK
375 This loop_back() shows how to read/write the period data.
377 static void loop_back(struct usb_stream
*s
)
382 struct usb_iso_packet_descriptor
*id
;
384 o
= s
->playback1st_to
;
385 ol
= s
->playback1st_size
;
388 if (s
->insplit_pack
>= 0) {
390 id
= iu
->iso_frame_desc
;
395 for (; p
< iu
->number_of_packets
&& l
< s
->period_size
; ++p
) {
396 i
= iu
->transfer_buffer
+ id
[p
].offset
;
397 il
= id
[p
].actual_length
;
398 if (l
+ il
> s
->period_size
)
399 il
= s
->period_size
- l
;
408 memcpy(o
, i
+ ol
, il
- ol
);
410 ol
= s
->period_size
- s
->playback1st_size
;
414 if (iu
== sk
->completed_inurb
) {
415 if (l
!= s
->period_size
)
416 printk(KERN_DEBUG
"%s:%i %i\n", __func__
, __LINE__
,
417 l
/(int)s
->cfg
.frame_size
);
422 iu
= sk
->completed_inurb
;
423 id
= iu
->iso_frame_desc
;
429 static void loop_back(struct usb_stream
*s
)
434 static void stream_idle(struct usb_stream_kernel
*sk
,
435 struct urb
*inurb
, struct urb
*outurb
)
437 struct usb_stream
*s
= sk
->s
;
439 int insize
= s
->idle_insize
;
442 s
->inpacket_split
= s
->next_inpacket_split
;
443 s
->inpacket_split_at
= s
->next_inpacket_split_at
;
444 s
->next_inpacket_split
= -1;
445 s
->next_inpacket_split_at
= 0;
447 for (p
= 0; p
< inurb
->number_of_packets
; ++p
) {
448 struct usb_iso_packet_descriptor
*id
= inurb
->iso_frame_desc
;
449 l
= id
[p
].actual_length
;
450 if (unlikely(l
== 0 || id
[p
].status
)) {
451 snd_printk(KERN_WARNING
"underrun, status=%u\n",
456 s
->inpacket_head
%= s
->inpackets
;
457 if (s
->inpacket_split
== -1)
458 s
->inpacket_split
= s
->inpacket_head
;
460 s
->inpacket
[s
->inpacket_head
].offset
=
461 id
[p
].offset
+ (inurb
->transfer_buffer
- (void *)s
);
462 s
->inpacket
[s
->inpacket_head
].length
= l
;
463 if (insize
+ l
> s
->period_size
&&
464 s
->next_inpacket_split
== -1) {
465 s
->next_inpacket_split
= s
->inpacket_head
;
466 s
->next_inpacket_split_at
= s
->period_size
- insize
;
471 s
->idle_insize
+= urb_size
- s
->period_size
;
472 if (s
->idle_insize
< 0) {
473 snd_printk(KERN_WARNING
"%i\n",
474 (s
->idle_insize
)/(int)s
->cfg
.frame_size
);
477 s
->insize_done
+= urb_size
;
480 s
->outpacket
[0].offset
= (sk
->idle_outurb
->transfer_buffer
-
483 if (usb_stream_prepare_playback(sk
, inurb
) < 0)
486 s
->outpacket
[0].length
= sk
->idle_outurb
->transfer_buffer_length
+ l
;
487 s
->outpacket
[1].offset
= sk
->completed_outurb
->transfer_buffer
-
490 if (submit_urbs(sk
, inurb
, outurb
) < 0)
495 wake_up_all(&sk
->sleep
);
498 s
->state
= usb_stream_xrun
;
499 wake_up_all(&sk
->sleep
);
502 static void i_capture_idle(struct urb
*urb
)
504 struct usb_stream_kernel
*sk
= urb
->context
;
505 if (balance_capture(sk
, urb
))
506 stream_idle(sk
, urb
, sk
->i_urb
);
509 static void i_playback_idle(struct urb
*urb
)
511 struct usb_stream_kernel
*sk
= urb
->context
;
512 if (balance_playback(sk
, urb
))
513 stream_idle(sk
, sk
->i_urb
, urb
);
516 static void stream_start(struct usb_stream_kernel
*sk
,
517 struct urb
*inurb
, struct urb
*outurb
)
519 struct usb_stream
*s
= sk
->s
;
520 if (s
->state
>= usb_stream_sync1
) {
521 int l
, p
, max_diff
, max_diff_0
;
523 unsigned frames_per_packet
, min_frames
= 0;
524 frames_per_packet
= (s
->period_size
- s
->idle_insize
);
525 frames_per_packet
<<= 8;
527 s
->cfg
.frame_size
* inurb
->number_of_packets
;
530 max_diff_0
= s
->cfg
.frame_size
;
531 if (s
->cfg
.period_frames
>= 256)
533 if (s
->cfg
.period_frames
>= 1024)
535 max_diff
= max_diff_0
;
536 for (p
= 0; p
< inurb
->number_of_packets
; ++p
) {
538 l
= inurb
->iso_frame_desc
[p
].actual_length
;
541 min_frames
+= frames_per_packet
;
543 (min_frames
>> 8) * s
->cfg
.frame_size
;
544 if (diff
< max_diff
) {
545 snd_printdd(KERN_DEBUG
"%i %i %i %i\n",
547 urb_size
/ (int)s
->cfg
.frame_size
,
548 inurb
->number_of_packets
, diff
);
552 s
->idle_insize
-= max_diff
- max_diff_0
;
553 s
->idle_insize
+= urb_size
- s
->period_size
;
554 if (s
->idle_insize
< 0) {
555 snd_printk(KERN_WARNING
"%i %i %i\n",
556 s
->idle_insize
, urb_size
, s
->period_size
);
558 } else if (s
->idle_insize
== 0) {
559 s
->next_inpacket_split
=
560 (s
->inpacket_head
+ 1) % s
->inpackets
;
561 s
->next_inpacket_split_at
= 0;
563 unsigned split
= s
->inpacket_head
;
565 while (l
> s
->inpacket
[split
].length
) {
566 l
-= s
->inpacket
[split
].length
;
568 split
= s
->inpackets
- 1;
572 s
->next_inpacket_split
= split
;
573 s
->next_inpacket_split_at
=
574 s
->inpacket
[split
].length
- l
;
577 s
->insize_done
+= urb_size
;
579 if (usb_stream_prepare_playback(sk
, inurb
) < 0)
583 playback_prep_freqn(sk
, sk
->idle_outurb
);
585 if (submit_urbs(sk
, inurb
, outurb
) < 0)
588 if (s
->state
== usb_stream_sync1
&& s
->insize_done
> 360000) {
589 /* just guesswork ^^^^^^ */
590 s
->state
= usb_stream_ready
;
591 subs_set_complete(sk
->inurb
, i_capture_idle
);
592 subs_set_complete(sk
->outurb
, i_playback_idle
);
596 static void i_capture_start(struct urb
*urb
)
598 struct usb_iso_packet_descriptor
*id
= urb
->iso_frame_desc
;
599 struct usb_stream_kernel
*sk
= urb
->context
;
600 struct usb_stream
*s
= sk
->s
;
605 snd_printk(KERN_WARNING
"status=%i\n", urb
->status
);
609 for (p
= 0; p
< urb
->number_of_packets
; ++p
) {
610 int l
= id
[p
].actual_length
;
611 if (l
< s
->cfg
.frame_size
) {
613 if (s
->state
>= usb_stream_sync0
) {
614 snd_printk(KERN_WARNING
"%i\n", l
);
619 s
->inpacket_head
%= s
->inpackets
;
620 s
->inpacket
[s
->inpacket_head
].offset
=
621 id
[p
].offset
+ (urb
->transfer_buffer
- (void *)s
);
622 s
->inpacket
[s
->inpacket_head
].length
= l
;
626 printk(KERN_DEBUG
"%s:%i: %i", __func__
, __LINE__
,
627 urb
->iso_frame_desc
[0].actual_length
);
628 for (pack
= 1; pack
< urb
->number_of_packets
; ++pack
) {
629 int l
= urb
->iso_frame_desc
[pack
].actual_length
;
635 if (!empty
&& s
->state
< usb_stream_sync1
)
638 if (balance_capture(sk
, urb
))
639 stream_start(sk
, urb
, sk
->i_urb
);
642 static void i_playback_start(struct urb
*urb
)
644 struct usb_stream_kernel
*sk
= urb
->context
;
645 if (balance_playback(sk
, urb
))
646 stream_start(sk
, sk
->i_urb
, urb
);
649 int usb_stream_start(struct usb_stream_kernel
*sk
)
651 struct usb_stream
*s
= sk
->s
;
652 int frame
= 0, iters
= 0;
656 if (s
->state
!= usb_stream_stopped
)
659 subs_set_complete(sk
->inurb
, i_capture_start
);
660 subs_set_complete(sk
->outurb
, i_playback_start
);
661 memset(sk
->write_page
, 0, s
->write_size
);
667 s
->inpacket_head
= -1;
668 sk
->iso_frame_balance
= 0;
670 for (u
= 0; u
< 2; u
++) {
671 struct urb
*inurb
= sk
->inurb
[u
];
672 struct urb
*outurb
= sk
->outurb
[u
];
673 playback_prep_freqn(sk
, outurb
);
674 inurb
->number_of_packets
= outurb
->number_of_packets
;
675 inurb
->transfer_buffer_length
=
676 inurb
->number_of_packets
*
677 inurb
->iso_frame_desc
[0].length
;
681 struct usb_device
*dev
= inurb
->dev
;
682 frame
= usb_get_current_frame_number(dev
);
684 now
= usb_get_current_frame_number(dev
);
686 } while (now
> -1 && now
== frame
);
688 err
= usb_submit_urb(inurb
, GFP_ATOMIC
);
690 snd_printk(KERN_ERR
"usb_submit_urb(sk->inurb[%i])"
691 " returned %i\n", u
, err
);
694 err
= usb_submit_urb(outurb
, GFP_ATOMIC
);
696 snd_printk(KERN_ERR
"usb_submit_urb(sk->outurb[%i])"
697 " returned %i\n", u
, err
);
701 if (inurb
->start_frame
!= outurb
->start_frame
) {
702 snd_printd(KERN_DEBUG
703 "u[%i] start_frames differ in:%u out:%u\n",
704 u
, inurb
->start_frame
, outurb
->start_frame
);
708 snd_printdd(KERN_DEBUG
"%i %i\n", frame
, iters
);
715 snd_printd(KERN_DEBUG
"goto dotry;\n");
718 snd_printk(KERN_WARNING
"couldn't start"
719 " all urbs on the same start_frame.\n");
723 sk
->idle_inurb
= sk
->inurb
[USB_STREAM_NURBS
- 2];
724 sk
->idle_outurb
= sk
->outurb
[USB_STREAM_NURBS
- 2];
725 sk
->completed_inurb
= sk
->inurb
[USB_STREAM_NURBS
- 1];
726 sk
->completed_outurb
= sk
->outurb
[USB_STREAM_NURBS
- 1];
731 while (s
->state
!= usb_stream_ready
&& wait_ms
> 0) {
732 snd_printdd(KERN_DEBUG
"%i\n", s
->state
);
738 return s
->state
== usb_stream_ready
? 0 : -EFAULT
;
744 void usb_stream_stop(struct usb_stream_kernel
*sk
)
749 for (u
= 0; u
< USB_STREAM_NURBS
; ++u
) {
750 usb_kill_urb(sk
->inurb
[u
]);
751 usb_kill_urb(sk
->outurb
[u
]);
753 sk
->s
->state
= usb_stream_stopped
;