os/nandboot-R2_0_4/lib/lib.c

Go to the documentation of this file.

/*****************************************************************************
*!
*! FILE NAME  : lib.c
*!
*! DESCRIPTION: Small practical functions for boot loader.
*!              malloc/free
*!              memcpy/memset
*!              writeb/writew/readb/readw
*!              putc/puts/putnybble/putx
*!              error/error2
*!              serial_init
*!
*! ---------------------------------------------------------------------------
*!
*! malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
*! puts by Nick Holloway 1993, better puts by Martin Mares 1995
*! adoptation for Linux/CRIS Axis Communications AB, 1999
*! 
*! Other parts (C) Copyright 2006-2007, Axis Communications AB, LUND, SWEDEN
*!
*! This program is free software; you can redistribute it and/or modify
*! it under the terms of the GNU General Public License as published by
*! the Free Software Foundation; either version 2 of the License, or
*! (at your option) any later version.
*!
*! This program is distributed in the hope that it will be useful,
*! but WITHOUT ANY WARRANTY; without even the implied warranty of
*! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*! GNU General Public License for more details.
*!
*! You should have received a copy of the GNU General Public License
*! along with this program; if not, write to the Free Software
*! Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*!
*!***************************************************************************/

#include <linux/autoconf.h> /* only for CONFIG_ETRAX_DEBUG_PORT_xxx */

#include <linux/types.h>
#include <asm/arch/hwregs/reg_rdwr.h>
#include <asm/arch/hwregs/reg_map.h>
#include <asm/arch/hwregs/ser_defs.h>
#include <asm/arch/hwregs/pinmux_defs.h>

#include "lib.h"

/* the "heap" is put directly after BSS ends, at _end */
  
extern int _end;
static long free_mem_ptr = (long)&_end;
 
void *malloc(unsigned int size)
{
        void *p;

        free_mem_ptr = (free_mem_ptr + 3) & ~3; /* Align */

        p = (void *)free_mem_ptr;
        free_mem_ptr += size;

        return p;
}

void free(void *where)
{       /* Don't care */
}

/* I/O */

unsigned char readb(const volatile void *addr)
{
        return *(volatile unsigned char *) addr;
}

unsigned short readw(const volatile void *addr)
{
        return *(volatile unsigned short *) addr;
}

void writeb(unsigned char b, volatile void *addr)
{
        *(volatile unsigned char *) addr = b;

#if GPIO_SYNC
        /* Bus sync: Read from address we just wrote.
         * This generates no signal to the NAND flash, since only chip 
         * select lines are pulled out to the chip, and read is not 
         * gated with chip select for the write  area.
         * This should not be necessary with correct wait states, but
         * may be necessary (but the wrong way to do it) if too short wait
         * states have been set up, or (correctly) if way too long wait states 
         * have been set up.
         */
        (void) readb(addr);
#endif
}

void writew(unsigned short b, volatile void *addr)
{
        *(volatile unsigned short *) addr = b;
}

/* info and error messages to serial console */

#ifndef CONFIG_ETRAX_DEBUG_PORT_NULL
static inline void
serout(const char c, reg_scope_instances regi_ser)
{
        reg_ser_rs_stat_din rs;
        reg_ser_rw_dout dout = {.data = c};

        do {
                rs = REG_RD(ser, regi_ser, rs_stat_din);
        }
        while (!rs.tr_rdy);/* Wait for tranceiver. */
        
        REG_WR(ser, regi_ser, rw_dout, dout);
}

#endif /* CONFIG_ETRAX_DEBUG_PORT_NULL */

void
putc(const char c)
{
#ifdef CONFIG_ETRAX_DEBUG_PORT0
        serout(c, regi_ser0);
#endif
#ifdef CONFIG_ETRAX_DEBUG_PORT1
        serout(c, regi_ser1);
#endif
#ifdef CONFIG_ETRAX_DEBUG_PORT2
        serout(c, regi_ser2);
#endif
#ifdef CONFIG_ETRAX_DEBUG_PORT3
        serout(c, regi_ser3);
#endif
}


void
puts(const char *s)
{
        while (*s)
                putc(*s++);
}

void
putnybble(unsigned int n)
{
        putc("0123456789abcdef"[n & 15]);
}

