path: root/sys/dev/ice/ice_strings.c

/* SPDX-License-Identifier: BSD-3-Clause */
/*  Copyright (c) 2023, Intel Corporation
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 *   3. Neither the name of the Intel Corporation nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */
/*$FreeBSD$*/

/**
 * @file ice_strings.c
 * @brief functions to convert enumerated values to human readable strings
 *
 * Contains various functions which convert enumerated values into human
 * readable strings. Primarily this is used for error values, such as the
 * ice_status enum, the ice_aq_err values, or standard sys/errno.h values.
 *
 * Additionally, various other driver enumerations which are displayed via
 * sysctl have converter functions.
 *
 * Some of the functions return struct ice_str_buf, instead of a character
 * string pointer. This is a trick to allow the function to create a struct
 * with space to convert unknown numeric values into a string, and return the
 * contents via copying the struct memory back. The functions then have an
 * associated macro to access the string value immediately. This allows the
 * functions to return static strings for known values, and convert unknown
 * values into a numeric representation. It also does not require
 * pre-allocating storage at each callsite, or using a local static value
 * which wouldn't be re-entrant, and could collide if multiple threads call
 * the function. The extra copies are somewhat annoying, but generally the
 * error functions aren't expected to be in a hot path so this is an
 * acceptable trade off.
 */

#include "ice_lib.h"

/**
 * ice_aq_str - Convert an AdminQ error into a string
 * @aq_err: the AQ error code to convert
 *
 * Convert the AdminQ status into its string name, if known. Otherwise, format
 * the error as an integer.
 */
struct ice_str_buf
_ice_aq_str(enum ice_aq_err aq_err)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (aq_err) {
	case ICE_AQ_RC_OK:
		str = "OK";
		break;
	case ICE_AQ_RC_EPERM:
		str = "AQ_RC_EPERM";
		break;
	case ICE_AQ_RC_ENOENT:
		str = "AQ_RC_ENOENT";
		break;
	case ICE_AQ_RC_ESRCH:
		str = "AQ_RC_ESRCH";
		break;
	case ICE_AQ_RC_EINTR:
		str = "AQ_RC_EINTR";
		break;
	case ICE_AQ_RC_EIO:
		str = "AQ_RC_EIO";
		break;
	case ICE_AQ_RC_ENXIO:
		str = "AQ_RC_ENXIO";
		break;
	case ICE_AQ_RC_E2BIG:
		str = "AQ_RC_E2BIG";
		break;
	case ICE_AQ_RC_EAGAIN:
		str = "AQ_RC_EAGAIN";
		break;
	case ICE_AQ_RC_ENOMEM:
		str = "AQ_RC_ENOMEM";
		break;
	case ICE_AQ_RC_EACCES:
		str = "AQ_RC_EACCES";
		break;
	case ICE_AQ_RC_EFAULT:
		str = "AQ_RC_EFAULT";
		break;
	case ICE_AQ_RC_EBUSY:
		str = "AQ_RC_EBUSY";
		break;
	case ICE_AQ_RC_EEXIST:
		str = "AQ_RC_EEXIST";
		break;
	case ICE_AQ_RC_EINVAL:
		str = "AQ_RC_EINVAL";
		break;
	case ICE_AQ_RC_ENOTTY:
		str = "AQ_RC_ENOTTY";
		break;
	case ICE_AQ_RC_ENOSPC:
		str = "AQ_RC_ENOSPC";
		break;
	case ICE_AQ_RC_ENOSYS:
		str = "AQ_RC_ENOSYS";
		break;
	case ICE_AQ_RC_ERANGE:
		str = "AQ_RC_ERANGE";
		break;
	case ICE_AQ_RC_EFLUSHED:
		str = "AQ_RC_EFLUSHED";
		break;
	case ICE_AQ_RC_BAD_ADDR:
		str = "AQ_RC_BAD_ADDR";
		break;
	case ICE_AQ_RC_EMODE:
		str = "AQ_RC_EMODE";
		break;
	case ICE_AQ_RC_EFBIG:
		str = "AQ_RC_EFBIG";
		break;
	case ICE_AQ_RC_ESBCOMP:
		str = "AQ_RC_ESBCOMP";
		break;
	case ICE_AQ_RC_ENOSEC:
		str = "AQ_RC_ENOSEC";
		break;
	case ICE_AQ_RC_EBADSIG:
		str = "AQ_RC_EBADSIG";
		break;
	case ICE_AQ_RC_ESVN:
		str = "AQ_RC_ESVN";
		break;
	case ICE_AQ_RC_EBADMAN:
		str = "AQ_RC_EBADMAN";
		break;
	case ICE_AQ_RC_EBADBUF:
		str = "AQ_RC_EBADBUF";
		break;
	case ICE_AQ_RC_EACCES_BMCU:
		str = "AQ_RC_EACCES_BMCU";
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "%d", aq_err);

	return buf;
}

