source: svn/newcon3bcm2_21bu/nexus/app/bapp_util.c

/******************************************************************************
 *    (c)2008-2009 Broadcom Corporation
 *
 * This program is the proprietary software of Broadcom Corporation and/or its licensors,
 * and may only be used, duplicated, modified or distributed pursuant to the terms and
 * conditions of a separate, written license agreement executed between you and Broadcom
 * (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
 * no license (express or implied), right to use, or waiver of any kind with respect to the
 * Software, and Broadcom expressly reserves all rights in and to the Software and all
 * intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
 * HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
 * NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
 *
 * Except as expressly set forth in the Authorized License,
 *
 * 1.     This program, including its structure, sequence and organization, constitutes the valuable trade
 * secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
 * and to use this information only in connection with your use of Broadcom integrated circuit products.
 *
 * 2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
 * AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
 * THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
 * OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
 * LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
 * OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
 * USE OR PERFORMANCE OF THE SOFTWARE.
 *
 * 3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
 * LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
 * EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
 * USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
 * ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
 * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
 * ANY LIMITED REMEDY.
 *
 * $brcm_Workfile:  $
 * $brcm_Revision:  $
 * $brcm_Date:  $
 *
 * Module Description:
 *
 * Revision History:
 *
 * Created: 09/28/2009 by Jeff Fisher
 *
 * $brcm_Log:  $
 * 
 *
 *****************************************************************************/
#include "bapp_util.h"
#include <string.h>
#include <sys/time.h>
BDBG_MODULE(bapp_util);         /* Register software module with debug interface */
/*
Summary:
        Utility IO function.
Description:
        Utility IO function to be used for pseudo IO.
*/

int bin_read( void *buffer, int size, int count, void *fp )
{
        bin_read_t *p_br = (bin_read_t*)fp;
        size = size * count;
        if (p_br->cnt + size > p_br->size)
        {
                BDBG_MSG(("Requesting more bytes than available (cnt = %d, size = %d,total = %d)\n",
                                  p_br->cnt,size,p_br->size));
                size = p_br->size - p_br->cnt;
        }

        memcpy(buffer,&p_br->data[p_br->cnt],size);
        p_br->cnt += size;
        return size;
}
/*
Summary:
        Utility IO function.
Description:
        Utility IO function to be used for pseudo IO.
*/

unsigned int bin_tell(void *fp )
{
        bin_read_t *p_br = (bin_read_t*)fp;

        return p_br->cnt;
}
/*
Summary:
        Utility IO function.
Description:
        Utility IO function to be used for pseudo IO.
*/

int bin_set(void *fp, int offset, int whence )
{
        bin_read_t *p_br = (bin_read_t*)fp;

        if ((whence != 0) || ((unsigned int)offset > p_br->size))
                return -1;

        p_br->cnt = offset;
        return 0;
}
#if 0
/**
Summary:
        Get ticks used to establish time deltas in the applicaiton.
**/

unsigned int bapp_util_get_ticks(void)
{
        struct timeval tv;

        GETTIMEOFDAY(&tv);

        return((tv.tv_sec * BAPP_TICKS_PER_SECOND) + (tv.tv_usec * BAPP_TICKS_PER_SECOND) / 1000000);
}
#endif

#define isaf(c)         ((c) >= 'a' && (c) <= 'f')
#define isAF(c)         ((c) >= 'A' && (c) <= 'Z')
#define isdigit(c)      ((c) >= '0' && (c) <= '9')

/**
Summary:
        Convert string to int value
**/
int bapp_util_atoi(unsigned char *str_p, int bytes)
{
        int i, value = 0;
        unsigned char c, *p;

        p = str_p;

        for (i = 0; i < bytes; i++)
        {
                value <<= 4;
                c = *p++;
                if (isdigit(c))
                        value |= (c - '0');
                else if (isaf(c))
                        value |= (c - 'a') + 10;
                else if (isAF(c))
                        value |= (c - 'A') + 10;
                else
                        return 0;
        }
        return value;
}

