prototype.c

OFDMA 物理层开发的matlab 源码.飞思卡尔提供.对物理层开发的工程师有帮助!

  Word40 local = {0,0}; return local;
}

Word40 X_shr (Word40 var1, Word16 var2)
{
  Word40 local = {0,0}; return local;
}
Word40 X_lsl (Word40 var1, Word16 var2)
{
  Word40 local = {0,0}; return local;
}
Word40 X_lsr (Word40 var1, Word16 var2)
{
  Word40 local = {0,0}; return local;
}

Word40 X_abs (Word40 var1)
{
  Word40 local = {0,0}; return local;
}

Word32 X_sat (Word40 var1) { return 0; }

Word40 X_or (Word40 var1, Word40 var2)
{
  Word40 local = {0,0}; return local;
}

Word40 X_xor (Word40 var1, Word40 var2)
{
  Word40 local = {0,0}; return local;
}

int    X_cmpeq(Word40 var1, Word40 var2) { return 0; }
int    X_cmpgt(Word40 var1, Word40 var2) { return 0; }

Word40 X_ror (Word40 var1)
{
  Word40 local = {0,0}; return local;
}

Word40 X_ror_unsafe (Word40 var1)
{
  Word40 local = {0,0}; return local;
}

Word40 X_rol (Word40 var1)
{
  Word40 local = {0,0}; return local;
}

Word40 X_rol_unsafe (Word40 var1)
{
  Word40 local = {0,0}; return local;
}


void* clear(void *src, unsigned int size) { return src; }


/* scaling*/
void force_moves_f(Word16 *ptr, Word16 src) { *ptr = src; }
void force_moves_l(long *ptr, long src) { *ptr = src; }



/*****************************************************/
/* Other primitives                                  */
/*****************************************************/

Word32 mpyuu( Word32 var1, Word32 var2 ) { return 0; }
Word32 mpyus( Word32 var1, Word32 var2 ) { return 0; }
Word32 mpyus_shr16(Word32 var1, Word16 var2) {return 0;}
Word32 mpysu_shr16(Word16 var1, Word32 var2) {return 0;}
Word32 L_mult_ls(Word32 var1, Word16 var2) {return 0;}
Word32 L_mult_sl(Word16 var2, Word32 var1) {return 0;}
Word32 mpysu( Word32 var1, Word32 var2 ) { return 0; }

/*void Write_64(Word64 * Fifo, Word64 Value) {return;}*/
/*Word64 Read_64(const Word64 * Fifo) {Word64 Res = {0, 0}; return Res;}*/
int bmtset(Word16 Sema, unsigned short mask) { return 0;}
#else

#include <stdio.h>
#include <stdlib.h>

/*___________________________________________________________________________
 |                                                                           |
 |   Constants and Globals                                                   |
 |___________________________________________________________________________|
*/
Flag Overflow = 0;
Flag Carry = 0;
Flag SaturationMode = 1;


/* Multi precison functions */

unsigned int B_SET_VECTOR_MASK[] = {
	1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7, 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
	1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23, 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30, 1<<31};

unsigned int B_RES_VECTOR_MASK[] = {
	(~(1<<0)), (~(1<<1)), (~(1<<2)), (~(1<<3)), (~(1<<4)), (~(1<<5)), (~(1<<6)), (~(1<<7)), (~(1<<8)), (~(1<<9)),
	(~(1<<10)), (~(1<<11)), (~(1<<12)), (~(1<<13)), (~(1<<14)), (~(1<<15)), (~(1<<16)), (~(1<<17)), (~(1<<18)),
	(~(1<<19)), (~(1<<20)), (~(1<<21)), (~(1<<22)), (~(1<<23)), (~(1<<24)), (~(1<<25)), (~(1<<26)), (~(1<<27)),
	(~(1<<28)), (~(1<<29)), (~(1<<30)), (~(1<<31)) };

#define BIT_S(b_vector, bit_number) ((b_vector[bit_number >> 5] |= B_SET_VECTOR_MASK[bit_number & 31]))
#define BIT_R(b_vector, bit_number) ((b_vector[bit_number >> 5] &= B_RES_VECTOR_MASK[bit_number & 31]))
#define BIT_V(b_vector, bit_number) ((b_vector[bit_number >> 5] & B_SET_VECTOR_MASK[bit_number & 31]))

void Set_Vect(unsigned int *To_Vect, unsigned int *From_Vect, int len)

{
	int i;

	for (i = 0; i<len; i++) if (BIT_V(From_Vect, i)) BIT_S(To_Vect, i); else BIT_R(To_Vect, i);
}

void ADD(unsigned int *X, unsigned int *Y, unsigned int *Res, int len)

{
	int i, Out, C = 0;
	int V1, V2;

	for (i = 0; i<len; i++) {
		V1 = (BIT_V(X, i) != 0) ; V2 = (BIT_V(Y, i) != 0);
		Out = V1^V2^C;
		if (Out) BIT_S(Res, i); else BIT_R(Res, i);
		C = (V1 + V2 + C) >= 2;

	}
}

void MINUS(unsigned int *X, unsigned int *Y, unsigned int *Res, int len)