/**
 * ice_status_str - convert status err code to a string
 * @status: the status error code to convert
 *
 * Convert the status code into its string name if known.
 *
 * Otherwise, use the scratch space to format the status code into a number.
 */
struct ice_str_buf
_ice_status_str(enum ice_status status)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (status) {
	case ICE_SUCCESS:
		str = "OK";
		break;
	case ICE_ERR_PARAM:
		str = "ICE_ERR_PARAM";
		break;
	case ICE_ERR_NOT_IMPL:
		str = "ICE_ERR_NOT_IMPL";
		break;
	case ICE_ERR_NOT_READY:
		str = "ICE_ERR_NOT_READY";
		break;
	case ICE_ERR_NOT_SUPPORTED:
		str = "ICE_ERR_NOT_SUPPORTED";
		break;
	case ICE_ERR_BAD_PTR:
		str = "ICE_ERR_BAD_PTR";
		break;
	case ICE_ERR_INVAL_SIZE:
		str = "ICE_ERR_INVAL_SIZE";
		break;
	case ICE_ERR_DEVICE_NOT_SUPPORTED:
		str = "ICE_ERR_DEVICE_NOT_SUPPORTED";
		break;
	case ICE_ERR_RESET_FAILED:
		str = "ICE_ERR_RESET_FAILED";
		break;
	case ICE_ERR_FW_API_VER:
		str = "ICE_ERR_FW_API_VER";
		break;
	case ICE_ERR_NO_MEMORY:
		str = "ICE_ERR_NO_MEMORY";
		break;
	case ICE_ERR_CFG:
		str = "ICE_ERR_CFG";
		break;
	case ICE_ERR_OUT_OF_RANGE:
		str = "ICE_ERR_OUT_OF_RANGE";
		break;
	case ICE_ERR_ALREADY_EXISTS:
		str = "ICE_ERR_ALREADY_EXISTS";
		break;
	case ICE_ERR_NVM:
		str = "ICE_ERR_NVM";
		break;
	case ICE_ERR_NVM_CHECKSUM:
		str = "ICE_ERR_NVM_CHECKSUM";
		break;
	case ICE_ERR_BUF_TOO_SHORT:
		str = "ICE_ERR_BUF_TOO_SHORT";
		break;
	case ICE_ERR_NVM_BLANK_MODE:
		str = "ICE_ERR_NVM_BLANK_MODE";
		break;
	case ICE_ERR_IN_USE:
		str = "ICE_ERR_IN_USE";
		break;
	case ICE_ERR_MAX_LIMIT:
		str = "ICE_ERR_MAX_LIMIT";
		break;
	case ICE_ERR_RESET_ONGOING:
		str = "ICE_ERR_RESET_ONGOING";
		break;
	case ICE_ERR_HW_TABLE:
		str = "ICE_ERR_HW_TABLE";
		break;
	case ICE_ERR_FW_DDP_MISMATCH:
		str = "ICE_ERR_FW_DDP_MISMATCH";
		break;
	case ICE_ERR_DOES_NOT_EXIST:
		str = "ICE_ERR_DOES_NOT_EXIST";
		break;
	case ICE_ERR_AQ_ERROR:
		str = "ICE_ERR_AQ_ERROR";
		break;
	case ICE_ERR_AQ_TIMEOUT:
		str = "ICE_ERR_AQ_TIMEOUT";
		break;
	case ICE_ERR_AQ_FULL:
		str = "ICE_ERR_AQ_FULL";
		break;
	case ICE_ERR_AQ_NO_WORK:
		str = "ICE_ERR_AQ_NO_WORK";
		break;
	case ICE_ERR_AQ_EMPTY:
		str = "ICE_ERR_AQ_EMPTY";
		break;
	case ICE_ERR_AQ_FW_CRITICAL:
		str = "ICE_ERR_AQ_FW_CRITICAL";
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "%d", status);

	return buf;
}

