drivers/net/ethernet/wangxun/txgbe/txgbe_hw.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2015 - 2022 Beijing WangXun Technology Co., Ltd. */

#include <linux/etherdevice.h>
#include <linux/if_ether.h>
#include <linux/string.h>
#include <linux/iopoll.h>
#include <linux/types.h>
#include <linux/pci.h>

#include "../libwx/wx_type.h"
#include "../libwx/wx_hw.h"
#include "txgbe_type.h"
#include "txgbe_hw.h"
#include "txgbe.h"

/**
 *  txgbe_init_thermal_sensor_thresh - Inits thermal sensor thresholds
 *  @hw: pointer to hardware structure
 *
 *  Inits the thermal sensor thresholds according to the NVM map
 *  and save off the threshold and location values into mac.thermal_sensor_data
 **/
static void txgbe_init_thermal_sensor_thresh(struct txgbe_hw *hw)
{
	struct wx_hw *wxhw = &hw->wxhw;
	struct wx_thermal_sensor_data *data = &wxhw->mac.sensor;

	memset(data, 0, sizeof(struct wx_thermal_sensor_data));

	/* Only support thermal sensors attached to SP physical port 0 */
	if (wxhw->bus.func)
		return;

	wr32(wxhw, TXGBE_TS_CTL, TXGBE_TS_CTL_EVAL_MD);

	wr32(wxhw, WX_TS_INT_EN,
	     WX_TS_INT_EN_ALARM_INT_EN | WX_TS_INT_EN_DALARM_INT_EN);
	wr32(wxhw, WX_TS_EN, WX_TS_EN_ENA);

	data->alarm_thresh = 100;
	wr32(wxhw, WX_TS_ALARM_THRE, 677);
	data->dalarm_thresh = 90;
	wr32(wxhw, WX_TS_DALARM_THRE, 614);
}

/**
 *  txgbe_read_pba_string - Reads part number string from EEPROM
 *  @hw: pointer to hardware structure
 *  @pba_num: stores the part number string from the EEPROM
 *  @pba_num_size: part number string buffer length
 *
 *  Reads the part number string from the EEPROM.
 **/
int txgbe_read_pba_string(struct txgbe_hw *hw, u8 *pba_num, u32 pba_num_size)
{
	u16 pba_ptr, offset, length, data;
	struct wx_hw *wxhw = &hw->wxhw;
	int ret_val;

	if (!pba_num) {
		wx_err(wxhw, "PBA string buffer was null\n");
		return -EINVAL;
	}

	ret_val = wx_read_ee_hostif(wxhw,
				    wxhw->eeprom.sw_region_offset + TXGBE_PBANUM0_PTR,
				    &data);
	if (ret_val != 0) {
		wx_err(wxhw, "NVM Read Error\n");
		return ret_val;
	}

	ret_val = wx_read_ee_hostif(wxhw,
				    wxhw->eeprom.sw_region_offset + TXGBE_PBANUM1_PTR,
				    &pba_ptr);
	if (ret_val != 0) {
		wx_err(wxhw, "NVM Read Error\n");
		return ret_val;
	}

	/* if data is not ptr guard the PBA must be in legacy format which
	 * means pba_ptr is actually our second data word for the PBA number
	 * and we can decode it into an ascii string
	 */
	if (data != TXGBE_PBANUM_PTR_GUARD) {
		wx_err(wxhw, "NVM PBA number is not stored as string\n");

		/* we will need 11 characters to store the PBA */
		if (pba_num_size < 11) {
			wx_err(wxhw, "PBA string buffer too small\n");
			return -ENOMEM;
		}

		/* extract hex string from data and pba_ptr */
		pba_num[0] = (data >> 12) & 0xF;
		pba_num[1] = (data >> 8) & 0xF;
		pba_num[2] = (data >> 4) & 0xF;
		pba_num[3] = data & 0xF;
		pba_num[4] = (pba_ptr >> 12) & 0xF;
		pba_num[5] = (pba_ptr >> 8) & 0xF;
		pba_num[6] = '-';
		pba_num[7] = 0;
		pba_num[8] = (pba_ptr >> 4) & 0xF;
		pba_num[9] = pba_ptr & 0xF;

		/* put a null character on the end of our string */
		pba_num[10] = '\0';

		/* switch all the data but the '-' to hex char */
		for (offset = 0; offset < 10; offset++) {
			if (pba_num[offset] < 0xA)
				pba_num[offset] += '0';
			else if (pba_num[offset] < 0x10)
				pba_num[offset] += 'A' - 0xA;
		}

		return 0;
	}

	ret_val = wx_read_ee_hostif(wxhw, pba_ptr, &length);
	if (ret_val != 0) {
		wx_err(wxhw, "NVM Read Error\n");
		return ret_val;
	}

	if (length == 0xFFFF || length == 0) {
		wx_err(wxhw, "NVM PBA number section invalid length\n");
		return -EINVAL;
	}

	/* check if pba_num buffer is big enough */
	if (pba_num_size  < (((u32)length * 2) - 1)) {
		wx_err(wxhw, "PBA string buffer too small\n");
		return -ENOMEM;
	}

	/* trim pba length from start of string */
	pba_ptr++;
	length--;

	for (offset = 0; offset < length; offset++) {
		ret_val = wx_read_ee_hostif(wxhw, pba_ptr + offset, &data);
		if (ret_val != 0) {
			wx_err(wxhw, "NVM Read Error\n");
			return ret_val;
		}
		pba_num[offset * 2] = (u8)(data >> 8);
		pba_num[(offset * 2) + 1] = (u8)(data & 0xFF);
	}
	pba_num[offset * 2] = '\0';

	return 0;
}

