/* * * Copyright (c) Sigma Designs, Inc. 2002. All rights reserved. * *//*  Code is very similar to llad_xtest/xrpc.c  Only difference is that the place where xrpc's are dropped is compatible with running RUA memory managers.*/#include "sample_os.h"#define ALLOW_OS_CODE 1#include "../dcc/include/dcc.h"#include "common.h"#define ac_G3r (1<<31)#define ac_G3w (1<<30)#define ac_G2r (1<<29)#define ac_G2w (1<<28)#define ac_G1r (1<<27)#define ac_G1w (1<<26)#define ac_G0r (1<<25)#define ac_G0w (1<<24)#define ac_D3r (1<<23)#define ac_D3w (1<<22)#define ac_D2r (1<<21)#define ac_D2w (1<<20)#define ac_D1r (1<<19)#define ac_D1w (1<<18)#if (EM86XX_CHIP>=EM86XX_CHIPID_TANGO3)#error miss xpu dma prot 17, 16 above#endif/* shortcuts */#define ac_Gr   (ac_G3r|ac_G2r|ac_G1r|ac_G0r)#define ac_Grw  (ac_G3w|ac_G2w|ac_G1w|ac_G0w|ac_Gr)#define ac_Dr   (ac_D3r|ac_D2r|ac_D1r)#define ac_Drw  (ac_D3w|ac_D2w|ac_D1w|ac_Dr)/* memory protection */#define dc_mem_access_0 0xff80#define dc_mem_access_1 0xff84#define dc_mem_access_2 0xff88#define dc_mem_access_3 0xff8c#define dc_mem_access_4 0xff90 /* only for dram */#define dc_mem_access_5 0xff94 /* only for dram */#define dc_reg_access_0 0xffc0#define dc_reg_access_1 0xffc4#define dc_reg_access_2 0xffc8 /* only for dram controller regs and xpu regs */#define dc_reg_access_3 0xffcc /* only for xpu regs */#define dc_reg_access_4 0xffd0 /* only for xpu regs */#define PMEM_BASE_xpu_block 0x400000#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "../xos/include/xos_xrpc.h"/* Default allocated size is huge (10MB), reduce here if needed */#define XRPC_ALLOC_SIZE (XRPC_MAXSIZE)#define RMasciiToUInt32(str,value) do { *(value)=strtoul(str,NULL,0); } while (0)#define xrpc_xload_pbusopen_ES4 xrpc_xload_pbusopen#define xrpc_xload_formatall_ES4 xrpc_xload_formatall#include "../llad_xtest/xrpc_xload_pbusopen_ES4.h"#include "../llad_xtest/xrpc_xload_formatall_ES4.h"int gbus_write_file(	RMuint8 *base,	char *filename);int gbus_write_file(	RMuint8 *base,	char *filename){	int fd,size=0,i=0;		fd=open(filename, O_RDONLY|O_LARGEFILE);	if (fd<0) {		perror("");		return -1;	}		// portable way to get a file's size	size=lseek(fd,0,SEEK_END);	if (size>XRPC_ALLOC_SIZE) {		fprintf(stderr,"exceeds usable memory range...\n");		return -1;	}		lseek(fd,0,SEEK_SET);		while (1) {		RMuint8 s[4];				if (read(fd,&s,4)!=4) {			perror("");			return -1;		}				*base=s[0];		base++;		*base=s[1];		base++;		*base=s[2];		base++;		*base=s[3];		base++;				i+=4;		if (i==size) break;	}		close(fd);		return size;}static void printprot(RMuint32 v){	RMint32 relevant=v&(ac_Grw|ac_Drw);		/* shortcuts */	if (relevant==0) {		printf(" denied\n"); // no one can access even xpu. Used for hw with looping effect (end of dram)		return;	}		if (relevant==(ac_Grw|ac_Drw)) {		printf(" noprot\n"); // not protected at all		return;	}		if (relevant==ac_Grw) {		printf(" nogprot\n"); // not protected from gbus access		return;	}	if (relevant==(ac_G0r|ac_G0w)) {		printf(" xpurwonly\n");		return;	}	/* in full... */	#undef DO#define DO(i)					\	do {					\		if (v&i) {			\			printf(" "#i);		\		}				\	} while (0)	DO(ac_G3r);	DO(ac_G3w);	DO(ac_G2r);	DO(ac_G2w);	DO(ac_G1r);	DO(ac_G1w);	DO(ac_G0r);	DO(ac_G0w);	DO(ac_D3r);	DO(ac_D3w);	DO(ac_D2r);	DO(ac_D2w);	DO(ac_D1r);	DO(ac_D1w);		printf("\n");}int main(int argc,char **argv) {	RMstatus rc=RM_ERROR;	struct RUA *pR = NULL;	RMuint32 chip_num=0;	if (argc==1) {		fprintf(stderr,"%s [-m board] <parameters>\n\n"			"<xrpc.bin>           Run provided xrpc\n"			"\n"			"xtask/ucode:\n"			" -xload <*.xload>\n"			" -xunload <image> <xload_size> <unload.xload>\n"		        "           (<xload_size> is ignored, only here for backward compatibility)\n"			"\n"			" -xstart <image> <a0> <a1> <a2> <a3>\n"			"                     Start an xtask instance from this image, returns pid\n"			" -xkill <tid> <val>  Signal a xtask. <val>=-1 causes immediate termination\n"			"\n"			" -ustart <image> <target>\n"			"                     Start ucode image <image> on dsp <target> (0 mpeg0 / 1 mpeg1 / 2 audio0 / 3 audio1 / 4 demux)\n"			" -ukill <tid> <val>  Signal a ucode. <val>=-1 causes immediate termination, other soft reset\n"			"\n"			"binding:\n"			" -xbind <*.xload>\n"			"\n"			"other:\n"		        " -bc                 Bonding comment (dev/prod)\n"			" -v                  Display xos SHA-1\n"		        " -V                  Display xos version (xos>=Mcc only)\n"			" -s                  Display serial#\n"			" -d                  Dump protection registers\n"		        " -b <certtype>       Dump certificate binding for type <certtype>\n"		        " -o <sector>         Dump sector owner\n"			" -e <ign> 22 21 0 0  Enhanced security mode (shown parameters are the xos defaults)\n"  		    	" -r                  Soft reboot\n"			" -c                  Cache dump (debug builds only)\n"			" -a <address>        Directly at address\n"			"sensitive ones:\n"			" -P                  pbusopen\n"			" -F                  formatall (blank all environment)\n"			"other helpers\n"			" -u                  unload irq handler\n"			" -z                  zero ih api block\n"			"\n"			,argv[0]);				return -1;	}		if (RMCompareAscii(argv[1], "-m")) {		RMasciiToUInt32(argv[2], &chip_num);		argv+=2;	}		if (RMFAILED(rc=RUACreateInstance(&pR, chip_num))) {		fprintf(stderr, "Error creating instance! %d\n",rc);		return -1;	}	#if 0	{		// test code for the different memory allocators				RMuint32 p0=RUAMalloc(pR,0,RUA_DRAM_UNPROTECTED,120);		RMuint32 p1=RUAMalloc(pR,1,RUA_DRAM_UNPROTECTED,130);		RMuint32 p2=RUAMalloc(pR,0,RUA_DRAM_PB,140); // picture buffers in dram0		RMuint32 p3=RUAMalloc(pR,1,RUA_DRAM_PB,150); // picture buffers in dram1		RMuint32 p4=RUAMalloc(pR,0,RUA_DRAM_BB,160); // bitstream buffers in dram0		RMuint32 p5=RUAMalloc(pR,1,RUA_DRAM_BB,170); // bitstream buffers in dram1		printf("p0=0x%08lx p1=0x%08lx p2=0x%08lx p3=0x%08lx p4=0x%08lx p5=0x%08lx\n",p0,p1,p2,p3,p4,p5);		if (p5)			RUAFree(pR,p5);		if (p4)			RUAFree(pR,p4);		if (p3)			RUAFree(pR,p3);		if (p2)			RUAFree(pR,p2);		if (p1)			RUAFree(pR,p1);		if (p0)			RUAFree(pR,p0);	}#else	{		RMuint32 p0=0, p=0;		RMuint8 *base_addr;		volatile struct xrpc_block_header *pB;				if (strcmp(argv[1],"-u")==0) {			printf("unload irq handler...\n");			rc=RUASetProperty(pR, XPUBlock, RMXPUBlockPropertyID_UnloadIrqHandler, &p0, sizeof(RMuint32), 0);			goto wayout2;		}				if (strcmp(argv[1],"-z")==0) {			printf("zero irq handler api...\n");			rc=RUASetProperty(pR, XPUBlock, RMXPUBlockPropertyID_ZeroIrqHandlerAPI, &p0, sizeof(RMuint32), 0);			goto wayout2;		}				p=RUAMalloc(pR,0,RUA_DRAM_UNPROTECTED,XRPC_ALLOC_SIZE);		if(p==0) {			fprintf(stderr,"cannot RUA allocate\n");			rc=RM_ERROR;			goto wayout2;		}				/* Aligned on cache line size */		p0=(p+16)&~0xF;				if (		    (RUALock(pR,p0,XRPC_ALLOC_SIZE-16)!=RM_OK)		    ||		    ((base_addr=RUAMap(pR,p0,XRPC_ALLOC_SIZE-16))==NULL)		    ) {			fprintf(stderr,"cannot map\n");			rc=RM_ERROR;			goto wayout2;		}				printf("[RUAXRPC map ok] dram_addr=0x%08lx base_addr=%p size=%d\n",p0,base_addr,XRPC_ALLOC_SIZE-16);				pB=(volatile struct xrpc_block_header *)base_addr; /* hack! endianness! e.m. */				if (argv[1][0]!='-') {			// FIXME: spaghettis 			if(gbus_write_file(base_addr, argv[1])<0)				goto wayout;						goto runit;		}		else {			pB->callerid=XRPC_CALLERID_IGNORED;			pB->headerandblocksize=(sizeof(struct xrpc_block_header)+63)&~63;			if (argc==3) { 				if ( (strcmp(argv[1],"-xload")==0) || (strcmp(argv[1],"-xbind")==0) ) { 					RMuint32 size; 					 					if((size=gbus_write_file( (RMuint8 *)(pB+1), argv[2]))<0) 						goto wayout;					 					if (strcmp(argv[1],"-xload")==0) 						pB->xrpcid=XRPC_ID_XLOAD;					else						pB->xrpcid=XRPC_ID_XBIND;					 					/* ! */ 					if (((*(RMuint32 *)(pB+1))>>24)==XLOAD_SEKID_CLEAR) 						pB->param0=size-XLOAD_CLEAR_HEADERSIZE; 					else 						pB->param0=size-XLOAD_CIPHERED_HEADERSIZE; 					 					pB->param1=0; // by putting garbage here, you can crash Maa. Fixed with Mac. 					pB->param2=0; 					pB->param3=0; 					pB->param4=0;					pB->headerandblocksize=sizeof(struct xrpc_block_header)+size; 					goto runit; 				}				if (strcmp(argv[1],"-o")==0) {					RMuint32 arg;					pB->xrpcid=XRPC_ID_GETOWNER;					RMasciiToUInt32(argv[2],&arg);					pB->param0=arg; 					pB->param1=0;  					pB->param2=0; 					pB->param3=0; 					pB->param4=0;										pB->headerandblocksize=sizeof(struct xrpc_block_header); 					goto runit;				}								if (strcmp(argv[1],"-b")==0) {					RMuint32 arg;					pB->xrpcid=XRPC_ID_GETBINDING;					RMasciiToUInt32(argv[2],&arg);					pB->param0=arg; 					pB->param1=0;  					pB->param2=0; 					pB->param3=0; 					pB->param4=0;										pB->headerandblocksize=sizeof(struct xrpc_block_header);