/* START of binary.c */ #include #define I_AM_HOST #define DEBUG #include #include #include #include #include "VME_trig.h" #include "binary.h" #include "binary_in.h" #include "dsp_hbook_defs.h" #include "source_hbook.h" int MessArea[MESS_BLOCKSIZE]; /*For received messages - Call it what you want*/ /* Some might even want to allocate this on the fly */ int *message_base = MessArea; /* mess_base must point to allocated area */ int dsp_status[NUM_CHAN]; /* dsp_status must be declared */ int ndelay = 10000; char errstring[80] ; void handle_sig(); /* For setitimer */ int nint(float); int eff_array[768][128]; int dsp_num=0; int run_no; int num_words = 10; int link_num = 0; FILE *fp; float atup[3]; extern int loops; /****** Accelerated "look" to try to speed readout. ******/ int hackvar; #define look(dsp, sig) ((io_base[dsp]->signals == (hackvar = io_base[dsp]->signals)) ? (hackvar >> sig) & 1 : ((io_base[dsp]->signals >> sig) & 1)) int do_binary_SOB (int count ) { int i; i = count; /*originally loop over dsps */ set_flag(i,EOB_SIG_FLAG,0); set_flag(i,SOB_SIG_FLAG,1); printf(" DSP-SOB flag set \n"); return 0; } int do_binary_EOB (int count) { int i; i = count; set_flag(i,SOB_SIG_FLAG,0); set_flag(i,EOB_SIG_FLAG,1); printf(" DSP-EOB flag set \n"); return 0; } int do_binary_init(dsp) int dsp; { static int dac_channel = 0; static int idac_set = 0; static float dac_set =0.0; static float I_ref = 0.7; /* set value for I_ref on CPD */ int line; /* calibration line number */ int cline; static int charge = 1; /* input charge number */ int i,j,k,kk; int num_runs; int theItem; static int nlinks =1; int countv=37; register int status; static int flag_val = 0 ; static int run_mode = 0; static int burst=0; int ans,vf; char fname [80]; float sys_dac[4]; static int ll_dac[4] ={0,0,0,0}; extern int verb_flag ; int cal_lines = 2; int link_dis,dis_enable; int chips = 2; static int countv_arr[7] = {0,20,37,53,68,88,104}; static int num_words_arr[7] = {0,6,10,14,18,23,27}; int num_rep = 999; int trig_yes_no; int mult; int yesno_str ; int ok = 1; float set_val; for(i=0; i<4; i++) { sys_dac[i]=0.0; } /* initialize DSP's according to binary_in.h dsp_min-dsp_max */ dsp_init(dsp_min,dsp_max); printf("\n dsp number -> "); scanf("%d",&dsp_num); dsp=dsp_num; printf("\n link number ->"); scanf("%d",&link_num); init_dsps(dsp_min,dsp_max,filnam); status= do_initialize(dsp_num); if(status != 0) printf("\n couldn't initialize DSP %d \n",dsp_num); printf("\n verbose flag off/on [0/1]:"); scanf("%d",&vf); verb_flag = vf; set_flag(dsp_num,6,vf) ; printf("\n Enter number of chips: "); scanf("%d", &chips ); countv = countv_arr[chips]; num_words = num_words_arr[chips]; do_set_counter_val (dsp_num,countv); run_mode = 0; /* DSP-EOB mode */ do_select_run_mode(dsp_num,run_mode) ; do_enable_readout(dsp_num); do_dis_enable_link(dsp_num,link_num,1); load_control_block (dsp_num,0,0,"TrigControl.dat") ; do_execute_control_block (dsp_num,0,100) ; printf("\n executing TrigControl.dat \n"); while(get_flag(dsp_num,DSP_STATE) == EXECUTING) loop_delay(20000); printf("\n VATT - float ->"); scanf("%f",&dac_set); do_set_dac(dsp_num,0,&dac_set) ; printf("\n VREF - float ->"); scanf("%f",&I_ref); do_set_dac(dsp_num,1,&I_ref) ; printf("\n THRESH (mV - integer) ->"); scanf("%f",&set_val); if(link_num < 2) { do_set_ll_dac(dsp_num,2,&set_val) ; } else { do_set_ll_dac(dsp_num,3,&set_val) ; } printf("\n number of events ->"); scanf("%d",&loops); printf("\n Enter RUN number -> "); scanf("%d",&run_no); hist_init(); for(i=0; i<128; i++) { for (k= 0;k<768; k++) { eff_array[k][i] = 0; /* Zero out the hits array */ } } return 0; } int do_binary_exit() { int j,id; id=150; for ( j = 0; j < 768; j++ ) /* loop over channels */ { atup[0] = 0.; atup[1] = (float) j; atup[2] = (float) eff_array[j][0]; hfn (id, atup[0]); } hist_out(); return 0; } int do_init_dsps(min, max) int min; int max; { int i; } int do_setup_dacs(dsp) int dsp; { int status; int i; float f; status = 0; return status; } int do_setup_links(int dsp) { int link, status; status = 0; return status; } int vme_init(min,max) int min; int max; { } print_all_status(dsp) int dsp; { m_dsp_status dsp_stat; m_dsp_status *dstat = &dsp_stat; m_generic get; m_generic *mg = &get; m_LL_status ll_stat; m_LL_status *ll; mg->ciw = GET_DSP_STATUS; mg->len = sizeof(m_generic) / sizeof(int32); mg->channel = 0; mg->dsp = dsp; if(send_mess((int32 *) mg) != SUCCESS) { printf("\nCan't send get dsp status message\n"); return 0; } if(m_wait(dsp) != SUCCESS) { printf("\nCan't get dsp stat message, timed out\n"); return 0; } message_base = (int *) dstat; if(get_mess(dsp) != SUCCESS) { printf("\nCan't get dsp stat\n"); return 0; } printf("\nDSP Status:\n"); printf("run_mode = %d\n", dstat->runmode); printf("ro_enabled = %d\n", dstat->ro_enabled); printf("tcc_connected = %d\n", dstat->tcc_connected); printf("tr_time = %d\n", dstat->tr_time); printf("t_addoff = %d\n", dstat->t_addoff); printf("trig_timer_val = %d\n", dstat->trig_timer_val); } int32 peek(dsp) int dsp; { if(io_base[dsp]) { if(io_base[dsp]->signals & (1 << EXPORT)) { return (io_base[dsp]->packet.message[0]); } } return 0; } int ld_control_block(dsp, blk_num) int dsp,blk_num; { return 0; } int do_exe_control_block(dsp, blk_num, num_rep) int dsp; int blk_num; int num_rep; { return 0; } /* BINARY readout code */ int do_binary_readout(dsp) int dsp; { do_trans_trgdata(dsp,link_num,2,0,num_words); return 0; } dsp_pause(time) int time; { struct itimerval timer; struct itimerval *tp = &timer; signal(SIGALRM, handle_sig); tp->it_interval.tv_sec = 0; tp->it_interval.tv_usec = 0; tp->it_value.tv_sec = 0; tp->it_value.tv_usec = time; setitimer(ITIMER_REAL, tp, (struct itimerval *) NULL); } void handle_sig() {} /* dsp_init */ dsp_init(int dsp_min, int dsp_max) { static int bases[6] = { DSP_BASE0, DSP_BASE1, DSP_BASE2, DSP_BASE3, DSP_BASE4, 0}; int err, i; if((dsp_min < 0) | (dsp_min > 4) | (dsp_max < dsp_min) | (dsp_max > 4)) { printf("Invalid DSP numbers, dsp_min = %d, dsp_max = %d\n", dsp_min, dsp_max); exit(-1); } for(err=0;err<6;err++) io_base[err] = 0; for(i=dsp_min;i<=dsp_max;i++) { if(err=RD13_VmeMap(bases[i], DSP_AM, DSP_SIZE, &io_base[i])) { printf("Error in VmeMap, status = %d\n", err); exit(-1); } } } loop_wait() { int i; /* printf(" loop_wait %d \n",ndelay); */ for (i=ndelay;i;i--); } loop_delay(int delayval) { volatile int i; for (i=delayval;i;i--); } dsp_end () { return; } /*********************/ /* START of v_com.c */ /*********************/ /* Still to be done: Fix abort code on vme side. */ /* Get a better user interface for message composing */ /* Test flag stuff */ /* Fix big_mess stuff */ /***********************************************************************/ int sys_set(int dest, int signal) /* sets a bit in signal word */ { extern dpr *io_base[]; int x = 1; if ((signal < 0) || (signal > NUM_FLAGS)) return(ENOSIG); io_base[dest]->signals |= (x << signal); return(SUCCESS); } /***********************************************************************/ int sys_clear(int dest, int signal) { extern dpr *io_base[]; int x = 1; if((signal < 0) || (signal > NUM_FLAGS)) return(ENOSIG); io_base[dest]->signals &= ~(x << signal); return(SUCCESS); } /***********************************************************************/ int sys_wait(int dest, int signal) /* wait a while, or timeout */ { unsigned long time; int val; for(time = (long) CLOCK(); (long) CLOCK() - time < MESS_TIMEOUT; ) { if((val = look(dest, signal)) == EABORT) return EABORT; if(val == ECONFLICT) continue; if(val) return SUCCESS; } return ETIMEOUT; } /***********************************************************************/ int sys_nwait(int dest, int signal) { unsigned long time; int val; for(time = (long) CLOCK(); (long) CLOCK() - time < MESS_TIMEOUT; ) { if((val = look(dest, signal)) == EABORT) return EABORT; if(val == ECONFLICT) continue; if(!val) return SUCCESS; } return ETIMEOUT; } /***********************************************************************/ void mess_error(int code, char *string) { printf("Binary Message error - "); switch(code) { case ETIMEOUT: printf("Transfer timeout:"); break; default: printf("Anonymous error"); } printf("%s \n", string); } /***********************************************************************/ /* replaced by macro at head of this file */ /*int */ /* look(int dest, int sig) */ /*{ */ /* int a[LOOKUPS]; */ /* int n; */ /* extern dpr *io_base[]; */ /* */ /* for(n = 0;n < LOOKUPS; n++) { */ /* a[n] = (io_base[dest]->signals) & (1 << sig); */ /* if(n != 0) { */ /* if(a[n] != a[n-1]) */ /* return ECONFLICT; */ /* } */ /* } */ /* if(a[0]) return(1); */ /* return(0); */ /*} */ /***********************************************************************/ /***********************************************************************/ int get_sigs( int dest ) { extern dpr *io_base[]; return io_base[dest]->signals; } /**********************************************************************/ int send_mess( int *pmess ) { int remain; int t, status; int *from, *to, dest, time; static int mess_id = 0; static int num_sent = 0; static int num_err = 0; static int iam = 0; extern dpr *io_base[]; m_generic *message; message = (m_generic *) pmess; dest = MDEST(message); remain = MSIZE(message); if(0) /* FIXME */ return EMESSINVAL; if(look(dest, EXPORT)) return ECONFLICT; sys_set(dest, IMPORT); if(look(dest, EXPORT)) return ECONFLICT; mess_id++; time = 0; DO_T_HEAD( dest ); from = (int *) message; to = io_base[dest]->packet.message; while( remain > MTU ) { copy(from, to, MTU); sys_set(dest, DAV); remain -= MTU; from += MTU; if((status = sys_wait(dest, ACK)) != SUCCESS) return status; sys_clear(dest, DAV); if((status = sys_nwait(dest, ACK)) != SUCCESS) return status; } copy(from, to, remain); to += remain; zero(to, (MTU - remain)); sys_set(dest, EOM); sys_set(dest, DAV); if((status = sys_wait(dest, ACK)) != SUCCESS) return status; sys_clear(dest, EOM); sys_clear(dest, IMPORT); sys_clear(dest, DAV); if((status = sys_nwait(dest, ACK)) != SUCCESS) return status; return(SUCCESS); } int get_mess( int dest ) { int *to, *from; int remain, status; extern int *message_base; int timestamp, mess_id; /* int maxtsize = 0x10000; */ /* FIXME */ int maxtsize = 400000; from = io_base[dest]->packet.message; to = message_base; if(!look( dest, EXPORT )) return ENOMESS; if((status = sys_wait( dest, DAV )) != SUCCESS ) return status; remain = TSIZE(dest); if(abs(remain) > maxtsize) return ETOOBIG; timestamp = TTIME( dest ); mess_id = TMESSID( dest ); while(remain > MTU) { copy( from, to, MTU ); sys_set( dest, ACK ); to += MTU; remain -= MTU; if((status = sys_nwait( dest, DAV )) != SUCCESS) return status; sys_clear( dest, ACK ); if((status = sys_wait( dest, DAV )) != SUCCESS) return status; } copy( from, to, remain ); sys_set( dest, ACK ); if((status = sys_nwait( dest, DAV )) != SUCCESS) return status; sys_clear( dest, ACK ); return SUCCESS; } void copy( int *from, int *to, int n ) { int c; if((!from) || (!to)) return; if(n == 0) return; for( c = n; c != 0; c--) *to++ = *from++; } void zero( int *to, int n) { int c; if((!to) || !(n > 0)) return; for( c = n; c != 0; c--) *to++ = 0; } int com_abort(int dest) { sys_set(dest, ABORT); sys_wait(dest, ACK); sys_nwait(dest, ACK); sys_clear(dest, ABORT); return(SUCCESS); } void com_aborted( int dest, int dir ) { sys_clear(dest, EOM); if(dir == EXPORT) { sys_clear(dest, EXPORT); sys_clear(dest, DAV); } else { sys_clear(dest, IMPORT); } sys_set(dest, ACK); /* Not too sure about this */ sys_clear(dest, ACK); } int get_flag( int dest, int flag ) { int val; if((dest > (NUM_CHAN - 1)) || (flag > (NUM_FLAGS - 1))) return ENOSIG; val = FLAG(dest, flag); return val; } int set_flag( int dest, int flag, int val ) { if((dest > (NUM_CHAN - 1)) || (flag > (NUM_FLAGS - 1))) return ENOSIG; FLAG(dest, flag) = val; } /***********************************************************************/ int message_status(void) { int stat = 0; int n; for(n = NUM_CHAN - 1; n >= 0; n--) { if( __check_mess(n) == 0) { stat <<= 1; continue; } stat <<= 1; stat += 1; } return stat; } int __check_mess(int dest) { extern dpr *io_base[]; if(io_base[dest]) { if(io_base[dest]->signals & (1 << EXPORT)) return 1; } return 0; } int check_mess(int dest) { int val; val = __check_mess(dest); return val; } int m_wait(int dest) { int err; err = sys_wait(dest, EXPORT); if(err == SUCCESS) return SUCCESS; if(err == ETIMEOUT) return ETIMEOUT; return ENOMESS; } int32 m_size(int dest) { if(!io_base[dest]) return 0; return(io_base[dest]->packet.message[1]); } int * dsp_base( int dsp ) { return (int *) io_base[dsp]; } void dsp_led( int dsp_no, int on ) /* turns red LED on DSP's VME card on or off */ { int i; i = get_port( dsp_no ); /* get theoretical current value in port */ i &= ~0x80; /* clear bit 7 = turn LED on */ if ( ! on ) i |= 0x80; /* set bit 7 = turn LED off */ set_port( dsp_no, i ); /* write new value to port */ } void interrupt_dsp( int dsp_no ) /* interrupts DSP */ { int i; i = get_port( dsp_no ); /* get theoretical current value in port */ i |= 0x2; /* set bit 1 */ set_port( dsp_no, i ); i &= ~0x2; /* clear bit 1 */ set_port( dsp_no, i ); i |= 0x2; /* set bit 1 */ set_port( dsp_no, i ); } int port_image[ NUM_CHAN ]; /* image of VME cards' host ports */ int get_port( int dsp_no ) /* returns image of port */ { return( port_image[ dsp_no ] ); /* return image of port */ } void set_port( int dsp_no, int value ) /* writes value to port */ { * ( dsp_base( dsp_no ) + PORT_OFFSET ) = value; /* write to hardware */ port_image[ dsp_no ] = value; /* write to image */ } /*********************/ /* END of v_com.c */ /*********************/ /***********************/ /* START of dsp_init.c */ /***********************/ /* Do not modify this file. Report bugs or desired changes to: Steve Pier University of California, Irvine pier@nucleus.ps.uci.edu 714-824-3162 */ /* dsp_init.c Host's DSP initialization code This file contains one function intended for direct use by the host software: int init_dsps( int dsp_min, int dsp_max, char* path ) -- initializes DSP's To initialize DSP's, the host should call init_dsps(), passing it the first DSP #, the last DSP #, and the path to the file containing the system code for these DSP's. init_dsps() attempts to complete the system download for each DSP, even if another DSP has caused an error. In this file, "port" refers to the port on the VME card that is writable by the VME host processor. This port is used to cause DSP reset or interrupt and to control the host's red LED on the VME card. See eboot.h for a description of the system file format. See eboot.h for a description of the DSP bootstrap process. */ /* functions in this file */ int init_dsps( int dsp_min, int dsp_max, char* path ); /* reset and initialize DSP's, send system */ void send_system ( int dsp_min, int dsp_max, char *path ); /* download system to DSP's */ void depart(); /* close files, etc., before leaving send_system() */ void check_final( int dsp_no ); /* check if download completed ok */ void prep_dsp( int dsp_no ); /* prepare DSP for system download */ int timed_wait( u_int32* var1, u_int32 var2 ); /* wait until *var1 == var2 or timeout */ int prep_file( char *path ); /* return 0 if everything went ok, else -1 */ void send_page( int dsp_no, u_int32 *page_data ); /* send page of system from host RAM to DSP */ void log_timeout( int dsp_no, char *err_mess ); /* log timeout error */ int get_page( u_int32 *page ); /* get page of system file into host's RAM */ int check_word_0( u_int32 w ); /* check that word 0 of system file is 0x20 */ int check_addr( u_int32 w ); /* check that address in system file is valid */ int check_blck_size( u_int32 w ); /* check that block size in system file is valid */ int get_word( u_int32 *word ); /* return GW_ERR, GW_EOF, or GW_OK */ void log_err( int err_code, char *err_mess ); /* print out errors */ void log_boot( int dsp_no ); /* print out contents of boot structure */ void init_dpram( int dsp_no ); /* zero all of DPRAM except host_state */ void reset_dsp( int dsp_no ); /* reset DSP and perform minimal initializations */ /* FORM_bpt(dsp_no) forms a pointer to the specified DSP's boot structure */ #define FORM_bpt(dsp_no) \ struct boot_dpr *bpt; \ bpt = (struct boot_dpr*) dsp_base( dsp_no ); extern int dsp_status[]; /* download status of each DSP */ int down_errs; /* count of errors encountered during download */ int sysf_state; /* host's state w.r.t. reading the system file */ long sysf_words; /* number of words read from the system file */ long sysf_blk_size; /* size of current block in system file */ long sysf_blk_index; /* index in current block in system file */ FILE* fpt; /* pointer to system file */ #define SS_START (0) /* state of system file */ #define SS_WORD_0 (1) #define SS_WORD_1 (2) #define SS_BLK_SIZE (3) #define SS_BLK_DEST (4) #define SS_BLK_DATA (5) #define SS_DATA (6) #define SS_END (7) /* these values are used for error checking */ #define MAX_SYSTEM_SIZE (250000) /* max system size in u_int32's */ #define MAX_SYSTEM_BLCK (250000) /* max size of block in system file */ #define MIN_SYSTEM_ADDR (0x809800) /* min address of block in system file */ #define MAX_SYSTEM_ADDR (0x93ffff) /* max address of block in system file */ /* reset and initialize the specified DSP's, then download system */ /* returns a count of errors encountered */ /* dsp_status contains status/errors for individual DSP's */ int init_dsps( int dsp_min, int dsp_max, char* path ) { int dsp_no; long t_zero; if ( dsp_min < 0 || /* check for valid parameters */ dsp_max >= NUM_CHAN || dsp_min > dsp_max ) { LOG_ERR( 10, "init_dsps(): invalid dsp_min or dsp_max" ); return( down_errs ); /* return with one error */ } for ( dsp_no = dsp_min; dsp_no <= dsp_max; ++ dsp_no ) /* init each DSP's status */ dsp_status[ dsp_no ] = DOWN_INCOMPLETE; /* download ok, but not done */ for ( dsp_no = dsp_min; dsp_no <= dsp_max; ++ dsp_no ) /* reset each DSP */ reset_dsp( dsp_no ); /* wait while DSP's reset */ for ( t_zero = (long) CLOCK(); (long)CLOCK() - t_zero <= DSP_RES_PERIOD; ); send_system( dsp_min, dsp_max, path ); return( down_errs ); } /* read system from file and send it to DSP's */ void send_system ( int dsp_min, int dsp_max, char *path ) { int i, c; long insure; u_int32 page_data[ PAGE_SIZE ]; /* or use malloc() (use free() in depart()) */ down_errs = 0; sysf_state = SS_START; /* state = at start of system file */ sysf_words = 0; /* number of words read = 0 */ fpt = NULL; /* open system file, remove header, etc. */ if ( prep_file( path ) ) depart(); /* get each DSP's attention, */ for ( i = dsp_min; i <= dsp_max; ++ i ) prep_dsp( i ); /* 'insure' should never cause the exit from this loop */ for ( insure = MAX_SYSTEM_SIZE; insure > 0; insure -= PAGE_SIZE ) { if ( sysf_state == SS_END ) break; /* if end of system file */ if ( get_page( page_data ) ) /* get page of file */ depart(); /* return if error */ /* try to send page to each DSP that is still ok */ for ( i = dsp_min; i <= dsp_max; ++ i ) { if ( dsp_status[ i ] == DOWN_INCOMPLETE ) send_page( i, page_data ); } /* continue while any DSP's download is incomplete */ for ( i = dsp_min; i <= dsp_max; ++ i ) { if ( dsp_status[ i ] == DOWN_INCOMPLETE ) break; } if ( i > dsp_max ) break; /* exit loop if no DSP is OK */ } if ( insure <= 0 ) { /* this should never happen */ LOG_ERR( 20, "send_system(): MAX_SYSTEM_SIZE exceeded" ); depart(); } for ( i = dsp_min; i <= dsp_max; ++ i ) { check_final( i ); /* do final check of dsp */ } depart(); } void depart() { if ( fpt != NULL ) fclose( fpt ); return; } void check_final( int dsp_no ) /* check if download completed ok */ { FORM_bpt( dsp_no ); /* form pointer to boot structure */ if ( dsp_status[ dsp_no ] != DOWN_INCOMPLETE ) /* if an error is already flagged */ return; /* then don't change it */ /* check for final DBS_DOWNLOAD_OK, watch for timeout */ if ( timed_wait( &bpt->dsp_bstate, (u_int32) DBS_DOWNLOAD_OK ) ) { log_timeout( dsp_no , "check_final(): DSP timed out after last page was downloaded" ); return; } if ( bpt->words_read != sysf_words ) { LOG_ERR( 30, "check_final(): DSP's word count does not agree with host's" ); dsp_status[ dsp_no ] = DOWN_ERROR; return; } bpt->host_bstate = HBS_IDLE; dsp_status[ dsp_no ] = DOWN_DONE; /* download was successful */ return; } /* make sure DSP is ready for download */ /* any errors are returned in dsp_status[ dsp_no ] */ void prep_dsp( int dsp_no ) { FORM_bpt( dsp_no ); /* form pointer to boot structure */ /* wait until dsp_state == DBS_READY */ /* abort if timeout */ if ( timed_wait( &bpt->dsp_bstate, (u_int32) DBS_READY ) ) { log_timeout( dsp_no, "prep_dsp(): DSP timed out during preparation for download" ); return; } /* *** check here for OK DSP memory test, etc. *** */ bpt->host_bstate = HBS_READY; /* wait until dsp_state == DBS_DOWNLOADING */ /* abort if timeout */ if ( timed_wait( &bpt->dsp_bstate, (u_int32) DBS_DOWNLOADING ) ) { log_timeout( dsp_no, "prep_dsp(): DSP timed out before entering DBS_DOWNLOADING state" ); return; } return; } /* wait until *var1 == var2, but do not wait beyond TIMEOUT_PERIOD */ /* return -1 if timeout, else 0 */ int timed_wait( u_int32* var1, u_int32 var2 ) { unsigned long t_zero; for ( t_zero = (long) CLOCK(); (long)CLOCK() - t_zero <= TIMEOUT_PERIOD; ) { if ( *var1 == var2 ) if ( *var1 == var2 ) /* make sure value is really there */ if ( *var1 == var2 ) return( 0 ); /* success */ } return( -1 ); /* signal timeout */ } /* See 'Format of System File' in eboot.h */ /* prep system code file for page reads */ int prep_file( char *path ) /* return 0 if everything went ok, else -1 */ { fpt = fopen ( path, "r" ); /* open file */ if ( fpt == NULL ) { LOG_ERR( 40, "prep_file(): could not open DSP system file" ); return( -1 ); } if ( getc( fpt ) != 0x02 ) { /* get rid of first character (ctrl-B) */ LOG_ERR( 50, "prep_file(): unexpected first character of DSP system file" ); return( -1 ); } sysf_state = SS_WORD_0; /* system file state: at word 0 */ return( 0 ); /* no errors */ } /* attempt to pass data to DSP specified by dsp_no */ /* return any error in dsp_status[ dsp_no ] */ void send_page( int dsp_no, u_int32 *page_data ) { int i; FORM_bpt( dsp_no ); /* form pointer to boot structure */ if ( bpt->dsp_bstate != DBS_DOWNLOADING ) { dsp_status[ dsp_no ] = DOWN_ERROR; LOG_ERR( 60, "send_page(): DSP aborted download" ); LOG_BOOT( dsp_no ); /* print out boot structure for DSP */ return; } /* wait until req == HAND_HI, abort if timeout */ if ( timed_wait( &bpt->req, (u_int32) HAND_HI ) ) { log_timeout( dsp_no, "send_page(): DSP timed out before activating req" ); return; } for (i = 0; i < PAGE_SIZE; ++ i ) /* move page to DPRAM */ bpt->page[ i ] = page_data[ i ]; for (i = 0; i < PAGE_SIZE; ++ i ) /* confirm that it made it */ if ( bpt->page[ i ] != page_data[ i ] ) break; if ( i < PAGE_SIZE ) { dsp_status[ dsp_no ] = DOWN_ERROR; LOG_ERR( 70, "send_page(): page data in DPRAM is corrupt" ); LOG_BOOT( dsp_no ); /* print out boot structure for DSP */ return; } bpt->ack = HAND_HI; /* complete handshake */ /* wait until req == HAND_LO, abort if timeout */ if ( timed_wait( &bpt->req, (u_int32) HAND_LO ) ) { log_timeout( dsp_no, "send_page(): DSP timed out before deactivating req" ); return; } bpt->ack = HAND_LO; return; } void log_timeout( int dsp_no, char *err_mess ) /* log timeout error */ { dsp_status[ dsp_no ] = DOWN_TIMEOUT; LOG_ERR( 80, err_mess ); /* log error, forward err_mess */ LOG_BOOT( dsp_no ); /* print out boot structure for DSP */ return; } #define GW_ERR 99 /* get_word() error */ #define GW_EOF -1 /* get_word() end of file */ #define GW_OK 0 /* get_word() word is ok */ /* get page from system file */ /* return -1 if initial EOF or other error, else 0 */ int get_page( u_int32 *page ) { int i, gw_code; u_int32 w; /* current word from system file */ for ( i = 0; i < PAGE_SIZE; ++ i ) { if ( sysf_state == SS_END ) break; /* get no more words */ gw_code = get_word( &w ); /* get_word() reports its own errors */ if ( gw_code != GW_OK ) return( -1 ); /* flag error */ page[ i ] = w; /* place word in page buffer */ ++ sysf_words; /* count words read from system file */ switch ( sysf_state ) { /* trace system file to help find errors */ case SS_WORD_0: if ( check_word_0( w ) ) return( -1 ); sysf_state = SS_WORD_1; break; /* next word: word 1 */ case SS_WORD_1: /* word 1 is ignored */ sysf_state = SS_BLK_SIZE; break; /* next word: block size */ case SS_BLK_SIZE: if ( check_blck_size( w ) ) return( -1 ); sysf_blk_size = w; /* set up for block */ sysf_blk_index = 0; if ( w == 0 ) sysf_state = SS_END; /* size of 0 == no more blocks */ else sysf_state = SS_BLK_DEST; /* next word: dest */ break; case SS_BLK_DEST: if ( check_addr( w ) ) return( -1 ); sysf_state = SS_BLK_DATA; break; /* next words: data */ case SS_BLK_DATA: ++ sysf_blk_index; /* count data words */ if ( sysf_blk_index == sysf_blk_size ) sysf_state = SS_BLK_SIZE; /* start another block */ break; case SS_END: /* should never happen */ LOG_ERR( 90, "get_page(): page read attempted after final block" ); break; } } if ( i == 0 ) { /* SS_END not allowed on first word */ LOG_ERR( 100, "get_page(): attempt to read beyond end of system file" ); return( -1 ); } return( 0 ); } int check_word_0( u_int32 w ) { if ( w != 0x20 ) { LOG_ERR( 110, "check_word_0(): first word of system file is not 0x20" ); return( -1 ); } return( 0 ); /* no error */ } int check_addr( u_int32 w ) { if ( w < MIN_SYSTEM_ADDR || w > MAX_SYSTEM_ADDR ) { LOG_ERR( 120, "check_addr(): illegal destination address in system file" ); return( -1 ); } return( 0 ); /* no error */ } int check_blck_size( u_int32 w ) { if ( w > MAX_SYSTEM_BLCK ) { LOG_ERR( 130, "check_blck_size(): illegal block size in system file" ); return( -1 ); } return( 0 ); /* no error */ } int get_word( u_int32 *word ) /* return GW_ERR, GW_EOF, or GW_OK */ { int i, f_err; unsigned u; u_int32 i32; *word = 0xdeadbeef; /* this value is returned in *word if error */ for ( i = 0, i32 = 0; i < 4; ++ i ) { /* read four bytes */ f_err = fscanf( fpt, "%2x", &u ); /* read hex byte, skip white space */ if ( f_err != 1 ) break; /* one value should be read, else problem */ if ( u > 255 ) { /* this should never happen */ LOG_ERR( 140, "get_word(): hex value in system file is too large" ); break; } i32 = (i32 << 8 ) + u; /* bytes are read from file MSB first */ } if ( i == 4 ) { *word = i32; return( GW_OK ); } /* all went well */ if ( f_err == EOF ) { /* EOF not expected */ LOG_ERR( 150, "get_word(): unexpected EOF in system file" ); return( GW_EOF ); } LOG_ERR( 160, "get_word(): error while reading system file" ); return( GW_ERR ); } void log_err( int err_code, char *err_mess ) /* print out errors */ { ++ down_errs; if ( down_errs > MAX_ERR_LOG ) return; /* ignore error if too many */ printf( "\n" ); printf( "\nDownload error #%d -->%s.", err_code, err_mess ); printf( "\nSystem file state: %d, words read so far: %ld.", sysf_state, sysf_words ); if ( down_errs == MAX_ERR_LOG ) printf( "\n%d download errors: no more will be logged.", down_errs ); return; } void log_boot( int dsp_no ) /* print out contents of boot structure */ { FORM_bpt( dsp_no ); /* form pointer to boot structure */ dsp_led( dsp_no, 1 ); /* turns red LED on DSP's VME card on */ printf( "\n" ); printf( "\nBoot structure for DSP #%d:", dsp_no ); printf( "\n host_bstate: %#10lx", (unsigned long) bpt->host_bstate ); printf( "\n boots: %10ld", (unsigned long) bpt->boots ); printf( "\n rom_rev: %10ld", (unsigned long) bpt->rom_rev ); printf( "\n dip_switches: %#10lx", (unsigned long) bpt->dip_switches); printf( "\n dsp_bstate: %#10lx", (unsigned long) bpt->dsp_bstate ); printf( "\n req: %#10lx", (unsigned long) bpt->req ); printf( "\n ack: %#10lx", (unsigned long) bpt->ack ); printf( "\n lo_mem %#10lx", (unsigned long) bpt->lo_mem ); printf( "\n hi_mem %#10lx", (unsigned long) bpt->hi_mem ); printf( "\n words_read %10ld", (unsigned long) bpt->words_read ); printf( "\n ram_loops %10ld", (unsigned long) bpt->ram_loops ); printf( "\n ram_errors %10ld", (unsigned long) bpt->ram_errors ); return; } void init_dpram( int dsp_no ) /* zero all of DPRAM except host_state */ { int i; u_int32 *bpt; bpt = (u_int32*) dsp_base( dsp_no ); /* pointer to base of DSP's dual-port RAM */ for ( i = 1; i < DPRAM_SIZE; ++ i ) /* do not clear host_bstate ( bpt[ 0 ] ) */ bpt[ i ] = 0; } void reset_dsp( int dsp_no ) /* reset DSP and perform minimal initializations */ { FORM_bpt( dsp_no ); /* form pointer to boot structure */ /*** --> start critical region (ideally: disable interrupts) ***/ bpt->host_bstate = HBS_RESETTING; /* tell DSP to wait after it is reset */ set_port( dsp_no, 0xff ); /* reset DSP by toggling HRESET\ line on VME card */ set_port( dsp_no, 0x7e ); /* ( this also clears the interrupt to the DSP */ set_port( dsp_no, 0xff ); /* and turns off the host's LED ) */ bpt->host_bstate = HBS_RESETTING; /* just in case DSP wrote host_bstate before being reset */ /*** <-- end critical region (ideally: re-enable interrupts) ***/ init_dpram( dsp_no ); /* clear DPRAM to 0 (except host_bstate) */ bpt->dsp_bstate = DBS_RESETTING; bpt->host_bstate = HBS_IDLE; /* allow DSP to proceed with RAM test */ return; } /******* functions below should be moved from init.c to one of Joe's files for communication functions *************/ #if 0 void dsp_led( int dsp_no, int on ) /* turns red LED on DSP's VME card on or off */ { int i; i = get_port( dsp_no ); /* get theoretical current value in port */ i &= ~0x80; /* clear bit 7 = turn LED on */ if ( ! on ) i |= 0x80; /* set bit 7 = turn LED off */ set_port( dsp_no, i ); /* write new value to port */ } void interrupt_dsp( int dsp_no ) /* interrupts DSP */ { int i; i = get_port( dsp_no ); /* get theoretical current value in port */ i |= 0x2; /* set bit 1 */ set_port( dsp_no, i ); i &= ~0x2; /* clear bit 1 */ set_port( dsp_no, i ); i |= 0x2; /* set bit 1 */ set_port( dsp_no, i ); } int port_image[ NUM_CHAN ]; /* image of VME cards' host ports */ int get_port( int dsp_no ) /* returns image of port */ { return( port_image[ dsp_no ] ); /* return image of port */ } void set_port( int dsp_no, int value ) /* writes value to port */ { * ( dsp_base( dsp_no ) + 2048 ) = value; /* write to hardware */ port_image[ dsp_no ] = value; /* write to image */ } #endif /***********************/ /* END of dsp_init.c */ /***********************/ /**************************/ /* START of dsp_sysmess.c */ /**************************/ int do_initialize(int dsp_no) { int status; m_init message; m_init *mp = &message; m_response resp; mp->ciw = INITIALIZE; mp->dsp = dsp_no; mp->channel = 0; mp->len = sizeof(m_generic) / sizeof(int32); if((status = send_mess((int32 *) mp)) != SUCCESS) { printf("\nError in Initialization send_mess\n"); return -1; } if(get_flag(dsp_no, VERBOSE_FLAG)) { if(m_wait(dsp_no ) == SUCCESS) { message_base = (int32 *) &resp; do_get_general_reply(dsp_no); } } return 0; } int do_set_dac(int dsp_no, int dac_channel,float *dac_set) { extern verb_flag ; m_set_dac message; m_set_dac *mp = &message; int dac_set_int ; int status, err; err = 0; dac_set_int = nint(4095.0* *dac_set/2.5) ; /* if(dac_channel == 1)dac_set_int = dac_set_int/2;*/ /* printf("\nDAC channel %d is set to %f Volts \n",dac_channel,*dac_set) ; */ mp->ciw = SET_DAC; mp->dsp = dsp_no; mp->channel = 0; mp->len = 2 + (sizeof(m_generic) / sizeof(int32)) ; mp->dac = dac_channel ; /* dac_channel */ mp->voltage = dac_set_int ; /* dac_set_int */ if((status = send_mess((int32 *) mp)) != SUCCESS) { printf("Error in SET_DAC send_mess"); err = -1; } if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } return err; } int do_enable_readout(int dsp_no) { extern verb_flag; int status; m_enable_read message; m_enable_read *mp = &message; mp->ciw = ENABLE_READOUT; mp->dsp = dsp_no; mp->channel = 0; mp->len = sizeof(m_generic) / sizeof(int32); if((status = send_mess((int32 *) mp)) != SUCCESS) { printf("Error in ENABLE_READOUT send_mess"); return -1; } if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } return 0; } int do_dis_enable_link(int dsp_no, int link_num, int linkenable) { extern verb_flag; int status, err; m_dis_enable_link message; m_dis_enable_link *mp = &message; err = 0; mp->ciw = DIS_ENABLE_LINK; mp->dsp = dsp_no; mp->channel = link_num; mp->link_enable = linkenable; mp->len = sizeof(m_dis_enable_link) / sizeof(int32); /* printf("\nLink %d is dis/enabled (0/1) %d\n", link_num, linkenable); */ if((status = send_mess((int32 *) mp)) != SUCCESS) { printf("Error in DIS_ENABLE_LINK send_mess %d \n",status); err = -1; } if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } return err; } int do_get_status(int dsp_no) { extern verbose_flag; extern int32 *message_base; m_generic message; m_generic *mp = &message; m_LL_status *rm = (m_LL_status *) message_base; m_dsp_status *rm2 = (m_dsp_status *) message_base; int i, status; mp->ciw = GET_LL_STATUS; mp->dsp = dsp_no; mp->channel = 0; mp->len = (sizeof(m_generic) / sizeof(int32)); printf("\nRequesting LL Status \n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in GET_LL_STATUS send_mess"); if((status = m_wait(dsp_no)) != SUCCESS) printf("m_wait error: error = %d\n", status); while((status = get_mess(dsp_no )) == ECONFLICT) { printf("conflict sending message, trying again\n"); } if(status != SUCCESS) { printf("Error in GET LL Status \n"); printf("status is: %d \n",status); } else { if(rm->ciw==LL_STATUS) { for(i=0; i<4; i++) { printf(" LL DAC %d = %f V\n",i,((float)rm->LL_dac_setting[i]*2.5/4095.)); } printf(" Strobe Setting %d\n",rm->LL_strobe_setting); printf(" Counter Setting %d\n",rm->LL_counter_setting); for(i=0; i<4; i++) { printf(" Link %d dis/enable [0/1]%d\n",i,rm->LL_link_enabling[i]); } } } mp->ciw = GET_DSP_STATUS; mp->dsp = dsp_no; mp->channel = 0; mp->len = (sizeof(m_generic) / sizeof(int32)); printf("\nRequesting DSP Status \n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in GET_DSP_STATUS send_mess"); if((status = m_wait(dsp_no)) != SUCCESS) printf("m_wait error: error = %d\n", status); while((status = get_mess(dsp_no )) == ECONFLICT) { printf("conflict sending message, trying again\n"); } if(status != SUCCESS) { printf("Error in GET DSP Status \n"); printf("status is: %d \n",status); } else { if(rm->ciw==DSP_STATUS) { for(i=0; i<4; i++) { printf(" SYSTEM DAC %d = %f V\n",i,((float)rm2->dac_setting[i]*2.5/4095.)); } } } return; } int do_load_data(int dsp_no, int format, char *DB_name) { m_load_data message; m_load_data *mp = &message; extern verb_flag; int32 blkdata[2048] ; int num_rep ; /* Num of repititions */ int32 value ; int i ,j ; int status; FILE *ifp; for(i = 0; i <= 2047; i++) blkdata[i] = 0 ; /* zero the array */ ifp = fopen(DB_name,"r"); i = 0 ; while(fscanf(ifp,"%d%lx \n",&num_rep, &value) ==2) { for(j = 1; j <= num_rep ; j++) { blkdata[i] = value ; i++ ; } } mp->ciw = LOAD_DATA; mp->dsp = dsp_no; mp->channel = 0; mp->len = 2049 + (sizeof(m_generic) / sizeof(int32)); mp->data_format = format ; for(i = 0; i <=2047; i++) mp->data_word[i] = blkdata[i] ; printf("Current First Data word is: %lx \n", blkdata[1]) ; fclose(ifp); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in Load_Data send_mess"); if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } } int do_disable_readout(int dsp_no) { extern verb_flag; int status; m_disable_read message; m_disable_read *mp = &message; mp->ciw = DISABLE_READOUT; mp->dsp = dsp_no; mp->channel = 0; mp->len = sizeof(m_generic) / sizeof(int32); printf("\nThe Readout is now DISABLED \n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in DISABLE_READOUT send_mess %d \n",status ); if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } } do_trans_trgdata(int dsp_no,int link_num,int format,int step,int num_words) { extern int32 *message_base; m_transfer_data message; m_transfer_data *mp = &message; m_echo *rm = (m_echo *) message_base; int i,j,k,l,m,chan,hid,firstword; int status; int link10 =0; int ts; extern verb_flag ; /* calculation for decoding */ static int head_bits = 25; /* bit 0 - 25 */ static int cmin[6] = {25,162,299,436,573,710} ; static int cmax[6] = {154,291,428,565,702,839} ; /* step =137 (128 + 9 extra bits) */ int idn; int ich; /* Check SOB here to see if things are screwed up */ if(get_flag(dsp_no, SOB_SIG_FLAG) != 1) { printf("\nSOB NOT SET IN READOUT OF DSP %d. VERY BAD!!\n", dsp_no); } if(set_flag(dsp_no, SOB_SIG_FLAG, 0) == ECONFLICT) { if(set_flag(dsp_no, SOB_SIG_FLAG, 0) == ECONFLICT) { printf("Can't clear SOB. set_flag returned ECONFLICT"); } } if(set_flag(dsp_no, EOB_SIG_FLAG, 1) == ECONFLICT) { if(set_flag(dsp_no, EOB_SIG_FLAG, 1) == ECONFLICT) { printf("Can't clear SOB. set_flag returned ECONFLICT"); } } mp->ciw = TRANSFER_DATA; mp->dsp = dsp_no; mp->channel = link_num; mp->len = 1 + (sizeof(m_generic) / sizeof(int32)); mp->data_format = format; printf("\nRequesting Data Transfer. \n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in TRANSFER_DATA send_mess"); /* now get the data back. If format is neg then data summary */ if((status = m_wait(dsp_no)) != SUCCESS) printf("m_wait error: error = %d\n", status); while((status = get_mess(dsp_no )) == ECONFLICT) { printf("conflict sending message, trying again\n"); } if(status != SUCCESS) { printf("Error in GET tranfer Data1.\n"); printf("status is: %d \n",status); } else { printf("CIW is: %ld \n",rm->ciw); printf("link number %ld\n",rm->channel); printf("Num data words %ld\n",rm->len); printf("Data retrieved Format = %ld\n",rm->data[0]) ; if(verb_flag != 0) { for(i = 1; i <= (rm->len - HEADLEN -1 ) ; i++) printf("Data Received %lx\n",rm->data[i]) ; } } if(step==-1) return 0; /* histogram the returned data */ printf(" histograms fill \n"); firstword = 1 ; if(rm->len > 12) { /* len-12/num_words to be modified by the number of words/eve for 5 chips is 23 ? */ for ( i = 0; i < (((rm->len-12)/num_words) ); i++ ) /* Loop over Number of events/FIFO */ { /* printf(" HAC header %x \n",rm->data[firstword]);*/ if( (rm->data[firstword] & 0xff000000) == 0xe8000000 ) { m = 0; for ( k = firstword; k < firstword + num_words ; k++ ) /* Loop Number words/event */ { for ( l= 0 ; l < 32; l++ ) /* bits/word */ { if((((rm->data[k] << l) & 0x80000000) != 0) ) { if( m > cmin[0] && m < cmax[0]) /* First Chip */ { chan = m - head_bits-1; eff_array[chan][step]++; idn=50011+link10; hf (idn, (float) (chan), 0.0, 1.0); } if( m > cmin[1] && m < cmax[1]) /* Second Chip */ { chan = m - cmin[1] -1; eff_array[chan+128][step]++; idn=50012+link10; hf (idn, (float) (chan+128), 0.0, 1.0); } if( m > cmin[2] && m < cmax[2]) /* Third Chip */ { chan = m - cmin[2] -1;; ich = (chan+256)%2; eff_array[chan+256][step]++ ; idn=50013+link10; hf (idn, (float) (chan+256), 0.0, 1.0); } if( m > cmin[3] && m < cmax[3]) /* foorth chip */ { chan = m - cmin[3] -11; ich = (chan+384)%2; eff_array[chan+384][step]++ ; idn=50014+link10; hf (idn, (float) (chan+384), 0.0, 1.0); } if( m > cmin[4] && m < cmax[4]) /* fifth chip */ { chan = m - cmin[4] -1; ich = (chan+512)%2; eff_array[chan+512][step]++ ; idn=50015+link10; hf (idn, (float) (chan+512), 0.0, 1.0); } if( m > cmin[5] && m < cmax[5]) /* sixth chip */ { chan = m - cmin[5] -1; ich = (chan+640)%2; eff_array[chan+640][step]++ ; idn=50016+link10; hf (idn, (float) (chan+640), 0.0, 1.0); } } m++ ; } } } firstword = firstword +num_words ; } } if(set_flag(dsp_no, EOB_SIG_FLAG, 0) == ECONFLICT) { if(set_flag(dsp_no, SOB_SIG_FLAG, 0) == ECONFLICT) { printf("Can't clear SOB. set_flag returned ECONFLICT"); } } if(set_flag(dsp_no, SOB_SIG_FLAG, 1) == ECONFLICT) { if(set_flag(dsp_no, SOB_SIG_FLAG, 0) == ECONFLICT) { printf("Can't clear SOB. set_flag returned ECONFLICT"); } } return 0; } int decode(format,num_chip,num_links,link_num) { /* this is the pointer from the DSP message */ extern int32 *message_base; m_echo *rm = (m_echo *) message_base; int firstword=1; int num_words = 27; /* 27 words/event/link if 6 chips */ int i,j,k,l,m,chan; int format,num_chip,num_links,link_num,plane; /* here declare array (matrix) of hits ***********************/ /* calculation for decoding */ static int head_bits = 25; /* bit 0 - 25 */ int cmin; int chipcount=0; int cstart = 25; /* bit step =137 (128 + 9 extra bits) */ if(rm->len > 12) { switch(format) /* switch on format */ { case 1: /* data format 1 -- one event all links */ for ( k =3 ; k < (rm->len-12) ; k++ ) /* Loop Number words/event */ { for ( j = 0; j < num_links; k++) /* Loop over number of links*/ { plane=j; chipcount=0; cmin=cstart; m =26; while(chipcount< num_chip) { for ( l= 0 ; l < 32; l++ ) /* bits/word */ { if(( ((rm->data[k] << l) & 0x80000000) != 0) ) /* depending on the p-type or n-type (1=hit or 0=hit) */ { if( m > cmin & m < cmin+129) { chan = m - cmin -1 + (128 *chipcount); /* matrix[chan][plane]=1; */ } else { chipcount++; cmin+= 137; } } m++ ; } } } } break; case 2: /* data format =2 -- all events one links */ plane=link_num; for ( i = 0; i < (((rm->len-12)/num_words) -1); i++ ) /* Loop over Number of events/FIFO */ { m = 26; cmin=cstart; for ( k = firstword; k < firstword + num_words ; k++ ) /* Loop Number words/event */ { for ( l= 0 ; l < 32; l++ ) /* bits/word */ { if(( ((rm->data[k] << l) & 0x80000000) != 0) ) /* depending on the p-type or n-type (1=hit or 0=hit) */ { if( m > cmin & m < cmin+129) { chan = m - cmin -1 + (128 *chipcount); /* matrix[k][chan][plane]=1; */ } else { chipcount++; cmin+= 137; } } m++ ; } } firstword = firstword +num_words ; } break; } } } int do_get_general_reply(int dsp_no) { extern int32 *message_base; m_echo *rm; int i; int status; message_base = MessArea; rm = (m_echo *) message_base; while(check_mess(dsp_no )) { if((status = get_mess(dsp_no )) != SUCCESS) { printf("Error in GET_GENERAL_REPLY, Perhaps message already received?\n"); } else { if(rm->ciw==RESPONSE) { /* printf("\nResponse Code = %ld\n",rm->data[0]); */ } else { /* printf("CIW is: %ld\n",rm->ciw); printf("length: %ld\n",rm->len); for(i = 0 ; i < (rm->len - HEADLEN) ;i++) printf("Parameter is: %ld\n",rm->data[i]); */ } } } } int do_calibrate(int dsp_no, int n_evts,int det_readout, int control_blk) { extern verbose_flag; m_calib message; m_calib *mp = &message; int status; mp->ciw = CALIBRATE; mp->dsp = dsp_no; mp->channel = 0; mp->len = 3 + (sizeof(m_generic) / sizeof(int32)); mp->acqui_events = n_evts; mp->take_data = det_readout; mp->user_par = control_blk; printf("\nRequesting Calibration.\n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in CALIBRATE send_mess"); if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } } int do_load_graycode(int dsp_no) { extern verb_flag; m_load_gray message; m_load_gray *mp = &message; int status; mp->ciw = LOAD_GRAYCODE_PATTERN; mp->dsp = dsp_no; mp->channel = 0; mp->len = 256 + (sizeof(m_generic) / sizeof(int32)); mp->graycode[0]=0 ; /* fix this tim */ printf("\nLoading Graycode Pattern\n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in LOAD_GRAYCODE send_mess"); if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } } void do_load_code( int dsp_min, int dsp_max, char *filnam) /* from Joe */ { dsp_init(dsp_min,dsp_max ) ; init_dsps( dsp_min, dsp_max, filnam ); } int do_select_run_mode(int dsp_no, int run_mode) { m_sel_run message; m_sel_run *mp = &message; int status; mp->ciw = SELECT_RUN_MODE; mp->dsp = dsp_no; mp->channel = 0; mp->len = 1 + (sizeof(m_generic) / sizeof(int32)); mp->runmode = run_mode; /* printf("\nRun Mode %d Selected\n",run_mode); */ if((status = send_mess((int32 *) mp)) != SUCCESS) { printf("Error in SELECT_RUN_MODE send_mess"); return -1; } if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } return 0; } int do_select_trigger_mode(int dsp_no, int trig_mode[]) { extern verb_flag; m_sel_trig message; m_sel_trig *mp = &message; int status; mp->ciw = SELECT_TRIGGER_MODE; mp->dsp = dsp_no; mp->channel = 0; mp->len = 4 + (sizeof(m_generic) / sizeof(int32)); mp->trignum[0] = trig_mode[0]; mp->trignum[1] = trig_mode[1]; mp->trignum[2] = trig_mode[2]; mp->trignum[3] = trig_mode[3]; printf("\nSetting the trigger modes \n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in SELECT_TRIGGER_MODE send_mess"); if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } } int do_select_align_delay(int dsp_no, int fifo_delay[]) { extern verb_flag; m_align_delay message; m_align_delay *mp = &message; int status; mp->ciw = SELECT_ALIGN_DELAY; mp->dsp = dsp_no; mp->channel = 0; mp->len = 2 + (sizeof(m_generic) / sizeof(int32)); mp->delay1 = fifo_delay[0]; mp->delay2 = fifo_delay[1]; printf("\nSetting the alignment delays\n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in SELECT_ALIGN_DELAY send_mess"); if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } } int do_select_time_param(int dsp_no, int time_param[]) { extern verb_flag; m_sel_time message; m_sel_time *mp = &message; int status; mp->ciw = SELECT_TIME_PARAM; mp->dsp = dsp_no; mp->channel = 0; mp->len = 3 + (sizeof(m_generic) / sizeof(int32)); mp->tr_time = time_param[0]; mp->rt_rtout = time_param[1]; mp->t_addoff = time_param[2]; printf("\nSetting the time parameters\n"); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in SELECT_TIME_PARAM send_mess"); if(verb_flag != 0) { m_wait(dsp_no ); do_get_general_reply(dsp_no); } } /***********************************************************************/ /***********************/ /* END of dsp_sysmess.c */ /**************************/ /***************************/ /* START of Silicon_user.c */ /***************************/ int do_set_ll_dac(int dsp_no, int dac_channel,float *dac_set) { extern verb_flag; extern int nint(float); m_set_LL_dac message; m_set_LL_dac *mp = &message; int dac_set_int ; int status, err; err = 0; dac_set_int = nint(4095* *dac_set/2500.) ; printf("\nLL DAC channel %d is set to %f mVolts \n",dac_channel,*dac_set) ; mp->ciw = SET_LL_DAC; mp->dsp = dsp_no; mp->channel = 0; mp->len = 2 + (sizeof(m_generic) / sizeof(int32)); mp->dac = dac_channel; mp->voltage = dac_set_int; if((status = send_mess((int32 *) mp)) != SUCCESS) { err = -1; printf("Error in SET_LL_DAC send_mess"); } if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } return err; } int do_reset_fifo(int dsp_no) { m_generic message; m_generic *mp = &message; int status; printf("\nReseting FIFOS:\n") ; mp->ciw = RESET_FIFOS; mp->dsp = dsp_no; mp->channel = 0; mp->len = sizeof(m_generic) / sizeof(int32); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in RESET_FIFOS send_mess"); if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } } int do_reset_detectors(int dsp_no) { extern verb_flag; m_generic message; m_generic *mp = &message; int status; mp->ciw = RESET_DETECTORS; mp->dsp = dsp_no; mp->channel = 0; mp->len = sizeof(m_generic) / sizeof(int32); if((status = send_mess((int32 *) mp)) != SUCCESS) { printf("Error in RESET_DETECTORS send_mess"); return -1; } if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } if(status = peek(dsp_no)) { do_get_general_reply(dsp_no); printf("\nBinary: reset_detectors - got message %d, dsp %d\n", status, dsp_no); } return 0; } int load_control_block(int dsp_no,int blk_num,int test_bit,char CB_codename[20]) { extern verb_flag; m_load_control message; m_load_control *mp = &message; int32 blkdata[2048] ; int num_rep ; /* Num of repititions */ int32 value ; int i ,j ; int status; char string[80]; int num_repnew; /* int ifp; */ FILE *ifp ; for(i = 0; i <= 2047; i++) blkdata[i] = 0 ; /* zero the array */ ifp = fopen(CB_codename,"r"); i = 0 ; while(fscanf(ifp,"%d%lx\n",&num_rep,&value)==2) { /* printf(" %d %lx\n",num_rep,value); */ if(test_bit == 0) { if(blk_num==1) { if(i == 52) { printf(" time bucket %d\n",num_rep); printf(" enter new time bucket "); scanf("%d",&num_repnew); num_rep = num_repnew; printf(" %d %lx\n",num_rep,value); } } } for(j = 1; j <= num_rep ; j++) { blkdata[i] = value ; /* if(blk_num == 1) printf(" blkdata %d %lx \n",i,value); */ i++ ; } } mp->ciw = LOAD_CONTROL_BLOCK; mp->dsp = dsp_no; mp->channel = 0; mp->len = 2049 + (sizeof(m_generic) / sizeof(int32)); mp->blocknum = blk_num ; for(i = 0; i <=2047; i++) mp->blockdata[i] = blkdata[i] ; printf("Current First Data word is: %lx \n", blkdata[0]) ; fclose(ifp); if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in Load Control blk send_mess"); if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } } int do_execute_control_block(int dsp_no,int blk_num,int num_rep) { extern verb_flag; m_exe_control message; m_exe_control *mp = &message; int status; printf("\nExecuting Control block %d, %d times \n",blk_num,num_rep) ; mp->ciw = EXECUTE_CONTROL_BLOCK; mp->dsp = dsp_no; mp->channel = 0; mp->len = 2 + (sizeof(m_generic) / sizeof(int32)); mp->blocknum = blk_num; mp->numexe = num_rep; if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in SET_LL_DAC send_mess"); if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } } int do_set_strobe_delay(int dsp_no, int delay_strobe) { m_set_strobe message; m_set_strobe *mp = &message; extern verb_flag; int status; printf("\nSetting Strobe Delay to: %d\n",delay_strobe) ; mp->ciw = SET_STROBE_DELAY; mp->dsp = dsp_no; mp->channel = 0; mp->len = 1 + (sizeof(m_generic) / sizeof(int32)); mp->strobe_delay = delay_strobe; if((status = send_mess((int32 *) mp)) != SUCCESS) printf("Error in SET_STROBE_DELAY send_mess"); if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } } int do_set_counter_val(int dsp_no, int val_counter) { extern verb_flag; m_set_counter message; m_set_counter *mp = &message; int status; /* printf("\nSetting Counter Val to: %d\n",val_counter) ; */ mp->ciw = SET_COUNTER_VAL; mp->dsp = dsp_no; mp->channel = 0; mp->len = 1 + (sizeof(m_generic) / sizeof(int32)); mp->count_val = val_counter; if((status = send_mess((int32 *) mp)) != SUCCESS) { printf("Error in SET_COUNTER_VAL send_mess"); return -1; } if(verb_flag != 0) { m_wait(dsp_no); do_get_general_reply(dsp_no); } return 0; } /***************************/ /* END of Silicon_user.c */ /***************************/ int nint(float x) { int iaux; iaux = (int)(x*10) - (int)x*10; if ( iaux >= 5 ) return ((int) x + 1); else return ((int) x); } hist_init() { int id; int lun=1,lrec=1024; int lmax; int l,chan,k ; int ierror; int icycle; char HF_name[9]; char stdummy[5]; char filen[1]; char filenxxx[25]; /* SET HLIMIT OR THE PAW MEMORY */ hlimit(psize); /* hropen */ strcpy (filen , "N"); sprintf (filenxxx, "data/histrun.%d\0", run_no); printf (" filname for histos %s \n", filenxxx); hropen (lun, "FILE", filenxxx, filen, lrec, ierror); printf (" hropen status%d \n"); printf("\n initializing histograms.....\n"); source_hbook(); printf(" hbook done .... \n"); } hist_out() { int lun=1,lrec=1024, idn=0; int icycle; hrout(idn,icycle," "); printf(" hrout done... \n"); hrend("FILE"); printf(" hrend done... \n"); }