OpenCores
URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [oss/] [btaudio.c] - Blame information for rev 3

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 3 xianfeng 
/*
2 
    btaudio - bt878 audio dma driver for linux 2.4.x
3 
 
4 
    (c) 2000-2002 Gerd Knorr <kraxel@bytesex.org>
5 
 
6 
    This program is free software; you can redistribute it and/or modify
7 
    it under the terms of the GNU General Public License as published by
8 
    the Free Software Foundation; either version 2 of the License, or
9 
    (at your option) any later version.
10 
 
11 
    This program is distributed in the hope that it will be useful,
12 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 
    GNU General Public License for more details.
15 
 
16 
    You should have received a copy of the GNU General Public License
17 
    along with this program; if not, write to the Free Software
18 
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 
 
20 
*/
21 
 
22 
#include <linux/module.h>
23 
#include <linux/errno.h>
24 
#include <linux/pci.h>
25 
#include <linux/sched.h>
26 
#include <linux/signal.h>
27 
#include <linux/types.h>
28 
#include <linux/interrupt.h>
29 
#include <linux/init.h>
30 
#include <linux/poll.h>
31 
#include <linux/sound.h>
32 
#include <linux/soundcard.h>
33 
#include <linux/slab.h>
34 
#include <linux/kdev_t.h>
35 
#include <linux/mutex.h>
36 
 
37 
#include <asm/uaccess.h>
38 
#include <asm/io.h>
39 
 
40 
 
41 
/* mmio access */
42 
#define btwrite(dat,adr)    writel((dat), (bta->mmio+(adr)))
43 
#define btread(adr)         readl(bta->mmio+(adr))
44 
 
45 
#define btand(dat,adr)      btwrite((dat) & btread(adr), adr)
46 
#define btor(dat,adr)       btwrite((dat) | btread(adr), adr)
47 
#define btaor(dat,mask,adr) btwrite((dat) | ((mask) & btread(adr)), adr)
48 
 
49 
/* registers (shifted because bta->mmio is long) */
50 
#define REG_INT_STAT      (0x100 >> 2)
51 
#define REG_INT_MASK      (0x104 >> 2)
52 
#define REG_GPIO_DMA_CTL  (0x10c >> 2)
53 
#define REG_PACKET_LEN    (0x110 >> 2)
54 
#define REG_RISC_STRT_ADD (0x114 >> 2)
55 
#define REG_RISC_COUNT    (0x120 >> 2)
56 
 
57 
/* IRQ bits - REG_INT_(STAT|MASK) */
58 
#define IRQ_SCERR         (1 << 19)
59 
#define IRQ_OCERR         (1 << 18)
60 
#define IRQ_PABORT        (1 << 17)
61 
#define IRQ_RIPERR        (1 << 16)
62 
#define IRQ_PPERR         (1 << 15)
63 
#define IRQ_FDSR          (1 << 14)
64 
#define IRQ_FTRGT         (1 << 13)
65 
#define IRQ_FBUS          (1 << 12)
66 
#define IRQ_RISCI         (1 << 11)
67 
#define IRQ_OFLOW         (1 <<  3)
68 
 
69 
#define IRQ_BTAUDIO       (IRQ_SCERR | IRQ_OCERR | IRQ_PABORT | IRQ_RIPERR |\
70 
                           IRQ_PPERR | IRQ_FDSR  | IRQ_FTRGT  | IRQ_FBUS   |\
71 
                           IRQ_RISCI)
72 
 
73 
/* REG_GPIO_DMA_CTL bits */
74 
#define DMA_CTL_A_PWRDN   (1 << 26)
75 
#define DMA_CTL_DA_SBR    (1 << 14)
76 
#define DMA_CTL_DA_ES2    (1 << 13)
77 
#define DMA_CTL_ACAP_EN   (1 <<  4)
78 
#define DMA_CTL_RISC_EN   (1 <<  1)
79 
#define DMA_CTL_FIFO_EN   (1 <<  0)
80 
 
81 
/* RISC instructions */
82 
#define RISC_WRITE        (0x01 << 28)
83 
#define RISC_JUMP         (0x07 << 28)
84 
#define RISC_SYNC         (0x08 << 28)
85 
 
86 
/* RISC bits */
87 
#define RISC_WR_SOL       (1 << 27)
88 
#define RISC_WR_EOL       (1 << 26)
89 
#define RISC_IRQ          (1 << 24)
90 
#define RISC_SYNC_RESYNC  (1 << 15)
91 
#define RISC_SYNC_FM1     0x06
92 
#define RISC_SYNC_VRO     0x0c
93 
 
94 
#define HWBASE_AD (448000)
95 
 
96 
/* -------------------------------------------------------------- */
97 
 
98 
struct btaudio {
99 
        /* linked list */
100 
        struct btaudio *next;
101 
 
102 
        /* device info */
103 
        int            dsp_digital;
104 
        int            dsp_analog;
105 
        int            mixer_dev;
106 
        struct pci_dev *pci;
107 
        unsigned int   irq;
108 
        unsigned long  mem;
109 
        unsigned long  __iomem *mmio;
110 
 
111 
        /* locking */
112 
        int            users;
113 
        struct mutex lock;
114 
 
115 
        /* risc instructions */
116 
        unsigned int   risc_size;
117 
        unsigned long  *risc_cpu;
118 
        dma_addr_t     risc_dma;
119 
 
120 
        /* audio data */
121 
        unsigned int   buf_size;
122 
        unsigned char  *buf_cpu;
123 
        dma_addr_t     buf_dma;
124 
 
125 
        /* buffer setup */
126 
        int line_bytes;
127 
        int line_count;
128 
        int block_bytes;
129 
        int block_count;
130 
 
131 
        /* read fifo management */
132 
        int recording;
133 
        int dma_block;
134 
        int read_offset;
135 
        int read_count;
136 
        wait_queue_head_t readq;
137 
 
138 
        /* settings */
139 
        int gain[3];
140 
        int source;
141 
        int bits;
142 
        int decimation;
143 
        int mixcount;
144 
        int sampleshift;
145 
        int channels;
146 
        int analog;
147 
        int rate;
148 
};
149 
 
