| /* |
| * Copyright 2001-2008 Texas Instruments - http://www.ti.com/ |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * ======== cexec.c ======== |
| * "cexec" is a Linux console-based utility that allows developers to load |
| * and start a new DSP/BIOS Bridge based DSP program. If "cexec" encounters |
| * an error, it will display a DSP/BIOS Bridge GPP API error code. |
| * |
| * Usage: |
| * cexec [optional args] <dsp_program> |
| * |
| * Options: |
| * -?: displays "cexec" usage. If this option is set, cexec does not |
| * load the DSP program. |
| * -w: waits for the user to hit the enter key on the keyboard, which |
| * stops DSP program execution by placing the DSP into reset. This |
| * will also display on the WinCE console window the contents of |
| * DSP/BIOS Bridge trace buffer, which is used internally by the |
| * DSP/BIOS Bridge runtime. If this option is not specified, "cexec" |
| * loads and starts the DSP program, then returns immeidately, |
| * leaving the DSP program running. |
| * -v: verbose mode. |
| * -p [processor]: defines the DSP processor on which to execute code, |
| * where processor is the processor number provided by cexec to |
| * the DSPProcessor_Attach() function. If this option is not |
| * specified, the default processor is 0. |
| * -T: Set scriptable mode. If set, cexec will run to completion after |
| * loading and running a DSP target. User will not be able to stop |
| * the loaded DSP target. |
| * |
| * Example: |
| * 1. Load and execute a DSP/BIOS Bridge base image, waiting for user to |
| * hit enter key to halt the DSP. |
| * |
| * cexec -w chnltest_tiomap1510.x55l |
| * |
| * 2. Start a program running on the second processor (zero-indexed). |
| * This will halt the currently running DSP program, if any. |
| * |
| * cexec -w -p l chnltest_tiomap1510.x55l |
| * |
| * 3. Load and start a program running on the DSP. Cexec will run to |
| * completion and leave the DSP loaded and running. |
| * |
| * cexec -T chnltest_tiomap1510.x55l |
| * |
| *! Revision History: |
| *! ================ |
| *! 20-Oct-2002 map: Instrumented to measure performance on PROC_Load |
| *! 31-Jul-2002 kc: Added scriptable mode to enable batch testing. |
| *! 05-Apr-2001 kc: Adapted from existing cexec. Updated cexec program |
| *! options. Added command line argument handling. |
| *! Based on DSP/BIOS Bridge API version 0.??. |
| *! 13-Feb-2001 kc: DSP/BIOS Bridge name update. |
| *! 15-Nov-2000 jeh Converted to use DSPProcessor. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <dbdefs.h> |
| /* #include <varargs.h> */ |
| #include <stdarg.h> |
| |
| #include <dbapi.h> |
| #include <DSPManager.h> |
| #include <DSPProcessor.h> |
| #include <DSPProcessor_OEM.h> |
| |
| /* global constants. */ |
| #define MAXTRACESIZE 256 /* size of trace buffer. */ |
| |
| /* function prototype. */ |
| VOID DisplayUsage(); |
| VOID PrintVerbose(PSTR pstrFmt,...); |
| |
| /* global variables. */ |
| bool g_fVerbose = false; |
| |
| /* |
| * ======== main ======== |
| */ |
| INT main(INT argc, CHAR * argv[]) |
| { |
| INT opt; |
| bool fWaitForTerminate = false; |
| UINT uProcId = 0; /* default proc ID is 0. */ |
| bool fError = false; |
| DSP_HPROCESSOR hProc; |
| DSP_STATUS status = DSP_SOK; |
| INT cArgc = 0; /* local argc count. */ |
| bool fScriptable = false; |
| extern char *optarg; |
| struct DSP_PROCESSORINFO dspInfo; |
| UINT numProcs; |
| UINT index = 0; |
| while ((opt = getopt(argc, argv, "+T+v+w+?p:")) != EOF) { |
| switch (opt) { |
| case 'v': |
| /* verbose mode */ |
| fprintf(stdout, "Verbose mode: ON\n"); |
| g_fVerbose = true; |
| cArgc++; |
| break; |
| case 'w': |
| /* wait for user input to terminate */ |
| fprintf(stdout, "Not supported \n"); |
| fWaitForTerminate = true; |
| cArgc++; |
| break; |
| case 'T': |
| fScriptable = true; |
| cArgc++; |
| break; |
| case 'p': |
| /* user specified DSP processor ID (based on zero-index) */ |
| uProcId = atoi(optarg); |
| cArgc++; |
| break; |
| case '?': |
| default: |
| fError = true; |
| break; |
| } |
| } |
| argv += cArgc + 1; |
| argc -= cArgc + 1; |
| if (fError) { |
| DisplayUsage(); |
| } else { |
| status = (DBAPI)DspManager_Open(0, NULL); |
| if (DSP_FAILED(status)) { |
| PrintVerbose("DSPManager_Open failed \n"); |
| return -1; |
| } |
| while (DSP_SUCCEEDED(DSPManager_EnumProcessorInfo(index,&dspInfo, |
| (UINT)sizeof(struct DSP_PROCESSORINFO),&numProcs))) { |
| if ((dspInfo.uProcessorType == DSPTYPE_55) || |
| (dspInfo.uProcessorType == DSPTYPE_64)) { |
| printf("DSP device detected !! \n"); |
| uProcId = index; |
| status = DSP_SOK; |
| break; |
| } |
| index++; |
| } |
| status = DSPProcessor_Attach(uProcId, NULL, &hProc); |
| if (DSP_SUCCEEDED(status)) { |
| PrintVerbose("DSPProcessor_Attach succeeded.\n"); |
| status = DSPProcessor_Stop(hProc); |
| if (DSP_SUCCEEDED(status)) { |
| PrintVerbose("DSPProcessor_Stop succeeded.\n"); |
| status = DSPProcessor_Load(hProc,argc,(CONST CHAR **)argv,NULL); |
| if (DSP_SUCCEEDED(status)) { |
| PrintVerbose("DSPProcessor_Load succeeded.\n"); |
| status = DSPProcessor_Start(hProc); |
| if (DSP_SUCCEEDED(status)) { |
| fprintf(stdout,"DSPProcessor_Start succeeded.\n"); |
| #if 0 |
| /* It seems Linux bridge does n't yet support |
| * * DSPProcessor_GetTrace */ |
| if (fWaitForTerminate) { |
| /* wait for user */ |
| fprintf(stdout,"Hit \"return\" to stop DSP and" |
| "dump trace buffer:\n"); |
| (void)getchar(); |
| status = DSPProcessor_GetTrace(hProc, |
| (BYTE *)&traceBuf,MAXTRACESIZE); |
| fprintf(stdout,"%s\n",traceBuf); |
| } else { |
| PrintVerbose("in run free mode...\n"); |
| } |
| #endif /* 0 */ |
| } else { |
| PrintVerbose("DSPProcessor_Start failed: 0x%x.\n", |
| status); |
| } |
| } else { |
| PrintVerbose("DSPProcessor_Load failed: 0x%x.\n",status); |
| } |
| DSPProcessor_Detach(hProc); |
| } |
| } else { |
| PrintVerbose("DSPProcessor_Attach failed: 0x%x.\n",status); |
| } |
| } |
| if (!fScriptable) { |
| /* Wait for user to hit any key before exiting. */ |
| fprintf(stdout, "Hit any key to terminate cexec.\n"); |
| (void)getchar(); |
| } |
| status = DspManager_Close(0, NULL); |
| if (DSP_FAILED(status)) { |
| printf("\nERROR: DSPManager Close FAILED\n"); |
| } |
| return (DSP_SUCCEEDED(status) ? 0 : -1); |
| } |
| |
| VOID DisplayUsage() |
| { |
| fprintf(stdout, "Usage: cexec [options] <dsp program>\n"); |
| fprintf(stdout, "\t[optional arguments]:\n"); |
| fprintf(stdout, "\t-?: Display cexec usage\n"); |
| fprintf(stdout, "\t-v: Verbose mode\n"); |
| fprintf(stdout, "\t-w: Waits for user to hit enter key before\n"); |
| fprintf(stdout, "\t terminating. Displays trace buffer\n"); |
| fprintf(stdout, "\t-p [processor]: User-specified processor #\n"); |
| fprintf(stdout, "\n\t[required arguments]:\n"); |
| fprintf(stdout, "\t<dsp program>\n"); |
| fprintf(stdout, "\n\tExample: cexec -w -p 1 prog.x55l\n\n"); |
| } |
| |
| |
| /* |
| * ======== PrintVerbose ======== |
| */ |
| VOID PrintVerbose(PSTR pstrFmt,...) |
| { |
| va_list args; |
| if (g_fVerbose) { |
| va_start(args, pstrFmt); |
| vfprintf(stdout, pstrFmt, args); |
| va_end(args); |
| fflush(stdout); |
| } |
| } |
| |
| |
