sound/oss/waveartist.c

   1 /*
   2  * linux/sound/oss/waveartist.c
   3  *
   4  * The low level driver for the RWA010 Rockwell Wave Artist
   5  * codec chip used in the Rebel.com NetWinder.
   6  *
   7  * Cleaned up and integrated into 2.1 by Russell King (rmk@arm.linux.org.uk)
   8  * and Pat Beirne (patb@corel.ca)
   9  *
  10  *
  11  * Copyright (C) by Rebel.com 1998-1999
  12  *
  13  * RWA010 specs received under NDA from Rockwell
  14  *
  15  * Copyright (C) by Hannu Savolainen 1993-1997
  16  *
  17  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  18  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  19  * for more info.
  20  *
  21  * Changes:
  22  * 11-10-2000   Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
  23  *              Added __init to waveartist_init()
  24  */
  25
  26 /* Debugging */
  27 #define DEBUG_CMD       1
  28 #define DEBUG_OUT       2
  29 #define DEBUG_IN        4
  30 #define DEBUG_INTR      8
  31 #define DEBUG_MIXER     16
  32 #define DEBUG_TRIGGER   32
  33
  34 #define debug_flg (0)
  35
  36 #include <linux/module.h>
  37 #include <linux/init.h>
  38 #include <linux/slab.h>
  39 #include <linux/sched.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/delay.h>
  42 #include <linux/spinlock.h>
  43 #include <linux/bitops.h>
  44
  45 #include <asm/system.h>
  46
  47 #include "sound_config.h"
  48 #include "waveartist.h"
  49
  50 #ifdef CONFIG_ARM
  51 #include <mach/hardware.h>
  52 #include <asm/mach-types.h>
  53 #endif
  54
  55 #ifndef NO_DMA
  56 #define NO_DMA  255
  57 #endif
  58
  59 #define SUPPORTED_MIXER_DEVICES         (SOUND_MASK_SYNTH      |\
  60                                          SOUND_MASK_PCM        |\
  61                                          SOUND_MASK_LINE       |\
  62                                          SOUND_MASK_MIC        |\
  63                                          SOUND_MASK_LINE1      |\
  64                                          SOUND_MASK_RECLEV     |\
  65                                          SOUND_MASK_VOLUME     |\
  66                                          SOUND_MASK_IMIX)
  67
  68 static unsigned short levels[SOUND_MIXER_NRDEVICES] = {
  69         0x5555,         /* Master Volume         */
  70         0x0000,         /* Bass                  */
  71         0x0000,         /* Treble                */
  72         0x2323,         /* Synth (FM)            */
  73         0x4b4b,         /* PCM                   */
  74         0x6464,         /* PC Speaker            */
  75         0x0000,         /* Ext Line              */
  76         0x0000,         /* Mic                   */
  77         0x0000,         /* CD                    */
  78         0x6464,         /* Recording monitor     */
  79         0x0000,         /* SB PCM (ALT PCM)      */
  80         0x0000,         /* Recording level       */
  81         0x6464,         /* Input gain            */
  82         0x6464,         /* Output gain           */
  83         0x0000,         /* Line1 (Aux1)          */
  84         0x0000,         /* Line2 (Aux2)          */
  85         0x0000,         /* Line3 (Aux3)          */
  86         0x0000,         /* Digital1              */
  87         0x0000,         /* Digital2              */
  88         0x0000,         /* Digital3              */
  89         0x0000,         /* Phone In              */
  90         0x6464,         /* Phone Out             */
  91         0x0000,         /* Video                 */
  92         0x0000,         /* Radio                 */
  93         0x0000          /* Monitor               */
  94 };
  95
  96 typedef struct {
  97         struct address_info  hw;        /* hardware */
  98         char            *chip_name;
  99
 100         int             xfer_count;
 101         int             audio_mode;
 102         int             open_mode;
 103         int             audio_flags;
 104         int             record_dev;
 105         int             playback_dev;
 106         int             dev_no;
 107
 108         /* Mixer parameters */
 109         const struct waveartist_mixer_info *mix;
 110
 111         unsigned short  *levels;           /* cache of volume settings   */
 112         int             recmask;           /* currently enabled recording device! */
 113
 114 #ifdef CONFIG_ARCH_NETWINDER
 115         signed int      slider_vol;        /* hardware slider volume     */
 116         unsigned int    handset_detect  :1;
 117         unsigned int    telephone_detect:1;
 118         unsigned int    no_autoselect   :1;/* handset/telephone autoselects a path */
 119         unsigned int    spkr_mute_state :1;/* set by ioctl or autoselect */
 120         unsigned int    line_mute_state :1;/* set by ioctl or autoselect */
 121         unsigned int    use_slider      :1;/* use slider setting for o/p vol */
 122 #endif
 123 } wavnc_info;
 124
 125 /*
 126  * This is the implementation specific mixer information.
 127  */
 128 struct waveartist_mixer_info {
 129         unsigned int    supported_devs;    /* Supported devices */
 130         unsigned int    recording_devs;    /* Recordable devies */
 131         unsigned int    stereo_devs;       /* Stereo devices    */
 132
 133         unsigned int    (*select_input)(wavnc_info *, unsigned int,
 134                                         unsigned char *, unsigned char *);
 135         int             (*decode_mixer)(wavnc_info *, int,
 136                                         unsigned char, unsigned char);
 137         int             (*get_mixer)(wavnc_info *, int);
 138 };
 139
 140 typedef struct wavnc_port_info {
 141         int             open_mode;
 142         int             speed;
 143         int             channels;
 144         int             audio_format;
 145 } wavnc_port_info;
 146
 147 static int              nr_waveartist_devs;
 148 static wavnc_info       adev_info[MAX_AUDIO_DEV];
 149 static DEFINE_SPINLOCK(waveartist_lock);
 150
 151 #ifndef CONFIG_ARCH_NETWINDER
 152 #define machine_is_netwinder() 0
 153 #else
 154 static struct timer_list vnc_timer;
 155 static void vnc_configure_mixer(wavnc_info *devc, unsigned int input_mask);
 156 static int vnc_private_ioctl(int dev, unsigned int cmd, int __user *arg);
 157 static void vnc_slider_tick(unsigned long data);
 158 #endif
 159
 160 static inline void
 161 waveartist_set_ctlr(struct address_info *hw, unsigned char clear, unsigned char set)
 162 {
 163         unsigned int ctlr_port = hw->io_base + CTLR;
 164
 165         clear = ~clear & inb(ctlr_port);
 166
 167         outb(clear | set, ctlr_port);
 168 }
 169
 170 /* Toggle IRQ acknowledge line
 171  */
 172 static inline void
 173 waveartist_iack(wavnc_info *devc)
 174 {
 175         unsigned int ctlr_port = devc->hw.io_base + CTLR;
 176         int old_ctlr;
 177
 178         old_ctlr = inb(ctlr_port) & ~IRQ_ACK;
 179
 180         outb(old_ctlr | IRQ_ACK, ctlr_port);
 181         outb(old_ctlr, ctlr_port);
 182 }
 183
 184 static inline int
 185 waveartist_sleep(int timeout_ms)
 186 {
 187         unsigned int timeout = msecs_to_jiffies(timeout_ms*100);
 188         return schedule_timeout_interruptible(timeout);
 189 }
 190
 191 static int
 192 waveartist_reset(wavnc_info *devc)
 193 {
 194         struct address_info *hw = &devc->hw;
 195         unsigned int timeout, res = -1;
 196
 197         waveartist_set_ctlr(hw, -1, RESET);
 198         waveartist_sleep(2);
 199         waveartist_set_ctlr(hw, RESET, 0);
 200
 201         timeout = 500;
 202         do {
 203                 mdelay(2);
 204
 205                 if (inb(hw->io_base + STATR) & CMD_RF) {
 206                         res = inw(hw->io_base + CMDR);
 207                         if (res == 0x55aa)
 208                                 break;
 209                 }
 210         } while (--timeout);
 211
 212         if (timeout == 0) {
 213                 printk(KERN_WARNING "WaveArtist: reset timeout ");
 214                 if (res != (unsigned int)-1)
 215                         printk("(res=%04X)", res);
 216                 printk("\n");
 217                 return 1;
 218         }
 219         return 0;
 220 }
 221
 222 /* Helper function to send and receive words
 223  * from WaveArtist.  It handles all the handshaking
 224  * and can send or receive multiple words.
 225  */
 226 static int
 227 waveartist_cmd(wavnc_info *devc,
 228                 int nr_cmd, unsigned int *cmd,
 229                 int nr_resp, unsigned int *resp)
 230 {
 231         unsigned int io_base = devc->hw.io_base;
 232         unsigned int timed_out = 0;
 233         unsigned int i;
 234
 235         if (debug_flg & DEBUG_CMD) {
 236                 printk("waveartist_cmd: cmd=");
 237
 238                 for (i = 0; i < nr_cmd; i++)
 239                         printk("%04X ", cmd[i]);
 240
 241                 printk("\n");
 242         }
 243
 244         if (inb(io_base + STATR) & CMD_RF) {
 245                 int old_data;
 246
 247                 /* flush the port
 248                  */
 249
 250                 old_data = inw(io_base + CMDR);
 251
 252                 if (debug_flg & DEBUG_CMD)
 253                         printk("flushed %04X...", old_data);
 254
 255                 udelay(10);
 256         }
 257
 258         for (i = 0; !timed_out && i < nr_cmd; i++) {
 259                 int count;
 260
 261                 for (count = 5000; count; count--)
 262                         if (inb(io_base + STATR) & CMD_WE)
 263                                 break;
 264
 265                 if (!count)
 266                         timed_out = 1;
 267                 else
 268                         outw(cmd[i], io_base + CMDR);
 269         }
 270
 271         for (i = 0; !timed_out && i < nr_resp; i++) {
 272                 int count;
 273
 274                 for (count = 5000; count; count--)
 275                         if (inb(io_base + STATR) & CMD_RF)
 276                                 break;
 277
 278                 if (!count)
 279                         timed_out = 1;
 280                 else
 281                         resp[i] = inw(io_base + CMDR);
 282         }
 283
 284         if (debug_flg & DEBUG_CMD) {
 285                 if (!timed_out) {
 286                         printk("waveartist_cmd: resp=");
 287
 288                         for (i = 0; i < nr_resp; i++)
 289                                 printk("%04X ", resp[i]);
 290
 291                         printk("\n");
 292                 } else
 293                         printk("waveartist_cmd: timed out\n");
 294         }
 295
 296         return timed_out ? 1 : 0;
 297 }
 298
 299 /*
 300  * Send one command word
 301  */
 302 static inline int
 303 waveartist_cmd1(wavnc_info *devc, unsigned int cmd)
 304 {
 305         return waveartist_cmd(devc, 1, &cmd, 0, NULL);
 306 }
 307
 308 /*
 309  * Send one command, receive one word
 310  */
 311 static inline unsigned int
 312 waveartist_cmd1_r(wavnc_info *devc, unsigned int cmd)
 313 {
 314         unsigned int ret;
 315
 316         waveartist_cmd(devc, 1, &cmd, 1, &ret);
 317
 318         return ret;
 319 }
 320
 321 /*
 322  * Send a double command, receive one
 323  * word (and throw it away)
 324  */
 325 static inline int
 326 waveartist_cmd2(wavnc_info *devc, unsigned int cmd, unsigned int arg)
 327 {
 328         unsigned int vals[2];
 329
 330         vals[0] = cmd;
 331         vals[1] = arg;
 332
 333         return waveartist_cmd(devc, 2, vals, 1, vals);
 334 }
 335
 336 /*
 337  * Send a triple command
 338  */
 339 static inline int
 340 waveartist_cmd3(wavnc_info *devc, unsigned int cmd,
 341                 unsigned int arg1, unsigned int arg2)
 342 {
 343         unsigned int vals[3];
 344
 345         vals[0] = cmd;
 346         vals[1] = arg1;
 347         vals[2] = arg2;
 348
 349         return waveartist_cmd(devc, 3, vals, 0, NULL);
 350 }
 351
 352 static int
 353 waveartist_getrev(wavnc_info *devc, char *rev)
 354 {
 355         unsigned int temp[2];
 356         unsigned int cmd = WACMD_GETREV;
 357
 358         waveartist_cmd(devc, 1, &cmd, 2, temp);
 359
 360         rev[0] = temp[0] >> 8;
 361         rev[1] = temp[0] & 255;
 362         rev[2] = '\0';
 363
 364         return temp[0];
 365 }
 366
 367 static void waveartist_halt_output(int dev);
 368 static void waveartist_halt_input(int dev);
 369 static void waveartist_halt(int dev);
 370 static void waveartist_trigger(int dev, int state);
 371
 372 static int
 373 waveartist_open(int dev, int mode)
 374 {
 375         wavnc_info      *devc;
 376         wavnc_port_info *portc;
 377         unsigned long   flags;
 378
 379         if (dev < 0 || dev >= num_audiodevs)
 380                 return -ENXIO;
 381
 382         devc  = (wavnc_info *) audio_devs[dev]->devc;
 383         portc = (wavnc_port_info *) audio_devs[dev]->portc;
 384
 385         spin_lock_irqsave(&waveartist_lock, flags);
 386         if (portc->open_mode || (devc->open_mode & mode)) {
 387                 spin_unlock_irqrestore(&waveartist_lock, flags);
 388                 return -EBUSY;
 389         }
 390
 391         devc->audio_mode  = 0;
 392         devc->open_mode  |= mode;
 393         portc->open_mode  = mode;
 394         waveartist_trigger(dev, 0);
 395
 396         if (mode & OPEN_READ)
 397                 devc->record_dev = dev;
 398         if (mode & OPEN_WRITE)
 399                 devc->playback_dev = dev;
 400         spin_unlock_irqrestore(&waveartist_lock, flags);
 401
 402         return 0;
 403 }
 404
 405 static void
 406 waveartist_close(int dev)
 407 {
 408         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 409         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 410         unsigned long   flags;
 411
 412         spin_lock_irqsave(&waveartist_lock, flags);
 413
 414         waveartist_halt(dev);
 415
 416         devc->audio_mode = 0;
 417         devc->open_mode &= ~portc->open_mode;
 418         portc->open_mode = 0;
 419
 420         spin_unlock_irqrestore(&waveartist_lock, flags);
 421 }
 422
 423 static void
 424 waveartist_output_block(int dev, unsigned long buf, int __count, int intrflag)
 425 {
 426         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 427         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 428         unsigned long   flags;
 429         unsigned int    count = __count;
 430
 431         if (debug_flg & DEBUG_OUT)
 432                 printk("waveartist: output block, buf=0x%lx, count=0x%x...\n",
 433                         buf, count);
 434         /*
 435          * 16 bit data
 436          */
 437         if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE))
 438                 count >>= 1;
 439
 440         if (portc->channels > 1)
 441                 count >>= 1;
 442
 443         count -= 1;
 444
 445         if (devc->audio_mode & PCM_ENABLE_OUTPUT &&
 446             audio_devs[dev]->flags & DMA_AUTOMODE &&
 447             intrflag &&
 448             count == devc->xfer_count) {
 449                 devc->audio_mode |= PCM_ENABLE_OUTPUT;
 450                 return; /*
 451                          * Auto DMA mode on. No need to react
 452                          */
 453         }
 454
 455         spin_lock_irqsave(&waveartist_lock, flags);
 456
 457         /*
 458          * set sample count
 459          */
 460         waveartist_cmd2(devc, WACMD_OUTPUTSIZE, count);
 461
 462         devc->xfer_count = count;
 463         devc->audio_mode |= PCM_ENABLE_OUTPUT;
 464
 465         spin_unlock_irqrestore(&waveartist_lock, flags);
 466 }
 467
 468 static void
 469 waveartist_start_input(int dev, unsigned long buf, int __count, int intrflag)
 470 {
 471         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 472         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 473         unsigned long   flags;
 474         unsigned int    count = __count;
 475
 476         if (debug_flg & DEBUG_IN)
 477                 printk("waveartist: start input, buf=0x%lx, count=0x%x...\n",
 478                         buf, count);
 479
 480         if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE))  /* 16 bit data */
 481                 count >>= 1;
 482
 483         if (portc->channels > 1)
 484                 count >>= 1;
 485
 486         count -= 1;
 487
 488         if (devc->audio_mode & PCM_ENABLE_INPUT &&
 489             audio_devs[dev]->flags & DMA_AUTOMODE &&
 490             intrflag &&
 491             count == devc->xfer_count) {
 492                 devc->audio_mode |= PCM_ENABLE_INPUT;
 493                 return; /*
 494                          * Auto DMA mode on. No need to react
 495                          */
 496         }
 497
 498         spin_lock_irqsave(&waveartist_lock, flags);
 499
 500         /*
 501          * set sample count
 502          */
 503         waveartist_cmd2(devc, WACMD_INPUTSIZE, count);
 504
 505         devc->xfer_count = count;
 506         devc->audio_mode |= PCM_ENABLE_INPUT;
 507
 508         spin_unlock_irqrestore(&waveartist_lock, flags);
 509 }
 510
 511 static int
 512 waveartist_ioctl(int dev, unsigned int cmd, void __user * arg)
 513 {
 514         return -EINVAL;
 515 }
 516
 517 static unsigned int
 518 waveartist_get_speed(wavnc_port_info *portc)
 519 {
 520         unsigned int speed;
 521
 522         /*
 523          * program the speed, channels, bits
 524          */
 525         if (portc->speed == 8000)
 526                 speed = 0x2E71;
 527         else if (portc->speed == 11025)
 528                 speed = 0x4000;
 529         else if (portc->speed == 22050)
 530                 speed = 0x8000;
 531         else if (portc->speed == 44100)
 532                 speed = 0x0;
 533         else {
 534                 /*
 535                  * non-standard - just calculate
 536                  */
 537                 speed = portc->speed << 16;
 538
 539                 speed = (speed / 44100) & 65535;
 540         }
 541
 542         return speed;
 543 }
 544
 545 static unsigned int
 546 waveartist_get_bits(wavnc_port_info *portc)
 547 {
 548         unsigned int bits;
 549
 550         if (portc->audio_format == AFMT_S16_LE)
 551                 bits = 1;
 552         else if (portc->audio_format == AFMT_S8)
 553                 bits = 0;
 554         else
 555                 bits = 2;       //default AFMT_U8
 556
 557         return bits;
 558 }
 559
 560 static int
 561 waveartist_prepare_for_input(int dev, int bsize, int bcount)
 562 {
 563         unsigned long   flags;
 564         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 565         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 566         unsigned int    speed, bits;
 567
 568         if (devc->audio_mode)
 569                 return 0;
 570
 571         speed = waveartist_get_speed(portc);
 572         bits  = waveartist_get_bits(portc);
 573
 574         spin_lock_irqsave(&waveartist_lock, flags);
 575
 576         if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
 577                 printk(KERN_WARNING "waveartist: error setting the "
 578                        "record format to %d\n", portc->audio_format);
 579
 580         if (waveartist_cmd2(devc, WACMD_INPUTCHANNELS, portc->channels))
 581                 printk(KERN_WARNING "waveartist: error setting record "
 582                        "to %d channels\n", portc->channels);
 583
 584         /*
 585          * write cmd SetSampleSpeedTimeConstant
 586          */
 587         if (waveartist_cmd2(devc, WACMD_INPUTSPEED, speed))
 588                 printk(KERN_WARNING "waveartist: error setting the record "
 589                        "speed to %dHz.\n", portc->speed);
 590
 591         if (waveartist_cmd2(devc, WACMD_INPUTDMA, 1))
 592                 printk(KERN_WARNING "waveartist: error setting the record "
 593                        "data path to 0x%X\n", 1);
 594
 595         if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
 596                 printk(KERN_WARNING "waveartist: error setting the record "
 597                        "format to %d\n", portc->audio_format);
 598
 599         devc->xfer_count = 0;
 600         spin_unlock_irqrestore(&waveartist_lock, flags);
 601         waveartist_halt_input(dev);
 602
 603         if (debug_flg & DEBUG_INTR) {
 604                 printk("WA CTLR reg: 0x%02X.\n",
 605                        inb(devc->hw.io_base + CTLR));
 606                 printk("WA STAT reg: 0x%02X.\n",
 607                        inb(devc->hw.io_base + STATR));
 608                 printk("WA IRQS reg: 0x%02X.\n",
 609                        inb(devc->hw.io_base + IRQSTAT));
 610         }
 611
 612         return 0;
 613 }
 614
 615 static int
 616 waveartist_prepare_for_output(int dev, int bsize, int bcount)
 617 {
 618         unsigned long   flags;
 619         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 620         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 621         unsigned int    speed, bits;
 622
 623         /*
 624          * program the speed, channels, bits
 625          */
 626         speed = waveartist_get_speed(portc);
 627         bits  = waveartist_get_bits(portc);
 628
 629         spin_lock_irqsave(&waveartist_lock, flags);
 630
 631         if (waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed) &&
 632             waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed))
 633                 printk(KERN_WARNING "waveartist: error setting the playback "
 634                        "speed to %dHz.\n", portc->speed);
 635
 636         if (waveartist_cmd2(devc, WACMD_OUTPUTCHANNELS, portc->channels))
 637                 printk(KERN_WARNING "waveartist: error setting the playback "
 638                        "to %d channels\n", portc->channels);
 639
 640         if (waveartist_cmd2(devc, WACMD_OUTPUTDMA, 0))
 641                 printk(KERN_WARNING "waveartist: error setting the playback "
 642                        "data path to 0x%X\n", 0);
 643
 644         if (waveartist_cmd2(devc, WACMD_OUTPUTFORMAT, bits))
 645                 printk(KERN_WARNING "waveartist: error setting the playback "
 646                        "format to %d\n", portc->audio_format);
 647
 648         devc->xfer_count = 0;
 649         spin_unlock_irqrestore(&waveartist_lock, flags);
 650         waveartist_halt_output(dev);
 651
 652         if (debug_flg & DEBUG_INTR) {
 653                 printk("WA CTLR reg: 0x%02X.\n",inb(devc->hw.io_base + CTLR));
 654                 printk("WA STAT reg: 0x%02X.\n",inb(devc->hw.io_base + STATR));
 655                 printk("WA IRQS reg: 0x%02X.\n",inb(devc->hw.io_base + IRQSTAT));
 656         }
 657
 658         return 0;
 659 }
 660
 661 static void
 662 waveartist_halt(int dev)
 663 {
 664         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 665         wavnc_info      *devc;
 666
 667         if (portc->open_mode & OPEN_WRITE)
 668                 waveartist_halt_output(dev);
 669
 670         if (portc->open_mode & OPEN_READ)
 671                 waveartist_halt_input(dev);
 672
 673         devc = (wavnc_info *) audio_devs[dev]->devc;
 674         devc->audio_mode = 0;
 675 }
 676
 677 static void
 678 waveartist_halt_input(int dev)
 679 {
 680         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 681         unsigned long   flags;
 682
 683         spin_lock_irqsave(&waveartist_lock, flags);
 684
 685         /*
 686          * Stop capture
 687          */
 688         waveartist_cmd1(devc, WACMD_INPUTSTOP);
 689
 690         devc->audio_mode &= ~PCM_ENABLE_INPUT;
 691
 692         /*
 693          * Clear interrupt by toggling
 694          * the IRQ_ACK bit in CTRL
 695          */
 696         if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
 697                 waveartist_iack(devc);
 698
 699 //      devc->audio_mode &= ~PCM_ENABLE_INPUT;
 700
 701         spin_unlock_irqrestore(&waveartist_lock, flags);
 702 }
 703
 704 static void
 705 waveartist_halt_output(int dev)
 706 {
 707         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 708         unsigned long   flags;
 709
 710         spin_lock_irqsave(&waveartist_lock, flags);
 711
 712         waveartist_cmd1(devc, WACMD_OUTPUTSTOP);
 713
 714         devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
 715
 716         /*
 717          * Clear interrupt by toggling
 718          * the IRQ_ACK bit in CTRL
 719          */
 720         if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
 721                 waveartist_iack(devc);
 722
 723 //      devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
 724
 725         spin_unlock_irqrestore(&waveartist_lock, flags);
 726 }
 727
 728 static void
 729 waveartist_trigger(int dev, int state)
 730 {
 731         wavnc_info      *devc = (wavnc_info *) audio_devs[dev]->devc;
 732         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 733         unsigned long   flags;
 734
 735         if (debug_flg & DEBUG_TRIGGER) {
 736                 printk("wavnc: audio trigger ");
 737                 if (state & PCM_ENABLE_INPUT)
 738                         printk("in ");
 739                 if (state & PCM_ENABLE_OUTPUT)
 740                         printk("out");
 741                 printk("\n");
 742         }
 743
 744         spin_lock_irqsave(&waveartist_lock, flags);
 745
 746         state &= devc->audio_mode;
 747
 748         if (portc->open_mode & OPEN_READ &&
 749             state & PCM_ENABLE_INPUT)
 750                 /*
 751                  * enable ADC Data Transfer to PC
 752                  */
 753                 waveartist_cmd1(devc, WACMD_INPUTSTART);
 754
 755         if (portc->open_mode & OPEN_WRITE &&
 756             state & PCM_ENABLE_OUTPUT)
 757                 /*
 758                  * enable DAC data transfer from PC
 759                  */
 760                 waveartist_cmd1(devc, WACMD_OUTPUTSTART);
 761
 762         spin_unlock_irqrestore(&waveartist_lock, flags);
 763 }
 764
 765 static int
 766 waveartist_set_speed(int dev, int arg)
 767 {
 768         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 769
 770         if (arg <= 0)
 771                 return portc->speed;
 772
 773         if (arg < 5000)
 774                 arg = 5000;
 775         if (arg > 44100)
 776                 arg = 44100;
 777
 778         portc->speed = arg;
 779         return portc->speed;
 780
 781 }
 782
 783 static short
 784 waveartist_set_channels(int dev, short arg)
 785 {
 786         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 787
 788         if (arg != 1 && arg != 2)
 789                 return portc->channels;
 790
 791         portc->channels = arg;
 792         return arg;
 793 }
 794
 795 static unsigned int
 796 waveartist_set_bits(int dev, unsigned int arg)
 797 {
 798         wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
 799
 800         if (arg == 0)
 801                 return portc->audio_format;
 802
 803         if ((arg != AFMT_U8) && (arg != AFMT_S16_LE) && (arg != AFMT_S8))
 804                 arg = AFMT_U8;
 805
 806         portc->audio_format = arg;
 807
 808         return arg;
 809 }
 810
 811 static struct audio_driver waveartist_audio_driver = {
 812         .owner                  = THIS_MODULE,
 813         .open                   = waveartist_open,
 814         .close                  = waveartist_close,
 815         .output_block           = waveartist_output_block,
 816         .start_input            = waveartist_start_input,
 817         .ioctl                  = waveartist_ioctl,
 818         .prepare_for_input      = waveartist_prepare_for_input,
 819         .prepare_for_output     = waveartist_prepare_for_output,
 820         .halt_io                = waveartist_halt,
 821         .halt_input             = waveartist_halt_input,
 822         .halt_output            = waveartist_halt_output,
 823         .trigger                = waveartist_trigger,
 824         .set_speed              = waveartist_set_speed,
 825         .set_bits               = waveartist_set_bits,
 826         .set_channels           = waveartist_set_channels
 827 };
 828
 829
 830 static irqreturn_t
 831 waveartist_intr(int irq, void *dev_id)
 832 {
 833         wavnc_info *devc = dev_id;
 834         int        irqstatus, status;
 835
 836         spin_lock(&waveartist_lock);
 837         irqstatus = inb(devc->hw.io_base + IRQSTAT);
 838         status    = inb(devc->hw.io_base + STATR);
 839
 840         if (debug_flg & DEBUG_INTR)
 841                 printk("waveartist_intr: stat=%02x, irqstat=%02x\n",
 842                        status, irqstatus);
 843
 844         if (status & IRQ_REQ)   /* Clear interrupt */
 845                 waveartist_iack(devc);
 846         else
 847                 printk(KERN_WARNING "waveartist: unexpected interrupt\n");
 848
 849         if (irqstatus & 0x01) {
 850                 int temp = 1;
 851
 852                 /* PCM buffer done
 853                  */
 854                 if ((status & DMA0) && (devc->audio_mode & PCM_ENABLE_OUTPUT)) {
 855                         DMAbuf_outputintr(devc->playback_dev, 1);
 856                         temp = 0;
 857                 }
 858                 if ((status & DMA1) && (devc->audio_mode & PCM_ENABLE_INPUT)) {
 859                         DMAbuf_inputintr(devc->record_dev);
 860                         temp = 0;
 861                 }
 862                 if (temp)       //default:
 863                         printk(KERN_WARNING "waveartist: Unknown interrupt\n");
 864         }
 865         if (irqstatus & 0x2)
 866                 // We do not use SB mode natively...
 867                 printk(KERN_WARNING "waveartist: Unexpected SB interrupt...\n");
 868         spin_unlock(&waveartist_lock);
 869         return IRQ_HANDLED;
 870 }
 871
 872 /* -------------------------------------------------------------------------
 873  * Mixer stuff
 874  */
 875 struct mix_ent {
 876         unsigned char   reg_l;
 877         unsigned char   reg_r;
 878         unsigned char   shift;
 879         unsigned char   max;
 880 };
 881
 882 static const struct mix_ent mix_devs[SOUND_MIXER_NRDEVICES] = {
 883         { 2, 6, 1,  7 }, /* SOUND_MIXER_VOLUME   */
 884         { 0, 0, 0,  0 }, /* SOUND_MIXER_BASS     */
 885         { 0, 0, 0,  0 }, /* SOUND_MIXER_TREBLE   */
 886         { 0, 0, 0,  0 }, /* SOUND_MIXER_SYNTH    */
 887         { 0, 0, 0,  0 }, /* SOUND_MIXER_PCM      */
 888         { 0, 0, 0,  0 }, /* SOUND_MIXER_SPEAKER  */
 889         { 0, 4, 6, 31 }, /* SOUND_MIXER_LINE     */
 890         { 2, 6, 4,  3 }, /* SOUND_MIXER_MIC      */
 891         { 0, 0, 0,  0 }, /* SOUND_MIXER_CD       */
 892         { 0, 0, 0,  0 }, /* SOUND_MIXER_IMIX     */
 893         { 0, 0, 0,  0 }, /* SOUND_MIXER_ALTPCM   */
 894 #if 0
 895         { 3, 7, 0, 10 }, /* SOUND_MIXER_RECLEV   */
 896         { 0, 0, 0,  0 }, /* SOUND_MIXER_IGAIN    */
 897 #else
 898         { 0, 0, 0,  0 }, /* SOUND_MIXER_RECLEV   */
 899         { 3, 7, 0,  7 }, /* SOUND_MIXER_IGAIN    */
 900 #endif
 901         { 0, 0, 0,  0 }, /* SOUND_MIXER_OGAIN    */
 902         { 0, 4, 1, 31 }, /* SOUND_MIXER_LINE1    */
 903         { 1, 5, 6, 31 }, /* SOUND_MIXER_LINE2    */
 904         { 0, 0, 0,  0 }, /* SOUND_MIXER_LINE3    */
 905         { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL1 */
 906         { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL2 */
 907         { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL3 */
 908         { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEIN  */
 909         { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEOUT */
 910         { 0, 0, 0,  0 }, /* SOUND_MIXER_VIDEO    */
 911         { 0, 0, 0,  0 }, /* SOUND_MIXER_RADIO    */
 912         { 0, 0, 0,  0 }  /* SOUND_MIXER_MONITOR  */
 913 };
 914
 915 static void
 916 waveartist_mixer_update(wavnc_info *devc, int whichDev)
 917 {
 918         unsigned int lev_left, lev_right;
 919
 920         lev_left  = devc->levels[whichDev] & 0xff;
 921         lev_right = devc->levels[whichDev] >> 8;
 922
 923         if (lev_left > 100)
 924                 lev_left = 100;
 925         if (lev_right > 100)
 926                 lev_right = 100;
 927
 928 #define SCALE(lev,max)  ((lev) * (max) / 100)
 929
 930         if (machine_is_netwinder() && whichDev == SOUND_MIXER_PHONEOUT)
 931                 whichDev = SOUND_MIXER_VOLUME;
 932
 933         if (mix_devs[whichDev].reg_l || mix_devs[whichDev].reg_r) {
 934                 const struct mix_ent *mix = mix_devs + whichDev;
 935                 unsigned int mask, left, right;
 936
 937                 mask = mix->max << mix->shift;
 938                 lev_left  = SCALE(lev_left,  mix->max) << mix->shift;
 939                 lev_right = SCALE(lev_right, mix->max) << mix->shift;
 940
 941                 /* read left setting */
 942                 left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
 943                                                mix->reg_l << 8);
 944
 945                 /* read right setting */
 946                 right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
 947                                                 mix->reg_r << 8);
 948
 949                 left  = (left  & ~mask) | (lev_left  & mask);
 950                 right = (right & ~mask) | (lev_right & mask);
 951
 952                 /* write left,right back */
 953                 waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
 954         } else {
 955                 switch(whichDev) {
 956                 case SOUND_MIXER_PCM:
 957                         waveartist_cmd3(devc, WACMD_SET_LEVEL,
 958                                         SCALE(lev_left,  32767),
 959                                         SCALE(lev_right, 32767));
 960                         break;
 961
 962                 case SOUND_MIXER_SYNTH:
 963                         waveartist_cmd3(devc, 0x0100 | WACMD_SET_LEVEL,
 964                                         SCALE(lev_left,  32767),
 965                                         SCALE(lev_right, 32767));
 966                         break;
 967                 }
 968         }
 969 }
 970
 971 /*
 972  * Set the ADC MUX to the specified values.  We do NOT do any
 973  * checking of the values passed, since we assume that the
 974  * relevant *_select_input function has done that for us.
 975  */
 976 static void
 977 waveartist_set_adc_mux(wavnc_info *devc, char left_dev, char right_dev)
 978 {
 979         unsigned int reg_08, reg_09;
 980
 981         reg_08 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0800);
 982         reg_09 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0900);
 983
 984         reg_08 = (reg_08 & ~0x3f) | right_dev << 3 | left_dev;
 985
 986         waveartist_cmd3(devc, WACMD_SET_MIXER, reg_08, reg_09);
 987 }
 988
 989 /*
 990  * Decode a recording mask into a mixer selection as follows:
 991  *
 992  *     OSS Source       WA Source       Actual source
 993  *  SOUND_MASK_IMIX     Mixer           Mixer output (same as AD1848)
 994  *  SOUND_MASK_LINE     Line            Line in
 995  *  SOUND_MASK_LINE1    Aux 1           Aux 1 in
 996  *  SOUND_MASK_LINE2    Aux 2           Aux 2 in
 997  *  SOUND_MASK_MIC      Mic             Microphone
 998  */
 999 static unsigned int
1000 waveartist_select_input(wavnc_info *devc, unsigned int recmask,
1001                         unsigned char *dev_l, unsigned char *dev_r)
1002 {
1003         unsigned int recdev = ADC_MUX_NONE;
1004
1005         if (recmask & SOUND_MASK_IMIX) {
1006                 recmask = SOUND_MASK_IMIX;
1007                 recdev = ADC_MUX_MIXER;
1008         } else if (recmask & SOUND_MASK_LINE2) {
1009                 recmask = SOUND_MASK_LINE2;
1010                 recdev = ADC_MUX_AUX2;
1011         } else if (recmask & SOUND_MASK_LINE1) {
1012                 recmask = SOUND_MASK_LINE1;
1013                 recdev = ADC_MUX_AUX1;
1014         } else if (recmask & SOUND_MASK_LINE) {
1015                 recmask = SOUND_MASK_LINE;
1016                 recdev = ADC_MUX_LINE;
1017         } else if (recmask & SOUND_MASK_MIC) {
1018                 recmask = SOUND_MASK_MIC;
1019                 recdev = ADC_MUX_MIC;
1020         }
1021
1022         *dev_l = *dev_r = recdev;
1023
1024         return recmask;
1025 }
1026
1027 static int
1028 waveartist_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
1029                         unsigned char lev_r)
1030 {
1031         switch (dev) {
1032         case SOUND_MIXER_VOLUME:
1033         case SOUND_MIXER_SYNTH:
1034         case SOUND_MIXER_PCM:
1035         case SOUND_MIXER_LINE:
1036         case SOUND_MIXER_MIC:
1037         case SOUND_MIXER_IGAIN:
1038         case SOUND_MIXER_LINE1:
1039         case SOUND_MIXER_LINE2:
1040                 devc->levels[dev] = lev_l | lev_r << 8;
1041                 break;
1042
1043         case SOUND_MIXER_IMIX:
1044                 break;
1045
1046         default:
1047                 dev = -EINVAL;
1048                 break;
1049         }
1050
1051         return dev;
1052 }
1053
1054 static int waveartist_get_mixer(wavnc_info *devc, int dev)
1055 {
1056         return devc->levels[dev];
1057 }
1058
1059 static const struct waveartist_mixer_info waveartist_mixer = {
1060         .supported_devs = SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN,
1061         .recording_devs = SOUND_MASK_LINE  | SOUND_MASK_MIC   |
1062                         SOUND_MASK_LINE1 | SOUND_MASK_LINE2 |
1063                         SOUND_MASK_IMIX,
1064         .stereo_devs    = (SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN) & ~
1065                         (SOUND_MASK_SPEAKER | SOUND_MASK_IMIX),
1066         .select_input   = waveartist_select_input,
1067         .decode_mixer   = waveartist_decode_mixer,
1068         .get_mixer      = waveartist_get_mixer,
1069 };
1070
1071 static void
1072 waveartist_set_recmask(wavnc_info *devc, unsigned int recmask)
1073 {
1074         unsigned char dev_l, dev_r;
1075
1076         recmask &= devc->mix->recording_devs;
1077
1078         /*
1079          * If more than one recording device selected,
1080          * disable the device that is currently in use.
1081          */
1082         if (hweight32(recmask) > 1)
1083                 recmask &= ~devc->recmask;
1084
1085         /*
1086          * Translate the recording device mask into
1087          * the ADC multiplexer settings.
1088          */
1089         devc->recmask = devc->mix->select_input(devc, recmask,
1090                                                 &dev_l, &dev_r);
1091
1092         waveartist_set_adc_mux(devc, dev_l, dev_r);
1093 }
1094
1095 static int
1096 waveartist_set_mixer(wavnc_info *devc, int dev, unsigned int level)
1097 {
1098         unsigned int lev_left  = level & 0x00ff;
1099         unsigned int lev_right = (level & 0xff00) >> 8;
1100
1101         if (lev_left > 100)
1102                 lev_left = 100;
1103         if (lev_right > 100)
1104                 lev_right = 100;
1105
1106         /*
1107          * Mono devices have their right volume forced to their
1108          * left volume.  (from ALSA driver OSS emulation).
1109          */
1110         if (!(devc->mix->stereo_devs & (1 << dev)))
1111                 lev_right = lev_left;
1112
1113         dev = devc->mix->decode_mixer(devc, dev, lev_left, lev_right);
1114
1115         if (dev >= 0)
1116                 waveartist_mixer_update(devc, dev);
1117
1118         return dev < 0 ? dev : 0;
1119 }
1120
1121 static int
1122 waveartist_mixer_ioctl(int dev, unsigned int cmd, void __user * arg)
1123 {
1124         wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
1125         int ret = 0, val, nr;
1126
1127         /*
1128          * All SOUND_MIXER_* ioctls use type 'M'
1129          */
1130         if (((cmd >> 8) & 255) != 'M')
1131                 return -ENOIOCTLCMD;
1132
1133 #ifdef CONFIG_ARCH_NETWINDER
1134         if (machine_is_netwinder()) {
1135                 ret = vnc_private_ioctl(dev, cmd, arg);
1136                 if (ret != -ENOIOCTLCMD)
1137                         return ret;
1138                 else
1139                         ret = 0;
1140         }
1141 #endif
1142
1143         nr = cmd & 0xff;
1144
1145         if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
1146                 if (get_user(val, (int __user *)arg))
1147                         return -EFAULT;
1148
1149                 switch (nr) {
1150                 case SOUND_MIXER_RECSRC:
1151                         waveartist_set_recmask(devc, val);
1152                         break;
1153
1154                 default:
1155                         ret = -EINVAL;
1156                         if (nr < SOUND_MIXER_NRDEVICES &&
1157                             devc->mix->supported_devs & (1 << nr))
1158                                 ret = waveartist_set_mixer(devc, nr, val);
1159                 }
1160         }
1161
1162         if (ret == 0 && _SIOC_DIR(cmd) & _SIOC_READ) {
1163                 ret = -EINVAL;
1164
1165                 switch (nr) {
1166                 case SOUND_MIXER_RECSRC:
1167                         ret = devc->recmask;
1168                         break;
1169
1170                 case SOUND_MIXER_DEVMASK:
1171                         ret = devc->mix->supported_devs;
1172                         break;
1173
1174                 case SOUND_MIXER_STEREODEVS:
1175                         ret = devc->mix->stereo_devs;
1176                         break;
1177
1178                 case SOUND_MIXER_RECMASK:
1179                         ret = devc->mix->recording_devs;
1180                         break;
1181
1182                 case SOUND_MIXER_CAPS:
1183                         ret = SOUND_CAP_EXCL_INPUT;
1184                         break;
1185
1186                 default:
1187                         if (nr < SOUND_MIXER_NRDEVICES)
1188                                 ret = devc->mix->get_mixer(devc, nr);
1189                         break;
1190                 }
1191
1192                 if (ret >= 0)
1193                         ret = put_user(ret, (int __user *)arg) ? -EFAULT : 0;
1194         }
1195
1196         return ret;
1197 }
1198
1199 static struct mixer_operations waveartist_mixer_operations =
1200 {
1201         .owner  = THIS_MODULE,
1202         .id     = "WaveArtist",
1203         .name   = "WaveArtist",
1204         .ioctl  = waveartist_mixer_ioctl
1205 };
1206
1207 static void
1208 waveartist_mixer_reset(wavnc_info *devc)
1209 {
1210         int i;
1211
1212         if (debug_flg & DEBUG_MIXER)
1213                 printk("%s: mixer_reset\n", devc->hw.name);
1214
1215         /*
1216          * reset mixer cmd
1217          */
1218         waveartist_cmd1(devc, WACMD_RST_MIXER);
1219
1220         /*
1221          * set input for ADC to come from 'quiet'
1222          * turn on default modes
1223          */
1224         waveartist_cmd3(devc, WACMD_SET_MIXER, 0x9800, 0xa836);
1225
1226         /*
1227          * set mixer input select to none, RX filter gains 0 dB
1228          */
1229         waveartist_cmd3(devc, WACMD_SET_MIXER, 0x4c00, 0x8c00);
1230
1231         /*
1232          * set bit 0 reg 2 to 1 - unmute MonoOut
1233          */
1234         waveartist_cmd3(devc, WACMD_SET_MIXER, 0x2801, 0x6800);
1235
1236         /* set default input device = internal mic
1237          * current recording device = none
1238          */
1239         waveartist_set_recmask(devc, 0);
1240
1241         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1242                 waveartist_mixer_update(devc, i);
1243 }
1244
1245 static int __init waveartist_init(wavnc_info *devc)
1246 {
1247         wavnc_port_info *portc;
1248         char rev[3], dev_name[64];
1249         int my_dev;
1250
1251         if (waveartist_reset(devc))
1252                 return -ENODEV;
1253
1254         sprintf(dev_name, "%s (%s", devc->hw.name, devc->chip_name);
1255
1256         if (waveartist_getrev(devc, rev)) {
1257                 strcat(dev_name, " rev. ");
1258                 strcat(dev_name, rev);
1259         }
1260         strcat(dev_name, ")");
1261
1262         conf_printf2(dev_name, devc->hw.io_base, devc->hw.irq,
1263                      devc->hw.dma, devc->hw.dma2);
1264
1265         portc = kzalloc(sizeof(wavnc_port_info), GFP_KERNEL);
1266         if (portc == NULL)
1267                 goto nomem;
1268
1269         my_dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, dev_name,
1270                         &waveartist_audio_driver, sizeof(struct audio_driver),
1271                         devc->audio_flags, AFMT_U8 | AFMT_S16_LE | AFMT_S8,
1272                         devc, devc->hw.dma, devc->hw.dma2);
1273
1274         if (my_dev < 0)
1275                 goto free;
1276
1277         audio_devs[my_dev]->portc = portc;
1278
1279         waveartist_mixer_reset(devc);
1280
1281         /*
1282          * clear any pending interrupt
1283          */
1284         waveartist_iack(devc);
1285
1286         if (request_irq(devc->hw.irq, waveartist_intr, 0, devc->hw.name, devc) < 0) {
1287                 printk(KERN_ERR "%s: IRQ %d in use\n",
1288                         devc->hw.name, devc->hw.irq);
1289                 goto uninstall;
1290         }
1291
1292         if (sound_alloc_dma(devc->hw.dma, devc->hw.name)) {
1293                 printk(KERN_ERR "%s: Can't allocate DMA%d\n",
1294                         devc->hw.name, devc->hw.dma);
1295                 goto uninstall_irq;
1296         }
1297
1298         if (devc->hw.dma != devc->hw.dma2 && devc->hw.dma2 != NO_DMA)
1299                 if (sound_alloc_dma(devc->hw.dma2, devc->hw.name)) {
1300                         printk(KERN_ERR "%s: can't allocate DMA%d\n",
1301                                 devc->hw.name, devc->hw.dma2);
1302                         goto uninstall_dma;
1303                 }
1304
1305         waveartist_set_ctlr(&devc->hw, 0, DMA1_IE | DMA0_IE);
1306
1307         audio_devs[my_dev]->mixer_dev =
1308                 sound_install_mixer(MIXER_DRIVER_VERSION,
1309                                 dev_name,
1310                                 &waveartist_mixer_operations,
1311                                 sizeof(struct mixer_operations),
1312                                 devc);
1313
1314         return my_dev;
1315
1316 uninstall_dma:
1317         sound_free_dma(devc->hw.dma);
1318
1319 uninstall_irq:
1320         free_irq(devc->hw.irq, devc);
1321
1322 uninstall:
1323         sound_unload_audiodev(my_dev);
1324
1325 free:
1326         kfree(portc);
1327
1328 nomem:
1329         return -1;
1330 }
1331
1332 static int __init probe_waveartist(struct address_info *hw_config)
1333 {
1334         wavnc_info *devc = &adev_info[nr_waveartist_devs];
1335
1336         if (nr_waveartist_devs >= MAX_AUDIO_DEV) {
1337                 printk(KERN_WARNING "waveartist: too many audio devices\n");
1338                 return 0;
1339         }
1340
1341         if (!request_region(hw_config->io_base, 15, hw_config->name))  {
1342                 printk(KERN_WARNING "WaveArtist: I/O port conflict\n");
1343                 return 0;
1344         }
1345
1346         if (hw_config->irq > 15 || hw_config->irq < 0) {
1347                 release_region(hw_config->io_base, 15);
1348                 printk(KERN_WARNING "WaveArtist: Bad IRQ %d\n",
1349                        hw_config->irq);
1350                 return 0;
1351         }
1352
1353         if (hw_config->dma != 3) {
1354                 release_region(hw_config->io_base, 15);
1355                 printk(KERN_WARNING "WaveArtist: Bad DMA %d\n",
1356                        hw_config->dma);
1357                 return 0;
1358         }
1359
1360         hw_config->name = "WaveArtist";
1361         devc->hw = *hw_config;
1362         devc->open_mode = 0;
1363         devc->chip_name = "RWA-010";
1364
1365         return 1;
1366 }
1367
1368 static void __init
1369 attach_waveartist(struct address_info *hw, const struct waveartist_mixer_info *mix)
1370 {
1371         wavnc_info *devc = &adev_info[nr_waveartist_devs];
1372
1373         /*
1374          * NOTE! If irq < 0, there is another driver which has allocated the
1375          *   IRQ so that this driver doesn't need to allocate/deallocate it.
1376          *   The actually used IRQ is ABS(irq).
1377          */
1378         devc->hw = *hw;
1379         devc->hw.irq = (hw->irq > 0) ? hw->irq : 0;
1380         devc->open_mode = 0;
1381         devc->playback_dev = 0;
1382         devc->record_dev = 0;
1383         devc->audio_flags = DMA_AUTOMODE;
1384         devc->levels = levels;
1385
1386         if (hw->dma != hw->dma2 && hw->dma2 != NO_DMA)
1387                 devc->audio_flags |= DMA_DUPLEX;
1388
1389         devc->mix = mix;
1390         devc->dev_no = waveartist_init(devc);
1391
1392         if (devc->dev_no < 0)
1393                 release_region(hw->io_base, 15);
1394         else {
1395 #ifdef CONFIG_ARCH_NETWINDER
1396                 if (machine_is_netwinder()) {
1397                         init_timer(&vnc_timer);
1398                         vnc_timer.function = vnc_slider_tick;
1399                         vnc_timer.expires  = jiffies;
1400                         vnc_timer.data     = nr_waveartist_devs;
1401                         add_timer(&vnc_timer);
1402
1403                         vnc_configure_mixer(devc, 0);
1404
1405                         devc->no_autoselect = 1;
1406                 }
1407 #endif
1408                 nr_waveartist_devs += 1;
1409         }
1410 }
1411
1412 static void __exit unload_waveartist(struct address_info *hw)
1413 {
1414         wavnc_info *devc = NULL;
1415         int i;
1416
1417         for (i = 0; i < nr_waveartist_devs; i++)
1418                 if (hw->io_base == adev_info[i].hw.io_base) {
1419                         devc = adev_info + i;
1420                         break;
1421                 }
1422
1423         if (devc != NULL) {
1424                 int mixer;
1425
1426 #ifdef CONFIG_ARCH_NETWINDER
1427                 if (machine_is_netwinder())
1428                         del_timer(&vnc_timer);
1429 #endif
1430
1431                 release_region(devc->hw.io_base, 15);
1432
1433                 waveartist_set_ctlr(&devc->hw, DMA1_IE|DMA0_IE, 0);
1434
1435                 if (devc->hw.irq >= 0)
1436                         free_irq(devc->hw.irq, devc);
1437
1438                 sound_free_dma(devc->hw.dma);
1439
1440                 if (devc->hw.dma != devc->hw.dma2 &&
1441                     devc->hw.dma2 != NO_DMA)
1442                         sound_free_dma(devc->hw.dma2);
1443
1444                 mixer = audio_devs[devc->dev_no]->mixer_dev;
1445
1446                 if (mixer >= 0)
1447                         sound_unload_mixerdev(mixer);
1448
1449                 if (devc->dev_no >= 0)
1450                         sound_unload_audiodev(devc->dev_no);
1451
1452                 nr_waveartist_devs -= 1;
1453
1454                 for (; i < nr_waveartist_devs; i++)
1455                         adev_info[i] = adev_info[i + 1];
1456         } else
1457                 printk(KERN_WARNING "waveartist: can't find device "
1458                        "to unload\n");
1459 }
1460
1461 #ifdef CONFIG_ARCH_NETWINDER
1462
1463 /*
1464  * Rebel.com Netwinder specifics...
1465  */
1466
1467 #include <asm/hardware/dec21285.h>
1468
1469 #define VNC_TIMER_PERIOD (HZ/4) //check slider 4 times/sec
1470
1471 #define MIXER_PRIVATE3_RESET    0x53570000
1472 #define MIXER_PRIVATE3_READ     0x53570001
1473 #define MIXER_PRIVATE3_WRITE    0x53570002
1474
1475 #define VNC_MUTE_INTERNAL_SPKR  0x01    //the sw mute on/off control bit
1476 #define VNC_MUTE_LINE_OUT       0x10
1477 #define VNC_PHONE_DETECT        0x20
1478 #define VNC_HANDSET_DETECT      0x40
1479 #define VNC_DISABLE_AUTOSWITCH  0x80
1480
1481 static inline void
1482 vnc_mute_spkr(wavnc_info *devc)
1483 {
1484         unsigned long flags;
1485
1486         spin_lock_irqsave(&nw_gpio_lock, flags);
1487         nw_cpld_modify(CPLD_UNMUTE, devc->spkr_mute_state ? 0 : CPLD_UNMUTE);
1488         spin_unlock_irqrestore(&nw_gpio_lock, flags);
1489 }
1490
1491 static void
1492 vnc_mute_lout(wavnc_info *devc)
1493 {
1494         unsigned int left, right;
1495
1496         left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL);
1497         right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x400);
1498
1499         if (devc->line_mute_state) {
1500                 left &= ~1;
1501                 right &= ~1;
1502         } else {
1503                 left |= 1;
1504                 right |= 1;
1505         }
1506         waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
1507
1508 }
1509
1510 static int
1511 vnc_volume_slider(wavnc_info *devc)
1512 {
1513         static signed int old_slider_volume;
1514         unsigned long flags;
1515         signed int volume = 255;
1516
1517         *CSR_TIMER1_LOAD = 0x00ffffff;
1518
1519         spin_lock_irqsave(&waveartist_lock, flags);
1520
1521         outb(0xFF, 0x201);
1522         *CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_DIV1;
1523
1524         while (volume && (inb(0x201) & 0x01))
1525                 volume--;
1526
1527         *CSR_TIMER1_CNTL = 0;
1528
1529         spin_unlock_irqrestore(&waveartist_lock,flags);
1530
1531         volume = 0x00ffffff - *CSR_TIMER1_VALUE;
1532
1533
1534 #ifndef REVERSE
1535         volume = 150 - (volume >> 5);
1536 #else
1537         volume = (volume >> 6) - 25;
1538 #endif
1539
1540         if (volume < 0)
1541                 volume = 0;
1542
1543         if (volume > 100)
1544                 volume = 100;
1545
1546         /*
1547          * slider quite often reads +-8, so debounce this random noise
1548          */
1549         if (abs(volume - old_slider_volume) > 7) {
1550                 old_slider_volume = volume;
1551
1552                 if (debug_flg & DEBUG_MIXER)
1553                         printk(KERN_DEBUG "Slider volume: %d.\n", volume);
1554         }
1555
1556         return old_slider_volume;
1557 }
1558
1559 /*
1560  * Decode a recording mask into a mixer selection on the NetWinder
1561  * as follows:
1562  *
1563  *     OSS Source       WA Source       Actual source
1564  *  SOUND_MASK_IMIX     Mixer           Mixer output (same as AD1848)
1565  *  SOUND_MASK_LINE     Line            Line in
1566  *  SOUND_MASK_LINE1    Left Mic        Handset
1567  *  SOUND_MASK_PHONEIN  Left Aux        Telephone microphone
1568  *  SOUND_MASK_MIC      Right Mic       Builtin microphone
1569  */
1570 static unsigned int
1571 netwinder_select_input(wavnc_info *devc, unsigned int recmask,
1572                        unsigned char *dev_l, unsigned char *dev_r)
1573 {
1574         unsigned int recdev_l = ADC_MUX_NONE, recdev_r = ADC_MUX_NONE;
1575
1576         if (recmask & SOUND_MASK_IMIX) {
1577                 recmask = SOUND_MASK_IMIX;
1578                 recdev_l = ADC_MUX_MIXER;
1579                 recdev_r = ADC_MUX_MIXER;
1580         } else if (recmask & SOUND_MASK_LINE) {
1581                 recmask = SOUND_MASK_LINE;
1582                 recdev_l = ADC_MUX_LINE;
1583                 recdev_r = ADC_MUX_LINE;
1584         } else if (recmask & SOUND_MASK_LINE1) {
1585                 recmask = SOUND_MASK_LINE1;
1586                 waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
1587                 recdev_l = ADC_MUX_MIC;
1588                 recdev_r = ADC_MUX_NONE;
1589         } else if (recmask & SOUND_MASK_PHONEIN) {
1590                 recmask = SOUND_MASK_PHONEIN;
1591                 waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
1592                 recdev_l = ADC_MUX_AUX1;
1593                 recdev_r = ADC_MUX_NONE;
1594         } else if (recmask & SOUND_MASK_MIC) {
1595                 recmask = SOUND_MASK_MIC;
1596                 waveartist_cmd1(devc, WACMD_SET_MONO | 0x100);  /* right */
1597                 recdev_l = ADC_MUX_NONE;
1598                 recdev_r = ADC_MUX_MIC;
1599         }
1600
1601         *dev_l = recdev_l;
1602         *dev_r = recdev_r;
1603
1604         return recmask;
1605 }
1606
1607 static int
1608 netwinder_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
1609                        unsigned char lev_r)
1610 {
1611         switch (dev) {
1612         case SOUND_MIXER_VOLUME:
1613         case SOUND_MIXER_SYNTH:
1614         case SOUND_MIXER_PCM:
1615         case SOUND_MIXER_LINE:
1616         case SOUND_MIXER_IGAIN:
1617                 devc->levels[dev] = lev_l | lev_r << 8;
1618                 break;
1619
1620         case SOUND_MIXER_MIC:           /* right mic only */
1621                 devc->levels[SOUND_MIXER_MIC] &= 0xff;
1622                 devc->levels[SOUND_MIXER_MIC] |= lev_l << 8;
1623                 break;
1624
1625         case SOUND_MIXER_LINE1:         /* left mic only  */
1626                 devc->levels[SOUND_MIXER_MIC] &= 0xff00;
1627                 devc->levels[SOUND_MIXER_MIC] |= lev_l;
1628                 dev = SOUND_MIXER_MIC;
1629                 break;
1630
1631         case SOUND_MIXER_PHONEIN:       /* left aux only  */
1632                 devc->levels[SOUND_MIXER_LINE1] = lev_l;
1633                 dev = SOUND_MIXER_LINE1;
1634                 break;
1635
1636         case SOUND_MIXER_IMIX:
1637         case SOUND_MIXER_PHONEOUT:
1638                 break;
1639
1640         default:
1641                 dev = -EINVAL;
1642                 break;
1643         }
1644         return dev;
1645 }
1646
1647 static int netwinder_get_mixer(wavnc_info *devc, int dev)
1648 {
1649         int levels;
1650
1651         switch (dev) {
1652         case SOUND_MIXER_VOLUME:
1653         case SOUND_MIXER_SYNTH:
1654         case SOUND_MIXER_PCM:
1655         case SOUND_MIXER_LINE:
1656         case SOUND_MIXER_IGAIN:
1657                 levels = devc->levels[dev];
1658                 break;
1659
1660         case SOUND_MIXER_MIC:           /* builtin mic: right mic only */
1661                 levels = devc->levels[SOUND_MIXER_MIC] >> 8;
1662                 levels |= levels << 8;
1663                 break;
1664
1665         case SOUND_MIXER_LINE1:         /* handset mic: left mic only */
1666                 levels = devc->levels[SOUND_MIXER_MIC] & 0xff;
1667                 levels |= levels << 8;
1668                 break;
1669
1670         case SOUND_MIXER_PHONEIN:       /* phone mic: left aux1 only */
1671                 levels = devc->levels[SOUND_MIXER_LINE1] & 0xff;
1672                 levels |= levels << 8;
1673                 break;
1674
1675         default:
1676                 levels = 0;
1677         }
1678
1679         return levels;
1680 }
1681
1682 /*
1683  * Waveartist specific mixer information.
1684  */
1685 static const struct waveartist_mixer_info netwinder_mixer = {
1686         .supported_devs = SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
1687                         SOUND_MASK_PCM     | SOUND_MASK_SPEAKER |
1688                         SOUND_MASK_LINE    | SOUND_MASK_MIC     |
1689                         SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
1690                         SOUND_MASK_PHONEIN | SOUND_MASK_PHONEOUT|
1691                         SOUND_MASK_IGAIN,
1692
1693         .recording_devs = SOUND_MASK_LINE    | SOUND_MASK_MIC     |
1694                         SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
1695                         SOUND_MASK_PHONEIN,
1696
1697         .stereo_devs    = SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
1698                         SOUND_MASK_PCM     | SOUND_MASK_LINE    |
1699                         SOUND_MASK_IMIX    | SOUND_MASK_IGAIN,
1700
1701         .select_input   = netwinder_select_input,
1702         .decode_mixer   = netwinder_decode_mixer,
1703         .get_mixer      = netwinder_get_mixer,
1704 };
1705
1706 static void
1707 vnc_configure_mixer(wavnc_info *devc, unsigned int recmask)
1708 {
1709         if (!devc->no_autoselect) {
1710                 if (devc->handset_detect) {
1711                         recmask = SOUND_MASK_LINE1;
1712                         devc->spkr_mute_state = devc->line_mute_state = 1;
1713                 } else if (devc->telephone_detect) {
1714                         recmask = SOUND_MASK_PHONEIN;
1715                         devc->spkr_mute_state = devc->line_mute_state = 1;
1716                 } else {
1717                         /* unless someone has asked for LINE-IN,
1718                          * we default to MIC
1719                          */
1720                         if ((devc->recmask & SOUND_MASK_LINE) == 0)
1721                                 devc->recmask = SOUND_MASK_MIC;
1722                         devc->spkr_mute_state = devc->line_mute_state = 0;
1723                 }
1724                 vnc_mute_spkr(devc);
1725                 vnc_mute_lout(devc);
1726
1727                 if (recmask != devc->recmask)
1728                         waveartist_set_recmask(devc, recmask);
1729         }
1730 }
1731
1732 static int
1733 vnc_slider(wavnc_info *devc)
1734 {
1735         signed int slider_volume;
1736         unsigned int temp, old_hs, old_td;
1737
1738         /*
1739          * read the "buttons" state.
1740          *  Bit 4 = 0 means handset present
1741          *  Bit 5 = 1 means phone offhook
1742          */
1743         temp = inb(0x201);
1744
1745         old_hs = devc->handset_detect;
1746         old_td = devc->telephone_detect;
1747
1748         devc->handset_detect = !(temp & 0x10);
1749         devc->telephone_detect = !!(temp & 0x20);
1750
1751         if (!devc->no_autoselect &&
1752             (old_hs != devc->handset_detect ||
1753              old_td != devc->telephone_detect))
1754                 vnc_configure_mixer(devc, devc->recmask);
1755
1756         slider_volume = vnc_volume_slider(devc);
1757
1758         /*
1759          * If we're using software controlled volume, and
1760          * the slider moves by more than 20%, then we
1761          * switch back to slider controlled volume.
1762          */
1763         if (abs(devc->slider_vol - slider_volume) > 20)
1764                 devc->use_slider = 1;
1765
1766         /*
1767          * use only left channel
1768          */
1769         temp = levels[SOUND_MIXER_VOLUME] & 0xFF;
1770
1771         if (slider_volume != temp && devc->use_slider) {
1772                 devc->slider_vol = slider_volume;
1773
1774                 waveartist_set_mixer(devc, SOUND_MIXER_VOLUME,
1775                         slider_volume | slider_volume << 8);
1776
1777                 return 1;
1778         }
1779
1780         return 0;
1781 }
1782
1783 static void
1784 vnc_slider_tick(unsigned long data)
1785 {
1786         int next_timeout;
1787
1788         if (vnc_slider(adev_info + data))
1789                 next_timeout = 5;       // mixer reported change
1790         else
1791                 next_timeout = VNC_TIMER_PERIOD;
1792
1793         mod_timer(&vnc_timer, jiffies + next_timeout);
1794 }
1795
1796 static int
1797 vnc_private_ioctl(int dev, unsigned int cmd, int __user * arg)
1798 {
1799         wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
1800         int val;
1801
1802         switch (cmd) {
1803         case SOUND_MIXER_PRIVATE1:
1804         {
1805                 u_int prev_spkr_mute, prev_line_mute, prev_auto_state;
1806                 int val;
1807
1808                 if (get_user(val, arg))
1809                         return -EFAULT;
1810
1811                 /* check if parameter is logical */
1812                 if (val & ~(VNC_MUTE_INTERNAL_SPKR |
1813                             VNC_MUTE_LINE_OUT |
1814                             VNC_DISABLE_AUTOSWITCH))
1815                         return -EINVAL;
1816
1817                 prev_auto_state = devc->no_autoselect;
1818                 prev_spkr_mute  = devc->spkr_mute_state;
1819                 prev_line_mute  = devc->line_mute_state;
1820
1821                 devc->no_autoselect   = (val & VNC_DISABLE_AUTOSWITCH) ? 1 : 0;
1822                 devc->spkr_mute_state = (val & VNC_MUTE_INTERNAL_SPKR) ? 1 : 0;
1823                 devc->line_mute_state = (val & VNC_MUTE_LINE_OUT) ? 1 : 0;
1824
1825                 if (prev_spkr_mute != devc->spkr_mute_state)
1826                         vnc_mute_spkr(devc);
1827
1828                 if (prev_line_mute != devc->line_mute_state)
1829                         vnc_mute_lout(devc);
1830
1831                 if (prev_auto_state != devc->no_autoselect)
1832                         vnc_configure_mixer(devc, devc->recmask);
1833
1834                 return 0;
1835         }
1836
1837         case SOUND_MIXER_PRIVATE2:
1838                 if (get_user(val, arg))
1839                         return -EFAULT;
1840
1841                 switch (val) {
1842 #define VNC_SOUND_PAUSE         0x53    //to pause the DSP
1843 #define VNC_SOUND_RESUME        0x57    //to unpause the DSP
1844                 case VNC_SOUND_PAUSE:
1845                         waveartist_cmd1(devc, 0x16);
1846                         break;
1847
1848                 case VNC_SOUND_RESUME:
1849                         waveartist_cmd1(devc, 0x18);
1850                         break;
1851
1852                 default:
1853                         return -EINVAL;
1854                 }
1855                 return 0;
1856
1857         /* private ioctl to allow bulk access to waveartist */
1858         case SOUND_MIXER_PRIVATE3:
1859         {
1860                 unsigned long   flags;
1861                 int             mixer_reg[15], i, val;
1862
1863                 if (get_user(val, arg))
1864                         return -EFAULT;
1865                 if (copy_from_user(mixer_reg, (void *)val, sizeof(mixer_reg)))
1866                         return -EFAULT;
1867
1868                 switch (mixer_reg[14]) {
1869                 case MIXER_PRIVATE3_RESET:
1870                         waveartist_mixer_reset(devc);
1871                         break;
1872
1873                 case MIXER_PRIVATE3_WRITE:
1874                         waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[0], mixer_reg[4]);
1875                         waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[1], mixer_reg[5]);
1876                         waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[2], mixer_reg[6]);
1877                         waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[3], mixer_reg[7]);
1878                         waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[8], mixer_reg[9]);
1879
1880                         waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[10], mixer_reg[11]);
1881                         waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[12], mixer_reg[13]);
1882                         break;
1883
1884                 case MIXER_PRIVATE3_READ:
1885                         spin_lock_irqsave(&waveartist_lock, flags);
1886
1887                         for (i = 0x30; i < 14 << 8; i += 1 << 8)
1888                                 waveartist_cmd(devc, 1, &i, 1, mixer_reg + (i >> 8));
1889
1890                         spin_unlock_irqrestore(&waveartist_lock, flags);
1891
1892                         if (copy_to_user((void *)val, mixer_reg, sizeof(mixer_reg)))
1893                                 return -EFAULT;
1894                         break;
1895
1896                 default:
1897                         return -EINVAL;
1898                 }
1899                 return 0;
1900         }
1901
1902         /* read back the state from PRIVATE1 */
1903         case SOUND_MIXER_PRIVATE4:
1904                 val = (devc->spkr_mute_state  ? VNC_MUTE_INTERNAL_SPKR : 0) |
1905                       (devc->line_mute_state  ? VNC_MUTE_LINE_OUT      : 0) |
1906                       (devc->handset_detect   ? VNC_HANDSET_DETECT     : 0) |
1907                       (devc->telephone_detect ? VNC_PHONE_DETECT       : 0) |
1908                       (devc->no_autoselect    ? VNC_DISABLE_AUTOSWITCH : 0);
1909
1910                 return put_user(val, arg) ? -EFAULT : 0;
1911         }
1912
1913         if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
1914                 /*
1915                  * special case for master volume: if we
1916                  * received this call - switch from hw
1917                  * volume control to a software volume
1918                  * control, till the hw volume is modified
1919                  * to signal that user wants to be back in
1920                  * hardware...
1921                  */
1922                 if ((cmd & 0xff) == SOUND_MIXER_VOLUME)
1923                         devc->use_slider = 0;
1924
1925                 /* speaker output            */
1926                 if ((cmd & 0xff) == SOUND_MIXER_SPEAKER) {
1927                         unsigned int val, l, r;
1928
1929                         if (get_user(val, arg))
1930                                 return -EFAULT;
1931
1932                         l = val & 0x7f;
1933                         r = (val & 0x7f00) >> 8;
1934                         val = (l + r) / 2;
1935                         devc->levels[SOUND_MIXER_SPEAKER] = val | (val << 8);
1936                         devc->spkr_mute_state = (val <= 50);
1937                         vnc_mute_spkr(devc);
1938                         return 0;
1939                 }
1940         }
1941
1942         return -ENOIOCTLCMD;
1943 }
1944
1945 #endif
1946
1947 static struct address_info cfg;
1948
1949 static int attached;
1950
1951 static int __initdata io = 0;
1952 static int __initdata irq = 0;
1953 static int __initdata dma = 0;
1954 static int __initdata dma2 = 0;
1955
1956
1957 static int __init init_waveartist(void)
1958 {
1959         const struct waveartist_mixer_info *mix;
1960
1961         if (!io && machine_is_netwinder()) {
1962                 /*
1963                  * The NetWinder WaveArtist is at a fixed address.
1964                  * If the user does not supply an address, use the
1965                  * well-known parameters.
1966                  */
1967                 io   = 0x250;
1968                 irq  = 12;
1969                 dma  = 3;
1970                 dma2 = 7;
1971         }
1972
1973         mix = &waveartist_mixer;
1974 #ifdef CONFIG_ARCH_NETWINDER
1975         if (machine_is_netwinder())
1976                 mix = &netwinder_mixer;
1977 #endif
1978
1979         cfg.io_base = io;
1980         cfg.irq = irq;
1981         cfg.dma = dma;
1982         cfg.dma2 = dma2;
1983
1984         if (!probe_waveartist(&cfg))
1985                 return -ENODEV;
1986
1987         attach_waveartist(&cfg, mix);
1988         attached = 1;
1989
1990         return 0;
1991 }
1992
1993 static void __exit cleanup_waveartist(void)
1994 {
1995         if (attached)
1996                 unload_waveartist(&cfg);
1997 }
1998
1999 module_init(init_waveartist);
2000 module_exit(cleanup_waveartist);
2001
2002 #ifndef MODULE
2003 static int __init setup_waveartist(char *str)
2004 {
2005         /* io, irq, dma, dma2 */
2006         int ints[5];
2007
2008         str = get_options(str, ARRAY_SIZE(ints), ints);
2009
2010         io      = ints[1];
2011         irq     = ints[2];
2012         dma     = ints[3];
2013         dma2    = ints[4];
2014
2015         return 1;
2016 }
2017 __setup("waveartist=", setup_waveartist);
2018 #endif
2019
2020 MODULE_DESCRIPTION("Rockwell WaveArtist RWA-010 sound driver");
2021 module_param(io, int, 0);               /* IO base */
2022 module_param(irq, int, 0);              /* IRQ */
2023 module_param(dma, int, 0);              /* DMA */
2024 module_param(dma2, int, 0);             /* DMA2 */
2025 MODULE_LICENSE("GPL");