/* * Audio Command Interface (ACI) driver (sound/aci.c) * * ACI is a protocol used to communicate with the microcontroller on * some sound cards produced by miro, e.g. the miroSOUND PCM12 and * PCM20. The ACI has been developed for miro by Norberto Pellicci * <pellicci@home.com>. Special thanks to both him and miro for * providing the ACI specification. * * The main function of the ACI is to control the mixer and to get a * product identification. On the PCM20, ACI also controls the radio * tuner on this card, this is supported in the Video for Linux * miropcm20 driver. * - * This is a fullfeatured implementation. Unsupported features * are bugs... (: * * It is not longer necessary to load the mad16 module first. The * user is currently responsible to set the mad16 mixer correctly. * * To toggle the solo mode for full duplex operation just use the OSS * record switch for the pcm ('wave') controller. Robert * - * * Revision history: * * 1995-11-10 Markus Kuhn <mskuhn@cip.informatik.uni-erlangen.de> * First version written. * 1995-12-31 Markus Kuhn * Second revision, general code cleanup. * 1996-05-16 Hannu Savolainen * Integrated with other parts of the driver. * 1996-05-28 Markus Kuhn * Initialize CS4231A mixer, make ACI first mixer, * use new private mixer API for solo mode. * 1998-08-18 Ruurd Reitsma <R.A.Reitsma@wbmt.tudelft.nl> * Small modification to export ACI functions and * complete modularisation. * 2000-06-20 Robert Siemer <Robert.Siemer@gmx.de> * Don't initialize the CS4231A mixer anymore, so the code is * working again, and other small changes to fit in todays * kernels. * 2000-08-26 Robert Siemer * Clean up and rewrite for 2.4.x. Maybe it's SMP safe now... (: * ioctl bugfix, and integration of solo-mode into OSS-API, * added (OSS-limited) equalizer support, return value bugfix, * changed param aci_reset to reset, new params: ide, wss. * 2001-04-20 Robert Siemer * even more cleanups... * 2001-10-08 Arnaldo Carvalho de Melo <acme@conectiva.com.br> * Get rid of check_region, .bss optimizations, use set_current_state */ #include <linux/kernel.h> #include <linux/init.h> #include <linux/module.h> #include <linux/proc_fs.h> #include <linux/slab.h> #include <asm/semaphore.h> #include <asm/io.h> #include <asm/uaccess.h> #include "sound_config.h" int aci_port; /* as determined by bit 4 in the OPTi 929 MC4 register */ static int aci_idcode[2]; /* manufacturer and product ID */ int aci_version; /* ACI firmware version */ EXPORT_SYMBOL(aci_port); EXPORT_SYMBOL(aci_version); #include "aci.h" static int aci_solo; /* status bit of the card that can't be * * checked with ACI versions prior to 0xb0 */ static int aci_amp; /* status bit for power-amp/line-out level but I have no docs about what is what... */ static int aci_micpreamp=3; /* microphone preamp-level that can't be * * checked with ACI versions prior to 0xb0 */ static int mixer_device; static struct semaphore aci_sem; #ifdef MODULE static int reset; module_param(reset, bool, 0); MODULE_PARM_DESC(reset,"When set to 1, reset aci mixer."); #else static int reset = 1; #endif static int ide=-1; module_param(ide, int, 0); MODULE_PARM_DESC(ide,"1 enable, 0 disable ide-port - untested" " default: do nothing"); static int wss=-1; module_param(wss, int, 0); MODULE_PARM_DESC(wss,"change between ACI/WSS-mixer; use 0 and 1 - untested" " default: do nothing; for PCM1-pro only"); #ifdef DEBUG static void print_bits(unsigned char c) { int j; printk(KERN_DEBUG "aci: "); for (j=7; j>=0; j--) { printk("%d", (c >> j) & 0x1); } printk("\n"); } #endif /* * This busy wait code normally requires less than 15 loops and * practically always less than 100 loops on my i486/DX2 66 MHz. * * Warning: Waiting on the general status flag after reseting the MUTE * function can take a VERY long time, because the PCM12 does some kind * of fade-in effect. For this reason, access to the MUTE function has * not been implemented at all. * * - The OSS interface has no mute option. It takes about 3 seconds to * fade-in on my PCM20. busy_wait() handles it great now... Robert */ static int busy_wait(void) { #define MINTIME 500 long timeout; unsigned char byte; for (timeout = 1; timeout <= MINTIME+30; timeout++) { if (((byte=inb(BUSY_REGISTER)) & 1) == 0) { if (timeout >= MINTIME) printk(KERN_DEBUG "aci: Got READYFLAG in round %ld.\n", timeout-MINTIME); return byte; } if (timeout >= MINTIME) { long out=10*HZ; switch (timeout-MINTIME) { case 0 ... 9: out /= 10; case 10 ... 19: out /= 10; case 20 ... 30: out /= 10; default: set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout(out); break; } } } printk(KERN_WARNING "aci: busy_wait() time out.\n"); return -EBUSY; } /* The four ACI command types are fucked up. [-: * implied is: 1w - special case for INIT * write is: 2w1r * read is: x(1w1r) where x is 1 or 2 (1 CHECK_SIG, 1 CHECK_STER, * 1 VERSION, 2 IDCODE) * the command is only in the first write, rest is protocol overhead * * indexed is technically a write and used for STATUS * and the special case for TUNE is: 3w1r * * Here the new general sheme: TUNE --> aci_rw_cmd(x, y, z) * indexed and write --> aci_rw_cmd(x, y, -1) * implied and read (x=1) --> aci_rw_cmd(x, -1, -1) * * Read (x>=2) is not implemented (only used during initialization). * Use aci_idcode[2] and aci_version... Robert */ /* Some notes for error detection: theoretically it is possible. * But it doubles the I/O-traffic from ww(r) to wwwrw(r) in the normal * case and doesn't seem to be designed for that... Robert */ static inline int aci_rawwrite(unsigned char byte) { if (busy_wait() >= 0) { #ifdef DEBUG printk(KERN_DEBUG "aci_rawwrite(%d)\n", byte); #endif outb(byte, COMMAND_REGISTER); return 0; } else return -EBUSY; } static inline int aci_rawread(void) { unsigned char byte; if (busy_wait() >= 0) { byte=inb(STATUS_REGISTER); #ifdef DEBUG printk(KERN_DEBUG "%d = aci_rawread()\n", byte); #endif return byte; } else return -EBUSY; } int aci_rw_cmd(int write1, int write2, int write3) { int write[] = {write1, write2, write3}; int read = -EINTR, i; if (down_interruptible(&aci_sem)) goto out; for (i=0; i<3; i++) { if (write[i]< 0 || write[i] > 255) break; else { read = aci_rawwrite(write[i]); if (read < 0) goto out_up; } } read = aci_rawread(); out_up: up(&aci_sem); out: return read; } EXPORT_SYMBOL(aci_rw_cmd); static int setvolume(int __user *arg, unsigned char left_index, unsigned char right_index) { int vol, ret, uservol, buf; __get_user(uservol, arg); /* left channel */ vol = uservol & 0xff; if (vol > 100) vol = 100; vol = SCALE(100, 0x20, vol); if ((buf=aci_write_cmd(left_index, 0x20 - vol))<0) return buf; ret = SCALE(0x20, 100, vol); /* right channel */ vol = (uservol >> 8) & 0xff; if (vol > 100) vol = 100; vol = SCALE(100, 0x20, vol); if ((buf=aci_write_cmd(right_index, 0x20 - vol))<0) return buf; ret |= SCALE(0x20, 100, vol) << 8; __put_user(ret, arg); return 0; } static int getvolume(int __user *arg, unsigned char left_index, unsigned char right_index) { int vol; int buf; /* left channel */ if ((buf=aci_indexed_cmd(ACI_STATUS, left_index))<0) return buf; vol = SCALE(0x20, 100, buf < 0x20 ? 0x20-buf : 0); /* right channel */ if ((buf=aci_indexed_cmd(ACI_STATUS, right_index))<0) return buf; vol |= SCALE(0x20, 100, buf < 0x20 ? 0x20-buf : 0) << 8; __put_user(vol, arg); return 0; } /* The equalizer is somewhat strange on the ACI. From -12dB to +12dB * write: 0xff..down.to..0x80==0x00..up.to..0x7f */ static inline unsigned int eq_oss2aci(unsigned int vol) { int boost=0; unsigned int ret; if (vol > 100) vol = 100; if (vol > 50) { vol -= 51; boost=1; } if (boost) ret=SCALE(49, 0x7e, vol)+1; else ret=0xff - SCALE(50, 0x7f, vol); return ret; } static inline unsigned int eq_aci2oss(unsigned int vol) { if (vol < 0x80) return SCALE(0x7f, 50, vol) + 50; else return SCALE(0x7f, 50, 0xff-vol); } static int setequalizer(int __user *arg, unsigned char left_index, unsigned char right_index) { int buf; unsigned int vol; __get_user(vol, arg); /* left channel */ if ((buf=aci_write_cmd(left_index, eq_oss2aci(vol & 0xff)))<0) return buf; /* right channel */ if ((buf=aci_write_cmd(right_index, eq_oss2aci((vol>>8) & 0xff)))<0) return buf; /* the ACI equalizer is more precise */ return 0; } static int getequalizer(int __user *arg, unsigned char left_index, unsigned char right_index) { int buf; unsigned int vol; /* left channel */ if ((buf=aci_indexed_cmd(ACI_STATUS, left_index))<0) return buf; vol = eq_aci2oss(buf); /* right channel */ if ((buf=aci_indexed_cmd(ACI_STATUS, right_index))<0) return buf; vol |= eq_aci2oss(buf) << 8; __put_user(vol, arg); return 0; } static int aci_mixer_ioctl (int dev, unsigned int cmd, void __user * arg) { int vol, buf; int __user *p = arg; switch (cmd) { case SOUND_MIXER_WRITE_VOLUME: return setvolume(p, 0x01, 0x00); case SOUND_MIXER_WRITE_CD: return setvolume(p, 0x3c, 0x34); case SOUND_MIXER_WRITE_MIC: return setvolume(p, 0x38, 0x30); case SOUND_MIXER_WRITE_LINE: return setvolume(p, 0x39, 0x31); case SOUND_MIXER_WRITE_SYNTH: return setvolume(p, 0x3b, 0x33); case SOUND_MIXER_WRITE_PCM: return setvolume(p, 0x3a, 0x32); case MIXER_WRITE(SOUND_MIXER_RADIO): /* fall through */ case SOUND_MIXER_WRITE_LINE1: /* AUX1 or radio */ return setvolume(p, 0x3d, 0x35); case SOUND_MIXER_WRITE_LINE2: /* AUX2 */ return setvolume(p, 0x3e, 0x36); case SOUND_MIXER_WRITE_BASS: /* set band one and two */ if (aci_idcode[1]=='C') { if ((buf=setequalizer(p, 0x48, 0x40)) || (buf=setequalizer(p, 0x49, 0x41))); return buf; } break; case SOUND_MIXER_WRITE_TREBLE: /* set band six and seven */ if (aci_idcode[1]=='C') { if ((buf=setequalizer(p, 0x4d, 0x45)) || (buf=setequalizer(p, 0x4e, 0x46))); return buf; } break; case SOUND_MIXER_WRITE_IGAIN: /* MIC pre-amp */ if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { __get_user(vol, p); vol = vol & 0xff; if (vol > 100) vol = 100; vol = SCALE(100, 3, vol); if ((buf=aci_write_cmd(ACI_WRITE_IGAIN, vol))<0) return buf; aci_micpreamp = vol; vol = SCALE(3, 100, vol); vol |= (vol << 8); __put_user(vol, p); return 0; } break; case SOUND_MIXER_WRITE_OGAIN: /* Power-amp/line-out level */ if (aci_idcode[1]=='A' || aci_idcode[1]=='B') { __get_user(buf, p); buf = buf & 0xff; if (buf > 50) vol = 1; else vol = 0; if ((buf=aci_write_cmd(ACI_SET_POWERAMP, vol))<0) return buf; aci_amp = vol; if (aci_amp) buf = (100 || 100<<8); else buf = 0; __put_user(buf, p); return 0; } break; case SOUND_MIXER_WRITE_RECSRC: /* handle solo mode control */ __get_user(buf, p); /* unset solo when RECSRC for PCM is requested */ if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { vol = !(buf & SOUND_MASK_PCM); if ((buf=aci_write_cmd(ACI_SET_SOLOMODE, vol))<0) return buf; aci_solo = vol; } buf = (SOUND_MASK_CD| SOUND_MASK_MIC| SOUND_MASK_LINE| SOUND_MASK_SYNTH| SOUND_MASK_LINE2); if (aci_idcode[1] == 'C') /* PCM20 radio */ buf |= SOUND_MASK_RADIO; else buf |= SOUND_MASK_LINE1; if (!aci_solo) buf |= SOUND_MASK_PCM; __put_user(buf, p); return 0; case SOUND_MIXER_READ_DEVMASK: buf = (SOUND_MASK_VOLUME | SOUND_MASK_CD | SOUND_MASK_MIC | SOUND_MASK_LINE | SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE2); switch (aci_idcode[1]) { case 'C': /* PCM20 radio */ buf |= (SOUND_MASK_RADIO | SOUND_MASK_IGAIN | SOUND_MASK_BASS | SOUND_MASK_TREBLE); break; case 'B': /* PCM12 */ buf |= (SOUND_MASK_LINE1 | SOUND_MASK_IGAIN | SOUND_MASK_OGAIN); break; case 'A': /* PCM1-pro */ buf |= (SOUND_MASK_LINE1 | SOUND_MASK_OGAIN); break; default: buf |= SOUND_MASK_LINE1; } __put_user(buf, p); return 0; case SOUND_MIXER_READ_STEREODEVS: buf = (SOUND_MASK_VOLUME | SOUND_MASK_CD | SOUND_MASK_MIC | SOUND_MASK_LINE | SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE2); switch (aci_idcode[1]) { case 'C': /* PCM20 radio */ buf |= (SOUND_MASK_RADIO | SOUND_MASK_BASS | SOUND_MASK_TREBLE); break; default: buf |= SOUND_MASK_LINE1; } __put_user(buf, p); return 0; case SOUND_MIXER_READ_RECMASK: buf = (SOUND_MASK_CD| SOUND_MASK_MIC| SOUND_MASK_LINE| SOUND_MASK_SYNTH| SOUND_MASK_LINE2| SOUND_MASK_PCM); if (aci_idcode[1] == 'C') /* PCM20 radio */ buf |= SOUND_MASK_RADIO; else buf |= SOUND_MASK_LINE1; __put_user(buf, p); return 0; case SOUND_MIXER_READ_RECSRC: buf = (SOUND_MASK_CD | SOUND_MASK_MIC | SOUND_MASK_LINE | SOUND_MASK_SYNTH | SOUND_MASK_LINE2); /* do we need aci_solo or can I get it from the ACI? */ switch (aci_idcode[1]) { case 'B': /* PCM12 */ case 'C': /* PCM20 radio */ if (aci_version >= 0xb0) { if ((vol=aci_rw_cmd(ACI_STATUS, ACI_S_GENERAL, -1))<0) return vol; if (vol & 0x20) buf |= SOUND_MASK_PCM; } else if (!aci_solo) buf |= SOUND_MASK_PCM; break; default: buf |= SOUND_MASK_PCM; } if (aci_idcode[1] == 'C') /* PCM20 radio */ buf |= SOUND_MASK_RADIO; else buf |= SOUND_MASK_LINE1; __put_user(buf, p); return 0; case SOUND_MIXER_READ_CAPS: __put_user(0, p); return 0; case SOUND_MIXER_READ_VOLUME: return getvolume(p, 0x04, 0x03); case SOUND_MIXER_READ_CD: return getvolume(p, 0x0a, 0x09); case SOUND_MIXER_READ_MIC: return getvolume(p, 0x06, 0x05); case SOUND_MIXER_READ_LINE: return getvolume(p, 0x08, 0x07); case SOUND_MIXER_READ_SYNTH: return getvolume(p, 0x0c, 0x0b); case SOUND_MIXER_READ_PCM: return getvolume(p, 0x0e, 0x0d); case MIXER_READ(SOUND_MIXER_RADIO): /* fall through */ case SOUND_MIXER_READ_LINE1: /* AUX1 */ return getvolume(p, 0x11, 0x10); case SOUND_MIXER_READ_LINE2: /* AUX2 */ return getvolume(p, 0x13, 0x12); case SOUND_MIXER_READ_BASS: /* get band one */ if (aci_idcode[1]=='C') { return getequalizer(p, 0x23, 0x22); } break; case SOUND_MIXER_READ_TREBLE: /* get band seven */ if (aci_idcode[1]=='C') { return getequalizer(p, 0x2f, 0x2e); } break; case SOUND_MIXER_READ_IGAIN: /* MIC pre-amp */ if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { /* aci_micpreamp or ACI? */ if (aci_version >= 0xb0) { if ((buf=aci_indexed_cmd(ACI_STATUS, ACI_S_READ_IGAIN))<0) return buf; } else buf=aci_micpreamp; vol = SCALE(3, 100, buf <= 3 ? buf : 3); vol |= vol << 8; __put_user(vol, p); return 0; } break; case SOUND_MIXER_READ_OGAIN: if (aci_amp) buf = (100 || 100<<8); else buf = 0; __put_user(buf, p); return 0; } return -EINVAL; } static struct mixer_operations aci_mixer_operations = { .owner = THIS_MODULE, .id = "ACI", .ioctl = aci_mixer_ioctl }; /* * There is also an internal mixer in the codec (CS4231A or AD1845), * that deserves no purpose in an ACI based system which uses an * external ACI controlled stereo mixer. Make sure that this codec * mixer has the AUX1 input selected as the recording source, that the * input gain is set near maximum and that the other channels going * from the inputs to the codec output are muted. */ static int __init attach_aci(void) { char *boardname; int i, rc = -EBUSY; init_MUTEX(&aci_sem); outb(0xE3, 0xf8f); /* Write MAD16 password */ aci_port = (inb(0xf90) & 0x10) ? 0x344: 0x354; /* Get aci_port from MC4_PORT */ if (!request_region(aci_port, 3, "sound mixer (ACI)")) { printk(KERN_NOTICE "aci: I/O area 0x%03x-0x%03x already used.\n", aci_port, aci_port+2); goto out; } /* force ACI into a known state */ rc = -EFAULT; for (i=0; i<3; i++) if (aci_rw_cmd(ACI_ERROR_OP, -1, -1)<0) goto out_release_region; /* official this is one aci read call: */ rc = -EFAULT; if ((aci_idcode[0]=aci_rw_cmd(ACI_READ_IDCODE, -1, -1))<0 || (aci_idcode[1]=aci_rw_cmd(ACI_READ_IDCODE, -1, -1))<0) { printk(KERN_ERR "aci: Failed to read idcode on 0x%03x.\n", aci_port); goto out_release_region; } if ((aci_version=aci_rw_cmd(ACI_READ_VERSION, -1, -1))<0) { printk(KERN_ERR "aci: Failed to read version on 0x%03x.\n", aci_port); goto out_release_region; } if (aci_idcode[0] == 'm') { /* It looks like a miro sound card. */ switch (aci_idcode[1]) { case 'A': boardname = "PCM1 pro / early PCM12"; break; case 'B': boardname = "PCM12"; break; case 'C': boardname = "PCM20 radio"; break; default: boardname = "unknown miro"; } } else { printk(KERN_WARNING "aci: Warning: unsupported card! - " "no hardware, no specs...\n"); boardname = "unknown Cardinal Technologies"; } printk(KERN_INFO "<ACI 0x%02x, id %02x/%02x \"%c/%c\", (%s)> at 0x%03x\n", aci_version, aci_idcode[0], aci_idcode[1], aci_idcode[0], aci_idcode[1], boardname, aci_port); rc = -EBUSY; if (reset) { /* first write()s after reset fail with my PCM20 */ if (aci_rw_cmd(ACI_INIT, -1, -1)<0 || aci_rw_cmd(ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP)<0 || aci_rw_cmd(ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP)<0) goto out_release_region; } /* the PCM20 is muted after reset (and reboot) */ if (aci_rw_cmd(ACI_SET_MUTE, 0x00, -1)<0) goto out_release_region; if (ide>=0) if (aci_rw_cmd(ACI_SET_IDE, !ide, -1)<0) goto out_release_region; if (wss>=0 && aci_idcode[1]=='A') if (aci_rw_cmd(ACI_SET_WSS, !!wss, -1)<0) goto out_release_region; mixer_device = sound_install_mixer(MIXER_DRIVER_VERSION, boardname, &aci_mixer_operations, sizeof(aci_mixer_operations), NULL); rc = 0; if (mixer_device < 0) { printk(KERN_ERR "aci: Failed to install mixer.\n"); rc = mixer_device; goto out_release_region; } /* else Maybe initialize the CS4231A mixer here... */ out: return rc; out_release_region: release_region(aci_port, 3); goto out; } static void __exit unload_aci(void) { sound_unload_mixerdev(mixer_device); release_region(aci_port, 3); } module_init(attach_aci); module_exit(unload_aci); MODULE_LICENSE("GPL");