/**
 * ice_err_str - convert error code to a string
 * @err: the error code to convert
 *
 * Convert an error code into its string/macro name if known. Note, it doesn't
 * handle negated errors.
 *
 * Otherwise, use the scratch space to format the error into a number.
 */
struct ice_str_buf
_ice_err_str(int err)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (err) {
	case 0:
		str = "OK";
		break;
	case EPERM:
		str = "EPERM";
		break;
	case ENOENT:
		str = "ENOENT";
		break;
	case ESRCH:
		str = "ESRCH";
		break;
	case EINTR:
		str = "EINTR";
		break;
	case EIO:
		str = "EIO";
		break;
	case ENXIO:
		str = "ENXIO";
		break;
	case E2BIG:
		str = "E2BIG";
		break;
	case ENOEXEC:
		str = "ENOEXEC";
		break;
	case EBADF:
		str = "EBADF";
		break;
	case ECHILD:
		str = "ECHILD";
		break;
	case EDEADLK:
		str = "EDEADLK";
		break;
	case ENOMEM:
		str = "ENOMEM";
		break;
	case EACCES:
		str = "EACCES";
		break;
	case EFAULT:
		str = "EFAULT";
		break;
	case ENOTBLK:
		str = "ENOTBLK";
		break;
	case EBUSY:
		str = "EBUSY";
		break;
	case EEXIST:
		str = "EEXIST";
		break;
	case EXDEV:
		str = "EXDEV";
		break;
	case ENODEV:
		str = "ENODEV";
		break;
	case ENOTDIR:
		str = "ENOTDIR";
		break;
	case EISDIR:
		str = "EISDIR";
		break;
	case EINVAL:
		str = "EINVAL";
		break;
	case ENFILE:
		str = "ENFILE";
		break;
	case EMFILE:
		str = "EMFILE";
		break;
	case ENOTTY:
		str = "ENOTTY";
		break;
	case ETXTBSY:
		str = "ETXTBSY";
		break;
	case EFBIG:
		str = "EFBIG";
		break;
	case ENOSPC:
		str = "ENOSPC";
		break;
	case ESPIPE:
		str = "ESPIPE";
		break;
	case EROFS:
		str = "EROFS";
		break;
	case EMLINK:
		str = "EMLINK";
		break;
	case EPIPE:
		str = "EPIPE";
		break;
	case EDOM:
		str = "EDOM";
		break;
	case ERANGE:
		str = "ERANGE";
		break;
	case EAGAIN:
		/* EWOULDBLOCK */
		str = "EAGAIN";
		break;
	case EINPROGRESS:
		str = "EINPROGRESS";
		break;
	case EALREADY:
		str = "EALREADY";
		break;
	case ENOTSOCK:
		str = "ENOTSOCK";
		break;
	case EDESTADDRREQ:
		str = "EDESTADDRREQ";
		break;
	case EMSGSIZE:
		str = "EMSGSIZE";
		break;
	case EPROTOTYPE:
		str = "EPROTOTYPE";
		break;
	case ENOPROTOOPT:
		str = "ENOPROTOOPT";
		break;
	case EPROTONOSUPPORT:
		str = "EPROTONOSUPPORT";
		break;
	case ESOCKTNOSUPPORT:
		str = "ESOCKTNOSUPPORT";
		break;
	case EOPNOTSUPP:
		str = "EOPNOTSUPP";
		break;
	case EPFNOSUPPORT:
		/* ENOTSUP */
		str = "EPFNOSUPPORT";
		break;
	case EAFNOSUPPORT:
		str = "EAFNOSUPPORT";
		break;
	case EADDRINUSE:
		str = "EADDRINUSE";
		break;
	case EADDRNOTAVAIL:
		str = "EADDRNOTAVAIL";
		break;
	case ENETDOWN:
		str = "ENETDOWN";
		break;
	case ENETUNREACH:
		str = "ENETUNREACH";
		break;
	case ENETRESET:
		str = "ENETRESET";
		break;
	case ECONNABORTED:
		str = "ECONNABORTED";
		break;
	case ECONNRESET:
		str = "ECONNRESET";
		break;
	case ENOBUFS:
		str = "ENOBUFS";
		break;
	case EISCONN:
		str = "EISCONN";
		break;
	case ENOTCONN:
		str = "ENOTCONN";
		break;
	case ESHUTDOWN:
		str = "ESHUTDOWN";
		break;
	case ETOOMANYREFS:
		str = "ETOOMANYREFS";
		break;
	case ETIMEDOUT:
		str = "ETIMEDOUT";
		break;
	case ECONNREFUSED:
		str = "ECONNREFUSED";
		break;
	case ELOOP:
		str = "ELOOP";
		break;
	case ENAMETOOLONG:
		str = "ENAMETOOLONG";
		break;
	case EHOSTDOWN:
		str = "EHOSTDOWN";
		break;
	case EHOSTUNREACH:
		str = "EHOSTUNREACH";
		break;
	case ENOTEMPTY:
		str = "ENOTEMPTY";
		break;
	case EPROCLIM:
		str = "EPROCLIM";
		break;
	case EUSERS:
		str = "EUSERS";
		break;
	case EDQUOT:
		str = "EDQUOT";
		break;
	case ESTALE:
		str = "ESTALE";
		break;
	case EREMOTE:
		str = "EREMOTE";
		break;
	case EBADRPC:
		str = "EBADRPC";
		break;
	case ERPCMISMATCH:
		str = "ERPCMISMATCH";
		break;
	case EPROGUNAVAIL:
		str = "EPROGUNAVAIL";
		break;
	case EPROGMISMATCH:
		str = "EPROGMISMATCH";
		break;
	case EPROCUNAVAIL:
		str = "EPROCUNAVAIL";
		break;
	case ENOLCK:
		str = "ENOLCK";
		break;
	case ENOSYS:
		str = "ENOSYS";
		break;
	case EFTYPE:
		str = "EFTYPE";
		break;
	case EAUTH:
		str = "EAUTH";
		break;
	case ENEEDAUTH:
		str = "ENEEDAUTH";
		break;
	case EIDRM:
		str = "EIDRM";
		break;
	case ENOMSG:
		str = "ENOMSG";
		break;
	case EOVERFLOW:
		str = "EOVERFLOW";
		break;
	case ECANCELED:
		str = "ECANCELED";
		break;
	case EILSEQ:
		str = "EILSEQ";
		break;
	case ENOATTR:
		str = "ENOATTR";
		break;
	case EDOOFUS:
		str = "EDOOFUS";
		break;
	case EBADMSG:
		str = "EBADMSG";
		break;
	case EMULTIHOP:
		str = "EMULTIHOP";
		break;
	case ENOLINK:
		str = "ENOLINK";
		break;
	case EPROTO:
		str = "EPROTO";
		break;
	case ENOTCAPABLE:
		str = "ENOTCAPABLE";
		break;
	case ECAPMODE:
		str = "ECAPMODE";
		break;
	case ENOTRECOVERABLE:
		str = "ENOTRECOVERABLE";
		break;
	case EOWNERDEAD:
		str = "EOWNERDEAD";
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "%d", err);

	return buf;
}