150 
struct cardinfo {
151 
        char *name;
152 
        int rate;
153 
};
154 
 
155 
static struct btaudio *btaudios;
156 
static unsigned int debug;
157 
static unsigned int irq_debug;
158 
 
159 
/* -------------------------------------------------------------- */
160 
 
161 
#define BUF_DEFAULT 128*1024
162 
#define BUF_MIN         8192
163 
 
164 
static int alloc_buffer(struct btaudio *bta)
165 
{
166 
        if (NULL == bta->buf_cpu) {
167 
                for (bta->buf_size = BUF_DEFAULT; bta->buf_size >= BUF_MIN;
168 
                     bta->buf_size = bta->buf_size >> 1) {
169 
                        bta->buf_cpu = pci_alloc_consistent
170 
                                (bta->pci, bta->buf_size, &bta->buf_dma);
171 
                        if (NULL != bta->buf_cpu)
172 
                                break;
173 
                }
174 
                if (NULL == bta->buf_cpu)
175 
                        return -ENOMEM;
176 
                memset(bta->buf_cpu,0,bta->buf_size);
177 
        }
178 
        if (NULL == bta->risc_cpu) {
179 
                bta->risc_size = PAGE_SIZE;
180 
                bta->risc_cpu = pci_alloc_consistent
181 
                        (bta->pci, bta->risc_size, &bta->risc_dma);
182 
                if (NULL == bta->risc_cpu) {
183 
                        pci_free_consistent(bta->pci, bta->buf_size, bta->buf_cpu, bta->buf_dma);
184 
                        bta->buf_cpu = NULL;
185 
                        return -ENOMEM;
186 
                }
187 
        }
188 
        return 0;
189 
}
190 
 
191 
static void free_buffer(struct btaudio *bta)
192 
{
193 
        if (NULL != bta->buf_cpu) {
194 
                pci_free_consistent(bta->pci, bta->buf_size,
195 
                                    bta->buf_cpu, bta->buf_dma);
196 
                bta->buf_cpu = NULL;
197 
        }
198 
        if (NULL != bta->risc_cpu) {
199 
                pci_free_consistent(bta->pci, bta->risc_size,
200 
                                    bta->risc_cpu, bta->risc_dma);
201 
                bta->risc_cpu = NULL;
202 
        }
203 
}
204 
 
205 
static int make_risc(struct btaudio *bta)
206 
{
207 
        int rp, bp, line, block;
208 
        unsigned long risc;
209 
 
210 
        bta->block_bytes = bta->buf_size >> 4;
211 
        bta->block_count = 1 << 4;
212 
        bta->line_bytes  = bta->block_bytes;
213 
        bta->line_count  = bta->block_count;
214 
        while (bta->line_bytes > 4095) {
215 
                bta->line_bytes >>= 1;
216 
                bta->line_count <<= 1;
217 
        }
218 
        if (bta->line_count > 255)
219 
                return -EINVAL;
220 
        if (debug)
221 
                printk(KERN_DEBUG
222 
                       "btaudio: bufsize=%d - bs=%d bc=%d - ls=%d, lc=%d\n",
223 
                       bta->buf_size,bta->block_bytes,bta->block_count,
224 
                       bta->line_bytes,bta->line_count);
225 
        rp = 0; bp = 0;
226 
        block = 0;
227 
        bta->risc_cpu[rp++] = cpu_to_le32(RISC_SYNC|RISC_SYNC_FM1);
228 
        bta->risc_cpu[rp++] = cpu_to_le32(0);
229 
        for (line = 0; line < bta->line_count; line++) {
230 
                risc  = RISC_WRITE | RISC_WR_SOL | RISC_WR_EOL;
231 
                risc |= bta->line_bytes;
232 
                if (0 == (bp & (bta->block_bytes-1))) {
233 
                        risc |= RISC_IRQ;
234 
                        risc |= (block  & 0x0f) << 16;
235 
                        risc |= (~block & 0x0f) << 20;
236 
                        block++;
237 
                }
238 
                bta->risc_cpu[rp++] = cpu_to_le32(risc);
239 
                bta->risc_cpu[rp++] = cpu_to_le32(bta->buf_dma + bp);
240 
                bp += bta->line_bytes;
241 
        }
242 
        bta->risc_cpu[rp++] = cpu_to_le32(RISC_SYNC|RISC_SYNC_VRO);
243 
        bta->risc_cpu[rp++] = cpu_to_le32(0);
244 
        bta->risc_cpu[rp++] = cpu_to_le32(RISC_JUMP);
245 
        bta->risc_cpu[rp++] = cpu_to_le32(bta->risc_dma);
246 
        return 0;
247 
}
248 
 
249 
static int start_recording(struct btaudio *bta)
250 
{
251 
        int ret;
252 
 
253 
        if (0 != (ret = alloc_buffer(bta)))
254 
                return ret;
255 
        if (0 != (ret = make_risc(bta)))
256 
                return ret;
257 
 
258 
        btwrite(bta->risc_dma, REG_RISC_STRT_ADD);
259 
        btwrite((bta->line_count << 16) | bta->line_bytes,
260 
                REG_PACKET_LEN);
261 
        btwrite(IRQ_BTAUDIO, REG_INT_MASK);
262 
        if (bta->analog) {
263 
                btwrite(DMA_CTL_ACAP_EN |
264 
                        DMA_CTL_RISC_EN |
265 
                        DMA_CTL_FIFO_EN |
266 
                        DMA_CTL_DA_ES2  |
267 
                        ((bta->bits == 8) ? DMA_CTL_DA_SBR : 0) |
268 
                        (bta->gain[bta->source] << 28) |
269 
                        (bta->source            << 24) |
270 
                        (bta->decimation        <<  8),
271 
                        REG_GPIO_DMA_CTL);
272 
        } else {
273 
                btwrite(DMA_CTL_ACAP_EN |
274 
                        DMA_CTL_RISC_EN |
275 
                        DMA_CTL_FIFO_EN |
276 
                        DMA_CTL_DA_ES2  |
277 
                        DMA_CTL_A_PWRDN |
278 
                        (1 << 6)   |
279 
                        ((bta->bits == 8) ? DMA_CTL_DA_SBR : 0) |
280 
                        (bta->gain[bta->source] << 28) |
281 
                        (bta->source            << 24) |
282 
                        (bta->decimation        <<  8),
283 
                        REG_GPIO_DMA_CTL);
284 
        }
285 
        bta->dma_block = 0;
286 
        bta->read_offset = 0;
287 
        bta->read_count = 0;
288 
        bta->recording = 1;
289 
        if (debug)
290 
                printk(KERN_DEBUG "btaudio: recording started\n");
291 
        return 0;
292 
}
293 
 
