/**************************************************************
* Utility Program
* 11/13/00
**************************************************************/
#include <stdio.h>
#include <stdarg.h>
#include "reg.h"

/* LCD Interface register map */
#define rDmLCDBase rEXT0Base
#define rDmLCDIRW  (*(volatile unsigned *)(rDmLCDBase+0x00)) /* Instruction write */
#define rDmLCDIRR  (*(volatile unsigned *)(rDmLCDBase+0x08)) /* Instruction read */
#define rDmLCDDRW  (*(volatile unsigned *)(rDmLCDBase+0x04)) /* Data write */
#define rDmLCDDRR  (*(volatile unsigned *)(rDmLCDBase+0x0C)) /* Data read */

/* Message print for dot matrix LCD display */
void InitDmLCD(void);
void ClearDmLCD(void);
void diaplayDmLCD1(char *s);  
void displayDmLCD2(char *s);  
void WaitDmLCD(void);

/* LED Interface register map */
void InitLED(void);
void ClearLED(void);
void displayLED(char v);
void Time_delay(int time);

/* Message print using UART for debugging */
void Init_Uart0(void);
char Uart_Getch(void);
void Uart_SendByte(int data);
void Uart_SendString(char *pt);
void Uart_Printf(char *fmt,...);
void eitoa(int number,char *str,int power);

void *malloc(unsigned byte);
void free(void *pt);

#define HEAPEND  0x8DFFFFC    // only when memory size is 16MB
extern char Image$$RW$$Limit[];
void *mallocPt = Image$$RW$$Limit;    

/*Very simple; Use malloc() & free() like Stack*/
void *malloc(unsigned nbyte)
{
     void *returnPt=mallocPt;

     mallocPt = (int *)mallocPt + nbyte/4 + ((nbyte%4)>0);

     if ((int)mallocPt > HEAPEND)
     {
        mallocPt=returnPt;
        return NULL;
     }

     return returnPt;
}

void free(void *pt)
{
     mallocPt=pt;
}

/* Dot matrix LCD controller Initialization & Display */
/* product name : HD44780U */
void InitDmLCD(void)
{
	 /* if APB clock cycle time is 33MHz */
     /* External device0 1 cycle time : 484ns (x16)*/
     rAPBCON2 = ((rAPBCON2 & 0xFFF0FFFF) | 0x000F0000) ;
  
     Time_delay(15);    // delay 4.5V:15ms    

     rDmLCDIRW = 0x30;
     Time_delay(5);     // delay 4.1ms

     rDmLCDIRW = 0x30;
     Time_delay(1);     // delay 100us

     rDmLCDIRW = 0x30;
     Time_delay(1);     // delay 100us

     rDmLCDIRW = 0x38;  // MCU 8bit interface, LCD 2line display
     rDmLCDIRW = 0x08;  // display off
     rDmLCDIRW = 0x01;  // display clear
     rDmLCDIRW = 0x06;  // entry mode set(no shift, auto increment)

     rDmLCDIRW = 0x0C;  // display on, cursor off, blink off
     WaitDmLCD();
}

void ClearDmLCD(void)
{
    rDmLCDIRW = 0x01;
    WaitDmLCD();
}

/* first line display */
/* display to maximum 16 characer per 1 line */
void displayDmLCD1(char *s) 
{
     ClearDmLCD();
     while(*s) {	
         rDmLCDDRW = *s++;
         WaitDmLCD();
     }
}

/* second line display */
/* display to maximum 16 characer per 1 line */
void displayDmLCD2(char *s)
{
     rDmLCDIRW = 0xA8;
     while(*s) {	
         rDmLCDDRW = *s++;
         WaitDmLCD();
     }
}

void WaitDmLCD(void)
{
     char bf = 0;

     while(!bf) {
        bf = rDmLCDIRR;
        bf &= 0x80;
     }
        
} 

void Time_delay(int time) // time 1ms(15ns x 70000 / 7)
{
   int i,j;

   for(i=0;i<time;i++)
       for(j=0;j<10000;j++)
           ;
       
}

/* LED(GIOP) Initialization & Display */
void InitLED(void)
{
     rGIOPCON = rGIOPCON & 0xFFF0;
     rGIOPINTEN = rGIOPINTEN & 0xFFF0;
}

void ClearLED(void)
{
    rGIOPDATA = rGIOPDATA | 0x000F;
}

