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