30#define SWITCHTEC_LIB_CORE
32#include "switchtec_priv.h"
35#include "switchtec/mrpc.h"
36#include "switchtec/errors.h"
37#include "switchtec/log.h"
38#include "switchtec/endian.h"
39#include "switchtec/utils.h"
81 unsigned short device_id;
90 {0x8531, SWITCHTEC_GEN3, SWITCHTEC_PFX},
91 {0x8532, SWITCHTEC_GEN3, SWITCHTEC_PFX},
92 {0x8533, SWITCHTEC_GEN3, SWITCHTEC_PFX},
93 {0x8534, SWITCHTEC_GEN3, SWITCHTEC_PFX},
94 {0x8535, SWITCHTEC_GEN3, SWITCHTEC_PFX},
95 {0x8536, SWITCHTEC_GEN3, SWITCHTEC_PFX},
96 {0x8541, SWITCHTEC_GEN3, SWITCHTEC_PSX},
97 {0x8542, SWITCHTEC_GEN3, SWITCHTEC_PSX},
98 {0x8543, SWITCHTEC_GEN3, SWITCHTEC_PSX},
99 {0x8544, SWITCHTEC_GEN3, SWITCHTEC_PSX},
100 {0x8545, SWITCHTEC_GEN3, SWITCHTEC_PSX},
101 {0x8546, SWITCHTEC_GEN3, SWITCHTEC_PSX},
102 {0x8551, SWITCHTEC_GEN3, SWITCHTEC_PAX},
103 {0x8552, SWITCHTEC_GEN3, SWITCHTEC_PAX},
104 {0x8553, SWITCHTEC_GEN3, SWITCHTEC_PAX},
105 {0x8554, SWITCHTEC_GEN3, SWITCHTEC_PAX},
106 {0x8555, SWITCHTEC_GEN3, SWITCHTEC_PAX},
107 {0x8556, SWITCHTEC_GEN3, SWITCHTEC_PAX},
108 {0x8561, SWITCHTEC_GEN3, SWITCHTEC_PFXL},
109 {0x8562, SWITCHTEC_GEN3, SWITCHTEC_PFXL},
110 {0x8563, SWITCHTEC_GEN3, SWITCHTEC_PFXL},
111 {0x8564, SWITCHTEC_GEN3, SWITCHTEC_PFXL},
112 {0x8565, SWITCHTEC_GEN3, SWITCHTEC_PFXL},
113 {0x8566, SWITCHTEC_GEN3, SWITCHTEC_PFXL},
114 {0x8571, SWITCHTEC_GEN3, SWITCHTEC_PFXI},
115 {0x8572, SWITCHTEC_GEN3, SWITCHTEC_PFXI},
116 {0x8573, SWITCHTEC_GEN3, SWITCHTEC_PFXI},
117 {0x8574, SWITCHTEC_GEN3, SWITCHTEC_PFXI},
118 {0x8575, SWITCHTEC_GEN3, SWITCHTEC_PFXI},
119 {0x8576, SWITCHTEC_GEN3, SWITCHTEC_PFXI},
120 {0x4000, SWITCHTEC_GEN4, SWITCHTEC_PFX},
121 {0x4084, SWITCHTEC_GEN4, SWITCHTEC_PFX},
122 {0x4068, SWITCHTEC_GEN4, SWITCHTEC_PFX},
123 {0x4052, SWITCHTEC_GEN4, SWITCHTEC_PFX},
124 {0x4036, SWITCHTEC_GEN4, SWITCHTEC_PFX},
125 {0x4028, SWITCHTEC_GEN4, SWITCHTEC_PFX},
126 {0x4100, SWITCHTEC_GEN4, SWITCHTEC_PSX},
127 {0x4184, SWITCHTEC_GEN4, SWITCHTEC_PSX},
128 {0x4168, SWITCHTEC_GEN4, SWITCHTEC_PSX},
129 {0x4152, SWITCHTEC_GEN4, SWITCHTEC_PSX},
130 {0x4136, SWITCHTEC_GEN4, SWITCHTEC_PSX},
131 {0x4128, SWITCHTEC_GEN4, SWITCHTEC_PSX},
132 {0x4200, SWITCHTEC_GEN4, SWITCHTEC_PAX},
133 {0x4284, SWITCHTEC_GEN4, SWITCHTEC_PAX},
134 {0x4268, SWITCHTEC_GEN4, SWITCHTEC_PAX},
135 {0x4252, SWITCHTEC_GEN4, SWITCHTEC_PAX},
136 {0x4236, SWITCHTEC_GEN4, SWITCHTEC_PAX},
137 {0x4352, SWITCHTEC_GEN4, SWITCHTEC_PFXA},
138 {0x4336, SWITCHTEC_GEN4, SWITCHTEC_PFXA},
139 {0x4328, SWITCHTEC_GEN4, SWITCHTEC_PFXA},
140 {0x4452, SWITCHTEC_GEN4, SWITCHTEC_PSXA},
141 {0x4436, SWITCHTEC_GEN4, SWITCHTEC_PSXA},
142 {0x4428, SWITCHTEC_GEN4, SWITCHTEC_PSXA},
143 {0x4552, SWITCHTEC_GEN4, SWITCHTEC_PAXA},
144 {0x4536, SWITCHTEC_GEN4, SWITCHTEC_PAXA},
145 {0x4528, SWITCHTEC_GEN4, SWITCHTEC_PAXA},
146 {0x4228, SWITCHTEC_GEN4, SWITCHTEC_PAX},
147 {0x5000, SWITCHTEC_GEN5, SWITCHTEC_PFX},
148 {0x5084, SWITCHTEC_GEN5, SWITCHTEC_PFX},
149 {0x5068, SWITCHTEC_GEN5, SWITCHTEC_PFX},
150 {0x5052, SWITCHTEC_GEN5, SWITCHTEC_PFX},
151 {0x5036, SWITCHTEC_GEN5, SWITCHTEC_PFX},
152 {0x5028, SWITCHTEC_GEN5, SWITCHTEC_PFX},
153 {0x5100, SWITCHTEC_GEN5, SWITCHTEC_PSX},
154 {0x5184, SWITCHTEC_GEN5, SWITCHTEC_PSX},
155 {0x5168, SWITCHTEC_GEN5, SWITCHTEC_PSX},
156 {0x5152, SWITCHTEC_GEN5, SWITCHTEC_PSX},
157 {0x5136, SWITCHTEC_GEN5, SWITCHTEC_PSX},
158 {0x5128, SWITCHTEC_GEN5, SWITCHTEC_PSX},
159 {0x5200, SWITCHTEC_GEN5, SWITCHTEC_PAX},
160 {0x5284, SWITCHTEC_GEN5, SWITCHTEC_PAX},
161 {0x5268, SWITCHTEC_GEN5, SWITCHTEC_PAX},
162 {0x5252, SWITCHTEC_GEN5, SWITCHTEC_PAX},
163 {0x5236, SWITCHTEC_GEN5, SWITCHTEC_PAX},
164 {0x5228, SWITCHTEC_GEN5, SWITCHTEC_PAX},
165 {0x5300, SWITCHTEC_GEN5, SWITCHTEC_PAXA},
166 {0x5384, SWITCHTEC_GEN5, SWITCHTEC_PAXA},
167 {0x5368, SWITCHTEC_GEN5, SWITCHTEC_PAXA},
168 {0x5352, SWITCHTEC_GEN5, SWITCHTEC_PAXA},
169 {0x5336, SWITCHTEC_GEN5, SWITCHTEC_PAXA},
170 {0x5328, SWITCHTEC_GEN5, SWITCHTEC_PAXA},
171 {0x5400, SWITCHTEC_GEN5, SWITCHTEC_PFXA},
172 {0x5484, SWITCHTEC_GEN5, SWITCHTEC_PFXA},
173 {0x5468, SWITCHTEC_GEN5, SWITCHTEC_PFXA},
174 {0x5452, SWITCHTEC_GEN5, SWITCHTEC_PFXA},
175 {0x5436, SWITCHTEC_GEN5, SWITCHTEC_PFXA},
176 {0x5428, SWITCHTEC_GEN5, SWITCHTEC_PFXA},
180static int set_gen_variant(
struct switchtec_dev * dev)
185 dev->boot_phase = SWITCHTEC_BOOT_PHASE_FW;
186 dev->gen = SWITCHTEC_GEN_UNKNOWN;
187 dev->var = SWITCHTEC_VAR_UNKNOWN;
188 dev->device_id = dev->ops->get_device_id(dev);
190 while (id->device_id) {
191 if (id->device_id == dev->device_id) {
208static int set_local_pax_id(
struct switchtec_dev *dev)
210 unsigned char local_pax_id;
213 dev->local_pax_id = -1;
219 &local_pax_id,
sizeof(local_pax_id));
223 dev->local_pax_id = local_pax_id;
261 struct switchtec_dev *ret;
263 if (sscanf(device,
"%i@%i", &bus, &dev) == 2) {
264 ret = switchtec_open_i2c_by_adapter(bus, dev);
268 if (sscanf(device,
"%2049[^@]@%i", path, &dev) == 2) {
273 if (device[0] ==
'/' &&
274 sscanf(device,
"%2049[^:]:%i", path, &dev) == 2) {
279 if (strchr(device,
'/') || strchr(device,
'\\')) {
284 if (sscanf(device,
"%x:%x.%x", &bus, &dev, &func) == 3) {
289 if (sscanf(device,
"%x:%x:%x.%x", &domain, &bus, &dev, &func) == 4) {
294 if (sscanf(device,
"%2049[^:]:%i", path, &inst) == 2) {
300 idx = strtol(device, &endptr, 0);
301 if (!errno && endptr != device) {
306 if (sscanf(device,
"switchtec%d", &idx) == 1) {
320 snprintf(ret->name,
sizeof(ret->name),
"%s", device);
322 if (set_gen_variant(ret))
325 if (set_local_pax_id(ret))
340 return dev->device_id;
376 return dev->boot_phase;
398 return dev->partition;
401int switchtec_set_pax_id(
struct switchtec_dev *dev,
int pax_id)
406 if (pax_id == SWITCHTEC_PAX_ID_LOCAL)
407 dev->pax_id = dev->local_pax_id;
409 dev->pax_id = pax_id;
414static int compare_port_id(
const void *aa,
const void *bb)
422 return a->
log_id - b->log_id;
425static int compare_status(
const void *aa,
const void *bb)
429 return compare_port_id(&a->
port, &b->port);
439 case 0:
return "Normal Lane Ordering";
440 case 1:
return "x16 (Full) Lane Reversal";
441 case 2:
return "x2 Lane Reversal";
442 case 4:
return "x4 Lane Reversal";
443 case 8:
return "x8 Lane Reversal";
444 default:
return "Unknown Lane Ordering";
467 s->lanes[l] =
'0' + i;
469 s->lanes[l] =
'a' + i - 10;
489 uint64_t port_bitmap = 0;
504 uint8_t phys_port_id;
511 uint8_t linkup_linkrate;
517 ret =
switchtec_cmd(dev, MRPC_LNKSTAT, &port_bitmap,
sizeof(port_bitmap),
518 ports,
sizeof(ports));
523 for (i = 0; i < max_ports; i++) {
524 if ((ports[i].stk_id >> 4) > SWITCHTEC_MAX_STACKS)
529 s = *status = calloc(nr_ports,
sizeof(*s));
533 for (i = 0, p = 0; i < max_ports && p < nr_ports; i++) {
534 if ((ports[i].stk_id >> 4) > SWITCHTEC_MAX_STACKS)
546 s[p].
link_up = ports[i].linkup_linkrate >> 7;
547 s[p].
link_rate = ports[i].linkup_linkrate & 0x7F;
548 s[p].
ltssm = le16toh(ports[i].LTSSM);
549 s[p].
ltssm_str = switchtec_ltssm_str(s[p].ltssm, 1);
555 generate_lane_str(&s[p]);
560 qsort(s, nr_ports,
sizeof(*s), compare_status);
575 for (i = 0; i < ports; i++) {
576 if (status[i].pci_bdf)
577 free(status[i].pci_bdf);
579 if (status[i].pci_bdf_path)
580 free(status[i].pci_bdf_path);
582 if (status[i].pci_dev)
583 free(status[i].pci_dev);
585 if (status[i].class_devices)
586 free(status[i].class_devices);
612 const char *msg =
"Unknown MRPC error";
615 if ((errno & (SWITCHTEC_ERRNO_MRPC_FLAG_BIT |
616 SWITCHTEC_ERRNO_GENERAL_FLAG_BIT)) == 0) {
618 return strerror(errno);
620 return platform_strerror();
623 if (errno & SWITCHTEC_ERRNO_GENERAL_FLAG_BIT) {
625 case SWITCHTEC_ERR_LOG_DEF_READ_ERROR:
626 msg =
"Error reading log definition file";
break;
627 case SWITCHTEC_ERR_BIN_LOG_READ_ERROR:
628 msg =
"Error reading binary log file";
break;
629 case SWITCHTEC_ERR_PARSED_LOG_WRITE_ERROR:
630 msg =
"Error writing parsed log file";
break;
631 case SWITCHTEC_ERR_LOG_DEF_DATA_INVAL:
632 msg =
"Invalid log definition data";
break;
633 case SWITCHTEC_ERR_INVALID_PORT:
634 msg =
"Invalid port specified";
break;
635 case SWITCHTEC_ERR_INVALID_LANE:
636 msg =
"Invalid lane specified";
break;
638 msg =
"Unknown Switchtec error";
break;
644 err = errno & ~SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
647 case ERR_NO_AVAIL_MRPC_THREAD:
648 msg =
"No available MRPC handler thread";
break;
649 case ERR_HANDLER_THREAD_NOT_IDLE:
650 msg =
"The handler thread is not idle";
break;
651 case ERR_NO_BG_THREAD:
652 msg =
"No background thread run for the command";
break;
654 case ERR_REFCLK_SUBCMD_INVALID:
655 case ERR_STACKBIF_SUBCMD_INVALID:
656 case ERR_SUBCMD_INVALID: msg =
"Invalid subcommand";
break;
657 case ERR_CMD_INVALID: msg =
"Invalid command";
break;
658 case ERR_PARAM_INVALID: msg =
"Invalid parameter";
break;
659 case ERR_BAD_FW_STATE: msg =
"Bad firmware state";
break;
660 case ERR_MRPC_DENIED: msg =
"MRPC request denied";
break;
661 case ERR_MRPC_NO_PREV_DATA:
662 msg =
"No previous adaptation object data";
664 case ERR_REFCLK_STACK_ID_INVALID:
665 case ERR_STACKBIF_STACK_ID_INVALID:
666 case ERR_STACK_INVALID: msg =
"Invalid Stack";
break;
667 case ERR_LOOPBACK_PORT_INVALID:
668 case ERR_PORT_INVALID: msg =
"Invalid Port";
break;
669 case ERR_EVENT_INVALID: msg =
"Invalid Event";
break;
670 case ERR_RST_RULE_FAILED: msg =
"Reset rule search failed";
break;
671 case ERR_UART_NOT_SUPPORTED:
672 msg =
"UART interface not supported for this command";
break;
673 case ERR_XML_VERSION_MISMATCH:
674 msg =
"XML version mismatch between MAIN and CFG partition";
676 case ERR_ACCESS_REFUSED: msg =
"Access Refused";
break;
678 case ERR_STACKBIF_CODE_INVALID:
679 msg =
"Stack bifurcation code invalid";
break;
681 case ERR_STACKBIF_PORT_BOUND:
682 msg =
"Port already bound";
break;
689 case MRPC_PORTPARTP2P:
691 case ERR_PHYC_PORT_ARDY_BIND:
692 msg =
"Physical port already bound";
break;
693 case ERR_LOGC_PORT_ARDY_BIND:
694 msg =
"Logical bridge instance already bound";
break;
695 case ERR_BIND_PRTT_NOT_EXIST:
696 msg =
"Partition does not exist";
break;
697 case ERR_PHYC_PORT_NOT_EXIST:
698 msg =
"Physical port does not exist";
break;
699 case ERR_PHYC_PORT_DIS:
700 msg =
"Physical port disabled";
break;
701 case ERR_NO_LOGC_PORT:
702 msg =
"No logical bridge instance";
break;
703 case ERR_BIND_IN_PROGRESS:
704 msg =
"Bind/unbind in progress";
break;
705 case ERR_BIND_TGT_IS_USP:
706 msg =
"Bind/unbind target is USP";
break;
707 case ERR_BIND_SUBCMD_INVALID:
708 msg =
"Sub-command does not exist";
break;
709 case ERR_PHYC_PORT_LINK_ACT:
710 msg =
"Physical port link active";
break;
711 case ERR_LOGC_PORT_NOT_BIND_PHYC_PORT:
712 msg =
"Logical bridge not bind to physical port";
break;
713 case ERR_UNBIND_OPT_INVALID:
714 msg =
"Invalid unbind option";
break;
715 case ERR_BIND_CHECK_FAIL:
716 msg =
"Port bind checking failed";
break;
736 int is_mrpc = errno & SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
737 int err = errno & ~SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
740 fprintf(stderr,
"%s: %s (MRPC: 0x%x, error: 0x%x)\n",
743 fprintf(stderr,
"%s: %s\n", str, msg);
768 output,
sizeof(*output));
784 return switchtec_cmd(dev, MRPC_RESET, &subcmd,
sizeof(subcmd),
829 for (i = defs->
num_alloc; i < num_modules; i++)
849 *val = strtol(str, &endptr, 0);
851 if ((endptr == str) || (*endptr !=
'\0') || (errno != 0))
878 while (fgets(line,
sizeof(line), log_def_file)) {
885 line[strcspn(line,
"\r\n")] =
'\0';
891 tok = strtok(line,
" \t");
895 tok = strtok(NULL,
" \t");
900 errno = SWITCHTEC_ERR_LOG_DEF_DATA_INVAL;
901 goto err_free_log_defs;
913 tok = strtok(NULL,
" \t");
918 errno = SWITCHTEC_ERR_LOG_DEF_DATA_INVAL;
919 goto err_free_log_defs;
928 if (!fgets(line,
sizeof(line),
940 goto err_free_log_defs;
943 if (fgets(line,
sizeof(line), log_def_file) == NULL) {
944 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
945 goto err_free_log_defs;
948 mod_defs->
entries[i] = strdup(line);
950 goto err_free_log_defs;
954 if (ferror(log_def_file)) {
955 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
956 goto err_free_log_defs;
977 int num_entries_alloc;
991 num_entries_alloc = 100;
992 mod_defs->
entries = calloc(num_entries_alloc,
995 goto err_free_log_defs;
997 while (fgets(line,
sizeof(line), log_def_file)) {
1004 num_entries_alloc *= 2;
1006 (num_entries_alloc *
1009 goto err_free_log_defs;
1014 goto err_free_log_defs;
1019 if (ferror(log_def_file)) {
1020 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
1021 goto err_free_log_defs;
1043 size_t count,
int init_entry_idx,
1046 FILE *log_file,
int ts_factor)
1050 int entry_idx = init_entry_idx;
1051 unsigned long long time;
1052 unsigned int nanos, micros, millis, secs, mins, hours, days;
1053 unsigned int entry_num;
1054 unsigned int mod_id;
1055 unsigned int log_sev = 0;
1056 const char *log_sev_strs[] = {
"DISABLED",
"HIGHEST",
"HIGH",
"MEDIUM",
1061 if (entry_idx == 0) {
1062 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP)
1063 fputs(
" #|Timestamp |Module |Severity |Event ID |Event\n",
1066 fputs(
" #|Timestamp |Source |Event ID |Event\n",
1070 for (i = 0; i < count; i ++) {
1072 time = (((
unsigned long long)log_data[i].data[0] << 32) |
1073 log_data[i].data[1]) * ts_factor/100;
1074 nanos = time % 1000;
1076 micros = time % 1000;
1078 millis = time % 1000;
1087 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP) {
1092 mod_id = (log_data[i].data[2] >> 16) & 0xFFF;
1093 log_sev = (log_data[i].data[2] >> 28) & 0xF;
1098 if (fprintf(log_file,
"(Invalid module ID: 0x%x)\n",
1100 goto ret_print_error;
1104 if (log_sev >= ARRAY_SIZE(log_sev_strs)) {
1105 if (fprintf(log_file,
"(Invalid log severity: %d)\n",
1107 goto ret_print_error;
1115 is_bl1 = (((log_data[i].data[2] >> 27) & 1) == 0);
1124 entry_num = log_data[i].data[2] & 0x0000FFFF;
1127 if (fprintf(log_file,
1128 "(Invalid log entry number: %d (module 0x%x))\n",
1129 entry_num, mod_id) < 0)
1130 goto ret_print_error;
1136 ret = fprintf(log_file,
1137 "%04d|xxxd xx:xx:xx.xxx,xxx,xxx|",
1140 ret = fprintf(log_file,
1141 "%04d|%03dd %02d:%02d:%02d.%03d,%03d,%03d|",
1142 entry_idx, days, hours, mins, secs,
1143 millis, micros, nanos);
1146 goto ret_print_error;
1148 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP) {
1150 if (fprintf(log_file,
"%-12s |%-8s |0x%04x |",
1151 mod_defs->
mod_name, log_sev_strs[log_sev],
1153 goto ret_print_error;
1156 if (fprintf(log_file,
"%-6s |0x%04x |",
1157 (is_bl1 ?
"BL1" :
"BL2"), entry_num) < 0)
1158 goto ret_print_error;
1162 if (fprintf(log_file, mod_defs->
entries[entry_num],
1163 log_data[i].data[3], log_data[i].data[4],
1164 log_data[i].data[5], log_data[i].data[6],
1165 log_data[i].data[7]) < 0)
1166 goto ret_print_error;
1171 if (fflush(log_file) != 0)
1177 errno = SWITCHTEC_ERR_PARSED_LOG_WRITE_ERROR;
1181static int parse_def_header(FILE *log_def_file, uint32_t *fw_version,
1182 uint32_t *sdk_version)
1189 while (fgets(line,
sizeof(line), log_def_file)) {
1194 while (line[i] ==
' ' || line[i] ==
'#') i++;
1196 if (strncasecmp(line + i,
"SDK Version:", 12) == 0) {
1198 while (line[i] ==
' ') i++;
1199 sscanf(line + i,
"%i", (
int*)sdk_version);
1201 else if (strncasecmp(line + i,
"FW Version:", 11) == 0) {
1203 while (line[i] ==
' ') i++;
1204 sscanf(line + i,
"%i", (
int*)fw_version);
1208 rewind(log_def_file);
1212static int append_log_header(
int fd, uint32_t sdk_version,
1213 uint32_t fw_version,
int binary)
1218 uint32_t fw_version;
1219 uint32_t sdk_version;
1223 .magic = {
'S',
'W',
'M',
'C',
'L',
'O',
'G',
'F'},
1224 .fw_version = fw_version,
1225 .sdk_version = sdk_version
1227 char hdr_str_fmt[] =
"#########################\n"
1228 "## FW version %08x\n"
1229 "## SDK version %08x\n"
1230 "#########################\n\n";
1234 ret = write(fd, &header,
sizeof(header));
1236 snprintf(hdr_str, 512, hdr_str_fmt, fw_version, sdk_version);
1237 ret = write(fd, hdr_str, strlen(hdr_str));
1245 if (gen == SWITCHTEC_GEN_UNKNOWN)
1247 else if (gen == SWITCHTEC_GEN3)
1253static int log_a_to_file(
struct switchtec_dev *dev,
int sub_cmd_id,
1254 int fd, FILE *log_def_file,
1261 .sub_cmd_id = sub_cmd_id,
1265 .module_defs = NULL,
1269 uint32_t fw_version = 0;
1270 uint32_t sdk_version = 0;
1272 if (log_def_file != NULL) {
1273 ret = parse_def_header(log_def_file, &fw_version,
1285 while (res.hdr.remain) {
1289 goto ret_free_log_defs;
1290 if (res.hdr.overflow && info)
1293 if (dev->gen < SWITCHTEC_GEN5) {
1294 res.hdr.sdk_version = 0;
1295 res.hdr.fw_version = 0;
1299 info->def_fw_version = fw_version;
1300 info->def_sdk_version = sdk_version;
1301 info->log_fw_version = res.hdr.fw_version;
1302 info->log_sdk_version = res.hdr.sdk_version;
1305 if (res.hdr.sdk_version != sdk_version ||
1306 res.hdr.fw_version != fw_version) {
1307 if (info && log_def_file)
1308 info->version_mismatch =
true;
1312 append_log_header(fd, res.hdr.sdk_version,
1314 log_def_file == NULL? 1 : 0);
1317 if (log_def_file == NULL) {
1319 ret = write(fd, res.data,
1320 sizeof(*res.data) * res.hdr.count);
1324 log_file = fdopen(fd,
"w");
1326 goto ret_free_log_defs;
1331 SWITCHTEC_LOG_PARSE_TYPE_APP,
1333 get_ts_factor(dev->gen));
1335 goto ret_free_log_defs;
1337 entry_idx += res.hdr.count;
1340 read += le32toh(res.hdr.count);
1341 cmd.start = res.hdr.next_start;
1351static int log_b_to_file(
struct switchtec_dev *dev,
int sub_cmd_id,
int fd)
1357 .sub_cmd_id = sub_cmd_id,
1359 .length = htole32(
sizeof(res.data)),
1362 res.hdr.remain =
sizeof(res.data);
1364 while (res.hdr.remain) {
1370 ret = write(fd, res.data, res.hdr.length);
1374 read += le32toh(res.hdr.length);
1375 cmd.offset = htole32(read);
1381static int log_c_to_file(
struct switchtec_dev *dev,
int sub_cmd_id,
int fd)
1392 uint32_t nvlog_version;
1393 uint32_t thread_handle;
1394 uint32_t fw_version;
1395 uint32_t timestamp1;
1396 uint32_t timestamp2;
1399 cmd.subcmd = sub_cmd_id;
1402 &reply,
sizeof(reply));
1406 ret = write(fd, &reply,
sizeof(reply));
1413static int log_ram_flash_to_file(
struct switchtec_dev *dev,
1414 int gen5_cmd,
int gen4_cmd,
int gen4_cmd_lgcy,
1415 int fd, FILE *log_def_file,
1421 return log_a_to_file(dev, gen5_cmd, fd, log_def_file,
1424 ret = log_a_to_file(dev, gen4_cmd, fd, log_def_file,
1433 (ERRNO_MRPC(errno) == ERR_LOGC_PORT_ARDY_BIND ||
1434 ERRNO_MRPC(errno) == ERR_SUBCMD_INVALID))
1435 ret = log_a_to_file(dev, gen4_cmd_lgcy, fd,
1436 log_def_file, info);
1456 memset(info, 0,
sizeof(*info));
1459 case SWITCHTEC_LOG_RAM:
1460 return log_ram_flash_to_file(dev,
1461 MRPC_FWLOGRD_RAM_GEN5,
1462 MRPC_FWLOGRD_RAM_WITH_FLAG,
1464 fd, log_def_file, info);
1465 case SWITCHTEC_LOG_FLASH:
1466 return log_ram_flash_to_file(dev,
1467 MRPC_FWLOGRD_FLASH_GEN5,
1468 MRPC_FWLOGRD_FLASH_WITH_FLAG,
1470 fd, log_def_file, info);
1471 case SWITCHTEC_LOG_MEMLOG:
1472 return log_b_to_file(dev, MRPC_FWLOGRD_MEMLOG, fd);
1473 case SWITCHTEC_LOG_REGS:
1474 return log_b_to_file(dev, MRPC_FWLOGRD_REGS, fd);
1475 case SWITCHTEC_LOG_THRD_STACK:
1476 return log_b_to_file(dev, MRPC_FWLOGRD_THRD_STACK, fd);
1477 case SWITCHTEC_LOG_SYS_STACK:
1478 return log_b_to_file(dev, MRPC_FWLOGRD_SYS_STACK, fd);
1479 case SWITCHTEC_LOG_THRD:
1480 return log_b_to_file(dev, MRPC_FWLOGRD_THRD, fd);
1481 case SWITCHTEC_LOG_NVHDR:
1482 return log_c_to_file(dev, MRPC_FWLOGRD_NVHDR, fd);
1489static int parse_log_header(FILE *bin_log_file, uint32_t *fw_version,
1490 uint32_t *sdk_version)
1494 uint32_t fw_version;
1495 uint32_t sdk_version;
1500 char sig[8] = {
'S',
'W',
'M',
'C',
'L',
'O',
'G',
'F'};
1503 ret = fread(&header,
sizeof(header), 1, bin_log_file);
1509 if (memcmp(sig, header.magic, 8)) {
1510 rewind(bin_log_file);
1516 *fw_version = header.fw_version;
1517 *sdk_version = header.sdk_version;
1533 FILE *parsed_log_file,
1541 .module_defs = NULL,
1544 uint32_t fw_version_log;
1545 uint32_t sdk_version_log;
1546 uint32_t fw_version_def;
1547 uint32_t sdk_version_def;
1551 memset(info, 0,
sizeof(*info));
1553 if ((log_type != SWITCHTEC_LOG_PARSE_TYPE_APP) &&
1554 (log_type != SWITCHTEC_LOG_PARSE_TYPE_MAILBOX)) {
1559 ret = parse_log_header(bin_log_file, &fw_version_log,
1563 ret = parse_def_header(log_def_file, &fw_version_def,
1568 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_MAILBOX) {
1569 fw_version_log = fw_version_def;
1570 sdk_version_log = sdk_version_def;
1574 info->def_fw_version = fw_version_def;
1575 info->def_sdk_version = sdk_version_def;
1577 info->log_fw_version = fw_version_log;
1578 info->log_sdk_version = sdk_version_log;
1581 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP)
1586 ret = append_log_header(fileno(parsed_log_file), sdk_version_log,
1592 while (fread(&log_data,
sizeof(
struct log_a_data), 1,
1593 bin_log_file) == 1) {
1599 if (gen_file != SWITCHTEC_GEN_UNKNOWN &&
1600 gen != SWITCHTEC_GEN_UNKNOWN) {
1602 info->gen_ignored =
true;
1603 }
else if (gen_file == SWITCHTEC_GEN_UNKNOWN &&
1604 gen == SWITCHTEC_GEN_UNKNOWN) {
1606 info->gen_unknown =
true;
1607 }
else if (gen != SWITCHTEC_GEN_UNKNOWN) {
1612 log_type, parsed_log_file,
1613 get_ts_factor(gen_file));
1615 goto ret_free_log_defs;
1620 if (ferror(bin_log_file)) {
1621 errno = SWITCHTEC_ERR_BIN_LOG_READ_ERROR;
1625 if (fw_version_def != fw_version_log ||
1626 sdk_version_def != sdk_version_log) {
1628 info->version_mismatch =
true;
1657 uint16_t end_of_data;
1660 uint16_t next_mod_id;
1661 uint8_t data[MRPC_MAX_DATA_LEN - 16];
1665 case SWITCHTEC_LOG_DEF_TYPE_APP:
1666 cmd.subcmd = MRPC_LOG_DEF_APP;
1669 case SWITCHTEC_LOG_DEF_TYPE_MAILBOX:
1670 cmd.subcmd = MRPC_LOG_DEF_MAILBOX;
1679 ret =
switchtec_cmd(dev, MRPC_LOG_DEF_GET, &cmd,
sizeof(cmd),
1680 &reply,
sizeof(reply));
1684 ret = fwrite(reply.data, reply.data_len, 1, file);
1688 cmd.idx = reply.next_idx;
1689 cmd.mod_id = reply.next_mod_id;
1690 }
while (!reply.end_of_data);
1701 ret = SWITCHTEC_GEN4;
1704 ret = SWITCHTEC_GEN5;
1707 ret = SWITCHTEC_GEN_UNKNOWN;
1728 uint32_t ping_dw = 0;
1730 struct get_dev_info_reply {
1732 uint32_t ping_reply;
1735 ping_dw = time(NULL);
1743 &reply,
sizeof(reply));
1745 if (ping_dw != ~reply.ping_reply)
1748 dev_info = le32toh(reply.dev_info);
1750 *phase = dev_info & 0xff;
1752 *rev = (dev_info >> 8) & 0x0f;
1754 *gen = map_to_gen((dev_info >> 12) & 0x0f);
1755 }
else if (ERRNO_MRPC(errno) == ERR_CMD_INVALID) {
1757 *phase = SWITCHTEC_BOOT_PHASE_FW;
1759 *gen = SWITCHTEC_GEN3;
1761 *rev = SWITCHTEC_REV_UNKNOWN;
1780 uint32_t sub_cmd_id;
1784 sub_cmd_id = MRPC_DIETEMP_SET_MEAS;
1786 sizeof(sub_cmd_id), NULL, 0);
1790 sub_cmd_id = MRPC_DIETEMP_GET;
1792 sizeof(sub_cmd_id), &temp,
sizeof(temp));
1796 sub_cmd_id = MRPC_DIETEMP_GET_GEN4;
1798 sizeof(sub_cmd_id), &temp,
sizeof(temp));
1803 return le32toh(temp) / 100.;
1806int switchtec_bind_info(
struct switchtec_dev *dev,
1810 .sub_cmd = MRPC_PORT_INFO,
1811 .phys_port_id = phy_port
1815 sizeof(sub_cmd_id), status,
sizeof(*status));
1818int switchtec_bind(
struct switchtec_dev *dev,
int par_id,
int log_port,
1824 .sub_cmd = MRPC_PORT_BIND,
1826 .log_port_id = log_port,
1827 .phys_port_id = phy_port
1831 sizeof(sub_cmd_id), &output,
sizeof(output));
1834int switchtec_unbind(
struct switchtec_dev *dev,
int par_id,
int log_port)
1839 .sub_cmd = MRPC_PORT_UNBIND,
1841 .log_port_id = log_port,
1846 sizeof(sub_cmd_id), &output,
sizeof(output));
1849static int __switchtec_calc_lane_id(
struct switchtec_status *port,
int lane_id)
1854 errno = SWITCHTEC_ERR_INVALID_LANE;
1875 default:
return lane;
1898 for (i = 0; i < ports; i++)
1903 errno = SWITCHTEC_ERR_INVALID_PORT;
1911 rc = __switchtec_calc_lane_id(&status[i], lane_id);
1928 int *phys_port_id,
int *port_lane_id,
1932 int ports, i, p, lane;
1939 if (lane_id >= 96) {
1940 if (dev->gen < SWITCHTEC_GEN5)
1941 p = lane_id - 96 + 48;
1943 p = lane_id - 96 + 56;
1945 for (i = 0; i < ports; i++)
1949 for (i = 0; i < ports; i++) {
1957 errno = SWITCHTEC_ERR_INVALID_PORT;
1969 if (
port->lane_reversal)
1973 *port_lane_id = lane;
1992 int lane_id,
int num_lanes,
int *lane_mask,
1996 int ports, i, l, lane;
2003 for (i = 0; i < ports; i++)
2008 errno = SWITCHTEC_ERR_INVALID_PORT;
2016 for (l = lane_id; l < lane_id + num_lanes; l++) {
2017 lane = __switchtec_calc_lane_id(&status[i], l);
2023 lane_mask[lane >> 5] |= 1 << (lane & 0x1F);
2041 if (dev->gen == SWITCHTEC_GEN4)
2042 return stack_id * 8 + port_id < 52;
2060 if (port_bif != 1 && port_bif != 2 && port_bif != 4 && port_bif != 8 &&
2066 if (dev->gen == SWITCHTEC_GEN4 && stack_id == 6)
2069 return (port_bif + 1) / 2;
2080 int port_bif[SWITCHTEC_PORTS_PER_STACK])
2083 .sub_cmd = MRPC_STACKBIF_GET,
2084 .stack_id = stack_id,
2088 ret =
switchtec_cmd(dev, MRPC_STACKBIF, &in,
sizeof(in), &out,
2093 for (i = 0; i < SWITCHTEC_PORTS_PER_STACK; i++) {
2099 switch (out.code & 0xF) {
2100 case 0x0: port_bif[i] = 0;
break;
2101 case 0x1: port_bif[i] = 2;
break;
2102 case 0x2: port_bif[i] = 4;
break;
2103 case 0x4: port_bif[i] = 8;
break;
2104 case 0x8: port_bif[i] = 16;
break;
2105 case 0xf: port_bif[i] = 1;
break;
2124 int port_bif[SWITCHTEC_PORTS_PER_STACK])
2127 .sub_cmd = MRPC_STACKBIF_SET,
2128 .stack_id = stack_id,
2132 for (i = 0; i < SWITCHTEC_PORTS_PER_STACK; i++) {
2133 switch (port_bif[i]) {
2134 case 0: in.code |= 0x0 << (i * 4);
break;
2135 case 1: in.code |= 0xf << (i * 4);
break;
2136 case 2: in.code |= 0x1 << (i * 4);
break;
2137 case 4: in.code |= 0x2 << (i * 4);
break;
2138 case 8: in.code |= 0x4 << (i * 4);
break;
2139 case 16: in.code |= 0x8 << (i * 4);
break;
2146 return switchtec_cmd(dev, MRPC_STACKBIF, &in,
sizeof(in), &out,
struct switchtec_dev * switchtec_open(const char *device)
Open a Switchtec device by string.
void switchtec_list_free(struct switchtec_device_info *devlist)
Free a list of device info structures allocated by switchtec_list()
struct switchtec_dev * switchtec_open_by_index(int index)
Open a switchtec device by index.
int switchtec_cmd(struct switchtec_dev *dev, uint32_t cmd, const void *payload, size_t payload_len, void *resp, size_t resp_len)
Execute an MRPC command.
void switchtec_perror(const char *str)
Print an error string to stdout.
int mrpc_error_cmd
The MRPC command ID when errno is set.
struct switchtec_dev * switchtec_open_i2c(const char *path, int i2c_addr)
Open a switchtec device behind an I2C device.
void switchtec_status_free(struct switchtec_status *status, int ports)
Free a list of status structures allocated by switchtec_status()
int switchtec_status(struct switchtec_dev *dev, struct switchtec_status **status)
Get the status of all the ports on a switchtec device.
struct switchtec_dev * switchtec_open_by_path(const char *path)
Open a switchtec device by path.
_PURE const char * switchtec_name(struct switchtec_dev *dev)
Get the string that was used to open the deviec.
const char * switchtec_strerror(void)
Return a message coresponding to the last error.
static const struct switchtec_device_id switchtec_device_id_tbl[]
Supported Switchtec device id table.
_PURE int switchtec_device_id(struct switchtec_dev *dev)
Get the device id of the device.
struct switchtec_dev * switchtec_open_eth(const char *ip, const int inst)
Open a switchtec device over ethernet.
_PURE int switchtec_partition(struct switchtec_dev *dev)
Get the partiton number of the device that was opened.
struct switchtec_dev * switchtec_open_by_pci_addr(int domain, int bus, int device, int func)
Open a switchtec device by PCI address (BDF)
enum switchtec_gen switchtec_fw_version_to_gen(unsigned int version)
Extract generation information from FW version number.
int switchtec_stack_bif_width(struct switchtec_dev *dev, int stack_id, int port_bif)
Return the number of stack ports used for a given bifurcation.
int switchtec_calc_lane_mask(struct switchtec_dev *dev, int phys_port_id, int lane_id, int num_lanes, int *lane_mask, struct switchtec_status *port)
Calculate the lane mask for lanes within a physical port.
int switchtec_log_to_file(struct switchtec_dev *dev, enum switchtec_log_type type, int fd, FILE *log_def_file, struct switchtec_log_file_info *info)
Dump the Switchtec log data to a file.
static int read_mailbox_log_defs(FILE *log_def_file, struct log_defs *defs)
Read a mailbox log definition file and store the definitions.
int switchtec_parse_log(FILE *bin_log_file, FILE *log_def_file, FILE *parsed_log_file, enum switchtec_log_parse_type log_type, enum switchtec_gen gen, struct switchtec_log_file_info *info)
Parse a binary app log or mailbox log to a text file.
float switchtec_die_temp(struct switchtec_dev *dev)
Get the die temperature of the switchtec device.
int switchtec_get_stack_bif(struct switchtec_dev *dev, int stack_id, int port_bif[SWITCHTEC_PORTS_PER_STACK])
Get the bifurcation of ports in a stack.
static void free_log_defs(struct log_defs *defs)
Free log definition data.
bool switchtec_stack_bif_port_valid(struct switchtec_dev *dev, int stack_id, int port_id)
Return true if a port within a stack is valid.
int switchtec_hard_reset(struct switchtec_dev *dev)
Perform an MRPC hard reset command.
int switchtec_log_def_to_file(struct switchtec_dev *dev, enum switchtec_log_def_type type, FILE *file)
Dump the Switchtec log definition data to a file.
int switchtec_get_device_info(struct switchtec_dev *dev, enum switchtec_boot_phase *phase, enum switchtec_gen *gen, enum switchtec_rev *rev)
Get device generation, revision, and boot phase info.
static int read_app_log_defs(FILE *log_def_file, struct log_defs *defs)
Read an app log definition file and store the definitions.
static int realloc_log_defs(struct log_defs *defs, int num_modules)
Allocate / reallocate log definition data.
int switchtec_echo(struct switchtec_dev *dev, uint32_t input, uint32_t *output)
Perform an MRPC echo command.
static bool parse_int(char *str, int *val)
Parse an integer from a string.
int switchtec_set_stack_bif(struct switchtec_dev *dev, int stack_id, int port_bif[SWITCHTEC_PORTS_PER_STACK])
Set the bifurcation of ports in a stack.
int switchtec_calc_lane_id(struct switchtec_dev *dev, int phys_port_id, int lane_id, struct switchtec_status *port)
Calculate the global lane ID for a lane within a physical port.
int switchtec_calc_port_lane(struct switchtec_dev *dev, int lane_id, int *phys_port_id, int *port_lane_id, struct switchtec_status *port)
Calculate the port and lane within the port from a global lane ID.
static int write_parsed_log(struct log_a_data log_data[], size_t count, int init_entry_idx, struct log_defs *defs, enum switchtec_log_parse_type log_type, FILE *log_file, int ts_factor)
Parse an app log or mailbox log and write the results to a file.
Log definitions for all modules.
struct module_log_defs * module_defs
per-module log definitions
int num_alloc
number of modules allocated
Module-specific log definitions.
char * mod_name
module name
int num_entries
number of log entries
char ** entries
log entry array
Switchtec device id to generation/variant mapping.
Represents a Switchtec device in the switchtec_list() function.
Information about log file and log definition file.
unsigned char upstream
1 if this is an upstream port
unsigned char partition
Partition the port is in.
unsigned char stk_id
Port number within the stack.
unsigned char log_id
Logical port number.
unsigned char phys_id
Physical port number.
unsigned char stack
Stack number.
struct switchtec_port_id port
Port ID.
unsigned char link_up
1 if the link is up
unsigned char lane_reversal
Lane reversal.
unsigned int acs_ctrl
ACS Setting of the Port.
const char * lane_reversal_str
Lane reversal as a string.
unsigned char cfg_lnk_width
Configured link width.
unsigned char link_rate
Link rate/gen.
unsigned char first_act_lane
First active lane.
unsigned char neg_lnk_width
Negotiated link width.
uint16_t ltssm
Link state.
const char * ltssm_str
Link state as a string.
switchtec_log_parse_type
Log types to parse.
switchtec_rev
Device hardware revision.
switchtec_gen
The PCIe generations.
switchtec_log_def_type
Log definition data types.
switchtec_variant
The variant types of Switchtec device.
switchtec_log_type
Describe the type of logs too dump.
switchtec_boot_phase
Device boot phase.
static int switchtec_max_supported_ports(struct switchtec_dev *dev)
Return the max number of ports of a Switchtec device.
static int switchtec_is_gen5(struct switchtec_dev *dev)
Return whether a Switchtec device is a Gen 5 device.
static int switchtec_is_pax_all(struct switchtec_dev *dev)
Return whether a Switchtec device is PAX(A).
static int switchtec_is_gen3(struct switchtec_dev *dev)
Return whether a Switchtec device is a Gen 3 device.