/**
 * ice_fec_str - convert fec mode enum to a string
 * @mode: the enum value to convert
 *
 * Convert an FEC mode enum to a string for display in a sysctl or log message.
 * Returns "Unknown" if the mode is not one of currently known FEC modes.
 */
const char *
ice_fec_str(enum ice_fec_mode mode)
{
	switch (mode) {
	case ICE_FEC_AUTO:
		return ICE_FEC_STRING_AUTO;
	case ICE_FEC_RS:
		return ICE_FEC_STRING_RS;
	case ICE_FEC_BASER:
		return ICE_FEC_STRING_BASER;
	case ICE_FEC_NONE:
		return ICE_FEC_STRING_NONE;
	case ICE_FEC_DIS_AUTO:
		return ICE_FEC_STRING_DIS_AUTO;
	}

	/* The compiler generates errors on unhandled enum values if we omit
	 * the default case.
	 */
	return "Unknown";
}

/**
 * ice_fc_str - convert flow control mode enum to a string
 * @mode: the enum value to convert
 *
 * Convert a flow control mode enum to a string for display in a sysctl or log
 * message. Returns "Unknown" if the mode is not one of currently supported or
 * known flow control modes.
 */
const char *
ice_fc_str(enum ice_fc_mode mode)
{
	switch (mode) {
	case ICE_FC_FULL:
		return ICE_FC_STRING_FULL;
	case ICE_FC_TX_PAUSE:
		return ICE_FC_STRING_TX;
	case ICE_FC_RX_PAUSE:
		return ICE_FC_STRING_RX;
	case ICE_FC_NONE:
		return ICE_FC_STRING_NONE;
	case ICE_FC_AUTO:
	case ICE_FC_PFC:
	case ICE_FC_DFLT:
		break;
	}

	/* The compiler generates errors on unhandled enum values if we omit
	 * the default case.
	 */
	return "Unknown";
}

