msp3430.cpp

ati driver

}

void CMSP3430::SetBalance(int balance, MSP3430_balance_mode mode)
{
	switch (mode) {
	case C_MSP3430_BALANCE_LINEAR:
		// set balance between -100% (right) and 100% (left)
		fBalance = (((0x7f * Clamp(balance, -100, 100)) / 100) << 8) + 0x0000;
		break;
	
	case C_MSP3430_BALANCE_LOGARITHMIC:
		// set balance between -128 dB (right) and 127 dB (left)
		fBalance = (((0x7f * Clamp(balance, -128, 127)) / 127) << 8) + 0x0001;
		break;
	}
	SetOutputChannels();
}


void CMSP3430::SetEqualizer(int bass, int treble)
{
	// set bass to -12..12 dB or 14..20 dB
	if (bass <= 12)
		fBass = Clamp(0x00 + 8 * bass, -0x60, 0x60) << 8;
	else
		fBass = Clamp(0x68 + 4 * (bass - 14), 0x68, 0x7f) << 8;
	
	// set treble to -12..15 dB
	fTreble = Clamp(0x00 + 8 * treble, -0x60, 0x78) << 8;

	// enable bass/treble and disable equalizer
	fToneControl = 0x00;
	fEqualizer[0] = fEqualizer[1] = fEqualizer[2] =
	fEqualizer[3] = fEqualizer[4] = fEqualizer[5] = 0x00;
	
	SetOutputChannels();
}

void CMSP3430::SetEqualizer(int gain[5])
{
	// set five band equalizer (120 Hz, 500 Hz, 1500 Hz, 5000 Hz, 10000 Hz)
	for (int index = 0; index < 5; index++)
		fEqualizer[index] = Clamp(0x00 + 8 * gain[index], -0x60, 0x60) << 8;
	
	// disable bass/treble and enable equalizer
	fToneControl = 0xff;
	fBass = fTreble = 0x00;

	SetOutputChannels();
}

void CMSP3430::SetLoudness(int loudness, MSP3430_loudness_mode mode)
{
	// set loudness gain between 0 dB and 17 dB
	fLoudness = Clamp(0x00 + 4 * loudness, 0x00, 0x44) << 8;
	switch (mode) {
	case C_MSP3430_LOUDNESS_NORMAL:
		fLoudness |= 0x0000;
		break;
	case C_MSP3430_LOUDNESS_SUPER_BASS:
		fLoudness |= 0x0004;
		break;
	}

	SetOutputChannels();
}

void CMSP3430::SetSpatial(int strength, MSP3430_spatial_mode mode, MSP3430_spatial_highpass pass)
{
	// enlarge or reduce spatial effects -100% to +100%
	fSpatial = Clamp(0x00 + (0x7f * strength) / 100, -0x80, 0x7f) << 8;
	switch (mode) {
	case C_MSP3430_SPATIAL_MODE_A:
		fSpatial |= 0x0000;
		break;
	case C_MSP3430_SPATIAL_MODE_B:
		fSpatial |= 0x0020;
		break;
	}
	switch (pass) {
	case C_MSP3430_SPATIAL_MAX_HIGH_PASS:
		fSpatial |= 0x0000;
		break;	
	case C_MSP3430_SPATIAL_2_3_HIGH_PASS:
		fSpatial |= 0x0002;
		break;	
	case C_MSP3430_SPATIAL_1_3_HIGH_PASS:
		fSpatial |= 0x0004;
		break;	
	case C_MSP3430_SPATIAL_MIN_HIGH_PASS:
		fSpatial |= 0x0006;
		break;	
	case C_MSP3430_SPATIAL_AUTO_HIGH_PASS:
		fSpatial |= 0x0008;
		break;	
	}
	SetOutputChannels();
}

