process_key.c

Sample code for use on smp 863x processor.

			"  x: toggle video output enable/disable\n"
			"  9: increase size, 3: decrease size, 2,4,6,8: move scaler window\n"
			"  1: half size, 7: full size (use numerical key block)\n"
			"  5: switch from VIDEO to OSD control (valid only if OSD is present)\n"
			"  w: change non-linear width\n"
			"  W: change non-linear level\n"
			"  d: Dump OSD Info\n"
			"  r: rotate picture\n");

	if (keyflags & SET_KEY_SPI) 
		fprintf(stderr, 
			"  k - SPI channel change\n"
			"  i - SPI PAT info\n"
			"  m - SPI PMT change\n"
			"  A - SPI audio stream change\n"
			"  X - SPI video stream change\n"
			"  a - Cycle through audio streams\n"
			"  l - Choose audio stream\n"
			"  K - switch between spi and file playback\n");
	
	if (keyflags & SET_KEY_AUDIO) 
		fprintf(stderr,
			"  v: decrease volume - V: increase volume - _: mute\n"
			"  E: toggle between dual modes (Stereo->LeftMono->RightMono->Mono)\n"
			"  <, >: decrease/increase playback speed by 1 ppm\n");
	
	if (keyflags & SET_KEY_DEBUG) 
		fprintf(stderr, 
			"  gr<A>: read 32 bits from gbus address A (hex)\n"
			"  gw<A> <D>: write D (hex) to gbus address A (hex)\n"
			"  gf<A>: measure frequency of the 32 bit register at gbus address A (hex)\n"
			"  I: enter I2C debug access mode (HDMI only)\n"
			"  M: enter video mode modificator\n"
			"  |: print STC drift information\n"
			"  !: show debug informations\n"
			"  Y: show display debug informations\n"
			"  Z: show vsync debug information\n"
			"  *: force filter settings on main video scaler\n"
			"  #: Turn HDCP on/off (HDMI only)\n");
	
}

static void print_hz(RMuint32 f) 
{
	if (f >= 1000000) fprintf(stderr, "%3lu,%03lu,%03lu", f / 1000000, (f / 1000) % 1000, f % 1000);
	else if (f >= 1000) fprintf(stderr, "%7lu,%03lu", f / 1000, f % 1000);
	else fprintf(stderr, "%11lu", f);
}

static RMuint32 get_freqency(
	struct gbus *pGBus, 
	RMuint32 addr, 
	RMuint32 uSecDelay)
{
	RMuint32 ref0, ref1, refd, ctr0, ctr1, ctrd;
	
	/* avoid integer overflow */
	if (uSecDelay > 159) uSecDelay = 159;
	
	/* initial counter values */
	ref0 = gbus_read_uint32(pGBus, 0x10048);  // REG_BASE_system_block + SYS_xtal_in_cnt
	ctr0 = gbus_read_uint32(pGBus, addr);
	
	/* loop for specified time, at least once */
	do {
		/* final counter values */
		ref1 = gbus_read_uint32(pGBus, 0x10048);  // REG_BASE_system_block + SYS_xtal_in_cnt
		ctr1 = gbus_read_uint32(pGBus, addr);
		
		/* delta values */
		refd = (ref1 > ref0) ? ref1 - ref0 : 0xFFFFFFFF - ref0 + ref1 + 1;
		ctrd = (ctr1 > ctr0) ? ctr1 - ctr0 : 0xFFFFFFFF - ctr0 + ctr1 + 1;
		
		/* check if xtal_in_ctr is stagnant */
		if (! refd) return 0;
	} while (refd < XTAL_HZ * uSecDelay / 1000);
	
	/* return ctrd, normalized to Hz */
	return (RMuint32)RM64mult32div32(ctrd, XTAL_HZ, refd);
}