/**
 * ice_fltr_flag_str - Convert filter flags to a string
 * @flag: the filter flags to convert
 *
 * Convert the u16 flag value of a filter into a readable string for
 * outputting in a sysctl.
 */
struct ice_str_buf
_ice_fltr_flag_str(u16 flag)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (flag) {
	case ICE_FLTR_RX:
		str = "RX";
		break;
	case ICE_FLTR_TX:
		str = "TX";
		break;
	case ICE_FLTR_TX_RX:
		str = "TX_RX";
		break;
	default:
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "%u", flag);

	return buf;
}

/**
 * ice_log_sev_str - Convert log level to a string
 * @log_level: the log level to convert
 *
 * Convert the u8 log level of a FW logging module into a readable
 * string for outputting in a sysctl.
 */
struct ice_str_buf
_ice_log_sev_str(u8 log_level)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (log_level) {
	case ICE_FWLOG_LEVEL_NONE:
		str = "none";
		break;
	case ICE_FWLOG_LEVEL_ERROR:
		str = "error";
		break;
	case ICE_FWLOG_LEVEL_WARNING:
		str = "warning";
		break;
	case ICE_FWLOG_LEVEL_NORMAL:
		str = "normal";
		break;
	case ICE_FWLOG_LEVEL_VERBOSE:
		str = "verbose";
		break;
	default:
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "%u", log_level);

	return buf;
}

/**
 * ice_fwd_act_str - convert filter action enum to a string
 * @action: the filter action to convert
 *
 * Convert an enum value of type enum ice_sw_fwd_act_type into a string, for
 * display in a sysctl filter list. Returns "UNKNOWN" for actions outside the
 * enumeration type.
 */
