开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sb_ess.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：51k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

sb_ess.c：源码内容
  1. #undef FKS_LOGGING
  2. #undef FKS_TEST
  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.  */
  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. Interresting ones are 0x7f, 0x7d and 0x7a. They are
  101.  * related to the Audio 2 channel. I also was suprised about the consequenses
  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 decribed
  109.  * as if it's exactly the same as register 0xa1. This is *NOT* true. The
  110.  * 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 allways 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 operation, and uses the
  121.  * same dma as audio 1: your ess changes into a funny echo machine.
  122.  *
  123.  * Received the new 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.  */
  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. It's 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.  * it's 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.  * it's 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. Futhermore 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.  * recordig 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.  */
  188. #include <linux/delay.h>
  189. #include <linux/spinlock.h>
  191. #include "sound_config.h"
  192. #include "sb_mixer.h"
  193. #include "sb.h"
  195. #include "sb_ess.h"
  197. #define ESSTYPE_LIKE20 -1 /* Mimic 2.0 behaviour */
  198. #define ESSTYPE_DETECT 0 /* Mimic 2.0 behaviour */
  200. #define SUBMDL_ES1788 0x10 /* Subtype ES1788 for specific handling */
  201. #define SUBMDL_ES1868 0x11 /* Subtype ES1868 for specific handling */
  202. #define SUBMDL_ES1869 0x12 /* Subtype ES1869 for specific handling */
  203. #define SUBMDL_ES1878 0x13 /* Subtype ES1878 for specific handling */
  204. #define SUBMDL_ES1879 0x16    /* ES1879 was initially forgotten */
  205. #define SUBMDL_ES1887 0x14 /* Subtype ES1887 for specific handling */
  206. #define SUBMDL_ES1888 0x15 /* Subtype ES1888 for specific handling */
  208. #define SB_CAP_ES18XX_RATE 0x100
  210. #define ES1688_CLOCK1 795444 /* 128 - div */
  211. #define ES1688_CLOCK2 397722 /* 256 - div */
  212. #define ES18XX_CLOCK1 793800 /* 128 - div */
  213. #define ES18XX_CLOCK2 768000 /* 256 - div */
  215. #ifdef FKS_LOGGING
  216. static void ess_show_mixerregs (sb_devc *devc);
  217. #endif
  218. static int ess_read (sb_devc * devc, unsigned char reg);
  219. static int ess_write (sb_devc * devc, unsigned char reg, unsigned char data);
  220. static void ess_chgmixer
  221. (sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val);
  223. /****************************************************************************
  224.  * *
  225.  * ESS audio *
  226.  * *
  227.  ****************************************************************************/
  229. struct ess_command {short cmd; short data;};
  231. /*
  232.  * Commands for initializing Audio 1 for input (record)
  233.  */
  234. static struct ess_command ess_i08m[] = /* input 8 bit mono */
  235. { {0xb7, 0x51}, {0xb7, 0xd0}, {-1, 0} };
  236. static struct ess_command ess_i16m[] = /* input 16 bit mono */
  237. { {0xb7, 0x71}, {0xb7, 0xf4}, {-1, 0} };
  238. static struct ess_command ess_i08s[] = /* input 8 bit stereo */
  239. { {0xb7, 0x51}, {0xb7, 0x98}, {-1, 0} };
  240. static struct ess_command ess_i16s[] = /* input 16 bit stereo */
  241. { {0xb7, 0x71}, {0xb7, 0xbc}, {-1, 0} };
  243. static struct ess_command *ess_inp_cmds[] =
  244. { ess_i08m, ess_i16m, ess_i08s, ess_i16s };
  247. /*
  248.  * Commands for initializing Audio 1 for output (playback)
  249.  */
  250. static struct ess_command ess_o08m[] = /* output 8 bit mono */
  251. { {0xb6, 0x80}, {0xb7, 0x51}, {0xb7, 0xd0}, {-1, 0} };
  252. static struct ess_command ess_o16m[] = /* output 16 bit mono */
  253. { {0xb6, 0x00}, {0xb7, 0x71}, {0xb7, 0xf4}, {-1, 0} };
  254. static struct ess_command ess_o08s[] = /* output 8 bit stereo */
  255. { {0xb6, 0x80}, {0xb7, 0x51}, {0xb7, 0x98}, {-1, 0} };
  256. static struct ess_command ess_o16s[] = /* output 16 bit stereo */
  257. { {0xb6, 0x00}, {0xb7, 0x71}, {0xb7, 0xbc}, {-1, 0} };
  259. static struct ess_command *ess_out_cmds[] =
  260. { ess_o08m, ess_o16m, ess_o08s, ess_o16s };
  262. static void ess_exec_commands
  263. (sb_devc *devc, struct ess_command *cmdtab[])
  264. {
  265. struct ess_command *cmd;
  267. cmd = cmdtab [ ((devc->channels != 1) << 1) + (devc->bits != AFMT_U8) ];
  269. while (cmd->cmd != -1) {
  270. ess_write (devc, cmd->cmd, cmd->data);
  271. cmd++;
  272. }
  273. }
  275. static void ess_change
  276. (sb_devc *devc, unsigned int reg, unsigned int mask, unsigned int val)
  277. {
  278. int value;
  280. value = ess_read (devc, reg);
  281. value = (value & ~mask) | (val & mask);
  282. ess_write (devc, reg, value);
  283. }
  285. static void ess_set_output_parms
  286. (int dev, unsigned long buf, int nr_bytes, int intrflag)
  287. {
  288. sb_devc *devc = audio_devs[dev]->devc;
  290. if (devc->duplex) {
  291. devc->trg_buf_16 = buf;
  292. devc->trg_bytes_16 = nr_bytes;
  293. devc->trg_intrflag_16 = intrflag;
  294. devc->irq_mode_16 = IMODE_OUTPUT;
  295. } else {
  296. devc->trg_buf = buf;
  297. devc->trg_bytes = nr_bytes;
  298. devc->trg_intrflag = intrflag;
  299. devc->irq_mode = IMODE_OUTPUT;
  300. }
  301. }
  303. static void ess_set_input_parms
  304. (int dev, unsigned long buf, int count, int intrflag)
  305. {
  306. sb_devc *devc = audio_devs[dev]->devc;
  308. devc->trg_buf = buf;
  309. devc->trg_bytes = count;
  310. devc->trg_intrflag = intrflag;
  311. devc->irq_mode = IMODE_INPUT;
  312. }
  314. static int ess_calc_div (int clock, int revert, int *speedp, int *diffp)
  315. {
  316. int divider;
  317. int speed, diff;
  318. int retval;
  320. speed   = *speedp;
  321. divider = (clock + speed / 2) / speed;
  322. retval  = revert - divider;
  323. if (retval > revert - 1) {
  324. retval  = revert - 1;
  325. divider = revert - retval;
  326. }
  327. /* This line is suggested. Must be wrong I think
  328. *speedp = (clock + divider / 2) / divider;
  329. So I chose the next one */
  331. *speedp = clock / divider;
  332. diff = speed - *speedp;
  333. if (diff < 0) diff =-diff;
  334. *diffp  = diff;
  336. return retval;
  337. }
  339. static int ess_calc_best_speed
  340. (int clock1, int rev1, int clock2, int rev2, int *divp, int *speedp)
  341. {
  342. int speed1 = *speedp, speed2 = *speedp;
  343. int div1, div2;
  344. int diff1, diff2;
  345. int retval;
  347. div1 = ess_calc_div (clock1, rev1, &speed1, &diff1);
  348. div2 = ess_calc_div (clock2, rev2, &speed2, &diff2);
  350. if (diff1 < diff2) {
  351. *divp   = div1;
  352. *speedp = speed1;
  353. retval  = 1;
  354. } else {
  355. /* *divp   = div2; */
  356. *divp   = 0x80 | div2;
  357. *speedp = speed2;
  358. retval  = 2;
  359. }
  361. return retval;
  362. }
  364. /*
  365.  * Depending on the audiochannel ESS devices can
  366.  * have different clock settings. These are made consistent for duplex
  367.  * however.
  368.  * callers of ess_speed only do an audionum suggestion, which means
  369.  * input suggests 1, output suggests 2. This suggestion is only true
  370.  * however when doing duplex.
  371.  */
  372. static void ess_common_speed (sb_devc *devc, int *speedp, int *divp)
  373. {
  374. int diff = 0, div;
  376. if (devc->duplex) {
  377. /*
  378.  * The 0x80 is important for the first audio channel
  379.  */
  380. if (devc->submodel == SUBMDL_ES1888) {
  381. div = 0x80 | ess_calc_div (795500, 256, speedp, &diff);
  382. } else {
  383. div = 0x80 | ess_calc_div (795500, 128, speedp, &diff);
  384. }
  385. } else if(devc->caps & SB_CAP_ES18XX_RATE) {
  386. if (devc->submodel == SUBMDL_ES1888) {
  387. ess_calc_best_speed(397700, 128, 795500, 256, 
  388. &div, speedp);
  389. } else {
  390. ess_calc_best_speed(ES18XX_CLOCK1, 128, ES18XX_CLOCK2, 256, 
  391. &div, speedp);
  392. }
  393. } else {
  394. if (*speedp > 22000) {
  395. div = 0x80 | ess_calc_div (ES1688_CLOCK1, 256, speedp, &diff);
  396. } else {
  397. div = 0x00 | ess_calc_div (ES1688_CLOCK2, 128, speedp, &diff);
  398. }
  399. }
  400. *divp = div;
  401. }
  403. static void ess_speed (sb_devc *devc, int audionum)
  404. {
  405. int speed;
  406. int div, div2;
  408. ess_common_speed (devc, &(devc->speed), &div);
  410. #ifdef FKS_REG_LOGGING
  411. printk (KERN_INFO "FKS: ess_speed (%d) b speed = %d, div=%xn", audionum, devc->speed, div);
  412. #endif
  414. /* Set filter roll-off to 90% of speed/2 */
  415. speed = (devc->speed * 9) / 20;
  417. div2 = 256 - 7160000 / (speed * 82);
  419. if (!devc->duplex) audionum = 1;
  421. if (audionum == 1) {
  422. /* Change behaviour of register A1 *
  423. sb_chg_mixer(devc, 0x71, 0x20, 0x20)
  424. * For ES1869 only??? */
  425. ess_write (devc, 0xa1, div);
  426. ess_write (devc, 0xa2, div2);
  427. } else {
  428. ess_setmixer (devc, 0x70, div);
  429. /*
  430.  * FKS: fascinating: 0x72 doesn't seem to work.
  431.  */
  432. ess_write (devc, 0xa2, div2);
  433. ess_setmixer (devc, 0x72, div2);
  434. }
  435. }
  437. static int ess_audio_prepare_for_input(int dev, int bsize, int bcount)
  438. {
  439. sb_devc *devc = audio_devs[dev]->devc;
  441. ess_speed(devc, 1);
  443. sb_dsp_command(devc, DSP_CMD_SPKOFF);
  445. ess_write (devc, 0xb8, 0x0e); /* Auto init DMA mode */
  446. ess_change (devc, 0xa8, 0x03, 3 - devc->channels); /* Mono/stereo */
  447. ess_write (devc, 0xb9, 2); /* Demand mode (4 bytes/DMA request) */
  449. ess_exec_commands (devc, ess_inp_cmds);
  451. ess_change (devc, 0xb1, 0xf0, 0x50);
  452. ess_change (devc, 0xb2, 0xf0, 0x50);
  454. devc->trigger_bits = 0;
  455. return 0;
  456. }
  458. static int ess_audio_prepare_for_output_audio1 (int dev, int bsize, int bcount)
  459. {
  460. sb_devc *devc = audio_devs[dev]->devc;
  462. sb_dsp_reset(devc);
  463. ess_speed(devc, 1);
  464. ess_write (devc, 0xb8, 4); /* Auto init DMA mode */
  465. ess_change (devc, 0xa8, 0x03, 3 - devc->channels); /* Mono/stereo */
  466. ess_write (devc, 0xb9, 2); /* Demand mode (4 bytes/request) */
  468. ess_exec_commands (devc, ess_out_cmds);
  470. ess_change (devc, 0xb1, 0xf0, 0x50); /* Enable DMA */
  471. ess_change (devc, 0xb2, 0xf0, 0x50); /* Enable IRQ */
  473. sb_dsp_command(devc, DSP_CMD_SPKON); /* There be sound! */
  475. devc->trigger_bits = 0;
  476. return 0;
  477. }
  479. static int ess_audio_prepare_for_output_audio2 (int dev, int bsize, int bcount)
  480. {
  481. sb_devc *devc = audio_devs[dev]->devc;
  482. unsigned char bits;
  484. /* FKS: qqq
  485. sb_dsp_reset(devc);
  486. */
  488. /*
  489.  * Auto-Initialize:
  490.  * DMA mode + demand mode (8 bytes/request, yes I want it all!)
  491.  * But leave 16-bit DMA bit untouched!
  492.  */
  493. ess_chgmixer (devc, 0x78, 0xd0, 0xd0);
  495. ess_speed(devc, 2);
  497. /* bits 4:3 on ES1887 represent recording source. Keep them! */
  498. bits = ess_getmixer (devc, 0x7a) & 0x18;
  500. /* Set stereo/mono */
  501. if (devc->channels != 1) bits |= 0x02;
  503. /* Init DACs; UNSIGNED mode for 8 bit; SIGNED mode for 16 bit */
  504. if (devc->bits != AFMT_U8) bits |= 0x05; /* 16 bit */
  506. /* Enable DMA, IRQ will be shared (hopefully)*/
  507. bits |= 0x60;
  509. ess_setmixer (devc, 0x7a, bits);
  511. ess_mixer_reload (devc, SOUND_MIXER_PCM); /* There be sound! */
  513. devc->trigger_bits = 0;
  514. return 0;
  515. }
  517. static int ess_audio_prepare_for_output(int dev, int bsize, int bcount)
  518. {
  519. sb_devc *devc = audio_devs[dev]->devc;
  521. #ifdef FKS_REG_LOGGING
  522. printk(KERN_INFO "ess_audio_prepare_for_output: dma_out=%d,dma_in=%dn"
  523. , audio_devs[dev]->dmap_out->dma, audio_devs[dev]->dmap_in->dma);
  524. #endif
  526. if (devc->duplex) {
  527. return ess_audio_prepare_for_output_audio2 (dev, bsize, bcount);
  528. } else {
  529. return ess_audio_prepare_for_output_audio1 (dev, bsize, bcount);
  530. }
  531. }
  533. static void ess_audio_halt_xfer(int dev)
  534. {
  535. unsigned long flags;
  536. sb_devc *devc = audio_devs[dev]->devc;
  538. spin_lock_irqsave(&devc->lock, flags);
  539. sb_dsp_reset(devc);
  540. spin_unlock_irqrestore(&devc->lock, flags);
  542. /*
  543.  * Audio 2 may still be operational! Creates awful sounds!
  544.  */
  545. if (devc->duplex) ess_chgmixer(devc, 0x78, 0x03, 0x00);
  546. }
  548. static void ess_audio_start_input
  549. (int dev, unsigned long buf, int nr_bytes, int intrflag)
  550. {
  551. int count = nr_bytes;
  552. sb_devc *devc = audio_devs[dev]->devc;
  553. short c = -nr_bytes;
  555. /*
  556.  * Start a DMA input to the buffer pointed by dmaqtail
  557.  */
  559. if (audio_devs[dev]->dmap_in->dma > 3) count >>= 1;
  560. count--;
  562. devc->irq_mode = IMODE_INPUT;
  564. ess_write (devc, 0xa4, (unsigned char) ((unsigned short) c & 0xff));
  565. ess_write (devc, 0xa5, (unsigned char) (((unsigned short) c >> 8) & 0xff));
  567. ess_change (devc, 0xb8, 0x0f, 0x0f); /* Go */
  568. devc->intr_active = 1;
  569. }
  571. static void ess_audio_output_block_audio1
  572. (int dev, unsigned long buf, int nr_bytes, int intrflag)
  573. {
  574. int count = nr_bytes;
  575. sb_devc *devc = audio_devs[dev]->devc;
  576. short c = -nr_bytes;
  578. if (audio_devs[dev]->dmap_out->dma > 3)
  579. count >>= 1;
  580. count--;
  582. devc->irq_mode = IMODE_OUTPUT;
  584. ess_write (devc, 0xa4, (unsigned char) ((unsigned short) c & 0xff));
  585. ess_write (devc, 0xa5, (unsigned char) (((unsigned short) c >> 8) & 0xff));
  587. ess_change (devc, 0xb8, 0x05, 0x05); /* Go */
  588. devc->intr_active = 1;
  589. }
  591. static void ess_audio_output_block_audio2
  592. (int dev, unsigned long buf, int nr_bytes, int intrflag)
  593. {
  594. int count = nr_bytes;
  595. sb_devc *devc = audio_devs[dev]->devc;
  596. short c = -nr_bytes;
  598. if (audio_devs[dev]->dmap_out->dma > 3) count >>= 1;
  599. count--;
  601. ess_setmixer (devc, 0x74, (unsigned char) ((unsigned short) c & 0xff));
  602. ess_setmixer (devc, 0x76, (unsigned char) (((unsigned short) c >> 8) & 0xff));
  603. ess_chgmixer (devc, 0x78, 0x03, 0x03);   /* Go */
  605. devc->irq_mode_16 = IMODE_OUTPUT;
  606. devc->intr_active_16 = 1;
  607. }
  609. static void ess_audio_output_block
  610. (int dev, unsigned long buf, int nr_bytes, int intrflag)
  611. {
  612. sb_devc *devc = audio_devs[dev]->devc;
  614. if (devc->duplex) {
  615. ess_audio_output_block_audio2 (dev, buf, nr_bytes, intrflag);
  616. } else {
  617. ess_audio_output_block_audio1 (dev, buf, nr_bytes, intrflag);
  618. }
  619. }
  621. /*
  622.  * FKS: the if-statements for both bits and bits_16 are quite alike.
  623.  * Combine this...
  624.  */
  625. static void ess_audio_trigger(int dev, int bits)
  626. {
  627. sb_devc *devc = audio_devs[dev]->devc;
  629. int bits_16 = bits & devc->irq_mode_16;
  630. bits &= devc->irq_mode;
  632. if (!bits && !bits_16) {
  633. /* FKS oh oh.... wrong?? for dma 16? */
  634. sb_dsp_command(devc, 0xd0); /* Halt DMA */
  635. }
  637. if (bits) {
  638. switch (devc->irq_mode)
  639. {
  640. case IMODE_INPUT:
  641. ess_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
  642. devc->trg_intrflag);
  643. break;
  645. case IMODE_OUTPUT:
  646. ess_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
  647. devc->trg_intrflag);
  648. break;
  649. }
  650. }
  652. if (bits_16) {
  653. switch (devc->irq_mode_16) {
  654. case IMODE_INPUT:
  655. ess_audio_start_input(dev, devc->trg_buf_16, devc->trg_bytes_16,
  656. devc->trg_intrflag_16);
  657. break;
  659. case IMODE_OUTPUT:
  660. ess_audio_output_block(dev, devc->trg_buf_16, devc->trg_bytes_16,
  661. devc->trg_intrflag_16);
  662. break;
  663. }
  664. }
  666. devc->trigger_bits = bits | bits_16;
  667. }
  669. static int ess_audio_set_speed(int dev, int speed)
  670. {
  671. sb_devc *devc = audio_devs[dev]->devc;
  672. int minspeed, maxspeed, dummydiv;
  674. if (speed > 0) {
  675. minspeed = (devc->duplex ? 6215  : 5000 );
  676. maxspeed = (devc->duplex ? 44100 : 48000);
  677. if (speed < minspeed) speed = minspeed;
  678. if (speed > maxspeed) speed = maxspeed;
  680. ess_common_speed (devc, &speed, &dummydiv);
  682. devc->speed = speed;
  683. }
  684. return devc->speed;
  685. }
  687. /*
  688.  * FKS: This is a one-on-one copy of sb1_audio_set_bits
  689.  */
  690. static unsigned int ess_audio_set_bits(int dev, unsigned int bits)
  691. {
  692. sb_devc *devc = audio_devs[dev]->devc;
  694. if (bits != 0) {
  695. if (bits == AFMT_U8 || bits == AFMT_S16_LE) {
  696. devc->bits = bits;
  697. } else {
  698. devc->bits = AFMT_U8;
  699. }
  700. }
  702. return devc->bits;
  703. }
  705. /*
  706.  * FKS: This is a one-on-one copy of sbpro_audio_set_channels
  707.  * (*) Modified it!!
  708.  */
  709. static short ess_audio_set_channels(int dev, short channels)
  710. {
  711. sb_devc *devc = audio_devs[dev]->devc;
  713. if (channels == 1 || channels == 2) devc->channels = channels;
  715. return devc->channels;
  716. }
  718. static struct audio_driver ess_audio_driver =   /* ESS ES688/1688 */
  719. {
  720. owner: THIS_MODULE,
  721. open: sb_audio_open,
  722. close: sb_audio_close,
  723. output_block: ess_set_output_parms,
  724. start_input: ess_set_input_parms,
  725. prepare_for_input: ess_audio_prepare_for_input,
  726. prepare_for_output: ess_audio_prepare_for_output,
  727. halt_io: ess_audio_halt_xfer,
  728. trigger: ess_audio_trigger,
  729. set_speed: ess_audio_set_speed,
  730. set_bits: ess_audio_set_bits,
  731. set_channels: ess_audio_set_channels
  732. };
  734. /*
  735.  * ess_audio_init must be called from sb_audio_init
  736.  */
  737. struct audio_driver *ess_audio_init
  738. (sb_devc *devc, int *audio_flags, int *format_mask)
  739. {
  740. *audio_flags = DMA_AUTOMODE;
  741. *format_mask |= AFMT_S16_LE;
  743. if (devc->duplex) {
  744. int tmp_dma;
  745. /*
  746.  * sb_audio_init thinks dma8 is for playback and
  747.  * dma16 is for record. Not now! So swap them.
  748.  */
  749. tmp_dma = devc->dma16;
  750. devc->dma16 = devc->dma8;
  751. devc->dma8 = tmp_dma;
  753. *audio_flags |= DMA_DUPLEX;
  754. }
  756. return &ess_audio_driver;
  757. }
  759. /****************************************************************************
  760.  * *
  761.  * ESS common *
  762.  * *
  763.  ****************************************************************************/
  764. static void ess_handle_channel
  765. (char *channel, int dev, int intr_active, unsigned char flag, int irq_mode)
  766. {
  767. if (!intr_active || !flag) return;
  768. #ifdef FKS_REG_LOGGING
  769. printk(KERN_INFO "FKS: ess_handle_channel %s irq_mode=%dn", channel, irq_mode);
  770. #endif
  771. switch (irq_mode) {
  772. case IMODE_OUTPUT:
  773. DMAbuf_outputintr (dev, 1);
  774. break;
  776. case IMODE_INPUT:
  777. DMAbuf_inputintr (dev);
  778. break;
  780. case IMODE_INIT:
  781. break;
  783. default:;
  784. /* printk(KERN_WARN "ESS: Unexpected interruptn"); */
  785. }
  786. }
  788. /*
  789.  * FKS: TODO!!! Finish this!
  790.  *
  791.  * I think midi stuff uses uart401, without interrupts.
  792.  * So IMODE_MIDI isn't a value for devc->irq_mode.
  793.  */
  794. void ess_intr (sb_devc *devc)
  795. {
  796. int status;
  797. unsigned char src;
  799. if (devc->submodel == SUBMDL_ES1887) {
  800. src = ess_getmixer (devc, 0x7f) >> 4;
  801. } else {
  802. src = 0xff;
  803. }
  805. #ifdef FKS_REG_LOGGING
  806. printk(KERN_INFO "FKS: sbintr src=%xn",(int)src);
  807. #endif
  808. ess_handle_channel
  809. ( "Audio 1"
  810. , devc->dev, devc->intr_active   , src & 0x01, devc->irq_mode   );
  811. ess_handle_channel
  812. ( "Audio 2"
  813. , devc->dev, devc->intr_active_16, src & 0x02, devc->irq_mode_16);
  814. /*
  815.  * Acknowledge interrupts
  816.  */
  817. if (devc->submodel == SUBMDL_ES1887 && (src & 0x02)) {
  818. ess_chgmixer (devc, 0x7a, 0x80, 0x00);
  819. }
  821. if (src & 0x01) {
  822. status = inb(DSP_DATA_AVAIL);
  823. }
  824. }
  826. static void ess_extended (sb_devc * devc)
  827. {
  828. /* Enable extended mode */
  830. sb_dsp_command(devc, 0xc6);
  831. }
  833. static int ess_write (sb_devc * devc, unsigned char reg, unsigned char data)
  834. {
  835. #ifdef FKS_REG_LOGGING
  836. printk(KERN_INFO "FKS: write reg %x: %xn", reg, data);
  837. #endif
  838. /* Write a byte to an extended mode register of ES1688 */
  840. if (!sb_dsp_command(devc, reg))
  841. return 0;
  843. return sb_dsp_command(devc, data);
  844. }
  846. static int ess_read (sb_devc * devc, unsigned char reg)
  847. {
  848. /* Read a byte from an extended mode register of ES1688 */
  850. /* Read register command */
  851. if (!sb_dsp_command(devc, 0xc0)) return -1;
  853. if (!sb_dsp_command(devc, reg )) return -1;
  855. return sb_dsp_get_byte(devc);
  856. }
  858. int ess_dsp_reset(sb_devc * devc)
  859. {
  860. int loopc;
  862. #ifdef FKS_REG_LOGGING
  863. printk(KERN_INFO "FKS: ess_dsp_reset 1n");
  864. ess_show_mixerregs (devc);
  865. #endif
  867. DEB(printk("Entered ess_dsp_reset()n"));
  869. outb(3, DSP_RESET); /* Reset FIFO too */
  871. udelay(10);
  872. outb(0, DSP_RESET);
  873. udelay(30);
  875. for (loopc = 0; loopc < 1000 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++);
  877. if (inb(DSP_READ) != 0xAA) {
  878. DDB(printk("sb: No response to RESETn"));
  879. return 0;   /* Sorry */
  880. }
  881. ess_extended (devc);
  883. DEB(printk("sb_dsp_reset() OKn"));
  885. #ifdef FKS_LOGGING
  886. printk(KERN_INFO "FKS: dsp_reset 2n");
  887. ess_show_mixerregs (devc);
  888. #endif
  890. return 1;
  891. }
  893. static int ess_irq_bits (int irq)
  894. {
  895. switch (irq) {
  896. case 2:
  897. case 9:
  898. return 0;
  900. case 5:
  901. return 1;
  903. case 7:
  904. return 2;
  906. case 10:
  907. return 3;
  909. default:
  910. printk(KERN_ERR "ESS1688: Invalid IRQ %dn", irq);
  911. return -1;
  912. }
  913. }
  915. /*
  916.  * Set IRQ configuration register for all ESS models
  917.  */
  918. static int ess_common_set_irq_hw (sb_devc * devc)
  919. {
  920. int irq_bits;
  922. if ((irq_bits = ess_irq_bits (devc->irq)) == -1) return 0;
  924. if (!ess_write (devc, 0xb1, 0x50 | (irq_bits << 2))) {
  925. printk(KERN_ERR "ES1688: Failed to write to IRQ config registern");
  926. return 0;
  927. }
  928. return 1;
  929. }
  931. /*
  932.  * I wanna use modern ES1887 mixer irq handling. Funny is the
  933.  * fact that my BIOS wants the same. But suppose someone's BIOS
  934.  * doesn't do this!
  935.  * This is independent of duplex. If there's a 1887 this will
  936.  * prevent it from going into 1888 mode.
  937.  */
  938. static void ess_es1887_set_irq_hw (sb_devc * devc)
  939. {
  940. int irq_bits;
  942. if ((irq_bits = ess_irq_bits (devc->irq)) == -1) return;
  944. ess_chgmixer (devc, 0x7f, 0x0f, 0x01 | ((irq_bits + 1) << 1));
  945. }
  947. static int ess_set_irq_hw (sb_devc * devc)
  948. {
  949. if (devc->submodel == SUBMDL_ES1887) ess_es1887_set_irq_hw (devc);
  951. return ess_common_set_irq_hw (devc);
  952. }
  954. #ifdef FKS_TEST
  956. /*
  957.  * FKS_test:
  958.  * for ES1887: 00, 18, non wr bits: 0001 1000
  959.  * for ES1868: 00, b8, non wr bits: 1011 1000
  960.  * for ES1888: 00, f8, non wr bits: 1111 1000
  961.  * for ES1688: 00, f8, non wr bits: 1111 1000
  962.  * +   ES968
  963.  */
  965. static void FKS_test (sb_devc * devc)
  966. {
  967. int val1, val2;
  968. val1 = ess_getmixer (devc, 0x64);
  969. ess_setmixer (devc, 0x64, ~val1);
  970. val2 = ess_getmixer (devc, 0x64) ^ ~val1;
  971. ess_setmixer (devc, 0x64, val1);
  972. val1 ^= ess_getmixer (devc, 0x64);
  973. printk (KERN_INFO "FKS: FKS_test %02x, %02xn", (val1 & 0x0ff), (val2 & 0x0ff));
  974. };
  975. #endif
  977. static unsigned int ess_identify (sb_devc * devc)
  978. {
  979. unsigned int val;
  980. unsigned long flags;
  982. spin_lock_irqsave(&devc->lock, flags);
  983. outb(((unsigned char) (0x40 & 0xff)), MIXER_ADDR);
  985. udelay(20);
  986. val  = inb(MIXER_DATA) << 8;
  987. udelay(20);
  988. val |= inb(MIXER_DATA);
  989. udelay(20);
  990. spin_unlock_irqrestore(&devc->lock, flags);
  992. return val;
  993. }
  995. /*
  996.  * ESS technology describes a detection scheme in their docs. It involves
  997.  * fiddling with the bits in certain mixer registers. ess_probe is supposed
  998.  * to help.
  999.  *
  1000.  * FKS: tracing shows ess_probe writes wrong value to 0x64. Bit 3 reads 1, but
  1001.  * should be written 0 only. Check this.
  1002.  */
  1003. static int ess_probe (sb_devc * devc, int reg, int xorval)
  1004. {
  1005. int  val1, val2, val3;
  1007. val1 = ess_getmixer (devc, reg);
  1008. val2 = val1 ^ xorval;
  1009. ess_setmixer (devc, reg, val2);
  1010. val3 = ess_getmixer (devc, reg);
  1011. ess_setmixer (devc, reg, val1);
  1013. return (val2 == val3);
  1014. }
  1016. int ess_init(sb_devc * devc, struct address_info *hw_config)
  1017. {
  1018. unsigned char cfg;
  1019. int ess_major = 0, ess_minor = 0;
  1020. int i;
  1021. static char name[100], modelname[10];
  1023. /*
  1024.  * Try to detect ESS chips.
  1025.  */
  1027. sb_dsp_command(devc, 0xe7); /* Return identification */
  1029. for (i = 1000; i; i--) {
  1030. if (inb(DSP_DATA_AVAIL) & 0x80) {
  1031. if (ess_major == 0) {
  1032. ess_major = inb(DSP_READ);
  1033. } else {
  1034. ess_minor = inb(DSP_READ);
  1035. break;
  1036. }
  1037. }
  1038. }
  1040. if (ess_major == 0) return 0;
  1042. if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) {
  1043. sprintf(name, "ESS ES488 AudioDrive (rev %d)",
  1044. ess_minor & 0x0f);
  1045. hw_config->name = name;
  1046. devc->model = MDL_SBPRO;
  1047. return 1;
  1048. }
  1050. /*
  1051.  * This the detection heuristic of ESS technology, though somewhat
  1052.  * changed to actually make it work.
  1053.  * This results in the following detection steps:
  1054.  * - distinct between ES688 and ES1688+ (as always done in this driver)
  1055.  *   if ES688 we're ready
  1056.  * - try to detect ES1868, ES1869 or ES1878 (ess_identify)
  1057.  *   if successful we're ready
  1058.  * - try to detect ES1888, ES1887 or ES1788 (aim: detect ES1887)
  1059.  *   if successful we're ready
  1060.  * - Dunno. Must be 1688. Will do in general
  1061.  *
  1062.  * This is the most BETA part of the software: Will the detection
  1063.  * always work?
  1064.  */
  1065. devc->model = MDL_ESS;
  1066. devc->submodel = ess_minor & 0x0f;
  1068. if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) {
  1069. char *chip = NULL;
  1070. int submodel = -1;
  1072. switch (devc->sbmo.esstype) {
  1073. case ESSTYPE_DETECT:
  1074. case ESSTYPE_LIKE20:
  1075. break;
  1076. case 688:
  1077. submodel = 0x00;
  1078. break;
  1079. case 1688:
  1080. submodel = 0x08;
  1081. break;
  1082. case 1868:
  1083. submodel = SUBMDL_ES1868;
  1084. break;
  1085. case 1869:
  1086. submodel = SUBMDL_ES1869;
  1087. break;
  1088. case 1788:
  1089. submodel = SUBMDL_ES1788;
  1090. break;
  1091. case 1878:
  1092. submodel = SUBMDL_ES1878;
  1093. break;
  1094. case 1879:
  1095. submodel = SUBMDL_ES1879;
  1096. break;
  1097. case 1887:
  1098. submodel = SUBMDL_ES1887;
  1099. break;
  1100. case 1888:
  1101. submodel = SUBMDL_ES1888;
  1102. break;
  1103. default:
  1104. printk (KERN_ERR "Invalid esstype=%d specifiedn", devc->sbmo.esstype);
  1105. return 0;
  1106. };
  1107. if (submodel != -1) {
  1108. devc->submodel = submodel;
  1109. sprintf (modelname, "ES%d", devc->sbmo.esstype);
  1110. chip = modelname;
  1111. };
  1112. if (chip == NULL && (ess_minor & 0x0f) < 8) {
  1113. chip = "ES688";
  1114. };
  1115. #ifdef FKS_TEST
  1116. FKS_test (devc);
  1117. #endif
  1118. /*
  1119.  * If Nothing detected yet, and we want 2.0 behaviour...
  1120.  * Then let's assume it's ES1688.
  1121.  */
  1122. if (chip == NULL && devc->sbmo.esstype == ESSTYPE_LIKE20) {
  1123. chip = "ES1688";
  1124. };
  1126. if (chip == NULL) {
  1127. int type;
  1129. type = ess_identify (devc);
  1131. switch (type) {
  1132. case 0x1868:
  1133. chip = "ES1868";
  1134. devc->submodel = SUBMDL_ES1868;
  1135. break;
  1136. case 0x1869:
  1137. chip = "ES1869";
  1138. devc->submodel = SUBMDL_ES1869;
  1139. break;
  1140. case 0x1878:
  1141. chip = "ES1878";
  1142. devc->submodel = SUBMDL_ES1878;
  1143. break;
  1144. case 0x1879:
  1145. chip = "ES1879";
  1146. devc->submodel = SUBMDL_ES1879;
  1147. break;
  1148. default:
  1149. if ((type & 0x00ff) != ((type >> 8) & 0x00ff)) {
  1150. printk ("ess_init: Unrecognized %04xn", type);
  1151. }
  1152. };
  1153. };
  1154. #if 0
  1155. /*
  1156.  * this one failed:
  1157.  * the probing of bit 4 is another thought: from ES1788 and up, all
  1158.  * chips seem to have hardware volume control. Bit 4 is readonly to
  1159.  * check if a hardware volume interrupt has fired.
  1160.  * Cause ES688/ES1688 don't have this feature, bit 4 might be writeable
  1161.  * for these chips.
  1162.  */
  1163. if (chip == NULL && !ess_probe(devc, 0x64, (1 << 4))) {
  1164. #endif
  1165. /*
  1166.  * the probing of bit 2 is my idea. The ES1887 docs want me to probe
  1167.  * bit 3. This results in ES1688 being detected as ES1788.
  1168.  * Bit 2 is for "Enable HWV IRQE", but as ES(1)688 chips don't have
  1169.  * HardWare Volume, I think they don't have this IRQE.
  1170.  */
  1171. if (chip == NULL && ess_probe(devc, 0x64, (1 << 2))) {
  1172. if (ess_probe (devc, 0x70, 0x7f)) {
  1173. if (ess_probe (devc, 0x64, (1 << 5))) {
  1174. chip = "ES1887";
  1175. devc->submodel = SUBMDL_ES1887;
  1176. } else {
  1177. chip = "ES1888";
  1178. devc->submodel = SUBMDL_ES1888;
  1179. }
  1180. } else {
  1181. chip = "ES1788";
  1182. devc->submodel = SUBMDL_ES1788;
  1183. }
  1184. };
  1185. if (chip == NULL) {
  1186. chip = "ES1688";
  1187. };
  1189.     printk ( KERN_INFO "ESS chip %s %s%sn"
  1190.                , chip
  1191.                , ( devc->sbmo.esstype == ESSTYPE_DETECT || devc->sbmo.esstype == ESSTYPE_LIKE20
  1192.                  ? "detected"
  1193.                  : "specified"
  1194.                  )
  1195.                , ( devc->sbmo.esstype == ESSTYPE_LIKE20
  1196.                  ? " (kernel 2.0 compatible)"
  1197.                  : ""
  1198.                  )
  1199.                );
  1201. sprintf(name,"ESS %s AudioDrive (rev %d)", chip, ess_minor & 0x0f);
  1202. } else {
  1203. strcpy(name, "Jazz16");
  1204. }
  1206. /* AAS: info stolen from ALSA: these boards have different clocks */
  1207. switch(devc->submodel) {
  1208. /* APPARENTLY NOT 1869 AND 1887
  1209. case SUBMDL_ES1869:
  1210. case SUBMDL_ES1887:
  1211. */
  1212. case SUBMDL_ES1888:
  1213. devc->caps |= SB_CAP_ES18XX_RATE;
  1214. break;
  1215. }
  1217. hw_config->name = name;
  1218. /* FKS: sb_dsp_reset to enable extended mode???? */
  1219. sb_dsp_reset(devc); /* Turn on extended mode */
  1221. /*
  1222.  *  Enable joystick and OPL3
  1223.  */
  1224. cfg = ess_getmixer (devc, 0x40);
  1225. ess_setmixer (devc, 0x40, cfg | 0x03);
  1226. if (devc->submodel >= 8) { /* ES1688 */
  1227. devc->caps |= SB_NO_MIDI;   /* ES1688 uses MPU401 MIDI mode */
  1228. }
  1229. sb_dsp_reset (devc);
  1231. /*
  1232.  * This is important! If it's not done, the IRQ probe in sb_dsp_init
  1233.  * may fail.
  1234.  */
  1235. return ess_set_irq_hw (devc);
  1236. }
  1238. static int ess_set_dma_hw(sb_devc * devc)
  1239. {
  1240. unsigned char cfg, dma_bits = 0, dma16_bits;
  1241. int dma;
  1243. #ifdef FKS_LOGGING
  1244. printk(KERN_INFO "ess_set_dma_hw: dma8=%d,dma16=%d,dup=%dn"
  1245. , devc->dma8, devc->dma16, devc->duplex);
  1246. #endif
  1248. /*
  1249.  * FKS: It seems as if this duplex flag isn't set yet. Check it.
  1250.  */
  1251. dma = devc->dma8;
  1253. if (dma > 3 || dma < 0 || dma == 2) {
  1254. dma_bits = 0;
  1255. printk(KERN_ERR "ESS1688: Invalid DMA8 %dn", dma);
  1256. return 0;
  1257. } else {
  1258. /* Extended mode DMA enable */
  1259. cfg = 0x50;
  1261. if (dma == 3) {
  1262. dma_bits = 3;
  1263. } else {
  1264. dma_bits = dma + 1;
  1265. }
  1266. }
  1268. if (!ess_write (devc, 0xb2, cfg | (dma_bits << 2))) {
  1269. printk(KERN_ERR "ESS1688: Failed to write to DMA config registern");
  1270. return 0;
  1271. }
  1273. if (devc->duplex) {
  1274. dma = devc->dma16;
  1275. dma16_bits = 0;
  1277. if (dma >= 0) {
  1278. switch (dma) {
  1279. case 0:
  1280. dma_bits = 0x04;
  1281. break;
  1282. case 1:
  1283. dma_bits = 0x05;
  1284. break;
  1285. case 3:
  1286. dma_bits = 0x06;
  1287. break;
  1288. case 5:
  1289. dma_bits   = 0x07;
  1290. dma16_bits = 0x20;
  1291. break;
  1292. default:
  1293. printk(KERN_ERR "ESS1887: Invalid DMA16 %dn", dma);
  1294. return 0;
  1295. };
  1296. ess_chgmixer (devc, 0x78, 0x20, dma16_bits);
  1297. ess_chgmixer (devc, 0x7d, 0x07, dma_bits);
  1298. }
  1299. }
  1300. return 1;
  1301. }
  1303. /*
  1304.  * This one is called from sb_dsp_init.
  1305.  *
  1306.  * Return values:
  1307.  *  0: Failed
  1308.  *  1: Succeeded or doesn't apply (not SUBMDL_ES1887)
  1309.  */
  1310. int ess_dsp_init (sb_devc *devc, struct address_info *hw_config)
  1311. {
  1312. /*
  1313.  * Caller also checks this, but anyway
  1314.  */
  1315. if (devc->model != MDL_ESS) {
  1316. printk (KERN_INFO "ess_dsp_init for non ESS chipn");
  1317. return 1;
  1318. }
  1319. /*
  1320.  * This for ES1887 to run Full Duplex. Actually ES1888
  1321.  * is allowed to do so too. I have no idea yet if this
  1322.  * will work for ES1888 however.
  1323.  *
  1324.  * For SB16 having both dma8 and dma16 means enable
  1325.  * Full Duplex. Let's try this for ES1887 too
  1326.  *
  1327.  */
  1328. if (devc->submodel == SUBMDL_ES1887) {
  1329. if (hw_config->dma2 != -1) {
  1330. devc->dma16 = hw_config->dma2;
  1331. }
  1332. /*
  1333.  * devc->duplex initialization is put here, cause
  1334.  * ess_set_dma_hw needs it.
  1335.  */
  1336. if (devc->dma8 != devc->dma16 && devc->dma16 != -1) {
  1337. devc->duplex = 1;
  1338. }
  1339. }
  1340. if (!ess_set_dma_hw (devc)) {
  1341. free_irq(devc->irq, devc);
  1342. return 0;
  1343. }
  1344. return 1;
  1345. }
  1347. /****************************************************************************
  1348.  * *
  1349.  * ESS mixer *
  1350.  * *
  1351.  ****************************************************************************/
  1353. #define ES688_RECORDING_DEVICES
  1354. ( SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD )
  1355. #define ES688_MIXER_DEVICES
  1356. ( SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE
  1357. | SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_VOLUME
  1358. | SOUND_MASK_LINE2 | SOUND_MASK_SPEAKER )
  1360. #define ES1688_RECORDING_DEVICES
  1361. ( ES688_RECORDING_DEVICES )
  1362. #define ES1688_MIXER_DEVICES
  1363. ( ES688_MIXER_DEVICES | SOUND_MASK_RECLEV )
  1365. #define ES1887_RECORDING_DEVICES
  1366. ( ES1688_RECORDING_DEVICES | SOUND_MASK_LINE2 | SOUND_MASK_SYNTH)
  1367. #define ES1887_MIXER_DEVICES
  1368. ( ES1688_MIXER_DEVICES )
  1370. /*
  1371.  * Mixer registers of ES1887
  1372.  *
  1373.  * These registers specifically take care of recording levels. To make the
  1374.  * mapping from playback devices to recording devices every recording
  1375.  * devices = playback device + ES_REC_MIXER_RECDIFF
  1376.  */
  1377. #define ES_REC_MIXER_RECBASE (SOUND_MIXER_LINE3 + 1)
  1378. #define ES_REC_MIXER_RECDIFF (ES_REC_MIXER_RECBASE - SOUND_MIXER_SYNTH)
  1380. #define ES_REC_MIXER_RECSYNTH (SOUND_MIXER_SYNTH  + ES_REC_MIXER_RECDIFF)
  1381. #define ES_REC_MIXER_RECPCM (SOUND_MIXER_PCM  + ES_REC_MIXER_RECDIFF)
  1382. #define ES_REC_MIXER_RECSPEAKER (SOUND_MIXER_SPEAKER + ES_REC_MIXER_RECDIFF)
  1383. #define ES_REC_MIXER_RECLINE (SOUND_MIXER_LINE  + ES_REC_MIXER_RECDIFF)
  1384. #define ES_REC_MIXER_RECMIC (SOUND_MIXER_MIC  + ES_REC_MIXER_RECDIFF)
  1385. #define ES_REC_MIXER_RECCD (SOUND_MIXER_CD  + ES_REC_MIXER_RECDIFF)
  1386. #define ES_REC_MIXER_RECIMIX (SOUND_MIXER_IMIX  + ES_REC_MIXER_RECDIFF)
  1387. #define ES_REC_MIXER_RECALTPCM (SOUND_MIXER_ALTPCM  + ES_REC_MIXER_RECDIFF)
  1388. #define ES_REC_MIXER_RECRECLEV (SOUND_MIXER_RECLEV  + ES_REC_MIXER_RECDIFF)
  1389. #define ES_REC_MIXER_RECIGAIN (SOUND_MIXER_IGAIN  + ES_REC_MIXER_RECDIFF)
  1390. #define ES_REC_MIXER_RECOGAIN (SOUND_MIXER_OGAIN  + ES_REC_MIXER_RECDIFF)
  1391. #define ES_REC_MIXER_RECLINE1 (SOUND_MIXER_LINE1  + ES_REC_MIXER_RECDIFF)
  1392. #define ES_REC_MIXER_RECLINE2 (SOUND_MIXER_LINE2  + ES_REC_MIXER_RECDIFF)
  1393. #define ES_REC_MIXER_RECLINE3 (SOUND_MIXER_LINE3  + ES_REC_MIXER_RECDIFF)
  1395. static mixer_tab es688_mix = {
  1396. MIX_ENT(SOUND_MIXER_VOLUME, 0x32, 7, 4, 0x32, 3, 4),
  1397. MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
  1398. MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
  1399. MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
  1400. MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
  1401. MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
  1402. MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
  1403. MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
  1404. MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
  1405. MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
  1406. MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
  1407. MIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0),
  1408. MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1409. MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1410. MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
  1411. MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
  1412. MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0)
  1413. };
  1415. /*
  1416.  * The ES1688 specifics... hopefully correct...
  1417.  * - 6 bit master volume
  1418.  *   I was wrong, ES1888 docs say ES1688 didn't have it.
  1419.  * - RECLEV control
  1420.  * These may apply to ES688 too. I have no idea.
  1421.  */
  1422. static mixer_tab es1688_mix = {
  1423. MIX_ENT(SOUND_MIXER_VOLUME, 0x32, 7, 4, 0x32, 3, 4),
  1424. MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
  1425. MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
  1426. MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
  1427. MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
  1428. MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
  1429. MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
  1430. MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
  1431. MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
  1432. MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
  1433. MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
  1434. MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
  1435. MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1436. MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1437. MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
  1438. MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
  1439. MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0)
  1440. };
  1442. static mixer_tab es1688later_mix = {
  1443. MIX_ENT(SOUND_MIXER_VOLUME, 0x60, 5, 6, 0x62, 5, 6),
  1444. MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
  1445. MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
  1446. MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
  1447. MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
  1448. MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
  1449. MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
  1450. MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
  1451. MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
  1452. MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
  1453. MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
  1454. MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
  1455. MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1456. MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1457. MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
  1458. MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
  1459. MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0)
  1460. };
  1462. /*
  1463.  * This one is for all ESS chips with a record mixer.
  1464.  * It's not used (yet) however
  1465.  */
  1466. static mixer_tab es_rec_mix = {
  1467. MIX_ENT(SOUND_MIXER_VOLUME, 0x60, 5, 6, 0x62, 5, 6),
  1468. MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
  1469. MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
  1470. MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
  1471. MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
  1472. MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
  1473. MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
  1474. MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
  1475. MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
  1476. MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
  1477. MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
  1478. MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
  1479. MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1480. MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1481. MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
  1482. MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
  1483. MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0),
  1484. MIX_ENT(ES_REC_MIXER_RECSYNTH, 0x6b, 7, 4, 0x6b, 3, 4),
  1485. MIX_ENT(ES_REC_MIXER_RECPCM, 0x00, 0, 0, 0x00, 0, 0),
  1486. MIX_ENT(ES_REC_MIXER_RECSPEAKER, 0x00, 0, 0, 0x00, 0, 0),
  1487. MIX_ENT(ES_REC_MIXER_RECLINE, 0x6e, 7, 4, 0x6e, 3, 4),
  1488. MIX_ENT(ES_REC_MIXER_RECMIC, 0x68, 7, 4, 0x68, 3, 4),
  1489. MIX_ENT(ES_REC_MIXER_RECCD, 0x6a, 7, 4, 0x6a, 3, 4),
  1490. MIX_ENT(ES_REC_MIXER_RECIMIX, 0x00, 0, 0, 0x00, 0, 0),
  1491. MIX_ENT(ES_REC_MIXER_RECALTPCM, 0x00, 0, 0, 0x00, 0, 0),
  1492. MIX_ENT(ES_REC_MIXER_RECRECLEV, 0x00, 0, 0, 0x00, 0, 0),
  1493. MIX_ENT(ES_REC_MIXER_RECIGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1494. MIX_ENT(ES_REC_MIXER_RECOGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1495. MIX_ENT(ES_REC_MIXER_RECLINE1, 0x00, 0, 0, 0x00, 0, 0),
  1496. MIX_ENT(ES_REC_MIXER_RECLINE2, 0x6c, 7, 4, 0x6c, 3, 4),
  1497. MIX_ENT(ES_REC_MIXER_RECLINE3, 0x00, 0, 0, 0x00, 0, 0)
  1498. };
  1500. /*
  1501.  * This one is for ES1887. It's little different from es_rec_mix: it
  1502.  * has 0x7c for PCM playback level. This is because ES1887 uses
  1503.  * Audio 2 for playback.
  1504.  */
  1505. static mixer_tab es1887_mix = {
  1506. MIX_ENT(SOUND_MIXER_VOLUME, 0x60, 5, 6, 0x62, 5, 6),
  1507. MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
  1508. MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
  1509. MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
  1510. MIX_ENT(SOUND_MIXER_PCM, 0x7c, 7, 4, 0x7c, 3, 4),
  1511. MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
  1512. MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
  1513. MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
  1514. MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
  1515. MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
  1516. MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
  1517. MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
  1518. MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1519. MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1520. MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
  1521. MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
  1522. MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0),
  1523. MIX_ENT(ES_REC_MIXER_RECSYNTH, 0x6b, 7, 4, 0x6b, 3, 4),
  1524. MIX_ENT(ES_REC_MIXER_RECPCM, 0x00, 0, 0, 0x00, 0, 0),
  1525. MIX_ENT(ES_REC_MIXER_RECSPEAKER, 0x00, 0, 0, 0x00, 0, 0),
  1526. MIX_ENT(ES_REC_MIXER_RECLINE, 0x6e, 7, 4, 0x6e, 3, 4),
  1527. MIX_ENT(ES_REC_MIXER_RECMIC, 0x68, 7, 4, 0x68, 3, 4),
  1528. MIX_ENT(ES_REC_MIXER_RECCD, 0x6a, 7, 4, 0x6a, 3, 4),
  1529. MIX_ENT(ES_REC_MIXER_RECIMIX, 0x00, 0, 0, 0x00, 0, 0),
  1530. MIX_ENT(ES_REC_MIXER_RECALTPCM, 0x00, 0, 0, 0x00, 0, 0),
  1531. MIX_ENT(ES_REC_MIXER_RECRECLEV, 0x00, 0, 0, 0x00, 0, 0),
  1532. MIX_ENT(ES_REC_MIXER_RECIGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1533. MIX_ENT(ES_REC_MIXER_RECOGAIN, 0x00, 0, 0, 0x00, 0, 0),
  1534. MIX_ENT(ES_REC_MIXER_RECLINE1, 0x00, 0, 0, 0x00, 0, 0),
  1535. MIX_ENT(ES_REC_MIXER_RECLINE2, 0x6c, 7, 4, 0x6c, 3, 4),
  1536. MIX_ENT(ES_REC_MIXER_RECLINE3, 0x00, 0, 0, 0x00, 0, 0)
  1537. };
  1539. static int ess_has_rec_mixer (int submodel)
  1540. {
  1541. switch (submodel) {
  1542. case SUBMDL_ES1887:
  1543. return 1;
  1544. default:
  1545. return 0;
  1546. };
  1547. };
  1549. #ifdef FKS_LOGGING
  1550. static int ess_mixer_mon_regs[]
  1551. = { 0x70, 0x71, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7d, 0x7f
  1552.   , 0xa1, 0xa2, 0xa4, 0xa5, 0xa8, 0xa9
  1553.   , 0xb1, 0xb2, 0xb4, 0xb5, 0xb6, 0xb7, 0xb9
  1554.   , 0x00};
  1556. static void ess_show_mixerregs (sb_devc *devc)
  1557. {
  1558. int *mp = ess_mixer_mon_regs;
  1560. return;
  1562. while (*mp != 0) {
  1563. printk (KERN_INFO "res (%x)=%xn", *mp, (int)(ess_getmixer (devc, *mp)));
  1564. mp++;
  1565. }
  1566. }
  1567. #endif
  1569. void ess_setmixer (sb_devc * devc, unsigned int port, unsigned int value)
  1570. {
  1571. unsigned long flags;
  1573. #ifdef FKS_LOGGING
  1574. printk(KERN_INFO "FKS: write mixer %x: %xn", port, value);
  1575. #endif
  1577. spin_lock_irqsave(&devc->lock, flags);
  1578. if (port >= 0xa0) {
  1579. ess_write (devc, port, value);
  1580. } else {
  1581. outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
  1583. udelay(20);
  1584. outb(((unsigned char) (value & 0xff)), MIXER_DATA);
  1585. udelay(20);
  1586. };
  1587. spin_unlock_irqrestore(&devc->lock, flags);
  1588. }
  1590. unsigned int ess_getmixer (sb_devc * devc, unsigned int port)
  1591. {
  1592. unsigned int val;
  1593. unsigned long flags;
  1595. spin_lock_irqsave(&devc->lock, flags);
  1597. if (port >= 0xa0) {
  1598. val = ess_read (devc, port);
  1599. } else {
  1600. outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
  1602. udelay(20);
  1603. val = inb(MIXER_DATA);
  1604. udelay(20);
  1605. }
  1606. spin_unlock_irqrestore(&devc->lock, flags);
  1608. return val;
  1609. }
  1611. static void ess_chgmixer
  1612. (sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val)
  1613. {
  1614. int value;
  1616. value = ess_getmixer (devc, reg);
  1617. value = (value & ~mask) | (val & mask);
  1618. ess_setmixer (devc, reg, value);
  1619. }
  1621. /*
  1622.  * ess_mixer_init must be called from sb_mixer_init
  1623.  */
  1624. void ess_mixer_init (sb_devc * devc)
  1625. {
  1626. devc->mixer_caps = SOUND_CAP_EXCL_INPUT;
  1628. /*
  1629. * Take care of ES1887 specifics...
  1630. */
  1631. switch (devc->submodel) {
  1632. case SUBMDL_ES1887:
  1633. devc->supported_devices = ES1887_MIXER_DEVICES;
  1634. devc->supported_rec_devices = ES1887_RECORDING_DEVICES;
  1635. #ifdef FKS_LOGGING
  1636. printk (KERN_INFO "FKS: ess_mixer_init dup = %dn", devc->duplex);
  1637. #endif
  1638. if (devc->duplex) {
  1639. devc->iomap = &es1887_mix;
  1640. } else {
  1641. devc->iomap = &es_rec_mix;
  1642. }
  1643. break;
  1644. default:
  1645. if (devc->submodel < 8) {
  1646. devc->supported_devices = ES688_MIXER_DEVICES;
  1647. devc->supported_rec_devices = ES688_RECORDING_DEVICES;
  1648. devc->iomap = &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. } else {
  1659. devc->iomap = &es1688later_mix;
  1660. }
  1661. }
  1662. }
  1663. }
  1665. /*
  1666.  * Changing playback levels at an ESS chip with record mixer means having to
  1667.  * take care of recording levels of recorded inputs (devc->recmask) too!
  1668.  */
  1669. int ess_mixer_set(sb_devc *devc, int dev, int left, int right)
  1670. {
  1671. if (ess_has_rec_mixer (devc->submodel) && (devc->recmask & (1 << dev))) {
  1672. sb_common_mixer_set (devc, dev + ES_REC_MIXER_RECDIFF, left, right);
  1673. }
  1674. return sb_common_mixer_set (devc, dev, left, right);
  1675. }
  1677. /*
  1678.  * After a sb_dsp_reset extended register 0xb4 (RECLEV) is reset too. After
  1679.  * sb_dsp_reset RECLEV has to be restored. This is where ess_mixer_reload
  1680.  * helps.
  1681.  */
  1682. void ess_mixer_reload (sb_devc *devc, int dev)
  1683. {
  1684. int left, right, value;
  1686. value = devc->levels[dev];
  1687. left  = value & 0x000000ff;
  1688. right = (value & 0x0000ff00) >> 8;
  1690. sb_common_mixer_set(devc, dev, left, right);
  1691. }
  1693. int es_rec_set_recmask(sb_devc * devc, int mask)
  1694. {
  1695. int i, i_mask, cur_mask, diff_mask;
  1696. int value, left, right;
  1698. #ifdef FKS_LOGGING
  1699. printk (KERN_INFO "FKS: es_rec_set_recmask mask = %xn", mask);
  1700. #endif
  1701. /*
  1702.  * Changing the recmask on an ESS chip with recording mixer means:
  1703.  * (1) Find the differences
  1704.  * (2) For "turned-on"  inputs: make the recording level the playback level
  1705.  * (3) For "turned-off" inputs: make the recording level zero
  1706.  */
  1707. cur_mask  = devc->recmask;
  1708. diff_mask = (cur_mask ^ mask);
  1710. for (i = 0; i < 32; i++) {
  1711. i_mask = (1 << i);
  1712. if (diff_mask & i_mask) { /* Difference? (1)  */
  1713. if (mask & i_mask) { /* Turn it on  (2)  */
  1714. value = devc->levels[i];
  1715. left  = value & 0x000000ff;
  1716. right = (value & 0x0000ff00) >> 8;
  1717. } else { /* Turn it off (3)  */
  1718. left  = 0;
  1719. left  = 0;
  1720. right = 0;
  1721. }
  1722. sb_common_mixer_set(devc, i + ES_REC_MIXER_RECDIFF, left, right);
  1723. }
  1724. }
  1725. return mask;
  1726. }
  1728. int ess_set_recmask(sb_devc * devc, int *mask)
  1729. {
  1730. /* This applies to ESS chips with record mixers only! */
  1732. if (ess_has_rec_mixer (devc->submodel)) {
  1733. *mask = es_rec_set_recmask (devc, *mask);
  1734. return 1; /* Applied */
  1735. } else {
  1736. return 0; /* Not applied */
  1737. }
  1738. }
  1740. /*
  1741.  * ess_mixer_reset must be called from sb_mixer_reset
  1742.  */
  1743. int ess_mixer_reset (sb_devc * devc)
  1744. {
  1745. /*
  1746.  * Separate actions for ESS chips with a record mixer:
  1747.  */
  1748. if (ess_has_rec_mixer (devc->submodel)) {
  1749. switch (devc->submodel) {
  1750. case SUBMDL_ES1887:
  1751. /*
  1752.  * Separate actions for ES1887:
  1753.  * Change registers 7a and 1c to make the record mixer the
  1754.  * actual recording source.
  1755.  */
  1756. ess_chgmixer(devc, 0x7a, 0x18, 0x08);
  1757. ess_chgmixer(devc, 0x1c, 0x07, 0x07);
  1758. break;
  1759. };
  1760. /*
  1761.  * Call set_recmask for proper initialization
  1762.  */
  1763. devc->recmask = devc->supported_rec_devices;
  1764. es_rec_set_recmask(devc, 0);
  1765. devc->recmask = 0;
  1767. return 1; /* We took care of recmask. */
  1768. } else {
  1769. return 0; /* We didn't take care; caller do it */
  1770. }
  1771. }
  1773. /****************************************************************************
  1774.  * *
  1775.  * ESS midi *
  1776.  * *
  1777.  ****************************************************************************/
  1779. /*
  1780.  * FKS: IRQ may be shared. Hm. And if so? Then What?
  1781.  */
  1782. int ess_midi_init(sb_devc * devc, struct address_info *hw_config)
  1783. {
  1784. unsigned char   cfg, tmp;
  1786. cfg = ess_getmixer (devc, 0x40) & 0x03;
  1788. if (devc->submodel < 8) {
  1789. ess_setmixer (devc, 0x40, cfg | 0x03); /* Enable OPL3 & joystick */
  1790. return 0;    /* ES688 doesn't support MPU401 mode */
  1791. }
  1792. tmp = (hw_config->io_base & 0x0f0) >> 4;
  1794. if (tmp > 3) {
  1795. ess_setmixer (devc, 0x40, cfg);
  1796. return 0;
  1797. }
  1798. cfg |= tmp << 3;
  1800. tmp = 1; /* MPU enabled without interrupts */
  1802. /* May be shared: if so the value is -ve */
  1804. switch (abs(hw_config->irq)) {
  1805. case 9:
  1806. tmp = 0x4;
  1807. break;
  1808. case 5:
  1809. tmp = 0x5;
  1810. break;
  1811. case 7:
  1812. tmp = 0x6;
  1813. break;
  1814. case 10:
  1815. tmp = 0x7;
  1816. break;
  1817. default:
  1818. return 0;
  1819. }
  1821. cfg |= tmp << 5;
  1822. ess_setmixer (devc, 0x40, cfg | 0x03);
  1824. return 1;
  1825. }