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