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