void CMSP3430::SetSubwoofer(int level, int frequency, bool mute, MSP3430_subwoofer_mode mode)
{
	// set subwoofer level between -128 dB and 12 dB
	fSubwooferLevel = (mute ? 0x80 : Clamp(0x00 + level, -128, 12)) << 8;
	
	// set subwoofer corner frequency between 50..400 Hz
	fSubwooferFrequency = Clamp(frequency / 10, 5, 40) << 8;
	switch (mode) {
	case C_MSP3430_SUBWOOFER_UNFILTERED:
		fSubwooferFrequency |= 0x0000;
		break;
	case C_MSP3430_SUBWOOFER_HIGH_PASS:
		fSubwooferFrequency |= 0x0001;
		break;
	case C_MSP3430_SUBWOOFER_MDB_MAIN:
		fSubwooferFrequency |= 0x0002;
		break;
	}
	
	// disable MDB?
	fMDBStrength = 0x0000;
	fMDBLimit = 0x0000;
	fMDBHarmonic = 0x0000;
	fMDBHighPass = 0x0a00;
	fMDBLowPass = 0x0a00;
	
	SetSubwooferAndMDBOutputChannels();
}

void CMSP3430::SetMDB(int strength, int limit, int harmonic,
					  int minfrequency, int maxfrequency, bool mute)
{
	// set MDB effect strength 0..127
	fMDBStrength = (mute ? 0x00 : Clamp(strength, 0x00, 0x7f)) << 7;
	
	// set MDB amplitude limit between -32..0 dBFS
	fMDBLimit = Clamp(limit, -32, 0) << 8;
	
	// set MDB harmonic content 0..100%
	fMDBHarmonic = Clamp((0x7f * harmonic) / 100, 0x00, 0x7f) << 8;
	
	// set MDB low pass corner frequency 50..300 Hz
	fMDBLowPass = Clamp(minFrequency / 10, 5, 30) << 8;
	
	// set MDB high pass corner frequency 20..300 Hz
	fMDBHighPass = Clamp(maxFrequency / 10, 2, 30) << 8;
	
	// disable subwoofer level adjustments
	fSubwooferLevel = 0x0000;
	fSubwooferFrequency = 0x0002;
	
	// for MDB, use dynamic clipping mode
	fVolume = (fVolume & ~0x000f) | 0x0003;

	SetSubwooferAndMDBOutputChannels();
}

void CMSP3430::SetSCART(int level1, int level2, bool mute,
						MSP3430_scart_input input,
						MSP3430_scart_output output1,
						MSP3430_scart_output output2)
{
	// set volume SCART1/2 output channel -114..12 dB
	fSCART1Volume = (mute ? 0x00 : Clamp(0x73 + (0x7f * level1) / 12, 0x00, 0x7f)) << 8;
	fSCART2Volume = (mute ? 0x00 : Clamp(0x73 + (0x7f * level2) / 12, 0x00, 0x7f)) << 8;

	fSCART1Volume |= 0x0001;	
	fSCART2Volume |= 0x0001;
	
	// SCART DSP input select
	fACB = 0x0000;
	switch (input) {
	case C_MSP3430_SCART_INPUT_SCART1:
		fACB = 0x0000;
		break;
	case C_MSP3430_SCART_INPUT_MONO:	
		fACB = 0x0100;
		break;
	case C_MSP3430_SCART_INPUT_SCART2:
		fACB = 0x0200;
		break;
	case C_MSP3430_SCART_INPUT_SCART3:	
		fACB = 0x0300;
		break;
	case C_MSP3430_SCART_INPUT_SCART4:
		fACB = 0x0020;
		break;
	case C_MSP3430_SCART_INPUT_MUTE:
		fACB = 0x0320;
		break;
	}
	
	// SCART1 output select
	switch (output1) {
	case C_MSP3430_SCART_OUTPUT_SCART3:
		fACB |= 0x0000;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART2:
		fACB |= 0x0400;
		break;
	case C_MSP3430_SCART_OUTPUT_MONO:
		fACB |= 0x0800;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART1_DA:
		fACB |= 0x0c00;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART2_DA:
		fACB |= 0x0080;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART1_INPUT:
		fACB |= 0x0480;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART4_INPUT:
		fACB |= 0x0880;
		break;
	case C_MSP3430_SCART_OUTPUT_MUTE:
		fACB |= 0x0c80;
		break;
	}

	// SCART2 output select
	switch (output2) {
	case C_MSP3430_SCART_OUTPUT_SCART3:
		fACB |= 0x0000;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART2:
		fACB |= 0x1000;
		break;
	case C_MSP3430_SCART_OUTPUT_MONO:
		fACB |= 0x2000;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART1_DA:
		fACB |= 0x3000;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART2_DA:
		fACB |= 0x0200;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART1_INPUT:
		fACB |= 0x1200;
		break;
	case C_MSP3430_SCART_OUTPUT_SCART4_INPUT:
		fACB |= 0x2200;
		break;
	case C_MSP3430_SCART_OUTPUT_MUTE:
		fACB |= 0x3200;
		break;
	}
	
	SetSCARTSignalPath();
	SetOutputChannels();
}