void
putx(unsigned int x)
{
        int i;

        puts("0x");
        for (i = 7; i >= 0; i--)
                putnybble(x >> 4*i);
}

void
putnl(void)
{
        puts("\r\n");
}

void*
memset(void* s, int c, size_t n)
{
        int i;
        char *ss = (char*)s;

        for (i=0;i<n;i++) ss[i] = c;
        return s;
}

void*
memcpy(void* __dest, __const void* __src,
                            size_t __n)
{
        int i;
        char *d = (char *)__dest, *s = (char *)__src;

        for (i=0;i<__n;i++) d[i] = s[i];
        return __dest;
}

void
error(const char *x)
{
        puts("\r\n\n");
        puts(x);
        puts("\r\n\n -- System halted\n");

        while(1);       /* Halt */
}

void
error2(const char *x, int y, const char *z)
{
        puts("\r\n\n");
        puts(x);
        putc(':');
        putx(y);
        putc(':');
        puts(z);
        puts("\r\n\n -- System halted\n");

        while(1);       /* Halt */
}

static inline void
serial_setup(reg_scope_instances regi_ser)
{
#ifndef CONFIG_ETRAX_DEBUG_PORT_NULL
        reg_ser_rw_xoff xoff;
        reg_ser_rw_tr_ctrl tr_ctrl;
        reg_ser_rw_rec_ctrl rec_ctrl;
        reg_ser_rw_tr_baud_div tr_baud;
        reg_ser_rw_rec_baud_div rec_baud;
        
        /* Turn off XOFF. */
        xoff = REG_RD(ser, regi_ser, rw_xoff);
        
        xoff.chr = 0;
        xoff.automatic = regk_ser_no;
        
        REG_WR(ser, regi_ser, rw_xoff, xoff);

        /* Set baudrate and stopbits. */
        tr_ctrl = REG_RD(ser, regi_ser, rw_tr_ctrl);
        rec_ctrl = REG_RD(ser, regi_ser, rw_rec_ctrl);
        tr_baud = REG_RD(ser, regi_ser, rw_tr_baud_div);
        rec_baud = REG_RD(ser, regi_ser, rw_rec_baud_div);
        
        tr_ctrl.stop_bits = 1;  /* 2 stop bits. */
        tr_ctrl.en = 1; /* enable transmitter */
        rec_ctrl.en = 1; /* enabler receiver */
        
        /* 
         * The baudrate setup used to be a bit fishy, but now transmitter and
         * receiver are both set to the intended baud rate, 115200.
         * The magic value is 29.493 MHz.
         */
        tr_ctrl.base_freq = regk_ser_f29_493;
        rec_ctrl.base_freq = regk_ser_f29_493;
        tr_baud.div = (29493000 / 8) / 115200;
        rec_baud.div = (29493000 / 8) / 115200;
        
        REG_WR(ser, regi_ser, rw_tr_ctrl, tr_ctrl);
        REG_WR(ser, regi_ser, rw_tr_baud_div, tr_baud);
        REG_WR(ser, regi_ser, rw_rec_ctrl, rec_ctrl);
        REG_WR(ser, regi_ser, rw_rec_baud_div, rec_baud);
#endif /* CONFIG_ETRAX_DEBUG_PORT_NULL */
}

void
serial_init(void)
{
#ifndef CONFIG_ETRAX_DEBUG_PORT_NULL
        reg_pinmux_rw_hwprot hwprot;
        
        hwprot = REG_RD(pinmux, regi_pinmux, rw_hwprot);
#ifdef CONFIG_ETRAX_DEBUG_PORT0
        serial_setup(regi_ser0);
#endif
#ifdef CONFIG_ETRAX_DEBUG_PORT1
        hwprot.ser1 = regk_pinmux_yes;
        serial_setup(regi_ser1);
#endif
#ifdef CONFIG_ETRAX_DEBUG_PORT2
        hwprot.ser2 = regk_pinmux_yes;
        serial_setup(regi_ser2);
#endif
#ifdef CONFIG_ETRAX_DEBUG_PORT3
        hwprot.ser3 = regk_pinmux_yes;
        serial_setup(regi_ser3);
#endif
        REG_WR(pinmux, regi_pinmux, rw_hwprot, hwprot);
#endif /* CONFIG_ETRAX_DEBUG_PORT_NULL */
}

---