]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Driver for Tascam US-X2Y USB soundcards | |
3 | * | |
4 | * FPGA Loader + ALSA Startup | |
5 | * | |
6 | * Copyright (c) 2003 by Karsten Wiese <annabellesgarden@yahoo.de> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 | */ | |
22 | ||
1da177e4 | 23 | #include <linux/interrupt.h> |
5a0e3ad6 | 24 | #include <linux/slab.h> |
1da177e4 LT |
25 | #include <linux/usb.h> |
26 | #include <sound/core.h> | |
27 | #include <sound/memalloc.h> | |
28 | #include <sound/pcm.h> | |
29 | #include <sound/hwdep.h> | |
30 | #include "usx2y.h" | |
31 | #include "usbusx2y.h" | |
32 | #include "usX2Yhwdep.h" | |
33 | ||
11bac800 | 34 | static int snd_us428ctls_vm_fault(struct vm_fault *vmf) |
1da177e4 LT |
35 | { |
36 | unsigned long offset; | |
37 | struct page * page; | |
38 | void *vaddr; | |
39 | ||
eb415b8f | 40 | snd_printdd("ENTER, start %lXh, pgoff %ld\n", |
11bac800 | 41 | vmf->vma->vm_start, |
eb415b8f | 42 | vmf->pgoff); |
1da177e4 | 43 | |
eb415b8f | 44 | offset = vmf->pgoff << PAGE_SHIFT; |
11bac800 | 45 | vaddr = (char *)((struct usX2Ydev *)vmf->vma->vm_private_data)->us428ctls_sharedmem + offset; |
1da177e4 LT |
46 | page = virt_to_page(vaddr); |
47 | get_page(page); | |
eb415b8f | 48 | vmf->page = page; |
1da177e4 | 49 | |
eb415b8f NP |
50 | snd_printdd("vaddr=%p made us428ctls_vm_fault() page %p\n", |
51 | vaddr, page); | |
1da177e4 | 52 | |
eb415b8f | 53 | return 0; |
1da177e4 LT |
54 | } |
55 | ||
f0f37e2f | 56 | static const struct vm_operations_struct us428ctls_vm_ops = { |
eb415b8f | 57 | .fault = snd_us428ctls_vm_fault, |
1da177e4 LT |
58 | }; |
59 | ||
bbe85bbd | 60 | static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) |
1da177e4 LT |
61 | { |
62 | unsigned long size = (unsigned long)(area->vm_end - area->vm_start); | |
bbe85bbd | 63 | struct usX2Ydev *us428 = hw->private_data; |
1da177e4 LT |
64 | |
65 | // FIXME this hwdep interface is used twice: fpga download and mmap for controlling Lights etc. Maybe better using 2 hwdep devs? | |
66 | // so as long as the device isn't fully initialised yet we return -EBUSY here. | |
cb432379 | 67 | if (!(us428->chip_status & USX2Y_STAT_CHIP_INIT)) |
1da177e4 LT |
68 | return -EBUSY; |
69 | ||
70 | /* if userspace tries to mmap beyond end of our buffer, fail */ | |
bbe85bbd TI |
71 | if (size > PAGE_ALIGN(sizeof(struct us428ctls_sharedmem))) { |
72 | snd_printd( "%lu > %lu\n", size, (unsigned long)sizeof(struct us428ctls_sharedmem)); | |
1da177e4 LT |
73 | return -EINVAL; |
74 | } | |
75 | ||
76 | if (!us428->us428ctls_sharedmem) { | |
77 | init_waitqueue_head(&us428->us428ctls_wait_queue_head); | |
bbe85bbd | 78 | if(!(us428->us428ctls_sharedmem = snd_malloc_pages(sizeof(struct us428ctls_sharedmem), GFP_KERNEL))) |
1da177e4 | 79 | return -ENOMEM; |
bbe85bbd | 80 | memset(us428->us428ctls_sharedmem, -1, sizeof(struct us428ctls_sharedmem)); |
1da177e4 LT |
81 | us428->us428ctls_sharedmem->CtlSnapShotLast = -2; |
82 | } | |
83 | area->vm_ops = &us428ctls_vm_ops; | |
314e51b9 | 84 | area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; |
1da177e4 LT |
85 | area->vm_private_data = hw->private_data; |
86 | return 0; | |
87 | } | |
88 | ||
680ef72a | 89 | static __poll_t snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait) |
1da177e4 | 90 | { |
680ef72a | 91 | __poll_t mask = 0; |
bbe85bbd TI |
92 | struct usX2Ydev *us428 = hw->private_data; |
93 | struct us428ctls_sharedmem *shm = us428->us428ctls_sharedmem; | |
1da177e4 | 94 | if (us428->chip_status & USX2Y_STAT_CHIP_HUP) |
a9a08845 | 95 | return EPOLLHUP; |
1da177e4 LT |
96 | |
97 | poll_wait(file, &us428->us428ctls_wait_queue_head, wait); | |
98 | ||
99 | if (shm != NULL && shm->CtlSnapShotLast != shm->CtlSnapShotRed) | |
a9a08845 | 100 | mask |= EPOLLIN; |
1da177e4 LT |
101 | |
102 | return mask; | |
103 | } | |
104 | ||
105 | ||
bbe85bbd TI |
106 | static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, |
107 | struct snd_hwdep_dsp_status *info) | |
1da177e4 LT |
108 | { |
109 | static char *type_ids[USX2Y_TYPE_NUMS] = { | |
110 | [USX2Y_TYPE_122] = "us122", | |
111 | [USX2Y_TYPE_224] = "us224", | |
112 | [USX2Y_TYPE_428] = "us428", | |
113 | }; | |
bbe85bbd | 114 | struct usX2Ydev *us428 = hw->private_data; |
1da177e4 LT |
115 | int id = -1; |
116 | ||
a014bbad | 117 | switch (le16_to_cpu(us428->dev->descriptor.idProduct)) { |
1da177e4 LT |
118 | case USB_ID_US122: |
119 | id = USX2Y_TYPE_122; | |
120 | break; | |
121 | case USB_ID_US224: | |
122 | id = USX2Y_TYPE_224; | |
123 | break; | |
124 | case USB_ID_US428: | |
125 | id = USX2Y_TYPE_428; | |
126 | break; | |
127 | } | |
128 | if (0 > id) | |
129 | return -ENODEV; | |
130 | strcpy(info->id, type_ids[id]); | |
131 | info->num_dsps = 2; // 0: Prepad Data, 1: FPGA Code | |
bbe85bbd | 132 | if (us428->chip_status & USX2Y_STAT_CHIP_INIT) |
1da177e4 LT |
133 | info->chip_ready = 1; |
134 | info->version = USX2Y_DRIVER_VERSION; | |
135 | return 0; | |
136 | } | |
137 | ||
138 | ||
bbe85bbd | 139 | static int usX2Y_create_usbmidi(struct snd_card *card) |
1da177e4 | 140 | { |
bbe85bbd TI |
141 | static struct snd_usb_midi_endpoint_info quirk_data_1 = { |
142 | .out_ep = 0x06, | |
1da177e4 LT |
143 | .in_ep = 0x06, |
144 | .out_cables = 0x001, | |
145 | .in_cables = 0x001 | |
146 | }; | |
bbe85bbd | 147 | static struct snd_usb_audio_quirk quirk_1 = { |
1da177e4 LT |
148 | .vendor_name = "TASCAM", |
149 | .product_name = NAME_ALLCAPS, | |
150 | .ifnum = 0, | |
151 | .type = QUIRK_MIDI_FIXED_ENDPOINT, | |
152 | .data = &quirk_data_1 | |
153 | }; | |
bbe85bbd TI |
154 | static struct snd_usb_midi_endpoint_info quirk_data_2 = { |
155 | .out_ep = 0x06, | |
1da177e4 LT |
156 | .in_ep = 0x06, |
157 | .out_cables = 0x003, | |
158 | .in_cables = 0x003 | |
159 | }; | |
bbe85bbd | 160 | static struct snd_usb_audio_quirk quirk_2 = { |
1da177e4 LT |
161 | .vendor_name = "TASCAM", |
162 | .product_name = "US428", | |
163 | .ifnum = 0, | |
164 | .type = QUIRK_MIDI_FIXED_ENDPOINT, | |
165 | .data = &quirk_data_2 | |
166 | }; | |
a014bbad | 167 | struct usb_device *dev = usX2Y(card)->dev; |
1da177e4 | 168 | struct usb_interface *iface = usb_ifnum_to_if(dev, 0); |
bbe85bbd TI |
169 | struct snd_usb_audio_quirk *quirk = |
170 | le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ? | |
171 | &quirk_2 : &quirk_1; | |
1da177e4 LT |
172 | |
173 | snd_printdd("usX2Y_create_usbmidi \n"); | |
d82af9f9 | 174 | return snd_usbmidi_create(card, iface, &usX2Y(card)->midi_list, quirk); |
1da177e4 LT |
175 | } |
176 | ||
bbe85bbd | 177 | static int usX2Y_create_alsa_devices(struct snd_card *card) |
1da177e4 LT |
178 | { |
179 | int err; | |
180 | ||
181 | do { | |
182 | if ((err = usX2Y_create_usbmidi(card)) < 0) { | |
d3d579f8 | 183 | snd_printk(KERN_ERR "usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i \n", err); |
1da177e4 LT |
184 | break; |
185 | } | |
186 | if ((err = usX2Y_audio_create(card)) < 0) | |
187 | break; | |
188 | if ((err = usX2Y_hwdep_pcm_new(card)) < 0) | |
189 | break; | |
190 | if ((err = snd_card_register(card)) < 0) | |
191 | break; | |
192 | } while (0); | |
193 | ||
194 | return err; | |
195 | } | |
196 | ||
bbe85bbd TI |
197 | static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, |
198 | struct snd_hwdep_dsp_image *dsp) | |
1da177e4 | 199 | { |
bbe85bbd | 200 | struct usX2Ydev *priv = hw->private_data; |
fc1c428e AV |
201 | struct usb_device* dev = priv->dev; |
202 | int lret, err; | |
203 | char *buf; | |
1da177e4 | 204 | |
fc1c428e | 205 | snd_printdd( "dsp_load %s\n", dsp->name); |
85385c15 | 206 | |
fc1c428e AV |
207 | buf = memdup_user(dsp->image, dsp->length); |
208 | if (IS_ERR(buf)) | |
209 | return PTR_ERR(buf); | |
85385c15 | 210 | |
fc1c428e AV |
211 | err = usb_set_interface(dev, 0, 1); |
212 | if (err) | |
213 | snd_printk(KERN_ERR "usb_set_interface error \n"); | |
214 | else | |
215 | err = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 2), buf, dsp->length, &lret, 6000); | |
216 | kfree(buf); | |
1da177e4 LT |
217 | if (err) |
218 | return err; | |
219 | if (dsp->index == 1) { | |
b27c187f | 220 | msleep(250); // give the device some time |
1da177e4 LT |
221 | err = usX2Y_AsyncSeq04_init(priv); |
222 | if (err) { | |
d3d579f8 | 223 | snd_printk(KERN_ERR "usX2Y_AsyncSeq04_init error \n"); |
1da177e4 LT |
224 | return err; |
225 | } | |
226 | err = usX2Y_In04_init(priv); | |
227 | if (err) { | |
d3d579f8 | 228 | snd_printk(KERN_ERR "usX2Y_In04_init error \n"); |
1da177e4 LT |
229 | return err; |
230 | } | |
231 | err = usX2Y_create_alsa_devices(hw->card); | |
232 | if (err) { | |
d3d579f8 | 233 | snd_printk(KERN_ERR "usX2Y_create_alsa_devices error %i \n", err); |
1da177e4 LT |
234 | snd_card_free(hw->card); |
235 | return err; | |
236 | } | |
237 | priv->chip_status |= USX2Y_STAT_CHIP_INIT; | |
238 | snd_printdd("%s: alsa all started\n", hw->name); | |
239 | } | |
240 | return err; | |
241 | } | |
242 | ||
243 | ||
bbe85bbd | 244 | int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device) |
1da177e4 LT |
245 | { |
246 | int err; | |
bbe85bbd | 247 | struct snd_hwdep *hw; |
1da177e4 LT |
248 | |
249 | if ((err = snd_hwdep_new(card, SND_USX2Y_LOADER_ID, 0, &hw)) < 0) | |
250 | return err; | |
251 | ||
252 | hw->iface = SNDRV_HWDEP_IFACE_USX2Y; | |
253 | hw->private_data = usX2Y(card); | |
1da177e4 LT |
254 | hw->ops.dsp_status = snd_usX2Y_hwdep_dsp_status; |
255 | hw->ops.dsp_load = snd_usX2Y_hwdep_dsp_load; | |
256 | hw->ops.mmap = snd_us428ctls_mmap; | |
257 | hw->ops.poll = snd_us428ctls_poll; | |
258 | hw->exclusive = 1; | |
a5f8661d | 259 | sprintf(hw->name, "/dev/bus/usb/%03d/%03d", device->bus->busnum, device->devnum); |
1da177e4 LT |
260 | return 0; |
261 | } | |
262 |