omap-audio-tsc2101.c

Linux Kernel 2.6.9 for OMAP1710

	tsc2101_local.volume = DEFAULT_VOLUME;
	tsc2101_update(SET_VOLUME, DEFAULT_VOLUME);

	FN_OUT(0);

}
#endif

/******************************************************************************************
 *
 * All generic ioctl's are handled by audio_ioctl() [File: omap-audio.c]. This
 * routine handles some platform specific ioctl's
 *
 ******************************************************************************************/
static int
omap_tsc2101_ioctl(struct inode *inode, struct file *file, uint cmd, ulong arg)
{
	long val;
	int ret = 0;

	DPRINTK(" 0x%08x\n", cmd);

	/*
	 * These are platform dependent ioctls which are not handled by the
	 * generic omap-audio module.
	 */
	switch (cmd) {
	case SNDCTL_DSP_STEREO:
		ret = get_user(val, (int *)arg);
		if (ret)
			return ret;
		/* the AIC23 is stereo only */
		ret = (val == 0) ? -EINVAL : 1;
		FN_OUT(1);
		return put_user(ret, (int *)arg);

	case SNDCTL_DSP_CHANNELS:
	case SOUND_PCM_READ_CHANNELS:
		/* the AIC23 is stereo only */
		FN_OUT(2);
		return put_user(2, (long *)arg);

	case SNDCTL_DSP_SPEED:
		ret = get_user(val, (long *)arg);
		if (ret)
			break;
		ret = omap_set_samplerate(val);
		if (ret)
			break;
		/* fall through */

	case SOUND_PCM_READ_RATE:
		FN_OUT(3);
		return put_user(audio_samplerate, (long *)arg);

	case SOUND_PCM_READ_BITS:
	case SNDCTL_DSP_SETFMT:
	case SNDCTL_DSP_GETFMTS:
		/* we can do 16-bit only */
		FN_OUT(4);
		return put_user(AFMT_S16_LE, (long *)arg);

	default:
		/* Maybe this is meant for the mixer (As per OSS Docs) */
		FN_OUT(5);
		return mixer_ioctl(inode, file, cmd, arg);
	}

	FN_OUT(0);
	return ret;
}

/*********************************************************************************
 *
 * module_probe for TSC2101
 *
 ********************************************************************************/
static int omap_tsc2101_probe(void)
{
	FN_IN;

	/* Get the fops from audio oss driver */
	if (!(omap_audio_fops = audio_get_fops())) {
		printk(KERN_ERR "Unable to Get the FOPs of Audio OSS driver\n");
		audio_unregister_codec(&tsc2101_state);
		return -EPERM;
	}

	tsc2101_local.volume = DEFAULT_VOLUME;

	/* register devices */
	audio_dev_id = register_sound_dsp(omap_audio_fops, -1);
	mixer_dev_id = register_sound_mixer(&omap_mixer_fops, -1);

#ifdef PROC_SUPPORT
	create_proc_read_entry(PROC_START_FILE, 0 /* default mode */ ,
			       NULL /* parent dir */ ,
			       codec_start, NULL /* client data */ );

	create_proc_read_entry(PROC_STOP_FILE, 0 /* default mode */ ,
			       NULL /* parent dir */ ,
			       codec_stop, NULL /* client data */ );
#endif

	/* Announcement Time */
	printk(KERN_INFO PLATFORM_NAME " " CODEC_NAME
	       " Audio support initialized\n");

	FN_OUT(0);
	return 0;
}

/*********************************************************************************
 *
 * Module Remove for TSC2101
 *
 ********************************************************************************/
static void omap_tsc2101_remove(void)
{
	FN_IN;
	/* Un-Register the codec with the audio driver */
	unregister_sound_dsp(audio_dev_id);
	unregister_sound_mixer(mixer_dev_id);

#ifdef PROC_SUPPORT
	remove_proc_entry(PROC_START_FILE, NULL);
	remove_proc_entry(PROC_STOP_FILE, NULL);
#endif
	FN_OUT(0);

}

/*********************************************************************************
 *
 * Module Suspend for TSC2101
 *
 ********************************************************************************/
static int omap_tsc2101_suspend(void)
{

	FN_OUT(0);
	return 0;
}

/*********************************************************************************
 *
 * Module Resume for TSC2101
 *
 ********************************************************************************/
static int omap_tsc2101_resume(void)
{

	FN_OUT(0);
	return 0;
}

/*********************************************************************************
 *
 * module_init for TSC2101
 *
 ********************************************************************************/
static int __init audio_tsc2101_init(void)
{

	int err = 0;
	FN_IN;
	/* register the codec with the audio driver */
	if ((err = audio_register_codec(&tsc2101_state))) {
		printk(KERN_ERR
		       "Failed to register TSC driver with Audio OSS Driver\n");
	}
	FN_OUT(err);
	return err;
}

/*********************************************************************************
 *
 * module_exit for TSC2101
 *
 ********************************************************************************/
static void __exit audio_tsc2101_exit(void)
{

	FN_IN;
	(void)audio_unregister_codec(&tsc2101_state);
	FN_OUT(0);
	return;
}

