c30fftp.c

GENERIC PROGRAM FOR A FAST LOOPED-CODE RADIX-2 DIT FFT

/*************************************************************************

  C30SERP.C : Partitioned serial DIT FFT implementation(Single-buffered version)

  Requirements: 32<= Q <= 1024 (minimum: because of Meyer-Schwarz FFT limitations
                                maximum: because of on-chip RAM limitations)
  Version : 1.0

**************************************************************************
 VERSION        DATE            COMMENT
   1.0		8/92		Original version
                                ROSEMARIE PIEDRA (TI Houston)
**************************************************************************/
#define    N          (1024*4)            /* FFT size (n)               */
#define    P           4                  /* P = N/Q                    */
#define    D           2                   /* LOG2 P                     */
#define    Q	       N/P		   /* maximum FFT size that can
                                              be computed on-chip        */
#define    BLOCK0      0x809800            /* on-chip RAM buffer         */

extern      void r2dit(),                  /* C-callable complex FFT     */
                 cmove(),                  /* CPU complex move           */
                 cmoveb();                 /* CPU bit-reversed complex move */

extern      float INPUT[];                 /* Input vector = N = Q * P   */

float	    *input	= (float *)BLOCK0, /* on-chip RAM		 */
            *shinput    = INPUT,
            *src_addr   = INPUT;

unsigned int i,j,k,
	     delta	= P,
	     ngroup	= 2,
	     incr_group = N,
	     p2 	= 2*P,
	     Wkpointer	= 0,
	     q		= Q,
	     q2 	= Q/2;

/*************************************************************************/
main()
{
asm(" or 1800h,st");
start:
/**********************************
  P size-q FFT's                  *
**********************************/
for (j=0;j<P;j++,src_addr +=2) {
    cmove(src_addr,input,p2,2,q);         /* q elements are transfered to
					     on-chip RAM for execution	  */
    r2dit(input,q);			  /* q-point FFT		  */
    cmove(input,src_addr,2,p2,q);	  /* FFT results are transfered back
					     to off-chip memory 	  */
    }

/**********************************
  LOG P Butterfly operation steps *
**********************************/

 src_addr = shinput;
 for (i=0;i<D;i++) { /* log P steps of P butterfly vector operations each */
     for (k=0;k<ngroup;++k) {	    /* at each step i there are "ngroups" of identical
				       butterfly vector operations	  */
	 for (j=0;j<delta;j+=2) {   /* each group contains (delta/2)
				       butterfly vector operations	  */
	     cmove(src_addr+j,input,delta,2,q);  /* move data on-chip	  */
	     bflyr(input,q,Wkpointer);	    /* butterfly vector operation */
	     cmove(input,src_addr+j,2,delta,q);  /* move result off chip  */
             }
	 src_addr  += incr_group;   /* update src address base for next group */
	 Wkpointer += q2;	    /* update Wk pointer for next group   */
         }
     ngroup <<=1;		    /* number of groups decrement by half
				       after each step			  */
     Wkpointer = 0;		    /* initialize Wk pointer= Wn(0)	  */
     src_addr = shinput;
     delta >>= 1;		    /* update parameters for next step	  */
     incr_group >>=1;
    }
} /*main*/