void displayLED(char v)
{
     switch(v){
        case 0x1:
             rGIOPDATA = 0xFFF7;
             break;
        case 0x2:
             rGIOPDATA = 0xFFFB;
             break;
        case 0x3:
             rGIOPDATA = 0xFFF3;
             break;
        case 0x4:
             rGIOPDATA = 0xFFFD;
             break;
        case 0x5:
             rGIOPDATA = 0xFFF5;
             break;
        case 0x6:
             rGIOPDATA = 0xFFF9;
             break;
        case 0x7:
             rGIOPDATA = 0xFFF1;
             break;
        case 0x8:
             rGIOPDATA = 0xFFFE;
             break;
        case 0x9:
             rGIOPDATA = 0xFFF6;
             break;
        case 0xa:
             rGIOPDATA = 0xFFFA;
             break;
        case 0xb:
             rGIOPDATA = 0xFFF2;
             break;
        case 0xc:
             rGIOPDATA = 0xFFFC;
             break;
        case 0xd:
             rGIOPDATA = 0xFFF4;
             break;
        case 0xe:
             rGIOPDATA = 0xFFF8;
             break;
        case 0xf:
             rGIOPDATA = 0xFFF0;
             break;
        default:
             break;
     }
}

/* Message print using UART0 for debugging */
/* Use to polling methord of UART */
void Init_Uart0(void)
{
    /* Set the Line Control Register. the baud rate 38400 */
    //rUART0LCR_L =  0x16; /* because uartclk = 14.318Mhz */
    rUART0LCR_L =  0x81; /* because uartclk = 80Mhz */
    //rUART0LCR_M =  0x00;
	
    /*No parity,stop bit:1,data bit:8bit,450Mode */
    rUART0LCR_H =  0x60;

    rUART0CR = rUART0CR | 0x1;
}

char Uart_Getch(void)
{       
    while(!(rUART0FR & 0x40))
         ;
    return  rUART0DR;
}

void Uart_SendByte(int data)
{
    if(data == '\n')
      data = '\r';
    while(!(rUART0FR & 0x80))
        ;   
    rUART0DR = data;
}               

void Uart_SendString(char *pt)
{
     while(*pt)
        Uart_SendByte(*pt++);
}

void Uart_Printf(char *fmt,...)
{
     va_list ap;
     char *p;
     char string[30];
        
     va_start(ap,fmt);

     for(p=fmt;*p;p++)
     {
         if (*p != '%')
         {
            Uart_SendByte(*p);
            continue;
         }
         switch(*++p)
         {
             case 'x':
             case 'X':
                eitoa(va_arg(ap,int),string,16);                    
                Uart_SendString(string);
                break;
             case 'd':
                eitoa(va_arg(ap,int),string,10);                    
                Uart_SendString(string);
                break;
             case 'c':
                Uart_SendByte(va_arg(ap,int));
                break;                        
             case 's':
                Uart_SendString((char *)va_arg(ap,int));
                break;
             default:
                Uart_SendByte('?');
                break;
         }
     }
     va_end(ap);
}

void eitoa(int number,char *str,int numtype)
{
     char buffer[15];
     int i;
     int firstNumber=1;
     unsigned int temp;
     unsigned int numtemp;

     switch(numtype)
     {
         case 16:
            for(i=0;i<8;i++)
            {
                numtemp=(unsigned int)number;
                numtemp=(numtemp << (i*4)) >> 28;
                if (numtemp >= 10)
                    numtemp+=('A'-10);
                else
                    numtemp+='0';
                if (!firstNumber || numtemp!='0' || i==7)
                {
                    *str++=numtemp;
                    firstNumber=0;
                }
            }
            *str++='\0';
            break;
         case 10:
            if (number < 0)
            {
                *str++='-';
                numtemp=-number;
            }
            else
                numtemp=number;
            for(i=0;i<10;i++)
            {
                temp=(numtemp/10)*10;
                temp=numtemp-temp;
                buffer[i]=temp;
                numtemp=(numtemp-temp)/10;
            }  
            for(i=9;i>=0;i--)
            {
                temp=buffer[i]+'0';
                if (!firstNumber || temp!='0' || i==0)
                {
                    *str++=temp;
                    firstNumber=0;
                }
            }
            *str++='\0';
            break;
        }
}