/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, v.1,  (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://opensource.org/licenses/CDDL-1.0.
* 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-2017 Cavium, Inc. 
* The contents of this file are subject to the terms of the Common Development 
* and Distribution License, v.1,  (the "License").

* You may not use this file except in compliance with the License.

* You can obtain a copy of the License at available 
* at http://opensource.org/licenses/CDDL-1.0

* See the License for the specific language governing permissions and 
* limitations under the License.
*/


#include "qede.h"

qede_link_props_t qede_def_link_props  = 
{
	GLDM_FIBER,
	B_TRUE,
	B_TRUE,
	B_TRUE,
	B_TRUE,
	B_TRUE,
	B_TRUE,
	B_TRUE,
	B_TRUE,
	B_FALSE
};
static void 
qede_cfg_get_val(qede_t  *qede,
    char *        pName,
    void *        pVal,
    int           defaultVal,
    boolean_t     boolVal)
{
	int val;
#define		QEDE_CFG_NAME_LEN_MAX 		128

	char name[QEDE_CFG_NAME_LEN_MAX];

	/* first check if the hardcoded default has been overridden */

	snprintf(name, QEDE_CFG_NAME_LEN_MAX, "default_%s", pName);

	val = ddi_prop_get_int(DDI_DEV_T_ANY,
		qede->dip,
		(DDI_PROP_NOTPROM | DDI_PROP_DONTPASS),
		name,
		defaultVal);
	/* now check for a config for this specific instance */

	snprintf(name, QEDE_CFG_NAME_LEN_MAX, "qede%d_%s", qede->instance, 
	    pName);

	val = ddi_prop_get_int(DDI_DEV_T_ANY,
		qede->dip,
		(DDI_PROP_NOTPROM | DDI_PROP_DONTPASS),
		name,
		val);

	if (boolVal) {
		*((boolean_t *)pVal) = (val) ? B_TRUE : B_FALSE;
	} else {
		*((int *)pVal) = val;
	}
}

void 
qede_cfg_init(qede_t *qede)
{

	int option;

	qede->checksum = DEFAULT_CKSUM_OFFLOAD;
	qede->enabled_offloads = QEDE_OFFLOAD_NONE;
	qede->mtu = DEFAULT_MTU;
	qede->num_fp = DEFAULT_FASTPATH_COUNT;
	qede->rx_ring_size = DEFAULT_RX_RING_SIZE;
	qede->tx_ring_size = DEFAULT_TX_RING_SIZE;
	qede->tx_recycle_threshold = DEFAULT_TX_RECYCLE_THRESHOLD;
	qede->rx_copy_threshold = DEFAULT_RX_COPY_THRESHOLD;
	qede->tx_bcopy_threshold = DEFAULT_TX_COPY_THRESHOLD;
	qede->lso_enable = B_TRUE;
	qede->lro_enable = B_TRUE;
	qede->log_enable = B_TRUE;
	qede->ecore_debug_level = DEFAULT_ECORE_DEBUG_LEVEL;
	qede->ecore_debug_module = DEFAULT_ECORE_DEBUG_MODULE;

	qede_cfg_get_val(qede, "checksum", 
			  &qede->checksum,
			  qede->checksum,
			  B_FALSE);
	switch(qede->checksum) {
	case USER_OPTION_CKSUM_L3:
	case USER_OPTION_CKSUM_L3_L4:
		qede->checksum = DEFAULT_CKSUM_OFFLOAD;
		break;
	}

	qede_cfg_get_val(qede, "mtu", &option,
	    qede->mtu,
	    B_FALSE);

	if (option != DEFAULT_JUMBO_MTU &&
	    option != DEFAULT_MTU) {
		qede->mtu = DEFAULT_MTU;
		qede->jumbo_enable = B_FALSE;
	} else {
		if (qede->mtu != option) {
		qede->mtu = option;
		}
		if (option == DEFAULT_JUMBO_MTU) {
		    qede->jumbo_enable = B_TRUE;
		}
	}

	qede_cfg_get_val(qede, "num_fp", &option,
	    qede->num_fp,
	    B_FALSE);
	qede->num_fp = (option < MIN_FASTPATH_COUNT) ?
	    MIN_FASTPATH_COUNT :
	    (option > MAX_FASTPATH_COUNT) ?
	    MAX_FASTPATH_COUNT :
	    option;

	qede_cfg_get_val(qede, "rx_ring_size", &option,
	    qede->rx_ring_size,
	    B_FALSE);
	qede->rx_ring_size = (option < MIN_RX_RING_SIZE) ?
	    MIN_RX_RING_SIZE :
	    (option > MAX_RX_RING_SIZE) ?
	    MAX_RX_RING_SIZE :
	    option;
	qede_cfg_get_val(qede, "tx_ring_size", &option,
	    qede->tx_ring_size,
	    B_FALSE);
	qede->tx_ring_size = (option < MIN_TX_RING_SIZE) ?
	    MIN_TX_RING_SIZE :
	    (option > MAX_TX_RING_SIZE) ?
	    MAX_TX_RING_SIZE :
	    option;
	qede_cfg_get_val(qede, "rx_copy_threshold", &option,
	    qede->rx_copy_threshold,
	    B_FALSE);
	qede_cfg_get_val(qede, "tx_copy_threshold", &option,
	    qede->tx_bcopy_threshold,
	    B_FALSE);
	qede_cfg_get_val(qede, "tx_recycle_threshold", &option,
	    qede->tx_bcopy_threshold,
	    B_FALSE);
	qede->tx_recycle_threshold =
	    (option < 0) ? 0:
	    (option > qede->tx_ring_size) ?
	    qede->tx_ring_size : option;
	qede_cfg_get_val(qede, "lso_enable", &option,
	    qede->lso_enable,
	    B_TRUE);
	qede->lso_enable = option;
	qede_cfg_get_val(qede, "lro_enable", &option,
	    qede->lro_enable,
	    B_TRUE);
	qede->lro_enable = option;

	if(qede->checksum != DEFAULT_CKSUM_OFFLOAD) {
		qede->lso_enable = B_FALSE;
		qede->lro_enable = B_FALSE;
	}

	qede_cfg_get_val(qede, "log_enable", &option,
	    qede->log_enable,
	    B_TRUE);
	qede_cfg_get_val(qede, "debug_level", &option,
	    qede->ecore_debug_level,
	    B_FALSE);
	qede->ecore_debug_level =  (uint32_t)((option < 0) ? 0 : option);

	qede_cfg_get_val(qede, "debug_module", &option,
	    qede->ecore_debug_module,
	    B_FALSE);
	qede->ecore_debug_module = (uint32_t)((option < 0) ? 0 : option);
}


void 
qede_cfg_reset(qede_t *qede)
{
	qede->params.link_state = 0;
	/* reset the link status */
	qede->props.link_speed = 0;
	qede->props.link_duplex = B_FALSE;
	qede->props.tx_pause = B_FALSE;
	qede->props.rx_pause = B_FALSE;
	qede->props.uptime = 0;

}