]>
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 | ||
eb415b8f NP |
34 | static int snd_us428ctls_vm_fault(struct vm_area_struct *area, |
35 | struct vm_fault *vmf) | |
1da177e4 LT |
36 | { |
37 | unsigned long offset; | |
38 | struct page * page; | |
39 | void *vaddr; | |
40 | ||
eb415b8f | 41 | snd_printdd("ENTER, start %lXh, pgoff %ld\n", |
1da177e4 | 42 | area->vm_start, |
eb415b8f | 43 | vmf->pgoff); |
1da177e4 | 44 | |
eb415b8f | 45 | offset = vmf->pgoff << PAGE_SHIFT; |
bbe85bbd | 46 | vaddr = (char*)((struct usX2Ydev *)area->vm_private_data)->us428ctls_sharedmem + offset; |
1da177e4 LT |
47 | page = virt_to_page(vaddr); |
48 | get_page(page); | |
eb415b8f | 49 | vmf->page = page; |
1da177e4 | 50 | |
eb415b8f NP |
51 | snd_printdd("vaddr=%p made us428ctls_vm_fault() page %p\n", |
52 | vaddr, page); | |
1da177e4 | 53 | |
eb415b8f | 54 | return 0; |
1da177e4 LT |
55 | } |
56 | ||
f0f37e2f | 57 | static const struct vm_operations_struct us428ctls_vm_ops = { |
eb415b8f | 58 | .fault = snd_us428ctls_vm_fault, |
1da177e4 LT |
59 | }; |
60 | ||
bbe85bbd | 61 | static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) |
1da177e4 LT |
62 | { |
63 | unsigned long size = (unsigned long)(area->vm_end - area->vm_start); | |
bbe85bbd | 64 | struct usX2Ydev *us428 = hw->private_data; |
1da177e4 LT |
65 | |
66 | // FIXME this hwdep interface is used twice: fpga download and mmap for controlling Lights etc. Maybe better using 2 hwdep devs? | |
67 | // so as long as the device isn't fully initialised yet we return -EBUSY here. | |
cb432379 | 68 | if (!(us428->chip_status & USX2Y_STAT_CHIP_INIT)) |
1da177e4 LT |
69 | return -EBUSY; |
70 | ||
71 | /* if userspace tries to mmap beyond end of our buffer, fail */ | |
bbe85bbd TI |
72 | if (size > PAGE_ALIGN(sizeof(struct us428ctls_sharedmem))) { |
73 | snd_printd( "%lu > %lu\n", size, (unsigned long)sizeof(struct us428ctls_sharedmem)); | |
1da177e4 LT |
74 | return -EINVAL; |
75 | } | |
76 | ||
77 | if (!us428->us428ctls_sharedmem) { | |
78 | init_waitqueue_head(&us428->us428ctls_wait_queue_head); | |
bbe85bbd | 79 | if(!(us428->us428ctls_sharedmem = snd_malloc_pages(sizeof(struct us428ctls_sharedmem), GFP_KERNEL))) |
1da177e4 | 80 | return -ENOMEM; |
bbe85bbd | 81 | memset(us428->us428ctls_sharedmem, -1, sizeof(struct us428ctls_sharedmem)); |
1da177e4 LT |
82 | us428->us428ctls_sharedmem->CtlSnapShotLast = -2; |
83 | } | |
84 | area->vm_ops = &us428ctls_vm_ops; | |
2f98735c | 85 | area->vm_flags |= VM_RESERVED | VM_DONTEXPAND; |
1da177e4 LT |
86 | area->vm_private_data = hw->private_data; |
87 | return 0; | |
88 | } | |
89 | ||
bbe85bbd | 90 | static unsigned int snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait) |
1da177e4 LT |
91 | { |
92 | unsigned int mask = 0; | |
bbe85bbd TI |
93 | struct usX2Ydev *us428 = hw->private_data; |
94 | struct us428ctls_sharedmem *shm = us428->us428ctls_sharedmem; | |
1da177e4 LT |
95 | if (us428->chip_status & USX2Y_STAT_CHIP_HUP) |
96 | return POLLHUP; | |
97 | ||
98 | poll_wait(file, &us428->us428ctls_wait_queue_head, wait); | |
99 | ||
100 | if (shm != NULL && shm->CtlSnapShotLast != shm->CtlSnapShotRed) | |
101 | mask |= POLLIN; | |
102 | ||
103 | return mask; | |
104 | } | |
105 | ||
106 | ||
bbe85bbd TI |
107 | static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, |
108 | struct snd_hwdep_dsp_status *info) | |
1da177e4 LT |
109 | { |
110 | static char *type_ids[USX2Y_TYPE_NUMS] = { | |
111 | [USX2Y_TYPE_122] = "us122", | |
112 | [USX2Y_TYPE_224] = "us224", | |
113 | [USX2Y_TYPE_428] = "us428", | |
114 | }; | |
bbe85bbd | 115 | struct usX2Ydev *us428 = hw->private_data; |
1da177e4 LT |
116 | int id = -1; |
117 | ||
a014bbad | 118 | switch (le16_to_cpu(us428->dev->descriptor.idProduct)) { |
1da177e4 LT |
119 | case USB_ID_US122: |
120 | id = USX2Y_TYPE_122; | |
121 | break; | |
122 | case USB_ID_US224: | |
123 | id = USX2Y_TYPE_224; | |
124 | break; | |
125 | case USB_ID_US428: | |
126 | id = USX2Y_TYPE_428; | |
127 | break; | |
128 | } | |
129 | if (0 > id) | |
130 | return -ENODEV; | |
131 | strcpy(info->id, type_ids[id]); | |
132 | info->num_dsps = 2; // 0: Prepad Data, 1: FPGA Code | |
bbe85bbd | 133 | if (us428->chip_status & USX2Y_STAT_CHIP_INIT) |
1da177e4 LT |
134 | info->chip_ready = 1; |
135 | info->version = USX2Y_DRIVER_VERSION; | |
136 | return 0; | |
137 | } | |
138 | ||
139 | ||
bbe85bbd | 140 | static int usX2Y_create_usbmidi(struct snd_card *card) |
1da177e4 | 141 | { |
bbe85bbd TI |
142 | static struct snd_usb_midi_endpoint_info quirk_data_1 = { |
143 | .out_ep = 0x06, | |
1da177e4 LT |
144 | .in_ep = 0x06, |
145 | .out_cables = 0x001, | |
146 | .in_cables = 0x001 | |
147 | }; | |
bbe85bbd | 148 | static struct snd_usb_audio_quirk quirk_1 = { |
1da177e4 LT |
149 | .vendor_name = "TASCAM", |
150 | .product_name = NAME_ALLCAPS, | |
151 | .ifnum = 0, | |
152 | .type = QUIRK_MIDI_FIXED_ENDPOINT, | |
153 | .data = &quirk_data_1 | |
154 | }; | |
bbe85bbd TI |
155 | static struct snd_usb_midi_endpoint_info quirk_data_2 = { |
156 | .out_ep = 0x06, | |
1da177e4 LT |
157 | .in_ep = 0x06, |
158 | .out_cables = 0x003, | |
159 | .in_cables = 0x003 | |
160 | }; | |
bbe85bbd | 161 | static struct snd_usb_audio_quirk quirk_2 = { |
1da177e4 LT |
162 | .vendor_name = "TASCAM", |
163 | .product_name = "US428", | |
164 | .ifnum = 0, | |
165 | .type = QUIRK_MIDI_FIXED_ENDPOINT, | |
166 | .data = &quirk_data_2 | |
167 | }; | |
a014bbad | 168 | struct usb_device *dev = usX2Y(card)->dev; |
1da177e4 | 169 | struct usb_interface *iface = usb_ifnum_to_if(dev, 0); |
bbe85bbd TI |
170 | struct snd_usb_audio_quirk *quirk = |
171 | le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ? | |
172 | &quirk_2 : &quirk_1; | |
1da177e4 LT |
173 | |
174 | snd_printdd("usX2Y_create_usbmidi \n"); | |
d82af9f9 | 175 | return snd_usbmidi_create(card, iface, &usX2Y(card)->midi_list, quirk); |
1da177e4 LT |
176 | } |
177 | ||
bbe85bbd | 178 | static int usX2Y_create_alsa_devices(struct snd_card *card) |
1da177e4 LT |
179 | { |
180 | int err; | |
181 | ||
182 | do { | |
183 | if ((err = usX2Y_create_usbmidi(card)) < 0) { | |
d3d579f8 | 184 | snd_printk(KERN_ERR "usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i \n", err); |
1da177e4 LT |
185 | break; |
186 | } | |
187 | if ((err = usX2Y_audio_create(card)) < 0) | |
188 | break; | |
189 | if ((err = usX2Y_hwdep_pcm_new(card)) < 0) | |
190 | break; | |
191 | if ((err = snd_card_register(card)) < 0) | |
192 | break; | |
193 | } while (0); | |
194 | ||
195 | return err; | |
196 | } | |
197 | ||
bbe85bbd TI |
198 | static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, |
199 | struct snd_hwdep_dsp_image *dsp) | |
1da177e4 | 200 | { |
bbe85bbd | 201 | struct usX2Ydev *priv = hw->private_data; |
1da177e4 LT |
202 | int lret, err = -EINVAL; |
203 | snd_printdd( "dsp_load %s\n", dsp->name); | |
204 | ||
205 | if (access_ok(VERIFY_READ, dsp->image, dsp->length)) { | |
a014bbad | 206 | struct usb_device* dev = priv->dev; |
85385c15 LZ |
207 | char *buf; |
208 | ||
209 | buf = memdup_user(dsp->image, dsp->length); | |
210 | if (IS_ERR(buf)) | |
211 | return PTR_ERR(buf); | |
212 | ||
1da177e4 LT |
213 | err = usb_set_interface(dev, 0, 1); |
214 | if (err) | |
d3d579f8 | 215 | snd_printk(KERN_ERR "usb_set_interface error \n"); |
1da177e4 LT |
216 | else |
217 | err = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 2), buf, dsp->length, &lret, 6000); | |
218 | kfree(buf); | |
219 | } | |
220 | if (err) | |
221 | return err; | |
222 | if (dsp->index == 1) { | |
b27c187f | 223 | msleep(250); // give the device some time |
1da177e4 LT |
224 | err = usX2Y_AsyncSeq04_init(priv); |
225 | if (err) { | |
d3d579f8 | 226 | snd_printk(KERN_ERR "usX2Y_AsyncSeq04_init error \n"); |
1da177e4 LT |
227 | return err; |
228 | } | |
229 | err = usX2Y_In04_init(priv); | |
230 | if (err) { | |
d3d579f8 | 231 | snd_printk(KERN_ERR "usX2Y_In04_init error \n"); |
1da177e4 LT |
232 | return err; |
233 | } | |
234 | err = usX2Y_create_alsa_devices(hw->card); | |
235 | if (err) { | |
d3d579f8 | 236 | snd_printk(KERN_ERR "usX2Y_create_alsa_devices error %i \n", err); |
1da177e4 LT |
237 | snd_card_free(hw->card); |
238 | return err; | |
239 | } | |
240 | priv->chip_status |= USX2Y_STAT_CHIP_INIT; | |
241 | snd_printdd("%s: alsa all started\n", hw->name); | |
242 | } | |
243 | return err; | |
244 | } | |
245 | ||
246 | ||
bbe85bbd | 247 | int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device) |
1da177e4 LT |
248 | { |
249 | int err; | |
bbe85bbd | 250 | struct snd_hwdep *hw; |
1da177e4 LT |
251 | |
252 | if ((err = snd_hwdep_new(card, SND_USX2Y_LOADER_ID, 0, &hw)) < 0) | |
253 | return err; | |
254 | ||
255 | hw->iface = SNDRV_HWDEP_IFACE_USX2Y; | |
256 | hw->private_data = usX2Y(card); | |
1da177e4 LT |
257 | hw->ops.dsp_status = snd_usX2Y_hwdep_dsp_status; |
258 | hw->ops.dsp_load = snd_usX2Y_hwdep_dsp_load; | |
259 | hw->ops.mmap = snd_us428ctls_mmap; | |
260 | hw->ops.poll = snd_us428ctls_poll; | |
261 | hw->exclusive = 1; | |
262 | sprintf(hw->name, "/proc/bus/usb/%03d/%03d", device->bus->busnum, device->devnum); | |
263 | return 0; | |
264 | } | |
265 |