git.oblomov.eu Git - linux-2.6/blob - sound/oss/btaudio.c

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