sys/dev/ice/ice_strings.c

   1 /* SPDX-License-Identifier: BSD-3-Clause */
   2 /*  Copyright (c) 2023, Intel Corporation
   3  *  All rights reserved.
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions are met:
   7  *
   8  *   1. Redistributions of source code must retain the above copyright notice,
   9  *      this list of conditions and the following disclaimer.
  10  *
  11  *   2. Redistributions in binary form must reproduce the above copyright
  12  *      notice, this list of conditions and the following disclaimer in the
  13  *      documentation and/or other materials provided with the distribution.
  14  *
  15  *   3. Neither the name of the Intel Corporation nor the names of its
  16  *      contributors may be used to endorse or promote products derived from
  17  *      this software without specific prior written permission.
  18  *
  19  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  *  POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /**
  33  * @file ice_strings.c
  34  * @brief functions to convert enumerated values to human readable strings
  35  *
  36  * Contains various functions which convert enumerated values into human
  37  * readable strings. Primarily this is used for error values, such as the
  38  * ice_status enum, the ice_aq_err values, or standard sys/errno.h values.
  39  *
  40  * Additionally, various other driver enumerations which are displayed via
  41  * sysctl have converter functions.
  42  *
  43  * Some of the functions return struct ice_str_buf, instead of a character
  44  * string pointer. This is a trick to allow the function to create a struct
  45  * with space to convert unknown numeric values into a string, and return the
  46  * contents via copying the struct memory back. The functions then have an
  47  * associated macro to access the string value immediately. This allows the
  48  * functions to return static strings for known values, and convert unknown
  49  * values into a numeric representation. It also does not require
  50  * pre-allocating storage at each callsite, or using a local static value
  51  * which wouldn't be re-entrant, and could collide if multiple threads call
  52  * the function. The extra copies are somewhat annoying, but generally the
  53  * error functions aren't expected to be in a hot path so this is an
  54  * acceptable trade off.
  55  */
  56
  57 #include "ice_lib.h"
  58
  59 /**
  60  * ice_aq_str - Convert an AdminQ error into a string
  61  * @aq_err: the AQ error code to convert
  62  *
  63  * Convert the AdminQ status into its string name, if known. Otherwise, format
  64  * the error as an integer.
  65  */
  66 struct ice_str_buf
  67 _ice_aq_str(enum ice_aq_err aq_err)
  68 {
  69         struct ice_str_buf buf = { .str = "" };
  70         const char *str = NULL;
  71
  72         switch (aq_err) {
  73         case ICE_AQ_RC_OK:
  74                 str = "OK";
  75                 break;
  76         case ICE_AQ_RC_EPERM:
  77                 str = "AQ_RC_EPERM";
  78                 break;
  79         case ICE_AQ_RC_ENOENT:
  80                 str = "AQ_RC_ENOENT";
  81                 break;
  82         case ICE_AQ_RC_ESRCH:
  83                 str = "AQ_RC_ESRCH";
  84                 break;
  85         case ICE_AQ_RC_EINTR:
  86                 str = "AQ_RC_EINTR";
  87                 break;
  88         case ICE_AQ_RC_EIO:
  89                 str = "AQ_RC_EIO";
  90                 break;
  91         case ICE_AQ_RC_ENXIO:
  92                 str = "AQ_RC_ENXIO";
  93                 break;
  94         case ICE_AQ_RC_E2BIG:
  95                 str = "AQ_RC_E2BIG";
  96                 break;
  97         case ICE_AQ_RC_EAGAIN:
  98                 str = "AQ_RC_EAGAIN";
  99                 break;
 100         case ICE_AQ_RC_ENOMEM:
 101                 str = "AQ_RC_ENOMEM";
 102                 break;
 103         case ICE_AQ_RC_EACCES:
 104                 str = "AQ_RC_EACCES";
 105                 break;
 106         case ICE_AQ_RC_EFAULT:
 107                 str = "AQ_RC_EFAULT";
 108                 break;
 109         case ICE_AQ_RC_EBUSY:
 110                 str = "AQ_RC_EBUSY";
 111                 break;
 112         case ICE_AQ_RC_EEXIST:
 113                 str = "AQ_RC_EEXIST";
 114                 break;
 115         case ICE_AQ_RC_EINVAL:
 116                 str = "AQ_RC_EINVAL";
 117                 break;
 118         case ICE_AQ_RC_ENOTTY:
 119                 str = "AQ_RC_ENOTTY";
 120                 break;
 121         case ICE_AQ_RC_ENOSPC:
 122                 str = "AQ_RC_ENOSPC";
 123                 break;
 124         case ICE_AQ_RC_ENOSYS:
 125                 str = "AQ_RC_ENOSYS";
 126                 break;
 127         case ICE_AQ_RC_ERANGE:
 128                 str = "AQ_RC_ERANGE";
 129                 break;
 130         case ICE_AQ_RC_EFLUSHED:
 131                 str = "AQ_RC_EFLUSHED";
 132                 break;
 133         case ICE_AQ_RC_BAD_ADDR:
 134                 str = "AQ_RC_BAD_ADDR";
 135                 break;
 136         case ICE_AQ_RC_EMODE:
 137                 str = "AQ_RC_EMODE";
 138                 break;
 139         case ICE_AQ_RC_EFBIG:
 140                 str = "AQ_RC_EFBIG";
 141                 break;
 142         case ICE_AQ_RC_ESBCOMP:
 143                 str = "AQ_RC_ESBCOMP";
 144                 break;
 145         case ICE_AQ_RC_ENOSEC:
 146                 str = "AQ_RC_ENOSEC";
 147                 break;
 148         case ICE_AQ_RC_EBADSIG:
 149                 str = "AQ_RC_EBADSIG";
 150                 break;
 151         case ICE_AQ_RC_ESVN:
 152                 str = "AQ_RC_ESVN";
 153                 break;
 154         case ICE_AQ_RC_EBADMAN:
 155                 str = "AQ_RC_EBADMAN";
 156                 break;
 157         case ICE_AQ_RC_EBADBUF:
 158                 str = "AQ_RC_EBADBUF";
 159                 break;
 160         case ICE_AQ_RC_EACCES_BMCU:
 161                 str = "AQ_RC_EACCES_BMCU";
 162                 break;
 163         }
 164
 165         if (str)
 166                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 167         else
 168                 snprintf(buf.str, ICE_STR_BUF_LEN, "%d", aq_err);
 169
 170         return buf;
 171 }
 172
 173 /**
 174  * ice_status_str - convert status err code to a string
 175  * @status: the status error code to convert
 176  *
 177  * Convert the status code into its string name if known.
 178  *
 179  * Otherwise, use the scratch space to format the status code into a number.
 180  */
 181 struct ice_str_buf
 182 _ice_status_str(enum ice_status status)
 183 {
 184         struct ice_str_buf buf = { .str = "" };
 185         const char *str = NULL;
 186
 187         switch (status) {
 188         case ICE_SUCCESS:
 189                 str = "OK";
 190                 break;
 191         case ICE_ERR_PARAM:
 192                 str = "ICE_ERR_PARAM";
 193                 break;
 194         case ICE_ERR_NOT_IMPL:
 195                 str = "ICE_ERR_NOT_IMPL";
 196                 break;
 197         case ICE_ERR_NOT_READY:
 198                 str = "ICE_ERR_NOT_READY";
 199                 break;
 200         case ICE_ERR_NOT_SUPPORTED:
 201                 str = "ICE_ERR_NOT_SUPPORTED";
 202                 break;
 203         case ICE_ERR_BAD_PTR:
 204                 str = "ICE_ERR_BAD_PTR";
 205                 break;
 206         case ICE_ERR_INVAL_SIZE:
 207                 str = "ICE_ERR_INVAL_SIZE";
 208                 break;
 209         case ICE_ERR_DEVICE_NOT_SUPPORTED:
 210                 str = "ICE_ERR_DEVICE_NOT_SUPPORTED";
 211                 break;
 212         case ICE_ERR_RESET_FAILED:
 213                 str = "ICE_ERR_RESET_FAILED";
 214                 break;
 215         case ICE_ERR_FW_API_VER:
 216                 str = "ICE_ERR_FW_API_VER";
 217                 break;
 218         case ICE_ERR_NO_MEMORY:
 219                 str = "ICE_ERR_NO_MEMORY";
 220                 break;
 221         case ICE_ERR_CFG:
 222                 str = "ICE_ERR_CFG";
 223                 break;
 224         case ICE_ERR_OUT_OF_RANGE:
 225                 str = "ICE_ERR_OUT_OF_RANGE";
 226                 break;
 227         case ICE_ERR_ALREADY_EXISTS:
 228                 str = "ICE_ERR_ALREADY_EXISTS";
 229                 break;
 230         case ICE_ERR_NVM:
 231                 str = "ICE_ERR_NVM";
 232                 break;
 233         case ICE_ERR_NVM_CHECKSUM:
 234                 str = "ICE_ERR_NVM_CHECKSUM";
 235                 break;
 236         case ICE_ERR_BUF_TOO_SHORT:
 237                 str = "ICE_ERR_BUF_TOO_SHORT";
 238                 break;
 239         case ICE_ERR_NVM_BLANK_MODE:
 240                 str = "ICE_ERR_NVM_BLANK_MODE";
 241                 break;
 242         case ICE_ERR_IN_USE:
 243                 str = "ICE_ERR_IN_USE";
 244                 break;
 245         case ICE_ERR_MAX_LIMIT:
 246                 str = "ICE_ERR_MAX_LIMIT";
 247                 break;
 248         case ICE_ERR_RESET_ONGOING:
 249                 str = "ICE_ERR_RESET_ONGOING";
 250                 break;
 251         case ICE_ERR_HW_TABLE:
 252                 str = "ICE_ERR_HW_TABLE";
 253                 break;
 254         case ICE_ERR_FW_DDP_MISMATCH:
 255                 str = "ICE_ERR_FW_DDP_MISMATCH";
 256                 break;
 257         case ICE_ERR_DOES_NOT_EXIST:
 258                 str = "ICE_ERR_DOES_NOT_EXIST";
 259                 break;
 260         case ICE_ERR_AQ_ERROR:
 261                 str = "ICE_ERR_AQ_ERROR";
 262                 break;
 263         case ICE_ERR_AQ_TIMEOUT:
 264                 str = "ICE_ERR_AQ_TIMEOUT";
 265                 break;
 266         case ICE_ERR_AQ_FULL:
 267                 str = "ICE_ERR_AQ_FULL";
 268                 break;
 269         case ICE_ERR_AQ_NO_WORK:
 270                 str = "ICE_ERR_AQ_NO_WORK";
 271                 break;
 272         case ICE_ERR_AQ_EMPTY:
 273                 str = "ICE_ERR_AQ_EMPTY";
 274                 break;
 275         case ICE_ERR_AQ_FW_CRITICAL:
 276                 str = "ICE_ERR_AQ_FW_CRITICAL";
 277                 break;
 278         }
 279
 280         if (str)
 281                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 282         else
 283                 snprintf(buf.str, ICE_STR_BUF_LEN, "%d", status);
 284
 285         return buf;
 286 }
 287
 288 /**
 289  * ice_err_str - convert error code to a string
 290  * @err: the error code to convert
 291  *
 292  * Convert an error code into its string/macro name if known. Note, it doesn't
 293  * handle negated errors.
 294  *
 295  * Otherwise, use the scratch space to format the error into a number.
 296  */
 297 struct ice_str_buf
 298 _ice_err_str(int err)
 299 {
 300         struct ice_str_buf buf = { .str = "" };
 301         const char *str = NULL;
 302
 303         switch (err) {
 304         case 0:
 305                 str = "OK";
 306                 break;
 307         case EPERM:
 308                 str = "EPERM";
 309                 break;
 310         case ENOENT:
 311                 str = "ENOENT";
 312                 break;
 313         case ESRCH:
 314                 str = "ESRCH";
 315                 break;
 316         case EINTR:
 317                 str = "EINTR";
 318                 break;
 319         case EIO:
 320                 str = "EIO";
 321                 break;
 322         case ENXIO:
 323                 str = "ENXIO";
 324                 break;
 325         case E2BIG:
 326                 str = "E2BIG";
 327                 break;
 328         case ENOEXEC:
 329                 str = "ENOEXEC";
 330                 break;
 331         case EBADF:
 332                 str = "EBADF";
 333                 break;
 334         case ECHILD:
 335                 str = "ECHILD";
 336                 break;
 337         case EDEADLK:
 338                 str = "EDEADLK";
 339                 break;
 340         case ENOMEM:
 341                 str = "ENOMEM";
 342                 break;
 343         case EACCES:
 344                 str = "EACCES";
 345                 break;
 346         case EFAULT:
 347                 str = "EFAULT";
 348                 break;
 349         case ENOTBLK:
 350                 str = "ENOTBLK";
 351                 break;
 352         case EBUSY:
 353                 str = "EBUSY";
 354                 break;
 355         case EEXIST:
 356                 str = "EEXIST";
 357                 break;
 358         case EXDEV:
 359                 str = "EXDEV";
 360                 break;
 361         case ENODEV:
 362                 str = "ENODEV";
 363                 break;
 364         case ENOTDIR:
 365                 str = "ENOTDIR";
 366                 break;
 367         case EISDIR:
 368                 str = "EISDIR";
 369                 break;
 370         case EINVAL:
 371                 str = "EINVAL";
 372                 break;
 373         case ENFILE:
 374                 str = "ENFILE";
 375                 break;
 376         case EMFILE:
 377                 str = "EMFILE";
 378                 break;
 379         case ENOTTY:
 380                 str = "ENOTTY";
 381                 break;
 382         case ETXTBSY:
 383                 str = "ETXTBSY";
 384                 break;
 385         case EFBIG:
 386                 str = "EFBIG";
 387                 break;
 388         case ENOSPC:
 389                 str = "ENOSPC";
 390                 break;
 391         case ESPIPE:
 392                 str = "ESPIPE";
 393                 break;
 394         case EROFS:
 395                 str = "EROFS";
 396                 break;
 397         case EMLINK:
 398                 str = "EMLINK";
 399                 break;
 400         case EPIPE:
 401                 str = "EPIPE";
 402                 break;
 403         case EDOM:
 404                 str = "EDOM";
 405                 break;
 406         case ERANGE:
 407                 str = "ERANGE";
 408                 break;
 409         case EAGAIN:
 410                 /* EWOULDBLOCK */
 411                 str = "EAGAIN";
 412                 break;
 413         case EINPROGRESS:
 414                 str = "EINPROGRESS";
 415                 break;
 416         case EALREADY:
 417                 str = "EALREADY";
 418                 break;
 419         case ENOTSOCK:
 420                 str = "ENOTSOCK";
 421                 break;
 422         case EDESTADDRREQ:
 423                 str = "EDESTADDRREQ";
 424                 break;
 425         case EMSGSIZE:
 426                 str = "EMSGSIZE";
 427                 break;
 428         case EPROTOTYPE:
 429                 str = "EPROTOTYPE";
 430                 break;
 431         case ENOPROTOOPT:
 432                 str = "ENOPROTOOPT";
 433                 break;
 434         case EPROTONOSUPPORT:
 435                 str = "EPROTONOSUPPORT";
 436                 break;
 437         case ESOCKTNOSUPPORT:
 438                 str = "ESOCKTNOSUPPORT";
 439                 break;
 440         case EOPNOTSUPP:
 441                 str = "EOPNOTSUPP";
 442                 break;
 443         case EPFNOSUPPORT:
 444                 /* ENOTSUP */
 445                 str = "EPFNOSUPPORT";
 446                 break;
 447         case EAFNOSUPPORT:
 448                 str = "EAFNOSUPPORT";
 449                 break;
 450         case EADDRINUSE:
 451                 str = "EADDRINUSE";
 452                 break;
 453         case EADDRNOTAVAIL:
 454                 str = "EADDRNOTAVAIL";
 455                 break;
 456         case ENETDOWN:
 457                 str = "ENETDOWN";
 458                 break;
 459         case ENETUNREACH:
 460                 str = "ENETUNREACH";
 461                 break;
 462         case ENETRESET:
 463                 str = "ENETRESET";
 464                 break;
 465         case ECONNABORTED:
 466                 str = "ECONNABORTED";
 467                 break;
 468         case ECONNRESET:
 469                 str = "ECONNRESET";
 470                 break;
 471         case ENOBUFS:
 472                 str = "ENOBUFS";
 473                 break;
 474         case EISCONN:
 475                 str = "EISCONN";
 476                 break;
 477         case ENOTCONN:
 478                 str = "ENOTCONN";
 479                 break;
 480         case ESHUTDOWN:
 481                 str = "ESHUTDOWN";
 482                 break;
 483         case ETOOMANYREFS:
 484                 str = "ETOOMANYREFS";
 485                 break;
 486         case ETIMEDOUT:
 487                 str = "ETIMEDOUT";
 488                 break;
 489         case ECONNREFUSED:
 490                 str = "ECONNREFUSED";
 491                 break;
 492         case ELOOP:
 493                 str = "ELOOP";
 494                 break;
 495         case ENAMETOOLONG:
 496                 str = "ENAMETOOLONG";
 497                 break;
 498         case EHOSTDOWN:
 499                 str = "EHOSTDOWN";
 500                 break;
 501         case EHOSTUNREACH:
 502                 str = "EHOSTUNREACH";
 503                 break;
 504         case ENOTEMPTY:
 505                 str = "ENOTEMPTY";
 506                 break;
 507         case EPROCLIM:
 508                 str = "EPROCLIM";
 509                 break;
 510         case EUSERS:
 511                 str = "EUSERS";
 512                 break;
 513         case EDQUOT:
 514                 str = "EDQUOT";
 515                 break;
 516         case ESTALE:
 517                 str = "ESTALE";
 518                 break;
 519         case EREMOTE:
 520                 str = "EREMOTE";
 521                 break;
 522         case EBADRPC:
 523                 str = "EBADRPC";
 524                 break;
 525         case ERPCMISMATCH:
 526                 str = "ERPCMISMATCH";
 527                 break;
 528         case EPROGUNAVAIL:
 529                 str = "EPROGUNAVAIL";
 530                 break;
 531         case EPROGMISMATCH:
 532                 str = "EPROGMISMATCH";
 533                 break;
 534         case EPROCUNAVAIL:
 535                 str = "EPROCUNAVAIL";
 536                 break;
 537         case ENOLCK:
 538                 str = "ENOLCK";
 539                 break;
 540         case ENOSYS:
 541                 str = "ENOSYS";
 542                 break;
 543         case EFTYPE:
 544                 str = "EFTYPE";
 545                 break;
 546         case EAUTH:
 547                 str = "EAUTH";
 548                 break;
 549         case ENEEDAUTH:
 550                 str = "ENEEDAUTH";
 551                 break;
 552         case EIDRM:
 553                 str = "EIDRM";
 554                 break;
 555         case ENOMSG:
 556                 str = "ENOMSG";
 557                 break;
 558         case EOVERFLOW:
 559                 str = "EOVERFLOW";
 560                 break;
 561         case ECANCELED:
 562                 str = "ECANCELED";
 563                 break;
 564         case EILSEQ:
 565                 str = "EILSEQ";
 566                 break;
 567         case ENOATTR:
 568                 str = "ENOATTR";
 569                 break;
 570         case EDOOFUS:
 571                 str = "EDOOFUS";
 572                 break;
 573         case EBADMSG:
 574                 str = "EBADMSG";
 575                 break;
 576         case EMULTIHOP:
 577                 str = "EMULTIHOP";
 578                 break;
 579         case ENOLINK:
 580                 str = "ENOLINK";
 581                 break;
 582         case EPROTO:
 583                 str = "EPROTO";
 584                 break;
 585         case ENOTCAPABLE:
 586                 str = "ENOTCAPABLE";
 587                 break;
 588         case ECAPMODE:
 589                 str = "ECAPMODE";
 590                 break;
 591         case ENOTRECOVERABLE:
 592                 str = "ENOTRECOVERABLE";
 593                 break;
 594         case EOWNERDEAD:
 595                 str = "EOWNERDEAD";
 596                 break;
 597         }
 598
 599         if (str)
 600                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 601         else
 602                 snprintf(buf.str, ICE_STR_BUF_LEN, "%d", err);
 603
 604         return buf;
 605 }
 606
 607 /**
 608  * ice_fec_str - convert fec mode enum to a string
 609  * @mode: the enum value to convert
 610  *
 611  * Convert an FEC mode enum to a string for display in a sysctl or log message.
 612  * Returns "Unknown" if the mode is not one of currently known FEC modes.
 613  */
 614 const char *
 615 ice_fec_str(enum ice_fec_mode mode)
 616 {
 617         switch (mode) {
 618         case ICE_FEC_AUTO:
 619                 return ICE_FEC_STRING_AUTO;
 620         case ICE_FEC_RS:
 621                 return ICE_FEC_STRING_RS;
 622         case ICE_FEC_BASER:
 623                 return ICE_FEC_STRING_BASER;
 624         case ICE_FEC_NONE:
 625                 return ICE_FEC_STRING_NONE;
 626         case ICE_FEC_DIS_AUTO:
 627                 return ICE_FEC_STRING_DIS_AUTO;
 628         }
 629
 630         /* The compiler generates errors on unhandled enum values if we omit
 631          * the default case.
 632          */
 633         return "Unknown";
 634 }
 635
 636 /**
 637  * ice_fc_str - convert flow control mode enum to a string
 638  * @mode: the enum value to convert
 639  *
 640  * Convert a flow control mode enum to a string for display in a sysctl or log
 641  * message. Returns "Unknown" if the mode is not one of currently supported or
 642  * known flow control modes.
 643  */
 644 const char *
 645 ice_fc_str(enum ice_fc_mode mode)
 646 {
 647         switch (mode) {
 648         case ICE_FC_FULL:
 649                 return ICE_FC_STRING_FULL;
 650         case ICE_FC_TX_PAUSE:
 651                 return ICE_FC_STRING_TX;
 652         case ICE_FC_RX_PAUSE:
 653                 return ICE_FC_STRING_RX;
 654         case ICE_FC_NONE:
 655                 return ICE_FC_STRING_NONE;
 656         case ICE_FC_AUTO:
 657         case ICE_FC_PFC:
 658         case ICE_FC_DFLT:
 659                 break;
 660         }
 661
 662         /* The compiler generates errors on unhandled enum values if we omit
 663          * the default case.
 664          */
 665         return "Unknown";
 666 }
 667
 668 /**
 669  * ice_fltr_flag_str - Convert filter flags to a string
 670  * @flag: the filter flags to convert
 671  *
 672  * Convert the u16 flag value of a filter into a readable string for
 673  * outputting in a sysctl.
 674  */
 675 struct ice_str_buf
 676 _ice_fltr_flag_str(u16 flag)
 677 {
 678         struct ice_str_buf buf = { .str = "" };
 679         const char *str = NULL;
 680
 681         switch (flag) {
 682         case ICE_FLTR_RX:
 683                 str = "RX";
 684                 break;
 685         case ICE_FLTR_TX:
 686                 str = "TX";
 687                 break;
 688         case ICE_FLTR_TX_RX:
 689                 str = "TX_RX";
 690                 break;
 691         default:
 692                 break;
 693         }
 694
 695         if (str)
 696                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 697         else
 698                 snprintf(buf.str, ICE_STR_BUF_LEN, "%u", flag);
 699
 700         return buf;
 701 }
 702
 703 /**
 704  * ice_log_sev_str - Convert log level to a string
 705  * @log_level: the log level to convert
 706  *
 707  * Convert the u8 log level of a FW logging module into a readable
 708  * string for outputting in a sysctl.
 709  */
 710 struct ice_str_buf
 711 _ice_log_sev_str(u8 log_level)
 712 {
 713         struct ice_str_buf buf = { .str = "" };
 714         const char *str = NULL;
 715
 716         switch (log_level) {
 717         case ICE_FWLOG_LEVEL_NONE:
 718                 str = "none";
 719                 break;
 720         case ICE_FWLOG_LEVEL_ERROR:
 721                 str = "error";
 722                 break;
 723         case ICE_FWLOG_LEVEL_WARNING:
 724                 str = "warning";
 725                 break;
 726         case ICE_FWLOG_LEVEL_NORMAL:
 727                 str = "normal";
 728                 break;
 729         case ICE_FWLOG_LEVEL_VERBOSE:
 730                 str = "verbose";
 731                 break;
 732         default:
 733                 break;
 734         }
 735
 736         if (str)
 737                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 738         else
 739                 snprintf(buf.str, ICE_STR_BUF_LEN, "%u", log_level);
 740
 741         return buf;
 742 }
 743
 744 /**
 745  * ice_fwd_act_str - convert filter action enum to a string
 746  * @action: the filter action to convert
 747  *
 748  * Convert an enum value of type enum ice_sw_fwd_act_type into a string, for
 749  * display in a sysctl filter list. Returns "UNKNOWN" for actions outside the
 750  * enumeration type.
 751  */
 752 const char *
 753 ice_fwd_act_str(enum ice_sw_fwd_act_type action)
 754 {
 755         switch (action) {
 756         case ICE_FWD_TO_VSI:
 757                 return "FWD_TO_VSI";
 758         case ICE_FWD_TO_VSI_LIST:
 759                 return "FWD_TO_VSI_LIST";
 760         case ICE_FWD_TO_Q:
 761                 return "FWD_TO_Q";
 762         case ICE_FWD_TO_QGRP:
 763                 return "FWD_TO_QGRP";
 764         case ICE_DROP_PACKET:
 765                 return "DROP_PACKET";
 766         case ICE_LG_ACTION:
 767                 return "LG_ACTION";
 768         case ICE_INVAL_ACT:
 769                 return "INVAL_ACT";
 770         }
 771
 772         /* The compiler generates errors on unhandled enum values if we omit
 773          * the default case.
 774          */
 775         return "Unknown";
 776 }
 777
 778 /**
 779  * ice_mdd_tx_tclan_str - Convert MDD Tx TCLAN event to a string
 780  * @event: the MDD event number to convert
 781  *
 782  * Convert the Tx TCLAN event value from the GL_MDET_TX_TCLAN register into
 783  * a human readable string for logging of MDD events.
 784  */
 785 struct ice_str_buf
 786 _ice_mdd_tx_tclan_str(u8 event)
 787 {
 788         struct ice_str_buf buf = { .str = "" };
 789         const char *str = NULL;
 790
 791         switch (event) {
 792         case 0:
 793                 str = "Wrong descriptor format/order";
 794                 break;
 795         case 1:
 796                 str = "Descriptor fetch failed";
 797                 break;
 798         case 2:
 799                 str = "Tail descriptor not EOP/NOP";
 800                 break;
 801         case 3:
 802                 str = "False scheduling error";
 803                 break;
 804         case 4:
 805                 str = "Tail value larger than ring len";
 806                 break;
 807         case 5:
 808                 str = "Too many data commands";
 809                 break;
 810         case 6:
 811                 str = "Zero packets sent in quanta";
 812                 break;
 813         case 7:
 814                 str = "Packet too small or too big";
 815                 break;
 816         case 8:
 817                 str = "TSO length doesn't match sum";
 818                 break;
 819         case 9:
 820                 str = "TSO tail reached before TLEN";
 821                 break;
 822         case 10:
 823                 str = "TSO max 3 descs for headers";
 824                 break;
 825         case 11:
 826                 str = "EOP on header descriptor";
 827                 break;
 828         case 12:
 829                 str = "MSS is 0 or TLEN is 0";
 830                 break;
 831         case 13:
 832                 str = "CTX desc invalid IPSec fields";
 833                 break;
 834         case 14:
 835                 str = "Quanta invalid # of SSO packets";
 836                 break;
 837         case 15:
 838                 str = "Quanta bytes exceeds pkt_len*64";
 839                 break;
 840         case 16:
 841                 str = "Quanta exceeds max_cmds_in_sq";
 842                 break;
 843         case 17:
 844                 str = "incoherent last_lso_quanta";
 845                 break;
 846         case 18:
 847                 str = "incoherent TSO TLEN";
 848                 break;
 849         case 19:
 850                 str = "Quanta: too many descriptors";
 851                 break;
 852         case 20:
 853                 str = "Quanta: # of packets mismatch";
 854                 break;
 855         default:
 856                 break;
 857         }
 858
 859         if (str)
 860                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 861         else
 862                 snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown Tx TCLAN event %u", event);
 863
 864         return buf;
 865 }
 866
 867 /**
 868  * ice_mdd_tx_pqm_str - Convert MDD Tx PQM event to a string
 869  * @event: the MDD event number to convert
 870  *
 871  * Convert the Tx PQM event value from the GL_MDET_TX_PQM register into
 872  * a human readable string for logging of MDD events.
 873  */
 874 struct ice_str_buf
 875 _ice_mdd_tx_pqm_str(u8 event)
 876 {
 877         struct ice_str_buf buf = { .str = "" };
 878         const char *str = NULL;
 879
 880         switch (event) {
 881         case 0:
 882                 str = "PCI_DUMMY_COMP";
 883                 break;
 884         case 1:
 885                 str = "PCI_UR_COMP";
 886                 break;
 887         /* Index 2 is unused */
 888         case 3:
 889                 str = "RCV_SH_BE_LSO";
 890                 break;
 891         case 4:
 892                 str = "Q_FL_MNG_EPY_CH";
 893                 break;
 894         case 5:
 895                 str = "Q_EPY_MNG_FL_CH";
 896                 break;
 897         case 6:
 898                 str = "LSO_NUMDESCS_ZERO";
 899                 break;
 900         case 7:
 901                 str = "LSO_LENGTH_ZERO";
 902                 break;
 903         case 8:
 904                 str = "LSO_MSS_BELOW_MIN";
 905                 break;
 906         case 9:
 907                 str = "LSO_MSS_ABOVE_MAX";
 908                 break;
 909         case 10:
 910                 str = "LSO_HDR_SIZE_ZERO";
 911                 break;
 912         case 11:
 913                 str = "RCV_CNT_BE_LSO";
 914                 break;
 915         case 12:
 916                 str = "SKIP_ONE_QT_ONLY";
 917                 break;
 918         case 13:
 919                 str = "LSO_PKTCNT_ZERO";
 920                 break;
 921         case 14:
 922                 str = "SSO_LENGTH_ZERO";
 923                 break;
 924         case 15:
 925                 str = "SSO_LENGTH_EXCEED";
 926                 break;
 927         case 16:
 928                 str = "SSO_PKTCNT_ZERO";
 929                 break;
 930         case 17:
 931                 str = "SSO_PKTCNT_EXCEED";
 932                 break;
 933         case 18:
 934                 str = "SSO_NUMDESCS_ZERO";
 935                 break;
 936         case 19:
 937                 str = "SSO_NUMDESCS_EXCEED";
 938                 break;
 939         case 20:
 940                 str = "TAIL_GT_RING_LENGTH";
 941                 break;
 942         case 21:
 943                 str = "RESERVED_DBL_TYPE";
 944                 break;
 945         case 22:
 946                 str = "ILLEGAL_HEAD_DROP_DBL";
 947                 break;
 948         case 23:
 949                 str = "LSO_OVER_COMMS_Q";
 950                 break;
 951         case 24:
 952                 str = "ILLEGAL_VF_QNUM";
 953                 break;
 954         case 25:
 955                 str = "QTAIL_GT_RING_LENGTH";
 956                 break;
 957         default:
 958                 break;
 959         }
 960
 961         if (str)
 962                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 963         else
 964                 snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown Tx PQM event %u", event);
 965
 966         return buf;
 967 }
 968
 969 /**
 970  * ice_mdd_rx_str - Convert MDD Rx queue event to a string
 971  * @event: the MDD event number to convert
 972  *
 973  * Convert the Rx queue event value from the GL_MDET_RX register into a human
 974  * readable string for logging of MDD events.
 975  */
 976 struct ice_str_buf
 977 _ice_mdd_rx_str(u8 event)
 978 {
 979         struct ice_str_buf buf = { .str = "" };
 980         const char *str = NULL;
 981
 982         switch (event) {
 983         case 1:
 984                 str = "Descriptor fetch failed";
 985                 break;
 986         default:
 987                 break;
 988         }
 989
 990         if (str)
 991                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
 992         else
 993                 snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown Rx event %u", event);
 994
 995         return buf;
 996 }
 997
 998 /**
 999  * ice_state_to_str - Convert the state enum to a string value
1000  * @state: the state bit to convert
1001  *
1002  * Converts a given state bit to its human readable string name. If the enum
1003  * value is unknown, returns NULL;
1004  */
1005 const char *
1006 ice_state_to_str(enum ice_state state)
1007 {
1008         switch (state) {
1009         case ICE_STATE_CONTROLQ_EVENT_PENDING:
1010                 return "CONTROLQ_EVENT_PENDING";
1011         case ICE_STATE_VFLR_PENDING:
1012                 return "VFLR_PENDING";
1013         case ICE_STATE_MDD_PENDING:
1014                 return "MDD_PENDING";
1015         case ICE_STATE_RESET_OICR_RECV:
1016                 return "RESET_OICR_RECV";
1017         case ICE_STATE_RESET_PFR_REQ:
1018                 return "RESET_PFR_REQ";
1019         case ICE_STATE_PREPARED_FOR_RESET:
1020                 return "PREPARED_FOR_RESET";
1021         case ICE_STATE_RESET_FAILED:
1022                 return "RESET_FAILED";
1023         case ICE_STATE_DRIVER_INITIALIZED:
1024                 return "DRIVER_INITIALIZED";
1025         case ICE_STATE_NO_MEDIA:
1026                 return "NO_MEDIA";
1027         case ICE_STATE_RECOVERY_MODE:
1028                 return "RECOVERY_MODE";
1029         case ICE_STATE_ROLLBACK_MODE:
1030                 return "ROLLBACK_MODE";
1031         case ICE_STATE_LINK_STATUS_REPORTED:
1032                 return "LINK_STATUS_REPORTED";
1033         case ICE_STATE_ATTACHING:
1034                 return "ATTACHING";
1035         case ICE_STATE_DETACHING:
1036                 return "DETACHING";
1037         case ICE_STATE_LINK_DEFAULT_OVERRIDE_PENDING:
1038                 return "LINK_DEFAULT_OVERRIDE_PENDING";
1039         case ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER:
1040                 return "LLDP_RX_FLTR_FROM_DRIVER";
1041         case ICE_STATE_MULTIPLE_TCS:
1042                 return "MULTIPLE_TCS";
1043         case ICE_STATE_DO_FW_DEBUG_DUMP:
1044                 return "DO_FW_DEBUG_DUMP";
1045         case ICE_STATE_LINK_ACTIVE_ON_DOWN:
1046                 return "LINK_ACTIVE_ON_DOWN";
1047         case ICE_STATE_FIRST_INIT_LINK:
1048                 return "FIRST_INIT_LINK";
1049         case ICE_STATE_LAST:
1050                 return NULL;
1051         }
1052
1053         return NULL;
1054 }
1055
1056 /**
1057  * ice_fw_module_str - Convert a FW logging module to a string name
1058  * @module: the module to convert
1059  *
1060  * Given a FW logging module id, convert it to a shorthand human readable
1061  * name, for generating sysctl tunables.
1062  */
1063 const char *
1064 ice_fw_module_str(enum ice_aqc_fw_logging_mod module)
1065 {
1066         switch (module) {
1067         case ICE_AQC_FW_LOG_ID_GENERAL:
1068                 return "general";
1069         case ICE_AQC_FW_LOG_ID_CTRL:
1070                 return "ctrl";
1071         case ICE_AQC_FW_LOG_ID_LINK:
1072                 return "link";
1073         case ICE_AQC_FW_LOG_ID_LINK_TOPO:
1074                 return "link_topo";
1075         case ICE_AQC_FW_LOG_ID_DNL:
1076                 return "dnl";
1077         case ICE_AQC_FW_LOG_ID_I2C:
1078                 return "i2c";
1079         case ICE_AQC_FW_LOG_ID_SDP:
1080                 return "sdp";
1081         case ICE_AQC_FW_LOG_ID_MDIO:
1082                 return "mdio";
1083         case ICE_AQC_FW_LOG_ID_ADMINQ:
1084                 return "adminq";
1085         case ICE_AQC_FW_LOG_ID_HDMA:
1086                 return "hdma";
1087         case ICE_AQC_FW_LOG_ID_LLDP:
1088                 return "lldp";
1089         case ICE_AQC_FW_LOG_ID_DCBX:
1090                 return "dcbx";
1091         case ICE_AQC_FW_LOG_ID_DCB:
1092                 return "dcb";
1093         case ICE_AQC_FW_LOG_ID_XLR:
1094                 return "xlr";
1095         case ICE_AQC_FW_LOG_ID_NVM:
1096                 return "nvm";
1097         case ICE_AQC_FW_LOG_ID_AUTH:
1098                 return "auth";
1099         case ICE_AQC_FW_LOG_ID_VPD:
1100                 return "vpd";
1101         case ICE_AQC_FW_LOG_ID_IOSF:
1102                 return "iosf";
1103         case ICE_AQC_FW_LOG_ID_PARSER:
1104                 return "parser";
1105         case ICE_AQC_FW_LOG_ID_SW:
1106                 return "sw";
1107         case ICE_AQC_FW_LOG_ID_SCHEDULER:
1108                 return "scheduler";
1109         case ICE_AQC_FW_LOG_ID_TXQ:
1110                 return "txq";
1111         case ICE_AQC_FW_LOG_ID_RSVD:
1112                 return "acl";
1113         case ICE_AQC_FW_LOG_ID_POST:
1114                 return "post";
1115         case ICE_AQC_FW_LOG_ID_WATCHDOG:
1116                 return "watchdog";
1117         case ICE_AQC_FW_LOG_ID_TASK_DISPATCH:
1118                 return "task_dispatch";
1119         case ICE_AQC_FW_LOG_ID_MNG:
1120                 return "mng";
1121         case ICE_AQC_FW_LOG_ID_SYNCE:
1122                 return "synce";
1123         case ICE_AQC_FW_LOG_ID_HEALTH:
1124                 return "health";
1125         case ICE_AQC_FW_LOG_ID_TSDRV:
1126                 return "tsdrv";
1127         case ICE_AQC_FW_LOG_ID_PFREG:
1128                 return "pfreg";
1129         case ICE_AQC_FW_LOG_ID_MDLVER:
1130                 return "mdlver";
1131         case ICE_AQC_FW_LOG_ID_MAX:
1132                 return "unknown";
1133         }
1134
1135         /* The compiler generates errors on unhandled enum values if we omit
1136          * the default case.
1137          */
1138         return "unknown";
1139 }
1140
1141 /**
1142  * ice_fw_lldp_status - Convert FW LLDP status to a string
1143  * @lldp_status: firmware LLDP status value to convert
1144  *
1145  * Given the FW LLDP status, convert it to a human readable string.
1146  */
1147 struct ice_str_buf
1148 _ice_fw_lldp_status(u32 lldp_status)
1149 {
1150         struct ice_str_buf buf = { .str = "" };
1151         const char *str = NULL;
1152
1153         switch (lldp_status)
1154         {
1155         case ICE_LLDP_ADMINSTATUS_DIS:
1156                 str = "DISABLED";
1157                 break;
1158         case ICE_LLDP_ADMINSTATUS_ENA_RX:
1159                 str = "ENA_RX";
1160                 break;
1161         case ICE_LLDP_ADMINSTATUS_ENA_TX:
1162                 str = "ENA_TX";
1163                 break;
1164         case ICE_LLDP_ADMINSTATUS_ENA_RXTX:
1165                 str = "ENA_RXTX";
1166                 break;
1167         case 0xF:
1168                 str = "NVM_DEFAULT";
1169                 break;
1170         }
1171
1172         if (str)
1173                 snprintf(buf.str, ICE_STR_BUF_LEN, "%s", str);
1174         else
1175                 snprintf(buf.str, ICE_STR_BUF_LEN, "Unknown LLDP status %u", lldp_status);
1176
1177         return buf;
1178 }