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 <sound/core.h>
20 #include <sound/hwdep.h>
21 #include <sound/pcm.h>
22 #include <sound/initval.h>
23 #define MODNAME "US122L"
24 #include "usb_stream.c"
25 #include "../usbaudio.h"
28 MODULE_AUTHOR("Karsten Wiese <fzu@wemgehoertderstaat.de>");
29 MODULE_DESCRIPTION("TASCAM "NAME_ALLCAPS
" Version 0.5");
30 MODULE_LICENSE("GPL");
32 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-max */
33 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* Id for this card */
34 /* Enable this card */
35 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
37 module_param_array(index
, int, NULL
, 0444);
38 MODULE_PARM_DESC(index
, "Index value for "NAME_ALLCAPS
".");
39 module_param_array(id
, charp
, NULL
, 0444);
40 MODULE_PARM_DESC(id
, "ID string for "NAME_ALLCAPS
".");
41 module_param_array(enable
, bool, NULL
, 0444);
42 MODULE_PARM_DESC(enable
, "Enable "NAME_ALLCAPS
".");
44 static int snd_us122l_card_used
[SNDRV_CARDS
];
47 static int us122l_create_usbmidi(struct snd_card
*card
)
49 static struct snd_usb_midi_endpoint_info quirk_data
= {
55 static struct snd_usb_audio_quirk quirk
= {
56 .vendor_name
= "US122L",
57 .product_name
= NAME_ALLCAPS
,
59 .type
= QUIRK_MIDI_US122L
,
62 struct usb_device
*dev
= US122L(card
)->chip
.dev
;
63 struct usb_interface
*iface
= usb_ifnum_to_if(dev
, 1);
65 return snd_usb_create_midi_interface(&US122L(card
)->chip
,
70 * Wrapper for usb_control_msg().
71 * Allocates a temp buffer to prevent dmaing from/to the stack.
73 static int us122l_ctl_msg(struct usb_device
*dev
, unsigned int pipe
,
74 __u8 request
, __u8 requesttype
,
75 __u16 value
, __u16 index
, void *data
,
76 __u16 size
, int timeout
)
82 buf
= kmemdup(data
, size
, GFP_KERNEL
);
86 err
= usb_control_msg(dev
, pipe
, request
, requesttype
,
87 value
, index
, buf
, size
, timeout
);
89 memcpy(data
, buf
, size
);
95 static void pt_info_set(struct usb_device
*dev
, u8 v
)
99 ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
101 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
102 v
, 0, NULL
, 0, 1000);
103 snd_printdd(KERN_DEBUG
"%i\n", ret
);
106 static void usb_stream_hwdep_vm_open(struct vm_area_struct
*area
)
108 struct us122l
*us122l
= area
->vm_private_data
;
109 atomic_inc(&us122l
->mmap_count
);
110 snd_printdd(KERN_DEBUG
"%i\n", atomic_read(&us122l
->mmap_count
));
113 static int usb_stream_hwdep_vm_fault(struct vm_area_struct
*area
,
114 struct vm_fault
*vmf
)
116 unsigned long offset
;
119 struct us122l
*us122l
= area
->vm_private_data
;
120 struct usb_stream
*s
;
122 mutex_lock(&us122l
->mutex
);
127 offset
= vmf
->pgoff
<< PAGE_SHIFT
;
128 if (offset
< PAGE_ALIGN(s
->read_size
))
129 vaddr
= (char *)s
+ offset
;
131 offset
-= PAGE_ALIGN(s
->read_size
);
132 if (offset
>= PAGE_ALIGN(s
->write_size
))
135 vaddr
= us122l
->sk
.write_page
+ offset
;
137 page
= virt_to_page(vaddr
);
140 mutex_unlock(&us122l
->mutex
);
146 mutex_unlock(&us122l
->mutex
);
147 return VM_FAULT_SIGBUS
;
150 static void usb_stream_hwdep_vm_close(struct vm_area_struct
*area
)
152 struct us122l
*us122l
= area
->vm_private_data
;
153 atomic_dec(&us122l
->mmap_count
);
154 snd_printdd(KERN_DEBUG
"%i\n", atomic_read(&us122l
->mmap_count
));
157 static struct vm_operations_struct usb_stream_hwdep_vm_ops
= {
158 .open
= usb_stream_hwdep_vm_open
,
159 .fault
= usb_stream_hwdep_vm_fault
,
160 .close
= usb_stream_hwdep_vm_close
,
164 static int usb_stream_hwdep_open(struct snd_hwdep
*hw
, struct file
*file
)
166 struct us122l
*us122l
= hw
->private_data
;
167 struct usb_interface
*iface
;
168 snd_printdd(KERN_DEBUG
"%p %p\n", hw
, file
);
173 us122l
->first
= file
;
174 iface
= usb_ifnum_to_if(us122l
->chip
.dev
, 1);
175 usb_autopm_get_interface(iface
);
179 static int usb_stream_hwdep_release(struct snd_hwdep
*hw
, struct file
*file
)
181 struct us122l
*us122l
= hw
->private_data
;
182 struct usb_interface
*iface
= usb_ifnum_to_if(us122l
->chip
.dev
, 1);
183 snd_printdd(KERN_DEBUG
"%p %p\n", hw
, file
);
184 usb_autopm_put_interface(iface
);
185 if (us122l
->first
== file
)
186 us122l
->first
= NULL
;
187 mutex_lock(&us122l
->mutex
);
188 if (us122l
->master
== file
)
189 us122l
->master
= us122l
->slave
;
191 us122l
->slave
= NULL
;
192 mutex_unlock(&us122l
->mutex
);
196 static int usb_stream_hwdep_mmap(struct snd_hwdep
*hw
,
197 struct file
*filp
, struct vm_area_struct
*area
)
199 unsigned long size
= area
->vm_end
- area
->vm_start
;
200 struct us122l
*us122l
= hw
->private_data
;
201 unsigned long offset
;
202 struct usb_stream
*s
;
206 offset
= area
->vm_pgoff
<< PAGE_SHIFT
;
207 mutex_lock(&us122l
->mutex
);
209 read
= offset
< s
->read_size
;
210 if (read
&& area
->vm_flags
& VM_WRITE
) {
214 snd_printdd(KERN_DEBUG
"%lu %u\n", size
,
215 read
? s
->read_size
: s
->write_size
);
216 /* if userspace tries to mmap beyond end of our buffer, fail */
217 if (size
> PAGE_ALIGN(read
? s
->read_size
: s
->write_size
)) {
218 snd_printk(KERN_WARNING
"%lu > %u\n", size
,
219 read
? s
->read_size
: s
->write_size
);
224 area
->vm_ops
= &usb_stream_hwdep_vm_ops
;
225 area
->vm_flags
|= VM_RESERVED
;
226 area
->vm_private_data
= us122l
;
227 atomic_inc(&us122l
->mmap_count
);
229 mutex_unlock(&us122l
->mutex
);
233 static unsigned int usb_stream_hwdep_poll(struct snd_hwdep
*hw
,
234 struct file
*file
, poll_table
*wait
)
236 struct us122l
*us122l
= hw
->private_data
;
237 struct usb_stream
*s
= us122l
->sk
.s
;
241 poll_wait(file
, &us122l
->sk
.sleep
, wait
);
244 case usb_stream_ready
:
245 if (us122l
->first
== file
)
246 polled
= &s
->periods_polled
;
248 polled
= &us122l
->second_periods_polled
;
249 if (*polled
!= s
->periods_done
) {
250 *polled
= s
->periods_done
;
251 mask
= POLLIN
| POLLOUT
| POLLWRNORM
;
258 mask
= POLLIN
| POLLOUT
| POLLWRNORM
| POLLERR
;
264 static void us122l_stop(struct us122l
*us122l
)
267 list_for_each(p
, &us122l
->chip
.midi_list
)
268 snd_usbmidi_input_stop(p
);
270 usb_stream_stop(&us122l
->sk
);
271 usb_stream_free(&us122l
->sk
);
274 static int us122l_set_sample_rate(struct usb_device
*dev
, int rate
)
276 unsigned int ep
= 0x81;
277 unsigned char data
[3];
282 data
[2] = rate
>> 16;
283 err
= us122l_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
,
284 USB_TYPE_CLASS
|USB_RECIP_ENDPOINT
|USB_DIR_OUT
,
285 SAMPLING_FREQ_CONTROL
<< 8, ep
, data
, 3, 1000);
287 snd_printk(KERN_ERR
"%d: cannot set freq %d to ep 0x%x\n",
288 dev
->devnum
, rate
, ep
);
292 static bool us122l_start(struct us122l
*us122l
,
293 unsigned rate
, unsigned period_frames
)
297 unsigned use_packsize
= 0;
298 bool success
= false;
300 if (us122l
->chip
.dev
->speed
== USB_SPEED_HIGH
) {
301 /* The us-122l's descriptor defaults to iso max_packsize 78,
302 which isn't needed for samplerates <= 48000.
303 Lets save some memory:
317 if (!usb_stream_new(&us122l
->sk
, us122l
->chip
.dev
, 1, 2,
318 rate
, use_packsize
, period_frames
, 6))
321 err
= us122l_set_sample_rate(us122l
->chip
.dev
, rate
);
324 snd_printk(KERN_ERR
"us122l_set_sample_rate error \n");
327 err
= usb_stream_start(&us122l
->sk
);
330 snd_printk(KERN_ERR
"us122l_start error %i \n", err
);
333 list_for_each(p
, &us122l
->chip
.midi_list
)
334 snd_usbmidi_input_start(p
);
340 static int usb_stream_hwdep_ioctl(struct snd_hwdep
*hw
, struct file
*file
,
341 unsigned cmd
, unsigned long arg
)
343 struct usb_stream_config
*cfg
;
344 struct us122l
*us122l
= hw
->private_data
;
345 unsigned min_period_frames
;
349 if (cmd
!= SNDRV_USB_STREAM_IOCTL_SET_PARAMS
)
352 cfg
= kmalloc(sizeof(*cfg
), GFP_KERNEL
);
356 if (copy_from_user(cfg
, (void *)arg
, sizeof(*cfg
))) {
360 if (cfg
->version
!= USB_STREAM_INTERFACE_VERSION
) {
364 high_speed
= us122l
->chip
.dev
->speed
== USB_SPEED_HIGH
;
365 if ((cfg
->sample_rate
!= 44100 && cfg
->sample_rate
!= 48000 &&
367 (cfg
->sample_rate
!= 88200 && cfg
->sample_rate
!= 96000))) ||
368 cfg
->frame_size
!= 6 ||
369 cfg
->period_frames
> 0x3000) {
373 switch (cfg
->sample_rate
) {
375 min_period_frames
= 48;
378 min_period_frames
= 52;
381 min_period_frames
= 104;
385 min_period_frames
<<= 1;
386 if (cfg
->period_frames
< min_period_frames
) {
391 snd_power_wait(hw
->card
, SNDRV_CTL_POWER_D0
);
393 mutex_lock(&us122l
->mutex
);
395 us122l
->master
= file
;
396 else if (us122l
->master
!= file
) {
397 if (memcmp(cfg
, &us122l
->sk
.s
->cfg
, sizeof(*cfg
))) {
401 us122l
->slave
= file
;
404 memcmp(cfg
, &us122l
->sk
.s
->cfg
, sizeof(*cfg
)) ||
405 us122l
->sk
.s
->state
== usb_stream_xrun
) {
407 if (!us122l_start(us122l
, cfg
->sample_rate
, cfg
->period_frames
))
413 mutex_unlock(&us122l
->mutex
);
419 #define SND_USB_STREAM_ID "USB STREAM"
420 static int usb_stream_hwdep_new(struct snd_card
*card
)
423 struct snd_hwdep
*hw
;
424 struct usb_device
*dev
= US122L(card
)->chip
.dev
;
426 err
= snd_hwdep_new(card
, SND_USB_STREAM_ID
, 0, &hw
);
430 hw
->iface
= SNDRV_HWDEP_IFACE_USB_STREAM
;
431 hw
->private_data
= US122L(card
);
432 hw
->ops
.open
= usb_stream_hwdep_open
;
433 hw
->ops
.release
= usb_stream_hwdep_release
;
434 hw
->ops
.ioctl
= usb_stream_hwdep_ioctl
;
435 hw
->ops
.ioctl_compat
= usb_stream_hwdep_ioctl
;
436 hw
->ops
.mmap
= usb_stream_hwdep_mmap
;
437 hw
->ops
.poll
= usb_stream_hwdep_poll
;
439 sprintf(hw
->name
, "/proc/bus/usb/%03d/%03d/hwdeppcm",
440 dev
->bus
->busnum
, dev
->devnum
);
445 static bool us122l_create_card(struct snd_card
*card
)
448 struct us122l
*us122l
= US122L(card
);
450 err
= usb_set_interface(us122l
->chip
.dev
, 1, 1);
452 snd_printk(KERN_ERR
"usb_set_interface error \n");
456 pt_info_set(us122l
->chip
.dev
, 0x11);
457 pt_info_set(us122l
->chip
.dev
, 0x10);
459 if (!us122l_start(us122l
, 44100, 256))
462 err
= us122l_create_usbmidi(card
);
464 snd_printk(KERN_ERR
"us122l_create_usbmidi error %i \n", err
);
468 err
= usb_stream_hwdep_new(card
);
470 /* release the midi resources */
472 list_for_each(p
, &us122l
->chip
.midi_list
)
473 snd_usbmidi_disconnect(p
);
481 static struct snd_card
*usx2y_create_card(struct usb_device
*device
)
484 struct snd_card
*card
;
485 for (dev
= 0; dev
< SNDRV_CARDS
; ++dev
)
486 if (enable
[dev
] && !snd_us122l_card_used
[dev
])
488 if (dev
>= SNDRV_CARDS
)
490 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
,
491 sizeof(struct us122l
));
494 snd_us122l_card_used
[US122L(card
)->chip
.index
= dev
] = 1;
496 US122L(card
)->chip
.dev
= device
;
497 US122L(card
)->chip
.card
= card
;
498 mutex_init(&US122L(card
)->mutex
);
499 init_waitqueue_head(&US122L(card
)->sk
.sleep
);
500 INIT_LIST_HEAD(&US122L(card
)->chip
.midi_list
);
501 strcpy(card
->driver
, "USB "NAME_ALLCAPS
"");
502 sprintf(card
->shortname
, "TASCAM "NAME_ALLCAPS
"");
503 sprintf(card
->longname
, "%s (%x:%x if %d at %03d/%03d)",
505 le16_to_cpu(device
->descriptor
.idVendor
),
506 le16_to_cpu(device
->descriptor
.idProduct
),
508 US122L(card
)->chip
.dev
->bus
->busnum
,
509 US122L(card
)->chip
.dev
->devnum
511 snd_card_set_dev(card
, &device
->dev
);
515 static void *us122l_usb_probe(struct usb_interface
*intf
,
516 const struct usb_device_id
*device_id
)
518 struct usb_device
*device
= interface_to_usbdev(intf
);
519 struct snd_card
*card
= usx2y_create_card(device
);
524 if (!us122l_create_card(card
) ||
525 snd_card_register(card
) < 0) {
534 static int snd_us122l_probe(struct usb_interface
*intf
,
535 const struct usb_device_id
*id
)
537 struct snd_card
*card
;
538 snd_printdd(KERN_DEBUG
"%p:%i\n",
539 intf
, intf
->cur_altsetting
->desc
.bInterfaceNumber
);
540 if (intf
->cur_altsetting
->desc
.bInterfaceNumber
!= 1)
543 card
= us122l_usb_probe(usb_get_intf(intf
), id
);
546 usb_set_intfdata(intf
, card
);
554 static void snd_us122l_disconnect(struct usb_interface
*intf
)
556 struct snd_card
*card
;
557 struct us122l
*us122l
;
560 card
= usb_get_intfdata(intf
);
564 snd_card_disconnect(card
);
566 us122l
= US122L(card
);
567 mutex_lock(&us122l
->mutex
);
569 mutex_unlock(&us122l
->mutex
);
570 us122l
->chip
.shutdown
= 1;
572 /* release the midi resources */
573 list_for_each(p
, &us122l
->chip
.midi_list
) {
574 snd_usbmidi_disconnect(p
);
578 usb_put_dev(US122L(card
)->chip
.dev
);
580 while (atomic_read(&us122l
->mmap_count
))
586 static int snd_us122l_suspend(struct usb_interface
*intf
, pm_message_t message
)
588 struct snd_card
*card
;
589 struct us122l
*us122l
;
592 card
= usb_get_intfdata(intf
);
595 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
597 us122l
= US122L(card
);
601 list_for_each(p
, &us122l
->chip
.midi_list
)
602 snd_usbmidi_input_stop(p
);
604 mutex_lock(&us122l
->mutex
);
605 usb_stream_stop(&us122l
->sk
);
606 mutex_unlock(&us122l
->mutex
);
611 static int snd_us122l_resume(struct usb_interface
*intf
)
613 struct snd_card
*card
;
614 struct us122l
*us122l
;
618 card
= usb_get_intfdata(intf
);
622 us122l
= US122L(card
);
626 mutex_lock(&us122l
->mutex
);
627 /* needed, doesn't restart without: */
628 err
= usb_set_interface(us122l
->chip
.dev
, 1, 1);
630 snd_printk(KERN_ERR
"usb_set_interface error \n");
634 pt_info_set(us122l
->chip
.dev
, 0x11);
635 pt_info_set(us122l
->chip
.dev
, 0x10);
637 err
= us122l_set_sample_rate(us122l
->chip
.dev
,
638 us122l
->sk
.s
->cfg
.sample_rate
);
640 snd_printk(KERN_ERR
"us122l_set_sample_rate error \n");
643 err
= usb_stream_start(&us122l
->sk
);
647 list_for_each(p
, &us122l
->chip
.midi_list
)
648 snd_usbmidi_input_start(p
);
650 mutex_unlock(&us122l
->mutex
);
651 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
655 static struct usb_device_id snd_us122l_usb_id_table
[] = {
657 .match_flags
= USB_DEVICE_ID_MATCH_DEVICE
,
659 .idProduct
= USB_ID_US122L
661 /* { */ /* US-144 maybe works when @USB1.1. Untested. */
662 /* .match_flags = USB_DEVICE_ID_MATCH_DEVICE, */
663 /* .idVendor = 0x0644, */
664 /* .idProduct = USB_ID_US144 */
669 MODULE_DEVICE_TABLE(usb
, snd_us122l_usb_id_table
);
670 static struct usb_driver snd_us122l_usb_driver
= {
671 .name
= "snd-usb-us122l",
672 .probe
= snd_us122l_probe
,
673 .disconnect
= snd_us122l_disconnect
,
674 .suspend
= snd_us122l_suspend
,
675 .resume
= snd_us122l_resume
,
676 .reset_resume
= snd_us122l_resume
,
677 .id_table
= snd_us122l_usb_id_table
,
678 .supports_autosuspend
= 1
682 static int __init
snd_us122l_module_init(void)
684 return usb_register(&snd_us122l_usb_driver
);
687 static void __exit
snd_us122l_module_exit(void)
689 usb_deregister(&snd_us122l_usb_driver
);
692 module_init(snd_us122l_module_init
)
693 module_exit(snd_us122l_module_exit
)