/**************************** DEBUG FUNCTIONS ***********************************/

/*********************************************************************************
 * TEST_KEYCLICK:
 * This is a test to generate various keyclick sound on tsc.
 * verifies if the tsc and the spi interfaces are operational.
 *
 ********************************************************************************/
#ifdef TEST_KEYCLICK
void tsc2101_testkeyclick(void)
{
	u8 freq = 0;
	u16 old_reg_val, reg_val;
	u32 uDummyVal = 0;
	u32 uTryVal = 0;

	old_reg_val = audio_tsc2101_read(TSC2101_AUDIO_CTRL_2);

	/* Keyclick active, max amplitude and longest key click len(32 period) */
	printk(KERN_INFO " TESTING KEYCLICK\n Listen carefully NOW....\n");
	printk(KERN_INFO " OLD REG VAL=0x%x\n", old_reg_val);
	/* try all frequencies */
	for (; freq < 8; freq++) {
		/* Keyclick active, max amplitude and longest key click len(32 period) */
		reg_val = old_reg_val | AC2_KCLAC(0x7) | AC2_KCLLN(0xF);
		uDummyVal = 0;
		uTryVal = 0;
		printk(KERN_INFO "\n\nTrying frequency %d reg val= 0x%x\n",
		       freq, reg_val | AC2_KCLFRQ(freq) | AC2_KCLEN);
		audio_tsc2101_write(TSC2101_AUDIO_CTRL_2,
				    reg_val | AC2_KCLFRQ(freq) | AC2_KCLEN);
		printk("DONE. Wait 10 ms ...\n");
		/* wait till the kclk bit is auto cleared! time out also to be considered. */
		while (audio_tsc2101_read(TSC2101_AUDIO_CTRL_2) & AC2_KCLEN) {
			udelay(3);
			uTryVal++;
			if (uTryVal > 2000) {
				printk(KERN_ERR
				       "KEYCLICK TIMED OUT! freq val=%d, POSSIBLE ERROR!\n",
				       freq);
				printk(KERN_INFO
				       "uTryVal == %d: Read back new reg val= 0x%x\n",
				       uTryVal,
				       audio_tsc2101_read
				       (TSC2101_AUDIO_CTRL_2));
				/* clear */
				audio_tsc2101_write(TSC2101_AUDIO_CTRL_2, 0x00);
				break;
			}
		}
	}
	/* put the old value back */
	audio_tsc2101_write(TSC2101_AUDIO_CTRL_2, old_reg_val);
	printk(KERN_INFO " KEYCLICK TEST COMPLETE\n");

}				/* End of tsc2101_testkeyclick */

#endif				/* TEST_KEYCLICK */

/*********************************************************************************
 * TONEGEN:
 * This is a test to generate a rather unpleasant sound..
 * verifies if the mcbsp is active (requires MCBSP_DIRECT_RW to be active on McBSP)
 *
 ********************************************************************************/