/****************************************************************
 * timeval_subtract
 *
 * INPUTS:      x,y - subtract the timevals
 * OUTPUTS:     result - result of x,y timeval subtract
 * RETURNS:     none
 * DESCRITPION: Subtract the `struct timeval' values X and Y,
 *              storing the result in RESULT.
 *              Return 1 if the difference is negative, otherwise 0
 ****************************************************************/

int timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y)
{
        /* Perform the carry for the later subtraction by updating y. */
        if (x->tv_usec < y->tv_usec)
        {
                int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
                y->tv_usec -= 1000000 * nsec;
                y->tv_sec += nsec;
        }
        if (x->tv_usec - y->tv_usec > 1000000)
        {
                int nsec = (x->tv_usec - y->tv_usec) / 1000000;
                y->tv_usec += 1000000 * nsec;
                y->tv_sec -= nsec;
        }

        /* Compute the time remaining to wait.
           tv_usec is certainly positive. */
        result->tv_sec = x->tv_sec - y->tv_sec;
        result->tv_usec = x->tv_usec - y->tv_usec;

        /* Return 1 if result is negative. */
        return x->tv_sec < y->tv_sec;
}
#define UNIT_ADDR_LEN 20
#define HW_ADDR_BYTES 5
static unsigned char s_unit_addr_str[UNIT_ADDR_LEN];
static unsigned char s_hw_addr_str[HW_ADDR_BYTES];

static const unsigned char crc8_table[] = 
{
          0, 155, 173,  54, 193,  90, 108, 247,  25, 130, 180,  47, 216,  67, 117, 238,
         50, 169, 159,   4, 243, 104,  94, 197,  43, 176, 134,  29, 234, 113,  71, 220,
        100, 255, 201,  82, 165,  62,   8, 147, 125, 230, 208,  75, 188,  39,  17, 138,
         86, 205, 251,  96, 151,  12,  58, 161,  79, 212, 226, 121, 142,  21,  35, 184,
        200,  83, 101, 254,   9, 146, 164,  63, 209,  74, 124, 231,  16, 139, 189,  38,
        250,  97,  87, 204,  59, 160, 150,  13, 227, 120,  78, 213,  34, 185, 143,  20,
        172,  55,   1, 154, 109, 246, 192,  91, 181,  46,  24, 131, 116, 239, 217,  66,
        158,   5,  51, 168,  95, 196, 242, 105, 135,  28,  42, 177,  70, 221, 235, 112,
         11, 144, 166,  61, 202,  81, 103, 252,  18, 137, 191,  36, 211,  72, 126, 229,
         57, 162, 148,  15, 248,  99,  85, 206,  32, 187, 141,  22, 225, 122,  76, 215,
        111, 244, 194,  89, 174,  53,   3, 152, 118, 237, 219,  64, 183,  44,  26, 129,
         93, 198, 240, 107, 156,   7,  49, 170,  68, 223, 233, 114, 133,  30,  40, 179,
        195,  88, 110, 245,   2, 153, 175,  52, 218,  65, 119, 236,  27, 128, 182,  45,
        241, 106,  92, 199,  48, 171, 157,   6, 232, 115,  69, 222,  41, 178, 132,  31,
        167,  60,  10, 145, 102, 253, 203,  80, 190,  37,  19, 136, 127, 228, 210,  73,
        149,  14,  56, 163,  84, 207, 249,  98, 140,  23,  33, 186,  77, 214, 224, 123,
};

/*
Summary:
        Return the mac address. Can return false if chip does not support HW address.
        An address to an array of at least 6 bytes must be provided.
*/
bool get_mac_address(unsigned char *hw_address)
{
        unsigned int upper,lower;
#if 1 /* Test value from UDTA CCAD spec with Radner stream captures */
        hw_address[0] = 0x12;
        hw_address[1] = 0xBE;
        hw_address[2] = 0x20;
        hw_address[3] = 0x00;
        hw_address[4] = 0x1C;
        hw_address[5] = 0xC3;
    return true;
#endif
}

