/*******************************************************************************
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 * Copyright 2014 QLogic Corporation
 * The contents of this file are subject to the terms of the
 * QLogic End User License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the License at
 * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
 * QLogic_End_User_Software_License.txt
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 *
 * Module Description:
 *      This file contains general LM utility functions
 *
 ******************************************************************************/

#include "lm5710.h"

#ifdef _VBD_CMD_
#include "everest_sim.h"
#endif

#define MASK_01010101 (((unsigned int)(-1))/3)
#define MASK_00110011 (((unsigned int)(-1))/5)
#define MASK_00001111 (((unsigned int)(-1))/17)

u32_t count_bits(u32_t n)
{
    n = (n & MASK_01010101) + ((n >> 1) & MASK_01010101) ;
    n = (n & MASK_00110011) + ((n >> 2) & MASK_00110011) ;
    n = (n & MASK_00001111) + ((n >> 4) & MASK_00001111) ;

    return n % 255 ;
}

unsigned long log2_align(unsigned long n)
{
    unsigned long ret = n ? 1 : 0;
    unsigned long _n  = n >> 1;

    while (_n)
    {
        _n >>= 1;
        ret <<= 1;
    }

    if (ret < n)
        ret <<= 1;

    return ret;
}
/**
 * @description
 * Should be moved to a common file.
 * Calculates the lower align of power 2.
 * Values lower than 0 are returned directly.
 * @param n
 *
 * @return unsigned long
 * lower align of power 2.
 */
unsigned long power2_lower_align(unsigned long n)
{
    unsigned long ret = 0;
    if(0 == n)
    {
        return 0;
    }

    if(TRUE == POWER_OF_2(n))
    {
        // The number is already a power of 2.
        return n;
    }

    //Calculates the lower align of power 2.
    ret = log2_align(n);
    DbgBreakIf(FALSE == POWER_OF_2(ret));
    ret >>= 1;

    return ret;
}
/*
Log2
this function calculates rounded LOG2 of a certain number
e.g.: LOG2(1080) = 10 (2^10=1024)
*/
u32_t LOG2(u32_t v){
    u32_t r=0;
    while (v >>= 1) {
        r++;
    }
    return r;
}

/**
 * @description
 *  Should be moved to a common place.
 *  Find the next power of 2 that is larger than "num".
 * @param num - The variable to find a power of 2 that is
 *            larger.
 * @param num_bits_supported - The largest number of bits
 *                           supported
 *
 * @return u32_t - The next power of 2 that is larger than
 *         "num".
 */
u32_t
upper_align_power_of_2(IN const u16_t num,
                       IN const u8_t num_bits_supported)
{
    u32_t const largest_power_of_2 = 1 << (num_bits_supported - 1);
    u32_t prev_power_of_2 = largest_power_of_2;
    u32_t cur_power_of_2 = 0;
    u8_t  i = 0;

    //This is not realy needed (the for also handles this case) but to avoide confusing
    if(num >= largest_power_of_2)
    {
        DbgBreakMsg("num is larger than num_bits_supported");
        return largest_power_of_2;
    }
    // Exception case
    if(0 == num)
    {
        return 1;
    }

    // Look for a value that is smaller than prev_power_of_2 and bigger than cur_power_of_2
    for (i = (num_bits_supported - 1) ; i != 0 ;i--)
    {
        cur_power_of_2 = 1 << (i);
        if(num > cur_power_of_2)
        {
            break;
        }
        prev_power_of_2 = cur_power_of_2;
    }
    return prev_power_of_2;
}

/**
 * General function that waits for a certain state to change,
 * not protocol specific. It takes into account vbd-commander
 * and reset-is-in-progress
 *
 * @param pdev
 * @param curr_state -> what to poll on
 * @param new_state -> what we're waiting for
 *
 * @return lm_status_t TIMEOUT if state didn't change, SUCCESS
 *         otherwise
 */


/**
 * @param pdev
 *
 * @return 0 if device is ASIC.
 */
int lm_chip_is_slow(struct _lm_device_t *pdev)
{
    u32_t val = 0;

    lm_reg_rd_ind(pdev, MISC_REG_CHIP_REV, &val);

    val = (val & 0xf) << 12;

    if (val > CHIP_REV_Cx) {
        DbgMessage(pdev, VERBOSEi, "Chip is slow\n");
        return 1;
    } else {
        return 0;
    }
}