294 
static void stop_recording(struct btaudio *bta)
295 
{
296 
        btand(~15, REG_GPIO_DMA_CTL);
297 
        bta->recording = 0;
298 
        if (debug)
299 
                printk(KERN_DEBUG "btaudio: recording stopped\n");
300 
}
301 
 
302 
 
303 
/* -------------------------------------------------------------- */
304 
 
305 
static int btaudio_mixer_open(struct inode *inode, struct file *file)
306 
{
307 
        int minor = iminor(inode);
308 
        struct btaudio *bta;
309 
 
310 
        for (bta = btaudios; bta != NULL; bta = bta->next)
311 
                if (bta->mixer_dev == minor)
312 
                        break;
313 
        if (NULL == bta)
314 
                return -ENODEV;
315 
 
316 
        if (debug)
317 
                printk("btaudio: open mixer [%d]\n",minor);
318 
        file->private_data = bta;
319 
        return 0;
320 
}
321 
 
322 
static int btaudio_mixer_release(struct inode *inode, struct file *file)
323 
{
324 
        return 0;
325 
}
326 
 
327 
static int btaudio_mixer_ioctl(struct inode *inode, struct file *file,
328 
                               unsigned int cmd, unsigned long arg)
329 
{
330 
        struct btaudio *bta = file->private_data;
331 
        int ret,val=0,i=0;
332 
        void __user *argp = (void __user *)arg;
333 
 
334 
        if (cmd == SOUND_MIXER_INFO) {
335 
                mixer_info info;
336 
                memset(&info,0,sizeof(info));
337 
                strlcpy(info.id,"bt878",sizeof(info.id));
338 
                strlcpy(info.name,"Brooktree Bt878 audio",sizeof(info.name));
339 
                info.modify_counter = bta->mixcount;
340 
                if (copy_to_user(argp, &info, sizeof(info)))
341 
                        return -EFAULT;
342 
                return 0;
343 
        }
344 
        if (cmd == SOUND_OLD_MIXER_INFO) {
345 
                _old_mixer_info info;
346 
                memset(&info,0,sizeof(info));
347 
                strlcpy(info.id, "bt878", sizeof(info.id));
348 
                strlcpy(info.name,"Brooktree Bt878 audio",sizeof(info.name));
349 
                if (copy_to_user(argp, &info, sizeof(info)))
350 
                        return -EFAULT;
351 
                return 0;
352 
        }
353 
        if (cmd == OSS_GETVERSION)
354 
                return put_user(SOUND_VERSION, (int __user *)argp);
355 
 
356 
        /* read */
357 
        if (_SIOC_DIR(cmd) & _SIOC_WRITE)
358 
                if (get_user(val, (int __user *)argp))
359 
                        return -EFAULT;
360 
 
361 
        switch (cmd) {
362 
        case MIXER_READ(SOUND_MIXER_CAPS):
363 
                ret = SOUND_CAP_EXCL_INPUT;
364 
                break;
365 
        case MIXER_READ(SOUND_MIXER_STEREODEVS):
366 
                ret = 0;
367 
                break;
368 
        case MIXER_READ(SOUND_MIXER_RECMASK):
369 
        case MIXER_READ(SOUND_MIXER_DEVMASK):
370 
                ret = SOUND_MASK_LINE1|SOUND_MASK_LINE2|SOUND_MASK_LINE3;
371 
                break;
372 
 
373 
        case MIXER_WRITE(SOUND_MIXER_RECSRC):
374 
                if (val & SOUND_MASK_LINE1 && bta->source != 0)
375 
                        bta->source = 0;
376 
                else if (val & SOUND_MASK_LINE2 && bta->source != 1)
377 
                        bta->source = 1;
378 
                else if (val & SOUND_MASK_LINE3 && bta->source != 2)
379 
                        bta->source = 2;
380 
                btaor((bta->gain[bta->source] << 28) |
381 
                      (bta->source            << 24),
382 
                      0x0cffffff, REG_GPIO_DMA_CTL);
383 
        case MIXER_READ(SOUND_MIXER_RECSRC):
384 
                switch (bta->source) {
385 
                case 0:  ret = SOUND_MASK_LINE1; break;
386 
                case 1:  ret = SOUND_MASK_LINE2; break;
387 
                case 2:  ret = SOUND_MASK_LINE3; break;
388 
                default: ret = 0;
389 
                }
390 
                break;
391 
 
392 
        case MIXER_WRITE(SOUND_MIXER_LINE1):
393 
        case MIXER_WRITE(SOUND_MIXER_LINE2):
394 
        case MIXER_WRITE(SOUND_MIXER_LINE3):
395 
                if (MIXER_WRITE(SOUND_MIXER_LINE1) == cmd)
396 
                        i = 0;
397 
                if (MIXER_WRITE(SOUND_MIXER_LINE2) == cmd)
398 
                        i = 1;
399 
                if (MIXER_WRITE(SOUND_MIXER_LINE3) == cmd)
400 
                        i = 2;
401 
                bta->gain[i] = (val & 0xff) * 15 / 100;
402 
                if (bta->gain[i] > 15) bta->gain[i] = 15;
403 
                if (bta->gain[i] <  0) bta->gain[i] =  0;
404 
                if (i == bta->source)
405 
                        btaor((bta->gain[bta->source]<<28),
406 
                              0x0fffffff, REG_GPIO_DMA_CTL);
407 
                ret  = bta->gain[i] * 100 / 15;
408 
                ret |= ret << 8;
409 
                break;
410 
 
411 
        case MIXER_READ(SOUND_MIXER_LINE1):
412 
        case MIXER_READ(SOUND_MIXER_LINE2):
413 
        case MIXER_READ(SOUND_MIXER_LINE3):
414 
                if (MIXER_READ(SOUND_MIXER_LINE1) == cmd)
415 
                        i = 0;
416 
                if (MIXER_READ(SOUND_MIXER_LINE2) == cmd)
417 
                        i = 1;
418 
                if (MIXER_READ(SOUND_MIXER_LINE3) == cmd)
419 
                        i = 2;
420 
                ret  = bta->gain[i] * 100 / 15;
421 
                ret |= ret << 8;
422 
                break;
423 
 
424 
        default:
425 
                return -EINVAL;
426 
        }
427 
        if (put_user(ret, (int __user *)argp))
428 
                return -EFAULT;
429 
        return 0;
430 
}
431 
 
