A_UINT32 decryptcrcerr = 0;
    A_UINT32 phyerr = 0;
    A_UINT32 keyidxvalid = 0;
    A_UINT32 keycachemiss = 0;
    A_UINT32 desc4 = 0;
    A_UINT32 more = 0;
    A_UINT32 rssi = 0;
    double rssi_out_resolution = read_rssi_out();

    //    FILE *STATUS;
    char name[25];

	retval = (A_UINT32 *) malloc(100*sizeof(A_UINT32));

//    if( (STATUS = fopen( "status.nfo", "w")) == NULL ) {
//	  printf("Failed to open status.nfo - using Defaults\n");
//	  exit(0);
//    }

//    fprintf( STATUS, "RSSI\tDONE\tDATALEN\tMORE\tFRRXOK\tCRCERR\tFIFO\tDECRYPT\tPHYERR\tKEYIDX\tKEYCACHE\n");
//    fprintf( STATUS, "\t\t\t\t\t\tOVERRUN\tCRCERR\t\tVALID\tMISS\n");
    for (j=0;j<desc_cnt; j++) {
        tmp_ptr      = rx_desc_ptr + (j*DESC_LEN);   
        desc5         = mem_read(tmp_ptr + 0x14);
        done          = (desc5 & 0x1);
        frrxok        = ((desc5 & 0x2) != 0x0) ? 1 : 0;
        crcerr        = ((desc5 & 0x4) != 0x0) ? 1 : 0;
        fifooverrun   = ((desc5 & 0x8) != 0x0) ? 1 : 0;
        decryptcrcerr = ((desc5 & 0x10) != 0x0) ? 1 : 0;
        phyerr        = ((desc5 & 0x60) != 0x0) ? 1 : 0;
        keyidxvalid   = ((desc5 & 0x80) != 0x0) ? 1 : 0;
        keycachemiss  = ((desc5 & 0x10000000) != 0x0) ? 1 : 0;
        desc4         = mem_read(tmp_ptr + 0x10);
        datalen       = desc4 & 0xfff;
        more          = (desc4 >> 12) & 0x1;
        rssi          = sign_ext((desc4 >> 19) & 0xff,8);
        if (done & frrxok) {
            retval[k++] = rssi ;
        }
	//        fprintf( STATUS, "%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",rssi,done,datalen,more,frrxok,
	//	 crcerr,fifooverrun,decryptcrcerr,phyerr,keyidxvalid,keycachemiss);

    }
    //    fclose(STATUS) ;

    strcpy(name, "rssi");
	return_val = mode(&(retval[0]), k, name);
	free(retval);
    return(rssi_out_resolution*return_val);
}

// Routine to report the rssi after descriptor consumption
double report_rssi (A_UINT32 rx_desc_ptr, A_UINT32 desc_cnt) { 
    A_UINT32 j = 0;
    A_UINT32 k = 0;
    A_UINT32 tmp_ptr = 0;
    A_UINT32 desc4 = 0;
    A_UINT32 desc5 = 0;
    A_UINT32 rssi = 0;
    double rssi_out_resolution = read_rssi_out();
    double final_ret_val;
    A_UINT32 *retval;
	A_UINT32 return_val;

    char  name[25];

	retval = (A_UINT32 *) malloc(100*sizeof(A_UINT32));

    for (j=0;j<desc_cnt; j++) {
        tmp_ptr = rx_desc_ptr + (j*DESC_LEN);
        desc4 = mem_read(tmp_ptr + 0x10);
        desc5 = mem_read(tmp_ptr + 0x14);
        if ((desc5 & 0x3) == 0x3) {
            rssi = sign_ext((desc4 >> 20) & 0xff,8);	
printf("snoop: report_rssi: rssi[%d] = %d  (res = %f)\n",k, rssi, rssi_out_resolution);	
            retval[k++] = rssi;
        }
    }
    strcpy(name, "rssi");
	return_val =  mode(&(retval[0]),k,name);
	final_ret_val = (double) (return_val*rssi_out_resolution);
	free(retval);
    return(final_ret_val);
}

// Routine to read back setting for adc_desired_size
A_INT32 adc_desired_size () { 
    return sign_ext((REGR(goldDevNum, 0x9850) & 0xff),8)/2;
}