/**
 *  txgbe_calc_eeprom_checksum - Calculates and returns the checksum
 *  @hw: pointer to hardware structure
 *  @checksum: pointer to cheksum
 *
 *  Returns a negative error code on error
 **/
static int txgbe_calc_eeprom_checksum(struct txgbe_hw *hw, u16 *checksum)
{
	struct wx_hw *wxhw = &hw->wxhw;
	u16 *eeprom_ptrs = NULL;
	u32 buffer_size = 0;
	u16 *buffer = NULL;
	u16 *local_buffer;
	int status;
	u16 i;

	wx_init_eeprom_params(wxhw);

	if (!buffer) {
		eeprom_ptrs = kvmalloc_array(TXGBE_EEPROM_LAST_WORD, sizeof(u16),
					     GFP_KERNEL);
		if (!eeprom_ptrs)
			return -ENOMEM;
		/* Read pointer area */
		status = wx_read_ee_hostif_buffer(wxhw, 0,
						  TXGBE_EEPROM_LAST_WORD,
						  eeprom_ptrs);
		if (status != 0) {
			wx_err(wxhw, "Failed to read EEPROM image\n");
			kvfree(eeprom_ptrs);
			return status;
		}
		local_buffer = eeprom_ptrs;
	} else {
		if (buffer_size < TXGBE_EEPROM_LAST_WORD)
			return -EFAULT;
		local_buffer = buffer;
	}

	for (i = 0; i < TXGBE_EEPROM_LAST_WORD; i++)
		if (i != wxhw->eeprom.sw_region_offset + TXGBE_EEPROM_CHECKSUM)
			*checksum += local_buffer[i];

	if (eeprom_ptrs)
		kvfree(eeprom_ptrs);

	if (*checksum > TXGBE_EEPROM_SUM)
		return -EINVAL;

	*checksum = TXGBE_EEPROM_SUM - *checksum;

	return 0;
}

/**
 *  txgbe_validate_eeprom_checksum - Validate EEPROM checksum
 *  @hw: pointer to hardware structure
 *  @checksum_val: calculated checksum
 *
 *  Performs checksum calculation and validates the EEPROM checksum.  If the
 *  caller does not need checksum_val, the value can be NULL.
 **/
int txgbe_validate_eeprom_checksum(struct txgbe_hw *hw, u16 *checksum_val)
{
	struct wx_hw *wxhw = &hw->wxhw;
	u16 read_checksum = 0;
	u16 checksum;
	int status;

	/* Read the first word from the EEPROM. If this times out or fails, do
	 * not continue or we could be in for a very long wait while every
	 * EEPROM read fails
	 */
	status = wx_read_ee_hostif(wxhw, 0, &checksum);
	if (status) {
		wx_err(wxhw, "EEPROM read failed\n");
		return status;
	}

	checksum = 0;
	status = txgbe_calc_eeprom_checksum(hw, &checksum);
	if (status != 0)
		return status;

	status = wx_read_ee_hostif(wxhw, wxhw->eeprom.sw_region_offset +
				   TXGBE_EEPROM_CHECKSUM, &read_checksum);
	if (status != 0)
		return status;

	/* Verify read checksum from EEPROM is the same as
	 * calculated checksum
	 */
	if (read_checksum != checksum) {
		status = -EIO;
		wx_err(wxhw, "Invalid EEPROM checksum\n");
	}

	/* If the user cares, return the calculated checksum */
	if (checksum_val)
		*checksum_val = checksum;

	return status;
}

static void txgbe_reset_misc(struct txgbe_hw *hw)
{
	struct wx_hw *wxhw = &hw->wxhw;

	wx_reset_misc(wxhw);
	txgbe_init_thermal_sensor_thresh(hw);
}

/**
 *  txgbe_reset_hw - Perform hardware reset
 *  @hw: pointer to hardware structure
 *
 *  Resets the hardware by resetting the transmit and receive units, masks
 *  and clears all interrupts, perform a PHY reset, and perform a link (MAC)
 *  reset.
 **/
int txgbe_reset_hw(struct txgbe_hw *hw)
{
	struct wx_hw *wxhw = &hw->wxhw;
	int status;

	/* Call adapter stop to disable tx/rx and clear interrupts */
	status = wx_stop_adapter(wxhw);
	if (status != 0)
		return status;

	if (!(((wxhw->subsystem_device_id & WX_NCSI_MASK) == WX_NCSI_SUP) ||
	      ((wxhw->subsystem_device_id & WX_WOL_MASK) == WX_WOL_SUP)))
		wx_reset_hostif(wxhw);

	usleep_range(10, 100);

	status = wx_check_flash_load(wxhw, TXGBE_SPI_ILDR_STATUS_LAN_SW_RST(wxhw->bus.func));
	if (status != 0)
		return status;

	txgbe_reset_misc(hw);

	/* Store the permanent mac address */
	wx_get_mac_addr(wxhw, wxhw->mac.perm_addr);

	/* Store MAC address from RAR0, clear receive address registers, and
	 * clear the multicast table.  Also reset num_rar_entries to 128,
	 * since we modify this value when programming the SAN MAC address.
	 */
	wxhw->mac.num_rar_entries = TXGBE_SP_RAR_ENTRIES;
	wx_init_rx_addrs(wxhw);

	pci_set_master(wxhw->pdev);

	return 0;
}