432 
static const struct file_operations btaudio_mixer_fops = {
433 
        .owner          = THIS_MODULE,
434 
        .llseek         = no_llseek,
435 
        .open           = btaudio_mixer_open,
436 
        .release        = btaudio_mixer_release,
437 
        .ioctl          = btaudio_mixer_ioctl,
438 
};
439 
 
440 
/* -------------------------------------------------------------- */
441 
 
442 
static int btaudio_dsp_open(struct inode *inode, struct file *file,
443 
                            struct btaudio *bta, int analog)
444 
{
445 
        mutex_lock(&bta->lock);
446 
        if (bta->users)
447 
                goto busy;
448 
        bta->users++;
449 
        file->private_data = bta;
450 
 
451 
        bta->analog = analog;
452 
        bta->dma_block = 0;
453 
        bta->read_offset = 0;
454 
        bta->read_count = 0;
455 
        bta->sampleshift = 0;
456 
 
457 
        mutex_unlock(&bta->lock);
458 
        return 0;
459 
 
460 
 busy:
461 
        mutex_unlock(&bta->lock);
462 
        return -EBUSY;
463 
}
464 
 
465 
static int btaudio_dsp_open_digital(struct inode *inode, struct file *file)
466 
{
467 
        int minor = iminor(inode);
468 
        struct btaudio *bta;
469 
 
470 
        for (bta = btaudios; bta != NULL; bta = bta->next)
471 
                if (bta->dsp_digital == minor)
472 
                        break;
473 
        if (NULL == bta)
474 
                return -ENODEV;
475 
 
476 
        if (debug)
477 
                printk("btaudio: open digital dsp [%d]\n",minor);
478 
        return btaudio_dsp_open(inode,file,bta,0);
479 
}
480 
 
481 
static int btaudio_dsp_open_analog(struct inode *inode, struct file *file)
482 
{
483 
        int minor = iminor(inode);
484 
        struct btaudio *bta;
485 
 
486 
        for (bta = btaudios; bta != NULL; bta = bta->next)
487 
                if (bta->dsp_analog == minor)
488 
                        break;
489 
        if (NULL == bta)
490 
                return -ENODEV;
491 
 
492 
        if (debug)
493 
                printk("btaudio: open analog dsp [%d]\n",minor);
494 
        return btaudio_dsp_open(inode,file,bta,1);
495 
}
496 
 
497 
static int btaudio_dsp_release(struct inode *inode, struct file *file)
498 
{
499 
        struct btaudio *bta = file->private_data;
500 
 
501 
        mutex_lock(&bta->lock);
502 
        if (bta->recording)
503 
                stop_recording(bta);
504 
        bta->users--;
505 
        mutex_unlock(&bta->lock);
506 
        return 0;
507 
}
508 
 
509 
static ssize_t btaudio_dsp_read(struct file *file, char __user *buffer,
510 
                                size_t swcount, loff_t *ppos)