const char *
ice_fwd_act_str(enum ice_sw_fwd_act_type action)
{
	switch (action) {
	case ICE_FWD_TO_VSI:
		return "FWD_TO_VSI";
	case ICE_FWD_TO_VSI_LIST:
		return "FWD_TO_VSI_LIST";
	case ICE_FWD_TO_Q:
		return "FWD_TO_Q";
	case ICE_FWD_TO_QGRP:
		return "FWD_TO_QGRP";
	case ICE_DROP_PACKET:
		return "DROP_PACKET";
	case ICE_LG_ACTION:
		return "LG_ACTION";
	case ICE_INVAL_ACT:
		return "INVAL_ACT";
	}

	/* The compiler generates errors on unhandled enum values if we omit
	 * the default case.
	 */
	return "Unknown";
}

/**
 * ice_mdd_tx_tclan_str - Convert MDD Tx TCLAN event to a string
 * @event: the MDD event number to convert
 *
 * Convert the Tx TCLAN event value from the GL_MDET_TX_TCLAN register into
 * a human readable string for logging of MDD events.
 */
struct ice_str_buf
_ice_mdd_tx_tclan_str(u8 event)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (event) {
	case 0:
		str = "Wrong descriptor format/order";
		break;
	case 1:
		str = "Descriptor fetch failed";
		break;
	case 2:
		str = "Tail descriptor not EOP/NOP";
		break;
	case 3:
		str = "False scheduling error";
		break;
	case 4:
		str = "Tail value larger than ring len";
		break;
	case 5:
		str = "Too many data commands";
		break;
	case 6:
		str = "Zero packets sent in quanta";
		break;
	case 7:
		str = "Packet too small or too big";
		break;
	case 8:
		str = "TSO length doesn't match sum";
		break;
	case 9:
		str = "TSO tail reached before TLEN";
		break;
	case 10:
		str = "TSO max 3 descs for headers";
		break;
	case 11:
		str = "EOP on header descriptor";
		break;
	case 12:
		str = "MSS is 0 or TLEN is 0";
		break;
	case 13:
		str = "CTX desc invalid IPSec fields";
		break;
	case 14:
		str = "Quanta invalid # of SSO packets";
		break;
	case 15:
		str = "Quanta bytes exceeds pkt_len*64";
		break;
	case 16:
		str = "Quanta exceeds max_cmds_in_sq";
		break;
	case 17:
		str = "incoherent last_lso_quanta";
		break;
	case 18:
		str = "incoherent TSO TLEN";
		break;
	case 19:
		str = "Quanta: too many descriptors";
		break;
	case 20:
		str = "Quanta: # of packets mismatch";
		break;
	default:
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown Tx TCLAN event %u", event);

	return buf;
}

/**
 * ice_mdd_tx_pqm_str - Convert MDD Tx PQM event to a string
 * @event: the MDD event number to convert
 *
 * Convert the Tx PQM event value from the GL_MDET_TX_PQM register into
 * a human readable string for logging of MDD events.
 */
struct ice_str_buf
_ice_mdd_tx_pqm_str(u8 event)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (event) {
	case 0:
		str = "PCI_DUMMY_COMP";
		break;
	case 1:
		str = "PCI_UR_COMP";
		break;
	/* Index 2 is unused */
	case 3:
		str = "RCV_SH_BE_LSO";
		break;
	case 4:
		str = "Q_FL_MNG_EPY_CH";
		break;
	case 5:
		str = "Q_EPY_MNG_FL_CH";
		break;
	case 6:
		str = "LSO_NUMDESCS_ZERO";
		break;
	case 7:
		str = "LSO_LENGTH_ZERO";
		break;
	case 8:
		str = "LSO_MSS_BELOW_MIN";
		break;
	case 9:
		str = "LSO_MSS_ABOVE_MAX";
		break;
	case 10:
		str = "LSO_HDR_SIZE_ZERO";
		break;
	case 11:
		str = "RCV_CNT_BE_LSO";
		break;
	case 12:
		str = "SKIP_ONE_QT_ONLY";
		break;
	case 13:
		str = "LSO_PKTCNT_ZERO";
		break;
	case 14:
		str = "SSO_LENGTH_ZERO";
		break;
	case 15:
		str = "SSO_LENGTH_EXCEED";
		break;
	case 16:
		str = "SSO_PKTCNT_ZERO";
		break;
	case 17:
		str = "SSO_PKTCNT_EXCEED";
		break;
	case 18:
		str = "SSO_NUMDESCS_ZERO";
		break;
	case 19:
		str = "SSO_NUMDESCS_EXCEED";
		break;
	case 20:
		str = "TAIL_GT_RING_LENGTH";
		break;
	case 21:
		str = "RESERVED_DBL_TYPE";
		break;
	case 22:
		str = "ILLEGAL_HEAD_DROP_DBL";
		break;
	case 23:
		str = "LSO_OVER_COMMS_Q";
		break;
	case 24:
		str = "ILLEGAL_VF_QNUM";
		break;
	case 25:
		str = "QTAIL_GT_RING_LENGTH";
		break;
	default:
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown Tx PQM event %u", event);

	return buf;
}

