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},
180 static 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) {
208 static 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;
401 int 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;
414 static int compare_port_id(
const void *aa,
const void *bb)
422 return a->
log_id - b->log_id;
425 static 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;
507 uint8_t phys_port_id;
514 uint8_t linkup_linkrate;
520 ret =
switchtec_cmd(dev, MRPC_LNKSTAT, &port_bitmap,
sizeof(port_bitmap),
521 ports,
sizeof(ports));
526 for (i = 0; i < max_ports; i++) {
527 if ((ports[i].stk_id >> 4) > SWITCHTEC_MAX_STACKS)
532 s = *status = calloc(nr_ports,
sizeof(*s));
536 for (i = 0, p = 0; i < max_ports && p < nr_ports; i++) {
537 if ((ports[i].stk_id >> 4) > SWITCHTEC_MAX_STACKS)
549 s[p].
link_up = ports[i].linkup_linkrate >> 7;
550 s[p].
link_rate = ports[i].linkup_linkrate & 0x7F;
551 s[p].
ltssm = le16toh(ports[i].LTSSM);
552 s[p].
ltssm_str = switchtec_ltssm_str(s[i].ltssm, 1);
558 generate_lane_str(&s[p]);
563 qsort(s, nr_ports,
sizeof(*s), compare_status);
578 for (i = 0; i < ports; i++) {
579 if (status[i].pci_bdf)
580 free(status[i].pci_bdf);
582 if (status[i].pci_bdf_path)
583 free(status[i].pci_bdf_path);
585 if (status[i].pci_dev)
586 free(status[i].pci_dev);
588 if (status[i].class_devices)
589 free(status[i].class_devices);
615 const char *msg =
"Unknown MRPC error";
618 if ((errno & (SWITCHTEC_ERRNO_MRPC_FLAG_BIT |
619 SWITCHTEC_ERRNO_GENERAL_FLAG_BIT)) == 0) {
621 return strerror(errno);
623 return platform_strerror();
626 if (errno & SWITCHTEC_ERRNO_GENERAL_FLAG_BIT) {
628 case SWITCHTEC_ERR_LOG_DEF_READ_ERROR:
629 msg =
"Error reading log definition file";
break;
630 case SWITCHTEC_ERR_BIN_LOG_READ_ERROR:
631 msg =
"Error reading binary log file";
break;
632 case SWITCHTEC_ERR_PARSED_LOG_WRITE_ERROR:
633 msg =
"Error writing parsed log file";
break;
634 case SWITCHTEC_ERR_LOG_DEF_DATA_INVAL:
635 msg =
"Invalid log definition data";
break;
636 case SWITCHTEC_ERR_INVALID_PORT:
637 msg =
"Invalid port specified";
break;
638 case SWITCHTEC_ERR_INVALID_LANE:
639 msg =
"Invalid lane specified";
break;
641 msg =
"Unknown Switchtec error";
break;
647 err = errno & ~SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
650 case ERR_NO_AVAIL_MRPC_THREAD:
651 msg =
"No available MRPC handler thread";
break;
652 case ERR_HANDLER_THREAD_NOT_IDLE:
653 msg =
"The handler thread is not idle";
break;
654 case ERR_NO_BG_THREAD:
655 msg =
"No background thread run for the command";
break;
657 case ERR_REFCLK_SUBCMD_INVALID:
658 case ERR_STACKBIF_SUBCMD_INVALID:
659 case ERR_SUBCMD_INVALID: msg =
"Invalid subcommand";
break;
660 case ERR_CMD_INVALID: msg =
"Invalid command";
break;
661 case ERR_PARAM_INVALID: msg =
"Invalid parameter";
break;
662 case ERR_BAD_FW_STATE: msg =
"Bad firmware state";
break;
663 case ERR_MRPC_DENIED: msg =
"MRPC request denied";
break;
664 case ERR_MRPC_NO_PREV_DATA:
665 msg =
"No previous adaptation object data";
667 case ERR_REFCLK_STACK_ID_INVALID:
668 case ERR_STACKBIF_STACK_ID_INVALID:
669 case ERR_STACK_INVALID: msg =
"Invalid Stack";
break;
670 case ERR_LOOPBACK_PORT_INVALID:
671 case ERR_PORT_INVALID: msg =
"Invalid Port";
break;
672 case ERR_EVENT_INVALID: msg =
"Invalid Event";
break;
673 case ERR_RST_RULE_FAILED: msg =
"Reset rule search failed";
break;
674 case ERR_UART_NOT_SUPPORTED:
675 msg =
"UART interface not supported for this command";
break;
676 case ERR_XML_VERSION_MISMATCH:
677 msg =
"XML version mismatch between MAIN and CFG partition";
679 case ERR_ACCESS_REFUSED: msg =
"Access Refused";
break;
681 case ERR_STACKBIF_CODE_INVALID:
682 msg =
"Stack bifurcation code invalid";
break;
684 case ERR_STACKBIF_PORT_BOUND:
685 msg =
"Port already bound";
break;
692 case MRPC_PORTPARTP2P:
694 case ERR_PHYC_PORT_ARDY_BIND:
695 msg =
"Physical port already bound";
break;
696 case ERR_LOGC_PORT_ARDY_BIND:
697 msg =
"Logical bridge instance already bound";
break;
698 case ERR_BIND_PRTT_NOT_EXIST:
699 msg =
"Partition does not exist";
break;
700 case ERR_PHYC_PORT_NOT_EXIST:
701 msg =
"Physical port does not exist";
break;
702 case ERR_PHYC_PORT_DIS:
703 msg =
"Physical port disabled";
break;
704 case ERR_NO_LOGC_PORT:
705 msg =
"No logical bridge instance";
break;
706 case ERR_BIND_IN_PROGRESS:
707 msg =
"Bind/unbind in progress";
break;
708 case ERR_BIND_TGT_IS_USP:
709 msg =
"Bind/unbind target is USP";
break;
710 case ERR_BIND_SUBCMD_INVALID:
711 msg =
"Sub-command does not exist";
break;
712 case ERR_PHYC_PORT_LINK_ACT:
713 msg =
"Physical port link active";
break;
714 case ERR_LOGC_PORT_NOT_BIND_PHYC_PORT:
715 msg =
"Logical bridge not bind to physical port";
break;
716 case ERR_UNBIND_OPT_INVALID:
717 msg =
"Invalid unbind option";
break;
718 case ERR_BIND_CHECK_FAIL:
719 msg =
"Port bind checking failed";
break;
739 int is_mrpc = errno & SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
740 int err = errno & ~SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
743 fprintf(stderr,
"%s: %s (MRPC: 0x%x, error: 0x%x)\n",
746 fprintf(stderr,
"%s: %s\n", str, msg);
771 output,
sizeof(*output));
787 return switchtec_cmd(dev, MRPC_RESET, &subcmd,
sizeof(subcmd),
832 for (i = defs->
num_alloc; i < num_modules; i++)
852 *val = strtol(str, &endptr, 0);
854 if ((endptr == str) || (*endptr !=
'\0') || (errno != 0))
881 while (fgets(line,
sizeof(line), log_def_file)) {
888 line[strcspn(line,
"\r\n")] =
'\0';
894 tok = strtok(line,
" \t");
898 tok = strtok(NULL,
" \t");
903 errno = SWITCHTEC_ERR_LOG_DEF_DATA_INVAL;
904 goto err_free_log_defs;
916 tok = strtok(NULL,
" \t");
921 errno = SWITCHTEC_ERR_LOG_DEF_DATA_INVAL;
922 goto err_free_log_defs;
931 if (!fgets(line,
sizeof(line),
943 goto err_free_log_defs;
946 if (fgets(line,
sizeof(line), log_def_file) == NULL) {
947 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
948 goto err_free_log_defs;
951 mod_defs->
entries[i] = strdup(line);
953 goto err_free_log_defs;
957 if (ferror(log_def_file)) {
958 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
959 goto err_free_log_defs;
980 int num_entries_alloc;
994 num_entries_alloc = 100;
995 mod_defs->
entries = calloc(num_entries_alloc,
998 goto err_free_log_defs;
1000 while (fgets(line,
sizeof(line), log_def_file)) {
1007 num_entries_alloc *= 2;
1009 (num_entries_alloc *
1012 goto err_free_log_defs;
1017 goto err_free_log_defs;
1022 if (ferror(log_def_file)) {
1023 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
1024 goto err_free_log_defs;
1046 size_t count,
int init_entry_idx,
1049 FILE *log_file,
int ts_factor)
1053 int entry_idx = init_entry_idx;
1054 unsigned long long time;
1055 unsigned int nanos, micros, millis, secs, mins, hours, days;
1056 unsigned int entry_num;
1057 unsigned int mod_id;
1058 unsigned int log_sev = 0;
1059 const char *log_sev_strs[] = {
"DISABLED",
"HIGHEST",
"HIGH",
"MEDIUM",
1064 if (entry_idx == 0) {
1065 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP)
1066 fputs(
" #|Timestamp |Module |Severity |Event ID |Event\n",
1069 fputs(
" #|Timestamp |Source |Event ID |Event\n",
1073 for (i = 0; i < count; i ++) {
1075 time = (((
unsigned long long)log_data[i].data[0] << 32) |
1076 log_data[i].data[1]) * ts_factor/100;
1077 nanos = time % 1000;
1079 micros = time % 1000;
1081 millis = time % 1000;
1090 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP) {
1095 mod_id = (log_data[i].data[2] >> 16) & 0xFFF;
1096 log_sev = (log_data[i].data[2] >> 28) & 0xF;
1101 if (fprintf(log_file,
"(Invalid module ID: 0x%x)\n",
1103 goto ret_print_error;
1107 if (log_sev >= ARRAY_SIZE(log_sev_strs)) {
1108 if (fprintf(log_file,
"(Invalid log severity: %d)\n",
1110 goto ret_print_error;
1118 is_bl1 = (((log_data[i].data[2] >> 27) & 1) == 0);
1127 entry_num = log_data[i].data[2] & 0x0000FFFF;
1130 if (fprintf(log_file,
1131 "(Invalid log entry number: %d (module 0x%x))\n",
1132 entry_num, mod_id) < 0)
1133 goto ret_print_error;
1139 ret = fprintf(log_file,
1140 "%04d|xxxd xx:xx:xx.xxx,xxx,xxx|",
1143 ret = fprintf(log_file,
1144 "%04d|%03dd %02d:%02d:%02d.%03d,%03d,%03d|",
1145 entry_idx, days, hours, mins, secs,
1146 millis, micros, nanos);
1149 goto ret_print_error;
1151 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP) {
1153 if (fprintf(log_file,
"%-12s |%-8s |0x%04x |",
1154 mod_defs->
mod_name, log_sev_strs[log_sev],
1156 goto ret_print_error;
1159 if (fprintf(log_file,
"%-6s |0x%04x |",
1160 (is_bl1 ?
"BL1" :
"BL2"), entry_num) < 0)
1161 goto ret_print_error;
1165 if (fprintf(log_file, mod_defs->
entries[entry_num],
1166 log_data[i].data[3], log_data[i].data[4],
1167 log_data[i].data[5], log_data[i].data[6],
1168 log_data[i].data[7]) < 0)
1169 goto ret_print_error;
1174 if (fflush(log_file) != 0)
1180 errno = SWITCHTEC_ERR_PARSED_LOG_WRITE_ERROR;
1184 static int parse_def_header(FILE *log_def_file, uint32_t *fw_version,
1185 uint32_t *sdk_version)
1192 while (fgets(line,
sizeof(line), log_def_file)) {
1197 while (line[i] ==
' ' || line[i] ==
'#') i++;
1199 if (strncasecmp(line + i,
"SDK Version:", 12) == 0) {
1201 while (line[i] ==
' ') i++;
1202 sscanf(line + i,
"%i", (
int*)sdk_version);
1204 else if (strncasecmp(line + i,
"FW Version:", 11) == 0) {
1206 while (line[i] ==
' ') i++;
1207 sscanf(line + i,
"%i", (
int*)fw_version);
1211 rewind(log_def_file);
1215 static int append_log_header(
int fd, uint32_t sdk_version,
1216 uint32_t fw_version,
int binary)
1221 uint32_t fw_version;
1222 uint32_t sdk_version;
1226 .magic = {
'S',
'W',
'M',
'C',
'L',
'O',
'G',
'F'},
1227 .fw_version = fw_version,
1228 .sdk_version = sdk_version
1230 char hdr_str_fmt[] =
"#########################\n" 1231 "## FW version %08x\n" 1232 "## SDK version %08x\n" 1233 "#########################\n\n";
1237 ret = write(fd, &header,
sizeof(header));
1239 snprintf(hdr_str, 512, hdr_str_fmt, fw_version, sdk_version);
1240 ret = write(fd, hdr_str, strlen(hdr_str));
1248 if (gen == SWITCHTEC_GEN_UNKNOWN)
1250 else if (gen == SWITCHTEC_GEN3)
1256 static int log_a_to_file(
struct switchtec_dev *dev,
int sub_cmd_id,
1257 int fd, FILE *log_def_file,
1264 .sub_cmd_id = sub_cmd_id,
1272 uint32_t fw_version = 0;
1273 uint32_t sdk_version = 0;
1275 if (log_def_file != NULL) {
1276 ret = parse_def_header(log_def_file, &fw_version,
1288 while (res.hdr.remain) {
1292 goto ret_free_log_defs;
1293 if (res.hdr.overflow && info)
1296 if (dev->gen < SWITCHTEC_GEN5) {
1297 res.hdr.sdk_version = 0;
1298 res.hdr.fw_version = 0;
1302 info->def_fw_version = fw_version;
1303 info->def_sdk_version = sdk_version;
1304 info->log_fw_version = res.hdr.fw_version;
1305 info->log_sdk_version = res.hdr.sdk_version;
1308 if (res.hdr.sdk_version != sdk_version ||
1309 res.hdr.fw_version != fw_version) {
1310 if (info && log_def_file)
1311 info->version_mismatch =
true;
1315 append_log_header(fd, res.hdr.sdk_version,
1317 log_def_file == NULL? 1 : 0);
1320 if (log_def_file == NULL) {
1322 ret = write(fd, res.data,
1323 sizeof(*res.data) * res.hdr.count);
1327 log_file = fdopen(fd,
"w");
1329 goto ret_free_log_defs;
1334 SWITCHTEC_LOG_PARSE_TYPE_APP,
1336 get_ts_factor(dev->gen));
1338 goto ret_free_log_defs;
1340 entry_idx += res.hdr.count;
1343 read += le32toh(res.hdr.count);
1344 cmd.start = res.hdr.next_start;
1354 static int log_b_to_file(
struct switchtec_dev *dev,
int sub_cmd_id,
int fd)
1360 .sub_cmd_id = sub_cmd_id,
1362 .length = htole32(
sizeof(res.data)),
1365 res.hdr.remain =
sizeof(res.data);
1367 while (res.hdr.remain) {
1373 ret = write(fd, res.data, res.hdr.length);
1377 read += le32toh(res.hdr.length);
1378 cmd.offset = htole32(read);
1384 static int log_c_to_file(
struct switchtec_dev *dev,
int sub_cmd_id,
int fd)
1395 uint32_t nvlog_version;
1396 uint32_t thread_handle;
1397 uint32_t fw_version;
1398 uint32_t timestamp1;
1399 uint32_t timestamp2;
1402 cmd.subcmd = sub_cmd_id;
1405 &reply,
sizeof(reply));
1409 ret = write(fd, &reply,
sizeof(reply));
1416 static int log_ram_flash_to_file(
struct switchtec_dev *dev,
1417 int gen5_cmd,
int gen4_cmd,
int gen4_cmd_lgcy,
1418 int fd, FILE *log_def_file,
1424 return log_a_to_file(dev, gen5_cmd, fd, log_def_file,
1427 ret = log_a_to_file(dev, gen4_cmd, fd, log_def_file,
1436 (ERRNO_MRPC(errno) == ERR_LOGC_PORT_ARDY_BIND ||
1437 ERRNO_MRPC(errno) == ERR_SUBCMD_INVALID))
1438 ret = log_a_to_file(dev, gen4_cmd_lgcy, fd,
1439 log_def_file, info);
1459 memset(info, 0,
sizeof(*info));
1462 case SWITCHTEC_LOG_RAM:
1463 return log_ram_flash_to_file(dev,
1464 MRPC_FWLOGRD_RAM_GEN5,
1465 MRPC_FWLOGRD_RAM_WITH_FLAG,
1467 fd, log_def_file, info);
1468 case SWITCHTEC_LOG_FLASH:
1469 return log_ram_flash_to_file(dev,
1470 MRPC_FWLOGRD_FLASH_GEN5,
1471 MRPC_FWLOGRD_FLASH_WITH_FLAG,
1473 fd, log_def_file, info);
1474 case SWITCHTEC_LOG_MEMLOG:
1475 return log_b_to_file(dev, MRPC_FWLOGRD_MEMLOG, fd);
1476 case SWITCHTEC_LOG_REGS:
1477 return log_b_to_file(dev, MRPC_FWLOGRD_REGS, fd);
1478 case SWITCHTEC_LOG_THRD_STACK:
1479 return log_b_to_file(dev, MRPC_FWLOGRD_THRD_STACK, fd);
1480 case SWITCHTEC_LOG_SYS_STACK:
1481 return log_b_to_file(dev, MRPC_FWLOGRD_SYS_STACK, fd);
1482 case SWITCHTEC_LOG_THRD:
1483 return log_b_to_file(dev, MRPC_FWLOGRD_THRD, fd);
1484 case SWITCHTEC_LOG_NVHDR:
1485 return log_c_to_file(dev, MRPC_FWLOGRD_NVHDR, fd);
1492 static int parse_log_header(FILE *bin_log_file, uint32_t *fw_version,
1493 uint32_t *sdk_version)
1497 uint32_t fw_version;
1498 uint32_t sdk_version;
1503 char sig[8] = {
'S',
'W',
'M',
'C',
'L',
'O',
'G',
'F'};
1506 ret = fread(&header,
sizeof(header), 1, bin_log_file);
1512 if (memcmp(sig, header.magic, 8)) {
1513 rewind(bin_log_file);
1519 *fw_version = header.fw_version;
1520 *sdk_version = header.sdk_version;
1536 FILE *parsed_log_file,
1547 uint32_t fw_version_log;
1548 uint32_t sdk_version_log;
1549 uint32_t fw_version_def;
1550 uint32_t sdk_version_def;
1554 memset(info, 0,
sizeof(*info));
1556 if ((log_type != SWITCHTEC_LOG_PARSE_TYPE_APP) &&
1557 (log_type != SWITCHTEC_LOG_PARSE_TYPE_MAILBOX)) {
1562 ret = parse_log_header(bin_log_file, &fw_version_log,
1566 ret = parse_def_header(log_def_file, &fw_version_def,
1571 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_MAILBOX) {
1572 fw_version_log = fw_version_def;
1573 sdk_version_log = sdk_version_def;
1577 info->def_fw_version = fw_version_def;
1578 info->def_sdk_version = sdk_version_def;
1580 info->log_fw_version = fw_version_log;
1581 info->log_sdk_version = sdk_version_log;
1584 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP)
1589 ret = append_log_header(fileno(parsed_log_file), sdk_version_log,
1595 while (fread(&log_data,
sizeof(
struct log_a_data), 1,
1596 bin_log_file) == 1) {
1602 if (gen_file != SWITCHTEC_GEN_UNKNOWN &&
1603 gen != SWITCHTEC_GEN_UNKNOWN) {
1605 info->gen_ignored =
true;
1606 }
else if (gen_file == SWITCHTEC_GEN_UNKNOWN &&
1607 gen == SWITCHTEC_GEN_UNKNOWN) {
1609 info->gen_unknown =
true;
1610 }
else if (gen != SWITCHTEC_GEN_UNKNOWN) {
1615 log_type, parsed_log_file,
1616 get_ts_factor(gen_file));
1618 goto ret_free_log_defs;
1623 if (ferror(bin_log_file)) {
1624 errno = SWITCHTEC_ERR_BIN_LOG_READ_ERROR;
1628 if (fw_version_def != fw_version_log ||
1629 sdk_version_def != sdk_version_log) {
1631 info->version_mismatch =
true;
1660 uint16_t end_of_data;
1663 uint16_t next_mod_id;
1664 uint8_t data[MRPC_MAX_DATA_LEN - 16];
1668 case SWITCHTEC_LOG_DEF_TYPE_APP:
1669 cmd.subcmd = MRPC_LOG_DEF_APP;
1672 case SWITCHTEC_LOG_DEF_TYPE_MAILBOX:
1673 cmd.subcmd = MRPC_LOG_DEF_MAILBOX;
1682 ret =
switchtec_cmd(dev, MRPC_LOG_DEF_GET, &cmd,
sizeof(cmd),
1683 &reply,
sizeof(reply));
1687 ret = fwrite(reply.data, reply.data_len, 1, file);
1691 cmd.idx = reply.next_idx;
1692 cmd.mod_id = reply.next_mod_id;
1693 }
while (!reply.end_of_data);
1704 ret = SWITCHTEC_GEN4;
1707 ret = SWITCHTEC_GEN5;
1710 ret = SWITCHTEC_GEN_UNKNOWN;
1731 uint32_t ping_dw = 0;
1733 struct get_dev_info_reply {
1735 uint32_t ping_reply;
1738 ping_dw = time(NULL);
1746 &reply,
sizeof(reply));
1748 if (ping_dw != ~reply.ping_reply)
1751 dev_info = le32toh(reply.dev_info);
1753 *phase = dev_info & 0xff;
1755 *rev = (dev_info >> 8) & 0x0f;
1757 *gen = map_to_gen((dev_info >> 12) & 0x0f);
1758 }
else if (ERRNO_MRPC(errno) == ERR_CMD_INVALID) {
1760 *phase = SWITCHTEC_BOOT_PHASE_FW;
1762 *gen = SWITCHTEC_GEN3;
1764 *rev = SWITCHTEC_REV_UNKNOWN;
1783 uint32_t sub_cmd_id;
1787 sub_cmd_id = MRPC_DIETEMP_SET_MEAS;
1789 sizeof(sub_cmd_id), NULL, 0);
1793 sub_cmd_id = MRPC_DIETEMP_GET;
1795 sizeof(sub_cmd_id), &temp,
sizeof(temp));
1799 sub_cmd_id = MRPC_DIETEMP_GET_GEN4;
1801 sizeof(sub_cmd_id), &temp,
sizeof(temp));
1806 return le32toh(temp) / 100.;
1809 int switchtec_bind_info(
struct switchtec_dev *dev,
1813 .sub_cmd = MRPC_PORT_INFO,
1814 .phys_port_id = phy_port
1818 sizeof(sub_cmd_id), status,
sizeof(*status));
1821 int switchtec_bind(
struct switchtec_dev *dev,
int par_id,
int log_port,
1827 .sub_cmd = MRPC_PORT_BIND,
1829 .log_port_id = log_port,
1830 .phys_port_id = phy_port
1834 sizeof(sub_cmd_id), &output,
sizeof(output));
1837 int switchtec_unbind(
struct switchtec_dev *dev,
int par_id,
int log_port)
1842 .sub_cmd = MRPC_PORT_UNBIND,
1844 .log_port_id = log_port,
1849 sizeof(sub_cmd_id), &output,
sizeof(output));
1852 static int __switchtec_calc_lane_id(
struct switchtec_status *port,
int lane_id)
1857 errno = SWITCHTEC_ERR_INVALID_LANE;
1878 default:
return lane;
1901 for (i = 0; i < ports; i++)
1906 errno = SWITCHTEC_ERR_INVALID_PORT;
1914 rc = __switchtec_calc_lane_id(&status[i], lane_id);
1931 int *phys_port_id,
int *port_lane_id,
1935 int ports, i, p, lane;
1942 if (lane_id >= 96) {
1943 if (dev->gen < SWITCHTEC_GEN5)
1944 p = lane_id - 96 + 48;
1946 p = lane_id - 96 + 56;
1948 for (i = 0; i < ports; i++)
1952 for (i = 0; i < ports; i++) {
1960 errno = SWITCHTEC_ERR_INVALID_PORT;
1972 if (
port->lane_reversal)
1976 *port_lane_id = lane;
1995 int lane_id,
int num_lanes,
int *lane_mask,
1999 int ports, i, l, lane;
2006 for (i = 0; i < ports; i++)
2011 errno = SWITCHTEC_ERR_INVALID_PORT;
2019 for (l = lane_id; l < lane_id + num_lanes; l++) {
2020 lane = __switchtec_calc_lane_id(&status[i], l);
2026 lane_mask[lane >> 5] |= 1 << (lane & 0x1F);
2044 if (dev->gen == SWITCHTEC_GEN4)
2045 return stack_id * 8 + port_id < 52;
2063 if (port_bif != 1 && port_bif != 2 && port_bif != 4 && port_bif != 8 &&
2069 if (dev->gen == SWITCHTEC_GEN4 && stack_id == 6)
2072 return (port_bif + 1) / 2;
2083 int port_bif[SWITCHTEC_PORTS_PER_STACK])
2086 .sub_cmd = MRPC_STACKBIF_GET,
2087 .stack_id = stack_id,
2091 ret =
switchtec_cmd(dev, MRPC_STACKBIF, &in,
sizeof(in), &out,
2096 for (i = 0; i < SWITCHTEC_PORTS_PER_STACK; i++) {
2102 switch (out.code & 0xF) {
2103 case 0x0: port_bif[i] = 0;
break;
2104 case 0x1: port_bif[i] = 2;
break;
2105 case 0x2: port_bif[i] = 4;
break;
2106 case 0x4: port_bif[i] = 8;
break;
2107 case 0x8: port_bif[i] = 16;
break;
2108 case 0xf: port_bif[i] = 1;
break;
2127 int port_bif[SWITCHTEC_PORTS_PER_STACK])
2130 .sub_cmd = MRPC_STACKBIF_SET,
2131 .stack_id = stack_id,
2135 for (i = 0; i < SWITCHTEC_PORTS_PER_STACK; i++) {
2136 switch (port_bif[i]) {
2137 case 0: in.code |= 0x0 << (i * 4);
break;
2138 case 1: in.code |= 0xf << (i * 4);
break;
2139 case 2: in.code |= 0x1 << (i * 4);
break;
2140 case 4: in.code |= 0x2 << (i * 4);
break;
2141 case 8: in.code |= 0x4 << (i * 4);
break;
2142 case 16: in.code |= 0x8 << (i * 4);
break;
2149 return switchtec_cmd(dev, MRPC_STACKBIF, &in,
sizeof(in), &out,
unsigned char cfg_lnk_width
Configured link width.
unsigned char neg_lnk_width
Negotiated link width.
unsigned int acs_ctrl
ACS Setting of the Port.
void switchtec_status_free(struct switchtec_status *status, int ports)
Free a list of status structures allocated by switchtec_status()
unsigned char upstream
1 if this is an upstream port
unsigned char link_rate
Link rate/gen.
switchtec_log_parse_type
Log types to parse.
enum switchtec_gen switchtec_fw_version_to_gen(unsigned int version)
Extract generation information from FW version number.
_PURE int switchtec_device_id(struct switchtec_dev *dev)
Get the device id of the device.
switchtec_log_def_type
Log definition data types.
struct switchtec_port_id port
Port ID.
Module-specific log definitions.
char * mod_name
module name
static int read_app_log_defs(FILE *log_def_file, struct log_defs *defs)
Read an app log definition file and store the definitions.
unsigned char partition
Partition the port is in.
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_eth(const char *ip, const int inst)
Open a switchtec device over ethernet.
switchtec_gen
The PCIe generations.
unsigned char stk_id
Port number within the stack.
struct module_log_defs * module_defs
per-module log definitions
unsigned char first_act_lane
First active lane.
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.
switchtec_boot_phase
Device boot phase.
char ** entries
log entry array
static int switchtec_is_gen5(struct switchtec_dev *dev)
Return whether a Switchtec device is a Gen 5 device.
Log definitions for all modules.
static void free_log_defs(struct log_defs *defs)
Free log definition data.
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.
static int switchtec_is_pax_all(struct switchtec_dev *dev)
Return whether a Switchtec device is PAX(A).
static const struct switchtec_device_id switchtec_device_id_tbl[]
Supported Switchtec device id table.
unsigned char phys_id
Physical port number.
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.
switchtec_log_type
Describe the type of logs too dump.
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.
float switchtec_die_temp(struct switchtec_dev *dev)
Get the die temperature of the switchtec device.
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_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.
static bool parse_int(char *str, int *val)
Parse an integer from a string.
_PURE int switchtec_partition(struct switchtec_dev *dev)
Get the partiton number of the device that was opened.
_PURE enum switchtec_gen switchtec_gen(struct switchtec_dev *dev)
Get the generation of the device.
unsigned char stack
Stack number.
const char * lane_reversal_str
Lane reversal as a string.
const char * switchtec_strerror(void)
Return a message coresponding to the last error.
int switchtec_echo(struct switchtec_dev *dev, uint32_t input, uint32_t *output)
Perform an MRPC echo 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.
Switchtec device id to generation/variant mapping.
_PURE enum switchtec_variant switchtec_variant(struct switchtec_dev *dev)
Get the variant type of the device.
static int realloc_log_defs(struct log_defs *defs, int num_modules)
Allocate / reallocate log definition data.
unsigned char lane_reversal
Lane reversal.
switchtec_variant
The variant types of Switchtec device.
const char * ltssm_str
Link state as a string.
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.
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_path(const char *path)
Open a switchtec device by path.
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.
static int switchtec_is_gen3(struct switchtec_dev *dev)
Return whether a Switchtec device is a Gen 3 device.
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_mailbox_log_defs(FILE *log_def_file, struct log_defs *defs)
Read a mailbox log definition file and store the definitions.
int num_alloc
number of modules allocated
void switchtec_perror(const char *str)
Print an error string to stdout.
switchtec_rev
Device hardware revision.
struct switchtec_dev * switchtec_open(const char *device)
Open a Switchtec device by string.
Information about log file and log definition file.
_PURE const char * switchtec_name(struct switchtec_dev *dev)
Get the string that was used to open the deviec.
int mrpc_error_cmd
The MRPC command ID when errno is set.
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.
int num_entries
number of log entries
unsigned char log_id
Logical port number.
Represents a Switchtec device in the switchtec_list() function.
struct switchtec_dev * switchtec_open_i2c(const char *path, int i2c_addr)
Open a switchtec device behind an I2C device.
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.
struct switchtec_dev * switchtec_open_by_index(int index)
Open a switchtec device by index.
struct switchtec_dev * switchtec_open_by_pci_addr(int domain, int bus, int device, int func)
Open a switchtec device by PCI address (BDF)
_PURE enum switchtec_boot_phase switchtec_boot_phase(struct switchtec_dev *dev)
Get boot phase of the device.
unsigned char link_up
1 if the link is up
int switchtec_hard_reset(struct switchtec_dev *dev)
Perform an MRPC hard reset command.
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.
uint16_t ltssm
Link state.