/*
Summary:
        Return the 40 bit hardware address. Can return false if chip does not support HW address.
        An address to an array of at least 5 bytes must be provided.
*/
#define SWAP_INT(x)   ((((unsigned int)x & 0xFF) << 24) |(((unsigned int)x & 0xFF00) << 8) |(((unsigned int)x & 0xFF0000) >> 8) | (((unsigned int)x & 0xFF000000) >> 24))
bool get_hw_address(unsigned char *hw_address)
{
        unsigned int upper,lower;
#if 1 /* Test value from UDTA CCAD spec */
        hw_address[0] = 0xc3;
        hw_address[1] = 0x1c;
        hw_address[2] = 0x00;
        hw_address[3] = 0x20;
        hw_address[4] = 0xBE;

/* c3:1c:00:20:be */
#endif
        return true;
}

/*
Summary:
        Get the current utc time in seconds. 
        Return non-zero on failure.
*/
bool s_have_time = false;
unsigned int s_system_time = 0;
unsigned int s_system_offset = 0;
unsigned int s_dst_entry = 0;
unsigned int s_dst_exit = 0;
unsigned int s_dst_delta = 0;
bool get_utc_time(unsigned int *time )
{
        struct timeval tv;

        if (!s_have_time)
                return false;

        GETTIMEOFDAY(&tv);

        *time = s_system_time + (tv.tv_sec - s_system_offset);

        return true;
}

/*
Summary:
        Get the current UTC time, local offset and dst flag. 
        Returns non-zero when it is not possible to determine local time.
        Currently this function uses XDS local offset over one obtained from the TSIDs
        
*/
bool get_local_time(unsigned int *utc_secs )    /* Current UTC time in seconds adjusted to local time */
{
        if (!get_utc_time(utc_secs))
                return false;

        if ((*utc_secs >= s_dst_entry) && (*utc_secs <= s_dst_exit))
        {
                if (s_dst_delta == 0)
                        *utc_secs += 3600;
                else
                        *utc_secs += s_dst_delta * 60;
        }
        return true;
}

/*
Summary:
        8-bit CRC value based on  x^^8 + x^^7 + x^^4 + x^^3 + x + 1 polynomial used 
        to calculate CRC on 40-bit hardware address.  Defined in Appendix F of CCAD UDTA
        specification.
*/

static unsigned char calc_crc8_ua40(unsigned char *hw_address)
{
    unsigned char crc8;
        int i;

    crc8 = 0xFF;        /* Start with all 1s */
    for (i = 0; i < HW_ADDR_BYTES; i++) 
        {
        crc8 = crc8_table[crc8 ^ *hw_address];
        hw_address++;
    }
    return crc8;
}

/*
Summary:
        Return a null terminated string form of the hw_address (40 bit chip ID)
        
*/

char *get_unit_address_str()
{
        unsigned int lw,i;
        unsigned char crc8;
        unsigned char tmp_hw_addr_str[HW_ADDR_BYTES];
        
        get_hw_address(s_hw_addr_str);
        
        lw = ((uint32_t)s_hw_addr_str[3] << 24) | ((uint32_t)s_hw_addr_str[2] << 16) | ((uint32_t)s_hw_addr_str[1] << 8) | ((uint32_t)s_hw_addr_str[0]);
        /* memcpy(&lw,s_hw_addr_str,sizeof(lw)); */
    
        bapp_util_memset(s_unit_addr_str,0,UNIT_ADDR_LEN);

    snprintf(s_unit_addr_str,UNIT_ADDR_LEN,"%03d-%010u",s_hw_addr_str[4],lw);
    
        /* Add - at dash in the middle of the 10 digit number */
        s_unit_addr_str[15] = s_unit_addr_str[14];
        s_unit_addr_str[14] = s_unit_addr_str[13];
        s_unit_addr_str[13] = s_unit_addr_str[12];
        s_unit_addr_str[12] = s_unit_addr_str[11];
        s_unit_addr_str[11] = s_unit_addr_str[10];
        s_unit_addr_str[10] = s_unit_addr_str[9];
    s_unit_addr_str[9] = '-';

    /* figure check digits and append */
    crc8 = 0;
    if ((s_hw_addr_str[0] == 0) && (s_hw_addr_str[1] == 0) && (s_hw_addr_str[2] == 0) && (s_hw_addr_str[3] == 0) && (s_hw_addr_str[4] == 0)) 
                crc8 = 0;
        else
        {
                /* Swap order */
                for (i = 0; i < HW_ADDR_BYTES; i++) 
                        tmp_hw_addr_str[i] = s_hw_addr_str[4-i];
        crc8 = calc_crc8_ua40(tmp_hw_addr_str);
        }
    snprintf(&s_unit_addr_str[15],5,"-%03d",crc8);

    return s_unit_addr_str;
}


