aci.c

linux和2410结合开发 用他可以生成2410所需的zImage文件

	__put_user(vol, (int *)arg);

	return 0;
}

static int aci_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
{
	int vol, buf;

	switch (cmd) {
	case SOUND_MIXER_WRITE_VOLUME:
		return setvolume(arg, 0x01, 0x00);
	case SOUND_MIXER_WRITE_CD:
		return setvolume(arg, 0x3c, 0x34);
	case SOUND_MIXER_WRITE_MIC:
		return setvolume(arg, 0x38, 0x30);
	case SOUND_MIXER_WRITE_LINE:
		return setvolume(arg, 0x39, 0x31);
	case SOUND_MIXER_WRITE_SYNTH:
		return setvolume(arg, 0x3b, 0x33);
	case SOUND_MIXER_WRITE_PCM:
		return setvolume(arg, 0x3a, 0x32);
	case MIXER_WRITE(SOUND_MIXER_RADIO): /* fall through */
	case SOUND_MIXER_WRITE_LINE1:  /* AUX1 or radio */
		return setvolume(arg, 0x3d, 0x35);
	case SOUND_MIXER_WRITE_LINE2:  /* AUX2 */
		return setvolume(arg, 0x3e, 0x36);
	case SOUND_MIXER_WRITE_BASS:   /* set band one and two */
		if (aci_idcode[1]=='C') {
			if ((buf=setequalizer(arg, 0x48, 0x40)) || 
			    (buf=setequalizer(arg, 0x49, 0x41)));
			return buf;
		}
		break;
	case SOUND_MIXER_WRITE_TREBLE: /* set band six and seven */
		if (aci_idcode[1]=='C') {
			if ((buf=setequalizer(arg, 0x4d, 0x45)) || 
			    (buf=setequalizer(arg, 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, (int *)arg);
			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, (int *)arg);
			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, (int *)arg);
			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, (int *)arg);
			return 0;
		}
		break;
	case SOUND_MIXER_WRITE_RECSRC:
		/* handle solo mode control */
		__get_user(buf, (int *)arg);
		/* 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, (int *)arg);
		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, (int *)arg);
		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, (int *)arg);
		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, (int *)arg);
		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, (int *)arg);
		return 0;
	case SOUND_MIXER_READ_CAPS:
		__put_user(0, (int *)arg);
		return 0;
	case SOUND_MIXER_READ_VOLUME:
		return getvolume(arg, 0x04, 0x03);
	case SOUND_MIXER_READ_CD:
		return getvolume(arg, 0x0a, 0x09);
	case SOUND_MIXER_READ_MIC:
		return getvolume(arg, 0x06, 0x05);
	case SOUND_MIXER_READ_LINE:
		return getvolume(arg, 0x08, 0x07);
	case SOUND_MIXER_READ_SYNTH:
		return getvolume(arg, 0x0c, 0x0b);
	case SOUND_MIXER_READ_PCM:
		return getvolume(arg, 0x0e, 0x0d);
	case MIXER_READ(SOUND_MIXER_RADIO): /* fall through */
	case SOUND_MIXER_READ_LINE1:  /* AUX1 */
		return getvolume(arg, 0x11, 0x10);
	case SOUND_MIXER_READ_LINE2:  /* AUX2 */
		return getvolume(arg, 0x13, 0x12);
	case SOUND_MIXER_READ_BASS:   /* get band one */
		if (aci_idcode[1]=='C') {
			return getequalizer(arg, 0x23, 0x22);
		}
		break;
	case SOUND_MIXER_READ_TREBLE: /* get band seven */
		if (aci_idcode[1]=='C') {
			return getequalizer(arg, 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, (int *)arg);
			return 0;
		}
		break;
	case SOUND_MIXER_READ_OGAIN:
		if (aci_amp)
			buf = (100 || 100<<8);
		else
			buf = 0;
		__put_user(buf, (int *)arg);
		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");