511 
{
512 
        struct btaudio *bta = file->private_data;
513 
        int hwcount = swcount << bta->sampleshift;
514 
        int nsrc, ndst, err, ret = 0;
515 
        DECLARE_WAITQUEUE(wait, current);
516 
 
517 
        add_wait_queue(&bta->readq, &wait);
518 
        mutex_lock(&bta->lock);
519 
        while (swcount > 0) {
520 
                if (0 == bta->read_count) {
521 
                        if (!bta->recording) {
522 
                                if (0 != (err = start_recording(bta))) {
523 
                                        if (0 == ret)
524 
                                                ret = err;
525 
                                        break;
526 
                                }
527 
                        }
528 
                        if (file->f_flags & O_NONBLOCK) {
529 
                                if (0 == ret)
530 
                                        ret = -EAGAIN;
531 
                                break;
532 
                        }
533 
                        mutex_unlock(&bta->lock);
534 
                        current->state = TASK_INTERRUPTIBLE;
535 
                        schedule();
536 
                        mutex_lock(&bta->lock);
537 
                        if(signal_pending(current)) {
538 
                                if (0 == ret)
539 
                                        ret = -EINTR;
540 
                                break;
541 
                        }
542 
                }
543 
                nsrc = (bta->read_count < hwcount) ? bta->read_count : hwcount;
544 
                if (nsrc > bta->buf_size - bta->read_offset)
545 
                        nsrc = bta->buf_size - bta->read_offset;
546 
                ndst = nsrc >> bta->sampleshift;
547 
 
548 
                if ((bta->analog  && 0 == bta->sampleshift) ||
549 
                    (!bta->analog && 2 == bta->channels)) {
550 
                        /* just copy */
551 
                        if (copy_to_user(buffer + ret, bta->buf_cpu + bta->read_offset, nsrc)) {
552 
                                if (0 == ret)
553 
                                        ret = -EFAULT;
554 
                                break;
555 
                        }
556 
 
557 
                } else if (!bta->analog) {
558 
                        /* stereo => mono (digital audio) */
559 
                        __s16 *src = (__s16*)(bta->buf_cpu + bta->read_offset);
560 
                        __s16 __user *dst = (__s16 __user *)(buffer + ret);
561 
                        __s16 avg;
562 
                        int n = ndst>>1;
563 
                        if (!access_ok(VERIFY_WRITE, dst, ndst)) {
564 
                                if (0 == ret)
565 
                                        ret = -EFAULT;
566 
                                break;
567 
                        }
568 
                        for (; n; n--, dst++) {
569 
                                avg  = (__s16)le16_to_cpu(*src) / 2; src++;
570 
                                avg += (__s16)le16_to_cpu(*src) / 2; src++;
571 
                                __put_user(cpu_to_le16(avg),dst);
572 
                        }
573 
 
574 
                } else if (8 == bta->bits) {
575 
                        /* copy + byte downsampling (audio A/D) */
576 
                        __u8 *src = bta->buf_cpu + bta->read_offset;
577 
                        __u8 __user *dst = buffer + ret;
578 
                        int n = ndst;
579 
                        if (!access_ok(VERIFY_WRITE, dst, ndst)) {
580 
                                if (0 == ret)
581 
                                        ret = -EFAULT;
582 
                                break;
583 
                        }
584 
                        for (; n; n--, src += (1 << bta->sampleshift), dst++)
585 
                                __put_user(*src, dst);
586 
 
587 
                } else {
588 
                        /* copy + word downsampling (audio A/D) */
589 
                        __u16 *src = (__u16*)(bta->buf_cpu + bta->read_offset);
590 
                        __u16 __user *dst = (__u16 __user *)(buffer + ret);
591 
                        int n = ndst>>1;
592 
                        if (!access_ok(VERIFY_WRITE,dst,ndst)) {
593 
                                if (0 == ret)
594 
                                        ret = -EFAULT;
595 
                                break;
596 
                        }
597 
                        for (; n; n--, src += (1 << bta->sampleshift), dst++)
598 
                                __put_user(*src, dst);
599 
                }
600 
 
601 
                ret     += ndst;
602 
                swcount -= ndst;
603 
                hwcount -= nsrc;
604 
                bta->read_count  -= nsrc;
605 
                bta->read_offset += nsrc;
606 
                if (bta->read_offset == bta->buf_size)
607 
                        bta->read_offset = 0;
608 
        }
609 
        mutex_unlock(&bta->lock);
610 
        remove_wait_queue(&bta->readq, &wait);
611 
        current->state = TASK_RUNNING;
612 
        return ret;
613 
}
614 
 
615 
static ssize_t btaudio_dsp_write(struct file *file, const char __user *buffer,
616 
                                 size_t count, loff_t *ppos)
617 
{
618 
        return -EINVAL;
619 
}
620 
 
621 
static int btaudio_dsp_ioctl(struct inode *inode, struct file *file,
622 
                             unsigned int cmd, unsigned long arg)
623 
{
624 
        struct btaudio *bta = file->private_data;
625 
        int s, i, ret, val = 0;
626 
        void __user *argp = (void __user *)arg;
627 
        int __user *p = argp;
628 
 
629 
        switch (cmd) {
630 
        case OSS_GETVERSION:
631 
                return put_user(SOUND_VERSION, p);
632 
        case SNDCTL_DSP_GETCAPS:
633 
                return 0;
634 
 
635 
        case SNDCTL_DSP_SPEED:
636 
                if (get_user(val, p))
637 
                        return -EFAULT;
638 
                if (bta->analog) {
639 
                        for (s = 0; s < 16; s++)
640 
                                if (val << s >= HWBASE_AD*4/15)
641 
                                        break;
642 
                        for (i = 15; i >= 5; i--)
643 
                                if (val << s <= HWBASE_AD*4/i)
644 
                                        break;
645 
                        bta->sampleshift = s;
646 
                        bta->decimation  = i;
647 
                        if (debug)
648 
                                printk(KERN_DEBUG "btaudio: rate: req=%d  "
649 
                                       "dec=%d shift=%d hwrate=%d swrate=%d\n",
650 
                                       val,i,s,(HWBASE_AD*4/i),(HWBASE_AD*4/i)>>s);
651 
                } else {
652 
                        bta->sampleshift = (bta->channels == 2) ? 0 : 1;
653 
                        bta->decimation  = 0;
654 
                }
655 
                if (bta->recording) {
656 
                        mutex_lock(&bta->lock);
657 
                        stop_recording(bta);
658 
                        start_recording(bta);
659 
                        mutex_unlock(&bta->lock);
660 
                }
661 
                /* fall through */
662 
        case SOUND_PCM_READ_RATE:
663 
                if (bta->analog) {
664 
                        return put_user(HWBASE_AD*4/bta->decimation>>bta->sampleshift, p);
665 
                } else {
666 
                        return put_user(bta->rate, p);
667 
                }
668 
 
669 
        case SNDCTL_DSP_STEREO:
670 
                if (!bta->analog) {
671 
                        if (get_user(val, p))
672 
                                return -EFAULT;
673 
                        bta->channels    = (val > 0) ? 2 : 1;
674 
                        bta->sampleshift = (bta->channels == 2) ? 0 : 1;
675 
                        if (debug)
676 
                                printk(KERN_INFO
677 
                                       "btaudio: stereo=%d channels=%d\n",
678 
                                       val,bta->channels);
679 
                } else {
680 
                        if (val == 1)
681 
                                return -EFAULT;
682 
                        else {
683 
                                bta->channels = 1;
684 
                                if (debug)
685 
                                        printk(KERN_INFO
686 
                                               "btaudio: stereo=0 channels=1\n");
687 
                        }
688 
                }
689 
                return put_user((bta->channels)-1, p);
690 
 
691 
        case SNDCTL_DSP_CHANNELS:
692 
                if (!bta->analog) {
693 
                        if (get_user(val, p))
694 
                                return -EFAULT;
695 
                        bta->channels    = (val > 1) ? 2 : 1;
696 
                        bta->sampleshift = (bta->channels == 2) ? 0 : 1;
697 
                        if (debug)
698 
                                printk(KERN_DEBUG
699 
                                       "btaudio: val=%d channels=%d\n",
700 
                                       val,bta->channels);
701 
                }
702 
                /* fall through */
703 
        case SOUND_PCM_READ_CHANNELS:
704 
                return put_user(bta->channels, p);
705 
 
706 
        case SNDCTL_DSP_GETFMTS: /* Returns a mask */
707 
                if (bta->analog)
708 
                        return put_user(AFMT_S16_LE|AFMT_S8, p);
709 
                else
710 
                        return put_user(AFMT_S16_LE, p);
711 
 
712 
        case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
713 
                if (get_user(val, p))
714 
                        return -EFAULT;
715 
                if (val != AFMT_QUERY) {
716 
                        if (bta->analog)
717 
                                bta->bits = (val == AFMT_S8) ? 8 : 16;
718 
                        else
719 
                                bta->bits = 16;
720 
                        if (bta->recording) {
721 
                                mutex_lock(&bta->lock);
722 
                                stop_recording(bta);
723 
                                start_recording(bta);
724 
                                mutex_unlock(&bta->lock);
725 
                        }
726 
                }
727 
                if (debug)
728 
                        printk(KERN_DEBUG "btaudio: fmt: bits=%d\n",bta->bits);
729 
                return put_user((bta->bits==16) ? AFMT_S16_LE : AFMT_S8,
730 
                                p);
731 
                break;
732 
        case SOUND_PCM_READ_BITS:
733 
                return put_user(bta->bits, p);
734 
 
735 
        case SNDCTL_DSP_NONBLOCK:
736 
                file->f_flags |= O_NONBLOCK;
737 
                return 0;
738 
 
739 
        case SNDCTL_DSP_RESET:
740 
                if (bta->recording) {
741 
                        mutex_lock(&bta->lock);
742 
                        stop_recording(bta);
743 
                        mutex_unlock(&bta->lock);
744 
                }
745 
                return 0;
746 
        case SNDCTL_DSP_GETBLKSIZE:
747 
                if (!bta->recording) {
748 
                        if (0 != (ret = alloc_buffer(bta)))
749 
                                return ret;
750 
                        if (0 != (ret = make_risc(bta)))
751 
                                return ret;
752 
                }
753 
                return put_user(bta->block_bytes>>bta->sampleshift,p);
754 
 
755 
        case SNDCTL_DSP_SYNC:
756 
                /* NOP */
757 
                return 0;
758 
        case SNDCTL_DSP_GETISPACE:
759 
        {
760 
                audio_buf_info info;
761 
                if (!bta->recording)
762 
                        return -EINVAL;
763 
                info.fragsize = bta->block_bytes>>bta->sampleshift;
764 
                info.fragstotal = bta->block_count;
765 
                info.bytes = bta->read_count;
766 
                info.fragments = info.bytes / info.fragsize;
767 
                if (debug)
768 
                        printk(KERN_DEBUG "btaudio: SNDCTL_DSP_GETISPACE "
769 
                               "returns %d/%d/%d/%d\n",
770 
                               info.fragsize, info.fragstotal,
771 
                               info.bytes, info.fragments);
772 
                if (copy_to_user(argp, &info, sizeof(info)))
773 
                        return -EFAULT;
774 
                return 0;
775 
        }
776 
#if 0 /* TODO */
777 
        case SNDCTL_DSP_GETTRIGGER:
778 
        case SNDCTL_DSP_SETTRIGGER:
779 
        case SNDCTL_DSP_SETFRAGMENT:
780 
#endif
781 
        default:
782 
                return -EINVAL;
783 
        }
784 
}
785 
 
