sound/pci/es1968.c

   1 /*
   2  *  Driver for ESS Maestro 1/2/2E Sound Card (started 21.8.99)
   3  *  Copyright (c) by Matze Braun <MatzeBraun@gmx.de>.
   4  *                   Takashi Iwai <tiwai@suse.de>
   5  *
   6  *  Most of the driver code comes from Zach Brown(zab@redhat.com)
   7  *      Alan Cox OSS Driver
   8  *  Rewritted from card-es1938.c source.
   9  *
  10  *  TODO:
  11  *   Perhaps Synth
  12  *
  13  *   This program is free software; you can redistribute it and/or modify
  14  *   it under the terms of the GNU General Public License as published by
  15  *   the Free Software Foundation; either version 2 of the License, or
  16  *   (at your option) any later version.
  17  *
  18  *   This program is distributed in the hope that it will be useful,
  19  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *   GNU General Public License for more details.
  22  *
  23  *   You should have received a copy of the GNU General Public License
  24  *   along with this program; if not, write to the Free Software
  25  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26  *
  27  *
  28  *  Notes from Zach Brown about the driver code
  29  *
  30  *  Hardware Description
  31  *
  32  *      A working Maestro setup contains the Maestro chip wired to a
  33  *      codec or 2.  In the Maestro we have the APUs, the ASSP, and the
  34  *      Wavecache.  The APUs can be though of as virtual audio routing
  35  *      channels.  They can take data from a number of sources and perform
  36  *      basic encodings of the data.  The wavecache is a storehouse for
  37  *      PCM data.  Typically it deals with PCI and interracts with the
  38  *      APUs.  The ASSP is a wacky DSP like device that ESS is loth
  39  *      to release docs on.  Thankfully it isn't required on the Maestro
  40  *      until you start doing insane things like FM emulation and surround
  41  *      encoding.  The codecs are almost always AC-97 compliant codecs,
  42  *      but it appears that early Maestros may have had PT101 (an ESS
  43  *      part?) wired to them.  The only real difference in the Maestro
  44  *      families is external goop like docking capability, memory for
  45  *      the ASSP, and initialization differences.
  46  *
  47  *  Driver Operation
  48  *
  49  *      We only drive the APU/Wavecache as typical DACs and drive the
  50  *      mixers in the codecs.  There are 64 APUs.  We assign 6 to each
  51  *      /dev/dsp? device.  2 channels for output, and 4 channels for
  52  *      input.
  53  *
  54  *      Each APU can do a number of things, but we only really use
  55  *      3 basic functions.  For playback we use them to convert PCM
  56  *      data fetched over PCI by the wavecahche into analog data that
  57  *      is handed to the codec.  One APU for mono, and a pair for stereo.
  58  *      When in stereo, the combination of smarts in the APU and Wavecache
  59  *      decide which wavecache gets the left or right channel.
  60  *
  61  *      For record we still use the old overly mono system.  For each in
  62  *      coming channel the data comes in from the codec, through a 'input'
  63  *      APU, through another rate converter APU, and then into memory via
  64  *      the wavecache and PCI.  If its stereo, we mash it back into LRLR in
  65  *      software.  The pass between the 2 APUs is supposedly what requires us
  66  *      to have a 512 byte buffer sitting around in wavecache/memory.
  67  *
  68  *      The wavecache makes our life even more fun.  First off, it can
  69  *      only address the first 28 bits of PCI address space, making it
  70  *      useless on quite a few architectures.  Secondly, its insane.
  71  *      It claims to fetch from 4 regions of PCI space, each 4 meg in length.
  72  *      But that doesn't really work.  You can only use 1 region.  So all our
  73  *      allocations have to be in 4meg of each other.  Booo.  Hiss.
  74  *      So we have a module parameter, dsps_order, that is the order of
  75  *      the number of dsps to provide.  All their buffer space is allocated
  76  *      on open time.  The sonicvibes OSS routines we inherited really want
  77  *      power of 2 buffers, so we have all those next to each other, then
  78  *      512 byte regions for the recording wavecaches.  This ends up
  79  *      wasting quite a bit of memory.  The only fixes I can see would be
  80  *      getting a kernel allocator that could work in zones, or figuring out
  81  *      just how to coerce the WP into doing what we want.
  82  *
  83  *      The indirection of the various registers means we have to spinlock
  84  *      nearly all register accesses.  We have the main register indirection
  85  *      like the wave cache, maestro registers, etc.  Then we have beasts
  86  *      like the APU interface that is indirect registers gotten at through
  87  *      the main maestro indirection.  Ouch.  We spinlock around the actual
  88  *      ports on a per card basis.  This means spinlock activity at each IO
  89  *      operation, but the only IO operation clusters are in non critical
  90  *      paths and it makes the code far easier to follow.  Interrupts are
  91  *      blocked while holding the locks because the int handler has to
  92  *      get at some of them :(.  The mixer interface doesn't, however.
  93  *      We also have an OSS state lock that is thrown around in a few
  94  *      places.
  95  */
  96
  97 #include <asm/io.h>
  98 #include <linux/delay.h>
  99 #include <linux/interrupt.h>
 100 #include <linux/init.h>
 101 #include <linux/pci.h>
 102 #include <linux/dma-mapping.h>
 103 #include <linux/slab.h>
 104 #include <linux/gameport.h>
 105 #include <linux/moduleparam.h>
 106 #include <linux/mutex.h>
 107 #include <linux/input.h>
 108
 109 #include <sound/core.h>
 110 #include <sound/pcm.h>
 111 #include <sound/mpu401.h>
 112 #include <sound/ac97_codec.h>
 113 #include <sound/initval.h>
 114
 115 #ifdef CONFIG_SND_ES1968_RADIO
 116 #include <sound/tea575x-tuner.h>
 117 #endif
 118
 119 #define CARD_NAME "ESS Maestro1/2"
 120 #define DRIVER_NAME "ES1968"
 121
 122 MODULE_DESCRIPTION("ESS Maestro");
 123 MODULE_LICENSE("GPL");
 124 MODULE_SUPPORTED_DEVICE("{{ESS,Maestro 2e},"
 125                 "{ESS,Maestro 2},"
 126                 "{ESS,Maestro 1},"
 127                 "{TerraTec,DMX}}");
 128
 129 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 130 #define SUPPORT_JOYSTICK 1
 131 #endif
 132
 133 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 1-MAX */
 134 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 135 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
 136 static int total_bufsize[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1024 };
 137 static int pcm_substreams_p[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4 };
 138 static int pcm_substreams_c[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1 };
 139 static int clock[SNDRV_CARDS];
 140 static int use_pm[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
 141 static int enable_mpu[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
 142 #ifdef SUPPORT_JOYSTICK
 143 static int joystick[SNDRV_CARDS];
 144 #endif
 145
 146 module_param_array(index, int, NULL, 0444);
 147 MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard.");
 148 module_param_array(id, charp, NULL, 0444);
 149 MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard.");
 150 module_param_array(enable, bool, NULL, 0444);
 151 MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard.");
 152 module_param_array(total_bufsize, int, NULL, 0444);
 153 MODULE_PARM_DESC(total_bufsize, "Total buffer size in kB.");
 154 module_param_array(pcm_substreams_p, int, NULL, 0444);
 155 MODULE_PARM_DESC(pcm_substreams_p, "PCM Playback substreams for " CARD_NAME " soundcard.");
 156 module_param_array(pcm_substreams_c, int, NULL, 0444);
 157 MODULE_PARM_DESC(pcm_substreams_c, "PCM Capture substreams for " CARD_NAME " soundcard.");
 158 module_param_array(clock, int, NULL, 0444);
 159 MODULE_PARM_DESC(clock, "Clock on " CARD_NAME " soundcard.  (0 = auto-detect)");
 160 module_param_array(use_pm, int, NULL, 0444);
 161 MODULE_PARM_DESC(use_pm, "Toggle power-management.  (0 = off, 1 = on, 2 = auto)");
 162 module_param_array(enable_mpu, int, NULL, 0444);
 163 MODULE_PARM_DESC(enable_mpu, "Enable MPU401.  (0 = off, 1 = on, 2 = auto)");
 164 #ifdef SUPPORT_JOYSTICK
 165 module_param_array(joystick, bool, NULL, 0444);
 166 MODULE_PARM_DESC(joystick, "Enable joystick.");
 167 #endif
 168
 169
 170 #define NR_APUS                 64
 171 #define NR_APU_REGS             16
 172
 173 /* NEC Versas ? */
 174 #define NEC_VERSA_SUBID1        0x80581033
 175 #define NEC_VERSA_SUBID2        0x803c1033
 176
 177 /* Mode Flags */
 178 #define ESS_FMT_STEREO          0x01
 179 #define ESS_FMT_16BIT           0x02
 180
 181 #define DAC_RUNNING             1
 182 #define ADC_RUNNING             2
 183
 184 /* Values for the ESM_LEGACY_AUDIO_CONTROL */
 185
 186 #define ESS_DISABLE_AUDIO       0x8000
 187 #define ESS_ENABLE_SERIAL_IRQ   0x4000
 188 #define IO_ADRESS_ALIAS         0x0020
 189 #define MPU401_IRQ_ENABLE       0x0010
 190 #define MPU401_IO_ENABLE        0x0008
 191 #define GAME_IO_ENABLE          0x0004
 192 #define FM_IO_ENABLE            0x0002
 193 #define SB_IO_ENABLE            0x0001
 194
 195 /* Values for the ESM_CONFIG_A */
 196
 197 #define PIC_SNOOP1              0x4000
 198 #define PIC_SNOOP2              0x2000
 199 #define SAFEGUARD               0x0800
 200 #define DMA_CLEAR               0x0700
 201 #define DMA_DDMA                0x0000
 202 #define DMA_TDMA                0x0100
 203 #define DMA_PCPCI               0x0200
 204 #define POST_WRITE              0x0080
 205 #define PCI_TIMING              0x0040
 206 #define SWAP_LR                 0x0020
 207 #define SUBTR_DECODE            0x0002
 208
 209 /* Values for the ESM_CONFIG_B */
 210
 211 #define SPDIF_CONFB             0x0100
 212 #define HWV_CONFB               0x0080
 213 #define DEBOUNCE                0x0040
 214 #define GPIO_CONFB              0x0020
 215 #define CHI_CONFB               0x0010
 216 #define IDMA_CONFB              0x0008  /*undoc */
 217 #define MIDI_FIX                0x0004  /*undoc */
 218 #define IRQ_TO_ISA              0x0001  /*undoc */
 219
 220 /* Values for Ring Bus Control B */
 221 #define RINGB_2CODEC_ID_MASK    0x0003
 222 #define RINGB_DIS_VALIDATION    0x0008
 223 #define RINGB_EN_SPDIF          0x0010
 224 #define RINGB_EN_2CODEC         0x0020
 225 #define RINGB_SING_BIT_DUAL     0x0040
 226
 227 /* ****Port Addresses**** */
 228
 229 /*   Write & Read */
 230 #define ESM_INDEX               0x02
 231 #define ESM_DATA                0x00
 232
 233 /*   AC97 + RingBus */
 234 #define ESM_AC97_INDEX          0x30
 235 #define ESM_AC97_DATA           0x32
 236 #define ESM_RING_BUS_DEST       0x34
 237 #define ESM_RING_BUS_CONTR_A    0x36
 238 #define ESM_RING_BUS_CONTR_B    0x38
 239 #define ESM_RING_BUS_SDO        0x3A
 240
 241 /*   WaveCache*/
 242 #define WC_INDEX                0x10
 243 #define WC_DATA                 0x12
 244 #define WC_CONTROL              0x14
 245
 246 /*   ASSP*/
 247 #define ASSP_INDEX              0x80
 248 #define ASSP_MEMORY             0x82
 249 #define ASSP_DATA               0x84
 250 #define ASSP_CONTROL_A          0xA2
 251 #define ASSP_CONTROL_B          0xA4
 252 #define ASSP_CONTROL_C          0xA6
 253 #define ASSP_HOSTW_INDEX        0xA8
 254 #define ASSP_HOSTW_DATA         0xAA
 255 #define ASSP_HOSTW_IRQ          0xAC
 256 /* Midi */
 257 #define ESM_MPU401_PORT         0x98
 258 /* Others */
 259 #define ESM_PORT_HOST_IRQ       0x18
 260
 261 #define IDR0_DATA_PORT          0x00
 262 #define IDR1_CRAM_POINTER       0x01
 263 #define IDR2_CRAM_DATA          0x02
 264 #define IDR3_WAVE_DATA          0x03
 265 #define IDR4_WAVE_PTR_LOW       0x04
 266 #define IDR5_WAVE_PTR_HI        0x05
 267 #define IDR6_TIMER_CTRL         0x06
 268 #define IDR7_WAVE_ROMRAM        0x07
 269
 270 #define WRITEABLE_MAP           0xEFFFFF
 271 #define READABLE_MAP            0x64003F
 272
 273 /* PCI Register */
 274
 275 #define ESM_LEGACY_AUDIO_CONTROL 0x40
 276 #define ESM_ACPI_COMMAND        0x54
 277 #define ESM_CONFIG_A            0x50
 278 #define ESM_CONFIG_B            0x52
 279 #define ESM_DDMA                0x60
 280
 281 /* Bob Bits */
 282 #define ESM_BOB_ENABLE          0x0001
 283 #define ESM_BOB_START           0x0001
 284
 285 /* Host IRQ Control Bits */
 286 #define ESM_RESET_MAESTRO       0x8000
 287 #define ESM_RESET_DIRECTSOUND   0x4000
 288 #define ESM_HIRQ_ClkRun         0x0100
 289 #define ESM_HIRQ_HW_VOLUME      0x0040
 290 #define ESM_HIRQ_HARPO          0x0030  /* What's that? */
 291 #define ESM_HIRQ_ASSP           0x0010
 292 #define ESM_HIRQ_DSIE           0x0004
 293 #define ESM_HIRQ_MPU401         0x0002
 294 #define ESM_HIRQ_SB             0x0001
 295
 296 /* Host IRQ Status Bits */
 297 #define ESM_MPU401_IRQ          0x02
 298 #define ESM_SB_IRQ              0x01
 299 #define ESM_SOUND_IRQ           0x04
 300 #define ESM_ASSP_IRQ            0x10
 301 #define ESM_HWVOL_IRQ           0x40
 302
 303 #define ESS_SYSCLK              50000000
 304 #define ESM_BOB_FREQ            200
 305 #define ESM_BOB_FREQ_MAX        800
 306
 307 #define ESM_FREQ_ESM1           (49152000L / 1024L)     /* default rate 48000 */
 308 #define ESM_FREQ_ESM2           (50000000L / 1024L)
 309
 310 /* APU Modes: reg 0x00, bit 4-7 */
 311 #define ESM_APU_MODE_SHIFT      4
 312 #define ESM_APU_MODE_MASK       (0xf << 4)
 313 #define ESM_APU_OFF             0x00
 314 #define ESM_APU_16BITLINEAR     0x01    /* 16-Bit Linear Sample Player */
 315 #define ESM_APU_16BITSTEREO     0x02    /* 16-Bit Stereo Sample Player */
 316 #define ESM_APU_8BITLINEAR      0x03    /* 8-Bit Linear Sample Player */
 317 #define ESM_APU_8BITSTEREO      0x04    /* 8-Bit Stereo Sample Player */
 318 #define ESM_APU_8BITDIFF        0x05    /* 8-Bit Differential Sample Playrer */
 319 #define ESM_APU_DIGITALDELAY    0x06    /* Digital Delay Line */
 320 #define ESM_APU_DUALTAP         0x07    /* Dual Tap Reader */
 321 #define ESM_APU_CORRELATOR      0x08    /* Correlator */
 322 #define ESM_APU_INPUTMIXER      0x09    /* Input Mixer */
 323 #define ESM_APU_WAVETABLE       0x0A    /* Wave Table Mode */
 324 #define ESM_APU_SRCONVERTOR     0x0B    /* Sample Rate Convertor */
 325 #define ESM_APU_16BITPINGPONG   0x0C    /* 16-Bit Ping-Pong Sample Player */
 326 #define ESM_APU_RESERVED1       0x0D    /* Reserved 1 */
 327 #define ESM_APU_RESERVED2       0x0E    /* Reserved 2 */
 328 #define ESM_APU_RESERVED3       0x0F    /* Reserved 3 */
 329
 330 /* reg 0x00 */
 331 #define ESM_APU_FILTER_Q_SHIFT          0
 332 #define ESM_APU_FILTER_Q_MASK           (3 << 0)
 333 /* APU Filtey Q Control */
 334 #define ESM_APU_FILTER_LESSQ    0x00
 335 #define ESM_APU_FILTER_MOREQ    0x03
 336
 337 #define ESM_APU_FILTER_TYPE_SHIFT       2
 338 #define ESM_APU_FILTER_TYPE_MASK        (3 << 2)
 339 #define ESM_APU_ENV_TYPE_SHIFT          8
 340 #define ESM_APU_ENV_TYPE_MASK           (3 << 8)
 341 #define ESM_APU_ENV_STATE_SHIFT         10
 342 #define ESM_APU_ENV_STATE_MASK          (3 << 10)
 343 #define ESM_APU_END_CURVE               (1 << 12)
 344 #define ESM_APU_INT_ON_LOOP             (1 << 13)
 345 #define ESM_APU_DMA_ENABLE              (1 << 14)
 346
 347 /* reg 0x02 */
 348 #define ESM_APU_SUBMIX_GROUP_SHIRT      0
 349 #define ESM_APU_SUBMIX_GROUP_MASK       (7 << 0)
 350 #define ESM_APU_SUBMIX_MODE             (1 << 3)
 351 #define ESM_APU_6dB                     (1 << 4)
 352 #define ESM_APU_DUAL_EFFECT             (1 << 5)
 353 #define ESM_APU_EFFECT_CHANNELS_SHIFT   6
 354 #define ESM_APU_EFFECT_CHANNELS_MASK    (3 << 6)
 355
 356 /* reg 0x03 */
 357 #define ESM_APU_STEP_SIZE_MASK          0x0fff
 358
 359 /* reg 0x04 */
 360 #define ESM_APU_PHASE_SHIFT             0
 361 #define ESM_APU_PHASE_MASK              (0xff << 0)
 362 #define ESM_APU_WAVE64K_PAGE_SHIFT      8       /* most 8bit of wave start offset */
 363 #define ESM_APU_WAVE64K_PAGE_MASK       (0xff << 8)
 364
 365 /* reg 0x05 - wave start offset */
 366 /* reg 0x06 - wave end offset */
 367 /* reg 0x07 - wave loop length */
 368
 369 /* reg 0x08 */
 370 #define ESM_APU_EFFECT_GAIN_SHIFT       0
 371 #define ESM_APU_EFFECT_GAIN_MASK        (0xff << 0)
 372 #define ESM_APU_TREMOLO_DEPTH_SHIFT     8
 373 #define ESM_APU_TREMOLO_DEPTH_MASK      (0xf << 8)
 374 #define ESM_APU_TREMOLO_RATE_SHIFT      12
 375 #define ESM_APU_TREMOLO_RATE_MASK       (0xf << 12)
 376
 377 /* reg 0x09 */
 378 /* bit 0-7 amplitude dest? */
 379 #define ESM_APU_AMPLITUDE_NOW_SHIFT     8
 380 #define ESM_APU_AMPLITUDE_NOW_MASK      (0xff << 8)
 381
 382 /* reg 0x0a */
 383 #define ESM_APU_POLAR_PAN_SHIFT         0
 384 #define ESM_APU_POLAR_PAN_MASK          (0x3f << 0)
 385 /* Polar Pan Control */
 386 #define ESM_APU_PAN_CENTER_CIRCLE               0x00
 387 #define ESM_APU_PAN_MIDDLE_RADIUS               0x01
 388 #define ESM_APU_PAN_OUTSIDE_RADIUS              0x02
 389
 390 #define ESM_APU_FILTER_TUNING_SHIFT     8
 391 #define ESM_APU_FILTER_TUNING_MASK      (0xff << 8)
 392
 393 /* reg 0x0b */
 394 #define ESM_APU_DATA_SRC_A_SHIFT        0
 395 #define ESM_APU_DATA_SRC_A_MASK         (0x7f << 0)
 396 #define ESM_APU_INV_POL_A               (1 << 7)
 397 #define ESM_APU_DATA_SRC_B_SHIFT        8
 398 #define ESM_APU_DATA_SRC_B_MASK         (0x7f << 8)
 399 #define ESM_APU_INV_POL_B               (1 << 15)
 400
 401 #define ESM_APU_VIBRATO_RATE_SHIFT      0
 402 #define ESM_APU_VIBRATO_RATE_MASK       (0xf << 0)
 403 #define ESM_APU_VIBRATO_DEPTH_SHIFT     4
 404 #define ESM_APU_VIBRATO_DEPTH_MASK      (0xf << 4)
 405 #define ESM_APU_VIBRATO_PHASE_SHIFT     8
 406 #define ESM_APU_VIBRATO_PHASE_MASK      (0xff << 8)
 407
 408 /* reg 0x0c */
 409 #define ESM_APU_RADIUS_SELECT           (1 << 6)
 410
 411 /* APU Filter Control */
 412 #define ESM_APU_FILTER_2POLE_LOPASS     0x00
 413 #define ESM_APU_FILTER_2POLE_BANDPASS   0x01
 414 #define ESM_APU_FILTER_2POLE_HIPASS     0x02
 415 #define ESM_APU_FILTER_1POLE_LOPASS     0x03
 416 #define ESM_APU_FILTER_1POLE_HIPASS     0x04
 417 #define ESM_APU_FILTER_OFF              0x05
 418
 419 /* APU ATFP Type */
 420 #define ESM_APU_ATFP_AMPLITUDE                  0x00
 421 #define ESM_APU_ATFP_TREMELO                    0x01
 422 #define ESM_APU_ATFP_FILTER                     0x02
 423 #define ESM_APU_ATFP_PAN                        0x03
 424
 425 /* APU ATFP Flags */
 426 #define ESM_APU_ATFP_FLG_OFF                    0x00
 427 #define ESM_APU_ATFP_FLG_WAIT                   0x01
 428 #define ESM_APU_ATFP_FLG_DONE                   0x02
 429 #define ESM_APU_ATFP_FLG_INPROCESS              0x03
 430
 431
 432 /* capture mixing buffer size */
 433 #define ESM_MEM_ALIGN           0x1000
 434 #define ESM_MIXBUF_SIZE         0x400
 435
 436 #define ESM_MODE_PLAY           0
 437 #define ESM_MODE_CAPTURE        1
 438
 439
 440 /* APU use in the driver */
 441 enum snd_enum_apu_type {
 442         ESM_APU_PCM_PLAY,
 443         ESM_APU_PCM_CAPTURE,
 444         ESM_APU_PCM_RATECONV,
 445         ESM_APU_FREE
 446 };
 447
 448 /* chip type */
 449 enum {
 450         TYPE_MAESTRO, TYPE_MAESTRO2, TYPE_MAESTRO2E
 451 };
 452
 453 /* DMA Hack! */
 454 struct esm_memory {
 455         struct snd_dma_buffer buf;
 456         int empty;      /* status */
 457         struct list_head list;
 458 };
 459
 460 /* Playback Channel */
 461 struct esschan {
 462         int running;
 463
 464         u8 apu[4];
 465         u8 apu_mode[4];
 466
 467         /* playback/capture pcm buffer */
 468         struct esm_memory *memory;
 469         /* capture mixer buffer */
 470         struct esm_memory *mixbuf;
 471
 472         unsigned int hwptr;     /* current hw pointer in bytes */
 473         unsigned int count;     /* sample counter in bytes */
 474         unsigned int dma_size;  /* total buffer size in bytes */
 475         unsigned int frag_size; /* period size in bytes */
 476         unsigned int wav_shift;
 477         u16 base[4];            /* offset for ptr */
 478
 479         /* stereo/16bit flag */
 480         unsigned char fmt;
 481         int mode;       /* playback / capture */
 482
 483         int bob_freq;   /* required timer frequency */
 484
 485         struct snd_pcm_substream *substream;
 486
 487         /* linked list */
 488         struct list_head list;
 489
 490 #ifdef CONFIG_PM
 491         u16 wc_map[4];
 492 #endif
 493 };
 494
 495 struct es1968 {
 496         /* Module Config */
 497         int total_bufsize;                      /* in bytes */
 498
 499         int playback_streams, capture_streams;
 500
 501         unsigned int clock;             /* clock */
 502         /* for clock measurement */
 503         unsigned int in_measurement: 1;
 504         unsigned int measure_apu;
 505         unsigned int measure_lastpos;
 506         unsigned int measure_count;
 507
 508         /* buffer */
 509         struct snd_dma_buffer dma;
 510
 511         /* Resources... */
 512         int irq;
 513         unsigned long io_port;
 514         int type;
 515         struct pci_dev *pci;
 516         struct snd_card *card;
 517         struct snd_pcm *pcm;
 518         int do_pm;              /* power-management enabled */
 519
 520         /* DMA memory block */
 521         struct list_head buf_list;
 522
 523         /* ALSA Stuff */
 524         struct snd_ac97 *ac97;
 525         struct snd_rawmidi *rmidi;
 526
 527         spinlock_t reg_lock;
 528         unsigned int in_suspend;
 529
 530         /* Maestro Stuff */
 531         u16 maestro_map[32];
 532         int bobclient;          /* active timer instancs */
 533         int bob_freq;           /* timer frequency */
 534         struct mutex memory_mutex;      /* memory lock */
 535
 536         /* APU states */
 537         unsigned char apu[NR_APUS];
 538
 539         /* active substreams */
 540         struct list_head substream_list;
 541         spinlock_t substream_lock;
 542
 543 #ifdef CONFIG_PM
 544         u16 apu_map[NR_APUS][NR_APU_REGS];
 545 #endif
 546
 547 #ifdef SUPPORT_JOYSTICK
 548         struct gameport *gameport;
 549 #endif
 550
 551 #ifdef CONFIG_SND_ES1968_INPUT
 552         struct input_dev *input_dev;
 553         char phys[64];                  /* physical device path */
 554 #else
 555         struct snd_kcontrol *master_switch; /* for h/w volume control */
 556         struct snd_kcontrol *master_volume;
 557         spinlock_t ac97_lock;
 558         struct tasklet_struct hwvol_tq;
 559 #endif
 560
 561 #ifdef CONFIG_SND_ES1968_RADIO
 562         struct snd_tea575x tea;
 563 #endif
 564 };
 565
 566 static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id);
 567
 568 static DEFINE_PCI_DEVICE_TABLE(snd_es1968_ids) = {
 569         /* Maestro 1 */
 570         { 0x1285, 0x0100, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO },
 571         /* Maestro 2 */
 572         { 0x125d, 0x1968, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO2 },
 573         /* Maestro 2E */
 574         { 0x125d, 0x1978, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO2E },
 575         { 0, }
 576 };
 577
 578 MODULE_DEVICE_TABLE(pci, snd_es1968_ids);
 579
 580 /* *********************
 581    * Low Level Funcs!  *
 582    *********************/
 583
 584 /* no spinlock */
 585 static void __maestro_write(struct es1968 *chip, u16 reg, u16 data)
 586 {
 587         outw(reg, chip->io_port + ESM_INDEX);
 588         outw(data, chip->io_port + ESM_DATA);
 589         chip->maestro_map[reg] = data;
 590 }
 591
 592 static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data)
 593 {
 594         unsigned long flags;
 595         spin_lock_irqsave(&chip->reg_lock, flags);
 596         __maestro_write(chip, reg, data);
 597         spin_unlock_irqrestore(&chip->reg_lock, flags);
 598 }
 599
 600 /* no spinlock */
 601 static u16 __maestro_read(struct es1968 *chip, u16 reg)
 602 {
 603         if (READABLE_MAP & (1 << reg)) {
 604                 outw(reg, chip->io_port + ESM_INDEX);
 605                 chip->maestro_map[reg] = inw(chip->io_port + ESM_DATA);
 606         }
 607         return chip->maestro_map[reg];
 608 }
 609
 610 static inline u16 maestro_read(struct es1968 *chip, u16 reg)
 611 {
 612         unsigned long flags;
 613         u16 result;
 614         spin_lock_irqsave(&chip->reg_lock, flags);
 615         result = __maestro_read(chip, reg);
 616         spin_unlock_irqrestore(&chip->reg_lock, flags);
 617         return result;
 618 }
 619
 620 /* Wait for the codec bus to be free */
 621 static int snd_es1968_ac97_wait(struct es1968 *chip)
 622 {
 623         int timeout = 100000;
 624
 625         while (timeout-- > 0) {
 626                 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
 627                         return 0;
 628                 cond_resched();
 629         }
 630         snd_printd("es1968: ac97 timeout\n");
 631         return 1; /* timeout */
 632 }
 633
 634 static int snd_es1968_ac97_wait_poll(struct es1968 *chip)
 635 {
 636         int timeout = 100000;
 637
 638         while (timeout-- > 0) {
 639                 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
 640                         return 0;
 641         }
 642         snd_printd("es1968: ac97 timeout\n");
 643         return 1; /* timeout */
 644 }
 645
 646 static void snd_es1968_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val)
 647 {
 648         struct es1968 *chip = ac97->private_data;
 649 #ifndef CONFIG_SND_ES1968_INPUT
 650         unsigned long flags;
 651 #endif
 652
 653         snd_es1968_ac97_wait(chip);
 654
 655         /* Write the bus */
 656 #ifndef CONFIG_SND_ES1968_INPUT
 657         spin_lock_irqsave(&chip->ac97_lock, flags);
 658 #endif
 659         outw(val, chip->io_port + ESM_AC97_DATA);
 660         /*msleep(1);*/
 661         outb(reg, chip->io_port + ESM_AC97_INDEX);
 662         /*msleep(1);*/
 663 #ifndef CONFIG_SND_ES1968_INPUT
 664         spin_unlock_irqrestore(&chip->ac97_lock, flags);
 665 #endif
 666 }
 667
 668 static unsigned short snd_es1968_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
 669 {
 670         u16 data = 0;
 671         struct es1968 *chip = ac97->private_data;
 672 #ifndef CONFIG_SND_ES1968_INPUT
 673         unsigned long flags;
 674 #endif
 675
 676         snd_es1968_ac97_wait(chip);
 677
 678 #ifndef CONFIG_SND_ES1968_INPUT
 679         spin_lock_irqsave(&chip->ac97_lock, flags);
 680 #endif
 681         outb(reg | 0x80, chip->io_port + ESM_AC97_INDEX);
 682         /*msleep(1);*/
 683
 684         if (!snd_es1968_ac97_wait_poll(chip)) {
 685                 data = inw(chip->io_port + ESM_AC97_DATA);
 686                 /*msleep(1);*/
 687         }
 688 #ifndef CONFIG_SND_ES1968_INPUT
 689         spin_unlock_irqrestore(&chip->ac97_lock, flags);
 690 #endif
 691
 692         return data;
 693 }
 694
 695 /* no spinlock */
 696 static void apu_index_set(struct es1968 *chip, u16 index)
 697 {
 698         int i;
 699         __maestro_write(chip, IDR1_CRAM_POINTER, index);
 700         for (i = 0; i < 1000; i++)
 701                 if (__maestro_read(chip, IDR1_CRAM_POINTER) == index)
 702                         return;
 703         snd_printd("es1968: APU register select failed. (Timeout)\n");
 704 }
 705
 706 /* no spinlock */
 707 static void apu_data_set(struct es1968 *chip, u16 data)
 708 {
 709         int i;
 710         for (i = 0; i < 1000; i++) {
 711                 if (__maestro_read(chip, IDR0_DATA_PORT) == data)
 712                         return;
 713                 __maestro_write(chip, IDR0_DATA_PORT, data);
 714         }
 715         snd_printd("es1968: APU register set probably failed (Timeout)!\n");
 716 }
 717
 718 /* no spinlock */
 719 static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
 720 {
 721         if (snd_BUG_ON(channel >= NR_APUS))
 722                 return;
 723 #ifdef CONFIG_PM
 724         chip->apu_map[channel][reg] = data;
 725 #endif
 726         reg |= (channel << 4);
 727         apu_index_set(chip, reg);
 728         apu_data_set(chip, data);
 729 }
 730
 731 static void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
 732 {
 733         unsigned long flags;
 734         spin_lock_irqsave(&chip->reg_lock, flags);
 735         __apu_set_register(chip, channel, reg, data);
 736         spin_unlock_irqrestore(&chip->reg_lock, flags);
 737 }
 738
 739 static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
 740 {
 741         if (snd_BUG_ON(channel >= NR_APUS))
 742                 return 0;
 743         reg |= (channel << 4);
 744         apu_index_set(chip, reg);
 745         return __maestro_read(chip, IDR0_DATA_PORT);
 746 }
 747
 748 static u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
 749 {
 750         unsigned long flags;
 751         u16 v;
 752         spin_lock_irqsave(&chip->reg_lock, flags);
 753         v = __apu_get_register(chip, channel, reg);
 754         spin_unlock_irqrestore(&chip->reg_lock, flags);
 755         return v;
 756 }
 757
 758 #if 0 /* ASSP is not supported */
 759
 760 static void assp_set_register(struct es1968 *chip, u32 reg, u32 value)
 761 {
 762         unsigned long flags;
 763
 764         spin_lock_irqsave(&chip->reg_lock, flags);
 765         outl(reg, chip->io_port + ASSP_INDEX);
 766         outl(value, chip->io_port + ASSP_DATA);
 767         spin_unlock_irqrestore(&chip->reg_lock, flags);
 768 }
 769
 770 static u32 assp_get_register(struct es1968 *chip, u32 reg)
 771 {
 772         unsigned long flags;
 773         u32 value;
 774
 775         spin_lock_irqsave(&chip->reg_lock, flags);
 776         outl(reg, chip->io_port + ASSP_INDEX);
 777         value = inl(chip->io_port + ASSP_DATA);
 778         spin_unlock_irqrestore(&chip->reg_lock, flags);
 779
 780         return value;
 781 }
 782
 783 #endif
 784
 785 static void wave_set_register(struct es1968 *chip, u16 reg, u16 value)
 786 {
 787         unsigned long flags;
 788
 789         spin_lock_irqsave(&chip->reg_lock, flags);
 790         outw(reg, chip->io_port + WC_INDEX);
 791         outw(value, chip->io_port + WC_DATA);
 792         spin_unlock_irqrestore(&chip->reg_lock, flags);
 793 }
 794
 795 static u16 wave_get_register(struct es1968 *chip, u16 reg)
 796 {
 797         unsigned long flags;
 798         u16 value;
 799
 800         spin_lock_irqsave(&chip->reg_lock, flags);
 801         outw(reg, chip->io_port + WC_INDEX);
 802         value = inw(chip->io_port + WC_DATA);
 803         spin_unlock_irqrestore(&chip->reg_lock, flags);
 804
 805         return value;
 806 }
 807
 808 /* *******************
 809    * Bob the Timer!  *
 810    *******************/
 811
 812 static void snd_es1968_bob_stop(struct es1968 *chip)
 813 {
 814         u16 reg;
 815
 816         reg = __maestro_read(chip, 0x11);
 817         reg &= ~ESM_BOB_ENABLE;
 818         __maestro_write(chip, 0x11, reg);
 819         reg = __maestro_read(chip, 0x17);
 820         reg &= ~ESM_BOB_START;
 821         __maestro_write(chip, 0x17, reg);
 822 }
 823
 824 static void snd_es1968_bob_start(struct es1968 *chip)
 825 {
 826         int prescale;
 827         int divide;
 828
 829         /* compute ideal interrupt frequency for buffer size & play rate */
 830         /* first, find best prescaler value to match freq */
 831         for (prescale = 5; prescale < 12; prescale++)
 832                 if (chip->bob_freq > (ESS_SYSCLK >> (prescale + 9)))
 833                         break;
 834
 835         /* next, back off prescaler whilst getting divider into optimum range */
 836         divide = 1;
 837         while ((prescale > 5) && (divide < 32)) {
 838                 prescale--;
 839                 divide <<= 1;
 840         }
 841         divide >>= 1;
 842
 843         /* now fine-tune the divider for best match */
 844         for (; divide < 31; divide++)
 845                 if (chip->bob_freq >
 846                     ((ESS_SYSCLK >> (prescale + 9)) / (divide + 1))) break;
 847
 848         /* divide = 0 is illegal, but don't let prescale = 4! */
 849         if (divide == 0) {
 850                 divide++;
 851                 if (prescale > 5)
 852                         prescale--;
 853         } else if (divide > 1)
 854                 divide--;
 855
 856         __maestro_write(chip, 6, 0x9000 | (prescale << 5) | divide);    /* set reg */
 857
 858         /* Now set IDR 11/17 */
 859         __maestro_write(chip, 0x11, __maestro_read(chip, 0x11) | 1);
 860         __maestro_write(chip, 0x17, __maestro_read(chip, 0x17) | 1);
 861 }
 862
 863 /* call with substream spinlock */
 864 static void snd_es1968_bob_inc(struct es1968 *chip, int freq)
 865 {
 866         chip->bobclient++;
 867         if (chip->bobclient == 1) {
 868                 chip->bob_freq = freq;
 869                 snd_es1968_bob_start(chip);
 870         } else if (chip->bob_freq < freq) {
 871                 snd_es1968_bob_stop(chip);
 872                 chip->bob_freq = freq;
 873                 snd_es1968_bob_start(chip);
 874         }
 875 }
 876
 877 /* call with substream spinlock */
 878 static void snd_es1968_bob_dec(struct es1968 *chip)
 879 {
 880         chip->bobclient--;
 881         if (chip->bobclient <= 0)
 882                 snd_es1968_bob_stop(chip);
 883         else if (chip->bob_freq > ESM_BOB_FREQ) {
 884                 /* check reduction of timer frequency */
 885                 int max_freq = ESM_BOB_FREQ;
 886                 struct esschan *es;
 887                 list_for_each_entry(es, &chip->substream_list, list) {
 888                         if (max_freq < es->bob_freq)
 889                                 max_freq = es->bob_freq;
 890                 }
 891                 if (max_freq != chip->bob_freq) {
 892                         snd_es1968_bob_stop(chip);
 893                         chip->bob_freq = max_freq;
 894                         snd_es1968_bob_start(chip);
 895                 }
 896         }
 897 }
 898
 899 static int
 900 snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es,
 901                          struct snd_pcm_runtime *runtime)
 902 {
 903         /* we acquire 4 interrupts per period for precise control.. */
 904         int freq = runtime->rate * 4;
 905         if (es->fmt & ESS_FMT_STEREO)
 906                 freq <<= 1;
 907         if (es->fmt & ESS_FMT_16BIT)
 908                 freq <<= 1;
 909         freq /= es->frag_size;
 910         if (freq < ESM_BOB_FREQ)
 911                 freq = ESM_BOB_FREQ;
 912         else if (freq > ESM_BOB_FREQ_MAX)
 913                 freq = ESM_BOB_FREQ_MAX;
 914         return freq;
 915 }
 916
 917
 918 /*************
 919  *  PCM Part *
 920  *************/
 921
 922 static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq)
 923 {
 924         u32 rate = (freq << 16) / chip->clock;
 925 #if 0 /* XXX: do we need this? */
 926         if (rate > 0x10000)
 927                 rate = 0x10000;
 928 #endif
 929         return rate;
 930 }
 931
 932 /* get current pointer */
 933 static inline unsigned int
 934 snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es)
 935 {
 936         unsigned int offset;
 937
 938         offset = apu_get_register(chip, es->apu[0], 5);
 939
 940         offset -= es->base[0];
 941
 942         return (offset & 0xFFFE);       /* hardware is in words */
 943 }
 944
 945 static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq)
 946 {
 947         apu_set_register(chip, apu, 2,
 948                            (apu_get_register(chip, apu, 2) & 0x00FF) |
 949                            ((freq & 0xff) << 8) | 0x10);
 950         apu_set_register(chip, apu, 3, freq >> 8);
 951 }
 952
 953 /* spin lock held */
 954 static inline void snd_es1968_trigger_apu(struct es1968 *esm, int apu, int mode)
 955 {
 956         /* set the APU mode */
 957         __apu_set_register(esm, apu, 0,
 958                            (__apu_get_register(esm, apu, 0) & 0xff0f) |
 959                            (mode << 4));
 960 }
 961
 962 static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es)
 963 {
 964         spin_lock(&chip->reg_lock);
 965         __apu_set_register(chip, es->apu[0], 5, es->base[0]);
 966         snd_es1968_trigger_apu(chip, es->apu[0], es->apu_mode[0]);
 967         if (es->mode == ESM_MODE_CAPTURE) {
 968                 __apu_set_register(chip, es->apu[2], 5, es->base[2]);
 969                 snd_es1968_trigger_apu(chip, es->apu[2], es->apu_mode[2]);
 970         }
 971         if (es->fmt & ESS_FMT_STEREO) {
 972                 __apu_set_register(chip, es->apu[1], 5, es->base[1]);
 973                 snd_es1968_trigger_apu(chip, es->apu[1], es->apu_mode[1]);
 974                 if (es->mode == ESM_MODE_CAPTURE) {
 975                         __apu_set_register(chip, es->apu[3], 5, es->base[3]);
 976                         snd_es1968_trigger_apu(chip, es->apu[3], es->apu_mode[3]);
 977                 }
 978         }
 979         spin_unlock(&chip->reg_lock);
 980 }
 981
 982 static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es)
 983 {
 984         spin_lock(&chip->reg_lock);
 985         snd_es1968_trigger_apu(chip, es->apu[0], 0);
 986         snd_es1968_trigger_apu(chip, es->apu[1], 0);
 987         if (es->mode == ESM_MODE_CAPTURE) {
 988                 snd_es1968_trigger_apu(chip, es->apu[2], 0);
 989                 snd_es1968_trigger_apu(chip, es->apu[3], 0);
 990         }
 991         spin_unlock(&chip->reg_lock);
 992 }
 993
 994 /* set the wavecache control reg */
 995 static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es,
 996                                          int channel, u32 addr, int capture)
 997 {
 998         u32 tmpval = (addr - 0x10) & 0xFFF8;
 999
1000         if (! capture) {
1001                 if (!(es->fmt & ESS_FMT_16BIT))
1002                         tmpval |= 4;    /* 8bit */
1003                 if (es->fmt & ESS_FMT_STEREO)
1004                         tmpval |= 2;    /* stereo */
1005         }
1006
1007         /* set the wavecache control reg */
1008         wave_set_register(chip, es->apu[channel] << 3, tmpval);
1009
1010 #ifdef CONFIG_PM
1011         es->wc_map[channel] = tmpval;
1012 #endif
1013 }
1014
1015
1016 static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es,
1017                                       struct snd_pcm_runtime *runtime)
1018 {
1019         u32 pa;
1020         int high_apu = 0;
1021         int channel, apu;
1022         int i, size;
1023         unsigned long flags;
1024         u32 freq;
1025
1026         size = es->dma_size >> es->wav_shift;
1027
1028         if (es->fmt & ESS_FMT_STEREO)
1029                 high_apu++;
1030
1031         for (channel = 0; channel <= high_apu; channel++) {
1032                 apu = es->apu[channel];
1033
1034                 snd_es1968_program_wavecache(chip, es, channel, es->memory->buf.addr, 0);
1035
1036                 /* Offset to PCMBAR */
1037                 pa = es->memory->buf.addr;
1038                 pa -= chip->dma.addr;
1039                 pa >>= 1;       /* words */
1040
1041                 pa |= 0x00400000;       /* System RAM (Bit 22) */
1042
1043                 if (es->fmt & ESS_FMT_STEREO) {
1044                         /* Enable stereo */
1045                         if (channel)
1046                                 pa |= 0x00800000;       /* (Bit 23) */
1047                         if (es->fmt & ESS_FMT_16BIT)
1048                                 pa >>= 1;
1049                 }
1050
1051                 /* base offset of dma calcs when reading the pointer
1052                    on this left one */
1053                 es->base[channel] = pa & 0xFFFF;
1054
1055                 for (i = 0; i < 16; i++)
1056                         apu_set_register(chip, apu, i, 0x0000);
1057
1058                 /* Load the buffer into the wave engine */
1059                 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1060                 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1061                 apu_set_register(chip, apu, 6, (pa + size) & 0xFFFF);
1062                 /* setting loop == sample len */
1063                 apu_set_register(chip, apu, 7, size);
1064
1065                 /* clear effects/env.. */
1066                 apu_set_register(chip, apu, 8, 0x0000);
1067                 /* set amp now to 0xd0 (?), low byte is 'amplitude dest'? */
1068                 apu_set_register(chip, apu, 9, 0xD000);
1069
1070                 /* clear routing stuff */
1071                 apu_set_register(chip, apu, 11, 0x0000);
1072                 /* dma on, no envelopes, filter to all 1s) */
1073                 apu_set_register(chip, apu, 0, 0x400F);
1074
1075                 if (es->fmt & ESS_FMT_16BIT)
1076                         es->apu_mode[channel] = ESM_APU_16BITLINEAR;
1077                 else
1078                         es->apu_mode[channel] = ESM_APU_8BITLINEAR;
1079
1080                 if (es->fmt & ESS_FMT_STEREO) {
1081                         /* set panning: left or right */
1082                         /* Check: different panning. On my Canyon 3D Chipset the
1083                            Channels are swapped. I don't know, about the output
1084                            to the SPDif Link. Perhaps you have to change this
1085                            and not the APU Regs 4-5. */
1086                         apu_set_register(chip, apu, 10,
1087                                          0x8F00 | (channel ? 0 : 0x10));
1088                         es->apu_mode[channel] += 1;     /* stereo */
1089                 } else
1090                         apu_set_register(chip, apu, 10, 0x8F08);
1091         }
1092
1093         spin_lock_irqsave(&chip->reg_lock, flags);
1094         /* clear WP interrupts */
1095         outw(1, chip->io_port + 0x04);
1096         /* enable WP ints */
1097         outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1098         spin_unlock_irqrestore(&chip->reg_lock, flags);
1099
1100         freq = runtime->rate;
1101         /* set frequency */
1102         if (freq > 48000)
1103                 freq = 48000;
1104         if (freq < 4000)
1105                 freq = 4000;
1106
1107         /* hmmm.. */
1108         if (!(es->fmt & ESS_FMT_16BIT) && !(es->fmt & ESS_FMT_STEREO))
1109                 freq >>= 1;
1110
1111         freq = snd_es1968_compute_rate(chip, freq);
1112
1113         /* Load the frequency, turn on 6dB */
1114         snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1115         snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1116 }
1117
1118
1119 static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel,
1120                              unsigned int pa, unsigned int bsize,
1121                              int mode, int route)
1122 {
1123         int i, apu = es->apu[channel];
1124
1125         es->apu_mode[channel] = mode;
1126
1127         /* set the wavecache control reg */
1128         snd_es1968_program_wavecache(chip, es, channel, pa, 1);
1129
1130         /* Offset to PCMBAR */
1131         pa -= chip->dma.addr;
1132         pa >>= 1;       /* words */
1133
1134         /* base offset of dma calcs when reading the pointer
1135            on this left one */
1136         es->base[channel] = pa & 0xFFFF;
1137         pa |= 0x00400000;       /* bit 22 -> System RAM */
1138
1139         /* Begin loading the APU */
1140         for (i = 0; i < 16; i++)
1141                 apu_set_register(chip, apu, i, 0x0000);
1142
1143         /* need to enable subgroups.. and we should probably
1144            have different groups for different /dev/dsps..  */
1145         apu_set_register(chip, apu, 2, 0x8);
1146
1147         /* Load the buffer into the wave engine */
1148         apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1149         apu_set_register(chip, apu, 5, pa & 0xFFFF);
1150         apu_set_register(chip, apu, 6, (pa + bsize) & 0xFFFF);
1151         apu_set_register(chip, apu, 7, bsize);
1152         /* clear effects/env.. */
1153         apu_set_register(chip, apu, 8, 0x00F0);
1154         /* amplitude now?  sure.  why not.  */
1155         apu_set_register(chip, apu, 9, 0x0000);
1156         /* set filter tune, radius, polar pan */
1157         apu_set_register(chip, apu, 10, 0x8F08);
1158         /* route input */
1159         apu_set_register(chip, apu, 11, route);
1160         /* dma on, no envelopes, filter to all 1s) */
1161         apu_set_register(chip, apu, 0, 0x400F);
1162 }
1163
1164 static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es,
1165                                      struct snd_pcm_runtime *runtime)
1166 {
1167         int size;
1168         u32 freq;
1169         unsigned long flags;
1170
1171         size = es->dma_size >> es->wav_shift;
1172
1173         /* APU assignments:
1174            0 = mono/left SRC
1175            1 = right SRC
1176            2 = mono/left Input Mixer
1177            3 = right Input Mixer
1178         */
1179         /* data seems to flow from the codec, through an apu into
1180            the 'mixbuf' bit of page, then through the SRC apu
1181            and out to the real 'buffer'.  ok.  sure.  */
1182
1183         /* input mixer (left/mono) */
1184         /* parallel in crap, see maestro reg 0xC [8-11] */
1185         init_capture_apu(chip, es, 2,
1186                          es->mixbuf->buf.addr, ESM_MIXBUF_SIZE/4, /* in words */
1187                          ESM_APU_INPUTMIXER, 0x14);
1188         /* SRC (left/mono); get input from inputing apu */
1189         init_capture_apu(chip, es, 0, es->memory->buf.addr, size,
1190                          ESM_APU_SRCONVERTOR, es->apu[2]);
1191         if (es->fmt & ESS_FMT_STEREO) {
1192                 /* input mixer (right) */
1193                 init_capture_apu(chip, es, 3,
1194                                  es->mixbuf->buf.addr + ESM_MIXBUF_SIZE/2,
1195                                  ESM_MIXBUF_SIZE/4, /* in words */
1196                                  ESM_APU_INPUTMIXER, 0x15);
1197                 /* SRC (right) */
1198                 init_capture_apu(chip, es, 1,
1199                                  es->memory->buf.addr + size*2, size,
1200                                  ESM_APU_SRCONVERTOR, es->apu[3]);
1201         }
1202
1203         freq = runtime->rate;
1204         /* Sample Rate conversion APUs don't like 0x10000 for their rate */
1205         if (freq > 47999)
1206                 freq = 47999;
1207         if (freq < 4000)
1208                 freq = 4000;
1209
1210         freq = snd_es1968_compute_rate(chip, freq);
1211
1212         /* Load the frequency, turn on 6dB */
1213         snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1214         snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1215
1216         /* fix mixer rate at 48khz.  and its _must_ be 0x10000. */
1217         freq = 0x10000;
1218         snd_es1968_apu_set_freq(chip, es->apu[2], freq);
1219         snd_es1968_apu_set_freq(chip, es->apu[3], freq);
1220
1221         spin_lock_irqsave(&chip->reg_lock, flags);
1222         /* clear WP interrupts */
1223         outw(1, chip->io_port + 0x04);
1224         /* enable WP ints */
1225         outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1226         spin_unlock_irqrestore(&chip->reg_lock, flags);
1227 }
1228
1229 /*******************
1230  *  ALSA Interface *
1231  *******************/
1232
1233 static int snd_es1968_pcm_prepare(struct snd_pcm_substream *substream)
1234 {
1235         struct es1968 *chip = snd_pcm_substream_chip(substream);
1236         struct snd_pcm_runtime *runtime = substream->runtime;
1237         struct esschan *es = runtime->private_data;
1238
1239         es->dma_size = snd_pcm_lib_buffer_bytes(substream);
1240         es->frag_size = snd_pcm_lib_period_bytes(substream);
1241
1242         es->wav_shift = 1; /* maestro handles always 16bit */
1243         es->fmt = 0;
1244         if (snd_pcm_format_width(runtime->format) == 16)
1245                 es->fmt |= ESS_FMT_16BIT;
1246         if (runtime->channels > 1) {
1247                 es->fmt |= ESS_FMT_STEREO;
1248                 if (es->fmt & ESS_FMT_16BIT) /* 8bit is already word shifted */
1249                         es->wav_shift++;
1250         }
1251         es->bob_freq = snd_es1968_calc_bob_rate(chip, es, runtime);
1252
1253         switch (es->mode) {
1254         case ESM_MODE_PLAY:
1255                 snd_es1968_playback_setup(chip, es, runtime);
1256                 break;
1257         case ESM_MODE_CAPTURE:
1258                 snd_es1968_capture_setup(chip, es, runtime);
1259                 break;
1260         }
1261
1262         return 0;
1263 }
1264
1265 static int snd_es1968_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1266 {
1267         struct es1968 *chip = snd_pcm_substream_chip(substream);
1268         struct esschan *es = substream->runtime->private_data;
1269
1270         spin_lock(&chip->substream_lock);
1271         switch (cmd) {
1272         case SNDRV_PCM_TRIGGER_START:
1273         case SNDRV_PCM_TRIGGER_RESUME:
1274                 if (es->running)
1275                         break;
1276                 snd_es1968_bob_inc(chip, es->bob_freq);
1277                 es->count = 0;
1278                 es->hwptr = 0;
1279                 snd_es1968_pcm_start(chip, es);
1280                 es->running = 1;
1281                 break;
1282         case SNDRV_PCM_TRIGGER_STOP:
1283         case SNDRV_PCM_TRIGGER_SUSPEND:
1284                 if (! es->running)
1285                         break;
1286                 snd_es1968_pcm_stop(chip, es);
1287                 es->running = 0;
1288                 snd_es1968_bob_dec(chip);
1289                 break;
1290         }
1291         spin_unlock(&chip->substream_lock);
1292         return 0;
1293 }
1294
1295 static snd_pcm_uframes_t snd_es1968_pcm_pointer(struct snd_pcm_substream *substream)
1296 {
1297         struct es1968 *chip = snd_pcm_substream_chip(substream);
1298         struct esschan *es = substream->runtime->private_data;
1299         unsigned int ptr;
1300
1301         ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1302
1303         return bytes_to_frames(substream->runtime, ptr % es->dma_size);
1304 }
1305
1306 static struct snd_pcm_hardware snd_es1968_playback = {
1307         .info =                 (SNDRV_PCM_INFO_MMAP |
1308                                  SNDRV_PCM_INFO_MMAP_VALID |
1309                                  SNDRV_PCM_INFO_INTERLEAVED |
1310                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1311                                  /*SNDRV_PCM_INFO_PAUSE |*/
1312                                  SNDRV_PCM_INFO_RESUME),
1313         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
1314         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1315         .rate_min =             4000,
1316         .rate_max =             48000,
1317         .channels_min =         1,
1318         .channels_max =         2,
1319         .buffer_bytes_max =     65536,
1320         .period_bytes_min =     256,
1321         .period_bytes_max =     65536,
1322         .periods_min =          1,
1323         .periods_max =          1024,
1324         .fifo_size =            0,
1325 };
1326
1327 static struct snd_pcm_hardware snd_es1968_capture = {
1328         .info =                 (SNDRV_PCM_INFO_NONINTERLEAVED |
1329                                  SNDRV_PCM_INFO_MMAP |
1330                                  SNDRV_PCM_INFO_MMAP_VALID |
1331                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1332                                  /*SNDRV_PCM_INFO_PAUSE |*/
1333                                  SNDRV_PCM_INFO_RESUME),
1334         .formats =              /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE,
1335         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1336         .rate_min =             4000,
1337         .rate_max =             48000,
1338         .channels_min =         1,
1339         .channels_max =         2,
1340         .buffer_bytes_max =     65536,
1341         .period_bytes_min =     256,
1342         .period_bytes_max =     65536,
1343         .periods_min =          1,
1344         .periods_max =          1024,
1345         .fifo_size =            0,
1346 };
1347
1348 /* *************************
1349    * DMA memory management *
1350    *************************/
1351
1352 /* Because the Maestro can only take addresses relative to the PCM base address
1353    register :( */
1354
1355 static int calc_available_memory_size(struct es1968 *chip)
1356 {
1357         int max_size = 0;
1358         struct esm_memory *buf;
1359
1360         mutex_lock(&chip->memory_mutex);
1361         list_for_each_entry(buf, &chip->buf_list, list) {
1362                 if (buf->empty && buf->buf.bytes > max_size)
1363                         max_size = buf->buf.bytes;
1364         }
1365         mutex_unlock(&chip->memory_mutex);
1366         if (max_size >= 128*1024)
1367                 max_size = 127*1024;
1368         return max_size;
1369 }
1370
1371 /* allocate a new memory chunk with the specified size */
1372 static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size)
1373 {
1374         struct esm_memory *buf;
1375
1376         size = ALIGN(size, ESM_MEM_ALIGN);
1377         mutex_lock(&chip->memory_mutex);
1378         list_for_each_entry(buf, &chip->buf_list, list) {
1379                 if (buf->empty && buf->buf.bytes >= size)
1380                         goto __found;
1381         }
1382         mutex_unlock(&chip->memory_mutex);
1383         return NULL;
1384
1385 __found:
1386         if (buf->buf.bytes > size) {
1387                 struct esm_memory *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
1388                 if (chunk == NULL) {
1389                         mutex_unlock(&chip->memory_mutex);
1390                         return NULL;
1391                 }
1392                 chunk->buf = buf->buf;
1393                 chunk->buf.bytes -= size;
1394                 chunk->buf.area += size;
1395                 chunk->buf.addr += size;
1396                 chunk->empty = 1;
1397                 buf->buf.bytes = size;
1398                 list_add(&chunk->list, &buf->list);
1399         }
1400         buf->empty = 0;
1401         mutex_unlock(&chip->memory_mutex);
1402         return buf;
1403 }
1404
1405 /* free a memory chunk */
1406 static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf)
1407 {
1408         struct esm_memory *chunk;
1409
1410         mutex_lock(&chip->memory_mutex);
1411         buf->empty = 1;
1412         if (buf->list.prev != &chip->buf_list) {
1413                 chunk = list_entry(buf->list.prev, struct esm_memory, list);
1414                 if (chunk->empty) {
1415                         chunk->buf.bytes += buf->buf.bytes;
1416                         list_del(&buf->list);
1417                         kfree(buf);
1418                         buf = chunk;
1419                 }
1420         }
1421         if (buf->list.next != &chip->buf_list) {
1422                 chunk = list_entry(buf->list.next, struct esm_memory, list);
1423                 if (chunk->empty) {
1424                         buf->buf.bytes += chunk->buf.bytes;
1425                         list_del(&chunk->list);
1426                         kfree(chunk);
1427                 }
1428         }
1429         mutex_unlock(&chip->memory_mutex);
1430 }
1431
1432 static void snd_es1968_free_dmabuf(struct es1968 *chip)
1433 {
1434         struct list_head *p;
1435
1436         if (! chip->dma.area)
1437                 return;
1438         snd_dma_reserve_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci));
1439         while ((p = chip->buf_list.next) != &chip->buf_list) {
1440                 struct esm_memory *chunk = list_entry(p, struct esm_memory, list);
1441                 list_del(p);
1442                 kfree(chunk);
1443         }
1444 }
1445
1446 static int __devinit
1447 snd_es1968_init_dmabuf(struct es1968 *chip)
1448 {
1449         int err;
1450         struct esm_memory *chunk;
1451
1452         chip->dma.dev.type = SNDRV_DMA_TYPE_DEV;
1453         chip->dma.dev.dev = snd_dma_pci_data(chip->pci);
1454         if (! snd_dma_get_reserved_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci))) {
1455                 err = snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV,
1456                                                    snd_dma_pci_data(chip->pci),
1457                                                    chip->total_bufsize, &chip->dma);
1458                 if (err < 0 || ! chip->dma.area) {
1459                         snd_printk(KERN_ERR "es1968: can't allocate dma pages for size %d\n",
1460                                    chip->total_bufsize);
1461                         return -ENOMEM;
1462                 }
1463                 if ((chip->dma.addr + chip->dma.bytes - 1) & ~((1 << 28) - 1)) {
1464                         snd_dma_free_pages(&chip->dma);
1465                         snd_printk(KERN_ERR "es1968: DMA buffer beyond 256MB.\n");
1466                         return -ENOMEM;
1467                 }
1468         }
1469
1470         INIT_LIST_HEAD(&chip->buf_list);
1471         /* allocate an empty chunk */
1472         chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
1473         if (chunk == NULL) {
1474                 snd_es1968_free_dmabuf(chip);
1475                 return -ENOMEM;
1476         }
1477         memset(chip->dma.area, 0, ESM_MEM_ALIGN);
1478         chunk->buf = chip->dma;
1479         chunk->buf.area += ESM_MEM_ALIGN;
1480         chunk->buf.addr += ESM_MEM_ALIGN;
1481         chunk->buf.bytes -= ESM_MEM_ALIGN;
1482         chunk->empty = 1;
1483         list_add(&chunk->list, &chip->buf_list);
1484
1485         return 0;
1486 }
1487
1488 /* setup the dma_areas */
1489 /* buffer is extracted from the pre-allocated memory chunk */
1490 static int snd_es1968_hw_params(struct snd_pcm_substream *substream,
1491                                 struct snd_pcm_hw_params *hw_params)
1492 {
1493         struct es1968 *chip = snd_pcm_substream_chip(substream);
1494         struct snd_pcm_runtime *runtime = substream->runtime;
1495         struct esschan *chan = runtime->private_data;
1496         int size = params_buffer_bytes(hw_params);
1497
1498         if (chan->memory) {
1499                 if (chan->memory->buf.bytes >= size) {
1500                         runtime->dma_bytes = size;
1501                         return 0;
1502                 }
1503                 snd_es1968_free_memory(chip, chan->memory);
1504         }
1505         chan->memory = snd_es1968_new_memory(chip, size);
1506         if (chan->memory == NULL) {
1507                 // snd_printd("cannot allocate dma buffer: size = %d\n", size);
1508                 return -ENOMEM;
1509         }
1510         snd_pcm_set_runtime_buffer(substream, &chan->memory->buf);
1511         return 1; /* area was changed */
1512 }
1513
1514 /* remove dma areas if allocated */
1515 static int snd_es1968_hw_free(struct snd_pcm_substream *substream)
1516 {
1517         struct es1968 *chip = snd_pcm_substream_chip(substream);
1518         struct snd_pcm_runtime *runtime = substream->runtime;
1519         struct esschan *chan;
1520
1521         if (runtime->private_data == NULL)
1522                 return 0;
1523         chan = runtime->private_data;
1524         if (chan->memory) {
1525                 snd_es1968_free_memory(chip, chan->memory);
1526                 chan->memory = NULL;
1527         }
1528         return 0;
1529 }
1530
1531
1532 /*
1533  * allocate APU pair
1534  */
1535 static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type)
1536 {
1537         int apu;
1538
1539         for (apu = 0; apu < NR_APUS; apu += 2) {
1540                 if (chip->apu[apu] == ESM_APU_FREE &&
1541                     chip->apu[apu + 1] == ESM_APU_FREE) {
1542                         chip->apu[apu] = chip->apu[apu + 1] = type;
1543                         return apu;
1544                 }
1545         }
1546         return -EBUSY;
1547 }
1548
1549 /*
1550  * release APU pair
1551  */
1552 static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu)
1553 {
1554         chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE;
1555 }
1556
1557
1558 /******************
1559  * PCM open/close *
1560  ******************/
1561
1562 static int snd_es1968_playback_open(struct snd_pcm_substream *substream)
1563 {
1564         struct es1968 *chip = snd_pcm_substream_chip(substream);
1565         struct snd_pcm_runtime *runtime = substream->runtime;
1566         struct esschan *es;
1567         int apu1;
1568
1569         /* search 2 APUs */
1570         apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY);
1571         if (apu1 < 0)
1572                 return apu1;
1573
1574         es = kzalloc(sizeof(*es), GFP_KERNEL);
1575         if (!es) {
1576                 snd_es1968_free_apu_pair(chip, apu1);
1577                 return -ENOMEM;
1578         }
1579
1580         es->apu[0] = apu1;
1581         es->apu[1] = apu1 + 1;
1582         es->apu_mode[0] = 0;
1583         es->apu_mode[1] = 0;
1584         es->running = 0;
1585         es->substream = substream;
1586         es->mode = ESM_MODE_PLAY;
1587
1588         runtime->private_data = es;
1589         runtime->hw = snd_es1968_playback;
1590         runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
1591                 calc_available_memory_size(chip);
1592
1593         spin_lock_irq(&chip->substream_lock);
1594         list_add(&es->list, &chip->substream_list);
1595         spin_unlock_irq(&chip->substream_lock);
1596
1597         return 0;
1598 }
1599
1600 static int snd_es1968_capture_open(struct snd_pcm_substream *substream)
1601 {
1602         struct snd_pcm_runtime *runtime = substream->runtime;
1603         struct es1968 *chip = snd_pcm_substream_chip(substream);
1604         struct esschan *es;
1605         int apu1, apu2;
1606
1607         apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
1608         if (apu1 < 0)
1609                 return apu1;
1610         apu2 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_RATECONV);
1611         if (apu2 < 0) {
1612                 snd_es1968_free_apu_pair(chip, apu1);
1613                 return apu2;
1614         }
1615
1616         es = kzalloc(sizeof(*es), GFP_KERNEL);
1617         if (!es) {
1618                 snd_es1968_free_apu_pair(chip, apu1);
1619                 snd_es1968_free_apu_pair(chip, apu2);
1620                 return -ENOMEM;
1621         }
1622
1623         es->apu[0] = apu1;
1624         es->apu[1] = apu1 + 1;
1625         es->apu[2] = apu2;
1626         es->apu[3] = apu2 + 1;
1627         es->apu_mode[0] = 0;
1628         es->apu_mode[1] = 0;
1629         es->apu_mode[2] = 0;
1630         es->apu_mode[3] = 0;
1631         es->running = 0;
1632         es->substream = substream;
1633         es->mode = ESM_MODE_CAPTURE;
1634
1635         /* get mixbuffer */
1636         if ((es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE)) == NULL) {
1637                 snd_es1968_free_apu_pair(chip, apu1);
1638                 snd_es1968_free_apu_pair(chip, apu2);
1639                 kfree(es);
1640                 return -ENOMEM;
1641         }
1642         memset(es->mixbuf->buf.area, 0, ESM_MIXBUF_SIZE);
1643
1644         runtime->private_data = es;
1645         runtime->hw = snd_es1968_capture;
1646         runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
1647                 calc_available_memory_size(chip) - 1024; /* keep MIXBUF size */
1648         snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1649
1650         spin_lock_irq(&chip->substream_lock);
1651         list_add(&es->list, &chip->substream_list);
1652         spin_unlock_irq(&chip->substream_lock);
1653
1654         return 0;
1655 }
1656
1657 static int snd_es1968_playback_close(struct snd_pcm_substream *substream)
1658 {
1659         struct es1968 *chip = snd_pcm_substream_chip(substream);
1660         struct esschan *es;
1661
1662         if (substream->runtime->private_data == NULL)
1663                 return 0;
1664         es = substream->runtime->private_data;
1665         spin_lock_irq(&chip->substream_lock);
1666         list_del(&es->list);
1667         spin_unlock_irq(&chip->substream_lock);
1668         snd_es1968_free_apu_pair(chip, es->apu[0]);
1669         kfree(es);
1670
1671         return 0;
1672 }
1673
1674 static int snd_es1968_capture_close(struct snd_pcm_substream *substream)
1675 {
1676         struct es1968 *chip = snd_pcm_substream_chip(substream);
1677         struct esschan *es;
1678
1679         if (substream->runtime->private_data == NULL)
1680                 return 0;
1681         es = substream->runtime->private_data;
1682         spin_lock_irq(&chip->substream_lock);
1683         list_del(&es->list);
1684         spin_unlock_irq(&chip->substream_lock);
1685         snd_es1968_free_memory(chip, es->mixbuf);
1686         snd_es1968_free_apu_pair(chip, es->apu[0]);
1687         snd_es1968_free_apu_pair(chip, es->apu[2]);
1688         kfree(es);
1689
1690         return 0;
1691 }
1692
1693 static struct snd_pcm_ops snd_es1968_playback_ops = {
1694         .open =         snd_es1968_playback_open,
1695         .close =        snd_es1968_playback_close,
1696         .ioctl =        snd_pcm_lib_ioctl,
1697         .hw_params =    snd_es1968_hw_params,
1698         .hw_free =      snd_es1968_hw_free,
1699         .prepare =      snd_es1968_pcm_prepare,
1700         .trigger =      snd_es1968_pcm_trigger,
1701         .pointer =      snd_es1968_pcm_pointer,
1702 };
1703
1704 static struct snd_pcm_ops snd_es1968_capture_ops = {
1705         .open =         snd_es1968_capture_open,
1706         .close =        snd_es1968_capture_close,
1707         .ioctl =        snd_pcm_lib_ioctl,
1708         .hw_params =    snd_es1968_hw_params,
1709         .hw_free =      snd_es1968_hw_free,
1710         .prepare =      snd_es1968_pcm_prepare,
1711         .trigger =      snd_es1968_pcm_trigger,
1712         .pointer =      snd_es1968_pcm_pointer,
1713 };
1714
1715
1716 /*
1717  * measure clock
1718  */
1719 #define CLOCK_MEASURE_BUFSIZE   16768   /* enough large for a single shot */
1720
1721 static void __devinit es1968_measure_clock(struct es1968 *chip)
1722 {
1723         int i, apu;
1724         unsigned int pa, offset, t;
1725         struct esm_memory *memory;
1726         struct timeval start_time, stop_time;
1727
1728         if (chip->clock == 0)
1729                 chip->clock = 48000; /* default clock value */
1730
1731         /* search 2 APUs (although one apu is enough) */
1732         if ((apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY)) < 0) {
1733                 snd_printk(KERN_ERR "Hmm, cannot find empty APU pair!?\n");
1734                 return;
1735         }
1736         if ((memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE)) == NULL) {
1737                 snd_printk(KERN_ERR "cannot allocate dma buffer - using default clock %d\n", chip->clock);
1738                 snd_es1968_free_apu_pair(chip, apu);
1739                 return;
1740         }
1741
1742         memset(memory->buf.area, 0, CLOCK_MEASURE_BUFSIZE);
1743
1744         wave_set_register(chip, apu << 3, (memory->buf.addr - 0x10) & 0xfff8);
1745
1746         pa = (unsigned int)((memory->buf.addr - chip->dma.addr) >> 1);
1747         pa |= 0x00400000;       /* System RAM (Bit 22) */
1748
1749         /* initialize apu */
1750         for (i = 0; i < 16; i++)
1751                 apu_set_register(chip, apu, i, 0x0000);
1752
1753         apu_set_register(chip, apu, 0, 0x400f);
1754         apu_set_register(chip, apu, 4, ((pa >> 16) & 0xff) << 8);
1755         apu_set_register(chip, apu, 5, pa & 0xffff);
1756         apu_set_register(chip, apu, 6, (pa + CLOCK_MEASURE_BUFSIZE/2) & 0xffff);
1757         apu_set_register(chip, apu, 7, CLOCK_MEASURE_BUFSIZE/2);
1758         apu_set_register(chip, apu, 8, 0x0000);
1759         apu_set_register(chip, apu, 9, 0xD000);
1760         apu_set_register(chip, apu, 10, 0x8F08);
1761         apu_set_register(chip, apu, 11, 0x0000);
1762         spin_lock_irq(&chip->reg_lock);
1763         outw(1, chip->io_port + 0x04); /* clear WP interrupts */
1764         outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); /* enable WP ints */
1765         spin_unlock_irq(&chip->reg_lock);
1766
1767         snd_es1968_apu_set_freq(chip, apu, ((unsigned int)48000 << 16) / chip->clock); /* 48000 Hz */
1768
1769         chip->in_measurement = 1;
1770         chip->measure_apu = apu;
1771         spin_lock_irq(&chip->reg_lock);
1772         snd_es1968_bob_inc(chip, ESM_BOB_FREQ);
1773         __apu_set_register(chip, apu, 5, pa & 0xffff);
1774         snd_es1968_trigger_apu(chip, apu, ESM_APU_16BITLINEAR);
1775         do_gettimeofday(&start_time);
1776         spin_unlock_irq(&chip->reg_lock);
1777         msleep(50);
1778         spin_lock_irq(&chip->reg_lock);
1779         offset = __apu_get_register(chip, apu, 5);
1780         do_gettimeofday(&stop_time);
1781         snd_es1968_trigger_apu(chip, apu, 0); /* stop */
1782         snd_es1968_bob_dec(chip);
1783         chip->in_measurement = 0;
1784         spin_unlock_irq(&chip->reg_lock);
1785
1786         /* check the current position */
1787         offset -= (pa & 0xffff);
1788         offset &= 0xfffe;
1789         offset += chip->measure_count * (CLOCK_MEASURE_BUFSIZE/2);
1790
1791         t = stop_time.tv_sec - start_time.tv_sec;
1792         t *= 1000000;
1793         if (stop_time.tv_usec < start_time.tv_usec)
1794                 t -= start_time.tv_usec - stop_time.tv_usec;
1795         else
1796                 t += stop_time.tv_usec - start_time.tv_usec;
1797         if (t == 0) {
1798                 snd_printk(KERN_ERR "?? calculation error..\n");
1799         } else {
1800                 offset *= 1000;
1801                 offset = (offset / t) * 1000 + ((offset % t) * 1000) / t;
1802                 if (offset < 47500 || offset > 48500) {
1803                         if (offset >= 40000 && offset <= 50000)
1804                                 chip->clock = (chip->clock * offset) / 48000;
1805                 }
1806                 printk(KERN_INFO "es1968: clocking to %d\n", chip->clock);
1807         }
1808         snd_es1968_free_memory(chip, memory);
1809         snd_es1968_free_apu_pair(chip, apu);
1810 }
1811
1812
1813 /*
1814  */
1815
1816 static void snd_es1968_pcm_free(struct snd_pcm *pcm)
1817 {
1818         struct es1968 *esm = pcm->private_data;
1819         snd_es1968_free_dmabuf(esm);
1820         esm->pcm = NULL;
1821 }
1822
1823 static int __devinit
1824 snd_es1968_pcm(struct es1968 *chip, int device)
1825 {
1826         struct snd_pcm *pcm;
1827         int err;
1828
1829         /* get DMA buffer */
1830         if ((err = snd_es1968_init_dmabuf(chip)) < 0)
1831                 return err;
1832
1833         /* set PCMBAR */
1834         wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
1835         wave_set_register(chip, 0x01FD, chip->dma.addr >> 12);
1836         wave_set_register(chip, 0x01FE, chip->dma.addr >> 12);
1837         wave_set_register(chip, 0x01FF, chip->dma.addr >> 12);
1838
1839         if ((err = snd_pcm_new(chip->card, "ESS Maestro", device,
1840                                chip->playback_streams,
1841                                chip->capture_streams, &pcm)) < 0)
1842                 return err;
1843
1844         pcm->private_data = chip;
1845         pcm->private_free = snd_es1968_pcm_free;
1846
1847         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1968_playback_ops);
1848         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1968_capture_ops);
1849
1850         pcm->info_flags = 0;
1851
1852         strcpy(pcm->name, "ESS Maestro");
1853
1854         chip->pcm = pcm;
1855
1856         return 0;
1857 }
1858 /*
1859  * suppress jitter on some maestros when playing stereo
1860  */
1861 static void snd_es1968_suppress_jitter(struct es1968 *chip, struct esschan *es)
1862 {
1863         unsigned int cp1;
1864         unsigned int cp2;
1865         unsigned int diff;
1866
1867         cp1 = __apu_get_register(chip, 0, 5);
1868         cp2 = __apu_get_register(chip, 1, 5);
1869         diff = (cp1 > cp2 ? cp1 - cp2 : cp2 - cp1);
1870
1871         if (diff > 1)
1872                 __maestro_write(chip, IDR0_DATA_PORT, cp1);
1873 }
1874
1875 /*
1876  * update pointer
1877  */
1878 static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)
1879 {
1880         unsigned int hwptr;
1881         unsigned int diff;
1882         struct snd_pcm_substream *subs = es->substream;
1883
1884         if (subs == NULL || !es->running)
1885                 return;
1886
1887         hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1888         hwptr %= es->dma_size;
1889
1890         diff = (es->dma_size + hwptr - es->hwptr) % es->dma_size;
1891
1892         es->hwptr = hwptr;
1893         es->count += diff;
1894
1895         if (es->count > es->frag_size) {
1896                 spin_unlock(&chip->substream_lock);
1897                 snd_pcm_period_elapsed(subs);
1898                 spin_lock(&chip->substream_lock);
1899                 es->count %= es->frag_size;
1900         }
1901 }
1902
1903 /* The hardware volume works by incrementing / decrementing 2 counters
1904    (without wrap around) in response to volume button presses and then
1905    generating an interrupt. The pair of counters is stored in bits 1-3 and 5-7
1906    of a byte wide register. The meaning of bits 0 and 4 is unknown. */
1907 static void es1968_update_hw_volume(unsigned long private_data)
1908 {
1909         struct es1968 *chip = (struct es1968 *) private_data;
1910         int x, val;
1911 #ifndef CONFIG_SND_ES1968_INPUT
1912         unsigned long flags;
1913 #endif
1914
1915         /* Figure out which volume control button was pushed,
1916            based on differences from the default register
1917            values. */
1918         x = inb(chip->io_port + 0x1c) & 0xee;
1919         /* Reset the volume control registers. */
1920         outb(0x88, chip->io_port + 0x1c);
1921         outb(0x88, chip->io_port + 0x1d);
1922         outb(0x88, chip->io_port + 0x1e);
1923         outb(0x88, chip->io_port + 0x1f);
1924
1925         if (chip->in_suspend)
1926                 return;
1927
1928 #ifndef CONFIG_SND_ES1968_INPUT
1929         if (! chip->master_switch || ! chip->master_volume)
1930                 return;
1931
1932         /* FIXME: we can't call snd_ac97_* functions since here is in tasklet. */
1933         spin_lock_irqsave(&chip->ac97_lock, flags);
1934         val = chip->ac97->regs[AC97_MASTER];
1935         switch (x) {
1936         case 0x88:
1937                 /* mute */
1938                 val ^= 0x8000;
1939                 chip->ac97->regs[AC97_MASTER] = val;
1940                 outw(val, chip->io_port + ESM_AC97_DATA);
1941                 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1942                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1943                                &chip->master_switch->id);
1944                 break;
1945         case 0xaa:
1946                 /* volume up */
1947                 if ((val & 0x7f) > 0)
1948                         val--;
1949                 if ((val & 0x7f00) > 0)
1950                         val -= 0x0100;
1951                 chip->ac97->regs[AC97_MASTER] = val;
1952                 outw(val, chip->io_port + ESM_AC97_DATA);
1953                 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1954                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1955                                &chip->master_volume->id);
1956                 break;
1957         case 0x66:
1958                 /* volume down */
1959                 if ((val & 0x7f) < 0x1f)
1960                         val++;
1961                 if ((val & 0x7f00) < 0x1f00)
1962                         val += 0x0100;
1963                 chip->ac97->regs[AC97_MASTER] = val;
1964                 outw(val, chip->io_port + ESM_AC97_DATA);
1965                 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1966                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1967                                &chip->master_volume->id);
1968                 break;
1969         }
1970         spin_unlock_irqrestore(&chip->ac97_lock, flags);
1971 #else
1972         if (!chip->input_dev)
1973                 return;
1974
1975         val = 0;
1976         switch (x) {
1977         case 0x88:
1978                 /* The counters have not changed, yet we've received a HV
1979                    interrupt. According to tests run by various people this
1980                    happens when pressing the mute button. */
1981                 val = KEY_MUTE;
1982                 break;
1983         case 0xaa:
1984                 /* counters increased by 1 -> volume up */
1985                 val = KEY_VOLUMEUP;
1986                 break;
1987         case 0x66:
1988                 /* counters decreased by 1 -> volume down */
1989                 val = KEY_VOLUMEDOWN;
1990                 break;
1991         }
1992
1993         if (val) {
1994                 input_report_key(chip->input_dev, val, 1);
1995                 input_sync(chip->input_dev);
1996                 input_report_key(chip->input_dev, val, 0);
1997                 input_sync(chip->input_dev);
1998         }
1999 #endif
2000 }
2001
2002 /*
2003  * interrupt handler
2004  */
2005 static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id)
2006 {
2007         struct es1968 *chip = dev_id;
2008         u32 event;
2009
2010         if (!(event = inb(chip->io_port + 0x1A)))
2011                 return IRQ_NONE;
2012
2013         outw(inw(chip->io_port + 4) & 1, chip->io_port + 4);
2014
2015         if (event & ESM_HWVOL_IRQ)
2016 #ifdef CONFIG_SND_ES1968_INPUT
2017                 es1968_update_hw_volume((unsigned long)chip);
2018 #else
2019                 tasklet_schedule(&chip->hwvol_tq); /* we'll do this later */
2020 #endif
2021
2022         /* else ack 'em all, i imagine */
2023         outb(0xFF, chip->io_port + 0x1A);
2024
2025         if ((event & ESM_MPU401_IRQ) && chip->rmidi) {
2026                 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
2027         }
2028
2029         if (event & ESM_SOUND_IRQ) {
2030                 struct esschan *es;
2031                 spin_lock(&chip->substream_lock);
2032                 list_for_each_entry(es, &chip->substream_list, list) {
2033                         if (es->running) {
2034                                 snd_es1968_update_pcm(chip, es);
2035                                 if (es->fmt & ESS_FMT_STEREO)
2036                                         snd_es1968_suppress_jitter(chip, es);
2037                         }
2038                 }
2039                 spin_unlock(&chip->substream_lock);
2040                 if (chip->in_measurement) {
2041                         unsigned int curp = __apu_get_register(chip, chip->measure_apu, 5);
2042                         if (curp < chip->measure_lastpos)
2043                                 chip->measure_count++;
2044                         chip->measure_lastpos = curp;
2045                 }
2046         }
2047
2048         return IRQ_HANDLED;
2049 }
2050
2051 /*
2052  *  Mixer stuff
2053  */
2054
2055 static int __devinit
2056 snd_es1968_mixer(struct es1968 *chip)
2057 {
2058         struct snd_ac97_bus *pbus;
2059         struct snd_ac97_template ac97;
2060 #ifndef CONFIG_SND_ES1968_INPUT
2061         struct snd_ctl_elem_id elem_id;
2062 #endif
2063         int err;
2064         static struct snd_ac97_bus_ops ops = {
2065                 .write = snd_es1968_ac97_write,
2066                 .read = snd_es1968_ac97_read,
2067         };
2068
2069         if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
2070                 return err;
2071         pbus->no_vra = 1; /* ES1968 doesn't need VRA */
2072
2073         memset(&ac97, 0, sizeof(ac97));
2074         ac97.private_data = chip;
2075         if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97)) < 0)
2076                 return err;
2077
2078 #ifndef CONFIG_SND_ES1968_INPUT
2079         /* attach master switch / volumes for h/w volume control */
2080         memset(&elem_id, 0, sizeof(elem_id));
2081         elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2082         strcpy(elem_id.name, "Master Playback Switch");
2083         chip->master_switch = snd_ctl_find_id(chip->card, &elem_id);
2084         memset(&elem_id, 0, sizeof(elem_id));
2085         elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2086         strcpy(elem_id.name, "Master Playback Volume");
2087         chip->master_volume = snd_ctl_find_id(chip->card, &elem_id);
2088 #endif
2089
2090         return 0;
2091 }
2092
2093 /*
2094  * reset ac97 codec
2095  */
2096
2097 static void snd_es1968_ac97_reset(struct es1968 *chip)
2098 {
2099         unsigned long ioaddr = chip->io_port;
2100
2101         unsigned short save_ringbus_a;
2102         unsigned short save_68;
2103         unsigned short w;
2104         unsigned int vend;
2105
2106         /* save configuration */
2107         save_ringbus_a = inw(ioaddr + 0x36);
2108
2109         //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38); /* clear second codec id? */
2110         /* set command/status address i/o to 1st codec */
2111         outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2112         outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2113
2114         /* disable ac link */
2115         outw(0x0000, ioaddr + 0x36);
2116         save_68 = inw(ioaddr + 0x68);
2117         pci_read_config_word(chip->pci, 0x58, &w);      /* something magical with gpio and bus arb. */
2118         pci_read_config_dword(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2119         if (w & 1)
2120                 save_68 |= 0x10;
2121         outw(0xfffe, ioaddr + 0x64);    /* unmask gpio 0 */
2122         outw(0x0001, ioaddr + 0x68);    /* gpio write */
2123         outw(0x0000, ioaddr + 0x60);    /* write 0 to gpio 0 */
2124         udelay(20);
2125         outw(0x0001, ioaddr + 0x60);    /* write 1 to gpio 1 */
2126         msleep(20);
2127
2128         outw(save_68 | 0x1, ioaddr + 0x68);     /* now restore .. */
2129         outw((inw(ioaddr + 0x38) & 0xfffc) | 0x1, ioaddr + 0x38);
2130         outw((inw(ioaddr + 0x3a) & 0xfffc) | 0x1, ioaddr + 0x3a);
2131         outw((inw(ioaddr + 0x3c) & 0xfffc) | 0x1, ioaddr + 0x3c);
2132
2133         /* now the second codec */
2134         /* disable ac link */
2135         outw(0x0000, ioaddr + 0x36);
2136         outw(0xfff7, ioaddr + 0x64);    /* unmask gpio 3 */
2137         save_68 = inw(ioaddr + 0x68);
2138         outw(0x0009, ioaddr + 0x68);    /* gpio write 0 & 3 ?? */
2139         outw(0x0001, ioaddr + 0x60);    /* write 1 to gpio */
2140         udelay(20);
2141         outw(0x0009, ioaddr + 0x60);    /* write 9 to gpio */
2142         msleep(500);
2143         //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38);
2144         outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2145         outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2146
2147 #if 0                           /* the loop here needs to be much better if we want it.. */
2148         snd_printk(KERN_INFO "trying software reset\n");
2149         /* try and do a software reset */
2150         outb(0x80 | 0x7c, ioaddr + 0x30);
2151         for (w = 0;; w++) {
2152                 if ((inw(ioaddr + 0x30) & 1) == 0) {
2153                         if (inb(ioaddr + 0x32) != 0)
2154                                 break;
2155
2156                         outb(0x80 | 0x7d, ioaddr + 0x30);
2157                         if (((inw(ioaddr + 0x30) & 1) == 0)
2158                             && (inb(ioaddr + 0x32) != 0))
2159                                 break;
2160                         outb(0x80 | 0x7f, ioaddr + 0x30);
2161                         if (((inw(ioaddr + 0x30) & 1) == 0)
2162                             && (inb(ioaddr + 0x32) != 0))
2163                                 break;
2164                 }
2165
2166                 if (w > 10000) {
2167                         outb(inb(ioaddr + 0x37) | 0x08, ioaddr + 0x37); /* do a software reset */
2168                         msleep(500);    /* oh my.. */
2169                         outb(inb(ioaddr + 0x37) & ~0x08,
2170                                 ioaddr + 0x37);
2171                         udelay(1);
2172                         outw(0x80, ioaddr + 0x30);
2173                         for (w = 0; w < 10000; w++) {
2174                                 if ((inw(ioaddr + 0x30) & 1) == 0)
2175                                         break;
2176                         }
2177                 }
2178         }
2179 #endif
2180         if (vend == NEC_VERSA_SUBID1 || vend == NEC_VERSA_SUBID2) {
2181                 /* turn on external amp? */
2182                 outw(0xf9ff, ioaddr + 0x64);
2183                 outw(inw(ioaddr + 0x68) | 0x600, ioaddr + 0x68);
2184                 outw(0x0209, ioaddr + 0x60);
2185         }
2186
2187         /* restore.. */
2188         outw(save_ringbus_a, ioaddr + 0x36);
2189
2190         /* Turn on the 978 docking chip.
2191            First frob the "master output enable" bit,
2192            then set most of the playback volume control registers to max. */
2193         outb(inb(ioaddr+0xc0)|(1<<5), ioaddr+0xc0);
2194         outb(0xff, ioaddr+0xc3);
2195         outb(0xff, ioaddr+0xc4);
2196         outb(0xff, ioaddr+0xc6);
2197         outb(0xff, ioaddr+0xc8);
2198         outb(0x3f, ioaddr+0xcf);
2199         outb(0x3f, ioaddr+0xd0);
2200 }
2201
2202 static void snd_es1968_reset(struct es1968 *chip)
2203 {
2204         /* Reset */
2205         outw(ESM_RESET_MAESTRO | ESM_RESET_DIRECTSOUND,
2206              chip->io_port + ESM_PORT_HOST_IRQ);
2207         udelay(10);
2208         outw(0x0000, chip->io_port + ESM_PORT_HOST_IRQ);
2209         udelay(10);
2210 }
2211
2212 /*
2213  * initialize maestro chip
2214  */
2215 static void snd_es1968_chip_init(struct es1968 *chip)
2216 {
2217         struct pci_dev *pci = chip->pci;
2218         int i;
2219         unsigned long iobase  = chip->io_port;
2220         u16 w;
2221         u32 n;
2222
2223         /* We used to muck around with pci config space that
2224          * we had no business messing with.  We don't know enough
2225          * about the machine to know which DMA mode is appropriate,
2226          * etc.  We were guessing wrong on some machines and making
2227          * them unhappy.  We now trust in the BIOS to do things right,
2228          * which almost certainly means a new host of problems will
2229          * arise with broken BIOS implementations.  screw 'em.
2230          * We're already intolerant of machines that don't assign
2231          * IRQs.
2232          */
2233
2234         /* Config Reg A */
2235         pci_read_config_word(pci, ESM_CONFIG_A, &w);
2236
2237         w &= ~DMA_CLEAR;        /* Clear DMA bits */
2238         w &= ~(PIC_SNOOP1 | PIC_SNOOP2);        /* Clear Pic Snoop Mode Bits */
2239         w &= ~SAFEGUARD;        /* Safeguard off */
2240         w |= POST_WRITE;        /* Posted write */
2241         w |= PCI_TIMING;        /* PCI timing on */
2242         /* XXX huh?  claims to be reserved.. */
2243         w &= ~SWAP_LR;          /* swap left/right
2244                                    seems to only have effect on SB
2245                                    Emulation */
2246         w &= ~SUBTR_DECODE;     /* Subtractive decode off */
2247
2248         pci_write_config_word(pci, ESM_CONFIG_A, w);
2249
2250         /* Config Reg B */
2251
2252         pci_read_config_word(pci, ESM_CONFIG_B, &w);
2253
2254         w &= ~(1 << 15);        /* Turn off internal clock multiplier */
2255         /* XXX how do we know which to use? */
2256         w &= ~(1 << 14);        /* External clock */
2257
2258         w &= ~SPDIF_CONFB;      /* disable S/PDIF output */
2259         w |= HWV_CONFB;         /* HWV on */
2260         w |= DEBOUNCE;          /* Debounce off: easier to push the HW buttons */
2261         w &= ~GPIO_CONFB;       /* GPIO 4:5 */
2262         w |= CHI_CONFB;         /* Disconnect from the CHI.  Enabling this made a dell 7500 work. */
2263         w &= ~IDMA_CONFB;       /* IDMA off (undocumented) */
2264         w &= ~MIDI_FIX;         /* MIDI fix off (undoc) */
2265         w &= ~(1 << 1);         /* reserved, always write 0 */
2266         w &= ~IRQ_TO_ISA;       /* IRQ to ISA off (undoc) */
2267
2268         pci_write_config_word(pci, ESM_CONFIG_B, w);
2269
2270         /* DDMA off */
2271
2272         pci_read_config_word(pci, ESM_DDMA, &w);
2273         w &= ~(1 << 0);
2274         pci_write_config_word(pci, ESM_DDMA, w);
2275
2276         /*
2277          *      Legacy mode
2278          */
2279
2280         pci_read_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, &w);
2281
2282         w |= ESS_DISABLE_AUDIO; /* Disable Legacy Audio */
2283         w &= ~ESS_ENABLE_SERIAL_IRQ;    /* Disable SIRQ */
2284         w &= ~(0x1f);           /* disable mpu irq/io, game port, fm, SB */
2285
2286         pci_write_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, w);
2287
2288         /* Set up 978 docking control chip. */
2289         pci_read_config_word(pci, 0x58, &w);
2290         w|=1<<2;        /* Enable 978. */
2291         w|=1<<3;        /* Turn on 978 hardware volume control. */
2292         w&=~(1<<11);    /* Turn on 978 mixer volume control. */
2293         pci_write_config_word(pci, 0x58, w);
2294
2295         /* Sound Reset */
2296
2297         snd_es1968_reset(chip);
2298
2299         /*
2300          *      Ring Bus Setup
2301          */
2302
2303         /* setup usual 0x34 stuff.. 0x36 may be chip specific */
2304         outw(0xC090, iobase + ESM_RING_BUS_DEST); /* direct sound, stereo */
2305         udelay(20);
2306         outw(0x3000, iobase + ESM_RING_BUS_CONTR_A); /* enable ringbus/serial */
2307         udelay(20);
2308
2309         /*
2310          *      Reset the CODEC
2311          */
2312
2313         snd_es1968_ac97_reset(chip);
2314
2315         /* Ring Bus Control B */
2316
2317         n = inl(iobase + ESM_RING_BUS_CONTR_B);
2318         n &= ~RINGB_EN_SPDIF;   /* SPDIF off */
2319         //w |= RINGB_EN_2CODEC; /* enable 2nd codec */
2320         outl(n, iobase + ESM_RING_BUS_CONTR_B);
2321
2322         /* Set hardware volume control registers to midpoints.
2323            We can tell which button was pushed based on how they change. */
2324         outb(0x88, iobase+0x1c);
2325         outb(0x88, iobase+0x1d);
2326         outb(0x88, iobase+0x1e);
2327         outb(0x88, iobase+0x1f);
2328
2329         /* it appears some maestros (dell 7500) only work if these are set,
2330            regardless of wether we use the assp or not. */
2331
2332         outb(0, iobase + ASSP_CONTROL_B);
2333         outb(3, iobase + ASSP_CONTROL_A);       /* M: Reserved bits... */
2334         outb(0, iobase + ASSP_CONTROL_C);       /* M: Disable ASSP, ASSP IRQ's and FM Port */
2335
2336         /*
2337          * set up wavecache
2338          */
2339         for (i = 0; i < 16; i++) {
2340                 /* Write 0 into the buffer area 0x1E0->1EF */
2341                 outw(0x01E0 + i, iobase + WC_INDEX);
2342                 outw(0x0000, iobase + WC_DATA);
2343
2344                 /* The 1.10 test program seem to write 0 into the buffer area
2345                  * 0x1D0-0x1DF too.*/
2346                 outw(0x01D0 + i, iobase + WC_INDEX);
2347                 outw(0x0000, iobase + WC_DATA);
2348         }
2349         wave_set_register(chip, IDR7_WAVE_ROMRAM,
2350                           (wave_get_register(chip, IDR7_WAVE_ROMRAM) & 0xFF00));
2351         wave_set_register(chip, IDR7_WAVE_ROMRAM,
2352                           wave_get_register(chip, IDR7_WAVE_ROMRAM) | 0x100);
2353         wave_set_register(chip, IDR7_WAVE_ROMRAM,
2354                           wave_get_register(chip, IDR7_WAVE_ROMRAM) & ~0x200);
2355         wave_set_register(chip, IDR7_WAVE_ROMRAM,
2356                           wave_get_register(chip, IDR7_WAVE_ROMRAM) | ~0x400);
2357
2358
2359         maestro_write(chip, IDR2_CRAM_DATA, 0x0000);
2360         /* Now back to the DirectSound stuff */
2361         /* audio serial configuration.. ? */
2362         maestro_write(chip, 0x08, 0xB004);
2363         maestro_write(chip, 0x09, 0x001B);
2364         maestro_write(chip, 0x0A, 0x8000);
2365         maestro_write(chip, 0x0B, 0x3F37);
2366         maestro_write(chip, 0x0C, 0x0098);
2367
2368         /* parallel in, has something to do with recording :) */
2369         maestro_write(chip, 0x0C,
2370                       (maestro_read(chip, 0x0C) & ~0xF000) | 0x8000);
2371         /* parallel out */
2372         maestro_write(chip, 0x0C,
2373                       (maestro_read(chip, 0x0C) & ~0x0F00) | 0x0500);
2374
2375         maestro_write(chip, 0x0D, 0x7632);
2376
2377         /* Wave cache control on - test off, sg off,
2378            enable, enable extra chans 1Mb */
2379
2380         w = inw(iobase + WC_CONTROL);
2381
2382         w &= ~0xFA00;           /* Seems to be reserved? I don't know */
2383         w |= 0xA000;            /* reserved... I don't know */
2384         w &= ~0x0200;           /* Channels 56,57,58,59 as Extra Play,Rec Channel enable
2385                                    Seems to crash the Computer if enabled... */
2386         w |= 0x0100;            /* Wave Cache Operation Enabled */
2387         w |= 0x0080;            /* Channels 60/61 as Placback/Record enabled */
2388         w &= ~0x0060;           /* Clear Wavtable Size */
2389         w |= 0x0020;            /* Wavetable Size : 1MB */
2390         /* Bit 4 is reserved */
2391         w &= ~0x000C;           /* DMA Stuff? I don't understand what the datasheet means */
2392         /* Bit 1 is reserved */
2393         w &= ~0x0001;           /* Test Mode off */
2394
2395         outw(w, iobase + WC_CONTROL);
2396
2397         /* Now clear the APU control ram */
2398         for (i = 0; i < NR_APUS; i++) {
2399                 for (w = 0; w < NR_APU_REGS; w++)
2400                         apu_set_register(chip, i, w, 0);
2401
2402         }
2403 }
2404
2405 /* Enable IRQ's */
2406 static void snd_es1968_start_irq(struct es1968 *chip)
2407 {
2408         unsigned short w;
2409         w = ESM_HIRQ_DSIE | ESM_HIRQ_HW_VOLUME;
2410         if (chip->rmidi)
2411                 w |= ESM_HIRQ_MPU401;
2412         outb(w, chip->io_port + 0x1A);
2413         outw(w, chip->io_port + ESM_PORT_HOST_IRQ);
2414 }
2415
2416 #ifdef CONFIG_PM
2417 /*
2418  * PM support
2419  */
2420 static int es1968_suspend(struct pci_dev *pci, pm_message_t state)
2421 {
2422         struct snd_card *card = pci_get_drvdata(pci);
2423         struct es1968 *chip = card->private_data;
2424
2425         if (! chip->do_pm)
2426                 return 0;
2427
2428         chip->in_suspend = 1;
2429         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
2430         snd_pcm_suspend_all(chip->pcm);
2431         snd_ac97_suspend(chip->ac97);
2432         snd_es1968_bob_stop(chip);
2433
2434         pci_disable_device(pci);
2435         pci_save_state(pci);
2436         pci_set_power_state(pci, pci_choose_state(pci, state));
2437         return 0;
2438 }
2439
2440 static int es1968_resume(struct pci_dev *pci)
2441 {
2442         struct snd_card *card = pci_get_drvdata(pci);
2443         struct es1968 *chip = card->private_data;
2444         struct esschan *es;
2445
2446         if (! chip->do_pm)
2447                 return 0;
2448
2449         /* restore all our config */
2450         pci_set_power_state(pci, PCI_D0);
2451         pci_restore_state(pci);
2452         if (pci_enable_device(pci) < 0) {
2453                 printk(KERN_ERR "es1968: pci_enable_device failed, "
2454                        "disabling device\n");
2455                 snd_card_disconnect(card);
2456                 return -EIO;
2457         }
2458         pci_set_master(pci);
2459
2460         snd_es1968_chip_init(chip);
2461
2462         /* need to restore the base pointers.. */
2463         if (chip->dma.addr) {
2464                 /* set PCMBAR */
2465                 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
2466         }
2467
2468         snd_es1968_start_irq(chip);
2469
2470         /* restore ac97 state */
2471         snd_ac97_resume(chip->ac97);
2472
2473         list_for_each_entry(es, &chip->substream_list, list) {
2474                 switch (es->mode) {
2475                 case ESM_MODE_PLAY:
2476                         snd_es1968_playback_setup(chip, es, es->substream->runtime);
2477                         break;
2478                 case ESM_MODE_CAPTURE:
2479                         snd_es1968_capture_setup(chip, es, es->substream->runtime);
2480                         break;
2481                 }
2482         }
2483
2484         /* start timer again */
2485         if (chip->bobclient)
2486                 snd_es1968_bob_start(chip);
2487
2488         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
2489         chip->in_suspend = 0;
2490         return 0;
2491 }
2492 #endif /* CONFIG_PM */
2493
2494 #ifdef SUPPORT_JOYSTICK
2495 #define JOYSTICK_ADDR   0x200
2496 static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev)
2497 {
2498         struct gameport *gp;
2499         struct resource *r;
2500         u16 val;
2501
2502         if (!joystick[dev])
2503                 return -ENODEV;
2504
2505         r = request_region(JOYSTICK_ADDR, 8, "ES1968 gameport");
2506         if (!r)
2507                 return -EBUSY;
2508
2509         chip->gameport = gp = gameport_allocate_port();
2510         if (!gp) {
2511                 printk(KERN_ERR "es1968: cannot allocate memory for gameport\n");
2512                 release_and_free_resource(r);
2513                 return -ENOMEM;
2514         }
2515
2516         pci_read_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, &val);
2517         pci_write_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, val | 0x04);
2518
2519         gameport_set_name(gp, "ES1968 Gameport");
2520         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
2521         gameport_set_dev_parent(gp, &chip->pci->dev);
2522         gp->io = JOYSTICK_ADDR;
2523         gameport_set_port_data(gp, r);
2524
2525         gameport_register_port(gp);
2526
2527         return 0;
2528 }
2529
2530 static void snd_es1968_free_gameport(struct es1968 *chip)
2531 {
2532         if (chip->gameport) {
2533                 struct resource *r = gameport_get_port_data(chip->gameport);
2534
2535                 gameport_unregister_port(chip->gameport);
2536                 chip->gameport = NULL;
2537
2538                 release_and_free_resource(r);
2539         }
2540 }
2541 #else
2542 static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; }
2543 static inline void snd_es1968_free_gameport(struct es1968 *chip) { }
2544 #endif
2545
2546 #ifdef CONFIG_SND_ES1968_INPUT
2547 static int __devinit snd_es1968_input_register(struct es1968 *chip)
2548 {
2549         struct input_dev *input_dev;
2550         int err;
2551
2552         input_dev = input_allocate_device();
2553         if (!input_dev)
2554                 return -ENOMEM;
2555
2556         snprintf(chip->phys, sizeof(chip->phys), "pci-%s/input0",
2557                  pci_name(chip->pci));
2558
2559         input_dev->name = chip->card->driver;
2560         input_dev->phys = chip->phys;
2561         input_dev->id.bustype = BUS_PCI;
2562         input_dev->id.vendor  = chip->pci->vendor;
2563         input_dev->id.product = chip->pci->device;
2564         input_dev->dev.parent = &chip->pci->dev;
2565
2566         __set_bit(EV_KEY, input_dev->evbit);
2567         __set_bit(KEY_MUTE, input_dev->keybit);
2568         __set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
2569         __set_bit(KEY_VOLUMEUP, input_dev->keybit);
2570
2571         err = input_register_device(input_dev);
2572         if (err) {
2573                 input_free_device(input_dev);
2574                 return err;
2575         }
2576
2577         chip->input_dev = input_dev;
2578         return 0;
2579 }
2580 #endif /* CONFIG_SND_ES1968_INPUT */
2581
2582 #ifdef CONFIG_SND_ES1968_RADIO
2583 #define GPIO_DATA       0x60
2584 #define IO_MASK         4      /* mask      register offset from GPIO_DATA
2585                                 bits 1=unmask write to given bit */
2586 #define IO_DIR          8      /* direction register offset from GPIO_DATA
2587                                 bits 0/1=read/write direction */
2588 /* mask bits for GPIO lines */
2589 #define STR_DATA        0x0040 /* GPIO6 */
2590 #define STR_CLK         0x0080 /* GPIO7 */
2591 #define STR_WREN        0x0100 /* GPIO8 */
2592 #define STR_MOST        0x0200 /* GPIO9 */
2593
2594 static void snd_es1968_tea575x_set_pins(struct snd_tea575x *tea, u8 pins)
2595 {
2596         struct es1968 *chip = tea->private_data;
2597         unsigned long io = chip->io_port + GPIO_DATA;
2598         u16 val = 0;
2599
2600         val |= (pins & TEA575X_DATA) ? STR_DATA : 0;
2601         val |= (pins & TEA575X_CLK)  ? STR_CLK  : 0;
2602         val |= (pins & TEA575X_WREN) ? STR_WREN : 0;
2603
2604         outw(val, io);
2605 }
2606
2607 static u8 snd_es1968_tea575x_get_pins(struct snd_tea575x *tea)
2608 {
2609         struct es1968 *chip = tea->private_data;
2610         unsigned long io = chip->io_port + GPIO_DATA;
2611         u16 val = inw(io);
2612
2613         return  (val & STR_DATA) ? TEA575X_DATA : 0 |
2614                 (val & STR_MOST) ? TEA575X_MOST : 0;
2615 }
2616
2617 static void snd_es1968_tea575x_set_direction(struct snd_tea575x *tea, bool output)
2618 {
2619         struct es1968 *chip = tea->private_data;
2620         unsigned long io = chip->io_port + GPIO_DATA;
2621         u16 odir = inw(io + IO_DIR);
2622
2623         if (output) {
2624                 outw(~(STR_DATA | STR_CLK | STR_WREN), io + IO_MASK);
2625                 outw(odir | STR_DATA | STR_CLK | STR_WREN, io + IO_DIR);
2626         } else {
2627                 outw(~(STR_CLK | STR_WREN | STR_DATA | STR_MOST), io + IO_MASK);
2628                 outw((odir & ~(STR_DATA | STR_MOST)) | STR_CLK | STR_WREN, io + IO_DIR);
2629         }
2630 }
2631
2632 static struct snd_tea575x_ops snd_es1968_tea_ops = {
2633         .set_pins = snd_es1968_tea575x_set_pins,
2634         .get_pins = snd_es1968_tea575x_get_pins,
2635         .set_direction = snd_es1968_tea575x_set_direction,
2636 };
2637 #endif
2638
2639 static int snd_es1968_free(struct es1968 *chip)
2640 {
2641 #ifdef CONFIG_SND_ES1968_INPUT
2642         if (chip->input_dev)
2643                 input_unregister_device(chip->input_dev);
2644 #endif
2645
2646         if (chip->io_port) {
2647                 if (chip->irq >= 0)
2648                         synchronize_irq(chip->irq);
2649                 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
2650                 outw(0, chip->io_port + ESM_PORT_HOST_IRQ); /* disable IRQ */
2651         }
2652
2653 #ifdef CONFIG_SND_ES1968_RADIO
2654         snd_tea575x_exit(&chip->tea);
2655 #endif
2656
2657         if (chip->irq >= 0)
2658                 free_irq(chip->irq, chip);
2659         snd_es1968_free_gameport(chip);
2660         pci_release_regions(chip->pci);
2661         pci_disable_device(chip->pci);
2662         kfree(chip);
2663         return 0;
2664 }
2665
2666 static int snd_es1968_dev_free(struct snd_device *device)
2667 {
2668         struct es1968 *chip = device->device_data;
2669         return snd_es1968_free(chip);
2670 }
2671
2672 struct ess_device_list {
2673         unsigned short type;    /* chip type */
2674         unsigned short vendor;  /* subsystem vendor id */
2675 };
2676
2677 static struct ess_device_list pm_whitelist[] __devinitdata = {
2678         { TYPE_MAESTRO2E, 0x0e11 },     /* Compaq Armada */
2679         { TYPE_MAESTRO2E, 0x1028 },
2680         { TYPE_MAESTRO2E, 0x103c },
2681         { TYPE_MAESTRO2E, 0x1179 },
2682         { TYPE_MAESTRO2E, 0x14c0 },     /* HP omnibook 4150 */
2683         { TYPE_MAESTRO2E, 0x1558 },
2684 };
2685
2686 static struct ess_device_list mpu_blacklist[] __devinitdata = {
2687         { TYPE_MAESTRO2, 0x125d },
2688 };
2689
2690 static int __devinit snd_es1968_create(struct snd_card *card,
2691                                        struct pci_dev *pci,
2692                                        int total_bufsize,
2693                                        int play_streams,
2694                                        int capt_streams,
2695                                        int chip_type,
2696                                        int do_pm,
2697                                        struct es1968 **chip_ret)
2698 {
2699         static struct snd_device_ops ops = {
2700                 .dev_free =     snd_es1968_dev_free,
2701         };
2702         struct es1968 *chip;
2703         int i, err;
2704
2705         *chip_ret = NULL;
2706
2707         /* enable PCI device */
2708         if ((err = pci_enable_device(pci)) < 0)
2709                 return err;
2710         /* check, if we can restrict PCI DMA transfers to 28 bits */
2711         if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
2712             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
2713                 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
2714                 pci_disable_device(pci);
2715                 return -ENXIO;
2716         }
2717
2718         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
2719         if (! chip) {
2720                 pci_disable_device(pci);
2721                 return -ENOMEM;
2722         }
2723
2724         /* Set Vars */
2725         chip->type = chip_type;
2726         spin_lock_init(&chip->reg_lock);
2727         spin_lock_init(&chip->substream_lock);
2728         INIT_LIST_HEAD(&chip->buf_list);
2729         INIT_LIST_HEAD(&chip->substream_list);
2730         mutex_init(&chip->memory_mutex);
2731 #ifndef CONFIG_SND_ES1968_INPUT
2732         spin_lock_init(&chip->ac97_lock);
2733         tasklet_init(&chip->hwvol_tq, es1968_update_hw_volume, (unsigned long)chip);
2734 #endif
2735         chip->card = card;
2736         chip->pci = pci;
2737         chip->irq = -1;
2738         chip->total_bufsize = total_bufsize;    /* in bytes */
2739         chip->playback_streams = play_streams;
2740         chip->capture_streams = capt_streams;
2741
2742         if ((err = pci_request_regions(pci, "ESS Maestro")) < 0) {
2743                 kfree(chip);
2744                 pci_disable_device(pci);
2745                 return err;
2746         }
2747         chip->io_port = pci_resource_start(pci, 0);
2748         if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
2749                         "ESS Maestro", chip)) {
2750                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
2751                 snd_es1968_free(chip);
2752                 return -EBUSY;
2753         }
2754         chip->irq = pci->irq;
2755
2756         /* Clear Maestro_map */
2757         for (i = 0; i < 32; i++)
2758                 chip->maestro_map[i] = 0;
2759
2760         /* Clear Apu Map */
2761         for (i = 0; i < NR_APUS; i++)
2762                 chip->apu[i] = ESM_APU_FREE;
2763
2764         /* just to be sure */
2765         pci_set_master(pci);
2766
2767         if (do_pm > 1) {
2768                 /* disable power-management if not on the whitelist */
2769                 unsigned short vend;
2770                 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2771                 for (i = 0; i < (int)ARRAY_SIZE(pm_whitelist); i++) {
2772                         if (chip->type == pm_whitelist[i].type &&
2773                             vend == pm_whitelist[i].vendor) {
2774                                 do_pm = 1;
2775                                 break;
2776                         }
2777                 }
2778                 if (do_pm > 1) {
2779                         /* not matched; disabling pm */
2780                         printk(KERN_INFO "es1968: not attempting power management.\n");
2781                         do_pm = 0;
2782                 }
2783         }
2784         chip->do_pm = do_pm;
2785
2786         snd_es1968_chip_init(chip);
2787
2788         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2789                 snd_es1968_free(chip);
2790                 return err;
2791         }
2792
2793         snd_card_set_dev(card, &pci->dev);
2794
2795 #ifdef CONFIG_SND_ES1968_RADIO
2796         chip->tea.private_data = chip;
2797         chip->tea.ops = &snd_es1968_tea_ops;
2798         strlcpy(chip->tea.card, "SF64-PCE2", sizeof(chip->tea.card));
2799         sprintf(chip->tea.bus_info, "PCI:%s", pci_name(pci));
2800         if (!snd_tea575x_init(&chip->tea))
2801                 printk(KERN_INFO "es1968: detected TEA575x radio\n");
2802 #endif
2803
2804         *chip_ret = chip;
2805
2806         return 0;
2807 }
2808
2809
2810 /*
2811  */
2812 static int __devinit snd_es1968_probe(struct pci_dev *pci,
2813                                       const struct pci_device_id *pci_id)
2814 {
2815         static int dev;
2816         struct snd_card *card;
2817         struct es1968 *chip;
2818         unsigned int i;
2819         int err;
2820
2821         if (dev >= SNDRV_CARDS)
2822                 return -ENODEV;
2823         if (!enable[dev]) {
2824                 dev++;
2825                 return -ENOENT;
2826         }
2827
2828         err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
2829         if (err < 0)
2830                 return err;
2831
2832         if (total_bufsize[dev] < 128)
2833                 total_bufsize[dev] = 128;
2834         if (total_bufsize[dev] > 4096)
2835                 total_bufsize[dev] = 4096;
2836         if ((err = snd_es1968_create(card, pci,
2837                                      total_bufsize[dev] * 1024, /* in bytes */
2838                                      pcm_substreams_p[dev],
2839                                      pcm_substreams_c[dev],
2840                                      pci_id->driver_data,
2841                                      use_pm[dev],
2842                                      &chip)) < 0) {
2843                 snd_card_free(card);
2844                 return err;
2845         }
2846         card->private_data = chip;
2847
2848         switch (chip->type) {
2849         case TYPE_MAESTRO2E:
2850                 strcpy(card->driver, "ES1978");
2851                 strcpy(card->shortname, "ESS ES1978 (Maestro 2E)");
2852                 break;
2853         case TYPE_MAESTRO2:
2854                 strcpy(card->driver, "ES1968");
2855                 strcpy(card->shortname, "ESS ES1968 (Maestro 2)");
2856                 break;
2857         case TYPE_MAESTRO:
2858                 strcpy(card->driver, "ESM1");
2859                 strcpy(card->shortname, "ESS Maestro 1");
2860                 break;
2861         }
2862
2863         if ((err = snd_es1968_pcm(chip, 0)) < 0) {
2864                 snd_card_free(card);
2865                 return err;
2866         }
2867
2868         if ((err = snd_es1968_mixer(chip)) < 0) {
2869                 snd_card_free(card);
2870                 return err;
2871         }
2872
2873         if (enable_mpu[dev] == 2) {
2874                 /* check the black list */
2875                 unsigned short vend;
2876                 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2877                 for (i = 0; i < ARRAY_SIZE(mpu_blacklist); i++) {
2878                         if (chip->type == mpu_blacklist[i].type &&
2879                             vend == mpu_blacklist[i].vendor) {
2880                                 enable_mpu[dev] = 0;
2881                                 break;
2882                         }
2883                 }
2884         }
2885         if (enable_mpu[dev]) {
2886                 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
2887                                                chip->io_port + ESM_MPU401_PORT,
2888                                                MPU401_INFO_INTEGRATED,
2889                                                chip->irq, 0, &chip->rmidi)) < 0) {
2890                         printk(KERN_WARNING "es1968: skipping MPU-401 MIDI support..\n");
2891                 }
2892         }
2893
2894         snd_es1968_create_gameport(chip, dev);
2895
2896 #ifdef CONFIG_SND_ES1968_INPUT
2897         err = snd_es1968_input_register(chip);
2898         if (err)
2899                 snd_printk(KERN_WARNING "Input device registration "
2900                         "failed with error %i", err);
2901 #endif
2902
2903         snd_es1968_start_irq(chip);
2904
2905         chip->clock = clock[dev];
2906         if (! chip->clock)
2907                 es1968_measure_clock(chip);
2908
2909         sprintf(card->longname, "%s at 0x%lx, irq %i",
2910                 card->shortname, chip->io_port, chip->irq);
2911
2912         if ((err = snd_card_register(card)) < 0) {
2913                 snd_card_free(card);
2914                 return err;
2915         }
2916         pci_set_drvdata(pci, card);
2917         dev++;
2918         return 0;
2919 }
2920
2921 static void __devexit snd_es1968_remove(struct pci_dev *pci)
2922 {
2923         snd_card_free(pci_get_drvdata(pci));
2924         pci_set_drvdata(pci, NULL);
2925 }
2926
2927 static struct pci_driver driver = {
2928         .name = "ES1968 (ESS Maestro)",
2929         .id_table = snd_es1968_ids,
2930         .probe = snd_es1968_probe,
2931         .remove = __devexit_p(snd_es1968_remove),
2932 #ifdef CONFIG_PM
2933         .suspend = es1968_suspend,
2934         .resume = es1968_resume,
2935 #endif
2936 };
2937
2938 static int __init alsa_card_es1968_init(void)
2939 {
2940         return pci_register_driver(&driver);
2941 }
2942
2943 static void __exit alsa_card_es1968_exit(void)
2944 {
2945         pci_unregister_driver(&driver);
2946 }
2947
2948 module_init(alsa_card_es1968_init)
2949 module_exit(alsa_card_es1968_exit)