/**
 * ice_mdd_rx_str - Convert MDD Rx queue event to a string
 * @event: the MDD event number to convert
 *
 * Convert the Rx queue event value from the GL_MDET_RX register into a human
 * readable string for logging of MDD events.
 */
struct ice_str_buf
_ice_mdd_rx_str(u8 event)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (event) {
	case 1:
		str = "Descriptor fetch failed";
		break;
	default:
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown Rx event %u", event);

	return buf;
}

/**
 * ice_state_to_str - Convert the state enum to a string value
 * @state: the state bit to convert
 *
 * Converts a given state bit to its human readable string name. If the enum
 * value is unknown, returns NULL;
 */
const char *
ice_state_to_str(enum ice_state state)
{
	switch (state) {
	case ICE_STATE_CONTROLQ_EVENT_PENDING:
		return "CONTROLQ_EVENT_PENDING";
	case ICE_STATE_VFLR_PENDING:
		return "VFLR_PENDING";
	case ICE_STATE_MDD_PENDING:
		return "MDD_PENDING";
	case ICE_STATE_RESET_OICR_RECV:
		return "RESET_OICR_RECV";
	case ICE_STATE_RESET_PFR_REQ:
		return "RESET_PFR_REQ";
	case ICE_STATE_PREPARED_FOR_RESET:
		return "PREPARED_FOR_RESET";
	case ICE_STATE_RESET_FAILED:
		return "RESET_FAILED";
	case ICE_STATE_DRIVER_INITIALIZED:
		return "DRIVER_INITIALIZED";
	case ICE_STATE_NO_MEDIA:
		return "NO_MEDIA";
	case ICE_STATE_RECOVERY_MODE:
		return "RECOVERY_MODE";
	case ICE_STATE_ROLLBACK_MODE:
		return "ROLLBACK_MODE";
	case ICE_STATE_LINK_STATUS_REPORTED:
		return "LINK_STATUS_REPORTED";
	case ICE_STATE_ATTACHING:
		return "ATTACHING";
	case ICE_STATE_DETACHING:
		return "DETACHING";
	case ICE_STATE_LINK_DEFAULT_OVERRIDE_PENDING:
		return "LINK_DEFAULT_OVERRIDE_PENDING";
	case ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER:
		return "LLDP_RX_FLTR_FROM_DRIVER";
	case ICE_STATE_MULTIPLE_TCS:
		return "MULTIPLE_TCS";
	case ICE_STATE_DO_FW_DEBUG_DUMP:
		return "DO_FW_DEBUG_DUMP";
	case ICE_STATE_LAST:
		return NULL;
	}

	return NULL;
}

/**
 * ice_fw_module_str - Convert a FW logging module to a string name
 * @module: the module to convert
 *
 * Given a FW logging module id, convert it to a shorthand human readable
 * name, for generating sysctl tunables.
 */