786 
static unsigned int btaudio_dsp_poll(struct file *file, struct poll_table_struct *wait)
787 
{
788 
        struct btaudio *bta = file->private_data;
789 
        unsigned int mask = 0;
790 
 
791 
        poll_wait(file, &bta->readq, wait);
792 
 
793 
        if (0 != bta->read_count)
794 
                mask |= (POLLIN | POLLRDNORM);
795 
 
796 
        return mask;
797 
}
798 
 
799 
static const struct file_operations btaudio_digital_dsp_fops = {
800 
        .owner          = THIS_MODULE,
801 
        .llseek         = no_llseek,
802 
        .open           = btaudio_dsp_open_digital,
803 
        .release        = btaudio_dsp_release,
804 
        .read           = btaudio_dsp_read,
805 
        .write          = btaudio_dsp_write,
806 
        .ioctl          = btaudio_dsp_ioctl,
807 
        .poll           = btaudio_dsp_poll,
808 
};
809 
 
810 
static const struct file_operations btaudio_analog_dsp_fops = {
811 
        .owner          = THIS_MODULE,
812 
        .llseek         = no_llseek,
813 
        .open           = btaudio_dsp_open_analog,
814 
        .release        = btaudio_dsp_release,
815 
        .read           = btaudio_dsp_read,
816 
        .write          = btaudio_dsp_write,
817 
        .ioctl          = btaudio_dsp_ioctl,
818 
        .poll           = btaudio_dsp_poll,
819 
};
820 
 
821 
/* -------------------------------------------------------------- */
822 
 
823 
static char *irq_name[] = { "", "", "", "OFLOW", "", "", "", "", "", "", "",
824 
                            "RISCI", "FBUS", "FTRGT", "FDSR", "PPERR",
825 
                            "RIPERR", "PABORT", "OCERR", "SCERR" };
826 
 
