Linux Audio

Check our new training course

Loading...
Note: File does not exist in v5.9.
   1#undef FKS_LOGGING
   2#undef FKS_TEST
   3
   4/*
   5 * tabs should be 4 spaces, in vi(m): set tabstop=4
   6 *
   7 * TODO: 	consistency speed calculations!!
   8 *			cleanup!
   9 * ????:	Did I break MIDI support?
  10 *
  11 * History:
  12 *
  13 * Rolf Fokkens	 (Dec 20 1998):	ES188x recording level support on a per
  14 * fokkensr@vertis.nl			input basis.
  15 *				 (Dec 24 1998):	Recognition of ES1788, ES1887, ES1888,
  16 *								ES1868, ES1869 and ES1878. Could be used for
  17 *								specific handling in the future. All except
  18 *								ES1887 and ES1888 and ES688 are handled like
  19 *								ES1688.
  20 *				 (Dec 27 1998):	RECLEV for all (?) ES1688+ chips. ES188x now
  21 *								have the "Dec 20" support + RECLEV
  22 *				 (Jan  2 1999):	Preparation for Full Duplex. This means
  23 *								Audio 2 is now used for playback when dma16
  24 *								is specified. The next step would be to use
  25 *								Audio 1 and Audio 2 at the same time.
  26 *				 (Jan  9 1999):	Put all ESS stuff into sb_ess.[ch], this
  27 *								includes both the ESS stuff that has been in
  28 *								sb_*[ch] before I touched it and the ESS support
  29 *								I added later
  30 *				 (Jan 23 1999):	Full Duplex seems to work. I wrote a small
  31 *								test proggy which works OK. Haven't found
  32 *								any applications to test it though. So why did
  33 *								I bother to create it anyway?? :) Just for
  34 *								fun.
  35 *				 (May  2 1999):	I tried to be too smart by "introducing"
  36 *								ess_calc_best_speed (). The idea was that two
  37 *								dividers could be used to setup a samplerate,
  38 *								ess_calc_best_speed () would choose the best.
  39 *								This works for playback, but results in
  40 *								recording problems for high samplerates. I
  41 *								fixed this by removing ess_calc_best_speed ()
  42 *								and just doing what the documentation says. 
  43 * Andy Sloane   (Jun  4 1999): Stole some code from ALSA to fix the playback
  44 * andy@guildsoftware.com		speed on ES1869, ES1879, ES1887, and ES1888.
  45 * 								1879's were previously ignored by this driver;
  46 * 								added (untested) support for those.
  47 * Cvetan Ivanov (Oct 27 1999): Fixed ess_dsp_init to call ess_set_dma_hw for
  48 * zezo@inet.bg					_ALL_ ESS models, not only ES1887
  49 *
  50 * This files contains ESS chip specifics. It's based on the existing ESS
  51 * handling as it resided in sb_common.c, sb_mixer.c and sb_audio.c. This
  52 * file adds features like:
  53 * - Chip Identification (as shown in /proc/sound)
  54 * - RECLEV support for ES1688 and later
  55 * - 6 bits playback level support chips later than ES1688
  56 * - Recording level support on a per-device basis for ES1887
  57 * - Full-Duplex for ES1887
  58 *
  59 * Full duplex is enabled by specifying dma16. While the normal dma must
  60 * be one of 0, 1 or 3, dma16 can be one of 0, 1, 3 or 5. DMA 5 is a 16 bit
  61 * DMA channel, while the others are 8 bit..
  62 *
  63 * ESS detection isn't full proof (yet). If it fails an additional module
  64 * parameter esstype can be specified to be one of the following:
  65 * -1, 0, 688, 1688, 1868, 1869, 1788, 1887, 1888
  66 * -1 means: mimic 2.0 behaviour, 
  67 *  0 means: auto detect.
  68 *   others: explicitly specify chip
  69 * -1 is default, cause auto detect still doesn't work.
  70 */
  71
  72/*
  73 * About the documentation
  74 *
  75 * I don't know if the chips all are OK, but the documentation is buggy. 'cause
  76 * I don't have all the cips myself, there's a lot I cannot verify. I'll try to
  77 * keep track of my latest insights about his here. If you have additional info,
  78 * please enlighten me (fokkensr@vertis.nl)!
  79 *
  80 * I had the impression that ES1688 also has 6 bit master volume control. The
  81 * documentation about ES1888 (rev C, october '95) claims that ES1888 has
  82 * the following features ES1688 doesn't have:
  83 * - 6 bit master volume
  84 * - Full Duplex
  85 * So ES1688 apparently doesn't have 6 bit master volume control, but the
  86 * ES1688 does have RECLEV control. Makes me wonder: does ES688 have it too?
  87 * Without RECLEV ES688 won't be much fun I guess.
  88 *
  89 * From the ES1888 (rev C, october '95) documentation I got the impression
  90 * that registers 0x68 to 0x6e don't exist which means: no recording volume
  91 * controls. To my surprise the ES888 documentation (1/14/96) claims that
  92 * ES888 does have these record mixer registers, but that ES1888 doesn't have
  93 * 0x69 and 0x6b. So the rest should be there.
  94 *
  95 * I'm trying to get ES1887 Full Duplex. Audio 2 is playback only, while Audio 2
  96 * is both record and playback. I think I should use Audio 2 for all playback.
  97 *
  98 * The documentation is an adventure: it's close but not fully accurate. I
  99 * found out that after a reset some registers are *NOT* reset, though the
 100 * docs say the would be. Interesting ones are 0x7f, 0x7d and 0x7a. They are
 101 * related to the Audio 2 channel. I also was surprised about the consequences
 102 * of writing 0x00 to 0x7f (which should be done by reset): The ES1887 moves
 103 * into ES1888 mode. This means that it claims IRQ 11, which happens to be my
 104 * ISDN adapter. Needless to say it no longer worked. I now understand why
 105 * after rebooting 0x7f already was 0x05, the value of my choice: the BIOS
 106 * did it.
 107 *
 108 * Oh, and this is another trap: in ES1887 docs mixer register 0x70 is
 109 * described as if it's exactly the same as register 0xa1. This is *NOT* true.
 110 * The description of 0x70 in ES1869 docs is accurate however.
 111 * Well, the assumption about ES1869 was wrong: register 0x70 is very much
 112 * like register 0xa1, except that bit 7 is always 1, whatever you want
 113 * it to be.
 114 *
 115 * When using audio 2 mixer register 0x72 seems te be meaningless. Only 0xa2
 116 * has effect.
 117 *
 118 * Software reset not being able to reset all registers is great! Especially
 119 * the fact that register 0x78 isn't reset is great when you wanna change back
 120 * to single dma operation (simplex): audio 2 is still operational, and uses
 121 * the same dma as audio 1: your ess changes into a funny echo machine.
 122 *
 123 * Received the news that ES1688 is detected as a ES1788. Did some thinking:
 124 * the ES1887 detection scheme suggests in step 2 to try if bit 3 of register
 125 * 0x64 can be changed. This is inaccurate, first I inverted the * check: "If
 126 * can be modified, it's a 1688", which lead to a correct detection
 127 * of my ES1887. It resulted however in bad detection of 1688 (reported by mail)
 128 * and 1868 (if no PnP detection first): they result in a 1788 being detected.
 129 * I don't have docs on 1688, but I do have docs on 1868: The documentation is
 130 * probably inaccurate in the fact that I should check bit 2, not bit 3. This
 131 * is what I do now.
 132 */
 133
 134/*
 135 * About recognition of ESS chips
 136 *
 137 * The distinction of ES688, ES1688, ES1788, ES1887 and ES1888 is described in
 138 * a (preliminary ??) datasheet on ES1887. Its aim is to identify ES1887, but
 139 * during detection the text claims that "this chip may be ..." when a step
 140 * fails. This scheme is used to distinct between the above chips.
 141 * It appears however that some PnP chips like ES1868 are recognized as ES1788
 142 * by the ES1887 detection scheme. These PnP chips can be detected in another
 143 * way however: ES1868, ES1869 and ES1878 can be recognized (full proof I think)
 144 * by repeatedly reading mixer register 0x40. This is done by ess_identify in
 145 * sb_common.c.
 146 * This results in the following detection steps:
 147 * - distinct between ES688 and ES1688+ (as always done in this driver)
 148 *   if ES688 we're ready
 149 * - try to detect ES1868, ES1869 or ES1878
 150 *   if successful we're ready
 151 * - try to detect ES1888, ES1887 or ES1788
 152 *   if successful we're ready
 153 * - Dunno. Must be 1688. Will do in general
 154 *
 155 * About RECLEV support:
 156 *
 157 * The existing ES1688 support didn't take care of the ES1688+ recording
 158 * levels very well. Whenever a device was selected (recmask) for recording
 159 * its recording level was loud, and it couldn't be changed. The fact that
 160 * internal register 0xb4 could take care of RECLEV, didn't work meaning until
 161 * its value was restored every time the chip was reset; this reset the
 162 * value of 0xb4 too. I guess that's what 4front also had (have?) trouble with.
 163 *
 164 * About ES1887 support:
 165 *
 166 * The ES1887 has separate registers to control the recording levels, for all
 167 * inputs. The ES1887 specific software makes these levels the same as their
 168 * corresponding playback levels, unless recmask says they aren't recorded. In
 169 * the latter case the recording volumes are 0.
 170 * Now recording levels of inputs can be controlled, by changing the playback
 171 * levels. Furthermore several devices can be recorded together (which is not
 172 * possible with the ES1688).
 173 * Besides the separate recording level control for each input, the common
 174 * recording level can also be controlled by RECLEV as described above.
 175 *
 176 * Not only ES1887 have this recording mixer. I know the following from the
 177 * documentation:
 178 * ES688	no
 179 * ES1688	no
 180 * ES1868	no
 181 * ES1869	yes
 182 * ES1878	no
 183 * ES1879	yes
 184 * ES1888	no/yes	Contradicting documentation; most recent: yes
 185 * ES1946	yes		This is a PCI chip; not handled by this driver
 186 */
 187
 188#include <linux/delay.h>
 189#include <linux/interrupt.h>
 190#include <linux/spinlock.h>
 191
 192#include "sound_config.h"
 193#include "sb_mixer.h"
 194#include "sb.h"
 195
 196#include "sb_ess.h"
 197
 198#define ESSTYPE_LIKE20	-1		/* Mimic 2.0 behaviour					*/
 199#define ESSTYPE_DETECT	0		/* Mimic 2.0 behaviour					*/
 200
 201#define SUBMDL_ES1788	0x10	/* Subtype ES1788 for specific handling */
 202#define SUBMDL_ES1868	0x11	/* Subtype ES1868 for specific handling */
 203#define SUBMDL_ES1869	0x12	/* Subtype ES1869 for specific handling */
 204#define SUBMDL_ES1878	0x13	/* Subtype ES1878 for specific handling */
 205#define SUBMDL_ES1879	0x16    /* ES1879 was initially forgotten */
 206#define SUBMDL_ES1887	0x14	/* Subtype ES1887 for specific handling */
 207#define SUBMDL_ES1888	0x15	/* Subtype ES1888 for specific handling */
 208
 209#define SB_CAP_ES18XX_RATE 0x100
 210
 211#define ES1688_CLOCK1 795444 /* 128 - div */
 212#define ES1688_CLOCK2 397722 /* 256 - div */
 213#define ES18XX_CLOCK1 793800 /* 128 - div */
 214#define ES18XX_CLOCK2 768000 /* 256 - div */
 215
 216#ifdef FKS_LOGGING
 217static void ess_show_mixerregs (sb_devc *devc);
 218#endif
 219static int ess_read (sb_devc * devc, unsigned char reg);
 220static int ess_write (sb_devc * devc, unsigned char reg, unsigned char data);
 221static void ess_chgmixer
 222	(sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val);
 223
 224/****************************************************************************
 225 *																			*
 226 *									ESS audio								*
 227 *																			*
 228 ****************************************************************************/
 229
 230struct ess_command {short cmd; short data;};
 231
 232/*
 233 * Commands for initializing Audio 1 for input (record)
 234 */
 235static struct ess_command ess_i08m[] =		/* input 8 bit mono */
 236	{ {0xb7, 0x51}, {0xb7, 0xd0}, {-1, 0} };
 237static struct ess_command ess_i16m[] =		/* input 16 bit mono */
 238	{ {0xb7, 0x71}, {0xb7, 0xf4}, {-1, 0} };
 239static struct ess_command ess_i08s[] =		/* input 8 bit stereo */
 240	{ {0xb7, 0x51}, {0xb7, 0x98}, {-1, 0} };
 241static struct ess_command ess_i16s[] =		/* input 16 bit stereo */
 242	{ {0xb7, 0x71}, {0xb7, 0xbc}, {-1, 0} };
 243
 244static struct ess_command *ess_inp_cmds[] =
 245	{ ess_i08m, ess_i16m, ess_i08s, ess_i16s };
 246
 247
 248/*
 249 * Commands for initializing Audio 1 for output (playback)
 250 */
 251static struct ess_command ess_o08m[] =		/* output 8 bit mono */
 252	{ {0xb6, 0x80}, {0xb7, 0x51}, {0xb7, 0xd0}, {-1, 0} };
 253static struct ess_command ess_o16m[] =		/* output 16 bit mono */
 254	{ {0xb6, 0x00}, {0xb7, 0x71}, {0xb7, 0xf4}, {-1, 0} };
 255static struct ess_command ess_o08s[] =		/* output 8 bit stereo */
 256	{ {0xb6, 0x80}, {0xb7, 0x51}, {0xb7, 0x98}, {-1, 0} };
 257static struct ess_command ess_o16s[] =		/* output 16 bit stereo */
 258	{ {0xb6, 0x00}, {0xb7, 0x71}, {0xb7, 0xbc}, {-1, 0} };
 259
 260static struct ess_command *ess_out_cmds[] =
 261	{ ess_o08m, ess_o16m, ess_o08s, ess_o16s };
 262
 263static void ess_exec_commands
 264	(sb_devc *devc, struct ess_command *cmdtab[])
 265{
 266	struct ess_command *cmd;
 267
 268	cmd = cmdtab [ ((devc->channels != 1) << 1) + (devc->bits != AFMT_U8) ];
 269
 270	while (cmd->cmd != -1) {
 271		ess_write (devc, cmd->cmd, cmd->data);
 272		cmd++;
 273	}
 274}
 275
 276static void ess_change
 277	(sb_devc *devc, unsigned int reg, unsigned int mask, unsigned int val)
 278{
 279	int value;
 280
 281	value = ess_read (devc, reg);
 282	value = (value & ~mask) | (val & mask);
 283	ess_write (devc, reg, value);
 284}
 285
 286static void ess_set_output_parms
 287	(int dev, unsigned long buf, int nr_bytes, int intrflag)
 288{
 289	sb_devc *devc = audio_devs[dev]->devc;
 290
 291	if (devc->duplex) {
 292		devc->trg_buf_16 = buf;
 293		devc->trg_bytes_16 = nr_bytes;
 294		devc->trg_intrflag_16 = intrflag;
 295		devc->irq_mode_16 = IMODE_OUTPUT;
 296	} else {
 297		devc->trg_buf = buf;
 298		devc->trg_bytes = nr_bytes;
 299		devc->trg_intrflag = intrflag;
 300		devc->irq_mode = IMODE_OUTPUT;
 301	}
 302}
 303
 304static void ess_set_input_parms
 305	(int dev, unsigned long buf, int count, int intrflag)
 306{
 307	sb_devc *devc = audio_devs[dev]->devc;
 308
 309	devc->trg_buf = buf;
 310	devc->trg_bytes = count;
 311	devc->trg_intrflag = intrflag;
 312	devc->irq_mode = IMODE_INPUT;
 313}
 314
 315static int ess_calc_div (int clock, int revert, int *speedp, int *diffp)
 316{
 317	int divider;
 318	int speed, diff;
 319	int retval;
 320
 321	speed   = *speedp;
 322	divider = (clock + speed / 2) / speed;
 323	retval  = revert - divider;
 324	if (retval > revert - 1) {
 325		retval  = revert - 1;
 326		divider = revert - retval;
 327	}
 328	/* This line is suggested. Must be wrong I think
 329	*speedp = (clock + divider / 2) / divider;
 330	So I chose the next one */
 331
 332	*speedp	= clock / divider;
 333	diff	= speed - *speedp;
 334	if (diff < 0) diff =-diff;
 335	*diffp  = diff;
 336
 337	return retval;
 338}
 339
 340static int ess_calc_best_speed
 341	(int clock1, int rev1, int clock2, int rev2, int *divp, int *speedp)
 342{
 343	int speed1 = *speedp, speed2 = *speedp;
 344	int div1, div2;
 345	int diff1, diff2;
 346	int retval;
 347
 348	div1 = ess_calc_div (clock1, rev1, &speed1, &diff1);
 349	div2 = ess_calc_div (clock2, rev2, &speed2, &diff2);
 350
 351	if (diff1 < diff2) {
 352		*divp   = div1;
 353		*speedp = speed1;
 354		retval  = 1;
 355	} else {
 356	/*	*divp   = div2; */
 357		*divp   = 0x80 | div2;
 358		*speedp = speed2;
 359		retval  = 2;
 360	}
 361
 362	return retval;
 363}
 364
 365/*
 366 * Depending on the audiochannel ESS devices can
 367 * have different clock settings. These are made consistent for duplex
 368 * however.
 369 * callers of ess_speed only do an audionum suggestion, which means
 370 * input suggests 1, output suggests 2. This suggestion is only true
 371 * however when doing duplex.
 372 */
 373static void ess_common_speed (sb_devc *devc, int *speedp, int *divp)
 374{
 375	int diff = 0, div;
 376
 377	if (devc->duplex) {
 378		/*
 379		 * The 0x80 is important for the first audio channel
 380		 */
 381		if (devc->submodel == SUBMDL_ES1888) {
 382			div = 0x80 | ess_calc_div (795500, 256, speedp, &diff);
 383		} else {
 384			div = 0x80 | ess_calc_div (795500, 128, speedp, &diff);
 385		}
 386	} else if(devc->caps & SB_CAP_ES18XX_RATE) {
 387		if (devc->submodel == SUBMDL_ES1888) {
 388			ess_calc_best_speed(397700, 128, 795500, 256, 
 389						&div, speedp);
 390		} else {
 391			ess_calc_best_speed(ES18XX_CLOCK1, 128, ES18XX_CLOCK2, 256, 
 392						&div, speedp);
 393		}
 394	} else {
 395		if (*speedp > 22000) {
 396			div = 0x80 | ess_calc_div (ES1688_CLOCK1, 256, speedp, &diff);
 397		} else {
 398			div = 0x00 | ess_calc_div (ES1688_CLOCK2, 128, speedp, &diff);
 399		}
 400	}
 401	*divp = div;
 402}
 403
 404static void ess_speed (sb_devc *devc, int audionum)
 405{
 406	int speed;
 407	int div, div2;
 408
 409	ess_common_speed (devc, &(devc->speed), &div);
 410
 411#ifdef FKS_REG_LOGGING
 412printk (KERN_INFO "FKS: ess_speed (%d) b speed = %d, div=%x\n", audionum, devc->speed, div);
 413#endif
 414
 415	/* Set filter roll-off to 90% of speed/2 */
 416	speed = (devc->speed * 9) / 20;
 417
 418	div2 = 256 - 7160000 / (speed * 82);
 419
 420	if (!devc->duplex) audionum = 1;
 421
 422	if (audionum == 1) {
 423		/* Change behaviour of register A1 *
 424		sb_chg_mixer(devc, 0x71, 0x20, 0x20)
 425		* For ES1869 only??? */
 426		ess_write (devc, 0xa1, div);
 427		ess_write (devc, 0xa2, div2);
 428	} else {
 429		ess_setmixer (devc, 0x70, div);
 430		/*
 431		 * FKS: fascinating: 0x72 doesn't seem to work.
 432		 */
 433		ess_write (devc, 0xa2, div2);
 434		ess_setmixer (devc, 0x72, div2);
 435	}
 436}
 437
 438static int ess_audio_prepare_for_input(int dev, int bsize, int bcount)
 439{
 440	sb_devc *devc = audio_devs[dev]->devc;
 441
 442	ess_speed(devc, 1);
 443
 444	sb_dsp_command(devc, DSP_CMD_SPKOFF);
 445
 446	ess_write (devc, 0xb8, 0x0e);	/* Auto init DMA mode */
 447	ess_change (devc, 0xa8, 0x03, 3 - devc->channels);	/* Mono/stereo */
 448	ess_write (devc, 0xb9, 2);	/* Demand mode (4 bytes/DMA request) */
 449
 450	ess_exec_commands (devc, ess_inp_cmds);
 451
 452	ess_change (devc, 0xb1, 0xf0, 0x50);
 453	ess_change (devc, 0xb2, 0xf0, 0x50);
 454
 455	devc->trigger_bits = 0;
 456	return 0;
 457}
 458
 459static int ess_audio_prepare_for_output_audio1 (int dev, int bsize, int bcount)
 460{
 461	sb_devc *devc = audio_devs[dev]->devc;
 462
 463	sb_dsp_reset(devc);
 464	ess_speed(devc, 1);
 465	ess_write (devc, 0xb8, 4);	/* Auto init DMA mode */
 466	ess_change (devc, 0xa8, 0x03, 3 - devc->channels);	/* Mono/stereo */
 467	ess_write (devc, 0xb9, 2);	/* Demand mode (4 bytes/request) */
 468
 469	ess_exec_commands (devc, ess_out_cmds);
 470
 471	ess_change (devc, 0xb1, 0xf0, 0x50);	/* Enable DMA */
 472	ess_change (devc, 0xb2, 0xf0, 0x50);	/* Enable IRQ */
 473
 474	sb_dsp_command(devc, DSP_CMD_SPKON);	/* There be sound! */
 475
 476	devc->trigger_bits = 0;
 477	return 0;
 478}
 479
 480static int ess_audio_prepare_for_output_audio2 (int dev, int bsize, int bcount)
 481{
 482	sb_devc *devc = audio_devs[dev]->devc;
 483	unsigned char bits;
 484
 485/* FKS: qqq
 486	sb_dsp_reset(devc);
 487*/
 488
 489	/*
 490	 * Auto-Initialize:
 491	 * DMA mode + demand mode (8 bytes/request, yes I want it all!)
 492	 * But leave 16-bit DMA bit untouched!
 493	 */
 494	ess_chgmixer (devc, 0x78, 0xd0, 0xd0);
 495
 496	ess_speed(devc, 2);
 497
 498	/* bits 4:3 on ES1887 represent recording source. Keep them! */
 499	bits = ess_getmixer (devc, 0x7a) & 0x18;
 500
 501	/* Set stereo/mono */
 502	if (devc->channels != 1) bits |= 0x02;
 503
 504	/* Init DACs; UNSIGNED mode for 8 bit; SIGNED mode for 16 bit */
 505	if (devc->bits != AFMT_U8) bits |= 0x05;	/* 16 bit */
 506
 507	/* Enable DMA, IRQ will be shared (hopefully)*/
 508	bits |= 0x60;
 509
 510	ess_setmixer (devc, 0x7a, bits);
 511
 512	ess_mixer_reload (devc, SOUND_MIXER_PCM);	/* There be sound! */
 513
 514	devc->trigger_bits = 0;
 515	return 0;
 516}
 517
 518static int ess_audio_prepare_for_output(int dev, int bsize, int bcount)
 519{
 520	sb_devc *devc = audio_devs[dev]->devc;
 521
 522#ifdef FKS_REG_LOGGING
 523printk(KERN_INFO "ess_audio_prepare_for_output: dma_out=%d,dma_in=%d\n"
 524, audio_devs[dev]->dmap_out->dma, audio_devs[dev]->dmap_in->dma);
 525#endif
 526
 527	if (devc->duplex) {
 528		return ess_audio_prepare_for_output_audio2 (dev, bsize, bcount);
 529	} else {
 530		return ess_audio_prepare_for_output_audio1 (dev, bsize, bcount);
 531	}
 532}
 533
 534static void ess_audio_halt_xfer(int dev)
 535{
 536	unsigned long flags;
 537	sb_devc *devc = audio_devs[dev]->devc;
 538
 539	spin_lock_irqsave(&devc->lock, flags);
 540	sb_dsp_reset(devc);
 541	spin_unlock_irqrestore(&devc->lock, flags);
 542
 543	/*
 544	 * Audio 2 may still be operational! Creates awful sounds!
 545	 */
 546	if (devc->duplex) ess_chgmixer(devc, 0x78, 0x03, 0x00);
 547}
 548
 549static void ess_audio_start_input
 550	(int dev, unsigned long buf, int nr_bytes, int intrflag)
 551{
 552	int count = nr_bytes;
 553	sb_devc *devc = audio_devs[dev]->devc;
 554	short c = -nr_bytes;
 555
 556	/*
 557	 * Start a DMA input to the buffer pointed by dmaqtail
 558	 */
 559
 560	if (audio_devs[dev]->dmap_in->dma > 3) count >>= 1;
 561	count--;
 562
 563	devc->irq_mode = IMODE_INPUT;
 564
 565	ess_write (devc, 0xa4, (unsigned char) ((unsigned short) c & 0xff));
 566	ess_write (devc, 0xa5, (unsigned char) (((unsigned short) c >> 8) & 0xff));
 567
 568	ess_change (devc, 0xb8, 0x0f, 0x0f);	/* Go */
 569	devc->intr_active = 1;
 570}
 571
 572static void ess_audio_output_block_audio1
 573	(int dev, unsigned long buf, int nr_bytes, int intrflag)
 574{
 575	int count = nr_bytes;
 576	sb_devc *devc = audio_devs[dev]->devc;
 577	short c = -nr_bytes;
 578
 579	if (audio_devs[dev]->dmap_out->dma > 3)
 580		count >>= 1;
 581	count--;
 582
 583	devc->irq_mode = IMODE_OUTPUT;
 584
 585	ess_write (devc, 0xa4, (unsigned char) ((unsigned short) c & 0xff));
 586	ess_write (devc, 0xa5, (unsigned char) (((unsigned short) c >> 8) & 0xff));
 587
 588	ess_change (devc, 0xb8, 0x05, 0x05);	/* Go */
 589	devc->intr_active = 1;
 590}
 591
 592static void ess_audio_output_block_audio2
 593	(int dev, unsigned long buf, int nr_bytes, int intrflag)
 594{
 595	int count = nr_bytes;
 596	sb_devc *devc = audio_devs[dev]->devc;
 597	short c = -nr_bytes;
 598
 599	if (audio_devs[dev]->dmap_out->dma > 3) count >>= 1;
 600	count--;
 601
 602	ess_setmixer (devc, 0x74, (unsigned char) ((unsigned short) c & 0xff));
 603	ess_setmixer (devc, 0x76, (unsigned char) (((unsigned short) c >> 8) & 0xff));
 604	ess_chgmixer (devc, 0x78, 0x03, 0x03);   /* Go */
 605
 606	devc->irq_mode_16 = IMODE_OUTPUT;
 607		devc->intr_active_16 = 1;
 608}
 609
 610static void ess_audio_output_block
 611	(int dev, unsigned long buf, int nr_bytes, int intrflag)
 612{
 613	sb_devc *devc = audio_devs[dev]->devc;
 614
 615	if (devc->duplex) {
 616		ess_audio_output_block_audio2 (dev, buf, nr_bytes, intrflag);
 617	} else {
 618		ess_audio_output_block_audio1 (dev, buf, nr_bytes, intrflag);
 619	}
 620}
 621
 622/*
 623 * FKS: the if-statements for both bits and bits_16 are quite alike.
 624 * Combine this...
 625 */
 626static void ess_audio_trigger(int dev, int bits)
 627{
 628	sb_devc *devc = audio_devs[dev]->devc;
 629
 630	int bits_16 = bits & devc->irq_mode_16;
 631	bits &= devc->irq_mode;
 632
 633	if (!bits && !bits_16) {
 634		/* FKS oh oh.... wrong?? for dma 16? */
 635		sb_dsp_command(devc, 0xd0);	/* Halt DMA */
 636	}
 637
 638	if (bits) {
 639		switch (devc->irq_mode)
 640		{
 641			case IMODE_INPUT:
 642				ess_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
 643					devc->trg_intrflag);
 644				break;
 645
 646			case IMODE_OUTPUT:
 647				ess_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
 648					devc->trg_intrflag);
 649				break;
 650		}
 651	}
 652
 653	if (bits_16) {
 654		switch (devc->irq_mode_16) {
 655		case IMODE_INPUT:
 656			ess_audio_start_input(dev, devc->trg_buf_16, devc->trg_bytes_16,
 657					devc->trg_intrflag_16);
 658			break;
 659
 660		case IMODE_OUTPUT:
 661			ess_audio_output_block(dev, devc->trg_buf_16, devc->trg_bytes_16,
 662					devc->trg_intrflag_16);
 663			break;
 664		}
 665	}
 666
 667	devc->trigger_bits = bits | bits_16;
 668}
 669
 670static int ess_audio_set_speed(int dev, int speed)
 671{
 672	sb_devc *devc = audio_devs[dev]->devc;
 673	int minspeed, maxspeed, dummydiv;
 674
 675	if (speed > 0) {
 676		minspeed = (devc->duplex ? 6215  : 5000 );
 677		maxspeed = (devc->duplex ? 44100 : 48000);
 678		if (speed < minspeed) speed = minspeed;
 679		if (speed > maxspeed) speed = maxspeed;
 680
 681		ess_common_speed (devc, &speed, &dummydiv);
 682
 683		devc->speed = speed;
 684	}
 685	return devc->speed;
 686}
 687
 688/*
 689 * FKS: This is a one-on-one copy of sb1_audio_set_bits
 690 */
 691static unsigned int ess_audio_set_bits(int dev, unsigned int bits)
 692{
 693	sb_devc *devc = audio_devs[dev]->devc;
 694
 695	if (bits != 0) {
 696		if (bits == AFMT_U8 || bits == AFMT_S16_LE) {
 697			devc->bits = bits;
 698		} else {
 699			devc->bits = AFMT_U8;
 700		}
 701	}
 702
 703	return devc->bits;
 704}
 705
 706/*
 707 * FKS: This is a one-on-one copy of sbpro_audio_set_channels
 708 * (*) Modified it!!
 709 */
 710static short ess_audio_set_channels(int dev, short channels)
 711{
 712	sb_devc *devc = audio_devs[dev]->devc;
 713
 714	if (channels == 1 || channels == 2) devc->channels = channels;
 715
 716	return devc->channels;
 717}
 718
 719static struct audio_driver ess_audio_driver =   /* ESS ES688/1688 */
 720{
 721	.owner			= THIS_MODULE,
 722	.open			= sb_audio_open,
 723	.close			= sb_audio_close,
 724	.output_block		= ess_set_output_parms,
 725	.start_input		= ess_set_input_parms,
 726	.prepare_for_input	= ess_audio_prepare_for_input,
 727	.prepare_for_output	= ess_audio_prepare_for_output,
 728	.halt_io		= ess_audio_halt_xfer,
 729	.trigger		= ess_audio_trigger,
 730	.set_speed		= ess_audio_set_speed,
 731	.set_bits		= ess_audio_set_bits,
 732	.set_channels		= ess_audio_set_channels
 733};
 734
 735/*
 736 * ess_audio_init must be called from sb_audio_init
 737 */
 738struct audio_driver *ess_audio_init
 739		(sb_devc *devc, int *audio_flags, int *format_mask)
 740{
 741	*audio_flags = DMA_AUTOMODE;
 742	*format_mask |= AFMT_S16_LE;
 743
 744	if (devc->duplex) {
 745		int tmp_dma;
 746		/*
 747		 * sb_audio_init thinks dma8 is for playback and
 748		 * dma16 is for record. Not now! So swap them.
 749		 */
 750		tmp_dma		= devc->dma16;
 751		devc->dma16	= devc->dma8;
 752		devc->dma8	= tmp_dma;
 753
 754		*audio_flags |= DMA_DUPLEX;
 755	}
 756
 757	return &ess_audio_driver;
 758}
 759
 760/****************************************************************************
 761 *																			*
 762 *								ESS common									*
 763 *																			*
 764 ****************************************************************************/
 765static void ess_handle_channel
 766	(char *channel, int dev, int intr_active, unsigned char flag, int irq_mode)
 767{
 768	if (!intr_active || !flag) return;
 769#ifdef FKS_REG_LOGGING
 770printk(KERN_INFO "FKS: ess_handle_channel %s irq_mode=%d\n", channel, irq_mode);
 771#endif
 772	switch (irq_mode) {
 773		case IMODE_OUTPUT:
 774			DMAbuf_outputintr (dev, 1);
 775			break;
 776
 777		case IMODE_INPUT:
 778			DMAbuf_inputintr (dev);
 779			break;
 780
 781		case IMODE_INIT:
 782			break;
 783
 784		default:;
 785			/* printk(KERN_WARNING "ESS: Unexpected interrupt\n"); */
 786	}
 787}
 788
 789/*
 790 * FKS: TODO!!! Finish this!
 791 *
 792 * I think midi stuff uses uart401, without interrupts.
 793 * So IMODE_MIDI isn't a value for devc->irq_mode.
 794 */
 795void ess_intr (sb_devc *devc)
 796{
 797	int				status;
 798	unsigned char	src;
 799
 800	if (devc->submodel == SUBMDL_ES1887) {
 801		src = ess_getmixer (devc, 0x7f) >> 4;
 802	} else {
 803		src = 0xff;
 804	}
 805
 806#ifdef FKS_REG_LOGGING
 807printk(KERN_INFO "FKS: sbintr src=%x\n",(int)src);
 808#endif
 809	ess_handle_channel
 810		( "Audio 1"
 811		, devc->dev, devc->intr_active   , src & 0x01, devc->irq_mode   );
 812	ess_handle_channel
 813		( "Audio 2"
 814		, devc->dev, devc->intr_active_16, src & 0x02, devc->irq_mode_16);
 815	/*
 816	 * Acknowledge interrupts
 817	 */
 818	if (devc->submodel == SUBMDL_ES1887 && (src & 0x02)) {
 819		ess_chgmixer (devc, 0x7a, 0x80, 0x00);
 820	}
 821
 822	if (src & 0x01) {
 823		status = inb(DSP_DATA_AVAIL);
 824	}
 825}
 826
 827static void ess_extended (sb_devc * devc)
 828{
 829	/* Enable extended mode */
 830
 831	sb_dsp_command(devc, 0xc6);
 832}
 833
 834static int ess_write (sb_devc * devc, unsigned char reg, unsigned char data)
 835{
 836#ifdef FKS_REG_LOGGING
 837printk(KERN_INFO "FKS: write reg %x: %x\n", reg, data);
 838#endif
 839	/* Write a byte to an extended mode register of ES1688 */
 840
 841	if (!sb_dsp_command(devc, reg))
 842		return 0;
 843
 844	return sb_dsp_command(devc, data);
 845}
 846
 847static int ess_read (sb_devc * devc, unsigned char reg)
 848{
 849	/* Read a byte from an extended mode register of ES1688 */
 850
 851	/* Read register command */
 852	if (!sb_dsp_command(devc, 0xc0)) return -1;
 853
 854	if (!sb_dsp_command(devc, reg )) return -1;
 855
 856	return sb_dsp_get_byte(devc);
 857}
 858
 859int ess_dsp_reset(sb_devc * devc)
 860{
 861	int loopc;
 862
 863#ifdef FKS_REG_LOGGING
 864printk(KERN_INFO "FKS: ess_dsp_reset 1\n");
 865ess_show_mixerregs (devc);
 866#endif
 867
 868	outb(3, DSP_RESET); /* Reset FIFO too */
 869
 870	udelay(10);
 871	outb(0, DSP_RESET);
 872	udelay(30);
 873
 874	for (loopc = 0; loopc < 1000 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++);
 875
 876	if (inb(DSP_READ) != 0xAA) {
 877		DDB(printk("sb: No response to RESET\n"));
 878		return 0;   /* Sorry */
 879	}
 880	ess_extended (devc);
 881
 882#ifdef FKS_LOGGING
 883printk(KERN_INFO "FKS: dsp_reset 2\n");
 884ess_show_mixerregs (devc);
 885#endif
 886
 887	return 1;
 888}
 889
 890static int ess_irq_bits (int irq)
 891{
 892	switch (irq) {
 893	case 2:
 894	case 9:
 895		return 0;
 896
 897	case 5:
 898		return 1;
 899
 900	case 7:
 901		return 2;
 902
 903	case 10:
 904		return 3;
 905
 906	default:
 907		printk(KERN_ERR "ESS1688: Invalid IRQ %d\n", irq);
 908		return -1;
 909	}
 910}
 911
 912/*
 913 *	Set IRQ configuration register for all ESS models
 914 */
 915static int ess_common_set_irq_hw (sb_devc * devc)
 916{
 917	int irq_bits;
 918
 919	if ((irq_bits = ess_irq_bits (devc->irq)) == -1) return 0;
 920
 921	if (!ess_write (devc, 0xb1, 0x50 | (irq_bits << 2))) {
 922		printk(KERN_ERR "ES1688: Failed to write to IRQ config register\n");
 923		return 0;
 924	}
 925	return 1;
 926}
 927
 928/*
 929 * I wanna use modern ES1887 mixer irq handling. Funny is the
 930 * fact that my BIOS wants the same. But suppose someone's BIOS
 931 * doesn't do this!
 932 * This is independent of duplex. If there's a 1887 this will
 933 * prevent it from going into 1888 mode.
 934 */
 935static void ess_es1887_set_irq_hw (sb_devc * devc)
 936{
 937	int irq_bits;
 938
 939	if ((irq_bits = ess_irq_bits (devc->irq)) == -1) return;
 940
 941	ess_chgmixer (devc, 0x7f, 0x0f, 0x01 | ((irq_bits + 1) << 1));
 942}
 943
 944static int ess_set_irq_hw (sb_devc * devc)
 945{
 946	if (devc->submodel == SUBMDL_ES1887) ess_es1887_set_irq_hw (devc);
 947
 948	return ess_common_set_irq_hw (devc);
 949}
 950
 951#ifdef FKS_TEST
 952
 953/*
 954 * FKS_test:
 955 *	for ES1887: 00, 18, non wr bits: 0001 1000
 956 *	for ES1868: 00, b8, non wr bits: 1011 1000
 957 *	for ES1888: 00, f8, non wr bits: 1111 1000
 958 *	for ES1688: 00, f8, non wr bits: 1111 1000
 959 *	+   ES968
 960 */
 961
 962static void FKS_test (sb_devc * devc)
 963{
 964	int val1, val2;
 965	val1 = ess_getmixer (devc, 0x64);
 966	ess_setmixer (devc, 0x64, ~val1);
 967	val2 = ess_getmixer (devc, 0x64) ^ ~val1;
 968	ess_setmixer (devc, 0x64, val1);
 969	val1 ^= ess_getmixer (devc, 0x64);
 970printk (KERN_INFO "FKS: FKS_test %02x, %02x\n", (val1 & 0x0ff), (val2 & 0x0ff));
 971};
 972#endif
 973
 974static unsigned int ess_identify (sb_devc * devc)
 975{
 976	unsigned int val;
 977	unsigned long flags;
 978
 979	spin_lock_irqsave(&devc->lock, flags);
 980	outb(((unsigned char) (0x40 & 0xff)), MIXER_ADDR);
 981
 982	udelay(20);
 983	val  = inb(MIXER_DATA) << 8;
 984	udelay(20);
 985	val |= inb(MIXER_DATA);
 986	udelay(20);
 987	spin_unlock_irqrestore(&devc->lock, flags);
 988
 989	return val;
 990}
 991
 992/*
 993 * ESS technology describes a detection scheme in their docs. It involves
 994 * fiddling with the bits in certain mixer registers. ess_probe is supposed
 995 * to help.
 996 *
 997 * FKS: tracing shows ess_probe writes wrong value to 0x64. Bit 3 reads 1, but
 998 * should be written 0 only. Check this.
 999 */
