sound/pci/azt3328.c

   1 /*  azt3328.c - driver for Aztech AZF3328 based soundcards (e.g. PCI168).
   2  *  Copyright (C) 2002, 2005 - 2011 by Andreas Mohr <andi AT lisas.de>
   3  *
   4  *  Framework borrowed from Bart Hartgers's als4000.c.
   5  *  Driver developed on PCI168 AP(W) version (PCI rev. 10, subsystem ID 1801),
   6  *  found in a Fujitsu-Siemens PC ("Cordant", aluminum case).
   7  *  Other versions are:
   8  *  PCI168 A(W), sub ID 1800
   9  *  PCI168 A/AP, sub ID 8000
  10  *  Please give me feedback in case you try my driver with one of these!!
  11  *
  12  *  Keywords: Windows XP Vista 168nt4-125.zip 168win95-125.zip PCI 168 download
  13  *  (XP/Vista do not support this card at all but every Linux distribution
  14  *   has very good support out of the box;
  15  *   just to make sure that the right people hit this and get to know that,
  16  *   despite the high level of Internet ignorance - as usual :-P -
  17  *   about very good support for this card - on Linux!)
  18  *
  19  * GPL LICENSE
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29
  30  *  You should have received a copy of the GNU General Public License
  31  *  along with this program; if not, write to the Free Software
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  33  *
  34  * NOTES
  35  *  Since Aztech does not provide any chipset documentation,
  36  *  even on repeated request to various addresses,
  37  *  and the answer that was finally given was negative
  38  *  (and I was stupid enough to manage to get hold of a PCI168 soundcard
  39  *  in the first place >:-P}),
  40  *  I was forced to base this driver on reverse engineering
  41  *  (3 weeks' worth of evenings filled with driver work).
  42  *  (and no, I did NOT go the easy way: to pick up a SB PCI128 for 9 Euros)
  43  *
  44  *  It is quite likely that the AZF3328 chip is the PCI cousin of the
  45  *  AZF3318 ("azt1020 pnp", "MM Pro 16") ISA chip, given very similar specs.
  46  *
  47  *  The AZF3328 chip (note: AZF3328, *not* AZT3328, that's just the driver name
  48  *  for compatibility reasons) from Azfin (joint-venture of Aztech and Fincitec,
  49  *  Fincitec acquired by National Semiconductor in 2002, together with the
  50  *  Fincitec-related company ARSmikro) has the following features:
  51  *
  52  *  - compatibility & compliance:
  53  *    - Microsoft PC 97 ("PC 97 Hardware Design Guide",
  54  *                       http://www.microsoft.com/whdc/archive/pcguides.mspx)
  55  *    - Microsoft PC 98 Baseline Audio
  56  *    - MPU401 UART
  57  *    - Sound Blaster Emulation (DOS Box)
  58  *  - builtin AC97 conformant codec (SNR over 80dB)
  59  *    Note that "conformant" != "compliant"!! this chip's mixer register layout
  60  *    *differs* from the standard AC97 layout:
  61  *    they chose to not implement the headphone register (which is not a
  62  *    problem since it's merely optional), yet when doing this, they committed
  63  *    the grave sin of letting other registers follow immediately instead of
  64  *    keeping a headphone dummy register, thereby shifting the mixer register
  65  *    addresses illegally. So far unfortunately it looks like the very flexible
  66  *    ALSA AC97 support is still not enough to easily compensate for such a
  67  *    grave layout violation despite all tweaks and quirks mechanisms it offers.
  68  *    Well, not quite: now ac97 layer is much improved (bus-specific ops!),
  69  *    thus I was able to implement support - it's actually working quite well.
  70  *    An interesting item might be Aztech AMR 2800-W, since it's an AC97
  71  *    modem card which might reveal the Aztech-specific codec ID which
  72  *    we might want to pretend, too. Dito PCI168's brother, PCI368,
  73  *    where the advertising datasheet says it's AC97-based and has a
  74  *    Digital Enhanced Game Port.
  75  *  - builtin genuine OPL3 - verified to work fine, 20080506
  76  *  - full duplex 16bit playback/record at independent sampling rate
  77  *  - MPU401 (+ legacy address support, claimed by one official spec sheet)
  78  *    FIXME: how to enable legacy addr??
  79  *  - game port (legacy address support)
  80  *  - builtin DirectInput support, helps reduce CPU overhead (interrupt-driven
  81  *    features supported). - See common term "Digital Enhanced Game Port"...
  82  *    (probably DirectInput 3.0 spec - confirm)
  83  *  - builtin 3D enhancement (said to be YAMAHA Ymersion)
  84  *  - built-in General DirectX timer having a 20 bits counter
  85  *    with 1us resolution (see below!)
  86  *  - I2S serial output port for external DAC
  87  *    [FIXME: 3.3V or 5V level? maximum rate is 66.2kHz right?]
  88  *  - supports 33MHz PCI spec 2.1, PCI power management 1.0, compliant with ACPI
  89  *  - supports hardware volume control
  90  *  - single chip low cost solution (128 pin QFP)
  91  *  - supports programmable Sub-vendor and Sub-system ID [24C02 SEEPROM chip]
  92  *    required for Microsoft's logo compliance (FIXME: where?)
  93  *    At least the Trident 4D Wave DX has one bit somewhere
  94  *    to enable writes to PCI subsystem VID registers, that should be it.
  95  *    This might easily be in extended PCI reg space, since PCI168 also has
  96  *    some custom data starting at 0x80. What kind of config settings
  97  *    are located in our extended PCI space anyway??
  98  *  - PCI168 AP(W) card: power amplifier with 4 Watts/channel at 4 Ohms
  99  *    [TDA1517P chip]
 100  *
 101  *  Note that this driver now is actually *better* than the Windows driver,
 102  *  since it additionally supports the card's 1MHz DirectX timer - just try
 103  *  the following snd-seq module parameters etc.:
 104  *  - options snd-seq seq_default_timer_class=2 seq_default_timer_sclass=0
 105  *    seq_default_timer_card=0 seq_client_load=1 seq_default_timer_device=0
 106  *    seq_default_timer_subdevice=0 seq_default_timer_resolution=1000000
 107  *  - "timidity -iAv -B2,8 -Os -EFreverb=0"
 108  *  - "pmidi -p 128:0 jazz.mid"
 109  *
 110  *  OPL3 hardware playback testing, try something like:
 111  *  cat /proc/asound/hwdep
 112  *  and
 113  *  aconnect -o
 114  *  Then use
 115  *  sbiload -Dhw:x,y --opl3 /usr/share/sounds/opl3/std.o3 ......./drums.o3
 116  *  where x,y is the xx-yy number as given in hwdep.
 117  *  Then try
 118  *  pmidi -p a:b jazz.mid
 119  *  where a:b is the client number plus 0 usually, as given by aconnect above.
 120  *  Oh, and make sure to unmute the FM mixer control (doh!)
 121  *  NOTE: power use during OPL3 playback is _VERY_ high (70W --> 90W!)
 122  *  despite no CPU activity, possibly due to hindering ACPI idling somehow.
 123  *  Shouldn't be a problem of the AZF3328 chip itself, I'd hope.
 124  *  Higher PCM / FM mixer levels seem to conflict (causes crackling),
 125  *  at least sometimes.   Maybe even use with hardware sequencer timer above :)
 126  *  adplay/adplug-utils might soon offer hardware-based OPL3 playback, too.
 127  *
 128  *  Certain PCI versions of this card are susceptible to DMA traffic underruns
 129  *  in some systems (resulting in sound crackling/clicking/popping),
 130  *  probably because they don't have a DMA FIFO buffer or so.
 131  *  Overview (PCI ID/PCI subID/PCI rev.):
 132  *  - no DMA crackling on SiS735: 0x50DC/0x1801/16
 133  *  - unknown performance: 0x50DC/0x1801/10
 134  *    (well, it's not bad on an Athlon 1800 with now very optimized IRQ handler)
 135  *
 136  *  Crackling happens with VIA chipsets or, in my case, an SiS735, which is
 137  *  supposed to be very fast and supposed to get rid of crackling much
 138  *  better than a VIA, yet ironically I still get crackling, like many other
 139  *  people with the same chipset.
 140  *  Possible remedies:
 141  *  - use speaker (amplifier) output instead of headphone output
 142  *    (in case crackling is due to overloaded output clipping)
 143  *  - plug card into a different PCI slot, preferably one that isn't shared
 144  *    too much (this helps a lot, but not completely!)
 145  *  - get rid of PCI VGA card, use AGP instead
 146  *  - upgrade or downgrade BIOS
 147  *  - fiddle with PCI latency settings (setpci -v -s BUSID latency_timer=XX)
 148  *    Not too helpful.
 149  *  - Disable ACPI/power management/"Auto Detect RAM/PCI Clk" in BIOS
 150  *
 151  * BUGS
 152  *  - full-duplex might *still* be problematic, however a recent test was fine
 153  *  - (non-bug) "Bass/Treble or 3D settings don't work" - they do get evaluated
 154  *    if you set PCM output switch to "pre 3D" instead of "post 3D".
 155  *    If this can't be set, then get a mixer application that Isn't Stupid (tm)
 156  *    (e.g. kmix, gamix) - unfortunately several are!!
 157  *  - locking is not entirely clean, especially the audio stream activity
 158  *    ints --> may be racy
 159  *  - an _unconnected_ secondary joystick at the gameport will be reported
 160  *    to be "active" (floating values, not precisely -1) due to the way we need
 161  *    to read the Digital Enhanced Game Port. Not sure whether it is fixable.
 162  *
 163  * TODO
 164  *  - use PCI_VDEVICE
 165  *  - verify driver status on x86_64
 166  *  - test multi-card driver operation
 167  *  - (ab)use 1MHz DirectX timer as kernel clocksource
 168  *  - test MPU401 MIDI playback etc.
 169  *  - add more power micro-management (disable various units of the card
 170  *    as long as they're unused, to improve audio quality and save power).
 171  *    However this requires more I/O ports which I haven't figured out yet
 172  *    and which thus might not even exist...
 173  *    The standard suspend/resume functionality could probably make use of
 174  *    some improvement, too...
 175  *  - figure out what all unknown port bits are responsible for
 176  *  - figure out some cleverly evil scheme to possibly make ALSA AC97 code
 177  *    fully accept our quite incompatible ""AC97"" mixer and thus save some
 178  *    code (but I'm not too optimistic that doing this is possible at all)
 179  *  - use MMIO (memory-mapped I/O)? Slightly faster access, e.g. for gameport.
 180  */
 181
 182 #include <asm/io.h>
 183 #include <linux/init.h>
 184 #include <linux/bug.h> /* WARN_ONCE */
 185 #include <linux/pci.h>
 186 #include <linux/delay.h>
 187 #include <linux/slab.h>
 188 #include <linux/gameport.h>
 189 #include <linux/module.h>
 190 #include <linux/dma-mapping.h>
 191 #include <sound/core.h>
 192 #include <sound/control.h>
 193 #include <sound/pcm.h>
 194 #include <sound/rawmidi.h>
 195 #include <sound/mpu401.h>
 196 #include <sound/opl3.h>
 197 #include <sound/initval.h>
 198 /*
 199  * Config switch, to use ALSA's AC97 layer instead of old custom mixer crap.
 200  * If the AC97 compatibility parts we needed to implement locally turn out
 201  * to work nicely, then remove the old implementation eventually.
 202  */
 203 #define AZF_USE_AC97_LAYER 1
 204
 205 #ifdef AZF_USE_AC97_LAYER
 206 #include <sound/ac97_codec.h>
 207 #endif
 208 #include "azt3328.h"
 209
 210 MODULE_AUTHOR("Andreas Mohr <andi AT lisas.de>");
 211 MODULE_DESCRIPTION("Aztech AZF3328 (PCI168)");
 212 MODULE_LICENSE("GPL");
 213 MODULE_SUPPORTED_DEVICE("{{Aztech,AZF3328}}");
 214
 215 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 216 #define SUPPORT_GAMEPORT 1
 217 #endif
 218
 219 /* === Debug settings ===
 220   Further diagnostic functionality than the settings below
 221   does not need to be provided, since one can easily write a POSIX shell script
 222   to dump the card's I/O ports (those listed in lspci -v -v):
 223   dump()
 224   {
 225     local descr=$1; local addr=$2; local count=$3
 226
 227     echo "${descr}: ${count} @ ${addr}:"
 228     dd if=/dev/port skip=`printf %d ${addr}` count=${count} bs=1 \
 229       2>/dev/null| hexdump -C
 230   }
 231   and then use something like
 232   "dump joy200 0x200 8", "dump mpu388 0x388 4", "dump joy 0xb400 8",
 233   "dump codec00 0xa800 32", "dump mixer 0xb800 64", "dump synth 0xbc00 8",
 234   possibly within a "while true; do ... sleep 1; done" loop.
 235   Tweaking ports could be done using
 236   VALSTRING="`printf "%02x" $value`"
 237   printf "\x""$VALSTRING"|dd of=/dev/port seek=`printf %d ${addr}` bs=1 \
 238     2>/dev/null
 239 */
 240
 241 #define DEBUG_MISC      0
 242 #define DEBUG_CALLS     0
 243 #define DEBUG_MIXER     0
 244 #define DEBUG_CODEC     0
 245 #define DEBUG_TIMER     0
 246 #define DEBUG_GAME      0
 247 #define DEBUG_PM        0
 248 #define MIXER_TESTING   0
 249
 250 #if DEBUG_MISC
 251 #define snd_azf3328_dbgmisc(format, args...) printk(KERN_DEBUG format, ##args)
 252 #else
 253 #define snd_azf3328_dbgmisc(format, args...)
 254 #endif
 255
 256 #if DEBUG_CALLS
 257 #define snd_azf3328_dbgcalls(format, args...) printk(format, ##args)
 258 #define snd_azf3328_dbgcallenter() printk(KERN_DEBUG "--> %s\n", __func__)
 259 #define snd_azf3328_dbgcallleave() printk(KERN_DEBUG "<-- %s\n", __func__)
 260 #else
 261 #define snd_azf3328_dbgcalls(format, args...)
 262 #define snd_azf3328_dbgcallenter()
 263 #define snd_azf3328_dbgcallleave()
 264 #endif
 265
 266 #if DEBUG_MIXER
 267 #define snd_azf3328_dbgmixer(format, args...) printk(KERN_DEBUG format, ##args)
 268 #else
 269 #define snd_azf3328_dbgmixer(format, args...)
 270 #endif
 271
 272 #if DEBUG_CODEC
 273 #define snd_azf3328_dbgcodec(format, args...) printk(KERN_DEBUG format, ##args)
 274 #else
 275 #define snd_azf3328_dbgcodec(format, args...)
 276 #endif
 277
 278 #if DEBUG_MISC
 279 #define snd_azf3328_dbgtimer(format, args...) printk(KERN_DEBUG format, ##args)
 280 #else
 281 #define snd_azf3328_dbgtimer(format, args...)
 282 #endif
 283
 284 #if DEBUG_GAME
 285 #define snd_azf3328_dbggame(format, args...) printk(KERN_DEBUG format, ##args)
 286 #else
 287 #define snd_azf3328_dbggame(format, args...)
 288 #endif
 289
 290 #if DEBUG_PM
 291 #define snd_azf3328_dbgpm(format, args...) printk(KERN_DEBUG format, ##args)
 292 #else
 293 #define snd_azf3328_dbgpm(format, args...)
 294 #endif
 295
 296 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 297 module_param_array(index, int, NULL, 0444);
 298 MODULE_PARM_DESC(index, "Index value for AZF3328 soundcard.");
 299
 300 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 301 module_param_array(id, charp, NULL, 0444);
 302 MODULE_PARM_DESC(id, "ID string for AZF3328 soundcard.");
 303
 304 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable this card */
 305 module_param_array(enable, bool, NULL, 0444);
 306 MODULE_PARM_DESC(enable, "Enable AZF3328 soundcard.");
 307
 308 static int seqtimer_scaling = 128;
 309 module_param(seqtimer_scaling, int, 0444);
 310 MODULE_PARM_DESC(seqtimer_scaling, "Set 1024000Hz sequencer timer scale factor (lockup danger!). Default 128.");
 311
 312 enum snd_azf3328_codec_type {
 313   /* warning: fixed indices (also used for bitmask checks!) */
 314   AZF_CODEC_PLAYBACK = 0,
 315   AZF_CODEC_CAPTURE = 1,
 316   AZF_CODEC_I2S_OUT = 2,
 317 };
 318
 319 struct snd_azf3328_codec_data {
 320         unsigned long io_base; /* keep first! (avoid offset calc) */
 321         unsigned int dma_base; /* helper to avoid an indirection in hotpath */
 322         spinlock_t *lock; /* TODO: convert to our own per-codec lock member */
 323         struct snd_pcm_substream *substream;
 324         bool running;
 325         enum snd_azf3328_codec_type type;
 326         const char *name;
 327 };
 328
 329 struct snd_azf3328 {
 330         /* often-used fields towards beginning, then grouped */
 331
 332         unsigned long ctrl_io; /* usually 0xb000, size 128 */
 333         unsigned long game_io;  /* usually 0xb400, size 8 */
 334         unsigned long mpu_io;   /* usually 0xb800, size 4 */
 335         unsigned long opl3_io; /* usually 0xbc00, size 8 */
 336         unsigned long mixer_io; /* usually 0xc000, size 64 */
 337
 338         spinlock_t reg_lock;
 339
 340         struct snd_timer *timer;
 341
 342         struct snd_pcm *pcm[3];
 343
 344         /* playback, recording and I2S out codecs */
 345         struct snd_azf3328_codec_data codecs[3];
 346
 347 #ifdef AZF_USE_AC97_LAYER
 348         struct snd_ac97 *ac97;
 349 #endif
 350
 351         struct snd_card *card;
 352         struct snd_rawmidi *rmidi;
 353
 354 #ifdef SUPPORT_GAMEPORT
 355         struct gameport *gameport;
 356         u16 axes[4];
 357 #endif
 358
 359         struct pci_dev *pci;
 360         int irq;
 361
 362         /* register 0x6a is write-only, thus need to remember setting.
 363          * If we need to add more registers here, then we might try to fold this
 364          * into some transparent combined shadow register handling with
 365          * CONFIG_PM register storage below, but that's slightly difficult. */
 366         u16 shadow_reg_ctrl_6AH;
 367
 368 #ifdef CONFIG_PM_SLEEP
 369         /* register value containers for power management
 370          * Note: not always full I/O range preserved (similar to Win driver!) */
 371         u32 saved_regs_ctrl[AZF_ALIGN(AZF_IO_SIZE_CTRL_PM) / 4];
 372         u32 saved_regs_game[AZF_ALIGN(AZF_IO_SIZE_GAME_PM) / 4];
 373         u32 saved_regs_mpu[AZF_ALIGN(AZF_IO_SIZE_MPU_PM) / 4];
 374         u32 saved_regs_opl3[AZF_ALIGN(AZF_IO_SIZE_OPL3_PM) / 4];
 375         u32 saved_regs_mixer[AZF_ALIGN(AZF_IO_SIZE_MIXER_PM) / 4];
 376 #endif
 377 };
 378
 379 static DEFINE_PCI_DEVICE_TABLE(snd_azf3328_ids) = {
 380         { 0x122D, 0x50DC, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },   /* PCI168/3328 */
 381         { 0x122D, 0x80DA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },   /* 3328 */
 382         { 0, }
 383 };
 384
 385 MODULE_DEVICE_TABLE(pci, snd_azf3328_ids);
 386
 387
 388 static int
 389 snd_azf3328_io_reg_setb(unsigned reg, u8 mask, bool do_set)
 390 {
 391         /* Well, strictly spoken, the inb/outb sequence isn't atomic
 392            and would need locking. However we currently don't care
 393            since it potentially complicates matters. */
 394         u8 prev = inb(reg), new;
 395
 396         new = (do_set) ? (prev|mask) : (prev & ~mask);
 397         /* we need to always write the new value no matter whether it differs
 398          * or not, since some register bits don't indicate their setting */
 399         outb(new, reg);
 400         if (new != prev)
 401                 return 1;
 402
 403         return 0;
 404 }
 405
 406 static inline void
 407 snd_azf3328_codec_outb(const struct snd_azf3328_codec_data *codec,
 408                        unsigned reg,
 409                        u8 value
 410 )
 411 {
 412         outb(value, codec->io_base + reg);
 413 }
 414
 415 static inline u8
 416 snd_azf3328_codec_inb(const struct snd_azf3328_codec_data *codec, unsigned reg)
 417 {
 418         return inb(codec->io_base + reg);
 419 }
 420
 421 static inline void
 422 snd_azf3328_codec_outw(const struct snd_azf3328_codec_data *codec,
 423                        unsigned reg,
 424                        u16 value
 425 )
 426 {
 427         outw(value, codec->io_base + reg);
 428 }
 429
 430 static inline u16
 431 snd_azf3328_codec_inw(const struct snd_azf3328_codec_data *codec, unsigned reg)
 432 {
 433         return inw(codec->io_base + reg);
 434 }
 435
 436 static inline void
 437 snd_azf3328_codec_outl(const struct snd_azf3328_codec_data *codec,
 438                        unsigned reg,
 439                        u32 value
 440 )
 441 {
 442         outl(value, codec->io_base + reg);
 443 }
 444
 445 static inline void
 446 snd_azf3328_codec_outl_multi(const struct snd_azf3328_codec_data *codec,
 447                              unsigned reg, const void *buffer, int count
 448 )
 449 {
 450         unsigned long addr = codec->io_base + reg;
 451         if (count) {
 452                 const u32 *buf = buffer;
 453                 do {
 454                         outl(*buf++, addr);
 455                         addr += 4;
 456                 } while (--count);
 457         }
 458 }
 459
 460 static inline u32
 461 snd_azf3328_codec_inl(const struct snd_azf3328_codec_data *codec, unsigned reg)
 462 {
 463         return inl(codec->io_base + reg);
 464 }
 465
 466 static inline void
 467 snd_azf3328_ctrl_outb(const struct snd_azf3328 *chip, unsigned reg, u8 value)
 468 {
 469         outb(value, chip->ctrl_io + reg);
 470 }
 471
 472 static inline u8
 473 snd_azf3328_ctrl_inb(const struct snd_azf3328 *chip, unsigned reg)
 474 {
 475         return inb(chip->ctrl_io + reg);
 476 }
 477
 478 static inline void
 479 snd_azf3328_ctrl_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
 480 {
 481         outw(value, chip->ctrl_io + reg);
 482 }
 483
 484 static inline void
 485 snd_azf3328_ctrl_outl(const struct snd_azf3328 *chip, unsigned reg, u32 value)
 486 {
 487         outl(value, chip->ctrl_io + reg);
 488 }
 489
 490 static inline void
 491 snd_azf3328_game_outb(const struct snd_azf3328 *chip, unsigned reg, u8 value)
 492 {
 493         outb(value, chip->game_io + reg);
 494 }
 495
 496 static inline void
 497 snd_azf3328_game_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
 498 {
 499         outw(value, chip->game_io + reg);
 500 }
 501
 502 static inline u8
 503 snd_azf3328_game_inb(const struct snd_azf3328 *chip, unsigned reg)
 504 {
 505         return inb(chip->game_io + reg);
 506 }
 507
 508 static inline u16
 509 snd_azf3328_game_inw(const struct snd_azf3328 *chip, unsigned reg)
 510 {
 511         return inw(chip->game_io + reg);
 512 }
 513
 514 static inline void
 515 snd_azf3328_mixer_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
 516 {
 517         outw(value, chip->mixer_io + reg);
 518 }
 519
 520 static inline u16
 521 snd_azf3328_mixer_inw(const struct snd_azf3328 *chip, unsigned reg)
 522 {
 523         return inw(chip->mixer_io + reg);
 524 }
 525
 526 #define AZF_MUTE_BIT 0x80
 527
 528 static bool
 529 snd_azf3328_mixer_mute_control(const struct snd_azf3328 *chip,
 530                            unsigned reg, bool do_mute
 531 )
 532 {
 533         unsigned long portbase = chip->mixer_io + reg + 1;
 534         bool updated;
 535
 536         /* the mute bit is on the *second* (i.e. right) register of a
 537          * left/right channel setting */
 538         updated = snd_azf3328_io_reg_setb(portbase, AZF_MUTE_BIT, do_mute);
 539
 540         /* indicate whether it was muted before */
 541         return (do_mute) ? !updated : updated;
 542 }
 543
 544 static inline bool
 545 snd_azf3328_mixer_mute_control_master(const struct snd_azf3328 *chip,
 546                            bool do_mute
 547 )
 548 {
 549         return snd_azf3328_mixer_mute_control(
 550                 chip,
 551                 IDX_MIXER_PLAY_MASTER,
 552                 do_mute
 553         );
 554 }
 555
 556 static inline bool
 557 snd_azf3328_mixer_mute_control_pcm(const struct snd_azf3328 *chip,
 558                            bool do_mute
 559 )
 560 {
 561         return snd_azf3328_mixer_mute_control(
 562                 chip,
 563                 IDX_MIXER_WAVEOUT,
 564                 do_mute
 565         );
 566 }
 567
 568 static inline void
 569 snd_azf3328_mixer_reset(const struct snd_azf3328 *chip)
 570 {
 571         /* reset (close) mixer:
 572          * first mute master volume, then reset
 573          */
 574         snd_azf3328_mixer_mute_control_master(chip, 1);
 575         snd_azf3328_mixer_outw(chip, IDX_MIXER_RESET, 0x0000);
 576 }
 577
 578 #ifdef AZF_USE_AC97_LAYER
 579
 580 static inline void
 581 snd_azf3328_mixer_ac97_map_unsupported(unsigned short reg, const char *mode)
 582 {
 583         /* need to add some more or less clever emulation? */
 584         printk(KERN_WARNING
 585                 "azt3328: missing %s emulation for AC97 register 0x%02x!\n",
 586                 mode, reg);
 587 }
 588
 589 /*
 590  * Need to have _special_ AC97 mixer hardware register index mapper,
 591  * to compensate for the issue of a rather AC97-incompatible hardware layout.
 592  */
 593 #define AZF_REG_MASK 0x3f
 594 #define AZF_AC97_REG_UNSUPPORTED 0x8000
 595 #define AZF_AC97_REG_REAL_IO_READ 0x4000
 596 #define AZF_AC97_REG_REAL_IO_WRITE 0x2000
 597 #define AZF_AC97_REG_REAL_IO_RW \
 598         (AZF_AC97_REG_REAL_IO_READ | AZF_AC97_REG_REAL_IO_WRITE)
 599 #define AZF_AC97_REG_EMU_IO_READ 0x0400
 600 #define AZF_AC97_REG_EMU_IO_WRITE 0x0200
 601 #define AZF_AC97_REG_EMU_IO_RW \
 602         (AZF_AC97_REG_EMU_IO_READ | AZF_AC97_REG_EMU_IO_WRITE)
 603 static unsigned short
 604 snd_azf3328_mixer_ac97_map_reg_idx(unsigned short reg)
 605 {
 606         static const struct {
 607                 unsigned short azf_reg;
 608         } azf_reg_mapper[] = {
 609                 /* Especially when taking into consideration
 610                  * mono/stereo-based sequence of azf vs. AC97 control series,
 611                  * it's quite obvious that azf simply got rid
 612                  * of the AC97_HEADPHONE control at its intended offset,
 613                  * thus shifted _all_ controls by one,
 614                  * and _then_ simply added it as an FMSYNTH control at the end,
 615                  * to make up for the offset.
 616                  * This means we'll have to translate indices here as
 617                  * needed and then do some tiny AC97 patch action
 618                  * (snd_ac97_rename_vol_ctl() etc.) - that's it.
 619                  */
 620                 { /* AC97_RESET */ IDX_MIXER_RESET
 621                         | AZF_AC97_REG_REAL_IO_WRITE
 622                         | AZF_AC97_REG_EMU_IO_READ },
 623                 { /* AC97_MASTER */ IDX_MIXER_PLAY_MASTER },
 624                  /* note large shift: AC97_HEADPHONE to IDX_MIXER_FMSYNTH! */
 625                 { /* AC97_HEADPHONE */ IDX_MIXER_FMSYNTH },
 626                 { /* AC97_MASTER_MONO */ IDX_MIXER_MODEMOUT },
 627                 { /* AC97_MASTER_TONE */ IDX_MIXER_BASSTREBLE },
 628                 { /* AC97_PC_BEEP */ IDX_MIXER_PCBEEP },
 629                 { /* AC97_PHONE */ IDX_MIXER_MODEMIN },
 630                 { /* AC97_MIC */ IDX_MIXER_MIC },
 631                 { /* AC97_LINE */ IDX_MIXER_LINEIN },
 632                 { /* AC97_CD */ IDX_MIXER_CDAUDIO },
 633                 { /* AC97_VIDEO */ IDX_MIXER_VIDEO },
 634                 { /* AC97_AUX */ IDX_MIXER_AUX },
 635                 { /* AC97_PCM */ IDX_MIXER_WAVEOUT },
 636                 { /* AC97_REC_SEL */ IDX_MIXER_REC_SELECT },
 637                 { /* AC97_REC_GAIN */ IDX_MIXER_REC_VOLUME },
 638                 { /* AC97_REC_GAIN_MIC */ AZF_AC97_REG_EMU_IO_RW },
 639                 { /* AC97_GENERAL_PURPOSE */ IDX_MIXER_ADVCTL2 },
 640                 { /* AC97_3D_CONTROL */ IDX_MIXER_ADVCTL1 },
 641         };
 642
 643         unsigned short reg_azf = AZF_AC97_REG_UNSUPPORTED;
 644
 645         /* azf3328 supports the low-numbered and low-spec:ed range
 646            of AC97 regs only */
 647         if (reg <= AC97_3D_CONTROL) {
 648                 unsigned short reg_idx = reg / 2;
 649                 reg_azf = azf_reg_mapper[reg_idx].azf_reg;
 650                 /* a translation-only entry means it's real read/write: */
 651                 if (!(reg_azf & ~AZF_REG_MASK))
 652                         reg_azf |= AZF_AC97_REG_REAL_IO_RW;
 653         } else {
 654                 switch (reg) {
 655                 case AC97_POWERDOWN:
 656                         reg_azf = AZF_AC97_REG_EMU_IO_RW;
 657                         break;
 658                 case AC97_EXTENDED_ID:
 659                         reg_azf = AZF_AC97_REG_EMU_IO_READ;
 660                         break;
 661                 case AC97_EXTENDED_STATUS:
 662                         /* I don't know what the h*ll AC97 layer
 663                          * would consult this _extended_ register for
 664                          * given a base-AC97-advertised card,
 665                          * but let's just emulate it anyway :-P
 666                          */
 667                         reg_azf = AZF_AC97_REG_EMU_IO_RW;
 668                         break;
 669                 case AC97_VENDOR_ID1:
 670                 case AC97_VENDOR_ID2:
 671                         reg_azf = AZF_AC97_REG_EMU_IO_READ;
 672                         break;
 673                 }
 674         }
 675         return reg_azf;
 676 }
 677
 678 static const unsigned short
 679 azf_emulated_ac97_caps =
 680         AC97_BC_DEDICATED_MIC |
 681         AC97_BC_BASS_TREBLE |
 682         /* Headphone is an FM Synth control here */
 683         AC97_BC_HEADPHONE |
 684         /* no AC97_BC_LOUDNESS! */
 685         /* mask 0x7c00 is
 686            vendor-specific 3D enhancement
 687            vendor indicator.
 688            Since there actually _is_ an
 689            entry for Aztech Labs
 690            (13), make damn sure
 691            to indicate it. */
 692         (13 << 10);
 693
 694 static const unsigned short
 695 azf_emulated_ac97_powerdown =
 696         /* pretend everything to be active */
 697                 AC97_PD_ADC_STATUS |
 698                 AC97_PD_DAC_STATUS |
 699                 AC97_PD_MIXER_STATUS |
 700                 AC97_PD_VREF_STATUS;
 701
 702 /*
 703  * Emulated, _inofficial_ vendor ID
 704  * (there might be some devices such as the MR 2800-W
 705  * which could reveal the real Aztech AC97 ID).
 706  * We choose to use "AZT" prefix, and then use 1 to indicate PCI168
 707  * (better don't use 0x68 since there's a PCI368 as well).
 708  */
 709 static const unsigned int
 710 azf_emulated_ac97_vendor_id = 0x415a5401;
 711
 712 static unsigned short
 713 snd_azf3328_mixer_ac97_read(struct snd_ac97 *ac97, unsigned short reg_ac97)
 714 {
 715         const struct snd_azf3328 *chip = ac97->private_data;
 716         unsigned short reg_azf = snd_azf3328_mixer_ac97_map_reg_idx(reg_ac97);
 717         unsigned short reg_val = 0;
 718         bool unsupported = false;
 719
 720         snd_azf3328_dbgmixer(
 721                 "snd_azf3328_mixer_ac97_read reg_ac97 %u\n",
 722                         reg_ac97
 723         );
 724         if (reg_azf & AZF_AC97_REG_UNSUPPORTED)
 725                 unsupported = true;
 726         else {
 727                 if (reg_azf & AZF_AC97_REG_REAL_IO_READ)
 728                         reg_val = snd_azf3328_mixer_inw(chip,
 729                                                 reg_azf & AZF_REG_MASK);
 730                 else {
 731                         /*
 732                          * Proceed with dummy I/O read,
 733                          * to ensure compatible timing where this may matter.
 734                          * (ALSA AC97 layer usually doesn't call I/O functions
 735                          * due to intelligent I/O caching anyway)
 736                          * Choose a mixer register that's thoroughly unrelated
 737                          * to common audio (try to minimize distortion).
 738                          */
 739                         snd_azf3328_mixer_inw(chip, IDX_MIXER_SOMETHING30H);
 740                 }
 741
 742                 if (reg_azf & AZF_AC97_REG_EMU_IO_READ) {
 743                         switch (reg_ac97) {
 744                         case AC97_RESET:
 745                                 reg_val |= azf_emulated_ac97_caps;
 746                                 break;
 747                         case AC97_POWERDOWN:
 748                                 reg_val |= azf_emulated_ac97_powerdown;
 749                                 break;
 750                         case AC97_EXTENDED_ID:
 751                         case AC97_EXTENDED_STATUS:
 752                                 /* AFAICS we simply can't support anything: */
 753                                 reg_val |= 0;
 754                                 break;
 755                         case AC97_VENDOR_ID1:
 756                                 reg_val = azf_emulated_ac97_vendor_id >> 16;
 757                                 break;
 758                         case AC97_VENDOR_ID2:
 759                                 reg_val = azf_emulated_ac97_vendor_id & 0xffff;
 760                                 break;
 761                         default:
 762                                 unsupported = true;
 763                                 break;
 764                         }
 765                 }
 766         }
 767         if (unsupported)
 768                 snd_azf3328_mixer_ac97_map_unsupported(reg_ac97, "read");
 769
 770         return reg_val;
 771 }
 772
 773 static void
 774 snd_azf3328_mixer_ac97_write(struct snd_ac97 *ac97,
 775                      unsigned short reg_ac97, unsigned short val)
 776 {
 777         const struct snd_azf3328 *chip = ac97->private_data;
 778         unsigned short reg_azf = snd_azf3328_mixer_ac97_map_reg_idx(reg_ac97);
 779         bool unsupported = false;
 780
 781         snd_azf3328_dbgmixer(
 782                 "snd_azf3328_mixer_ac97_write reg_ac97 %u val %u\n",
 783                         reg_ac97, val
 784         );
 785         if (reg_azf & AZF_AC97_REG_UNSUPPORTED)
 786                 unsupported = true;
 787         else {
 788                 if (reg_azf & AZF_AC97_REG_REAL_IO_WRITE)
 789                         snd_azf3328_mixer_outw(
 790                                 chip,
 791                                 reg_azf & AZF_REG_MASK,
 792                                 val
 793                         );
 794                 else
 795                 if (reg_azf & AZF_AC97_REG_EMU_IO_WRITE) {
 796                         switch (reg_ac97) {
 797                         case AC97_REC_GAIN_MIC:
 798                         case AC97_POWERDOWN:
 799                         case AC97_EXTENDED_STATUS:
 800                                 /*
 801                                  * Silently swallow these writes.
 802                                  * Since for most registers our card doesn't
 803                                  * actually support a comparable feature,
 804                                  * this is exactly what we should do here.
 805                                  * The AC97 layer's I/O caching probably
 806                                  * automatically takes care of all the rest...
 807                                  * (remembers written values etc.)
 808                                  */
 809                                 break;
 810                         default:
 811                                 unsupported = true;
 812                                 break;
 813                         }
 814                 }
 815         }
 816         if (unsupported)
 817                 snd_azf3328_mixer_ac97_map_unsupported(reg_ac97, "write");
 818 }
 819
 820 static int
 821 snd_azf3328_mixer_new(struct snd_azf3328 *chip)
 822 {
 823         struct snd_ac97_bus *bus;
 824         struct snd_ac97_template ac97;
 825         static struct snd_ac97_bus_ops ops = {
 826                 .write = snd_azf3328_mixer_ac97_write,
 827                 .read = snd_azf3328_mixer_ac97_read,
 828         };
 829         int rc;
 830
 831         memset(&ac97, 0, sizeof(ac97));
 832         ac97.scaps = AC97_SCAP_SKIP_MODEM
 833                         | AC97_SCAP_AUDIO /* we support audio! */
 834                         | AC97_SCAP_NO_SPDIF;
 835         ac97.private_data = chip;
 836         ac97.pci = chip->pci;
 837
 838         /*
 839          * ALSA's AC97 layer has terrible init crackling issues,
 840          * unfortunately, and since it makes use of AC97_RESET,
 841          * there's no use trying to mute Master Playback proactively.
 842          */
 843
 844         rc = snd_ac97_bus(chip->card, 0, &ops, NULL, &bus);
 845         if (!rc)
 846                 rc = snd_ac97_mixer(bus, &ac97, &chip->ac97);
 847                 /*
 848                  * Make sure to complain loudly in case of AC97 init failure,
 849                  * since failure may happen quite often,
 850                  * due to this card being a very quirky AC97 "lookalike".
 851                  */
 852         if (rc)
 853                 printk(KERN_ERR "azt3328: AC97 init failed, err %d!\n", rc);
 854
 855         /* If we return an error here, then snd_card_free() should
 856          * free up any ac97 codecs that got created, as well as the bus.
 857          */
 858         return rc;
 859 }
 860 #else /* AZF_USE_AC97_LAYER */
 861 static void
 862 snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip,
 863                                          unsigned reg,
 864                                          unsigned char dst_vol_left,
 865                                          unsigned char dst_vol_right,
 866                                          int chan_sel, int delay
 867 )
 868 {
 869         unsigned long portbase = chip->mixer_io + reg;
 870         unsigned char curr_vol_left = 0, curr_vol_right = 0;
 871         int left_change = 0, right_change = 0;
 872
 873         snd_azf3328_dbgcallenter();
 874
 875         if (chan_sel & SET_CHAN_LEFT) {
 876                 curr_vol_left  = inb(portbase + 1);
 877
 878                 /* take care of muting flag contained in left channel */
 879                 if (curr_vol_left & AZF_MUTE_BIT)
 880                         dst_vol_left |= AZF_MUTE_BIT;
 881                 else
 882                         dst_vol_left &= ~AZF_MUTE_BIT;
 883
 884                 left_change = (curr_vol_left > dst_vol_left) ? -1 : 1;
 885         }
 886
 887         if (chan_sel & SET_CHAN_RIGHT) {
 888                 curr_vol_right = inb(portbase + 0);
 889
 890                 right_change = (curr_vol_right > dst_vol_right) ? -1 : 1;
 891         }
 892
 893         do {
 894                 if (left_change) {
 895                         if (curr_vol_left != dst_vol_left) {
 896                                 curr_vol_left += left_change;
 897                                 outb(curr_vol_left, portbase + 1);
 898                         } else
 899                             left_change = 0;
 900                 }
 901                 if (right_change) {
 902                         if (curr_vol_right != dst_vol_right) {
 903                                 curr_vol_right += right_change;
 904
 905                         /* during volume change, the right channel is crackling
 906                          * somewhat more than the left channel, unfortunately.
 907                          * This seems to be a hardware issue. */
 908                                 outb(curr_vol_right, portbase + 0);
 909                         } else
 910                             right_change = 0;
 911                 }
 912                 if (delay)
 913                         mdelay(delay);
 914         } while ((left_change) || (right_change));
 915         snd_azf3328_dbgcallleave();
 916 }
 917
 918 /*
 919  * general mixer element
 920  */
 921 struct azf3328_mixer_reg {
 922         unsigned reg;
 923         unsigned int lchan_shift, rchan_shift;
 924         unsigned int mask;
 925         unsigned int invert: 1;
 926         unsigned int stereo: 1;
 927         unsigned int enum_c: 4;
 928 };
 929
 930 #define COMPOSE_MIXER_REG(reg,lchan_shift,rchan_shift,mask,invert,stereo,enum_c) \
 931  ((reg) | (lchan_shift << 8) | (rchan_shift << 12) | \
 932   (mask << 16) | \
 933   (invert << 24) | \
 934   (stereo << 25) | \
 935   (enum_c << 26))
 936
 937 static void snd_azf3328_mixer_reg_decode(struct azf3328_mixer_reg *r, unsigned long val)
 938 {
 939         r->reg = val & 0xff;
 940         r->lchan_shift = (val >> 8) & 0x0f;
 941         r->rchan_shift = (val >> 12) & 0x0f;
 942         r->mask = (val >> 16) & 0xff;
 943         r->invert = (val >> 24) & 1;
 944         r->stereo = (val >> 25) & 1;
 945         r->enum_c = (val >> 26) & 0x0f;
 946 }
 947
 948 /*
 949  * mixer switches/volumes
 950  */
 951
 952 #define AZF3328_MIXER_SWITCH(xname, reg, shift, invert) \
 953 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 954   .info = snd_azf3328_info_mixer, \
 955   .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
 956   .private_value = COMPOSE_MIXER_REG(reg, shift, 0, 0x1, invert, 0, 0), \
 957 }
 958
 959 #define AZF3328_MIXER_VOL_STEREO(xname, reg, mask, invert) \
 960 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 961   .info = snd_azf3328_info_mixer, \
 962   .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
 963   .private_value = COMPOSE_MIXER_REG(reg, 8, 0, mask, invert, 1, 0), \
 964 }
 965
 966 #define AZF3328_MIXER_VOL_MONO(xname, reg, mask, is_right_chan) \
 967 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 968   .info = snd_azf3328_info_mixer, \
 969   .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
 970   .private_value = COMPOSE_MIXER_REG(reg, is_right_chan ? 0 : 8, 0, mask, 1, 0, 0), \
 971 }
 972
 973 #define AZF3328_MIXER_VOL_SPECIAL(xname, reg, mask, shift, invert) \
 974 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 975   .info = snd_azf3328_info_mixer, \
 976   .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
 977   .private_value = COMPOSE_MIXER_REG(reg, shift, 0, mask, invert, 0, 0), \
 978 }
 979
 980 #define AZF3328_MIXER_ENUM(xname, reg, enum_c, shift) \
 981 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 982   .info = snd_azf3328_info_mixer_enum, \
 983   .get = snd_azf3328_get_mixer_enum, .put = snd_azf3328_put_mixer_enum, \
 984   .private_value = COMPOSE_MIXER_REG(reg, shift, 0, 0, 0, 0, enum_c), \
 985 }
 986
 987 static int
 988 snd_azf3328_info_mixer(struct snd_kcontrol *kcontrol,
 989                        struct snd_ctl_elem_info *uinfo)
 990 {
 991         struct azf3328_mixer_reg reg;
 992
 993         snd_azf3328_dbgcallenter();
 994         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
 995         uinfo->type = reg.mask == 1 ?
 996                 SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 997         uinfo->count = reg.stereo + 1;
 998         uinfo->value.integer.min = 0;
 999         uinfo->value.integer.max = reg.mask;
1000         snd_azf3328_dbgcallleave();
1001         return 0;
1002 }
1003
1004 static int
1005 snd_azf3328_get_mixer(struct snd_kcontrol *kcontrol,
1006                       struct snd_ctl_elem_value *ucontrol)
1007 {
1008         struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
1009         struct azf3328_mixer_reg reg;
1010         u16 oreg, val;
1011
1012         snd_azf3328_dbgcallenter();
1013         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
1014
1015         oreg = snd_azf3328_mixer_inw(chip, reg.reg);
1016         val = (oreg >> reg.lchan_shift) & reg.mask;
1017         if (reg.invert)
1018                 val = reg.mask - val;
1019         ucontrol->value.integer.value[0] = val;
1020         if (reg.stereo) {
1021                 val = (oreg >> reg.rchan_shift) & reg.mask;
1022                 if (reg.invert)
1023                         val = reg.mask - val;
1024                 ucontrol->value.integer.value[1] = val;
1025         }
1026         snd_azf3328_dbgmixer("get: %02x is %04x -> vol %02lx|%02lx "
1027                              "(shift %02d|%02d, mask %02x, inv. %d, stereo %d)\n",
1028                 reg.reg, oreg,
1029                 ucontrol->value.integer.value[0], ucontrol->value.integer.value[1],
1030                 reg.lchan_shift, reg.rchan_shift, reg.mask, reg.invert, reg.stereo);
1031         snd_azf3328_dbgcallleave();
1032         return 0;
1033 }
1034
1035 static int
1036 snd_azf3328_put_mixer(struct snd_kcontrol *kcontrol,
1037                       struct snd_ctl_elem_value *ucontrol)
1038 {
1039         struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
1040         struct azf3328_mixer_reg reg;
1041         u16 oreg, nreg, val;
1042
1043         snd_azf3328_dbgcallenter();
1044         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
1045         oreg = snd_azf3328_mixer_inw(chip, reg.reg);
1046         val = ucontrol->value.integer.value[0] & reg.mask;
1047         if (reg.invert)
1048                 val = reg.mask - val;
1049         nreg = oreg & ~(reg.mask << reg.lchan_shift);
1050         nreg |= (val << reg.lchan_shift);
1051         if (reg.stereo) {
1052                 val = ucontrol->value.integer.value[1] & reg.mask;
1053                 if (reg.invert)
1054                         val = reg.mask - val;
1055                 nreg &= ~(reg.mask << reg.rchan_shift);
1056                 nreg |= (val << reg.rchan_shift);
1057         }
1058         if (reg.mask >= 0x07) /* it's a volume control, so better take care */
1059                 snd_azf3328_mixer_write_volume_gradually(
1060                         chip, reg.reg, nreg >> 8, nreg & 0xff,
1061                         /* just set both channels, doesn't matter */
1062                         SET_CHAN_LEFT|SET_CHAN_RIGHT,
1063                         0);
1064         else
1065                 snd_azf3328_mixer_outw(chip, reg.reg, nreg);
1066
1067         snd_azf3328_dbgmixer("put: %02x to %02lx|%02lx, "
1068                              "oreg %04x; shift %02d|%02d -> nreg %04x; after: %04x\n",
1069                 reg.reg, ucontrol->value.integer.value[0], ucontrol->value.integer.value[1],
1070                 oreg, reg.lchan_shift, reg.rchan_shift,
1071                 nreg, snd_azf3328_mixer_inw(chip, reg.reg));
1072         snd_azf3328_dbgcallleave();
1073         return (nreg != oreg);
1074 }
1075
1076 static int
1077 snd_azf3328_info_mixer_enum(struct snd_kcontrol *kcontrol,
1078                             struct snd_ctl_elem_info *uinfo)
1079 {
1080         static const char * const texts1[] = {
1081                 "Mic1", "Mic2"
1082         };
1083         static const char * const texts2[] = {
1084                 "Mix", "Mic"
1085         };
1086         static const char * const texts3[] = {
1087                 "Mic", "CD", "Video", "Aux",
1088                 "Line", "Mix", "Mix Mono", "Phone"
1089         };
1090         static const char * const texts4[] = {
1091                 "pre 3D", "post 3D"
1092         };
1093         struct azf3328_mixer_reg reg;
1094         const char * const *p = NULL;
1095
1096         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
1097         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1098         uinfo->count = (reg.reg == IDX_MIXER_REC_SELECT) ? 2 : 1;
1099         uinfo->value.enumerated.items = reg.enum_c;
1100         if (uinfo->value.enumerated.item > reg.enum_c - 1U)
1101                 uinfo->value.enumerated.item = reg.enum_c - 1U;
1102         if (reg.reg == IDX_MIXER_ADVCTL2) {
1103                 switch(reg.lchan_shift) {
1104                 case 8: /* modem out sel */
1105                         p = texts1;
1106                         break;
1107                 case 9: /* mono sel source */
1108                         p = texts2;
1109                         break;
1110                 case 15: /* PCM Out Path */
1111                         p = texts4;
1112                         break;
1113                 }
1114         } else
1115         if (reg.reg == IDX_MIXER_REC_SELECT)
1116                 p = texts3;
1117
1118         strcpy(uinfo->value.enumerated.name, p[uinfo->value.enumerated.item]);
1119         return 0;
1120 }
1121
1122 static int
1123 snd_azf3328_get_mixer_enum(struct snd_kcontrol *kcontrol,
1124                            struct snd_ctl_elem_value *ucontrol)
1125 {
1126         struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
1127         struct azf3328_mixer_reg reg;
1128         unsigned short val;
1129
1130         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
1131         val = snd_azf3328_mixer_inw(chip, reg.reg);
1132         if (reg.reg == IDX_MIXER_REC_SELECT) {
1133                 ucontrol->value.enumerated.item[0] = (val >> 8) & (reg.enum_c - 1);
1134                 ucontrol->value.enumerated.item[1] = (val >> 0) & (reg.enum_c - 1);
1135         } else
1136                 ucontrol->value.enumerated.item[0] = (val >> reg.lchan_shift) & (reg.enum_c - 1);
1137
1138         snd_azf3328_dbgmixer("get_enum: %02x is %04x -> %d|%d (shift %02d, enum_c %d)\n",
1139                 reg.reg, val, ucontrol->value.enumerated.item[0], ucontrol->value.enumerated.item[1],
1140                 reg.lchan_shift, reg.enum_c);
1141         return 0;
1142 }
1143
1144 static int
1145 snd_azf3328_put_mixer_enum(struct snd_kcontrol *kcontrol,
1146                            struct snd_ctl_elem_value *ucontrol)
1147 {
1148         struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
1149         struct azf3328_mixer_reg reg;
1150         u16 oreg, nreg, val;
1151
1152         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
1153         oreg = snd_azf3328_mixer_inw(chip, reg.reg);
1154         val = oreg;
1155         if (reg.reg == IDX_MIXER_REC_SELECT) {
1156                 if (ucontrol->value.enumerated.item[0] > reg.enum_c - 1U ||
1157                 ucontrol->value.enumerated.item[1] > reg.enum_c - 1U)
1158                         return -EINVAL;
1159                 val = (ucontrol->value.enumerated.item[0] << 8) |
1160                       (ucontrol->value.enumerated.item[1] << 0);
1161         } else {
1162                 if (ucontrol->value.enumerated.item[0] > reg.enum_c - 1U)
1163                         return -EINVAL;
1164                 val &= ~((reg.enum_c - 1) << reg.lchan_shift);
1165                 val |= (ucontrol->value.enumerated.item[0] << reg.lchan_shift);
1166         }
1167         snd_azf3328_mixer_outw(chip, reg.reg, val);
1168         nreg = val;
1169
1170         snd_azf3328_dbgmixer("put_enum: %02x to %04x, oreg %04x\n", reg.reg, val, oreg);
1171         return (nreg != oreg);
1172 }
1173
1174 static struct snd_kcontrol_new snd_azf3328_mixer_controls[] = {
1175         AZF3328_MIXER_SWITCH("Master Playback Switch", IDX_MIXER_PLAY_MASTER, 15, 1),
1176         AZF3328_MIXER_VOL_STEREO("Master Playback Volume", IDX_MIXER_PLAY_MASTER, 0x1f, 1),
1177         AZF3328_MIXER_SWITCH("PCM Playback Switch", IDX_MIXER_WAVEOUT, 15, 1),
1178         AZF3328_MIXER_VOL_STEREO("PCM Playback Volume",
1179                                         IDX_MIXER_WAVEOUT, 0x1f, 1),
1180         AZF3328_MIXER_SWITCH("PCM 3D Bypass Playback Switch",
1181                                         IDX_MIXER_ADVCTL2, 7, 1),
1182         AZF3328_MIXER_SWITCH("FM Playback Switch", IDX_MIXER_FMSYNTH, 15, 1),
1183         AZF3328_MIXER_VOL_STEREO("FM Playback Volume", IDX_MIXER_FMSYNTH, 0x1f, 1),
1184         AZF3328_MIXER_SWITCH("CD Playback Switch", IDX_MIXER_CDAUDIO, 15, 1),
1185         AZF3328_MIXER_VOL_STEREO("CD Playback Volume", IDX_MIXER_CDAUDIO, 0x1f, 1),
1186         AZF3328_MIXER_SWITCH("Capture Switch", IDX_MIXER_REC_VOLUME, 15, 1),
1187         AZF3328_MIXER_VOL_STEREO("Capture Volume", IDX_MIXER_REC_VOLUME, 0x0f, 0),
1188         AZF3328_MIXER_ENUM("Capture Source", IDX_MIXER_REC_SELECT, 8, 0),
1189         AZF3328_MIXER_SWITCH("Mic Playback Switch", IDX_MIXER_MIC, 15, 1),
1190         AZF3328_MIXER_VOL_MONO("Mic Playback Volume", IDX_MIXER_MIC, 0x1f, 1),
1191         AZF3328_MIXER_SWITCH("Mic Boost (+20dB)", IDX_MIXER_MIC, 6, 0),
1192         AZF3328_MIXER_SWITCH("Line Playback Switch", IDX_MIXER_LINEIN, 15, 1),
1193         AZF3328_MIXER_VOL_STEREO("Line Playback Volume", IDX_MIXER_LINEIN, 0x1f, 1),
1194         AZF3328_MIXER_SWITCH("Beep Playback Switch", IDX_MIXER_PCBEEP, 15, 1),
1195         AZF3328_MIXER_VOL_SPECIAL("Beep Playback Volume", IDX_MIXER_PCBEEP, 0x0f, 1, 1),
1196         AZF3328_MIXER_SWITCH("Video Playback Switch", IDX_MIXER_VIDEO, 15, 1),
1197         AZF3328_MIXER_VOL_STEREO("Video Playback Volume", IDX_MIXER_VIDEO, 0x1f, 1),
1198         AZF3328_MIXER_SWITCH("Aux Playback Switch", IDX_MIXER_AUX, 15, 1),
1199         AZF3328_MIXER_VOL_STEREO("Aux Playback Volume", IDX_MIXER_AUX, 0x1f, 1),
1200         AZF3328_MIXER_SWITCH("Modem Playback Switch", IDX_MIXER_MODEMOUT, 15, 1),
1201         AZF3328_MIXER_VOL_MONO("Modem Playback Volume", IDX_MIXER_MODEMOUT, 0x1f, 1),
1202         AZF3328_MIXER_SWITCH("Modem Capture Switch", IDX_MIXER_MODEMIN, 15, 1),
1203         AZF3328_MIXER_VOL_MONO("Modem Capture Volume", IDX_MIXER_MODEMIN, 0x1f, 1),
1204         AZF3328_MIXER_ENUM("Mic Select", IDX_MIXER_ADVCTL2, 2, 8),
1205         AZF3328_MIXER_ENUM("Mono Output Select", IDX_MIXER_ADVCTL2, 2, 9),
1206         AZF3328_MIXER_ENUM("PCM Output Route", IDX_MIXER_ADVCTL2, 2, 15), /* PCM Out Path, place in front since it controls *both* 3D and Bass/Treble! */
1207         AZF3328_MIXER_VOL_SPECIAL("Tone Control - Treble", IDX_MIXER_BASSTREBLE, 0x07, 1, 0),
1208         AZF3328_MIXER_VOL_SPECIAL("Tone Control - Bass", IDX_MIXER_BASSTREBLE, 0x07, 9, 0),
1209         AZF3328_MIXER_SWITCH("3D Control - Switch", IDX_MIXER_ADVCTL2, 13, 0),
1210         AZF3328_MIXER_VOL_SPECIAL("3D Control - Width", IDX_MIXER_ADVCTL1, 0x07, 1, 0), /* "3D Width" */
1211         AZF3328_MIXER_VOL_SPECIAL("3D Control - Depth", IDX_MIXER_ADVCTL1, 0x03, 8, 0), /* "Hifi 3D" */
1212 #if MIXER_TESTING
1213         AZF3328_MIXER_SWITCH("0", IDX_MIXER_ADVCTL2, 0, 0),
1214         AZF3328_MIXER_SWITCH("1", IDX_MIXER_ADVCTL2, 1, 0),
1215         AZF3328_MIXER_SWITCH("2", IDX_MIXER_ADVCTL2, 2, 0),
1216         AZF3328_MIXER_SWITCH("3", IDX_MIXER_ADVCTL2, 3, 0),
1217         AZF3328_MIXER_SWITCH("4", IDX_MIXER_ADVCTL2, 4, 0),
1218         AZF3328_MIXER_SWITCH("5", IDX_MIXER_ADVCTL2, 5, 0),
1219         AZF3328_MIXER_SWITCH("6", IDX_MIXER_ADVCTL2, 6, 0),
1220         AZF3328_MIXER_SWITCH("7", IDX_MIXER_ADVCTL2, 7, 0),
1221         AZF3328_MIXER_SWITCH("8", IDX_MIXER_ADVCTL2, 8, 0),
1222         AZF3328_MIXER_SWITCH("9", IDX_MIXER_ADVCTL2, 9, 0),
1223         AZF3328_MIXER_SWITCH("10", IDX_MIXER_ADVCTL2, 10, 0),
1224         AZF3328_MIXER_SWITCH("11", IDX_MIXER_ADVCTL2, 11, 0),
1225         AZF3328_MIXER_SWITCH("12", IDX_MIXER_ADVCTL2, 12, 0),
1226         AZF3328_MIXER_SWITCH("13", IDX_MIXER_ADVCTL2, 13, 0),
1227         AZF3328_MIXER_SWITCH("14", IDX_MIXER_ADVCTL2, 14, 0),
1228         AZF3328_MIXER_SWITCH("15", IDX_MIXER_ADVCTL2, 15, 0),
1229 #endif
1230 };
1231
1232 static u16 snd_azf3328_init_values[][2] = {
1233         { IDX_MIXER_PLAY_MASTER,        MIXER_MUTE_MASK|0x1f1f },
1234         { IDX_MIXER_MODEMOUT,           MIXER_MUTE_MASK|0x1f1f },
1235         { IDX_MIXER_BASSTREBLE,         0x0000 },
1236         { IDX_MIXER_PCBEEP,             MIXER_MUTE_MASK|0x1f1f },
1237         { IDX_MIXER_MODEMIN,            MIXER_MUTE_MASK|0x1f1f },
1238         { IDX_MIXER_MIC,                MIXER_MUTE_MASK|0x001f },
1239         { IDX_MIXER_LINEIN,             MIXER_MUTE_MASK|0x1f1f },
1240         { IDX_MIXER_CDAUDIO,            MIXER_MUTE_MASK|0x1f1f },
1241         { IDX_MIXER_VIDEO,              MIXER_MUTE_MASK|0x1f1f },
1242         { IDX_MIXER_AUX,                MIXER_MUTE_MASK|0x1f1f },
1243         { IDX_MIXER_WAVEOUT,            MIXER_MUTE_MASK|0x1f1f },
1244         { IDX_MIXER_FMSYNTH,            MIXER_MUTE_MASK|0x1f1f },
1245         { IDX_MIXER_REC_VOLUME,         MIXER_MUTE_MASK|0x0707 },
1246 };
1247
1248 static int
1249 snd_azf3328_mixer_new(struct snd_azf3328 *chip)
1250 {
1251         struct snd_card *card;
1252         const struct snd_kcontrol_new *sw;
1253         unsigned int idx;
1254         int err;
1255
1256         snd_azf3328_dbgcallenter();
1257         if (snd_BUG_ON(!chip || !chip->card))
1258                 return -EINVAL;
1259
1260         card = chip->card;
1261
1262         /* mixer reset */
1263         snd_azf3328_mixer_outw(chip, IDX_MIXER_RESET, 0x0000);
1264
1265         /* mute and zero volume channels */
1266         for (idx = 0; idx < ARRAY_SIZE(snd_azf3328_init_values); ++idx) {
1267                 snd_azf3328_mixer_outw(chip,
1268                         snd_azf3328_init_values[idx][0],
1269                         snd_azf3328_init_values[idx][1]);
1270         }
1271
1272         /* add mixer controls */
1273         sw = snd_azf3328_mixer_controls;
1274         for (idx = 0; idx < ARRAY_SIZE(snd_azf3328_mixer_controls);
1275                         ++idx, ++sw) {
1276                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(sw, chip))) < 0)
1277                         return err;
1278         }
1279         snd_component_add(card, "AZF3328 mixer");
1280         strcpy(card->mixername, "AZF3328 mixer");
1281
1282         snd_azf3328_dbgcallleave();
1283         return 0;
1284 }
1285 #endif /* AZF_USE_AC97_LAYER */
1286
1287 static int
1288 snd_azf3328_hw_params(struct snd_pcm_substream *substream,
1289                                  struct snd_pcm_hw_params *hw_params)
1290 {
1291         int res;
1292         snd_azf3328_dbgcallenter();
1293         res = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
1294         snd_azf3328_dbgcallleave();
1295         return res;
1296 }
1297
1298 static int
1299 snd_azf3328_hw_free(struct snd_pcm_substream *substream)
1300 {
1301         snd_azf3328_dbgcallenter();
1302         snd_pcm_lib_free_pages(substream);
1303         snd_azf3328_dbgcallleave();
1304         return 0;
1305 }
1306
1307 static void
1308 snd_azf3328_codec_setfmt(struct snd_azf3328_codec_data *codec,
1309                                enum azf_freq_t bitrate,
1310                                unsigned int format_width,
1311                                unsigned int channels
1312 )
1313 {
1314         unsigned long flags;
1315         u16 val = 0xff00;
1316         u8 freq = 0;
1317
1318         snd_azf3328_dbgcallenter();
1319         switch (bitrate) {
1320         case AZF_FREQ_4000:  freq = SOUNDFORMAT_FREQ_SUSPECTED_4000; break;
1321         case AZF_FREQ_4800:  freq = SOUNDFORMAT_FREQ_SUSPECTED_4800; break;
1322         case AZF_FREQ_5512:
1323                 /* the AZF3328 names it "5510" for some strange reason */
1324                              freq = SOUNDFORMAT_FREQ_5510; break;
1325         case AZF_FREQ_6620:  freq = SOUNDFORMAT_FREQ_6620; break;
1326         case AZF_FREQ_8000:  freq = SOUNDFORMAT_FREQ_8000; break;
1327         case AZF_FREQ_9600:  freq = SOUNDFORMAT_FREQ_9600; break;
1328         case AZF_FREQ_11025: freq = SOUNDFORMAT_FREQ_11025; break;
1329         case AZF_FREQ_13240: freq = SOUNDFORMAT_FREQ_SUSPECTED_13240; break;
1330         case AZF_FREQ_16000: freq = SOUNDFORMAT_FREQ_16000; break;
1331         case AZF_FREQ_22050: freq = SOUNDFORMAT_FREQ_22050; break;
1332         case AZF_FREQ_32000: freq = SOUNDFORMAT_FREQ_32000; break;
1333         default:
1334                 snd_printk(KERN_WARNING "unknown bitrate %d, assuming 44.1kHz!\n", bitrate);
1335                 /* fall-through */
1336         case AZF_FREQ_44100: freq = SOUNDFORMAT_FREQ_44100; break;
1337         case AZF_FREQ_48000: freq = SOUNDFORMAT_FREQ_48000; break;
1338         case AZF_FREQ_66200: freq = SOUNDFORMAT_FREQ_SUSPECTED_66200; break;
1339         }
1340         /* val = 0xff07; 3m27.993s (65301Hz; -> 64000Hz???) hmm, 66120, 65967, 66123 */
1341         /* val = 0xff09; 17m15.098s (13123,478Hz; -> 12000Hz???) hmm, 13237.2Hz? */
1342         /* val = 0xff0a; 47m30.599s (4764,891Hz; -> 4800Hz???) yup, 4803Hz */
1343         /* val = 0xff0c; 57m0.510s (4010,263Hz; -> 4000Hz???) yup, 4003Hz */
1344         /* val = 0xff05; 5m11.556s (... -> 44100Hz) */
1345         /* val = 0xff03; 10m21.529s (21872,463Hz; -> 22050Hz???) */
1346         /* val = 0xff0f; 20m41.883s (10937,993Hz; -> 11025Hz???) */
1347         /* val = 0xff0d; 41m23.135s (5523,600Hz; -> 5512Hz???) */
1348         /* val = 0xff0e; 28m30.777s (8017Hz; -> 8000Hz???) */
1349
1350         val |= freq;
1351
1352         if (channels == 2)
1353                 val |= SOUNDFORMAT_FLAG_2CHANNELS;
1354
1355         if (format_width == 16)
1356                 val |= SOUNDFORMAT_FLAG_16BIT;
1357
1358         spin_lock_irqsave(codec->lock, flags);
1359
1360         /* set bitrate/format */
1361         snd_azf3328_codec_outw(codec, IDX_IO_CODEC_SOUNDFORMAT, val);
1362
1363         /* changing the bitrate/format settings switches off the
1364          * audio output with an annoying click in case of 8/16bit format change
1365          * (maybe shutting down DAC/ADC?), thus immediately
1366          * do some tweaking to reenable it and get rid of the clicking
1367          * (FIXME: yes, it works, but what exactly am I doing here?? :)
1368          * FIXME: does this have some side effects for full-duplex
1369          * or other dramatic side effects? */
1370         /* do it for non-capture codecs only */
1371         if (codec->type != AZF_CODEC_CAPTURE)
1372                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1373                         snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS) |
1374                         DMA_RUN_SOMETHING1 |
1375                         DMA_RUN_SOMETHING2 |
1376                         SOMETHING_ALMOST_ALWAYS_SET |
1377                         DMA_EPILOGUE_SOMETHING |
1378                         DMA_SOMETHING_ELSE
1379                 );
1380
1381         spin_unlock_irqrestore(codec->lock, flags);
1382         snd_azf3328_dbgcallleave();
1383 }
1384
1385 static inline void
1386 snd_azf3328_codec_setfmt_lowpower(struct snd_azf3328_codec_data *codec
1387 )
1388 {
1389         /* choose lowest frequency for low power consumption.
1390          * While this will cause louder noise due to rather coarse frequency,
1391          * it should never matter since output should always
1392          * get disabled properly when idle anyway. */
1393         snd_azf3328_codec_setfmt(codec, AZF_FREQ_4000, 8, 1);
1394 }
1395
1396 static void
1397 snd_azf3328_ctrl_reg_6AH_update(struct snd_azf3328 *chip,
1398                                         unsigned bitmask,
1399                                         bool enable
1400 )
1401 {
1402         bool do_mask = !enable;
1403         if (do_mask)
1404                 chip->shadow_reg_ctrl_6AH |= bitmask;
1405         else
1406                 chip->shadow_reg_ctrl_6AH &= ~bitmask;
1407         snd_azf3328_dbgcodec("6AH_update mask 0x%04x do_mask %d: val 0x%04x\n",
1408                         bitmask, do_mask, chip->shadow_reg_ctrl_6AH);
1409         snd_azf3328_ctrl_outw(chip, IDX_IO_6AH, chip->shadow_reg_ctrl_6AH);
1410 }
1411
1412 static inline void
1413 snd_azf3328_ctrl_enable_codecs(struct snd_azf3328 *chip, bool enable)
1414 {
1415         snd_azf3328_dbgcodec("codec_enable %d\n", enable);
1416         /* no idea what exactly is being done here, but I strongly assume it's
1417          * PM related */
1418         snd_azf3328_ctrl_reg_6AH_update(
1419                 chip, IO_6A_PAUSE_PLAYBACK_BIT8, enable
1420         );
1421 }
1422
1423 static void
1424 snd_azf3328_ctrl_codec_activity(struct snd_azf3328 *chip,
1425                                 enum snd_azf3328_codec_type codec_type,
1426                                 bool enable
1427 )
1428 {
1429         struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
1430         bool need_change = (codec->running != enable);
1431
1432         snd_azf3328_dbgcodec(
1433                 "codec_activity: %s codec, enable %d, need_change %d\n",
1434                                 codec->name, enable, need_change
1435         );
1436         if (need_change) {
1437                 static const struct {
1438                         enum snd_azf3328_codec_type other1;
1439                         enum snd_azf3328_codec_type other2;
1440                 } peer_codecs[3] =
1441                         { { AZF_CODEC_CAPTURE, AZF_CODEC_I2S_OUT },
1442                           { AZF_CODEC_PLAYBACK, AZF_CODEC_I2S_OUT },
1443                           { AZF_CODEC_PLAYBACK, AZF_CODEC_CAPTURE } };
1444                 bool call_function;
1445
1446                 if (enable)
1447                         /* if enable codec, call enable_codecs func
1448                            to enable codec supply... */
1449                         call_function = 1;
1450                 else {
1451                         /* ...otherwise call enable_codecs func
1452                            (which globally shuts down operation of codecs)
1453                            only in case the other codecs are currently
1454                            not active either! */
1455                         call_function =
1456                                 ((!chip->codecs[peer_codecs[codec_type].other1]
1457                                         .running)
1458                              &&  (!chip->codecs[peer_codecs[codec_type].other2]
1459                                         .running));
1460                  }
1461                  if (call_function)
1462                         snd_azf3328_ctrl_enable_codecs(chip, enable);
1463
1464                 /* ...and adjust clock, too
1465                  * (reduce noise and power consumption) */
1466                 if (!enable)
1467                         snd_azf3328_codec_setfmt_lowpower(codec);
1468                 codec->running = enable;
1469         }
1470 }
1471
1472 static void
1473 snd_azf3328_codec_setdmaa(struct snd_azf3328_codec_data *codec,
1474                                 unsigned long addr,
1475                                 unsigned int period_bytes,
1476                                 unsigned int buffer_bytes
1477 )
1478 {
1479         snd_azf3328_dbgcallenter();
1480         WARN_ONCE(period_bytes & 1, "odd period length!?\n");
1481         WARN_ONCE(buffer_bytes != 2 * period_bytes,
1482                  "missed our input expectations! %u vs. %u\n",
1483                  buffer_bytes, period_bytes);
1484         if (!codec->running) {
1485                 /* AZF3328 uses a two buffer pointer DMA transfer approach */
1486
1487                 unsigned long flags;
1488
1489                 /* width 32bit (prevent overflow): */
1490                 u32 area_length;
1491                 struct codec_setup_io {
1492                         u32 dma_start_1;
1493                         u32 dma_start_2;
1494                         u32 dma_lengths;
1495                 } __attribute__((packed)) setup_io;
1496
1497                 area_length = buffer_bytes/2;
1498
1499                 setup_io.dma_start_1 = addr;
1500                 setup_io.dma_start_2 = addr+area_length;
1501
1502                 snd_azf3328_dbgcodec(
1503                         "setdma: buffers %08x[%u] / %08x[%u], %u, %u\n",
1504                                 setup_io.dma_start_1, area_length,
1505                                 setup_io.dma_start_2, area_length,
1506                                 period_bytes, buffer_bytes);
1507
1508                 /* Hmm, are we really supposed to decrement this by 1??
1509                    Most definitely certainly not: configuring full length does
1510                    work properly (i.e. likely better), and BTW we
1511                    violated possibly differing frame sizes with this...
1512
1513                 area_length--; |* max. index *|
1514                 */
1515
1516                 /* build combined I/O buffer length word */
1517                 setup_io.dma_lengths = (area_length << 16) | (area_length);
1518
1519                 spin_lock_irqsave(codec->lock, flags);
1520                 snd_azf3328_codec_outl_multi(
1521                         codec, IDX_IO_CODEC_DMA_START_1, &setup_io, 3
1522                 );
1523                 spin_unlock_irqrestore(codec->lock, flags);
1524         }
1525         snd_azf3328_dbgcallleave();
1526 }
1527
1528 static int
1529 snd_azf3328_pcm_prepare(struct snd_pcm_substream *substream)
1530 {
1531         struct snd_pcm_runtime *runtime = substream->runtime;
1532         struct snd_azf3328_codec_data *codec = runtime->private_data;
1533 #if 0
1534         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
1535         unsigned int count = snd_pcm_lib_period_bytes(substream);
1536 #endif
1537
1538         snd_azf3328_dbgcallenter();
1539
1540         codec->dma_base = runtime->dma_addr;
1541
1542 #if 0
1543         snd_azf3328_codec_setfmt(codec,
1544                 runtime->rate,
1545                 snd_pcm_format_width(runtime->format),
1546                 runtime->channels);
1547         snd_azf3328_codec_setdmaa(codec,
1548                                         runtime->dma_addr, count, size);
1549 #endif
1550         snd_azf3328_dbgcallleave();
1551         return 0;
1552 }
1553
1554 static int
1555 snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1556 {
1557         struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
1558         struct snd_pcm_runtime *runtime = substream->runtime;
1559         struct snd_azf3328_codec_data *codec = runtime->private_data;
1560         int result = 0;
1561         u16 flags1;
1562         bool previously_muted = false;
1563         bool is_main_mixer_playback_codec = (AZF_CODEC_PLAYBACK == codec->type);
1564
1565         snd_azf3328_dbgcalls("snd_azf3328_pcm_trigger cmd %d\n", cmd);
1566
1567         switch (cmd) {
1568         case SNDRV_PCM_TRIGGER_START:
1569                 snd_azf3328_dbgcodec("START %s\n", codec->name);
1570
1571                 if (is_main_mixer_playback_codec) {
1572                         /* mute WaveOut (avoid clicking during setup) */
1573                         previously_muted =
1574                                 snd_azf3328_mixer_mute_control_pcm(
1575                                                 chip, 1
1576                                 );
1577                 }
1578
1579                 snd_azf3328_codec_setfmt(codec,
1580                         runtime->rate,
1581                         snd_pcm_format_width(runtime->format),
1582                         runtime->channels);
1583
1584                 spin_lock(codec->lock);
1585                 /* first, remember current value: */
1586                 flags1 = snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS);
1587
1588                 /* stop transfer */
1589                 flags1 &= ~DMA_RESUME;
1590                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1591
1592                 /* FIXME: clear interrupts or what??? */
1593                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_IRQTYPE, 0xffff);
1594                 spin_unlock(codec->lock);
1595
1596                 snd_azf3328_codec_setdmaa(codec, runtime->dma_addr,
1597                         snd_pcm_lib_period_bytes(substream),
1598                         snd_pcm_lib_buffer_bytes(substream)
1599                 );
1600
1601                 spin_lock(codec->lock);
1602 #ifdef WIN9X
1603                 /* FIXME: enable playback/recording??? */
1604                 flags1 |= DMA_RUN_SOMETHING1 | DMA_RUN_SOMETHING2;
1605                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1606
1607                 /* start transfer again */
1608                 /* FIXME: what is this value (0x0010)??? */
1609                 flags1 |= DMA_RESUME | DMA_EPILOGUE_SOMETHING;
1610                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1611 #else /* NT4 */
1612                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1613                         0x0000);
1614                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1615                         DMA_RUN_SOMETHING1);
1616                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1617                         DMA_RUN_SOMETHING1 |
1618                         DMA_RUN_SOMETHING2);
1619                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1620                         DMA_RESUME |
1621                         SOMETHING_ALMOST_ALWAYS_SET |
1622                         DMA_EPILOGUE_SOMETHING |
1623                         DMA_SOMETHING_ELSE);
1624 #endif
1625                 spin_unlock(codec->lock);
1626                 snd_azf3328_ctrl_codec_activity(chip, codec->type, 1);
1627
1628                 if (is_main_mixer_playback_codec) {
1629                         /* now unmute WaveOut */
1630                         if (!previously_muted)
1631                                 snd_azf3328_mixer_mute_control_pcm(
1632                                                 chip, 0
1633                                 );
1634                 }
1635
1636                 snd_azf3328_dbgcodec("STARTED %s\n", codec->name);
1637                 break;
1638         case SNDRV_PCM_TRIGGER_RESUME:
1639                 snd_azf3328_dbgcodec("RESUME %s\n", codec->name);
1640                 /* resume codec if we were active */
1641                 spin_lock(codec->lock);
1642                 if (codec->running)
1643                         snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1644                                 snd_azf3328_codec_inw(
1645                                         codec, IDX_IO_CODEC_DMA_FLAGS
1646                                 ) | DMA_RESUME
1647                         );
1648                 spin_unlock(codec->lock);
1649                 break;
1650         case SNDRV_PCM_TRIGGER_STOP:
1651                 snd_azf3328_dbgcodec("STOP %s\n", codec->name);
1652
1653                 if (is_main_mixer_playback_codec) {
1654                         /* mute WaveOut (avoid clicking during setup) */
1655                         previously_muted =
1656                                 snd_azf3328_mixer_mute_control_pcm(
1657                                                 chip, 1
1658                                 );
1659                 }
1660
1661                 spin_lock(codec->lock);
1662                 /* first, remember current value: */
1663                 flags1 = snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS);
1664
1665                 /* stop transfer */
1666                 flags1 &= ~DMA_RESUME;
1667                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1668
1669                 /* hmm, is this really required? we're resetting the same bit
1670                  * immediately thereafter... */
1671                 flags1 |= DMA_RUN_SOMETHING1;
1672                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1673
1674                 flags1 &= ~DMA_RUN_SOMETHING1;
1675                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1676                 spin_unlock(codec->lock);
1677                 snd_azf3328_ctrl_codec_activity(chip, codec->type, 0);
1678
1679                 if (is_main_mixer_playback_codec) {
1680                         /* now unmute WaveOut */
1681                         if (!previously_muted)
1682                                 snd_azf3328_mixer_mute_control_pcm(
1683                                                 chip, 0
1684                                 );
1685                 }
1686
1687                 snd_azf3328_dbgcodec("STOPPED %s\n", codec->name);
1688                 break;
1689         case SNDRV_PCM_TRIGGER_SUSPEND:
1690                 snd_azf3328_dbgcodec("SUSPEND %s\n", codec->name);
1691                 /* make sure codec is stopped */
1692                 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1693                         snd_azf3328_codec_inw(
1694                                 codec, IDX_IO_CODEC_DMA_FLAGS
1695                         ) & ~DMA_RESUME
1696                 );
1697                 break;
1698         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1699                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
1700                 break;
1701         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1702                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
1703                 break;
1704         default:
1705                 snd_printk(KERN_ERR "FIXME: unknown trigger mode!\n");
1706                 return -EINVAL;
1707         }
1708
1709         snd_azf3328_dbgcallleave();
1710         return result;
1711 }
1712
1713 static snd_pcm_uframes_t
1714 snd_azf3328_pcm_pointer(struct snd_pcm_substream *substream
1715 )
1716 {
1717         const struct snd_azf3328_codec_data *codec =
1718                 substream->runtime->private_data;
1719         unsigned long result;
1720         snd_pcm_uframes_t frmres;
1721
1722         result = snd_azf3328_codec_inl(codec, IDX_IO_CODEC_DMA_CURRPOS);
1723
1724         /* calculate offset */
1725 #ifdef QUERY_HARDWARE
1726         result -= snd_azf3328_codec_inl(codec, IDX_IO_CODEC_DMA_START_1);
1727 #else
1728         result -= codec->dma_base;
1729 #endif
1730         frmres = bytes_to_frames( substream->runtime, result);
1731         snd_azf3328_dbgcodec("%08li %s @ 0x%8lx, frames %8ld\n",
1732                                 jiffies, codec->name, result, frmres);
1733         return frmres;
1734 }
1735
1736 /******************************************************************/
1737
1738 #ifdef SUPPORT_GAMEPORT
1739 static inline void
1740 snd_azf3328_gameport_irq_enable(struct snd_azf3328 *chip,
1741                                 bool enable
1742 )
1743 {
1744         snd_azf3328_io_reg_setb(
1745                 chip->game_io+IDX_GAME_HWCONFIG,
1746                 GAME_HWCFG_IRQ_ENABLE,
1747                 enable
1748         );
1749 }
1750
1751 static inline void
1752 snd_azf3328_gameport_legacy_address_enable(struct snd_azf3328 *chip,
1753                                            bool enable
1754 )
1755 {
1756         snd_azf3328_io_reg_setb(
1757                 chip->game_io+IDX_GAME_HWCONFIG,
1758                 GAME_HWCFG_LEGACY_ADDRESS_ENABLE,
1759                 enable
1760         );
1761 }
1762
1763 static void
1764 snd_azf3328_gameport_set_counter_frequency(struct snd_azf3328 *chip,
1765                                            unsigned int freq_cfg
1766 )
1767 {
1768         snd_azf3328_io_reg_setb(
1769                 chip->game_io+IDX_GAME_HWCONFIG,
1770                 0x02,
1771                 (freq_cfg & 1) != 0
1772         );
1773         snd_azf3328_io_reg_setb(
1774                 chip->game_io+IDX_GAME_HWCONFIG,
1775                 0x04,
1776                 (freq_cfg & 2) != 0
1777         );
1778 }
1779
1780 static inline void
1781 snd_azf3328_gameport_axis_circuit_enable(struct snd_azf3328 *chip, bool enable)
1782 {
1783         snd_azf3328_ctrl_reg_6AH_update(
1784                 chip, IO_6A_SOMETHING2_GAMEPORT, enable
1785         );
1786 }
1787
1788 static inline void
1789 snd_azf3328_gameport_interrupt(struct snd_azf3328 *chip)
1790 {
1791         /*
1792          * skeleton handler only
1793          * (we do not want axis reading in interrupt handler - too much load!)
1794          */
1795         snd_azf3328_dbggame("gameport irq\n");
1796
1797          /* this should ACK the gameport IRQ properly, hopefully. */
1798         snd_azf3328_game_inw(chip, IDX_GAME_AXIS_VALUE);
1799 }
1800
1801 static int
1802 snd_azf3328_gameport_open(struct gameport *gameport, int mode)
1803 {
1804         struct snd_azf3328 *chip = gameport_get_port_data(gameport);
1805         int res;
1806
1807         snd_azf3328_dbggame("gameport_open, mode %d\n", mode);
1808         switch (mode) {
1809         case GAMEPORT_MODE_COOKED:
1810         case GAMEPORT_MODE_RAW:
1811                 res = 0;
1812                 break;
1813         default:
1814                 res = -1;
1815                 break;
1816         }
1817
1818         snd_azf3328_gameport_set_counter_frequency(chip,
1819                                 GAME_HWCFG_ADC_COUNTER_FREQ_STD);
1820         snd_azf3328_gameport_axis_circuit_enable(chip, (res == 0));
1821
1822         return res;
1823 }
1824
1825 static void
1826 snd_azf3328_gameport_close(struct gameport *gameport)
1827 {
1828         struct snd_azf3328 *chip = gameport_get_port_data(gameport);
1829
1830         snd_azf3328_dbggame("gameport_close\n");
1831         snd_azf3328_gameport_set_counter_frequency(chip,
1832                                 GAME_HWCFG_ADC_COUNTER_FREQ_1_200);
1833         snd_azf3328_gameport_axis_circuit_enable(chip, 0);
1834 }
1835
1836 static int
1837 snd_azf3328_gameport_cooked_read(struct gameport *gameport,
1838                                  int *axes,
1839                                  int *buttons
1840 )
1841 {
1842         struct snd_azf3328 *chip = gameport_get_port_data(gameport);
1843         int i;
1844         u8 val;
1845         unsigned long flags;
1846
1847         if (snd_BUG_ON(!chip))
1848                 return 0;
1849
1850         spin_lock_irqsave(&chip->reg_lock, flags);
1851         val = snd_azf3328_game_inb(chip, IDX_GAME_LEGACY_COMPATIBLE);
1852         *buttons = (~(val) >> 4) & 0xf;
1853
1854         /* ok, this one is a bit dirty: cooked_read is being polled by a timer,
1855          * thus we're atomic and cannot actively wait in here
1856          * (which would be useful for us since it probably would be better
1857          * to trigger a measurement in here, then wait a short amount of
1858          * time until it's finished, then read values of _this_ measurement).
1859          *
1860          * Thus we simply resort to reading values if they're available already
1861          * and trigger the next measurement.
1862          */
1863
1864         val = snd_azf3328_game_inb(chip, IDX_GAME_AXES_CONFIG);
1865         if (val & GAME_AXES_SAMPLING_READY) {
1866                 for (i = 0; i < ARRAY_SIZE(chip->axes); ++i) {
1867                         /* configure the axis to read */
1868                         val = (i << 4) | 0x0f;
1869                         snd_azf3328_game_outb(chip, IDX_GAME_AXES_CONFIG, val);
1870
1871                         chip->axes[i] = snd_azf3328_game_inw(
1872                                                 chip, IDX_GAME_AXIS_VALUE
1873                                         );
1874                 }
1875         }
1876
1877         /* trigger next sampling of axes, to be evaluated the next time we
1878          * enter this function */
1879
1880         /* for some very, very strange reason we cannot enable
1881          * Measurement Ready monitoring for all axes here,
1882          * at least not when only one joystick connected */
1883         val = 0x03; /* we're able to monitor axes 1 and 2 only */
1884         snd_azf3328_game_outb(chip, IDX_GAME_AXES_CONFIG, val);
1885
1886         snd_azf3328_game_outw(chip, IDX_GAME_AXIS_VALUE, 0xffff);
1887         spin_unlock_irqrestore(&chip->reg_lock, flags);
1888
1889         for (i = 0; i < ARRAY_SIZE(chip->axes); i++) {
1890                 axes[i] = chip->axes[i];
1891                 if (axes[i] == 0xffff)
1892                         axes[i] = -1;
1893         }
1894
1895         snd_azf3328_dbggame("cooked_read: axes %d %d %d %d buttons %d\n",
1896                 axes[0], axes[1], axes[2], axes[3], *buttons
1897         );
1898
1899         return 0;
1900 }
1901
1902 static int
1903 snd_azf3328_gameport(struct snd_azf3328 *chip, int dev)
1904 {
1905         struct gameport *gp;
1906
1907         chip->gameport = gp = gameport_allocate_port();
1908         if (!gp) {
1909                 printk(KERN_ERR "azt3328: cannot alloc memory for gameport\n");
1910                 return -ENOMEM;
1911         }
1912
1913         gameport_set_name(gp, "AZF3328 Gameport");
1914         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1915         gameport_set_dev_parent(gp, &chip->pci->dev);
1916         gp->io = chip->game_io;
1917         gameport_set_port_data(gp, chip);
1918
1919         gp->open = snd_azf3328_gameport_open;
1920         gp->close = snd_azf3328_gameport_close;
1921         gp->fuzz = 16; /* seems ok */
1922         gp->cooked_read = snd_azf3328_gameport_cooked_read;
1923
1924         /* DISABLE legacy address: we don't need it! */
1925         snd_azf3328_gameport_legacy_address_enable(chip, 0);
1926
1927         snd_azf3328_gameport_set_counter_frequency(chip,
1928                                 GAME_HWCFG_ADC_COUNTER_FREQ_1_200);
1929         snd_azf3328_gameport_axis_circuit_enable(chip, 0);
1930
1931         gameport_register_port(chip->gameport);
1932
1933         return 0;
1934 }
1935
1936 static void
1937 snd_azf3328_gameport_free(struct snd_azf3328 *chip)
1938 {
1939         if (chip->gameport) {
1940                 gameport_unregister_port(chip->gameport);
1941                 chip->gameport = NULL;
1942         }
1943         snd_azf3328_gameport_irq_enable(chip, 0);
1944 }
1945 #else
1946 static inline int
1947 snd_azf3328_gameport(struct snd_azf3328 *chip, int dev) { return -ENOSYS; }
1948 static inline void
1949 snd_azf3328_gameport_free(struct snd_azf3328 *chip) { }
1950 static inline void
1951 snd_azf3328_gameport_interrupt(struct snd_azf3328 *chip)
1952 {
1953         printk(KERN_WARNING "huh, game port IRQ occurred!?\n");
1954 }
1955 #endif /* SUPPORT_GAMEPORT */
1956
1957 /******************************************************************/
1958
1959 static inline void
1960 snd_azf3328_irq_log_unknown_type(u8 which)
1961 {
1962         snd_azf3328_dbgcodec(
1963         "azt3328: unknown IRQ type (%x) occurred, please report!\n",
1964                 which
1965         );
1966 }
1967
1968 static inline void
1969 snd_azf3328_pcm_interrupt(const struct snd_azf3328_codec_data *first_codec,
1970                           u8 status
1971 )
1972 {
1973         u8 which;
1974         enum snd_azf3328_codec_type codec_type;
1975         const struct snd_azf3328_codec_data *codec = first_codec;
1976
1977         for (codec_type = AZF_CODEC_PLAYBACK;
1978                  codec_type <= AZF_CODEC_I2S_OUT;
1979                          ++codec_type, ++codec) {
1980
1981                 /* skip codec if there's no interrupt for it */
1982                 if (!(status & (1 << codec_type)))
1983                         continue;
1984
1985                 spin_lock(codec->lock);
1986                 which = snd_azf3328_codec_inb(codec, IDX_IO_CODEC_IRQTYPE);
1987                 /* ack all IRQ types immediately */
1988                 snd_azf3328_codec_outb(codec, IDX_IO_CODEC_IRQTYPE, which);
1989                 spin_unlock(codec->lock);
1990
1991                 if (codec->substream) {
1992                         snd_pcm_period_elapsed(codec->substream);
1993                         snd_azf3328_dbgcodec("%s period done (#%x), @ %x\n",
1994                                 codec->name,
1995                                 which,
1996                                 snd_azf3328_codec_inl(
1997                                         codec, IDX_IO_CODEC_DMA_CURRPOS
1998                                 )
1999                         );
2000                 } else
2001                         printk(KERN_WARNING "azt3328: irq handler problem!\n");
2002                 if (which & IRQ_SOMETHING)
2003                         snd_azf3328_irq_log_unknown_type(which);
2004         }
2005 }
2006
2007 static irqreturn_t
2008 snd_azf3328_interrupt(int irq, void *dev_id)
2009 {
2010         struct snd_azf3328 *chip = dev_id;
2011         u8 status;
2012 #if DEBUG_CODEC
2013         static unsigned long irq_count;
2014 #endif
2015
2016         status = snd_azf3328_ctrl_inb(chip, IDX_IO_IRQSTATUS);
2017
2018         /* fast path out, to ease interrupt sharing */
2019         if (!(status &
2020                 (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_I2S_OUT
2021                 |IRQ_GAMEPORT|IRQ_MPU401|IRQ_TIMER)
2022         ))
2023                 return IRQ_NONE; /* must be interrupt for another device */
2024
2025         snd_azf3328_dbgcodec(
2026                 "irq_count %ld! IDX_IO_IRQSTATUS %04x\n",
2027                         irq_count++ /* debug-only */,
2028                         status
2029         );
2030
2031         if (status & IRQ_TIMER) {
2032                 /* snd_azf3328_dbgcodec("timer %ld\n",
2033                         snd_azf3328_codec_inl(chip, IDX_IO_TIMER_VALUE)
2034                                 & TIMER_VALUE_MASK
2035                 ); */
2036                 if (chip->timer)
2037                         snd_timer_interrupt(chip->timer, chip->timer->sticks);
2038                 /* ACK timer */
2039                 spin_lock(&chip->reg_lock);
2040                 snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x07);
2041                 spin_unlock(&chip->reg_lock);
2042                 snd_azf3328_dbgcodec("azt3328: timer IRQ\n");
2043         }
2044
2045         if (status & (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_I2S_OUT))
2046                 snd_azf3328_pcm_interrupt(chip->codecs, status);
2047
2048         if (status & IRQ_GAMEPORT)
2049                 snd_azf3328_gameport_interrupt(chip);
2050
2051         /* MPU401 has less critical IRQ requirements
2052          * than timer and playback/recording, right? */
2053         if (status & IRQ_MPU401) {
2054                 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
2055
2056                 /* hmm, do we have to ack the IRQ here somehow?
2057                  * If so, then I don't know how yet... */
2058                 snd_azf3328_dbgcodec("azt3328: MPU401 IRQ\n");
2059         }
2060         return IRQ_HANDLED;
2061 }
2062
2063 /*****************************************************************/
2064
2065 /* as long as we think we have identical snd_pcm_hardware parameters
2066    for playback, capture and i2s out, we can use the same physical struct
2067    since the struct is simply being copied into a member.
2068 */
2069 static const struct snd_pcm_hardware snd_azf3328_hardware =
2070 {
2071         /* FIXME!! Correct? */
2072         .info =                 SNDRV_PCM_INFO_MMAP |
2073                                 SNDRV_PCM_INFO_INTERLEAVED |
2074                                 SNDRV_PCM_INFO_MMAP_VALID,
2075         .formats =              SNDRV_PCM_FMTBIT_S8 |
2076                                 SNDRV_PCM_FMTBIT_U8 |
2077                                 SNDRV_PCM_FMTBIT_S16_LE |
2078                                 SNDRV_PCM_FMTBIT_U16_LE,
2079         .rates =                SNDRV_PCM_RATE_5512 |
2080                                 SNDRV_PCM_RATE_8000_48000 |
2081                                 SNDRV_PCM_RATE_KNOT,
2082         .rate_min =             AZF_FREQ_4000,
2083         .rate_max =             AZF_FREQ_66200,
2084         .channels_min =         1,
2085         .channels_max =         2,
2086         .buffer_bytes_max =     (64*1024),
2087         .period_bytes_min =     1024,
2088         .period_bytes_max =     (32*1024),
2089         /* We simply have two DMA areas (instead of a list of descriptors
2090            such as other cards); I believe that this is a fixed hardware
2091            attribute and there isn't much driver magic to be done to expand it.
2092            Thus indicate that we have at least and at most 2 periods. */
2093         .periods_min =          2,
2094         .periods_max =          2,
2095         /* FIXME: maybe that card actually has a FIFO?
2096          * Hmm, it seems newer revisions do have one, but we still don't know
2097          * its size... */
2098         .fifo_size =            0,
2099 };
2100
2101
2102 static unsigned int snd_azf3328_fixed_rates[] = {
2103         AZF_FREQ_4000,
2104         AZF_FREQ_4800,
2105         AZF_FREQ_5512,
2106         AZF_FREQ_6620,
2107         AZF_FREQ_8000,
2108         AZF_FREQ_9600,
2109         AZF_FREQ_11025,
2110         AZF_FREQ_13240,
2111         AZF_FREQ_16000,
2112         AZF_FREQ_22050,
2113         AZF_FREQ_32000,
2114         AZF_FREQ_44100,
2115         AZF_FREQ_48000,
2116         AZF_FREQ_66200
2117 };
2118
2119 static struct snd_pcm_hw_constraint_list snd_azf3328_hw_constraints_rates = {
2120         .count = ARRAY_SIZE(snd_azf3328_fixed_rates),
2121         .list = snd_azf3328_fixed_rates,
2122         .mask = 0,
2123 };
2124
2125 /*****************************************************************/
2126
2127 static int
2128 snd_azf3328_pcm_open(struct snd_pcm_substream *substream,
2129                      enum snd_azf3328_codec_type codec_type
2130 )
2131 {
2132         struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
2133         struct snd_pcm_runtime *runtime = substream->runtime;
2134         struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
2135
2136         snd_azf3328_dbgcallenter();
2137         codec->substream = substream;
2138
2139         /* same parameters for all our codecs - at least we think so... */
2140         runtime->hw = snd_azf3328_hardware;
2141
2142         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
2143                                    &snd_azf3328_hw_constraints_rates);
2144         runtime->private_data = codec;
2145         snd_azf3328_dbgcallleave();
2146         return 0;
2147 }
2148
2149 static int
2150 snd_azf3328_pcm_playback_open(struct snd_pcm_substream *substream)
2151 {
2152         return snd_azf3328_pcm_open(substream, AZF_CODEC_PLAYBACK);
2153 }
2154
2155 static int
2156 snd_azf3328_pcm_capture_open(struct snd_pcm_substream *substream)
2157 {
2158         return snd_azf3328_pcm_open(substream, AZF_CODEC_CAPTURE);
2159 }
2160
2161 static int
2162 snd_azf3328_pcm_i2s_out_open(struct snd_pcm_substream *substream)
2163 {
2164         return snd_azf3328_pcm_open(substream, AZF_CODEC_I2S_OUT);
2165 }
2166
2167 static int
2168 snd_azf3328_pcm_close(struct snd_pcm_substream *substream
2169 )
2170 {
2171         struct snd_azf3328_codec_data *codec =
2172                 substream->runtime->private_data;
2173
2174         snd_azf3328_dbgcallenter();
2175         codec->substream = NULL;
2176         snd_azf3328_dbgcallleave();
2177         return 0;
2178 }
2179
2180 /******************************************************************/
2181
2182 static struct snd_pcm_ops snd_azf3328_playback_ops = {
2183         .open =         snd_azf3328_pcm_playback_open,
2184         .close =        snd_azf3328_pcm_close,
2185         .ioctl =        snd_pcm_lib_ioctl,
2186         .hw_params =    snd_azf3328_hw_params,
2187         .hw_free =      snd_azf3328_hw_free,
2188         .prepare =      snd_azf3328_pcm_prepare,
2189         .trigger =      snd_azf3328_pcm_trigger,
2190         .pointer =      snd_azf3328_pcm_pointer
2191 };
2192
2193 static struct snd_pcm_ops snd_azf3328_capture_ops = {
2194         .open =         snd_azf3328_pcm_capture_open,
2195         .close =        snd_azf3328_pcm_close,
2196         .ioctl =        snd_pcm_lib_ioctl,
2197         .hw_params =    snd_azf3328_hw_params,
2198         .hw_free =      snd_azf3328_hw_free,
2199         .prepare =      snd_azf3328_pcm_prepare,
2200         .trigger =      snd_azf3328_pcm_trigger,
2201         .pointer =      snd_azf3328_pcm_pointer
2202 };
2203
2204 static struct snd_pcm_ops snd_azf3328_i2s_out_ops = {
2205         .open =         snd_azf3328_pcm_i2s_out_open,
2206         .close =        snd_azf3328_pcm_close,
2207         .ioctl =        snd_pcm_lib_ioctl,
2208         .hw_params =    snd_azf3328_hw_params,
2209         .hw_free =      snd_azf3328_hw_free,
2210         .prepare =      snd_azf3328_pcm_prepare,
2211         .trigger =      snd_azf3328_pcm_trigger,
2212         .pointer =      snd_azf3328_pcm_pointer
2213 };
2214
2215 static int
2216 snd_azf3328_pcm(struct snd_azf3328 *chip)
2217 {
2218 enum { AZF_PCMDEV_STD, AZF_PCMDEV_I2S_OUT, NUM_AZF_PCMDEVS }; /* pcm devices */
2219
2220         struct snd_pcm *pcm;
2221         int err;
2222
2223         snd_azf3328_dbgcallenter();
2224
2225         err = snd_pcm_new(chip->card, "AZF3328 DSP", AZF_PCMDEV_STD,
2226                                                                 1, 1, &pcm);
2227         if (err < 0)
2228                 return err;
2229         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
2230                                                 &snd_azf3328_playback_ops);
2231         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
2232                                                 &snd_azf3328_capture_ops);
2233
2234         pcm->private_data = chip;
2235         pcm->info_flags = 0;
2236         strcpy(pcm->name, chip->card->shortname);
2237         /* same pcm object for playback/capture (see snd_pcm_new() above) */
2238         chip->pcm[AZF_CODEC_PLAYBACK] = pcm;
2239         chip->pcm[AZF_CODEC_CAPTURE] = pcm;
2240
2241         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
2242                                                 snd_dma_pci_data(chip->pci),
2243                                                         64*1024, 64*1024);
2244
2245         err = snd_pcm_new(chip->card, "AZF3328 I2S OUT", AZF_PCMDEV_I2S_OUT,
2246                                                                 1, 0, &pcm);
2247         if (err < 0)
2248                 return err;
2249         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
2250                                                 &snd_azf3328_i2s_out_ops);
2251
2252         pcm->private_data = chip;
2253         pcm->info_flags = 0;
2254         strcpy(pcm->name, chip->card->shortname);
2255         chip->pcm[AZF_CODEC_I2S_OUT] = pcm;
2256
2257         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
2258                                                 snd_dma_pci_data(chip->pci),
2259                                                         64*1024, 64*1024);
2260
2261         snd_azf3328_dbgcallleave();
2262         return 0;
2263 }
2264
2265 /******************************************************************/
2266
2267 /*** NOTE: the physical timer resolution actually is 1024000 ticks per second
2268  *** (probably derived from main crystal via a divider of 24),
2269  *** but announcing those attributes to user-space would make programs
2270  *** configure the timer to a 1 tick value, resulting in an absolutely fatal
2271  *** timer IRQ storm.
2272  *** Thus I chose to announce a down-scaled virtual timer to the outside and
2273  *** calculate real timer countdown values internally.
2274  *** (the scale factor can be set via module parameter "seqtimer_scaling").
2275  ***/
2276
2277 static int
2278 snd_azf3328_timer_start(struct snd_timer *timer)
2279 {
2280         struct snd_azf3328 *chip;
2281         unsigned long flags;
2282         unsigned int delay;
2283
2284         snd_azf3328_dbgcallenter();
2285         chip = snd_timer_chip(timer);
2286         delay = ((timer->sticks * seqtimer_scaling) - 1) & TIMER_VALUE_MASK;
2287         if (delay < 49) {
2288                 /* uhoh, that's not good, since user-space won't know about
2289                  * this timing tweak
2290                  * (we need to do it to avoid a lockup, though) */
2291
2292                 snd_azf3328_dbgtimer("delay was too low (%d)!\n", delay);
2293                 delay = 49; /* minimum time is 49 ticks */
2294         }
2295         snd_azf3328_dbgtimer("setting timer countdown value %d\n", delay);
2296         delay |= TIMER_COUNTDOWN_ENABLE | TIMER_IRQ_ENABLE;
2297         spin_lock_irqsave(&chip->reg_lock, flags);
2298         snd_azf3328_ctrl_outl(chip, IDX_IO_TIMER_VALUE, delay);
2299         spin_unlock_irqrestore(&chip->reg_lock, flags);
2300         snd_azf3328_dbgcallleave();
2301         return 0;
2302 }
2303
2304 static int
2305 snd_azf3328_timer_stop(struct snd_timer *timer)
2306 {
2307         struct snd_azf3328 *chip;
2308         unsigned long flags;
2309
2310         snd_azf3328_dbgcallenter();
2311         chip = snd_timer_chip(timer);
2312         spin_lock_irqsave(&chip->reg_lock, flags);
2313         /* disable timer countdown and interrupt */
2314         /* Hmm, should we write TIMER_IRQ_ACK here?
2315            YES indeed, otherwise a rogue timer operation - which prompts
2316            ALSA(?) to call repeated stop() in vain, but NOT start() -
2317            will never end (value 0x03 is kept shown in control byte).
2318            Simply manually poking 0x04 _once_ immediately successfully stops
2319            the hardware/ALSA interrupt activity. */
2320         snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x04);
2321         spin_unlock_irqrestore(&chip->reg_lock, flags);
2322         snd_azf3328_dbgcallleave();
2323         return 0;
2324 }
2325
2326
2327 static int
2328 snd_azf3328_timer_precise_resolution(struct snd_timer *timer,
2329                                                unsigned long *num, unsigned long *den)
2330 {
2331         snd_azf3328_dbgcallenter();
2332         *num = 1;
2333         *den = 1024000 / seqtimer_scaling;
2334         snd_azf3328_dbgcallleave();
2335         return 0;
2336 }
2337
2338 static struct snd_timer_hardware snd_azf3328_timer_hw = {
2339         .flags = SNDRV_TIMER_HW_AUTO,
2340         .resolution = 977, /* 1000000/1024000 = 0.9765625us */
2341         .ticks = 1024000, /* max tick count, defined by the value register; actually it's not 1024000, but 1048576, but we don't care */
2342         .start = snd_azf3328_timer_start,
2343         .stop = snd_azf3328_timer_stop,
2344         .precise_resolution = snd_azf3328_timer_precise_resolution,
2345 };
2346
2347 static int
2348 snd_azf3328_timer(struct snd_azf3328 *chip, int device)
2349 {
2350         struct snd_timer *timer = NULL;
2351         struct snd_timer_id tid;
2352         int err;
2353
2354         snd_azf3328_dbgcallenter();
2355         tid.dev_class = SNDRV_TIMER_CLASS_CARD;
2356         tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
2357         tid.card = chip->card->number;
2358         tid.device = device;
2359         tid.subdevice = 0;
2360
2361         snd_azf3328_timer_hw.resolution *= seqtimer_scaling;
2362         snd_azf3328_timer_hw.ticks /= seqtimer_scaling;
2363
2364         err = snd_timer_new(chip->card, "AZF3328", &tid, &timer);
2365         if (err < 0)
2366                 goto out;
2367
2368         strcpy(timer->name, "AZF3328 timer");
2369         timer->private_data = chip;
2370         timer->hw = snd_azf3328_timer_hw;
2371
2372         chip->timer = timer;
2373
2374         snd_azf3328_timer_stop(timer);
2375
2376         err = 0;
2377
2378 out:
2379         snd_azf3328_dbgcallleave();
2380         return err;
2381 }
2382
2383 /******************************************************************/
2384
2385 static int
2386 snd_azf3328_free(struct snd_azf3328 *chip)
2387 {
2388         if (chip->irq < 0)
2389                 goto __end_hw;
2390
2391         snd_azf3328_mixer_reset(chip);
2392
2393         snd_azf3328_timer_stop(chip->timer);
2394         snd_azf3328_gameport_free(chip);
2395
2396         if (chip->irq >= 0)
2397                 synchronize_irq(chip->irq);
2398 __end_hw:
2399         if (chip->irq >= 0)
2400                 free_irq(chip->irq, chip);
2401         pci_release_regions(chip->pci);
2402         pci_disable_device(chip->pci);
2403
2404         kfree(chip);
2405         return 0;
2406 }
2407
2408 static int
2409 snd_azf3328_dev_free(struct snd_device *device)
2410 {
2411         struct snd_azf3328 *chip = device->device_data;
2412         return snd_azf3328_free(chip);
2413 }
2414
2415 #if 0
2416 /* check whether a bit can be modified */
2417 static void
2418 snd_azf3328_test_bit(unsigned unsigned reg, int bit)
2419 {
2420         unsigned char val, valoff, valon;
2421
2422         val = inb(reg);
2423
2424         outb(val & ~(1 << bit), reg);
2425         valoff = inb(reg);
2426
2427         outb(val|(1 << bit), reg);
2428         valon = inb(reg);
2429
2430         outb(val, reg);
2431
2432         printk(KERN_DEBUG "reg %04x bit %d: %02x %02x %02x\n",
2433                                 reg, bit, val, valoff, valon
2434         );
2435 }
2436 #endif
2437
2438 static inline void
2439 snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip)
2440 {
2441 #if DEBUG_MISC
2442         u16 tmp;
2443
2444         snd_azf3328_dbgmisc(
2445                 "ctrl_io 0x%lx, game_io 0x%lx, mpu_io 0x%lx, "
2446                 "opl3_io 0x%lx, mixer_io 0x%lx, irq %d\n",
2447                 chip->ctrl_io, chip->game_io, chip->mpu_io,
2448                 chip->opl3_io, chip->mixer_io, chip->irq
2449         );
2450
2451         snd_azf3328_dbgmisc("game %02x %02x %02x %02x %02x %02x\n",
2452                 snd_azf3328_game_inb(chip, 0),
2453                 snd_azf3328_game_inb(chip, 1),
2454                 snd_azf3328_game_inb(chip, 2),
2455                 snd_azf3328_game_inb(chip, 3),
2456                 snd_azf3328_game_inb(chip, 4),
2457                 snd_azf3328_game_inb(chip, 5)
2458         );
2459
2460         for (tmp = 0; tmp < 0x07; tmp += 1)
2461                 snd_azf3328_dbgmisc("mpu_io 0x%04x\n", inb(chip->mpu_io + tmp));
2462
2463         for (tmp = 0; tmp <= 0x07; tmp += 1)
2464                 snd_azf3328_dbgmisc("0x%02x: game200 0x%04x, game208 0x%04x\n",
2465                         tmp, inb(0x200 + tmp), inb(0x208 + tmp));
2466
2467         for (tmp = 0; tmp <= 0x01; tmp += 1)
2468                 snd_azf3328_dbgmisc(
2469                         "0x%02x: mpu300 0x%04x, mpu310 0x%04x, mpu320 0x%04x, "
2470                         "mpu330 0x%04x opl388 0x%04x opl38c 0x%04x\n",
2471                                 tmp,
2472                                 inb(0x300 + tmp),
2473                                 inb(0x310 + tmp),
2474                                 inb(0x320 + tmp),
2475                                 inb(0x330 + tmp),
2476                                 inb(0x388 + tmp),
2477                                 inb(0x38c + tmp)
2478                 );
2479
2480         for (tmp = 0; tmp < AZF_IO_SIZE_CTRL; tmp += 2)
2481                 snd_azf3328_dbgmisc("ctrl 0x%02x: 0x%04x\n",
2482                         tmp, snd_azf3328_ctrl_inw(chip, tmp)
2483                 );
2484
2485         for (tmp = 0; tmp < AZF_IO_SIZE_MIXER; tmp += 2)
2486                 snd_azf3328_dbgmisc("mixer 0x%02x: 0x%04x\n",
2487                         tmp, snd_azf3328_mixer_inw(chip, tmp)
2488                 );
2489 #endif /* DEBUG_MISC */
2490 }
2491
2492 static int
2493 snd_azf3328_create(struct snd_card *card,
2494                    struct pci_dev *pci,
2495                    unsigned long device_type,
2496                    struct snd_azf3328 **rchip)
2497 {
2498         struct snd_azf3328 *chip;
2499         int err;
2500         static struct snd_device_ops ops = {
2501                 .dev_free =     snd_azf3328_dev_free,
2502         };
2503         u8 dma_init;
2504         enum snd_azf3328_codec_type codec_type;
2505         struct snd_azf3328_codec_data *codec_setup;
2506
2507         *rchip = NULL;
2508
2509         err = pci_enable_device(pci);
2510         if (err < 0)
2511                 return err;
2512
2513         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
2514         if (chip == NULL) {
2515                 err = -ENOMEM;
2516                 goto out_err;
2517         }
2518         spin_lock_init(&chip->reg_lock);
2519         chip->card = card;
2520         chip->pci = pci;
2521         chip->irq = -1;
2522
2523         /* check if we can restrict PCI DMA transfers to 24 bits */
2524         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
2525             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
2526                 snd_printk(KERN_ERR "architecture does not support "
2527                                         "24bit PCI busmaster DMA\n"
2528                 );
2529                 err = -ENXIO;
2530                 goto out_err;
2531         }
2532
2533         err = pci_request_regions(pci, "Aztech AZF3328");
2534         if (err < 0)
2535                 goto out_err;
2536
2537         chip->ctrl_io  = pci_resource_start(pci, 0);
2538         chip->game_io  = pci_resource_start(pci, 1);
2539         chip->mpu_io   = pci_resource_start(pci, 2);
2540         chip->opl3_io  = pci_resource_start(pci, 3);
2541         chip->mixer_io = pci_resource_start(pci, 4);
2542
2543         codec_setup = &chip->codecs[AZF_CODEC_PLAYBACK];
2544         codec_setup->io_base = chip->ctrl_io + AZF_IO_OFFS_CODEC_PLAYBACK;
2545         codec_setup->lock = &chip->reg_lock;
2546         codec_setup->type = AZF_CODEC_PLAYBACK;
2547         codec_setup->name = "PLAYBACK";
2548
2549         codec_setup = &chip->codecs[AZF_CODEC_CAPTURE];
2550         codec_setup->io_base = chip->ctrl_io + AZF_IO_OFFS_CODEC_CAPTURE;
2551         codec_setup->lock = &chip->reg_lock;
2552         codec_setup->type = AZF_CODEC_CAPTURE;
2553         codec_setup->name = "CAPTURE";
2554
2555         codec_setup = &chip->codecs[AZF_CODEC_I2S_OUT];
2556         codec_setup->io_base = chip->ctrl_io + AZF_IO_OFFS_CODEC_I2S_OUT;
2557         codec_setup->lock = &chip->reg_lock;
2558         codec_setup->type = AZF_CODEC_I2S_OUT;
2559         codec_setup->name = "I2S_OUT";
2560
2561         if (request_irq(pci->irq, snd_azf3328_interrupt,
2562                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
2563                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
2564                 err = -EBUSY;
2565                 goto out_err;
2566         }
2567         chip->irq = pci->irq;
2568         pci_set_master(pci);
2569         synchronize_irq(chip->irq);
2570
2571         snd_azf3328_debug_show_ports(chip);
2572
2573         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
2574         if (err < 0)
2575                 goto out_err;
2576
2577         /* create mixer interface & switches */
2578         err = snd_azf3328_mixer_new(chip);
2579         if (err < 0)
2580                 goto out_err;
2581
2582         /* standard codec init stuff */
2583                 /* default DMA init value */
2584         dma_init = DMA_RUN_SOMETHING2|DMA_EPILOGUE_SOMETHING|DMA_SOMETHING_ELSE;
2585
2586         for (codec_type = AZF_CODEC_PLAYBACK;
2587                 codec_type <= AZF_CODEC_I2S_OUT; ++codec_type) {
2588                 struct snd_azf3328_codec_data *codec =
2589                          &chip->codecs[codec_type];
2590
2591                 /* shutdown codecs to reduce power / noise */
2592                         /* have ...ctrl_codec_activity() act properly */
2593                 codec->running = 1;
2594                 snd_azf3328_ctrl_codec_activity(chip, codec_type, 0);
2595
2596                 spin_lock_irq(codec->lock);
2597                 snd_azf3328_codec_outb(codec, IDX_IO_CODEC_DMA_FLAGS,
2598                                                  dma_init);
2599                 spin_unlock_irq(codec->lock);
2600         }
2601
2602         snd_card_set_dev(card, &pci->dev);
2603
2604         *rchip = chip;
2605
2606         err = 0;
2607         goto out;
2608
2609 out_err:
2610         if (chip)
2611                 snd_azf3328_free(chip);
2612         pci_disable_device(pci);
2613
2614 out:
2615         return err;
2616 }
2617
2618 static int
2619 snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
2620 {
2621         static int dev;
2622         struct snd_card *card;
2623         struct snd_azf3328 *chip;
2624         struct snd_opl3 *opl3;
2625         int err;
2626
2627         snd_azf3328_dbgcallenter();
2628         if (dev >= SNDRV_CARDS) {
2629                 err = -ENODEV;
2630                 goto out;
2631         }
2632         if (!enable[dev]) {
2633                 dev++;
2634                 err = -ENOENT;
2635                 goto out;
2636         }
2637
2638         err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
2639         if (err < 0)
2640                 goto out;
2641
2642         strcpy(card->driver, "AZF3328");
2643         strcpy(card->shortname, "Aztech AZF3328 (PCI168)");
2644
2645         err = snd_azf3328_create(card, pci, pci_id->driver_data, &chip);
2646         if (err < 0)
2647                 goto out_err;
2648
2649         card->private_data = chip;
2650
2651         /* chose to use MPU401_HW_AZT2320 ID instead of MPU401_HW_MPU401,
2652            since our hardware ought to be similar, thus use same ID. */
2653         err = snd_mpu401_uart_new(
2654                 card, 0,
2655                 MPU401_HW_AZT2320, chip->mpu_io,
2656                 MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK,
2657                 -1, &chip->rmidi
2658         );
2659         if (err < 0) {
2660                 snd_printk(KERN_ERR "azf3328: no MPU-401 device at 0x%lx?\n",
2661                                 chip->mpu_io
2662                 );
2663                 goto out_err;
2664         }
2665
2666         err = snd_azf3328_timer(chip, 0);
2667         if (err < 0)
2668                 goto out_err;
2669
2670         err = snd_azf3328_pcm(chip);
2671         if (err < 0)
2672                 goto out_err;
2673
2674         if (snd_opl3_create(card, chip->opl3_io, chip->opl3_io+2,
2675                             OPL3_HW_AUTO, 1, &opl3) < 0) {
2676                 snd_printk(KERN_ERR "azf3328: no OPL3 device at 0x%lx-0x%lx?\n",
2677                            chip->opl3_io, chip->opl3_io+2
2678                 );
2679         } else {
2680                 /* need to use IDs 1, 2 since ID 0 is snd_azf3328_timer above */
2681                 err = snd_opl3_timer_new(opl3, 1, 2);
2682                 if (err < 0)
2683                         goto out_err;
2684                 err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
2685                 if (err < 0)
2686                         goto out_err;
2687                 opl3->private_data = chip;
2688         }
2689
2690         sprintf(card->longname, "%s at 0x%lx, irq %i",
2691                 card->shortname, chip->ctrl_io, chip->irq);
2692
2693         err = snd_card_register(card);
2694         if (err < 0)
2695                 goto out_err;
2696
2697 #ifdef MODULE
2698         printk(KERN_INFO
2699 "azt3328: Sound driver for Aztech AZF3328-based soundcards such as PCI168.\n"
2700 "azt3328: Hardware was completely undocumented, unfortunately.\n"
2701 "azt3328: Feel free to contact andi AT lisas.de for bug reports etc.!\n"
2702 "azt3328: User-scalable sequencer timer set to %dHz (1024000Hz / %d).\n",
2703         1024000 / seqtimer_scaling, seqtimer_scaling);
2704 #endif
2705
2706         snd_azf3328_gameport(chip, dev);
2707
2708         pci_set_drvdata(pci, card);
2709         dev++;
2710
2711         err = 0;
2712         goto out;
2713
2714 out_err:
2715         snd_printk(KERN_ERR "azf3328: something failed, exiting\n");
2716         snd_card_free(card);
2717
2718 out:
2719         snd_azf3328_dbgcallleave();
2720         return err;
2721 }
2722
2723 static void
2724 snd_azf3328_remove(struct pci_dev *pci)
2725 {
2726         snd_azf3328_dbgcallenter();
2727         snd_card_free(pci_get_drvdata(pci));
2728         snd_azf3328_dbgcallleave();
2729 }
2730
2731 #ifdef CONFIG_PM_SLEEP
2732 static inline void
2733 snd_azf3328_suspend_regs(unsigned long io_addr, unsigned count, u32 *saved_regs)
2734 {
2735         unsigned reg;
2736
2737         for (reg = 0; reg < count; ++reg) {
2738                 *saved_regs = inl(io_addr);
2739                 snd_azf3328_dbgpm("suspend: io 0x%04lx: 0x%08x\n",
2740                         io_addr, *saved_regs);
2741                 ++saved_regs;
2742                 io_addr += sizeof(*saved_regs);
2743         }
2744 }
2745
2746 static inline void
2747 snd_azf3328_resume_regs(const u32 *saved_regs,
2748                         unsigned long io_addr,
2749                         unsigned count
2750 )
2751 {
2752         unsigned reg;
2753
2754         for (reg = 0; reg < count; ++reg) {
2755                 outl(*saved_regs, io_addr);
2756                 snd_azf3328_dbgpm("resume: io 0x%04lx: 0x%08x --> 0x%08x\n",
2757                         io_addr, *saved_regs, inl(io_addr));
2758                 ++saved_regs;
2759                 io_addr += sizeof(*saved_regs);
2760         }
2761 }
2762
2763 static inline void
2764 snd_azf3328_suspend_ac97(struct snd_azf3328 *chip)
2765 {
2766 #ifdef AZF_USE_AC97_LAYER
2767         snd_ac97_suspend(chip->ac97);
2768 #else
2769         snd_azf3328_suspend_regs(chip->mixer_io,
2770                 ARRAY_SIZE(chip->saved_regs_mixer), chip->saved_regs_mixer);
2771
2772         /* make sure to disable master volume etc. to prevent looping sound */
2773         snd_azf3328_mixer_mute_control_master(chip, 1);
2774         snd_azf3328_mixer_mute_control_pcm(chip, 1);
2775 #endif /* AZF_USE_AC97_LAYER */
2776 }
2777
2778 static inline void
2779 snd_azf3328_resume_ac97(const struct snd_azf3328 *chip)
2780 {
2781 #ifdef AZF_USE_AC97_LAYER
2782         snd_ac97_resume(chip->ac97);
2783 #else
2784         snd_azf3328_resume_regs(chip->saved_regs_mixer, chip->mixer_io,
2785                                         ARRAY_SIZE(chip->saved_regs_mixer));
2786
2787         /* unfortunately with 32bit transfers, IDX_MIXER_PLAY_MASTER (0x02)
2788            and IDX_MIXER_RESET (offset 0x00) get touched at the same time,
2789            resulting in a mixer reset condition persisting until _after_
2790            master vol was restored. Thus master vol needs an extra restore. */
2791         outw(((u16 *)chip->saved_regs_mixer)[1], chip->mixer_io + 2);
2792 #endif /* AZF_USE_AC97_LAYER */
2793 }
2794
2795 static int
2796 snd_azf3328_suspend(struct device *dev)
2797 {
2798         struct pci_dev *pci = to_pci_dev(dev);
2799         struct snd_card *card = dev_get_drvdata(dev);
2800         struct snd_azf3328 *chip = card->private_data;
2801         u16 *saved_regs_ctrl_u16;
2802
2803         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
2804
2805         /* same pcm object for playback/capture */
2806         snd_pcm_suspend_all(chip->pcm[AZF_CODEC_PLAYBACK]);
2807         snd_pcm_suspend_all(chip->pcm[AZF_CODEC_I2S_OUT]);
2808
2809         snd_azf3328_suspend_ac97(chip);
2810
2811         snd_azf3328_suspend_regs(chip->ctrl_io,
2812                 ARRAY_SIZE(chip->saved_regs_ctrl), chip->saved_regs_ctrl);
2813
2814         /* manually store the one currently relevant write-only reg, too */
2815         saved_regs_ctrl_u16 = (u16 *)chip->saved_regs_ctrl;
2816         saved_regs_ctrl_u16[IDX_IO_6AH / 2] = chip->shadow_reg_ctrl_6AH;
2817
2818         snd_azf3328_suspend_regs(chip->game_io,
2819                 ARRAY_SIZE(chip->saved_regs_game), chip->saved_regs_game);
2820         snd_azf3328_suspend_regs(chip->mpu_io,
2821                 ARRAY_SIZE(chip->saved_regs_mpu), chip->saved_regs_mpu);
2822         snd_azf3328_suspend_regs(chip->opl3_io,
2823                 ARRAY_SIZE(chip->saved_regs_opl3), chip->saved_regs_opl3);
2824
2825         pci_disable_device(pci);
2826         pci_save_state(pci);
2827         pci_set_power_state(pci, PCI_D3hot);
2828         return 0;
2829 }
2830
2831 static int
2832 snd_azf3328_resume(struct device *dev)
2833 {
2834         struct pci_dev *pci = to_pci_dev(dev);
2835         struct snd_card *card = dev_get_drvdata(dev);
2836         const struct snd_azf3328 *chip = card->private_data;
2837
2838         pci_set_power_state(pci, PCI_D0);
2839         pci_restore_state(pci);
2840         if (pci_enable_device(pci) < 0) {
2841                 printk(KERN_ERR "azt3328: pci_enable_device failed, "
2842                        "disabling device\n");
2843                 snd_card_disconnect(card);
2844                 return -EIO;
2845         }
2846         pci_set_master(pci);
2847
2848         snd_azf3328_resume_regs(chip->saved_regs_game, chip->game_io,
2849                                         ARRAY_SIZE(chip->saved_regs_game));
2850         snd_azf3328_resume_regs(chip->saved_regs_mpu, chip->mpu_io,
2851                                         ARRAY_SIZE(chip->saved_regs_mpu));
2852         snd_azf3328_resume_regs(chip->saved_regs_opl3, chip->opl3_io,
2853                                         ARRAY_SIZE(chip->saved_regs_opl3));
2854
2855         snd_azf3328_resume_ac97(chip);
2856
2857         snd_azf3328_resume_regs(chip->saved_regs_ctrl, chip->ctrl_io,
2858                                         ARRAY_SIZE(chip->saved_regs_ctrl));
2859
2860         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
2861         return 0;
2862 }
2863
2864 static SIMPLE_DEV_PM_OPS(snd_azf3328_pm, snd_azf3328_suspend, snd_azf3328_resume);
2865 #define SND_AZF3328_PM_OPS      &snd_azf3328_pm
2866 #else
2867 #define SND_AZF3328_PM_OPS      NULL
2868 #endif /* CONFIG_PM_SLEEP */
2869
2870 static struct pci_driver azf3328_driver = {
2871         .name = KBUILD_MODNAME,
2872         .id_table = snd_azf3328_ids,
2873         .probe = snd_azf3328_probe,
2874         .remove = snd_azf3328_remove,
2875         .driver = {
2876                 .pm = SND_AZF3328_PM_OPS,
2877         },
2878 };
2879
2880 module_pci_driver(azf3328_driver);