827 
static irqreturn_t btaudio_irq(int irq, void *dev_id)
828 
{
829 
        int count = 0;
830 
        u32 stat,astat;
831 
        struct btaudio *bta = dev_id;
832 
        int handled = 0;
833 
 
834 
        for (;;) {
835 
                count++;
836 
                stat  = btread(REG_INT_STAT);
837 
                astat = stat & btread(REG_INT_MASK);
838 
                if (!astat)
839 
                        return IRQ_RETVAL(handled);
840 
                handled = 1;
841 
                btwrite(astat,REG_INT_STAT);
842 
 
843 
                if (irq_debug) {
844 
                        int i;
845 
                        printk(KERN_DEBUG "btaudio: irq loop=%d risc=%x, bits:",
846 
                               count, stat>>28);
847 
                        for (i = 0; i < (sizeof(irq_name)/sizeof(char*)); i++) {
848 
                                if (stat & (1 << i))
849 
                                        printk(" %s",irq_name[i]);
850 
                                if (astat & (1 << i))
851 
                                        printk("*");
852 
                        }
853 
                        printk("\n");
854 
                }
855 
                if (stat & IRQ_RISCI) {
856 
                        int blocks;
857 
                        blocks = (stat >> 28) - bta->dma_block;
858 
                        if (blocks < 0)
859 
                                blocks += bta->block_count;
860 
                        bta->dma_block = stat >> 28;
861 
                        if (bta->read_count + 2*bta->block_bytes > bta->buf_size) {
862 
                                stop_recording(bta);
863 
                                printk(KERN_INFO "btaudio: buffer overrun\n");
864 
                        }
865 
                        if (blocks > 0) {
866 
                                bta->read_count += blocks * bta->block_bytes;
867 
                                wake_up_interruptible(&bta->readq);
868 
                        }
869 
                }
870 
                if (count > 10) {
871 
                        printk(KERN_WARNING
872 
                               "btaudio: Oops - irq mask cleared\n");
873 
                        btwrite(0, REG_INT_MASK);
874 
                }
875 
        }
876 
        return IRQ_NONE;
877 
}
878 
 
879 
/* -------------------------------------------------------------- */
880 
 
881 
static unsigned int dsp1 = -1;
882 
static unsigned int dsp2 = -1;
883 
static unsigned int mixer = -1;
884 
static int latency = -1;
885 
static int digital = 1;
886 
static int analog = 1;
887 
static int rate;
888 
 
889 
#define BTA_OSPREY200 1
890 
 
891 
static struct cardinfo cards[] = {
892 
        [0] = {
893 
                .name   = "default",
894 
                .rate   = 32000,
895 
        },
896 
        [BTA_OSPREY200] = {
897 
                .name   = "Osprey 200",
898 
                .rate   = 44100,
899 
        },
900 
};
901 
 
902 
static int __devinit btaudio_probe(struct pci_dev *pci_dev,
903 
                                   const struct pci_device_id *pci_id)
904 
{
905 
        struct btaudio *bta;
906 
        struct cardinfo *card = &cards[pci_id->driver_data];
907 
        unsigned char revision,lat;
908 
        int rc = -EBUSY;
909 
 
910 
        if (pci_enable_device(pci_dev))
911 
                return -EIO;
912 
        if (!request_mem_region(pci_resource_start(pci_dev,0),
913 
                                pci_resource_len(pci_dev,0),
914 
                                "btaudio")) {
915 
                return -EBUSY;
916 
        }
917 
 
918 
        bta = kzalloc(sizeof(*bta),GFP_ATOMIC);
919 
        if (!bta) {
920 
                rc = -ENOMEM;
921 
                goto fail0;
922 
        }
923 
 
924 
        bta->pci  = pci_dev;
925 
        bta->irq  = pci_dev->irq;
926 
        bta->mem  = pci_resource_start(pci_dev,0);
927 
        bta->mmio = ioremap(pci_resource_start(pci_dev,0),
928 
                            pci_resource_len(pci_dev,0));
929 
 
930 
        bta->source     = 1;
931 
        bta->bits       = 8;
932 
        bta->channels   = 1;
933 
        if (bta->analog) {
934 
                bta->decimation  = 15;
935 
        } else {
936 
                bta->decimation  = 0;
937 
                bta->sampleshift = 1;
938 
        }
939 
 
940 
        /* sample rate */
941 
        bta->rate = card->rate;
942 
        if (rate)
943 
                bta->rate = rate;
944 
 
945 
        mutex_init(&bta->lock);
946 
        init_waitqueue_head(&bta->readq);
947 
 
948 
        if (-1 != latency) {
949 
                printk(KERN_INFO "btaudio: setting pci latency timer to %d\n",
950 
                       latency);
951 
                pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
952 
        }
953 
        pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
954 
        pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &lat);
955 
        printk(KERN_INFO "btaudio: Bt%x (rev %d) at %02x:%02x.%x, ",
956 
               pci_dev->device,revision,pci_dev->bus->number,
957 
               PCI_SLOT(pci_dev->devfn),PCI_FUNC(pci_dev->devfn));
958 
        printk("irq: %d, latency: %d, mmio: 0x%lx\n",
959 
               bta->irq, lat, bta->mem);
960 
        printk("btaudio: using card config \"%s\"\n", card->name);
961 
 
962 
        /* init hw */
963 
        btwrite(0, REG_GPIO_DMA_CTL);
964 
        btwrite(0, REG_INT_MASK);
965 
        btwrite(~0U, REG_INT_STAT);
966 
        pci_set_master(pci_dev);
967 
 
968 
        if ((rc = request_irq(bta->irq, btaudio_irq, IRQF_SHARED|IRQF_DISABLED,
969 
                              "btaudio",(void *)bta)) < 0) {
970 
                printk(KERN_WARNING
971 
                       "btaudio: can't request irq (rc=%d)\n",rc);
972 
                goto fail1;
973 
        }
974 
 
975 
        /* register devices */
976 
        if (digital) {
977 
                rc = bta->dsp_digital =
978 
                        register_sound_dsp(&btaudio_digital_dsp_fops,dsp1);
979 
                if (rc < 0) {
980 
                        printk(KERN_WARNING
981 
                               "btaudio: can't register digital dsp (rc=%d)\n",rc);
982 
                        goto fail2;
983 
                }
984 
                printk(KERN_INFO "btaudio: registered device dsp%d [digital]\n",
985 
                       bta->dsp_digital >> 4);
986 
        }
987 
        if (analog) {
988 
                rc = bta->dsp_analog =
989 
                        register_sound_dsp(&btaudio_analog_dsp_fops,dsp2);
990 
                if (rc < 0) {
991 
                        printk(KERN_WARNING
992 
                               "btaudio: can't register analog dsp (rc=%d)\n",rc);
993 
                        goto fail3;
994 
                }
995 
                printk(KERN_INFO "btaudio: registered device dsp%d [analog]\n",
996 
                       bta->dsp_analog >> 4);
997 
                rc = bta->mixer_dev = register_sound_mixer(&btaudio_mixer_fops,mixer);
998 
                if (rc < 0) {
999 
                        printk(KERN_WARNING
1000 
                               "btaudio: can't register mixer (rc=%d)\n",rc);
1001 
                        goto fail4;
1002 
                }
1003 
                printk(KERN_INFO "btaudio: registered device mixer%d\n",
1004 
                       bta->mixer_dev >> 4);
1005 
        }
