path: root/Graphic_Equalizer/src/smartmedia.hcc

/*! \file smartmedia.hcc
 *
 * \section generic	Here we interface with the SmartMedia card.
 *
 * \section project Project information.
 * Project Graphic Equalizer\n
 * \author O.M. Schinagl
 * \date 20041110
 * \version 0.1
 *
 * \section copyright Copyright
 * Copyright ©2004 Koninklijke Philips Electronics N.V. All rights reserved
 *
 * \section history Change history
 * 20041110: O.M. Schinagl\n	Initial version
 *
 ********************************************************************/

/******** System Includes *************/
#include <stdlib.hch>

#include "pal_master.hch"

/******** Application Includes ********/
#include "configuration.hch"
#include "display_shared.hch"
#include "smartmedia_shared.hch"
#include "smartmedia.hch"

#if HAVE_DEBUG
	#include "debug.hch"
#endif

#include "audio.hch"
#include "mouse_shared.hch"
#include "eventhandler_shared.hch"
#include "display.hch" /* FIXME: temporary include, needs to be moved to 'init' */

/*! \fn		unsigned 1 smartmedia_init(void);
 * \brief	We here initialize the Smart Media card and verify wether the
 *		card is inserted and such.
 * 
 * \return	We return 0 on success, 1 on error.
 * \retval	unsigned 1
 */
unsigned 1 smartmedia_init(void) {
	unsigned 1 retval;
	/*
	 * Firstly we enable both the CPLD and the SmartMedia.
	 */
	RC200CPLDEnable();
	RC200SmartMediaInit(&retval);

	if (retval) {
		RC200SmartMediaReset(&retval);
		RC200SmartMediaInit(&retval);
	}
	
	return retval;	
} /* --- smartmedia_init() --- */



/*! \fn		void smartmedia_loaddata(skindata_t *skindata);
 * \brief	We load our memory with skin and help data from the smartmedia.
 * 
 * \param	*skindata	skindata like boundries and colors of elements.
 *
 * \return	void
 * \retval	void
 */