1000static int ess_probe (sb_devc * devc, int reg, int xorval)
1001{
1002	int  val1, val2, val3;
1003
1004	val1 = ess_getmixer (devc, reg);
1005	val2 = val1 ^ xorval;
1006	ess_setmixer (devc, reg, val2);
1007	val3 = ess_getmixer (devc, reg);
1008	ess_setmixer (devc, reg, val1);
1009
1010	return (val2 == val3);
1011}
1012
1013int ess_init(sb_devc * devc, struct address_info *hw_config)
1014{
1015	unsigned char cfg;
1016	int ess_major = 0, ess_minor = 0;
1017	int i;
1018	static char name[100], modelname[10];
1019
1020	/*
1021	 * Try to detect ESS chips.
1022	 */
1023
1024	sb_dsp_command(devc, 0xe7); /* Return identification */
1025
1026	for (i = 1000; i; i--) {
1027		if (inb(DSP_DATA_AVAIL) & 0x80) {
1028			if (ess_major == 0) {
1029				ess_major = inb(DSP_READ);
1030			} else {
1031				ess_minor = inb(DSP_READ);
1032				break;
1033			}
1034		}
1035	}
1036
1037	if (ess_major == 0) return 0;
1038
1039	if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) {
1040		sprintf(name, "ESS ES488 AudioDrive (rev %d)",
1041			ess_minor & 0x0f);
1042		hw_config->name = name;
1043		devc->model = MDL_SBPRO;
1044		return 1;
1045	}
1046
1047	/*
1048	 * This the detection heuristic of ESS technology, though somewhat
1049	 * changed to actually make it work.
1050	 * This results in the following detection steps:
1051	 * - distinct between ES688 and ES1688+ (as always done in this driver)
1052	 *   if ES688 we're ready
1053	 * - try to detect ES1868, ES1869 or ES1878 (ess_identify)
1054	 *   if successful we're ready
1055	 * - try to detect ES1888, ES1887 or ES1788 (aim: detect ES1887)
1056	 *   if successful we're ready
1057	 * - Dunno. Must be 1688. Will do in general
1058	 *
1059	 * This is the most BETA part of the software: Will the detection
1060	 * always work?
1061	 */
1062	devc->model = MDL_ESS;
1063	devc->submodel = ess_minor & 0x0f;
1064
1065	if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) {
1066		char *chip = NULL;
1067		int submodel = -1;
1068
1069		switch (devc->sbmo.esstype) {
1070		case ESSTYPE_DETECT:
1071		case ESSTYPE_LIKE20:
1072			break;
1073		case 688:
1074			submodel = 0x00;
1075			break;
1076		case 1688:
1077			submodel = 0x08;
1078			break;
1079		case 1868:
1080			submodel = SUBMDL_ES1868;
1081			break;
1082		case 1869:
1083			submodel = SUBMDL_ES1869;
1084			break;
1085		case 1788:
1086			submodel = SUBMDL_ES1788;
1087			break;
1088		case 1878:
1089			submodel = SUBMDL_ES1878;
1090			break;
1091		case 1879:
1092			submodel = SUBMDL_ES1879;
1093			break;
1094		case 1887:
1095			submodel = SUBMDL_ES1887;
1096			break;
1097		case 1888:
1098			submodel = SUBMDL_ES1888;
1099			break;
1100		default:
1101			printk (KERN_ERR "Invalid esstype=%d specified\n", devc->sbmo.esstype);
1102			return 0;
1103		}
1104		if (submodel != -1) {
1105			devc->submodel = submodel;
1106			sprintf (modelname, "ES%d", devc->sbmo.esstype);
1107			chip = modelname;
1108		}
1109		if (chip == NULL && (ess_minor & 0x0f) < 8) {
1110			chip = "ES688";
1111		}
1112#ifdef FKS_TEST
1113FKS_test (devc);
1114#endif
1115		/*
1116		 * If Nothing detected yet, and we want 2.0 behaviour...
1117		 * Then let's assume it's ES1688.
1118		 */
1119		if (chip == NULL && devc->sbmo.esstype == ESSTYPE_LIKE20) {
1120			chip = "ES1688";
1121		}
1122
1123		if (chip == NULL) {
1124			int type;
1125
1126			type = ess_identify (devc);
1127
1128			switch (type) {
1129			case 0x1868:
1130				chip = "ES1868";
1131				devc->submodel = SUBMDL_ES1868;
1132				break;
1133			case 0x1869:
1134				chip = "ES1869";
1135				devc->submodel = SUBMDL_ES1869;
1136				break;
1137			case 0x1878:
1138				chip = "ES1878";
1139				devc->submodel = SUBMDL_ES1878;
1140				break;
1141			case 0x1879:
1142				chip = "ES1879";
1143				devc->submodel = SUBMDL_ES1879;
1144				break;
1145			default:
1146				if ((type & 0x00ff) != ((type >> 8) & 0x00ff)) {
1147					printk ("ess_init: Unrecognized %04x\n", type);
1148				}
1149			}
1150		}
1151#if 0
1152		/*
1153		 * this one failed:
1154		 * the probing of bit 4 is another thought: from ES1788 and up, all
1155		 * chips seem to have hardware volume control. Bit 4 is readonly to
1156		 * check if a hardware volume interrupt has fired.
1157		 * Cause ES688/ES1688 don't have this feature, bit 4 might be writeable
1158		 * for these chips.
1159		 */
1160		if (chip == NULL && !ess_probe(devc, 0x64, (1 << 4))) {
1161#endif
1162		/*
1163		 * the probing of bit 2 is my idea. The ES1887 docs want me to probe
1164		 * bit 3. This results in ES1688 being detected as ES1788.
1165		 * Bit 2 is for "Enable HWV IRQE", but as ES(1)688 chips don't have
1166		 * HardWare Volume, I think they don't have this IRQE.
1167		 */
1168		if (chip == NULL && ess_probe(devc, 0x64, (1 << 2))) {
1169			if (ess_probe (devc, 0x70, 0x7f)) {
1170				if (ess_probe (devc, 0x64, (1 << 5))) {
1171					chip = "ES1887";
1172					devc->submodel = SUBMDL_ES1887;
1173				} else {
1174					chip = "ES1888";
1175					devc->submodel = SUBMDL_ES1888;
1176				}
1177			} else {
1178				chip = "ES1788";
1179				devc->submodel = SUBMDL_ES1788;
1180			}
1181		}
1182		if (chip == NULL) {
1183			chip = "ES1688";
1184		}
1185
1186	    printk ( KERN_INFO "ESS chip %s %s%s\n"
1187               , chip
1188               , ( devc->sbmo.esstype == ESSTYPE_DETECT || devc->sbmo.esstype == ESSTYPE_LIKE20
1189                 ? "detected"
1190                 : "specified"
1191                 )
1192               , ( devc->sbmo.esstype == ESSTYPE_LIKE20
1193                 ? " (kernel 2.0 compatible)"
1194                 : ""
1195                 )
1196               );
1197
1198		sprintf(name,"ESS %s AudioDrive (rev %d)", chip, ess_minor & 0x0f);
1199	} else {
1200		strcpy(name, "Jazz16");
1201	}
1202
1203	/* AAS: info stolen from ALSA: these boards have different clocks */
1204	switch(devc->submodel) {
1205/* APPARENTLY NOT 1869 AND 1887
1206		case SUBMDL_ES1869:
1207		case SUBMDL_ES1887:
1208*/		
1209		case SUBMDL_ES1888:
1210			devc->caps |= SB_CAP_ES18XX_RATE;
1211			break;
1212	}
1213
1214	hw_config->name = name;
1215	/* FKS: sb_dsp_reset to enable extended mode???? */
1216	sb_dsp_reset(devc); /* Turn on extended mode */
1217
1218	/*
1219	 *  Enable joystick and OPL3
1220	 */
1221	cfg = ess_getmixer (devc, 0x40);
1222	ess_setmixer (devc, 0x40, cfg | 0x03);
1223	if (devc->submodel >= 8) {		/* ES1688 */
1224		devc->caps |= SB_NO_MIDI;   /* ES1688 uses MPU401 MIDI mode */
1225	}
1226	sb_dsp_reset (devc);
1227
1228	/*
1229	 * This is important! If it's not done, the IRQ probe in sb_dsp_init
1230	 * may fail.
1231	 */
1232	return ess_set_irq_hw (devc);
1233}
1234
1235static int ess_set_dma_hw(sb_devc * devc)
1236{
1237	unsigned char cfg, dma_bits = 0, dma16_bits;
1238	int dma;
1239
1240#ifdef FKS_LOGGING
1241printk(KERN_INFO "ess_set_dma_hw: dma8=%d,dma16=%d,dup=%d\n"
1242, devc->dma8, devc->dma16, devc->duplex);
1243#endif
1244
1245	/*
1246	 * FKS: It seems as if this duplex flag isn't set yet. Check it.
1247	 */
1248	dma = devc->dma8;
1249
1250	if (dma > 3 || dma < 0 || dma == 2) {
1251		dma_bits = 0;
1252		printk(KERN_ERR "ESS1688: Invalid DMA8 %d\n", dma);
1253		return 0;
1254	} else {
1255		/* Extended mode DMA enable */
1256		cfg = 0x50;
1257
1258		if (dma == 3) {
1259			dma_bits = 3;
1260		} else {
1261			dma_bits = dma + 1;
1262		}
1263	}
1264
1265	if (!ess_write (devc, 0xb2, cfg | (dma_bits << 2))) {
1266		printk(KERN_ERR "ESS1688: Failed to write to DMA config register\n");
1267		return 0;
1268	}
1269
1270	if (devc->duplex) {
1271		dma = devc->dma16;
1272		dma16_bits = 0;
1273
1274		if (dma >= 0) {
1275			switch (dma) {
1276			case 0:
1277				dma_bits = 0x04;
1278				break;
1279			case 1:
1280				dma_bits = 0x05;
1281				break;
1282			case 3:
1283				dma_bits = 0x06;
1284				break;
1285			case 5:
1286				dma_bits   = 0x07;
1287				dma16_bits = 0x20;
1288				break;
1289			default:
1290				printk(KERN_ERR "ESS1887: Invalid DMA16 %d\n", dma);
1291				return 0;
1292			}
1293			ess_chgmixer (devc, 0x78, 0x20, dma16_bits);
1294			ess_chgmixer (devc, 0x7d, 0x07, dma_bits);
1295		}
1296	}
1297	return 1;
1298}
1299
1300/*
1301 * This one is called from sb_dsp_init.
1302 *
1303 * Return values:
1304 *  0: Failed
1305 *  1: Succeeded or doesn't apply (not SUBMDL_ES1887)
1306 */
1307int ess_dsp_init (sb_devc *devc, struct address_info *hw_config)
1308{
1309	/*
1310	 * Caller also checks this, but anyway
1311	 */
1312	if (devc->model != MDL_ESS) {
1313		printk (KERN_INFO "ess_dsp_init for non ESS chip\n");
1314		return 1;
1315	}
1316	/*
1317	 * This for ES1887 to run Full Duplex. Actually ES1888
1318	 * is allowed to do so too. I have no idea yet if this
1319	 * will work for ES1888 however.
1320	 *
1321	 * For SB16 having both dma8 and dma16 means enable
1322	 * Full Duplex. Let's try this for ES1887 too
1323	 *
1324	 */
1325	if (devc->submodel == SUBMDL_ES1887) {
1326		if (hw_config->dma2 != -1) {
1327			devc->dma16 = hw_config->dma2;
1328		}
1329		/*
1330		 * devc->duplex initialization is put here, cause
1331		 * ess_set_dma_hw needs it.
1332		 */
1333		if (devc->dma8 != devc->dma16 && devc->dma16 != -1) {
1334			devc->duplex = 1;
1335		}
1336	}
1337	if (!ess_set_dma_hw (devc)) {
1338		free_irq(devc->irq, devc);
1339		return 0;
1340	}
1341	return 1;
1342}
1343
1344/****************************************************************************
1345 *																			*
1346 *									ESS mixer								*
1347 *																			*
1348 ****************************************************************************/
1349
1350#define ES688_RECORDING_DEVICES	\
1351			( SOUND_MASK_LINE	| SOUND_MASK_MIC	| SOUND_MASK_CD		)
1352#define ES688_MIXER_DEVICES		\
1353			( SOUND_MASK_SYNTH	| SOUND_MASK_PCM	| SOUND_MASK_LINE	\
1354			| SOUND_MASK_MIC	| SOUND_MASK_CD		| SOUND_MASK_VOLUME	\
1355			| SOUND_MASK_LINE2	| SOUND_MASK_SPEAKER					)
1356
1357#define ES1688_RECORDING_DEVICES	\
1358			( ES688_RECORDING_DEVICES					)
1359#define ES1688_MIXER_DEVICES		\
1360			( ES688_MIXER_DEVICES | SOUND_MASK_RECLEV	)
1361
1362#define ES1887_RECORDING_DEVICES	\
1363			( ES1688_RECORDING_DEVICES | SOUND_MASK_LINE2 | SOUND_MASK_SYNTH)
1364#define ES1887_MIXER_DEVICES		\
1365			( ES1688_MIXER_DEVICES											)
1366
1367/*
1368 * Mixer registers of ES1887
1369 *
1370 * These registers specifically take care of recording levels. To make the
1371 * mapping from playback devices to recording devices every recording
1372 * devices = playback device + ES_REC_MIXER_RECDIFF
1373 */
1374#define ES_REC_MIXER_RECBASE	(SOUND_MIXER_LINE3 + 1)
1375#define ES_REC_MIXER_RECDIFF	(ES_REC_MIXER_RECBASE - SOUND_MIXER_SYNTH)
1376
1377#define ES_REC_MIXER_RECSYNTH	(SOUND_MIXER_SYNTH	 + ES_REC_MIXER_RECDIFF)
1378#define ES_REC_MIXER_RECPCM		(SOUND_MIXER_PCM	 + ES_REC_MIXER_RECDIFF)
1379#define ES_REC_MIXER_RECSPEAKER	(SOUND_MIXER_SPEAKER + ES_REC_MIXER_RECDIFF)
1380#define ES_REC_MIXER_RECLINE	(SOUND_MIXER_LINE	 + ES_REC_MIXER_RECDIFF)
1381#define ES_REC_MIXER_RECMIC		(SOUND_MIXER_MIC	 + ES_REC_MIXER_RECDIFF)
1382#define ES_REC_MIXER_RECCD		(SOUND_MIXER_CD		 + ES_REC_MIXER_RECDIFF)
1383#define ES_REC_MIXER_RECIMIX	(SOUND_MIXER_IMIX	 + ES_REC_MIXER_RECDIFF)
1384#define ES_REC_MIXER_RECALTPCM	(SOUND_MIXER_ALTPCM	 + ES_REC_MIXER_RECDIFF)
1385#define ES_REC_MIXER_RECRECLEV	(SOUND_MIXER_RECLEV	 + ES_REC_MIXER_RECDIFF)
1386#define ES_REC_MIXER_RECIGAIN	(SOUND_MIXER_IGAIN	 + ES_REC_MIXER_RECDIFF)
1387#define ES_REC_MIXER_RECOGAIN	(SOUND_MIXER_OGAIN	 + ES_REC_MIXER_RECDIFF)
1388#define ES_REC_MIXER_RECLINE1	(SOUND_MIXER_LINE1	 + ES_REC_MIXER_RECDIFF)
1389#define ES_REC_MIXER_RECLINE2	(SOUND_MIXER_LINE2	 + ES_REC_MIXER_RECDIFF)
1390#define ES_REC_MIXER_RECLINE3	(SOUND_MIXER_LINE3	 + ES_REC_MIXER_RECDIFF)
1391
1392static mixer_tab es688_mix = {
1393MIX_ENT(SOUND_MIXER_VOLUME,			0x32, 7, 4, 0x32, 3, 4),
1394MIX_ENT(SOUND_MIXER_BASS,			0x00, 0, 0, 0x00, 0, 0),
1395MIX_ENT(SOUND_MIXER_TREBLE,			0x00, 0, 0, 0x00, 0, 0),
1396MIX_ENT(SOUND_MIXER_SYNTH,			0x36, 7, 4, 0x36, 3, 4),
1397MIX_ENT(SOUND_MIXER_PCM,			0x14, 7, 4, 0x14, 3, 4),
1398MIX_ENT(SOUND_MIXER_SPEAKER,		0x3c, 2, 3, 0x00, 0, 0),
1399MIX_ENT(SOUND_MIXER_LINE,			0x3e, 7, 4, 0x3e, 3, 4),
1400MIX_ENT(SOUND_MIXER_MIC,			0x1a, 7, 4, 0x1a, 3, 4),
1401MIX_ENT(SOUND_MIXER_CD,				0x38, 7, 4, 0x38, 3, 4),
1402MIX_ENT(SOUND_MIXER_IMIX,			0x00, 0, 0, 0x00, 0, 0),
1403MIX_ENT(SOUND_MIXER_ALTPCM,			0x00, 0, 0, 0x00, 0, 0),
1404MIX_ENT(SOUND_MIXER_RECLEV,			0x00, 0, 0, 0x00, 0, 0),
1405MIX_ENT(SOUND_MIXER_IGAIN,			0x00, 0, 0, 0x00, 0, 0),
1406MIX_ENT(SOUND_MIXER_OGAIN,			0x00, 0, 0, 0x00, 0, 0),
1407MIX_ENT(SOUND_MIXER_LINE1,			0x00, 0, 0, 0x00, 0, 0),
1408MIX_ENT(SOUND_MIXER_LINE2,			0x3a, 7, 4, 0x3a, 3, 4),
1409MIX_ENT(SOUND_MIXER_LINE3,			0x00, 0, 0, 0x00, 0, 0)
1410};
1411
1412/*
1413 * The ES1688 specifics... hopefully correct...
1414 * - 6 bit master volume
1415 *   I was wrong, ES1888 docs say ES1688 didn't have it.
1416 * - RECLEV control
1417 * These may apply to ES688 too. I have no idea.
1418 */
1419static mixer_tab es1688_mix = {
1420MIX_ENT(SOUND_MIXER_VOLUME,			0x32, 7, 4, 0x32, 3, 4),
1421MIX_ENT(SOUND_MIXER_BASS,			0x00, 0, 0, 0x00, 0, 0),
1422MIX_ENT(SOUND_MIXER_TREBLE,			0x00, 0, 0, 0x00, 0, 0),
1423MIX_ENT(SOUND_MIXER_SYNTH,			0x36, 7, 4, 0x36, 3, 4),
1424MIX_ENT(SOUND_MIXER_PCM,			0x14, 7, 4, 0x14, 3, 4),
1425MIX_ENT(SOUND_MIXER_SPEAKER,		0x3c, 2, 3, 0x00, 0, 0),
1426MIX_ENT(SOUND_MIXER_LINE,			0x3e, 7, 4, 0x3e, 3, 4),
1427MIX_ENT(SOUND_MIXER_MIC,			0x1a, 7, 4, 0x1a, 3, 4),
1428MIX_ENT(SOUND_MIXER_CD,				0x38, 7, 4, 0x38, 3, 4),
1429MIX_ENT(SOUND_MIXER_IMIX,			0x00, 0, 0, 0x00, 0, 0),
1430MIX_ENT(SOUND_MIXER_ALTPCM,			0x00, 0, 0, 0x00, 0, 0),
1431MIX_ENT(SOUND_MIXER_RECLEV,			0xb4, 7, 4, 0xb4, 3, 4),
1432MIX_ENT(SOUND_MIXER_IGAIN,			0x00, 0, 0, 0x00, 0, 0),
1433MIX_ENT(SOUND_MIXER_OGAIN,			0x00, 0, 0, 0x00, 0, 0),
1434MIX_ENT(SOUND_MIXER_LINE1,			0x00, 0, 0, 0x00, 0, 0),
1435MIX_ENT(SOUND_MIXER_LINE2,			0x3a, 7, 4, 0x3a, 3, 4),
1436MIX_ENT(SOUND_MIXER_LINE3,			0x00, 0, 0, 0x00, 0, 0)
1437};
1438
1439static mixer_tab es1688later_mix = {
1440MIX_ENT(SOUND_MIXER_VOLUME,			0x60, 5, 6, 0x62, 5, 6),
1441MIX_ENT(SOUND_MIXER_BASS,			0x00, 0, 0, 0x00, 0, 0),
1442MIX_ENT(SOUND_MIXER_TREBLE,			0x00, 0, 0, 0x00, 0, 0),
1443MIX_ENT(SOUND_MIXER_SYNTH,			0x36, 7, 4, 0x36, 3, 4),
1444MIX_ENT(SOUND_MIXER_PCM,			0x14, 7, 4, 0x14, 3, 4),
1445MIX_ENT(SOUND_MIXER_SPEAKER,		0x3c, 2, 3, 0x00, 0, 0),
1446MIX_ENT(SOUND_MIXER_LINE,			0x3e, 7, 4, 0x3e, 3, 4),
1447MIX_ENT(SOUND_MIXER_MIC,			0x1a, 7, 4, 0x1a, 3, 4),
1448MIX_ENT(SOUND_MIXER_CD,				0x38, 7, 4, 0x38, 3, 4),
1449MIX_ENT(SOUND_MIXER_IMIX,			0x00, 0, 0, 0x00, 0, 0),
1450MIX_ENT(SOUND_MIXER_ALTPCM,			0x00, 0, 0, 0x00, 0, 0),
1451MIX_ENT(SOUND_MIXER_RECLEV,			0xb4, 7, 4, 0xb4, 3, 4),
1452MIX_ENT(SOUND_MIXER_IGAIN,			0x00, 0, 0, 0x00, 0, 0),
1453MIX_ENT(SOUND_MIXER_OGAIN,			0x00, 0, 0, 0x00, 0, 0),
1454MIX_ENT(SOUND_MIXER_LINE1,			0x00, 0, 0, 0x00, 0, 0),
1455MIX_ENT(SOUND_MIXER_LINE2,			0x3a, 7, 4, 0x3a, 3, 4),
1456MIX_ENT(SOUND_MIXER_LINE3,			0x00, 0, 0, 0x00, 0, 0)
1457};
1458
1459/*
1460 * This one is for all ESS chips with a record mixer.
1461 * It's not used (yet) however
1462 */
1463static mixer_tab es_rec_mix = {
1464MIX_ENT(SOUND_MIXER_VOLUME,			0x60, 5, 6, 0x62, 5, 6),
1465MIX_ENT(SOUND_MIXER_BASS,			0x00, 0, 0, 0x00, 0, 0),
1466MIX_ENT(SOUND_MIXER_TREBLE,			0x00, 0, 0, 0x00, 0, 0),
1467MIX_ENT(SOUND_MIXER_SYNTH,			0x36, 7, 4, 0x36, 3, 4),
1468MIX_ENT(SOUND_MIXER_PCM,			0x14, 7, 4, 0x14, 3, 4),
1469MIX_ENT(SOUND_MIXER_SPEAKER,		0x3c, 2, 3, 0x00, 0, 0),
1470MIX_ENT(SOUND_MIXER_LINE,			0x3e, 7, 4, 0x3e, 3, 4),
1471MIX_ENT(SOUND_MIXER_MIC,			0x1a, 7, 4, 0x1a, 3, 4),
1472MIX_ENT(SOUND_MIXER_CD,				0x38, 7, 4, 0x38, 3, 4),
1473MIX_ENT(SOUND_MIXER_IMIX,			0x00, 0, 0, 0x00, 0, 0),
1474MIX_ENT(SOUND_MIXER_ALTPCM,			0x00, 0, 0, 0x00, 0, 0),
1475MIX_ENT(SOUND_MIXER_RECLEV,			0xb4, 7, 4, 0xb4, 3, 4),
1476MIX_ENT(SOUND_MIXER_IGAIN,			0x00, 0, 0, 0x00, 0, 0),
1477MIX_ENT(SOUND_MIXER_OGAIN,			0x00, 0, 0, 0x00, 0, 0),
1478MIX_ENT(SOUND_MIXER_LINE1,			0x00, 0, 0, 0x00, 0, 0),
1479MIX_ENT(SOUND_MIXER_LINE2,			0x3a, 7, 4, 0x3a, 3, 4),
1480MIX_ENT(SOUND_MIXER_LINE3,			0x00, 0, 0, 0x00, 0, 0),
1481MIX_ENT(ES_REC_MIXER_RECSYNTH,		0x6b, 7, 4, 0x6b, 3, 4),
1482MIX_ENT(ES_REC_MIXER_RECPCM,		0x00, 0, 0, 0x00, 0, 0),
1483MIX_ENT(ES_REC_MIXER_RECSPEAKER,	0x00, 0, 0, 0x00, 0, 0),
1484MIX_ENT(ES_REC_MIXER_RECLINE,		0x6e, 7, 4, 0x6e, 3, 4),
1485MIX_ENT(ES_REC_MIXER_RECMIC,		0x68, 7, 4, 0x68, 3, 4),
1486MIX_ENT(ES_REC_MIXER_RECCD,			0x6a, 7, 4, 0x6a, 3, 4),
1487MIX_ENT(ES_REC_MIXER_RECIMIX,		0x00, 0, 0, 0x00, 0, 0),
1488MIX_ENT(ES_REC_MIXER_RECALTPCM,		0x00, 0, 0, 0x00, 0, 0),
1489MIX_ENT(ES_REC_MIXER_RECRECLEV,		0x00, 0, 0, 0x00, 0, 0),
1490MIX_ENT(ES_REC_MIXER_RECIGAIN,		0x00, 0, 0, 0x00, 0, 0),
1491MIX_ENT(ES_REC_MIXER_RECOGAIN,		0x00, 0, 0, 0x00, 0, 0),
1492MIX_ENT(ES_REC_MIXER_RECLINE1,		0x00, 0, 0, 0x00, 0, 0),
1493MIX_ENT(ES_REC_MIXER_RECLINE2,		0x6c, 7, 4, 0x6c, 3, 4),
1494MIX_ENT(ES_REC_MIXER_RECLINE3,		0x00, 0, 0, 0x00, 0, 0)
1495};
1496
1497/*
1498 * This one is for ES1887. It's little different from es_rec_mix: it
1499 * has 0x7c for PCM playback level. This is because ES1887 uses
1500 * Audio 2 for playback.
1501 */
1502static mixer_tab es1887_mix = {
1503MIX_ENT(SOUND_MIXER_VOLUME,			0x60, 5, 6, 0x62, 5, 6),
1504MIX_ENT(SOUND_MIXER_BASS,			0x00, 0, 0, 0x00, 0, 0),
1505MIX_ENT(SOUND_MIXER_TREBLE,			0x00, 0, 0, 0x00, 0, 0),
1506MIX_ENT(SOUND_MIXER_SYNTH,			0x36, 7, 4, 0x36, 3, 4),
1507MIX_ENT(SOUND_MIXER_PCM,			0x7c, 7, 4, 0x7c, 3, 4),
1508MIX_ENT(SOUND_MIXER_SPEAKER,		0x3c, 2, 3, 0x00, 0, 0),
1509MIX_ENT(SOUND_MIXER_LINE,			0x3e, 7, 4, 0x3e, 3, 4),
1510MIX_ENT(SOUND_MIXER_MIC,			0x1a, 7, 4, 0x1a, 3, 4),
1511MIX_ENT(SOUND_MIXER_CD,				0x38, 7, 4, 0x38, 3, 4),
1512MIX_ENT(SOUND_MIXER_IMIX,			0x00, 0, 0, 0x00, 0, 0),
1513MIX_ENT(SOUND_MIXER_ALTPCM,			0x00, 0, 0, 0x00, 0, 0),
1514MIX_ENT(SOUND_MIXER_RECLEV,			0xb4, 7, 4, 0xb4, 3, 4),
1515MIX_ENT(SOUND_MIXER_IGAIN,			0x00, 0, 0, 0x00, 0, 0),
1516MIX_ENT(SOUND_MIXER_OGAIN,			0x00, 0, 0, 0x00, 0, 0),
1517MIX_ENT(SOUND_MIXER_LINE1,			0x00, 0, 0, 0x00, 0, 0),
1518MIX_ENT(SOUND_MIXER_LINE2,			0x3a, 7, 4, 0x3a, 3, 4),
1519MIX_ENT(SOUND_MIXER_LINE3,			0x00, 0, 0, 0x00, 0, 0),
1520MIX_ENT(ES_REC_MIXER_RECSYNTH,		0x6b, 7, 4, 0x6b, 3, 4),
1521MIX_ENT(ES_REC_MIXER_RECPCM,		0x00, 0, 0, 0x00, 0, 0),
1522MIX_ENT(ES_REC_MIXER_RECSPEAKER,	0x00, 0, 0, 0x00, 0, 0),
1523MIX_ENT(ES_REC_MIXER_RECLINE,		0x6e, 7, 4, 0x6e, 3, 4),
1524MIX_ENT(ES_REC_MIXER_RECMIC,		0x68, 7, 4, 0x68, 3, 4),
1525MIX_ENT(ES_REC_MIXER_RECCD,			0x6a, 7, 4, 0x6a, 3, 4),
1526MIX_ENT(ES_REC_MIXER_RECIMIX,		0x00, 0, 0, 0x00, 0, 0),
1527MIX_ENT(ES_REC_MIXER_RECALTPCM,		0x00, 0, 0, 0x00, 0, 0),
1528MIX_ENT(ES_REC_MIXER_RECRECLEV,		0x00, 0, 0, 0x00, 0, 0),
1529MIX_ENT(ES_REC_MIXER_RECIGAIN,		0x00, 0, 0, 0x00, 0, 0),
1530MIX_ENT(ES_REC_MIXER_RECOGAIN,		0x00, 0, 0, 0x00, 0, 0),
1531MIX_ENT(ES_REC_MIXER_RECLINE1,		0x00, 0, 0, 0x00, 0, 0),
1532MIX_ENT(ES_REC_MIXER_RECLINE2,		0x6c, 7, 4, 0x6c, 3, 4),
1533MIX_ENT(ES_REC_MIXER_RECLINE3,		0x00, 0, 0, 0x00, 0, 0)
1534};
1535
1536static int ess_has_rec_mixer (int submodel)
1537{
1538	switch (submodel) {
1539	case SUBMDL_ES1887:
1540		return 1;
1541	default:
1542		return 0;
1543	}
1544};
1545
1546#ifdef FKS_LOGGING
1547static int ess_mixer_mon_regs[]
1548	= { 0x70, 0x71, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7d, 0x7f
1549	  , 0xa1, 0xa2, 0xa4, 0xa5, 0xa8, 0xa9
1550	  , 0xb1, 0xb2, 0xb4, 0xb5, 0xb6, 0xb7, 0xb9
1551	  , 0x00};
1552
1553static void ess_show_mixerregs (sb_devc *devc)
1554{
1555	int *mp = ess_mixer_mon_regs;
1556
1557return;
1558
1559	while (*mp != 0) {
1560		printk (KERN_INFO "res (%x)=%x\n", *mp, (int)(ess_getmixer (devc, *mp)));
1561		mp++;
1562	}
1563}
1564#endif
1565
1566void ess_setmixer (sb_devc * devc, unsigned int port, unsigned int value)
1567{
1568	unsigned long flags;
1569
1570#ifdef FKS_LOGGING
1571printk(KERN_INFO "FKS: write mixer %x: %x\n", port, value);
1572#endif
1573
1574	spin_lock_irqsave(&devc->lock, flags);
1575	if (port >= 0xa0) {
1576		ess_write (devc, port, value);
1577	} else {
1578		outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
1579
1580		udelay(20);
1581		outb(((unsigned char) (value & 0xff)), MIXER_DATA);
1582		udelay(20);
1583	}
1584	spin_unlock_irqrestore(&devc->lock, flags);
1585}
1586
1587unsigned int ess_getmixer (sb_devc * devc, unsigned int port)
1588{
1589	unsigned int val;
1590	unsigned long flags;
1591
1592	spin_lock_irqsave(&devc->lock, flags);
1593
1594	if (port >= 0xa0) {
1595		val = ess_read (devc, port);
1596	} else {
1597		outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
1598
1599		udelay(20);
1600		val = inb(MIXER_DATA);
1601		udelay(20);
1602	}
1603	spin_unlock_irqrestore(&devc->lock, flags);
1604
1605	return val;
1606}
1607
1608static void ess_chgmixer
1609	(sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val)
1610{
1611	int value;
1612
1613	value = ess_getmixer (devc, reg);
1614	value = (value & ~mask) | (val & mask);
1615	ess_setmixer (devc, reg, value);
1616}
1617
1618/*
1619 * ess_mixer_init must be called from sb_mixer_init
1620 */
1621void ess_mixer_init (sb_devc * devc)
1622{
1623	devc->mixer_caps = SOUND_CAP_EXCL_INPUT;
1624
1625	/*
1626	* Take care of ES1887 specifics...
1627	*/
1628	switch (devc->submodel) {
1629	case SUBMDL_ES1887:
1630		devc->supported_devices		= ES1887_MIXER_DEVICES;
1631		devc->supported_rec_devices	= ES1887_RECORDING_DEVICES;
1632#ifdef FKS_LOGGING
1633printk (KERN_INFO "FKS: ess_mixer_init dup = %d\n", devc->duplex);
1634#endif
1635		if (devc->duplex) {
1636			devc->iomap				= &es1887_mix;
1637			devc->iomap_sz                          = ARRAY_SIZE(es1887_mix);
1638		} else {
1639			devc->iomap				= &es_rec_mix;
1640			devc->iomap_sz                          = ARRAY_SIZE(es_rec_mix);
1641		}
1642		break;
1643	default:
1644		if (devc->submodel < 8) {
1645			devc->supported_devices		= ES688_MIXER_DEVICES;
1646			devc->supported_rec_devices	= ES688_RECORDING_DEVICES;
1647			devc->iomap					= &es688_mix;
1648			devc->iomap_sz                                  = ARRAY_SIZE(es688_mix);
1649		} else {
1650			/*
1651			 * es1688 has 4 bits master vol.
1652			 * later chips have 6 bits (?)
1653			 */
1654			devc->supported_devices		= ES1688_MIXER_DEVICES;
1655			devc->supported_rec_devices	= ES1688_RECORDING_DEVICES;
1656			if (devc->submodel < 0x10) {
1657				devc->iomap				= &es1688_mix;
1658				devc->iomap_sz                          = ARRAY_SIZE(es688_mix);
1659			} else {
1660				devc->iomap				= &es1688later_mix;
1661				devc->iomap_sz                          = ARRAY_SIZE(es1688later_mix);
1662			}
1663		}
1664	}
1665}
1666
1667/*
1668 * Changing playback levels at an ESS chip with record mixer means having to
1669 * take care of recording levels of recorded inputs (devc->recmask) too!
1670 */
1671int ess_mixer_set(sb_devc *devc, int dev, int left, int right)
1672{
1673	if (ess_has_rec_mixer (devc->submodel) && (devc->recmask & (1 << dev))) {
1674		sb_common_mixer_set (devc, dev + ES_REC_MIXER_RECDIFF, left, right);
1675	}
1676	return sb_common_mixer_set (devc, dev, left, right);
1677}
1678
1679/*
1680 * After a sb_dsp_reset extended register 0xb4 (RECLEV) is reset too. After
1681 * sb_dsp_reset RECLEV has to be restored. This is where ess_mixer_reload
1682 * helps.
1683 */
1684void ess_mixer_reload (sb_devc *devc, int dev)
1685{
1686	int left, right, value;
1687
1688	value = devc->levels[dev];
1689	left  = value & 0x000000ff;
1690	right = (value & 0x0000ff00) >> 8;
1691
1692	sb_common_mixer_set(devc, dev, left, right);
1693}
1694
1695static int es_rec_set_recmask(sb_devc * devc, int mask)
1696{
1697	int i, i_mask, cur_mask, diff_mask;
1698	int value, left, right;
1699
1700#ifdef FKS_LOGGING
1701printk (KERN_INFO "FKS: es_rec_set_recmask mask = %x\n", mask);
1702#endif
1703	/*
1704	 * Changing the recmask on an ESS chip with recording mixer means:
1705	 * (1) Find the differences
1706	 * (2) For "turned-on"  inputs: make the recording level the playback level
1707	 * (3) For "turned-off" inputs: make the recording level zero
1708	 */
1709	cur_mask  = devc->recmask;
1710	diff_mask = (cur_mask ^ mask);
1711
1712	for (i = 0; i < 32; i++) {
1713		i_mask = (1 << i);
1714		if (diff_mask & i_mask) {	/* Difference? (1)  */
1715			if (mask & i_mask) {	/* Turn it on  (2)  */
1716				value = devc->levels[i];
1717				left  = value & 0x000000ff;
1718				right = (value & 0x0000ff00) >> 8;
1719			} else {				/* Turn it off (3)  */
1720				left  = 0;
1721				right = 0;
1722			}
1723			sb_common_mixer_set(devc, i + ES_REC_MIXER_RECDIFF, left, right);
1724		}
1725	}
1726	return mask;
1727}
1728
1729int ess_set_recmask(sb_devc * devc, int *mask)
1730{
1731	/* This applies to ESS chips with record mixers only! */
1732
1733	if (ess_has_rec_mixer (devc->submodel)) {
1734		*mask	= es_rec_set_recmask (devc, *mask);
1735		return 1;									/* Applied		*/
1736	} else {
1737		return 0;									/* Not applied	*/
1738	}
1739}
1740
1741/*
1742 * ess_mixer_reset must be called from sb_mixer_reset
1743 */
1744int ess_mixer_reset (sb_devc * devc)
1745{
1746	/*
1747	 * Separate actions for ESS chips with a record mixer:
1748	 */
1749	if (ess_has_rec_mixer (devc->submodel)) {
1750		switch (devc->submodel) {
1751		case SUBMDL_ES1887:
1752			/*
1753			 * Separate actions for ES1887:
1754			 * Change registers 7a and 1c to make the record mixer the
1755			 * actual recording source.
1756			 */
1757			ess_chgmixer(devc, 0x7a, 0x18, 0x08);
1758			ess_chgmixer(devc, 0x1c, 0x07, 0x07);
1759			break;
1760		}
1761		/*
1762		 * Call set_recmask for proper initialization
1763		 */
1764		devc->recmask = devc->supported_rec_devices;
1765		es_rec_set_recmask(devc, 0);
1766		devc->recmask = 0;
1767
1768		return 1;	/* We took care of recmask.				*/
1769	} else {
1770		return 0;	/* We didn't take care; caller do it	*/
1771	}
1772}
1773
1774/****************************************************************************
1775 *																			*
1776 *								ESS midi									*
1777 *																			*
1778 ****************************************************************************/
1779
1780/*
1781 * FKS: IRQ may be shared. Hm. And if so? Then What?
1782 */
1783int ess_midi_init(sb_devc * devc, struct address_info *hw_config)
1784{
1785	unsigned char   cfg, tmp;
1786
1787	cfg = ess_getmixer (devc, 0x40) & 0x03;
1788
1789	if (devc->submodel < 8) {
1790		ess_setmixer (devc, 0x40, cfg | 0x03);	/* Enable OPL3 & joystick */
1791		return 0;  					 /* ES688 doesn't support MPU401 mode */
1792	}
1793	tmp = (hw_config->io_base & 0x0f0) >> 4;
1794
1795	if (tmp > 3) {
1796		ess_setmixer (devc, 0x40, cfg);
1797		return 0;
1798	}
1799	cfg |= tmp << 3;
1800
1801	tmp = 1;		/* MPU enabled without interrupts */
1802
1803	/* May be shared: if so the value is -ve */
1804
1805	switch (abs(hw_config->irq)) {
1806		case 9:
1807			tmp = 0x4;
1808			break;
1809		case 5:
1810			tmp = 0x5;
1811			break;
1812		case 7:
1813			tmp = 0x6;
1814			break;
1815		case 10:
1816			tmp = 0x7;
1817			break;
1818		default:
1819			return 0;
1820	}
1821
1822	cfg |= tmp << 5;
1823	ess_setmixer (devc, 0x40, cfg | 0x03);
1824
1825	return 1;
1826}
1827