ruaxrpc.c

1. 8623L平台

/*
 *
 * 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);