#ifdef TONE_GEN
/* Generates a shrill tone */
u16 tone[] = {
	0x0ce4, 0x0ce4, 0x1985, 0x1985, 0x25A1, 0x25A1, 0x30FD, 0x30FE,
	0x3B56, 0x3B55, 0x447A, 0x447A, 0x4C3B, 0x4C3C, 0x526D, 0x526C,
	0x56F1, 0x56F1, 0x59B1, 0x59B1, 0x5A9E, 0x5A9D, 0x59B1, 0x59B2,
	0x56F3, 0x56F2, 0x526D, 0x526D, 0x4C3B, 0x4C3B, 0x447C, 0x447C,
	0x3B5A, 0x3B59, 0x30FE, 0x30FE, 0x25A5, 0x25A6, 0x1989, 0x198A,
	0x0CE5, 0x0CE3, 0x0000, 0x0000, 0xF31C, 0xF31C, 0xE677, 0xE676,
	0xDA5B, 0xDA5B, 0xCF03, 0xCF03, 0xC4AA, 0xC4AA, 0xBB83, 0xBB83,
	0xB3C5, 0xB3C5, 0xAD94, 0xAD94, 0xA90D, 0xA90E, 0xA64F, 0xA64E,
	0xA562, 0xA563, 0xA64F, 0xA64F, 0xA910, 0xA90F, 0xAD93, 0xAD94,
	0xB3C4, 0xB3C4, 0xBB87, 0xBB86, 0xC4AB, 0xC4AB, 0xCF03, 0xCF03,
	0xDA5B, 0xDA5A, 0xE67B, 0xE67B, 0xF31B, 0xF3AC, 0x0000, 0x0000,
	0x0CE4, 0x0CE4, 0x1985, 0x1985, 0x25A1, 0x25A1, 0x30FD, 0x30FE,
	0x3B56, 0x3B55, 0x447A, 0x447A, 0x4C3B, 0x4C3C, 0x526D, 0x526C,
	0x56F1, 0x56F1, 0x59B1, 0x59B1, 0x5A9E, 0x5A9D, 0x59B1, 0x59B2,
	0x56F3, 0x56F2, 0x526D, 0x526D, 0x4C3B, 0x4C3B, 0x447C, 0x447C,
	0x3B5A, 0x3B59, 0x30FE, 0x30FE, 0x25A5, 0x25A6, 0x1989, 0x198A,
	0x0CE5, 0x0CE3, 0x0000, 0x0000, 0xF31C, 0xF31C, 0xE677, 0xE676,
	0xDA5B, 0xDA5B, 0xCF03, 0xCF03, 0xC4AA, 0xC4AA, 0xBB83, 0xBB83,
	0xB3C5, 0xB3C5, 0xAD94, 0xAD94, 0xA90D, 0xA90E, 0xA64F, 0xA64E,
	0xA562, 0xA563, 0xA64F, 0xA64F, 0xA910, 0xA90F, 0xAD93, 0xAD94,
	0xB3C4, 0xB3C4, 0xBB87, 0xBB86, 0xC4AB, 0xC4AB, 0xCF03, 0xCF03,
	0xDA5B, 0xDA5A, 0xE67B, 0xE67B, 0xF31B, 0xF3AC, 0x0000, 0x0000,
	0x0CE4, 0x0CE4, 0x1985, 0x1985, 0x25A1, 0x25A1, 0x30FD, 0x30FE,
	0x3B56, 0x3B55, 0x447A, 0x447A, 0x4C3B, 0x4C3C, 0x526D, 0x526C,
	0x56F1, 0x56F1, 0x59B1, 0x59B1, 0x5A9E, 0x5A9D, 0x59B1, 0x59B2,
	0x56F3, 0x56F2, 0x526D, 0x526D, 0x4C3B, 0x4C3B, 0x447C, 0x447C,
	0x3B5A, 0x3B59, 0x30FE, 0x30FE, 0x25A5, 0x25A6, 0x1989, 0x198A,
	0x0CE5, 0x0CE3, 0x0000, 0x0000, 0xF31C, 0xF31C, 0xE677, 0xE676,
	0xDA5B, 0xDA5B, 0xCF03, 0xCF03, 0xC4AA, 0xC4AA, 0xBB83, 0xBB83,
	0xB3C5, 0xB3C5, 0xAD94, 0xAD94, 0xA90D, 0xA90E, 0xA64F, 0xA64E,
	0xA562, 0xA563, 0xA64F, 0xA64F, 0xA910, 0xA90F, 0xAD93, 0xAD94,
	0xB3C4, 0xB3C4, 0xBB87, 0xBB86, 0xC4AB, 0xC4AB, 0xCF03, 0xCF03,
	0xDA5B, 0xDA5A, 0xE67B, 0xE67B, 0xF31B, 0xF3AC, 0x0000, 0x0000
};

void toneGen(void)
{
	int count = 0;
	int ret = 0;
	printk(KERN_INFO "TONE GEN TEST :");

	for (count = 0; count < 5000; count++) {
		int bytes;
		for (bytes = 0; bytes < sizeof(tone) / 2; bytes++) {
			ret = omap_mcbsp_write(AUDIO_MCBSP, tone[bytes]);
			if (ret == -1) {
				/* retry */
				bytes--;
			} else if (ret == -2) {
				printk(KERN_INFO "ERROR:bytes=%d\n", bytes);
				return;
			}
		}
	}
	printk(KERN_INFO "SUCCESS\n");
}

#endif				/* End of TONE_GEN */

/*********************************************************************************
 *
 * TSC_DUMP_REGISTERS:
 * This will dump the entire register set of Page 2 tsc2101. 
 * Useful for major goof ups
 *
 ********************************************************************************/
#ifdef TSC_DUMP_REGISTERS
static void tsc2101_dumpRegisters(void)
{
	int i = 0;
	u16 data = 0;
	printk("TSC 2101 Register dump for Page 2 \n");
	for (i = 0; i < 0x27; i++) {
		data = audio_tsc2101_read(i);
		printk(KERN_INFO "Register[%x]=0x%04x\n", i, data);

	}
}
#endif				/* End of #ifdef TSC_DUMP_REGISTERS */

#ifdef PROC_SUPPORT
static int codec_start(char *buf, char **start, off_t offset, int count,
		       int *eof, void *data)
{
	omap_tsc2101_enable();
	tsc2101_start();
	printk("Codec initialization done.\n");
	return 0;
}
static int codec_stop(char *buf, char **start, off_t offset, int count,
		      int *eof, void *data)
{

	omap_tsc2101_disable();
	audio_tsc2101_write(TSC2101_CODEC_POWER_CTRL,
			    ~(CPC_SP1PWDN | CPC_SP2PWDN | CPC_BASSBC));
	printk("Codec shutdown.\n");
	return 0;
}
#endif

/*********************************************************************************
 *
 * Other misc management, registration etc
 *
 ********************************************************************************/
module_init(audio_tsc2101_init);
module_exit(audio_tsc2101_exit);

MODULE_AUTHOR("Texas Instruments");
MODULE_DESCRIPTION
    ("Glue audio driver for the TI OMAP1610/OMAP1710/2420 TSC2101 codec.");
MODULE_LICENSE("GPL");