RMstatus process_key(struct dcc_context *dcc_info, RMuint32 *cmd, RMuint32 keyflags)
{
	RMascii key;
	RMstatus err;

 in_key:	
	
	key = 0;
	if (((dcc_info->state == RM_STOPPED) || (dcc_info->state == RM_PAUSED)) || (RMKeyAvailable())) 
		key = RMGetKey();
	
	err = handle_key(dcc_info, cmd, keyflags, key);
	if (err == RM_PENDING) err = RM_OK;
	
	if (RMSUCCEEDED(err) && (*cmd == RM_UNKNOWN) && ((dcc_info->state == RM_STOPPED) || (dcc_info->state == RM_PAUSED))) {
		goto in_key;
	}
	
	return err;
}

RMstatus handle_debug_key(struct dcc_context *dcc_info, RMascii key, RMbool *processed);
void send_hilight_button(struct dcc_context *dcc_info);

RMstatus handle_debug_key(struct dcc_context *dcc_info, RMascii key, RMbool *processed)
{
	static RMuint32 last_gr = 0;
	RMstatus err;
	
	*processed = TRUE;
	
	// Debug access to HDMI I2C busses
	if (dcc_info->dh_info && dcc_info->dh_info->pDH) {
		err = DHDebugI2C(dcc_info->dh_info->pDH, KEY_CMD_I2C, key);
		if (RMSUCCEEDED(err)) return RM_OK; //we processed the key
	}
	
	switch (key) {
	case KEY_CMD_GBUS: {
		RMascii k;
		fprintf(stderr, "%c", key);
		k = RMGetKey(); fprintf(stderr, "%c", k);
		if ((k == 'r') || (k == 'w') || (k == 'f')) {
			RMascii command = k;
			RMbool error = FALSE;
			RMuint32 a = 0, d = 0;
			RMascii device[40];
			struct llad *pLLAD;
			struct gbus *pGBus;
			RMPrintAscii(device, "%lu", dcc_info->chip_num);
			pLLAD = llad_open(device);
			pGBus = gbus_open(pLLAD);
			do {
				k = RMGetKey(); fprintf(stderr, "%c", k);
				if ((k >= '0') && (k <= '9')) a = (a << 4) + (k - '0'); 
				else if ((k >= 'A') && (k <= 'F')) a = (a << 4) + (k - 'A' + 10); 
				else if ((k >= 'a') && (k <= 'f')) a = (a << 4) + (k - 'a' + 10); 
				else if ((k == '\b') || (k == '\177')) a >>= 4; 
				else {
					if ((k != ' ') && (k != '\n')) error = TRUE; 
					break;
				}
			} while (!(a & 0xF0000000));
			if ((! error) && ((command == 'r') || (command == 'f'))) {
				if (! a) {
					a = last_gr;
					fprintf(stderr, "%08lX", a);
				} else last_gr = a;
				if (command == 'r') {
					fprintf(stderr, " = %08lX\n", gbus_read_uint32(pGBus, a));
				} else {
					fprintf(stderr, " @ ");
					print_hz(get_freqency(pGBus, a, 100));
					fprintf(stderr, " Hz\n");
				}
				k = '\n';
			} else if (! error) {
				do {
					k = RMGetKey(); fprintf(stderr, "%c", k);
					if ((k >= '0') && (k <= '9')) d = (d << 4) + (k - '0'); 
					else if ((k >= 'A') && (k <= 'F')) d = (d << 4) + (k - 'A' + 10); 
					else if ((k >= 'a') && (k <= 'f')) d = (d << 4) + (k - 'a' + 10); 
					else if ((k == '\b') || (k == '\177')) d >>= 4; 
					else {
						if ((k != ' ') && (k != '\n')) error = TRUE; 
						break;
					}
				} while (!(d & 0xF0000000));
				if (! error) gbus_write_uint32(pGBus, a, d);
			}
			if (error) fprintf(stderr, " input error!\n");
			gbus_close(pGBus);
			llad_close(pLLAD);
		}
		if (k != '\n') fprintf(stderr, "\n");
		break;
	}
	case KEY_CMD_VIDEOMODE: {
		struct VideoMode VM;
		RMascii k;
		RMuint32 *mod;
		err = get_current_video_mode(dcc_info, &VM);
		if (RMFAILED(err)) break;
		do {
			mod = NULL;
			fprintf(stderr, "Current video mode: (press corresponding key to modify value)\n");
			fprintf(stderr, "  [a] PixelClock:     %lu\n", VM.PixelClock);
			fprintf(stderr, "  [b] HActive:        %lu\n", VM.HActive);
			fprintf(stderr, "  [c] HFrontPorch:    %lu\n", VM.HFrontPorch);
			fprintf(stderr, "  [d] HSyncWidth:     %lu\n", VM.HSyncWidth);
			fprintf(stderr, "  [e] HBackPorch:     %lu\n", VM.HBackPorch);
			fprintf(stderr, "  [f] HSyncPolarity:  %s\n", VM.HSyncPolarity ? "positive" : "negative");
			fprintf(stderr, "  [g] VActive:        %lu\n", VM.VActive);
			fprintf(stderr, "  [h] VFrontPorch:    %lu\n", VM.VFrontPorch);
			fprintf(stderr, "  [i] VSyncWidth:     %lu\n", VM.VSyncWidth);
			fprintf(stderr, "  [j] VBackPorch:     %lu\n", VM.VBackPorch);
			fprintf(stderr, "  [k] VSyncPolarity:  %s\n", VM.VSyncPolarity ? "positive" : "negative");
			fprintf(stderr, "  [l] Interlaced:     %s\n", VM.Interlaced ? "yes" : "no");
			fprintf(stderr, "  <enter> to quit\n");
			k = RMGetKey();
			if (k == '\n') {
				RMuint32 HTotal, VTotal;
				HTotal = VM.HActive + VM.HFrontPorch + VM.HSyncWidth + VM.HBackPorch;
				VTotal = VM.VActive + VM.VFrontPorch + VM.VSyncWidth + VM.VBackPorch;
				if (VM.Interlaced) VTotal = VTotal * 2 + 1;
				fprintf(stderr, "New mode line for vesa.tbl:\n"
					"%9lu, %4lu, %4lu, %4lu, %3lu, %3lu, %3lu, %d, %4lu, %2lu, %2lu, %2lu, %d, NewMode_%lux%lux%lu%s\n", 
					VM.PixelClock, VM.HActive, VM.VActive, 
					HTotal, VM.HFrontPorch, VM.HSyncWidth, VM.HBackPorch, VM.HSyncPolarity, 
					VTotal, VM.VFrontPorch, VM.VSyncWidth, VM.VBackPorch, VM.VSyncPolarity, 
					VM.HActive, VM.VActive, 
					VM.PixelClock / (VTotal * HTotal), 
					VM.Interlaced ? "i" : "");
				break;
			}
			fprintf(stderr, "%c\n", k);
			switch (k) {
			case 'a': mod = &VM.PixelClock; break;
			case 'b': mod = &VM.HActive; break;
			case 'c': mod = &VM.HFrontPorch; break;
			case 'd': mod = &VM.HSyncWidth; break;
			case 'e': mod = &VM.HBackPorch; break;
			case 'f': VM.HSyncPolarity = ! VM.HSyncPolarity; break;
			case 'g': mod = &VM.VActive; break;
			case 'h': mod = &VM.VFrontPorch; break;
			case 'i': mod = &VM.VSyncWidth; break;
			case 'j': mod = &VM.VBackPorch; break;
			case 'k': VM.VSyncPolarity = ! VM.VSyncPolarity; break;
			case 'l': {
				VM.Interlaced = ! VM.Interlaced; 
				if (VM.Interlaced) {
					VM.VActive /= 2;
					VM.VFrontPorch /= 2;
					VM.VSyncWidth /= 2;
					VM.VBackPorch /= 2;
				} else {
					VM.VActive *= 2;
					VM.VFrontPorch *= 2;
					VM.VSyncWidth *= 2;
					VM.VBackPorch *= 2;
				}
				break;
			}
			}
			if (mod) {
				RMuint32 new = 0;
				RMbool parse = FALSE;
				fprintf(stderr, "press '+' or '-', or enter new value, <enter> to end\n");
				do {
					if (! parse) fprintf(stderr, "(%lu) ", *mod);
					k = RMGetKey();
							
					switch (k) {
					case '+': parse = FALSE; (*mod)++; break;
					case '-': parse = FALSE; if (*mod) (*mod)--; break;
					case '0': case '1': case '2': case '3': case '4': 
					case '5': case '6': case '7': case '8': case '9': 
						if (! parse) {
							new = 0;
							parse = TRUE;
						}
						fprintf(stderr, "%c", k);
						new = (new * 10) + (k - '0');
						break;
					case '\b': case '\177':
						if (parse) {
							fprintf(stderr, "%c", k);
							new /= 10;
						}
						break;
					case '\n': 
						if (parse) {
							*mod = new; 
							parse = FALSE; 
							k = ' ';
						}
						break;
					default: parse = FALSE; break;
					}
					if (!parse) {
						fprintf(stderr, "\n");
						err = set_modifyed_video_mode(dcc_info, &VM);
					}
				} while (k != '\n');
			} else {
				err = set_modifyed_video_mode(dcc_info, &VM);
			}
			if (RMFAILED(err)) {
				fprintf(stderr, "Error setting new mode!\n");
			}
		} while (TRUE);
		break;
	}
	case KEY_CMD_HIGHLIGHT:
		send_hilight_button(dcc_info);	
		break;
	case KEY_CMD_STCDRIFT: {
		RMuint32 STCModuleID = EMHWLIB_MODULE(STC, 0);
		RMuint32 stc_freq, xtal_freq, rounds;
		RMuint64 stc_curr;
		RMuint32 xtal_curr;
		RMint32 dist;
		static RMint32 initialdist = 0;
		enum ClockCounter ctr = ClockCounter_xtal_in;
		enum PLLSource xtal = PLLSource_xtal;
		
		err = RUAExchangeProperty(dcc_info->pRUA, PLL, RMPLLPropertyID_QuerySourceFrequency, 
			&xtal, sizeof(xtal), &xtal_freq, sizeof(xtal_freq));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get XTAL speed, %s\n", RMstatusToString(err));
		}
		err = RUAGetProperty(dcc_info->pRUA, STCModuleID, RMSTCPropertyID_StcTimeResolution, &stc_freq, sizeof(stc_freq));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get STC speed, %s\n", RMstatusToString(err));
		}
		fprintf(stderr, "STC running at %lu Hz, Xtal running at %lu Hz\n", stc_freq, xtal_freq);
		err = RUAExchangeProperty(dcc_info->pRUA, STCModuleID, RMSTCPropertyID_TimeInfo,
			&xtal_freq, sizeof(xtal_freq), &stc_curr, sizeof(stc_curr));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get STC, %s\n", RMstatusToString(err));
		}
		err = RUAExchangeProperty(dcc_info->pRUA, PLL, RMPLLPropertyID_QueryCounter,
			&ctr, sizeof(ctr), &xtal_curr, sizeof(xtal_curr));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get XTAL, %s\n", RMstatusToString(err));
		}
		if (! initialdist) initialdist = xtal_curr - (RMuint32)stc_curr;
		xtal_curr -= initialdist;
		rounds = (xtal_curr + xtal_freq) / xtal_freq;
		dist = xtal_curr - (RMuint32)stc_curr;
		if ((RMuint32)(RMabs(dist)) > (RMuint32)(xtal_freq * 10)) initialdist = 0;
		fprintf(stderr, "stc:%lu - xtal:%lu = %ld, avrg: %ld ppm\n", 
			(RMuint32)stc_curr, xtal_curr, dist,