blob: a7ad2b0a2ac095b768bb6f9ddd7fdf65615b6654 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*********************************************************************
2 *
3 * msnd.c - Driver Base
4 *
5 * Turtle Beach MultiSound Sound Card Driver for Linux
6 *
7 * Copyright (C) 1998 Andrew Veliath
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 * $Id: msnd.c,v 1.17 1999/03/21 16:50:09 andrewtv Exp $
24 *
25 ********************************************************************/
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
28#include <linux/kernel.h>
29#include <linux/slab.h>
30#include <linux/vmalloc.h>
31#include <linux/types.h>
32#include <linux/delay.h>
33#include <linux/mm.h>
34#include <linux/init.h>
35#include <linux/interrupt.h>
36
37#include <asm/io.h>
38#include <asm/uaccess.h>
39#include <linux/spinlock.h>
40#include <asm/irq.h>
41#include "msnd.h"
42
43#define LOGNAME "msnd"
44
45#define MSND_MAX_DEVS 4
46
47static multisound_dev_t *devs[MSND_MAX_DEVS];
48static int num_devs;
49
50int __init msnd_register(multisound_dev_t *dev)
51{
52 int i;
53
54 for (i = 0; i < MSND_MAX_DEVS; ++i)
55 if (devs[i] == NULL)
56 break;
57
58 if (i == MSND_MAX_DEVS)
59 return -ENOMEM;
60
61 devs[i] = dev;
62 ++num_devs;
63 return 0;
64}
65
66void msnd_unregister(multisound_dev_t *dev)
67{
68 int i;
69
70 for (i = 0; i < MSND_MAX_DEVS; ++i)
71 if (devs[i] == dev)
72 break;
73
74 if (i == MSND_MAX_DEVS) {
75 printk(KERN_WARNING LOGNAME ": Unregistering unknown device\n");
76 return;
77 }
78
79 devs[i] = NULL;
80 --num_devs;
81}
82
83void msnd_init_queue(void __iomem *base, int start, int size)
84{
85 writew(PCTODSP_BASED(start), base + JQS_wStart);
86 writew(PCTODSP_OFFSET(size) - 1, base + JQS_wSize);
87 writew(0, base + JQS_wHead);
88 writew(0, base + JQS_wTail);
89}
90
91void msnd_fifo_init(msnd_fifo *f)
92{
93 f->data = NULL;
94}
95
96void msnd_fifo_free(msnd_fifo *f)
97{
98 if (f->data) {
99 vfree(f->data);
100 f->data = NULL;
101 }
102}
103
104int msnd_fifo_alloc(msnd_fifo *f, size_t n)
105{
106 msnd_fifo_free(f);
107 f->data = (char *)vmalloc(n);
108 f->n = n;
109 f->tail = 0;
110 f->head = 0;
111 f->len = 0;
112
113 if (!f->data)
114 return -ENOMEM;
115
116 return 0;
117}
118
119void msnd_fifo_make_empty(msnd_fifo *f)
120{
121 f->len = f->tail = f->head = 0;
122}
123
124int msnd_fifo_write_io(msnd_fifo *f, char __iomem *buf, size_t len)
125{
126 int count = 0;
127
128 while ((count < len) && (f->len != f->n)) {
129
130 int nwritten;
131
132 if (f->head <= f->tail) {
133 nwritten = len - count;
134 if (nwritten > f->n - f->tail)
135 nwritten = f->n - f->tail;
136 }
137 else {
138 nwritten = f->head - f->tail;
139 if (nwritten > len - count)
140 nwritten = len - count;
141 }
142
143 memcpy_fromio(f->data + f->tail, buf, nwritten);
144
145 count += nwritten;
146 buf += nwritten;
147 f->len += nwritten;
148 f->tail += nwritten;
149 f->tail %= f->n;
150 }
151
152 return count;
153}
154
155int msnd_fifo_write(msnd_fifo *f, const char *buf, size_t len)
156{
157 int count = 0;
158
159 while ((count < len) && (f->len != f->n)) {
160
161 int nwritten;
162
163 if (f->head <= f->tail) {
164 nwritten = len - count;
165 if (nwritten > f->n - f->tail)
166 nwritten = f->n - f->tail;
167 }
168 else {
169 nwritten = f->head - f->tail;
170 if (nwritten > len - count)
171 nwritten = len - count;
172 }
173
174 memcpy(f->data + f->tail, buf, nwritten);
175
176 count += nwritten;
177 buf += nwritten;
178 f->len += nwritten;
179 f->tail += nwritten;
180 f->tail %= f->n;
181 }
182
183 return count;
184}
185
186int msnd_fifo_read_io(msnd_fifo *f, char __iomem *buf, size_t len)
187{
188 int count = 0;
189
190 while ((count < len) && (f->len > 0)) {
191
192 int nread;
193
194 if (f->tail <= f->head) {
195 nread = len - count;
196 if (nread > f->n - f->head)
197 nread = f->n - f->head;
198 }
199 else {
200 nread = f->tail - f->head;
201 if (nread > len - count)
202 nread = len - count;
203 }
204
205 memcpy_toio(buf, f->data + f->head, nread);
206
207 count += nread;
208 buf += nread;
209 f->len -= nread;
210 f->head += nread;
211 f->head %= f->n;
212 }
213
214 return count;
215}
216
217int msnd_fifo_read(msnd_fifo *f, char *buf, size_t len)
218{
219 int count = 0;
220
221 while ((count < len) && (f->len > 0)) {
222
223 int nread;
224
225 if (f->tail <= f->head) {
226 nread = len - count;
227 if (nread > f->n - f->head)
228 nread = f->n - f->head;
229 }
230 else {
231 nread = f->tail - f->head;
232 if (nread > len - count)
233 nread = len - count;
234 }
235
236 memcpy(buf, f->data + f->head, nread);
237
238 count += nread;
239 buf += nread;
240 f->len -= nread;
241 f->head += nread;
242 f->head %= f->n;
243 }
244
245 return count;
246}
247
248static int msnd_wait_TXDE(multisound_dev_t *dev)
249{
250 register unsigned int io = dev->io;
251 register int timeout = 1000;
252
253 while(timeout-- > 0)
254 if (msnd_inb(io + HP_ISR) & HPISR_TXDE)
255 return 0;
256
257 return -EIO;
258}
259
260static int msnd_wait_HC0(multisound_dev_t *dev)
261{
262 register unsigned int io = dev->io;
263 register int timeout = 1000;
264
265 while(timeout-- > 0)
266 if (!(msnd_inb(io + HP_CVR) & HPCVR_HC))
267 return 0;
268
269 return -EIO;
270}
271
272int msnd_send_dsp_cmd(multisound_dev_t *dev, BYTE cmd)
273{
274 unsigned long flags;
275
276 spin_lock_irqsave(&dev->lock, flags);
277 if (msnd_wait_HC0(dev) == 0) {
278 msnd_outb(cmd, dev->io + HP_CVR);
279 spin_unlock_irqrestore(&dev->lock, flags);
280 return 0;
281 }
282 spin_unlock_irqrestore(&dev->lock, flags);
283
284 printk(KERN_DEBUG LOGNAME ": Send DSP command timeout\n");
285
286 return -EIO;
287}
288
289int msnd_send_word(multisound_dev_t *dev, unsigned char high,
290 unsigned char mid, unsigned char low)
291{
292 register unsigned int io = dev->io;
293
294 if (msnd_wait_TXDE(dev) == 0) {
295 msnd_outb(high, io + HP_TXH);
296 msnd_outb(mid, io + HP_TXM);
297 msnd_outb(low, io + HP_TXL);
298 return 0;
299 }
300
301 printk(KERN_DEBUG LOGNAME ": Send host word timeout\n");
302
303 return -EIO;
304}
305
306int msnd_upload_host(multisound_dev_t *dev, char *bin, int len)
307{
308 int i;
309
310 if (len % 3 != 0) {
311 printk(KERN_WARNING LOGNAME ": Upload host data not multiple of 3!\n");
312 return -EINVAL;
313 }
314
315 for (i = 0; i < len; i += 3)
316 if (msnd_send_word(dev, bin[i], bin[i + 1], bin[i + 2]) != 0)
317 return -EIO;
318
319 msnd_inb(dev->io + HP_RXL);
320 msnd_inb(dev->io + HP_CVR);
321
322 return 0;
323}
324
325int msnd_enable_irq(multisound_dev_t *dev)
326{
327 unsigned long flags;
328
329 if (dev->irq_ref++)
330 return 0;
331
332 printk(KERN_DEBUG LOGNAME ": Enabling IRQ\n");
333
334 spin_lock_irqsave(&dev->lock, flags);
335 if (msnd_wait_TXDE(dev) == 0) {
336 msnd_outb(msnd_inb(dev->io + HP_ICR) | HPICR_TREQ, dev->io + HP_ICR);
337 if (dev->type == msndClassic)
338 msnd_outb(dev->irqid, dev->io + HP_IRQM);
339 msnd_outb(msnd_inb(dev->io + HP_ICR) & ~HPICR_TREQ, dev->io + HP_ICR);
340 msnd_outb(msnd_inb(dev->io + HP_ICR) | HPICR_RREQ, dev->io + HP_ICR);
341 enable_irq(dev->irq);
342 msnd_init_queue(dev->DSPQ, dev->dspq_data_buff, dev->dspq_buff_size);
343 spin_unlock_irqrestore(&dev->lock, flags);
344 return 0;
345 }
346 spin_unlock_irqrestore(&dev->lock, flags);
347
348 printk(KERN_DEBUG LOGNAME ": Enable IRQ failed\n");
349
350 return -EIO;
351}
352
353int msnd_disable_irq(multisound_dev_t *dev)
354{
355 unsigned long flags;
356
357 if (--dev->irq_ref > 0)
358 return 0;
359
360 if (dev->irq_ref < 0)
361 printk(KERN_DEBUG LOGNAME ": IRQ ref count is %d\n", dev->irq_ref);
362
363 printk(KERN_DEBUG LOGNAME ": Disabling IRQ\n");
364
365 spin_lock_irqsave(&dev->lock, flags);
366 if (msnd_wait_TXDE(dev) == 0) {
367 msnd_outb(msnd_inb(dev->io + HP_ICR) & ~HPICR_RREQ, dev->io + HP_ICR);
368 if (dev->type == msndClassic)
369 msnd_outb(HPIRQ_NONE, dev->io + HP_IRQM);
370 disable_irq(dev->irq);
371 spin_unlock_irqrestore(&dev->lock, flags);
372 return 0;
373 }
374 spin_unlock_irqrestore(&dev->lock, flags);
375
376 printk(KERN_DEBUG LOGNAME ": Disable IRQ failed\n");
377
378 return -EIO;
379}
380
381#ifndef LINUX20
382EXPORT_SYMBOL(msnd_register);
383EXPORT_SYMBOL(msnd_unregister);
384
385EXPORT_SYMBOL(msnd_init_queue);
386
387EXPORT_SYMBOL(msnd_fifo_init);
388EXPORT_SYMBOL(msnd_fifo_free);
389EXPORT_SYMBOL(msnd_fifo_alloc);
390EXPORT_SYMBOL(msnd_fifo_make_empty);
391EXPORT_SYMBOL(msnd_fifo_write_io);
392EXPORT_SYMBOL(msnd_fifo_read_io);
393EXPORT_SYMBOL(msnd_fifo_write);
394EXPORT_SYMBOL(msnd_fifo_read);
395
396EXPORT_SYMBOL(msnd_send_dsp_cmd);
397EXPORT_SYMBOL(msnd_send_word);
398EXPORT_SYMBOL(msnd_upload_host);
399
400EXPORT_SYMBOL(msnd_enable_irq);
401EXPORT_SYMBOL(msnd_disable_irq);
402#endif
403
404#ifdef MODULE
405MODULE_AUTHOR ("Andrew Veliath <andrewtv@usa.net>");
406MODULE_DESCRIPTION ("Turtle Beach MultiSound Driver Base");
407MODULE_LICENSE("GPL");
408
409
410int init_module(void)
411{
412 return 0;
413}
414
415void cleanup_module(void)
416{
417}
418#endif