{
	int i;
	unsigned int Temp_V[2] = {0, 0};
	unsigned int Temp_V1[2] = {0, 0};

	BIT_S(Temp_V1, 0);
	Set_Vect(Temp_V, Y, len);
	for (i = 0; i<len; i++) if (BIT_V(Temp_V, i)) BIT_R(Temp_V, i); else BIT_S(Temp_V, i); /* !Y */
	ADD(Temp_V, Temp_V1, Temp_V, len);			/* !Y + 1 */
	ADD(X, Temp_V, Res, len);				/* X + !Y + 1 */
}



Word40 X_SUB(Word40 a, Word40 b)

{
	Word40 c;
	unsigned int A[] = {0, 0};
	unsigned int B[] = {0, 0};
	unsigned int R[] = {0, 0};
	int v1 = a.body;
	int v2 = a.ext;
	int v3 = b.body;
	int v4 = b.ext;

	Set_Vect(&A[0], &v1, 32); Set_Vect(&A[1], &v2, 8);
	Set_Vect(&B[0], &v3, 32); Set_Vect(&B[1], &v4, 8);
	A[0] = v1; A[1] = v2;
	B[0] = v3; B[1] = v4;
	MINUS(A, B, R, 40);
	c.ext = R[1]; c.body = R[0];
	return c;
}

Word64 D_SUB(Word64 a, Word64 b)

{
	Word64 c;
	unsigned int A[] = {0, 0};
	unsigned int B[] = {0, 0};
	unsigned int R[] = {0, 0};
	int v1 = a.lsb;
	int v2 = a.msb;
	int v3 = b.lsb;
	int v4 = b.msb;

	Set_Vect(&A[0], &v1, 32); Set_Vect(&A[1], &v2, 32);
	Set_Vect(&B[0], &v3, 32); Set_Vect(&B[1], &v4, 32);
	A[0] = v1; A[1] = v2;
	B[0] = v3; B[1] = v4;
	MINUS(A, B, R, 64);
	c.msb = R[1]; c.lsb = R[0];
	return c;
}

Word40 X_ADD(Word40 a, Word40 b)

{
	Word40 c;
	unsigned int A[] = {0, 0};
	unsigned int B[] = {0, 0};
	unsigned int R[] = {0, 0};
	int v1 = a.body;
	int v2 = a.ext;
	int v3 = b.body;
	int v4 = b.ext;

	Set_Vect(&A[0], &v1, 32); Set_Vect(&A[1], &v2, 8);
	Set_Vect(&B[0], &v3, 32); Set_Vect(&B[1], &v4, 8);
	A[0] = v1; A[1] = v2;
	B[0] = v3; B[1] = v4;
	ADD(A, B, R, 40);
	c.ext = R[1]; c.body = R[0];
	return c;
}

Word64 D_ADD(Word64 a, Word64 b)

{
	Word64 c;
	unsigned int A[] = {0, 0};
	unsigned int B[] = {0, 0};
	unsigned int R[] = {0, 0};
	int v1 = a.lsb;
	int v2 = a.msb;
	int v3 = b.lsb;
	int v4 = b.msb;

	Set_Vect(&A[0], &v1, 32); Set_Vect(&A[1], &v2, 32);
	Set_Vect(&B[0], &v3, 32); Set_Vect(&B[1], &v4, 32);
	A[0] = v1; A[1] = v2;
	B[0] = v3; B[1] = v4;
	ADD(A, B, R, 64);
	c.msb = R[1]; c.lsb = R[0];
	return c;
}

static Word32 L_add_c (Word32 L_var1, Word32 L_var2);
static Word32 L_sub_c (Word32 L_var1, Word32 L_var2);

static Word32 L_macNs (Word32 L_var3, Word16 var1, Word16 var2);
static Word32 L_msuNs (Word32 L_var3, Word16 var1, Word16 var2);

/*___________________________________________________________________________
 |                                                                           |
 |   Functions:
 |___________________________________________________________________________|
*/

/*___________________________________________________________________________
 |                                                                           |
 |   Function Name : saturate                                                |
 |                                                                           |
 |   Purpose :                                                               |
 |                                                                           |
 |    Limit the 32 bit input to the range of a 16 bit word.                  |
 |                                                                           |
 |   Inputs :                                                                |
 |                                                                           |
 |    L_var1                                                                 |
 |             32 bit long signed integer (Word32) whose value falls in the  |
 |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
 |                                                                           |
 |   Outputs :                                                               |
 |                                                                           |
 |    none                                                                   |
 |                                                                           |
 |   Return Value :                                                          |
 |                                                                           |
 |    var_out                                                                |
 |             16 bit short signed integer (Word16) whose value falls in the |
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 |___________________________________________________________________________|
*/

Word16 saturate (Word32 L_var1)
{
    Word16 var_out;

    if (L_var1 > 0X00007fffL)
    {
        Overflow = 1;
        var_out = MAX_16;
    }
    else if (L_var1 < (Word32) 0xffff8000L)
    {
        Overflow = 1;
        var_out = MIN_16;
    }
    else