// Routine to setup the receive capture buffer and enable the tstadc
void enable_tstadc () { 
    CAP_DESC_PTR = memAlloc(goldDevNum, DESC_LEN);
    CAP_DATA_PTR = memAlloc(goldDevNum, CAPTURE_LEN);
    mem_write(CAP_DESC_PTR,      0x0);
    mem_write(CAP_DESC_PTR+0x4,  CAP_DATA_PTR);
    mem_write(CAP_DESC_PTR+0x8,  0x0);
    mem_write(CAP_DESC_PTR+0xc,  0xfff);
    mem_write(CAP_DESC_PTR+0x10, 0x0);
    mem_write(CAP_DESC_PTR+0x14, 0x0);
    REGW(goldDevNum, 0x803c,0x20);                                   // mac::pcu::rx_filter::promiscuous
    REGW(goldDevNum, 0x8048,0x0);                                    // mac::pcu::diag_sw::rx_disable
    REGW(goldDevNum, 0x9808, REGR(goldDevNum, 0x9808) | (1<<8) | (1<<10));   // tstadc_en=1, rx_obs_sel=adc
	printf("snoop: enable_tstadc : reg_9808 = 0x%x\n", REGR(goldDevNum, 0x9808));
    mSleep(10);
}

// Routine to reset and arm the tstadc
void arm_rx_buffer () { 
    A_UINT32 addr;

    for (addr=0; addr<CAPTURE_LEN/4; addr++) {
        mem_write(CAP_DATA_PTR+(addr<<2), 0x0);
    }
    REGW(goldDevNum, 0x8054, 0x0);                                   // pcu::tst_addac::test_mode
    mSleep(5);
    
    REGW(goldDevNum, 0x000c,CAP_DESC_PTR);                           // mac::dru::rxdp::linkptr
    REGW(goldDevNum, 0x0008,0x4);                                    // mac::dru::cr::rxe
    
    REGW(goldDevNum, 0x8054, (1<<20) | (1<<14) | 2);                 // pcu::tst_addac::[arm_rx_buffer
    mSleep(5);	
}
    

// Routine to capture the last n samples of tstadc data
void begin_capture (A_UINT32 n, double *i, double *q) { 
    A_UINT32 desc5 = CAP_DESC_PTR+0x14;
    A_UINT32 k = 0;
    A_UINT32 dwords = CAPTURE_LEN/4;
    A_UINT32 addr = 0;
    A_UINT32 rdaddr = 0;
    A_UINT32 rddata = 0;

	double ADC_OFFSET	 = pow(2,ADC_BITS)/2;
	double ADC_SCALE	 = ADC_VPP/pow(2,ADC_BITS);

    REGW(goldDevNum, 0x8054, REGR(goldDevNum, 0x8054) | (1<<19));            // pcu::tst_addac::begin_capture
    mSleep(10);

    while (((mem_read(desc5) & 0x1)) != 0x1) { 1; }
    mem_write(desc5, 0x0);

    // read tstadc data except last 2 samples which are empty
    for (addr=(dwords-n/2-1); addr<(dwords-1); addr++) {
        rdaddr = CAP_DATA_PTR + (addr<<2);
        rddata = mem_read(rdaddr);
    
        q[2*k]   = ((((rddata >> 8) & 0xff) << 1) - ADC_OFFSET) * ADC_SCALE;
        i[2*k]   = (((rddata & 0xff) << 1) - ADC_OFFSET) * ADC_SCALE;
        q[2*k+1] = ((((rddata >> 24) & 0xff) << 1) - ADC_OFFSET) * ADC_SCALE;
        i[2*k+1] = ((((rddata >> 16) & 0xff) << 1) - ADC_OFFSET) * ADC_SCALE;

        k++;    
    }
}