void smartmedia_loaddata(skindata_t *skindata) {
	/*
	 * Setup RAM Handle, and determin maximum Data and Address widths
	 */
	macro expr RAM_BANK0 = PalPL2RAMCT(0);
	macro expr DW = PalPL2RAMGetMaxDataWidthCT();
	macro expr AW = PalPL2RAMGetMaxAddressWidthCT();

	unsigned DW data;
	unsigned 27 smartmedia_address, smartmedia_address_mask;
	unsigned AW address, address_offset;
	unsigned 8 mask, r, g, b;
	unsigned 4 stage;
	unsigned 1 result;

	extern ram unsigned 8 presets_default_values[768];

#if HAVE_DEBUG
	/*
	 * Print some nice stats about data loading.
	 */
	print_eol();
	print_hex_value(0);
#endif
	/*
	 * Before we enter our loop to fill our memory with valid data, we have
	 * to set the startup positions for the SmartMedia.
	 */
	address_offset = 0;
	smartmedia_address = 0;
	smartmedia_address_mask = SMARTMEDIA_ADDRESS_PRESET_DEMO_START;
	stage = STAGE_LOAD_PRESET;
	/*
	 * We start with the address of the skin, and do the loop until we have
	 * done the end of the help.
	 */
	while ((ADDRESS_ABOUT_BOTTOM_END +1) != (address_offset +address)) {
		if (STAGE_LOAD_PRESET == stage) {
			if (ADDRESS_PRESET_RESET_START == (address_offset +address)) {
				smartmedia_address_mask = SMARTMEDIA_ADDRESS_PRESET_RESET_START;
			}
			if (ADDRESS_PRESET_RESET_END == (address_offset +address)) { /* case ADRESS_SKIN_START */
#if HAVE_DEBUG
					print_string(" ADDRESS_SKIN_START");print_eol();
#endif
				address = 0;
				address_offset = ADDRESS_SKIN_START;
				smartmedia_address = SMARTMEDIA_ADDRESS_SKIN_START;
				smartmedia_address_mask = SMARTMEDIA_ADDRESS_SKINMASK_START;
				stage = STAGE_LOAD_SKIN;
			}
		} else {
			/*
			 * Once we are done with the loading of our skin, we need to
			 * change the smartmedia start addresses.
			 */
			switch (address_offset +address) {
				case ADDRESS_HELP_START:
#if HAVE_DEBUG
					print_string(" ADDRESS_HELP_START");print_eol();
#endif
					address = 0;
					address_offset = ADDRESS_HELP_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_HELP_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_HELPMASK_START;
					stage = STAGE_LOAD_HELP;
					break;
				case ADDRESS_GRAPHMASK_START:
#if HAVE_DEBUG
					print_string(" ADDRESS_GRAPHMASK_START");print_eol();
#endif
					address = 0;
					address_offset = ADDRESS_GRAPHMASK_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_GRAPHMASK_START;
					stage = STAGE_LOAD_GRAPH;
					break;
				case ADDRESS_ABOUT_TOP_FONTYS_START:
#if HAVE_DEBUG
					print_string(" ADDRESS_ABOUT_TOP_FONTYS_START: ");print_eol();
#endif
					address = 0;
					address_offset = ADDRESS_ABOUT_TOP_FONTYS_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_TOP_FONTYS_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_TOPMASK_START;
					stage = STAGE_LOAD_TOP_FONTYS;
					break;
				case ADDRESS_ABOUT_TOP_TASS_START:
#if HAVE_DEBUG
					print_string(" ADDRESS_ABOUT_TOP_TASS_START");print_eol();
#endif
 					address = 0;
					address_offset = ADDRESS_ABOUT_TOP_FONTYS_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_TOP_FONTYS_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_TOPMASK_START;
					stage = STAGE_LOAD_TOP_FONTYS;
					/*
					address_offset = ADDRESS_ABOUT_TOP_TASS_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_TOP_TASS_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_TOPMASK_START;
					stage = STAGE_LOAD_TOP_TASS;
					*/
					break;
				case ADDRESS_ABOUT_TOP_TRANSFER_START:
#if HAVE_DEBUG
					print_string(" ADDRESS_ABOUT_TOP_TRANSFER_START");print_eol();
#endif
					address = 0;
					address_offset = ADDRESS_ABOUT_TOP_TRANSFER_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_TOP_TRANSFER_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_TOPMASK_START;
					stage = STAGE_LOAD_TOP_TRANSFER;
					break;
				case ADDRESS_ABOUT_TOP_CELOXICA_START:
#if HAVE_DEBUG
					print_string(" ADDRESS_ABOUT_TOP_CELOXICA_START");print_eol();
#endif
					address = 0;
					address_offset = ADDRESS_ABOUT_TOP_CELOXICA_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_TOP_CELOXICA_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_TOPMASK_START;
					stage = STAGE_LOAD_TOP_CELOXICA;
					break;
/*
				case ADDRESS_ABOUT_TOP_DETAILS_START:
					address = 0;
					address_offset = ADDRESS_ABOUT_TOP_DETAILS_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_TOP_DETAILS_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_TOPMASK_START;
					stage = STAGE_LOAD_TOP_DETAILS;
					break;
*/
				case ADDRESS_ABOUT_BOTTOM_START:
#if HAVE_DEBUG
					print_string(" ADDRESS_ABOUT_BOTTOM_START");print_eol();
#endif
					address = 0;
					address_offset = ADDRESS_ABOUT_BOTTOM_START;
					smartmedia_address = SMARTMEDIA_ADDRESS_BOTTOM_START;
					smartmedia_address_mask = SMARTMEDIA_ADDRESS_BOTTOMMASK_START;
					stage = STAGE_LOAD_ABOUT_BOTTOM;
					break;
				default:
					break;
			}
		}

		/*
		 * Before reading our data from the smartmedia we set our
		 * address pointer to the address from our loop.
		 */
#if HAVE_SMARTMEDIA
		PalPL2RAMSetWriteAddress(RAM_BANK0, (STAGE_LOAD_GRAPH == stage) ? (address_offset +(0 @ (address \\ 2))) : (address_offset +address)); //(STAGE_LOAD_PRESET == stage) ? (address_offset +(0 @ (address \\ 2))) : 
#else
		PalPL2RAMSetWriteAddress(RAM_BANK0, 0);
#endif

		/*
		 * SmartMedia data is read one byte per call. Because we want
		 * to store the mask + the rgb values in one variable for later
		 * useage we need to read those 4 bytes from the smartmedia
		 * before storing it as one.
		 */
#if HAVE_SMARTMEDIA
		/*
		 * FIXME: Due to a bug in the DK2 smartmedia libraries we need
		 * stop reading after each byte with OperationEnd call. This is
		 * VERY slow and must be changed.
		 */
		if ((STAGE_LOAD_PRESET != stage) && (STAGE_LOAD_GRAPH != stage)) {
			RC200SmartMediaSetAddress(READ, smartmedia_address);
			RC200SmartMediaRead(&r, TRUE);
			RC200SmartMediaOperationEnd(&result);
			RC200SmartMediaSetAddress(READ, (smartmedia_address +1));
			RC200SmartMediaRead(&g, TRUE);
			RC200SmartMediaOperationEnd(&result);
			RC200SmartMediaSetAddress(READ, (smartmedia_address +2));
			RC200SmartMediaRead(&b, TRUE);
			RC200SmartMediaOperationEnd(&result);
		}

		if (STAGE_LOAD_GRAPH == stage) {
			RC200SmartMediaSetAddress(READ, smartmedia_address_mask +1);
			RC200SmartMediaRead(&r, TRUE);
			RC200SmartMediaOperationEnd(&result);
			RC200SmartMediaSetAddress(READ, (smartmedia_address_mask +2));
			RC200SmartMediaRead(&g, TRUE);
			RC200SmartMediaOperationEnd(&result);
			RC200SmartMediaSetAddress(READ, (smartmedia_address_mask +3));
			RC200SmartMediaRead(&b, TRUE);
			RC200SmartMediaOperationEnd(&result);
		}

		RC200SmartMediaSetAddress(READ, smartmedia_address_mask);
		RC200SmartMediaRead(&mask, TRUE);
		RC200SmartMediaOperationEnd(&result);

		switch (stage) {
			case STAGE_LOAD_PRESET:
				presets_default_values[address <- 10] = mask;
				break;
			case STAGE_LOAD_SKIN:		/* fall through */
			case STAGE_LOAD_HELP:		/* fall through */
			case STAGE_LOAD_GRAPH:		/* fall through */
			case STAGE_LOAD_TOP_FONTYS:	/* fall through */
			case STAGE_LOAD_TOP_TASS:	/* fall through */
			case STAGE_LOAD_TOP_TRANSFER:	/* fall through */
			case STAGE_LOAD_TOP_CELOXICA:	/* fall through */
			case STAGE_LOAD_TOP_DETAILS:	/* fall through */
			case STAGE_LOAD_ABOUT_BOTTOM:
				data = 0 @ mask @ r @ g @ b;
				break;
		//	case STAGE_LOAD_GRAPH:
		//		data = ((address <- 2) ? ((data << 8) +(0 @ mask)) : (0 @ mask));
		//		break;
		}
		
#else
		data = 0x0000ff00;
#endif
		/*
		 * Now that we have gathered all pixel data, store it in ram.
		 */
		PalPL2RAMWrite(RAM_BANK0, data);

#if HAVE_DEBUG
		/*
		 * Print some nice stats about data loading.
		 */
		if (!((address_offset +address) <- 10)) {
			print_cr();
			print_hex_value(0 @ ((address_offset +address) \\ 11));
			print_string(" / 000001D7 | data: ");
			print_hex_value(data <- 32);
			print_string(" | PL2: ");
			print_hex_value(0@(address_offset));
			print_string(" | SMC: ");
			print_hex_value(0@smartmedia_address);
		}
#endif

		/*
		 * Finally increase al our indexes approperiatly.
		 */
		smartmedia_address += 3;
		if (STAGE_LOAD_GRAPH == stage) {
			smartmedia_address_mask += 4;
		} else {
			smartmedia_address_mask++;
		}
		address++;
	}

	/*
	 * This block needs to probably move up into the fore loop where we
	 * calculate these settings later.
	 */
	skindata->spectrum.top = 200;
	skindata->spectrum.bottom = 335;
	skindata->spectrum.left = 77;
	skindata->spectrum.right = 575;
//	skindata->spectrum.color_primary = PIXEL_SPECTRUM;
//	skindata->spectrum.color_secondary = PIXEL_SPECTRUM;

	skindata->waveform.top = 46;
	skindata->waveform.bottom = 118;
	skindata->waveform.left = 76;
	skindata->waveform.right = 413;
	skindata->waveform.color_primary = PIXEL_WAVEFORM;

	skindata->volume.top = 112;
	skindata->volume.bottom = 66;
	skindata->volume.left = 439;
	skindata->volume.right = 455;
	skindata->volume.color_primary = PIXEL_VOLUME;

	skindata->equalizer.color_primary = PIXEL_EQUALIZER;
} /* --- smartmedia_loaddata() --- */