/*
Summary:
    Same as text box but with shadow.
Description:
    Same as text box but with shadow.
*/
#define TEXT_SHADDOW
int text_box_shadow(bgfx_surf_t *p_surf,       /* bgfx surface */
             bgfx_font_t *font,                 /* bgfx font */
            uint16_t x,                         /* x location in pixels */
            uint16_t y,                         /* y location in pixels */
            uint16_t width,                     /* width in pixels */
            uint16_t height,                    /* height in pixels */ 
            unsigned int *msg,                  /* UNI string */
            unsigned int msg_len,               /* Number of characters in the msg */
            bgfx_pixel c_f,                     /* palette index for forground text*/
            bgfx_pixel c_b,                     /* palette index for background text */
            int shadow_offset,                 /* offset from xy to place shadow (can be negative) */
            int line_spacing                    /* number of vertical pixels between lines */
            )
{
#ifdef TEXT_SHADDOW
    text_box(p_surf,font,x + shadow_offset,y + shadow_offset,width,height,msg,msg_len,c_b,line_spacing);
#endif
    text_box(p_surf,font,x,y,width,height,msg,msg_len,c_f,line_spacing);
    return 0;
}
/*
Summary:
    Perform a "hard" chip reset if possible.
*/
void chip_reset(void)
{
}

/*
Summary:
        Calculate the UTC time offset from Jan 6th 1980.  
        NOTE:  This function only works for times after Jan 6th, 1980
        
*/
#ifndef LINUX
        /* Jan 6, 1980 => Sunday */
        #define START_DAY       0
        #define START_YEAR      1980
#else
        /* Jan 1, 1970 => Thursday */
        #define START_DAY       3
        #define START_YEAR      1970
#endif

/* Days/month for non-leap year */
const unsigned char s_days_per_mon[] = 
{
        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
        31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
};

#define IS_LEAP_YEAR(y) ( !((y + START_YEAR) % 4) && ( ((y + START_YEAR) % 100) || !((y + START_YEAR) % 400) ) )
void utctime(unsigned int secs,struct utc_tm *p_tm)
{
        unsigned int yday,mon,t_val;
        unsigned char *p_dpm = (unsigned char*)s_days_per_mon;

        memset(p_tm,0,sizeof(struct utc_tm));

        /* seconds */
        p_tm->tm_sec = secs % 60;
        t_val = secs / 60;  /* minutes */

        /* minutes */
        p_tm->tm_min = t_val % 60;
        t_val /= 60; /* hours */

        /* hours */
        p_tm->tm_hour = t_val % 24;
        t_val /= 24;

        /* day of week */
    p_tm->tm_wday = t_val % 7;
    p_tm->tm_wday = (t_val - START_DAY) % 7;

        /* offset value to start of the year */
#ifndef LINUX
        t_val += 5;
#endif
        /* year */
    p_tm->tm_yday = t_val;
    p_tm->tm_year = 0;

    /* day of current year */
    while ((IS_LEAP_YEAR(p_tm->tm_year) && (p_tm->tm_yday > 365)) ||
            (!IS_LEAP_YEAR(p_tm->tm_year) && (p_tm->tm_yday > 364)))
    {
        if (IS_LEAP_YEAR(p_tm->tm_year))
            p_tm->tm_yday -= 366;
        else
            p_tm->tm_yday -= 365;
        p_tm->tm_year++;
    }

        if (IS_LEAP_YEAR(p_tm->tm_year))
                p_dpm += 12;

        yday = p_tm->tm_yday + 1;
        mon = 0;
    while(yday > p_dpm[mon])
    {
        yday -= p_dpm[mon];
                mon++;
        }

        /* month */
        p_tm->tm_mon = mon;

        /* day of month */
        p_tm->tm_mday = yday;

}