1006 
 
1007 
        /* hook into linked list */
1008 
        bta->next = btaudios;
1009 
        btaudios = bta;
1010 
 
1011 
        pci_set_drvdata(pci_dev,bta);
1012 
        return 0;
1013 
 
1014 
 fail4:
1015 
        unregister_sound_dsp(bta->dsp_analog);
1016 
 fail3:
1017 
        if (digital)
1018 
                unregister_sound_dsp(bta->dsp_digital);
1019 
 fail2:
1020 
        free_irq(bta->irq,bta);
1021 
 fail1:
1022 
        iounmap(bta->mmio);
1023 
        kfree(bta);
1024 
 fail0:
1025 
        release_mem_region(pci_resource_start(pci_dev,0),
1026 
                           pci_resource_len(pci_dev,0));
1027 
        return rc;
1028 
}
1029 
 
1030 
static void __devexit btaudio_remove(struct pci_dev *pci_dev)
1031 
{
1032 
        struct btaudio *bta = pci_get_drvdata(pci_dev);
1033 
        struct btaudio *walk;
1034 
 
1035 
        /* turn off all DMA / IRQs */
1036 
        btand(~15, REG_GPIO_DMA_CTL);
1037 
        btwrite(0, REG_INT_MASK);
1038 
        btwrite(~0U, REG_INT_STAT);
1039 
 
1040 
        /* unregister devices */
1041 
        if (digital) {
1042 
                unregister_sound_dsp(bta->dsp_digital);
1043 
        }
1044 
        if (analog) {
1045 
                unregister_sound_dsp(bta->dsp_analog);
1046 
                unregister_sound_mixer(bta->mixer_dev);
1047 
        }
1048 
 
1049 
        /* free resources */
1050 
        free_buffer(bta);
1051 
        free_irq(bta->irq,bta);
1052 
        release_mem_region(pci_resource_start(pci_dev,0),
1053 
                           pci_resource_len(pci_dev,0));
1054 
        iounmap(bta->mmio);
1055 
 
1056 
        /* remove from linked list */
1057 
        if (bta == btaudios) {
1058 
                btaudios = NULL;
1059 
        } else {
1060 
                for (walk = btaudios; walk->next != bta; walk = walk->next)
1061 
                        ; /* if (NULL == walk->next) BUG(); */
1062 
                walk->next = bta->next;
1063 
        }
1064 
 
1065 
        pci_set_drvdata(pci_dev, NULL);
1066 
        kfree(bta);
1067 
        return;
1068 
}
1069 
 
1070 
/* -------------------------------------------------------------- */
1071 
 
1072 
static struct pci_device_id btaudio_pci_tbl[] = {
1073 
        {
1074 
                .vendor         = PCI_VENDOR_ID_BROOKTREE,
1075 
                .device         = 0x0878,
1076 
                .subvendor      = 0x0070,
1077 
                .subdevice      = 0xff01,
1078 
                .driver_data    = BTA_OSPREY200,
1079 
        },{
1080 
                .vendor         = PCI_VENDOR_ID_BROOKTREE,
1081 
                .device         = 0x0878,
1082 
                .subvendor      = PCI_ANY_ID,
1083 
                .subdevice      = PCI_ANY_ID,
1084 
        },{
1085 
                .vendor         = PCI_VENDOR_ID_BROOKTREE,
1086 
                .device         = 0x0878,
1087 
                .subvendor      = PCI_ANY_ID,
1088 
                .subdevice      = PCI_ANY_ID,
1089 
        },{
1090 
                /* --- end of list --- */
1091 
        }
1092 
};
1093 
 
1094 
static struct pci_driver btaudio_pci_driver = {
1095 
        .name           = "btaudio",
1096 
        .id_table       = btaudio_pci_tbl,
1097 
        .probe          = btaudio_probe,
1098 
        .remove         =  __devexit_p(btaudio_remove),
1099 
};
1100 
 
1101 
static int btaudio_init_module(void)
1102 
{
1103 
        printk(KERN_INFO "btaudio: driver version 0.7 loaded [%s%s%s]\n",
1104 
               digital ? "digital" : "",
1105 
               analog && digital ? "+" : "",
1106 
               analog ? "analog" : "");
1107 
        return pci_register_driver(&btaudio_pci_driver);
1108 
}
1109 
 
1110 
static void btaudio_cleanup_module(void)
1111 
{
1112 
        pci_unregister_driver(&btaudio_pci_driver);
1113 
        return;
1114 
}
1115 
 
1116 
module_init(btaudio_init_module);
1117 
module_exit(btaudio_cleanup_module);
1118 
 
1119 
module_param(dsp1, int, S_IRUGO);
1120 
module_param(dsp2, int, S_IRUGO);
1121 
module_param(mixer, int, S_IRUGO);
1122 
module_param(debug, int, S_IRUGO | S_IWUSR);
1123 
module_param(irq_debug, int, S_IRUGO | S_IWUSR);
1124 
module_param(digital, int, S_IRUGO);
1125 
module_param(analog, int, S_IRUGO);
1126 
module_param(rate, int, S_IRUGO);
1127 
module_param(latency, int, S_IRUGO);
1128 
MODULE_PARM_DESC(latency,"pci latency timer");
1129 
 
1130 
MODULE_DEVICE_TABLE(pci, btaudio_pci_tbl);
1131 
MODULE_DESCRIPTION("bt878 audio dma driver");
1132 
MODULE_AUTHOR("Gerd Knorr");
1133 
MODULE_LICENSE("GPL");
1134 
 
1135 
/*
1136 
 * Local variables:
1137 
 * c-basic-offset: 8
1138 
 * End:
1139 
 */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.