void CMSP3430::SetBeeper(int volume, MSP3430_beeper_frequency frequency, bool mute)
{
	// set beeper volume 0..127
	int beeper = (mute ? 0x00 : Clamp(volume, 0x00, 0x7f)) << 8;
	
	// set beeper frequency 16, 1000 or 4000 Hz
	switch (frequency) {
	case C_MSP3430_BEEPER_16_HZ:
		beeper |= 0x0001;
		break;
	case C_MSP3430_BEEPER_1_KHZ:
		beeper |= 0x0040;
		break;
	case C_MSP3430_BEEPER_4_KHZ:
		beeper |= 0x00ff;
		break;
	}
	SetRegister(MSP3430_WR_DSP, BEEPER, beeper);
}

void CMSP3430::SetQuasiPeak(int left, int right)
{
	// set quasipeak detector readout -32768..32767
	fQPeakLeft = left;
	fQPeakRight = right;

	SetOutputChannels();
}

void CMSP3430::GetVersion(char * version)
{
	int revision = Register(MSP3430_RD_DSP, MSP_HARD_REVISION);
	int product = Register(MSP3430_RD_DSP, MSP_PRODUCT_ROM);
	
	sprintf(version, "MSP34%02d%c-%c%d",
		((product  & MSP_PRODUCT)  >> 8),
		((revision & MSP_REVISION) >> 0) + 0x40,
		((revision & MSP_HARD)     >> 8) + 0x40,
		((product  & MSP_ROM)      >> 0));
}

#pragma mark -

void CMSP3430::Reset()
{
	// software reset
	SetControlRegister(MSP3430_CONTROL_RESET);
	SetControlRegister(MSP3430_CONTROL_NORMAL);
}

void CMSP3430::SetSCARTSignalPath()
{
	// select SCART DSP input and output
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_ACB_REG,fACB);
}

void CMSP3430::SetDemodulator()
{
	// set preferred mode and sound IF input
	// (automatic, enable STATUS change, detect 4.5 MHz carrier as BTSC)
	SetRegister(MSP3430_WR_DEM, MODUS, 0x2003);
	
	// set preferred prescale (FM and NICAM)
	SetRegister(MSP3430_WR_DSP, PRE_FM, fFMPrescale);
	SetRegister(MSP3430_WR_DSP, PRE_NICAM, fNICAMPrescale);
	
	// automatic sound standard selection
	SetRegister(MSP3430_WR_DEM, MSP3430_DEM_STANDARD_SEL, 0x0001);
	
	// readback the detected TV sound or FM-radio standard
	while ((fStandard = Register(MSP3430_RD_DEM, STANDARD_RES)) >= 0x0800)
		snooze(100000);	
}

void CMSP3430::SetSCARTInput()
{
	// select preferred prescale for SCART and I2C
	SetRegister(MSP3430_WR_DSP, PRE_SCART, fSCARTPrescale);
	SetRegister(MSP3430_WR_DSP, PRE_I2S1, fI2SPrescale);
	SetRegister(MSP3430_WR_DSP, PRE_I2S2, fI2SPrescale);
}

