sound/pci/es1968.c

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