// Routine to capture the last n samples of tstadc data
// and estimate the power spectral density over averages
void estimate_spectrum (A_UINT32 n, double *wr, double *wi, A_UINT32 averages, A_UINT32 lvl_offset, double *psd) { 

    A_UINT32 j = 0;
    A_UINT32 k = 0;
    double *i, *q, *iq;
    double psd_offset = -PSD_SCALE*log((n*n)*averages);

	i  = (double *) malloc(n*sizeof(double));
	q  = (double *) malloc(n*sizeof(double));
	iq = (double *) malloc(n*sizeof(double));

	if ((i==NULL) || (q==NULL) || (iq==NULL)) {
			printf("could not allocate memory for i, q or iq\n");
			if (i != NULL) { free(i); }
			if (q != NULL) { free(q); }
			if (iq != NULL) { free(iq); }
			exit(0);
	}
	printf("snoop: estimate_spectrum : n=%d, avgs = %d, lvl_offset=%d\n", n, averages, lvl_offset);

    for (j=0; j<averages; j++) {
//      printf("snoop: estimate_spectrum : j=%d, ", j);

        arm_rx_buffer();
        begin_capture(n, &(i[0]), &(q[0]));
//      printf("snoop: estimate_spectrum : begun capture, ");

        fft(n,&(i[0]),&(q[0]),wr,wi);
//      printf("snoop: estimate_spectrum : did fft 1, ");
        mag(n,i,q,&(iq[0]));
//      printf("snoop: estimate_spectrum : did mag, ");
        fftshift(n,&(iq[0]));
//      printf("snoop: estimate_spectrum : did fft 2\n ");

        for (k=0; k<n; k++) {
            if (iq[k]!=0) { psd[k] += iq[k]; }
        }

    }
    // ---------------------------------------------------------------
    // PSD is calculated as:
    //
    //     averages
    //       ----         --             --
    //        \           |  *iq[j]/n  |
    //         >  20*log10|  -----------  |
    //        /           |   averages   |
    //       ----         __             __
    //       j=0
    //
    // ---------------------------------------------------------------
    for (k=0; k<n; k++) {
        psd[k] = PSD_SCALE*log(psd[k])+psd_offset+lvl_offset;
    }

    psd[n/2] = (psd[n/2-1]+psd[n/2+1])/2;

	free(i);
	free(q);
	free(iq);
      printf("snoop: estimate_spectrum : done \n");
}



// Routine to calculate turbo mode filter response at a given frequency
double turbo_resp (A_INT32 freq) { 
	A_UINT32  x = abs(freq);
	double retval;

	if (x <= 19e6) {
		retval = 0.0;
	} else if (x <= 20e6) {
		retval = interp(0.0,-0.5,19000000,20000000,x);
	} else if (x <= 30e6) {
		retval = interp(-0.5,-7.0,20000000,30000000,x);
	} else if (x <= 40e6) {
		retval = interp(-7.0,-13.5,30000000,40000000,x);
	} else {
		retval = -13.5;
	}
	return(retval);
}
           
// Routine to select the resolution of the rssi register
void select_rssi_out (double resolution) { 
	A_UINT32  format = 0;
	if (resolution == .5)  { 
		format = 1; 
	} else if (resolution == .25) { 
		format = 2; 
	}

	REGW(goldDevNum, 0x985c,REGR(goldDevNum, 0x985c) & ~(3<<30) | (format<<30));
}

// Routine to read the resolution of the rssi register
double read_rssi_out () { 
	A_UINT32 format = (REGR(goldDevNum, 0x985c) >> 30) & 0x3;

	if (format == 1) { 
		return .5; 
	} else if (format == 2) { 
		return .25; 
	} else { 
		return 1; 
	}
}

// Routine to read back the rssi register
A_UINT32 read_rssi () { 
    return sign_ext(REGR(goldDevNum, 0x9c1c),8);
}



// Routine to read back minccapwr register
A_UINT32 read_minccapwr () { 
    return sign_ext((REGR(goldDevNum, 0x9864) >> 19),9);
}

// Routine to read testout
A_UINT32 read_testout (A_UINT32 bits, A_UINT32 offset) {
//    if (not defined offset) { offset = 0; }
    REGW(goldDevNum, 0x987c+(bits<<2),0x0);
    return bit_rev((REGR(goldDevNum, 0x9c00) >> (32-bits-offset)) & mask(bits),bits);
}


A_UINT32 mem_read(A_UINT32 addr) {
	A_UINT32 buffer;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[goldDevNum];

	pLibDev->devMap.OSmemRead(goldDevNum,addr, (A_UCHAR *)&buffer, 4);
	return(buffer);
}

void mem_write(A_UINT32 addr, A_UINT32 val) {
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[goldDevNum];
	pLibDev->devMap.OSmemWrite(goldDevNum, addr, (A_UCHAR *)&val, 4);
}