void CMSP3430::SetOutputChannels()
{
	// select source channel and matrix for each output
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_SRC_MAT_MAIN, fMainMatrix);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_SRC_MAT_AUX, fAuxMatrix);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_SRC_MAT_SCART1, fSCART1Matrix);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_SRC_MAT_SCART2, fSCART2Matrix);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_SRC_MAT_I2S, fI2SMatrix);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_SRC_MAT_QPEAK, fQPeakMatrix);
	
	// set audio baseband processing
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_TONE_MODE, fToneControl);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_BASS_MAIN, fBass);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_BASS_AUX, fBass);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_TREB_MAIN, fTreble);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_TREB_AUX, fTreble);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_EQUAL_BAND1, fEqualizer[0]);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_EQUAL_BAND2, fEqualizer[1]);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_EQUAL_BAND3, fEqualizer[2]);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_EQUAL_BAND4, fEqualizer[3]);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_EQUAL_BAND5, fEqualizer[4]);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_LOUD_MAIN, fLoudness);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_LOUD_AUX, fLoudness);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_SPAT_MAIN, fSpatial);
	
	// select volume for each output channel
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_VOL_MAIN, fVolume);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_VOL_AUX, fVolume);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_AVC, fAVC);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_BAL_MAIN, fBalance);
	SetRegister(MSP3430_WR_DSP, MSP3430_DSP_BAL_AUX, fBalance);
	
	SetRegister(MSP3430_WR_DSP, VOL_SCART1, fSCART1Volume);
	SetRegister(MSP3430_WR_DSP, VOL_SCART2, fSCART2Volume);
	
	// set quasipeak detector readout
	SetRegister(MSP3430_WR_DSP, QPEAK_L, fQPeakLeft);
	SetRegister(MSP3430_WR_DSP, QPEAK_R, fQPeakRight);
}

void CMSP3430::SetSubwooferAndMDBOutputChannels()
{
	// set subwoofer output channel
	SetRegister(MSP3430_WR_DSP, SUBW_LEVEL, fSubwooferLevel);
	SetRegister(MSP3430_WR_DSP, SUBW_FREQ, fSubwooferFrequency);

	// set MDB control
	SetRegister(MSP3430_WR_DSP, MDB_STR, fMDBStrength);
	SetRegister(MSP3430_WR_DSP, MDB_LIM, fMDBLimit);
	SetRegister(MSP3430_WR_DSP, MDB_HMC, fMDBHarmonic);
	SetRegister(MSP3430_WR_DSP, MDB_LP, fMDBLowPass);
	SetRegister(MSP3430_WR_DSP, MDB_HP, fMDBHighPass);
}

#pragma mark -
#endif

int CMSP3430::ControlRegister()
{
	char message[1], result[2];

	message[0] = MSP3430_CONTROL;
	if (fPort.Write(fAddress, message, sizeof(message), result, sizeof(result)))
		return ((result[0] << 8) & 0xff00) + ((result[1] << 0) & 0x00ff);
	return 0;
}

void CMSP3430::SetControlRegister(int value)
{
	char message[3];
	
	message[0] = MSP3430_CONTROL;
	message[1] = value >> 8;
	message[2] = value >> 0;
	
	if (!fPort.Write(fAddress, message, sizeof(message)))
		PRINT(("CMSP3430::SetControl() - error\n"));
}

int CMSP3430::Register(int address, int subaddress)
{
	char message[3], response[2];
	
	message[0] = address;
	message[1] = subaddress >> 8;
	message[2] = subaddress >> 0;
	
	if (fPort.Write(fAddress, message, sizeof(message), response, sizeof(response)))
		return ((response[0] << 8) & 0xff00) + ((response[1] << 0) & 0x00ff);
	return 0;
}

void CMSP3430::SetRegister(int address, int subaddress, int value)
{
	char message[5];
	
	message[0] = address;
	message[1] = subaddress >> 8;
	message[2] = subaddress >> 0;
	message[3] = value >> 8;
	message[4] = value >> 0;
	
	if (!fPort.Write(fAddress, message, sizeof(message)))
		PRINT(("CMSP3430::SetRegister() - error\n"));
}