lm_status_t lm_wait_state_change(struct _lm_device_t *pdev, volatile u32_t * curr_state, u32_t new_state)
{
    u32_t delay_us = 0;
    u32_t to_cnt   = 10000 + 2360; // We'll wait 10,000 times 100us (1 second) + 2360 times 25000us (59sec) = total 60 sec
                                                                    // (Winodws only note) the 25000 wait will cause wait to be without CPU stall (look in win_util.c)
    lm_status_t lm_status = LM_STATUS_SUCCESS;


#ifdef _VBD_CMD_
    if (!GET_FLAGS(*g_everest_sim_flags_ptr, EVEREST_SIM_RAMROD))
    {
        *curr_state = new_state;
        return lm_status;
    }
#endif


    /* wait for state change */
    while ((*curr_state != new_state) && to_cnt--)
    {
        delay_us = (to_cnt >= 2360) ? 100 : 25000 ;
        mm_wait(pdev, delay_us);

        #ifdef DOS
            sleep(0); // rescheduling threads, since we don't have a memory barrier.
        #elif defined(__LINUX)
            mm_read_barrier(); // synchronize on eth_con->con_state
        #endif

        // in case reset in progress
        // we won't get completion so no need to wait
        if( lm_reset_is_inprogress(pdev) )
        {
            lm_status = LM_STATUS_ABORTED;
            break;
        }
    }

    if ( *curr_state != new_state)
    {
        DbgMessage(pdev, FATAL,
                    "lm_wait_state_change: state change timeout, curr state=%d, expected new state=%d!\n",
                    *curr_state, new_state);
        if (!lm_reset_is_inprogress(pdev)) {
            #if defined(_VBD_)
            DbgBreak();
            #endif
            lm_status = LM_STATUS_TIMEOUT;
        }
    }

    return lm_status;
}

/*******************************************************************************
 * Description:
 *         Calculates crc 32 on a buffer
 *         Note: crc32_length MUST be aligned to 8
 * Return:
 ******************************************************************************/
u32_t calc_crc32( u8_t* crc32_packet, u32_t crc32_length, u32_t crc32_seed, u8_t complement)
{
   u32_t byte             = 0 ;
   u32_t bit              = 0 ;
   u8_t  msb              = 0 ; // 1
   u32_t temp             = 0 ;
   u32_t shft             = 0 ;
   u8_t  current_byte     = 0 ;
   u32_t crc32_result     = crc32_seed;
   const u32_t CRC32_POLY = 0x1edc6f41;
    if( CHK_NULL( crc32_packet) || ERR_IF( 0 == crc32_length ) || ERR_IF( 0 != ( crc32_length % 8 ) ) )
    {
        return crc32_result ;
    }
    for (byte = 0; byte < crc32_length; byte = byte + 1)
    {
        current_byte = crc32_packet[byte];
        for (bit = 0; bit < 8; bit = bit + 1)
        {
            msb = (u8_t)(crc32_result >> 31) ; // msb = crc32_result[31];
            crc32_result = crc32_result << 1;
            if ( msb != ( 0x1 & (current_byte>>bit)) ) // (msb != current_byte[bit])
            {
               crc32_result = crc32_result ^ CRC32_POLY;
               crc32_result |= 1 ;//crc32_result[0] = 1;
            }
         }
      }
      // Last step is to "mirror" every bit, swap the 4 bytes, and then complement each bit.
      //
      // Mirror:
      temp = crc32_result ;
      shft = sizeof(crc32_result) * 8 -1 ;
      for( crc32_result>>= 1; crc32_result; crc32_result>>= 1 )
      {
        temp <<= 1;
        temp  |= crc32_result & 1;
        shft-- ;
      }
      temp <<= shft ;
      //temp[31-bit] = crc32_result[bit];
      // Swap:
      // crc32_result = {temp[7:0], temp[15:8], temp[23:16], temp[31:24]};
      {
          u32_t t0, t1, t2, t3 ;
          t0 = ( ( 0x000000ff ) & ( temp >> 24 ) ) ; // temp >> 24 ;
          t1 = ( ( 0x0000ff00 ) & ( temp >> 8 ) ) ;
          t2 = ( ( 0x00ff0000 ) & ( temp << 8 ) ) ;
          t3 = ( ( 0xff000000 ) & ( temp << 24 ) ) ;
          crc32_result = t0 | t1 | t2 | t3 ;
      }
      // Complement:
      if (complement)
      {
          crc32_result = ~crc32_result ;
      }
      return crc32_result  ;
}

/**
 *  @brief: convert 4 bytes version into 32 bit BCD formatted version
 *
 *  1. Format the product_version string:
 *     a. The "Major, "Minor, "Build and "Sub build" bytes are BCD-encoded, and each byte holds two BCD digits.
 *     b. The semantics of these fields follow the semantics specified in DSP4004.
 *     c. The value 0xF in the most-significant nibble of a BCD-encoded value indicates that the most significant nibble should be ignored and the overall field treated as a single digit value.
 *     d. A value of 0xFF indicates that the entire field is not present. 0xFF is not allowed as a value for the fields.
 *     Example: Version 3.7.10.FF --> 0xF3F710FF
 *

 * @param[in] CONST u8_t IN ver_arr[4]
 *
 * @return u32_t value
 */
u32_t
convert_to_bcd( const u8_t IN ver_arr[4] )
{
    u32_t                 ver_32             = 0xffffffff;
    u8_t                  idx                = 0;
    u8_t                  ver_current        = 0;

    if ( ver_arr )
    {
        ver_32 = 0;

        // convert to BCD format
        // We have for sure 4 digits only
        // ARRSIZE(ver_arr) won't work here since in non x86 compile it is NOT 4....
        for( idx = 0; idx < 4; idx++ )
        {
            ver_current = ver_arr[idx];
            if ( 0 == ( ver_current & 0xf0 ) )
            {
                ver_current |= 0xf0 ;
            }
            ver_32 =  ( ver_32<<8 ) | ver_current ;
        }
    }

    return ver_32;
}