const char *
ice_fw_module_str(enum ice_aqc_fw_logging_mod module)
{
	switch (module) {
	case ICE_AQC_FW_LOG_ID_GENERAL:
		return "general";
	case ICE_AQC_FW_LOG_ID_CTRL:
		return "ctrl";
	case ICE_AQC_FW_LOG_ID_LINK:
		return "link";
	case ICE_AQC_FW_LOG_ID_LINK_TOPO:
		return "link_topo";
	case ICE_AQC_FW_LOG_ID_DNL:
		return "dnl";
	case ICE_AQC_FW_LOG_ID_I2C:
		return "i2c";
	case ICE_AQC_FW_LOG_ID_SDP:
		return "sdp";
	case ICE_AQC_FW_LOG_ID_MDIO:
		return "mdio";
	case ICE_AQC_FW_LOG_ID_ADMINQ:
		return "adminq";
	case ICE_AQC_FW_LOG_ID_HDMA:
		return "hdma";
	case ICE_AQC_FW_LOG_ID_LLDP:
		return "lldp";
	case ICE_AQC_FW_LOG_ID_DCBX:
		return "dcbx";
	case ICE_AQC_FW_LOG_ID_DCB:
		return "dcb";
	case ICE_AQC_FW_LOG_ID_XLR:
		return "xlr";
	case ICE_AQC_FW_LOG_ID_NVM:
		return "nvm";
	case ICE_AQC_FW_LOG_ID_AUTH:
		return "auth";
	case ICE_AQC_FW_LOG_ID_VPD:
		return "vpd";
	case ICE_AQC_FW_LOG_ID_IOSF:
		return "iosf";
	case ICE_AQC_FW_LOG_ID_PARSER:
		return "parser";
	case ICE_AQC_FW_LOG_ID_SW:
		return "sw";
	case ICE_AQC_FW_LOG_ID_SCHEDULER:
		return "scheduler";
	case ICE_AQC_FW_LOG_ID_TXQ:
		return "txq";
	case ICE_AQC_FW_LOG_ID_RSVD:
		return "acl";
	case ICE_AQC_FW_LOG_ID_POST:
		return "post";
	case ICE_AQC_FW_LOG_ID_WATCHDOG:
		return "watchdog";
	case ICE_AQC_FW_LOG_ID_TASK_DISPATCH:
		return "task_dispatch";
	case ICE_AQC_FW_LOG_ID_MNG:
		return "mng";
	case ICE_AQC_FW_LOG_ID_SYNCE:
		return "synce";
	case ICE_AQC_FW_LOG_ID_HEALTH:
		return "health";
	case ICE_AQC_FW_LOG_ID_TSDRV:
		return "tsdrv";
	case ICE_AQC_FW_LOG_ID_PFREG:
		return "pfreg";
	case ICE_AQC_FW_LOG_ID_MDLVER:
		return "mdlver";
	case ICE_AQC_FW_LOG_ID_MAX:
		return "unknown";
	}

	/* The compiler generates errors on unhandled enum values if we omit
	 * the default case.
	 */
	return "unknown";
}

/**
 * ice_fw_lldp_status - Convert FW LLDP status to a string
 * @lldp_status: firmware LLDP status value to convert
 *
 * Given the FW LLDP status, convert it to a human readable string.
 */
struct ice_str_buf
_ice_fw_lldp_status(u32 lldp_status)
{
	struct ice_str_buf buf = { .str = "" };
	const char *str = NULL;

	switch (lldp_status)
	{
	case ICE_LLDP_ADMINSTATUS_DIS:
		str = "DISABLED";
		break;
	case ICE_LLDP_ADMINSTATUS_ENA_RX:
		str = "ENA_RX";
		break;
	case ICE_LLDP_ADMINSTATUS_ENA_TX:
		str = "ENA_TX";
		break;
	case ICE_LLDP_ADMINSTATUS_ENA_RXTX:
		str = "ENA_RXTX";
		break;
	case 0xF:
		str = "NVM_DEFAULT";
		break;
	}

	if (str)
		snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
	else
		snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown LLDP status %u", lldp_status);

	return buf;
}