Switchtec Userspace PROJECT_NUMBER = 4.2
Loading...
Searching...
No Matches
switchtec.c
Go to the documentation of this file.
1/*
2 * Microsemi Switchtec(tm) PCIe Management Library
3 * Copyright (c) 2017, Microsemi Corporation
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 */
24
30#define SWITCHTEC_LIB_CORE
31
32#include "switchtec_priv.h"
33
34#include "switchtec/switchtec.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"
40
41#include <string.h>
42#include <unistd.h>
43#include <errno.h>
44#include <time.h>
45
64 char *mod_name;
65 char **entries;
67};
68
72struct log_defs {
75};
76
81 unsigned short device_id;
82 enum switchtec_gen gen;
83 enum switchtec_variant var;
84};
85
90 {0x8531, SWITCHTEC_GEN3, SWITCHTEC_PFX}, //PFX 24xG3
91 {0x8532, SWITCHTEC_GEN3, SWITCHTEC_PFX}, //PFX 32xG3
92 {0x8533, SWITCHTEC_GEN3, SWITCHTEC_PFX}, //PFX 48xG3
93 {0x8534, SWITCHTEC_GEN3, SWITCHTEC_PFX}, //PFX 64xG3
94 {0x8535, SWITCHTEC_GEN3, SWITCHTEC_PFX}, //PFX 80xG3
95 {0x8536, SWITCHTEC_GEN3, SWITCHTEC_PFX}, //PFX 96xG3
96 {0x8541, SWITCHTEC_GEN3, SWITCHTEC_PSX}, //PSX 24xG3
97 {0x8542, SWITCHTEC_GEN3, SWITCHTEC_PSX}, //PSX 32xG3
98 {0x8543, SWITCHTEC_GEN3, SWITCHTEC_PSX}, //PSX 48xG3
99 {0x8544, SWITCHTEC_GEN3, SWITCHTEC_PSX}, //PSX 64xG3
100 {0x8545, SWITCHTEC_GEN3, SWITCHTEC_PSX}, //PSX 80xG3
101 {0x8546, SWITCHTEC_GEN3, SWITCHTEC_PSX}, //PSX 96xG3
102 {0x8551, SWITCHTEC_GEN3, SWITCHTEC_PAX}, //PAX 24XG3
103 {0x8552, SWITCHTEC_GEN3, SWITCHTEC_PAX}, //PAX 32XG3
104 {0x8553, SWITCHTEC_GEN3, SWITCHTEC_PAX}, //PAX 48XG3
105 {0x8554, SWITCHTEC_GEN3, SWITCHTEC_PAX}, //PAX 64XG3
106 {0x8555, SWITCHTEC_GEN3, SWITCHTEC_PAX}, //PAX 80XG3
107 {0x8556, SWITCHTEC_GEN3, SWITCHTEC_PAX}, //PAX 96XG3
108 {0x8561, SWITCHTEC_GEN3, SWITCHTEC_PFXL}, //PFXL 24XG3
109 {0x8562, SWITCHTEC_GEN3, SWITCHTEC_PFXL}, //PFXL 32XG3
110 {0x8563, SWITCHTEC_GEN3, SWITCHTEC_PFXL}, //PFXL 48XG3
111 {0x8564, SWITCHTEC_GEN3, SWITCHTEC_PFXL}, //PFXL 64XG3
112 {0x8565, SWITCHTEC_GEN3, SWITCHTEC_PFXL}, //PFXL 80XG3
113 {0x8566, SWITCHTEC_GEN3, SWITCHTEC_PFXL}, //PFXL 96XG3
114 {0x8571, SWITCHTEC_GEN3, SWITCHTEC_PFXI}, //PFXI 24XG3
115 {0x8572, SWITCHTEC_GEN3, SWITCHTEC_PFXI}, //PFXI 32XG3
116 {0x8573, SWITCHTEC_GEN3, SWITCHTEC_PFXI}, //PFXI 48XG3
117 {0x8574, SWITCHTEC_GEN3, SWITCHTEC_PFXI}, //PFXI 64XG3
118 {0x8575, SWITCHTEC_GEN3, SWITCHTEC_PFXI}, //PFXI 80XG3
119 {0x8576, SWITCHTEC_GEN3, SWITCHTEC_PFXI}, //PFXI 96XG3
120 {0x4000, SWITCHTEC_GEN4, SWITCHTEC_PFX}, //PFX 100XG4
121 {0x4084, SWITCHTEC_GEN4, SWITCHTEC_PFX}, //PFX 84XG4
122 {0x4068, SWITCHTEC_GEN4, SWITCHTEC_PFX}, //PFX 68XG4
123 {0x4052, SWITCHTEC_GEN4, SWITCHTEC_PFX}, //PFX 52XG4
124 {0x4036, SWITCHTEC_GEN4, SWITCHTEC_PFX}, //PFX 36XG4
125 {0x4028, SWITCHTEC_GEN4, SWITCHTEC_PFX}, //PFX 28XG4
126 {0x4100, SWITCHTEC_GEN4, SWITCHTEC_PSX}, //PSX 100XG4
127 {0x4184, SWITCHTEC_GEN4, SWITCHTEC_PSX}, //PSX 84XG4
128 {0x4168, SWITCHTEC_GEN4, SWITCHTEC_PSX}, //PSX 68XG4
129 {0x4152, SWITCHTEC_GEN4, SWITCHTEC_PSX}, //PSX 52XG4
130 {0x4136, SWITCHTEC_GEN4, SWITCHTEC_PSX}, //PSX 36XG4
131 {0x4128, SWITCHTEC_GEN4, SWITCHTEC_PSX}, //PSX 28XG4
132 {0x4200, SWITCHTEC_GEN4, SWITCHTEC_PAX}, //PAX 100XG4
133 {0x4284, SWITCHTEC_GEN4, SWITCHTEC_PAX}, //PAX 84XG4
134 {0x4268, SWITCHTEC_GEN4, SWITCHTEC_PAX}, //PAX 68XG4
135 {0x4252, SWITCHTEC_GEN4, SWITCHTEC_PAX}, //PAX 52XG4
136 {0x4236, SWITCHTEC_GEN4, SWITCHTEC_PAX}, //PAX 36XG4
137 {0x4352, SWITCHTEC_GEN4, SWITCHTEC_PFXA}, //PFXA 52XG4
138 {0x4336, SWITCHTEC_GEN4, SWITCHTEC_PFXA}, //PFXA 36XG4
139 {0x4328, SWITCHTEC_GEN4, SWITCHTEC_PFXA}, //PFXA 28XG4
140 {0x4452, SWITCHTEC_GEN4, SWITCHTEC_PSXA}, //PSXA 52XG4
141 {0x4436, SWITCHTEC_GEN4, SWITCHTEC_PSXA}, //PSXA 36XG4
142 {0x4428, SWITCHTEC_GEN4, SWITCHTEC_PSXA}, //PSXA 28XG4
143 {0x4552, SWITCHTEC_GEN4, SWITCHTEC_PAXA}, //PAXA 52XG4
144 {0x4536, SWITCHTEC_GEN4, SWITCHTEC_PAXA}, //PAXA 36XG4
145 {0x4528, SWITCHTEC_GEN4, SWITCHTEC_PAXA}, //PAXA 28XG4
146 {0x4228, SWITCHTEC_GEN4, SWITCHTEC_PAX}, //PAX 28XG4
147 {0x5000, SWITCHTEC_GEN5, SWITCHTEC_PFX}, //PFX 100XG5
148 {0x5084, SWITCHTEC_GEN5, SWITCHTEC_PFX}, //PFX 84XG5
149 {0x5068, SWITCHTEC_GEN5, SWITCHTEC_PFX}, //PFX 68XG5
150 {0x5052, SWITCHTEC_GEN5, SWITCHTEC_PFX}, //PFX 52XG5
151 {0x5036, SWITCHTEC_GEN5, SWITCHTEC_PFX}, //PFX 36XG5
152 {0x5028, SWITCHTEC_GEN5, SWITCHTEC_PFX}, //PFX 28XG5
153 {0x5100, SWITCHTEC_GEN5, SWITCHTEC_PSX}, //PSX 100XG5
154 {0x5184, SWITCHTEC_GEN5, SWITCHTEC_PSX}, //PSX 84XG5
155 {0x5168, SWITCHTEC_GEN5, SWITCHTEC_PSX}, //PSX 68XG5
156 {0x5152, SWITCHTEC_GEN5, SWITCHTEC_PSX}, //PSX 52XG5
157 {0x5136, SWITCHTEC_GEN5, SWITCHTEC_PSX}, //PSX 36XG5
158 {0x5128, SWITCHTEC_GEN5, SWITCHTEC_PSX}, //PSX 28XG5
159 {0x5200, SWITCHTEC_GEN5, SWITCHTEC_PAX}, //PAX 100XG5
160 {0x5284, SWITCHTEC_GEN5, SWITCHTEC_PAX}, //PAX 84XG5
161 {0x5268, SWITCHTEC_GEN5, SWITCHTEC_PAX}, //PAX 68XG5
162 {0x5252, SWITCHTEC_GEN5, SWITCHTEC_PAX}, //PAX 52XG5
163 {0x5236, SWITCHTEC_GEN5, SWITCHTEC_PAX}, //PAX 36XG5
164 {0x5228, SWITCHTEC_GEN5, SWITCHTEC_PAX}, //PAX 28XG5
165 {0x5300, SWITCHTEC_GEN5, SWITCHTEC_PFXA}, //PFX-A 100XG5
166 {0x5384, SWITCHTEC_GEN5, SWITCHTEC_PFXA}, //PFX-A 84XG5
167 {0x5368, SWITCHTEC_GEN5, SWITCHTEC_PFXA}, //PFX-A 68XG5
168 {0x5352, SWITCHTEC_GEN5, SWITCHTEC_PFXA}, //PFX-A 52XG5
169 {0x5336, SWITCHTEC_GEN5, SWITCHTEC_PFXA}, //PFX-A 36XG5
170 {0x5328, SWITCHTEC_GEN5, SWITCHTEC_PFXA}, //PFX-A 28XG5
171 {0x5400, SWITCHTEC_GEN5, SWITCHTEC_PSXA}, //PSX-A 100XG5
172 {0x5484, SWITCHTEC_GEN5, SWITCHTEC_PSXA}, //PSX-A 84XG5
173 {0x5468, SWITCHTEC_GEN5, SWITCHTEC_PSXA}, //PSX-A 68XG5
174 {0x5452, SWITCHTEC_GEN5, SWITCHTEC_PSXA}, //PSX-A 52XG5
175 {0x5436, SWITCHTEC_GEN5, SWITCHTEC_PSXA}, //PSX-A 36XG5
176 {0x5428, SWITCHTEC_GEN5, SWITCHTEC_PSXA}, //PSX-A 28XG5
177 {0x5500, SWITCHTEC_GEN5, SWITCHTEC_PAXA}, //PAX-A 100XG5
178 {0x5584, SWITCHTEC_GEN5, SWITCHTEC_PAXA}, //PAX-A 84XG5
179 {0x5568, SWITCHTEC_GEN5, SWITCHTEC_PAXA}, //PAX-A 68XG5
180 {0x5552, SWITCHTEC_GEN5, SWITCHTEC_PAXA}, //PAX-A 52XG5
181 {0x5536, SWITCHTEC_GEN5, SWITCHTEC_PAXA}, //PAX-A 36XG5
182 {0x5528, SWITCHTEC_GEN5, SWITCHTEC_PAXA}, //PAX-A 28XG5
183 {0},
184};
185
186static int set_gen_variant(struct switchtec_dev * dev)
187{
189 int ret;
190
191 dev->boot_phase = SWITCHTEC_BOOT_PHASE_FW;
192 dev->gen = SWITCHTEC_GEN_UNKNOWN;
193 dev->var = SWITCHTEC_VAR_UNKNOWN;
194 dev->device_id = dev->ops->get_device_id(dev);
195 if (!dev->device_id)
196 switchtec_get_device_id_bl2(dev,
197 (unsigned short *)&dev->device_id);
198
199 while (id->device_id) {
200 if (id->device_id == dev->device_id) {
201 dev->gen = id->gen;
202 dev->var = id->var;
203
204 break;
205 }
206
207 id++;
208 }
209
210 dev->pax_id = SWITCHTEC_PAX_ID_LOCAL;
211 ret = switchtec_get_device_info(dev, &dev->boot_phase, &dev->gen, NULL);
212 if (ret)
213 return -1;
214
215 return 0;
216}
217
218static int set_local_pax_id(struct switchtec_dev *dev)
219{
220 unsigned char local_pax_id;
221 int ret;
222
223 dev->local_pax_id = -1;
224
225 if (!switchtec_is_pax_all(dev))
226 return 0;
227
228 ret = switchtec_cmd(dev, MRPC_GET_PAX_ID, NULL, 0,
229 &local_pax_id, sizeof(local_pax_id));
230 if (ret)
231 return -1;
232
233 dev->local_pax_id = local_pax_id;
234 return 0;
235}
236
242{
243 free(devlist);
244}
245
263struct switchtec_dev *switchtec_open(const char *device)
264{
265 int idx;
266 int domain = 0;
267 int bus, dev, func;
268 char path[PATH_MAX];
269 int inst;
270 char *endptr;
271 struct switchtec_dev *ret;
272
273 if (sscanf(device, "%i@%i", &bus, &dev) == 2) {
274 ret = switchtec_open_i2c_by_adapter(bus, dev);
275 goto found;
276 }
277
278 if (sscanf(device, "%2049[^@]@%i", path, &dev) == 2) {
279 ret = switchtec_open_i2c(path, dev);
280 goto found;
281 }
282
283 if (device[0] == '/' &&
284 sscanf(device, "%2049[^:]:%i", path, &dev) == 2) {
285 ret = switchtec_open_i2c(path, dev);
286 goto found;
287 }
288
289 if (strchr(device, '/') || strchr(device, '\\')) {
290 ret = switchtec_open_by_path(device);
291 goto found;
292 }
293
294 if (sscanf(device, "%x:%x.%x", &bus, &dev, &func) == 3) {
295 ret = switchtec_open_by_pci_addr(domain, bus, dev, func);
296 goto found;
297 }
298
299 if (sscanf(device, "%x:%x:%x.%x", &domain, &bus, &dev, &func) == 4) {
300 ret = switchtec_open_by_pci_addr(domain, bus, dev, func);
301 goto found;
302 }
303
304 if (sscanf(device, "%2049[^:]:%i", path, &inst) == 2) {
305 ret = switchtec_open_eth(path, inst);
306 goto found;
307 }
308
309 errno = 0;
310 idx = strtol(device, &endptr, 0);
311 if (!errno && endptr != device) {
312 ret = switchtec_open_by_index(idx);
313 goto found;
314 }
315
316 if (sscanf(device, "switchtec%d", &idx) == 1) {
317 ret = switchtec_open_by_index(idx);
318 goto found;
319 }
320
321 errno = ENODEV;
322 return NULL;
323
324found:
325 if (!ret) {
326 errno = ENODEV;
327 return NULL;
328 }
329
330 snprintf(ret->name, sizeof(ret->name), "%s", device);
331
332 if (set_gen_variant(ret))
333 return NULL;
334
335 if (set_local_pax_id(ret))
336 return NULL;
337
338 return ret;
339}
340
348_PURE int switchtec_device_id(struct switchtec_dev *dev)
349{
350 return dev->device_id;
351}
352
360_PURE enum switchtec_gen switchtec_gen(struct switchtec_dev *dev)
361{
362 return dev->gen;
363}
364
372_PURE enum switchtec_variant switchtec_variant(struct switchtec_dev *dev)
373{
374 return dev->var;
375}
376
384_PURE enum switchtec_boot_phase switchtec_boot_phase(struct switchtec_dev *dev)
385{
386 return dev->boot_phase;
387}
388
396_PURE const char *switchtec_name(struct switchtec_dev *dev)
397{
398 return dev->name;
399}
400
406_PURE int switchtec_partition(struct switchtec_dev *dev)
407{
408 return dev->partition;
409}
410
411int switchtec_set_pax_id(struct switchtec_dev *dev, int pax_id)
412{
413 if (!switchtec_is_pax_all(dev) && (pax_id != SWITCHTEC_PAX_ID_LOCAL))
414 return -1;
415
416 if (pax_id == SWITCHTEC_PAX_ID_LOCAL)
417 dev->pax_id = dev->local_pax_id;
418 else
419 dev->pax_id = pax_id;
420
421 return 0;
422}
423
424static int compare_port_id(const void *aa, const void *bb)
425{
426 const struct switchtec_port_id *a = aa, *b = bb;
427
428 if (a->partition != b->partition)
429 return a->partition - b->partition;
430 if (a->upstream != b->upstream)
431 return b->upstream - a->upstream;
432 return a->log_id - b->log_id;
433}
434
435static int compare_status(const void *aa, const void *bb)
436{
437 const struct switchtec_status *a = aa, *b = bb;
438
439 return compare_port_id(&a->port, &b->port);
440}
441
442static const char *lane_reversal_str(int link_up,
443 int lane_reversal)
444{
445 if (!link_up)
446 return "N/A";
447
448 switch(lane_reversal) {
449 case 0: return "Normal Lane Ordering";
450 case 1: return "x16 (Full) Lane Reversal";
451 case 2: return "x2 Lane Reversal";
452 case 4: return "x4 Lane Reversal";
453 case 8: return "x8 Lane Reversal";
454 default: return "Unknown Lane Ordering";
455 }
456}
457
458static void generate_lane_str(struct switchtec_status *s)
459{
460 int i, l;
461
462 for (i = 0; i < s->cfg_lnk_width; i++)
463 s->lanes[i] = 'x';
464
465 if (!s->link_up)
466 return;
467
468 l = s->first_act_lane;
469 if (!l && s->lane_reversal)
470 l += s->neg_lnk_width - 1;
471
472 for (i = 0; i < s->neg_lnk_width; i++) {
473 if (l < 0)
474 break;
475
476 if (i < 10)
477 s->lanes[l] = '0' + i;
478 else
479 s->lanes[l] = 'a' + i - 10;
480
481 l += s->lane_reversal ? -1 : 1;
482 }
483}
484
496int switchtec_status(struct switchtec_dev *dev,
497 struct switchtec_status **status)
498{
499 uint64_t port_bitmap = 0;
500 int ret;
501 int i, p;
502 int nr_ports = 0;
503 struct switchtec_status *s;
504 int max_ports;
505
506 if (!status) {
507 errno = EINVAL;
508 return -errno;
509 }
510
511 max_ports = switchtec_max_supported_ports(dev);
512
513 struct {
514 uint8_t phys_port_id;
515 uint8_t par_id;
516 uint8_t log_port_id;
517 uint8_t stk_id;
518 uint8_t cfg_lnk_width;
519 uint8_t neg_lnk_width;
520 uint8_t usp_flag;
521 uint8_t linkup_linkrate;
522 uint16_t LTSSM;
523 uint8_t lane_reversal;
524 uint8_t first_act_lane;
525 } ports[max_ports];
526
527 ret = switchtec_cmd(dev, MRPC_LNKSTAT, &port_bitmap, sizeof(port_bitmap),
528 ports, sizeof(ports));
529 if (ret)
530 return -1;
531
532
533 for (i = 0; i < max_ports; i++) {
534 if ((ports[i].stk_id >> 4) > SWITCHTEC_MAX_STACKS)
535 continue;
536 nr_ports++;
537 }
538
539 s = *status = calloc(nr_ports, sizeof(*s));
540 if (!s)
541 return -ENOMEM;
542
543 for (i = 0, p = 0; i < max_ports && p < nr_ports; i++) {
544 if ((ports[i].stk_id >> 4) > SWITCHTEC_MAX_STACKS)
545 continue;
546
547 s[p].port.partition = ports[i].par_id;
548 s[p].port.stack = ports[i].stk_id >> 4;
549 s[p].port.upstream = ports[i].usp_flag;
550 s[p].port.stk_id = ports[i].stk_id & 0xF;
551 s[p].port.phys_id = ports[i].phys_port_id;
552 s[p].port.log_id = ports[i].log_port_id;
553
554 s[p].cfg_lnk_width = ports[i].cfg_lnk_width;
555 s[p].neg_lnk_width = ports[i].neg_lnk_width;
556 s[p].link_up = ports[i].linkup_linkrate >> 7;
557 s[p].link_rate = ports[i].linkup_linkrate & 0x7F;
558 s[p].ltssm = le16toh(ports[i].LTSSM);
559 s[p].ltssm_str = switchtec_ltssm_str(s[p].ltssm, 1);
560 s[p].lane_reversal = ports[i].lane_reversal;
561 s[p].lane_reversal_str = lane_reversal_str(s[p].link_up,
562 s[p].lane_reversal);
563 s[p].first_act_lane = ports[i].first_act_lane & 0xF;
564 s[p].acs_ctrl = -1;
565 generate_lane_str(&s[p]);
566
567 p++;
568 }
569
570 qsort(s, nr_ports, sizeof(*s), compare_status);
571
572 return nr_ports;
573}
574
581void switchtec_status_free(struct switchtec_status *status, int ports)
582{
583 int i;
584
585 for (i = 0; i < ports; i++) {
586 if (status[i].pci_bdf)
587 free(status[i].pci_bdf);
588
589 if (status[i].pci_bdf_path)
590 free(status[i].pci_bdf_path);
591
592 if (status[i].pci_dev)
593 free(status[i].pci_dev);
594
595 if (status[i].class_devices)
596 free(status[i].class_devices);
597 }
598
599 free(status);
600}
601
609
620const char *switchtec_strerror(void)
621{
622 const char *msg = "Unknown MRPC error";
623 int err;
624
625 if ((errno & (SWITCHTEC_ERRNO_MRPC_FLAG_BIT |
626 SWITCHTEC_ERRNO_GENERAL_FLAG_BIT)) == 0) {
627 if (errno)
628 return strerror(errno);
629 else
630 return platform_strerror();
631 }
632
633 if (errno & SWITCHTEC_ERRNO_GENERAL_FLAG_BIT) {
634 switch (errno) {
635 case SWITCHTEC_ERR_LOG_DEF_READ_ERROR:
636 msg = "Error reading log definition file"; break;
637 case SWITCHTEC_ERR_BIN_LOG_READ_ERROR:
638 msg = "Error reading binary log file"; break;
639 case SWITCHTEC_ERR_PARSED_LOG_WRITE_ERROR:
640 msg = "Error writing parsed log file"; break;
641 case SWITCHTEC_ERR_LOG_DEF_DATA_INVAL:
642 msg = "Invalid log definition data"; break;
643 case SWITCHTEC_ERR_INVALID_PORT:
644 msg = "Invalid port specified"; break;
645 case SWITCHTEC_ERR_INVALID_LANE:
646 msg = "Invalid lane specified"; break;
647 default:
648 msg = "Unknown Switchtec error"; break;
649 }
650
651 return msg;
652 }
653
654 err = errno & ~SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
655
656 switch (err) {
657 case ERR_NO_AVAIL_MRPC_THREAD:
658 msg = "No available MRPC handler thread"; break;
659 case ERR_HANDLER_THREAD_NOT_IDLE:
660 msg = "The handler thread is not idle"; break;
661 case ERR_NO_BG_THREAD:
662 msg = "No background thread run for the command"; break;
663
664 case ERR_REFCLK_SUBCMD_INVALID:
665 case ERR_STACKBIF_SUBCMD_INVALID:
666 case ERR_SUBCMD_INVALID: msg = "Invalid subcommand"; break;
667 case ERR_CMD_INVALID: msg = "Invalid command"; break;
668 case ERR_PARAM_INVALID: msg = "Invalid parameter"; break;
669 case ERR_BAD_FW_STATE: msg = "Bad firmware state"; break;
670 case ERR_MRPC_DENIED: msg = "MRPC request denied"; break;
671 case ERR_MRPC_NO_PREV_DATA:
672 msg = "No previous adaptation object data";
673 break;
674 case ERR_REFCLK_STACK_ID_INVALID:
675 case ERR_STACKBIF_STACK_ID_INVALID:
676 case ERR_STACK_INVALID: msg = "Invalid Stack"; break;
677 case ERR_LOOPBACK_PORT_INVALID:
678 case ERR_PORT_INVALID: msg = "Invalid Port"; break;
679 case ERR_EVENT_INVALID: msg = "Invalid Event"; break;
680 case ERR_RST_RULE_FAILED: msg = "Reset rule search failed"; break;
681 case ERR_UART_NOT_SUPPORTED:
682 msg = "UART interface not supported for this command"; break;
683 case ERR_XML_VERSION_MISMATCH:
684 msg = "XML version mismatch between MAIN and CFG partition";
685 break;
686 case ERR_ACCESS_REFUSED: msg = "Access Refused"; break;
687
688 case ERR_STACKBIF_CODE_INVALID:
689 msg = "Stack bifurcation code invalid"; break;
690 break;
691 case ERR_STACKBIF_PORT_BOUND:
692 msg = "Port already bound"; break;
693 break;
694
695 default: break;
696 }
697
698 switch (mrpc_error_cmd) {
699 case MRPC_PORTPARTP2P:
700 switch (err) {
701 case ERR_PHYC_PORT_ARDY_BIND:
702 msg = "Physical port already bound"; break;
703 case ERR_LOGC_PORT_ARDY_BIND:
704 msg = "Logical bridge instance already bound"; break;
705 case ERR_BIND_PRTT_NOT_EXIST:
706 msg = "Partition does not exist"; break;
707 case ERR_PHYC_PORT_NOT_EXIST:
708 msg = "Physical port does not exist"; break;
709 case ERR_PHYC_PORT_DIS:
710 msg = "Physical port disabled"; break;
711 case ERR_NO_LOGC_PORT:
712 msg = "No logical bridge instance"; break;
713 case ERR_BIND_IN_PROGRESS:
714 msg = "Bind/unbind in progress"; break;
715 case ERR_BIND_TGT_IS_USP:
716 msg = "Bind/unbind target is USP"; break;
717 case ERR_BIND_SUBCMD_INVALID:
718 msg = "Sub-command does not exist"; break;
719 case ERR_PHYC_PORT_LINK_ACT:
720 msg = "Physical port link active"; break;
721 case ERR_LOGC_PORT_NOT_BIND_PHYC_PORT:
722 msg = "Logical bridge not bind to physical port"; break;
723 case ERR_UNBIND_OPT_INVALID:
724 msg = "Invalid unbind option"; break;
725 case ERR_BIND_CHECK_FAIL:
726 msg = "Port bind checking failed"; break;
727 default: break;
728 }
729 break;
730 default: break;
731 }
732
733 return msg;
734}
735
743void switchtec_perror(const char *str)
744{
745 const char *msg = switchtec_strerror();
746 int is_mrpc = errno & SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
747 int err = errno & ~SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
748
749 if (is_mrpc)
750 fprintf(stderr, "%s: %s (MRPC: 0x%x, error: 0x%x)\n",
751 str, msg, mrpc_error_cmd, err);
752 else
753 fprintf(stderr, "%s: %s\n", str, msg);
754}
755
774int switchtec_echo(struct switchtec_dev *dev, uint32_t input,
775 uint32_t *output)
776{
777 return switchtec_cmd(dev, MRPC_ECHO, &input, sizeof(input),
778 output, sizeof(*output));
779}
780
790int switchtec_hard_reset(struct switchtec_dev *dev)
791{
792 uint32_t subcmd = 0;
793
794 return switchtec_cmd(dev, MRPC_RESET, &subcmd, sizeof(subcmd),
795 NULL, 0);
796}
797
802static void free_log_defs(struct log_defs *defs)
803{
804 int i, j;
805
806 if (!defs->module_defs)
807 return;
808
809 for (i = 0; i < defs->num_alloc; i++) {
810 free(defs->module_defs[i].mod_name);
811
812 for (j = 0; j < defs->module_defs[i].num_entries; j++)
813 free(defs->module_defs[i].entries[j]);
814
815 free(defs->module_defs[i].entries);
816 }
817
818 free(defs->module_defs);
819}
820
827static int realloc_log_defs(struct log_defs *defs, int num_modules)
828{
829 int i;
830
831 defs->module_defs = realloc(defs->module_defs,
832 (num_modules *
833 sizeof(struct module_log_defs)));
834 if (!defs->module_defs) {
835 free_log_defs(defs);
836 return -1;
837 }
838
839 for (i = defs->num_alloc; i < num_modules; i++)
840 memset(&defs->module_defs[i], 0,
841 sizeof(struct module_log_defs));
842
843 defs->num_alloc = num_modules;
844
845 return 0;
846}
847
854static bool parse_int(char *str, int *val)
855{
856 char *endptr;
857
858 errno = 0;
859 *val = strtol(str, &endptr, 0);
860
861 if ((endptr == str) || (*endptr != '\0') || (errno != 0))
862 return false;
863
864 return true;
865}
866
873static int read_app_log_defs(FILE *log_def_file, struct log_defs *defs)
874{
875 int ret;
876 char line[512];
877 char *tok;
878 int mod_id;
879 struct module_log_defs *mod_defs;
880 int num_entries;
881 int i;
882
883 /* allocate some log definition entries */
884 ret = realloc_log_defs(defs, 200);
885 if (ret < 0)
886 return ret;
887
888 while (fgets(line, sizeof(line), log_def_file)) {
889
890 /* ignore comments */
891 if (line[0] == '#')
892 continue;
893
894 /* strip any newline characters */
895 line[strcspn(line, "\r\n")] = '\0';
896
897 /*
898 * Tokenize and parse the line. Module headings are of the form:
899 * mod_name mod_id num_entries
900 */
901 tok = strtok(line, " \t");
902 if (!tok)
903 continue;
904
905 tok = strtok(NULL, " \t");
906 if (!tok)
907 continue;
908
909 if (!parse_int(tok, &mod_id)) {
910 errno = SWITCHTEC_ERR_LOG_DEF_DATA_INVAL;
911 goto err_free_log_defs;
912 }
913
914 /* reallocate more log definition entries if needed */
915 if (mod_id > defs->num_alloc) {
916 ret = realloc_log_defs(defs, mod_id * 2);
917 if (ret < 0)
918 return ret;
919 }
920
921 mod_defs = &defs->module_defs[mod_id];
922
923 tok = strtok(NULL, " \t");
924 if (!tok)
925 continue;
926
927 if (!parse_int(tok, &num_entries)) {
928 errno = SWITCHTEC_ERR_LOG_DEF_DATA_INVAL;
929 goto err_free_log_defs;
930 }
931
932 /*
933 * Skip this module if it has already been done. This can happen
934 * if the module is duplicated in the log definition file.
935 */
936 if (mod_defs->mod_name != NULL) {
937 for (i = 0; i < num_entries; i++) {
938 if (!fgets(line, sizeof(line),
939 log_def_file))
940 break;
941 }
942 continue;
943 }
944
945 mod_defs->mod_name = strdup(line);
946 mod_defs->num_entries = num_entries;
947 mod_defs->entries = calloc(mod_defs->num_entries,
948 sizeof(*mod_defs->entries));
949 if (!mod_defs->entries)
950 goto err_free_log_defs;
951
952 for (i = 0; i < mod_defs->num_entries; i++) {
953 if (fgets(line, sizeof(line), log_def_file) == NULL) {
954 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
955 goto err_free_log_defs;
956 }
957
958 mod_defs->entries[i] = strdup(line);
959 if (!mod_defs->entries[i])
960 goto err_free_log_defs;
961 }
962 }
963
964 if (ferror(log_def_file)) {
965 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
966 goto err_free_log_defs;
967 }
968
969 return 0;
970
971err_free_log_defs:
972 free_log_defs(defs);
973 return -1;
974}
975
982static int read_mailbox_log_defs(FILE *log_def_file, struct log_defs *defs)
983{
984 int ret;
985 char line[512];
986 struct module_log_defs *mod_defs;
987 int num_entries_alloc;
988
989 /*
990 * The mailbox log definitions don't keep track of modules. Allocate a
991 * single log definition entry for all definitions.
992 */
993 ret = realloc_log_defs(defs, 1);
994 if (ret < 0)
995 return ret;
996
997 mod_defs = &defs->module_defs[0];
998 mod_defs->num_entries = 0;
999
1000 /* allocate some entries */
1001 num_entries_alloc = 100;
1002 mod_defs->entries = calloc(num_entries_alloc,
1003 sizeof(*mod_defs->entries));
1004 if (!mod_defs->entries)
1005 goto err_free_log_defs;
1006
1007 while (fgets(line, sizeof(line), log_def_file)) {
1008 /* ignore comments */
1009 if (line[0] == '#')
1010 continue;
1011
1012 if (mod_defs->num_entries >= num_entries_alloc) {
1013 /* allocate more entries */
1014 num_entries_alloc *= 2;
1015 mod_defs->entries = realloc(mod_defs->entries,
1016 (num_entries_alloc *
1017 sizeof(*mod_defs->entries)));
1018 if (!mod_defs->entries)
1019 goto err_free_log_defs;
1020 }
1021
1022 mod_defs->entries[mod_defs->num_entries] = strdup(line);
1023 if (!mod_defs->entries[mod_defs->num_entries])
1024 goto err_free_log_defs;
1025
1026 mod_defs->num_entries++;
1027 }
1028
1029 if (ferror(log_def_file)) {
1030 errno = SWITCHTEC_ERR_LOG_DEF_READ_ERROR;
1031 goto err_free_log_defs;
1032 }
1033
1034 return 0;
1035
1036err_free_log_defs:
1037 free_log_defs(defs);
1038 return -1;
1039}
1040
1052static int write_parsed_log(struct log_a_data log_data[],
1053 size_t count, int init_entry_idx,
1054 struct log_defs *defs,
1055 enum switchtec_log_parse_type log_type,
1056 FILE *log_file, int ts_factor)
1057{
1058 int i;
1059 int ret;
1060 int entry_idx = init_entry_idx;
1061 unsigned long long time;
1062 unsigned int nanos, micros, millis, secs, mins, hours, days;
1063 unsigned int entry_num;
1064 unsigned int mod_id;
1065 unsigned int log_sev = 0;
1066 const char *log_sev_strs[] = {"DISABLED", "HIGHEST", "HIGH", "MEDIUM",
1067 "LOW", "LOWEST"};
1068 bool is_bl1;
1069 struct module_log_defs *mod_defs;
1070
1071 if (entry_idx == 0) {
1072 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP)
1073 fputs(" #|Timestamp |Module |Severity |Event ID |Event\n",
1074 log_file);
1075 else
1076 fputs(" #|Timestamp |Source |Event ID |Event\n",
1077 log_file);
1078 }
1079
1080 for (i = 0; i < count; i ++) {
1081 /* timestamp is in the first 2 DWords */
1082 time = (((unsigned long long)log_data[i].data[0] << 32) |
1083 log_data[i].data[1]) * ts_factor/100;
1084 nanos = time % 1000;
1085 time /= 1000;
1086 micros = time % 1000;
1087 time /= 1000;
1088 millis = time % 1000;
1089 time /= 1000;
1090 secs = time % 60;
1091 time /= 60;
1092 mins = time % 60;
1093 time /= 60;
1094 hours = time % 24;
1095 days = time / 24;
1096
1097 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP) {
1098 /*
1099 * app log: module ID and log severity are in the 3rd
1100 * DWord
1101 */
1102 mod_id = (log_data[i].data[2] >> 16) & 0xFFF;
1103 log_sev = (log_data[i].data[2] >> 28) & 0xF;
1104
1105 if ((mod_id > defs->num_alloc) ||
1106 (defs->module_defs[mod_id].mod_name == NULL) ||
1107 (strlen(defs->module_defs[mod_id].mod_name) == 0)) {
1108 if (fprintf(log_file, "(Invalid module ID: 0x%x)\n",
1109 mod_id) < 0)
1110 goto ret_print_error;
1111 continue;
1112 }
1113
1114 if (log_sev >= ARRAY_SIZE(log_sev_strs)) {
1115 if (fprintf(log_file, "(Invalid log severity: %d)\n",
1116 log_sev) < 0)
1117 goto ret_print_error;
1118 continue;
1119 }
1120 } else {
1121 /*
1122 * mailbox log: BL1/BL2 indication is in the 3rd
1123 * DWord
1124 */
1125 is_bl1 = (((log_data[i].data[2] >> 27) & 1) == 0);
1126
1127 /* mailbox log definitions are all in the first entry */
1128 mod_id = 0;
1129 }
1130
1131 mod_defs = &defs->module_defs[mod_id];
1132
1133 /* entry number is in the 3rd DWord */
1134 entry_num = log_data[i].data[2] & 0x0000FFFF;
1135
1136 if (entry_num >= mod_defs->num_entries) {
1137 if (fprintf(log_file,
1138 "(Invalid log entry number: %d (module 0x%x))\n",
1139 entry_num, mod_id) < 0)
1140 goto ret_print_error;
1141 continue;
1142 }
1143
1144 /* print the entry index and timestamp */
1145 if (ts_factor == 0)
1146 ret = fprintf(log_file,
1147 "%04d|xxxd xx:xx:xx.xxx,xxx,xxx|",
1148 entry_idx);
1149 else
1150 ret = fprintf(log_file,
1151 "%04d|%03dd %02d:%02d:%02d.%03d,%03d,%03d|",
1152 entry_idx, days, hours, mins, secs,
1153 millis, micros, nanos);
1154
1155 if (ret < 0)
1156 goto ret_print_error;
1157
1158 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP) {
1159 /* print the module name and log severity */
1160 if (fprintf(log_file, "%-12s |%-8s |0x%04x |",
1161 mod_defs->mod_name, log_sev_strs[log_sev],
1162 entry_num) < 0)
1163 goto ret_print_error;
1164 } else {
1165 /* print the log source (BL1/BL2) */
1166 if (fprintf(log_file, "%-6s |0x%04x |",
1167 (is_bl1 ? "BL1" : "BL2"), entry_num) < 0)
1168 goto ret_print_error;
1169 }
1170
1171 /* print the log entry */
1172 if (fprintf(log_file, mod_defs->entries[entry_num],
1173 log_data[i].data[3], log_data[i].data[4],
1174 log_data[i].data[5], log_data[i].data[6],
1175 log_data[i].data[7]) < 0)
1176 goto ret_print_error;
1177
1178 entry_idx++;
1179 }
1180
1181 if (fflush(log_file) != 0)
1182 return -1;
1183
1184 return 0;
1185
1186ret_print_error:
1187 errno = SWITCHTEC_ERR_PARSED_LOG_WRITE_ERROR;
1188 return -1;
1189}
1190
1191static int parse_def_header(FILE *log_def_file, uint32_t *fw_version,
1192 uint32_t *sdk_version)
1193{
1194 char line[512];
1195 int i;
1196
1197 *fw_version = 0;
1198 *sdk_version = 0;
1199 while (fgets(line, sizeof(line), log_def_file)) {
1200 if (line[0] != '#')
1201 continue;
1202
1203 i = 0;
1204 while (line[i] == ' ' || line[i] == '#') i++;
1205
1206 if (strncasecmp(line + i, "SDK Version:", 12) == 0) {
1207 i += 12;
1208 while (line[i] == ' ') i++;
1209 sscanf(line + i, "%i", (int*)sdk_version);
1210 }
1211 else if (strncasecmp(line + i, "FW Version:", 11) == 0) {
1212 i += 11;
1213 while (line[i] == ' ') i++;
1214 sscanf(line + i, "%i", (int*)fw_version);
1215 }
1216 }
1217
1218 rewind(log_def_file);
1219 return 0;
1220}
1221
1222static int append_log_header(int fd, uint32_t sdk_version,
1223 uint32_t fw_version, int binary)
1224{
1225 int ret;
1226 struct log_header {
1227 uint8_t magic[8];
1228 uint32_t fw_version;
1229 uint32_t sdk_version;
1230 uint32_t flags;
1231 uint32_t rsvd[3];
1232 } header = {
1233 .magic = {'S', 'W', 'M', 'C', 'L', 'O', 'G', 'F'},
1234 .fw_version = fw_version,
1235 .sdk_version = sdk_version
1236 };
1237 char hdr_str_fmt[] = "####################################\n"
1238 "## Parsed with definition file for\n"
1239 "## FW version %08x\n"
1240 "## SDK version %08x\n"
1241 "####################################\n\n";
1242 char hdr_str[512];
1243
1244 if (binary) {
1245 ret = write(fd, &header, sizeof(header));
1246 } else {
1247 snprintf(hdr_str, 512, hdr_str_fmt, fw_version, sdk_version);
1248 ret = write(fd, hdr_str, strlen(hdr_str));
1249 }
1250
1251 return ret;
1252}
1253
1254static int get_ts_factor(enum switchtec_gen gen)
1255{
1256 if (gen == SWITCHTEC_GEN_UNKNOWN)
1257 return 0;
1258 else if (gen == SWITCHTEC_GEN3)
1259 return 1000;
1260 else
1261 return 833;
1262}
1263
1264static int log_a_to_file(struct switchtec_dev *dev, int sub_cmd_id,
1265 int fd, FILE *log_def_file,
1266 struct switchtec_log_file_info *info)
1267{
1268 int ret = -1;
1269 int read = 0;
1270 struct log_a_retr_result res;
1271 struct log_a_retr cmd = {
1272 .sub_cmd_id = sub_cmd_id,
1273 .start = -1,
1274 };
1275 struct log_defs defs = {
1276 .module_defs = NULL,
1277 .num_alloc = 0};
1278 FILE *log_file;
1279 int entry_idx = 0;
1280 uint32_t fw_version = 0;
1281 uint32_t sdk_version = 0;
1282
1283 if (log_def_file != NULL) {
1284 ret = parse_def_header(log_def_file, &fw_version,
1285 &sdk_version);
1286 if (ret)
1287 return ret;
1288 /* read the log definition file into defs */
1289 ret = read_app_log_defs(log_def_file, &defs);
1290 if (ret < 0)
1291 return ret;
1292 }
1293
1294 res.hdr.remain = 1;
1295
1296 while (res.hdr.remain) {
1297 ret = switchtec_cmd(dev, MRPC_FWLOGRD, &cmd, sizeof(cmd),
1298 &res, sizeof(res));
1299 if (ret)
1300 goto ret_free_log_defs;
1301 if (res.hdr.overflow && info)
1302 info->overflow = 1;
1303 if (read == 0) {
1304 if (dev->gen < SWITCHTEC_GEN5) {
1305 res.hdr.sdk_version = 0;
1306 res.hdr.fw_version = 0;
1307 }
1308
1309 if (info) {
1310 info->def_fw_version = fw_version;
1311 info->def_sdk_version = sdk_version;
1312 info->log_fw_version = res.hdr.fw_version;
1313 info->log_sdk_version = res.hdr.sdk_version;
1314 }
1315
1316 if (res.hdr.sdk_version != sdk_version ||
1317 res.hdr.fw_version != fw_version) {
1318 if (info && log_def_file)
1319 info->version_mismatch = true;
1320
1321 }
1322
1323 append_log_header(fd, res.hdr.sdk_version,
1324 res.hdr.fw_version,
1325 log_def_file == NULL? 1 : 0);
1326 }
1327
1328 if (log_def_file == NULL) {
1329 /* write the binary log data to a file */
1330 ret = write(fd, res.data,
1331 sizeof(*res.data) * res.hdr.count);
1332 if (ret < 0)
1333 return ret;
1334 } else {
1335 log_file = fdopen(fd, "w");
1336 if (!log_file)
1337 goto ret_free_log_defs;
1338
1339 /* parse the log data and write it to a file */
1340 ret = write_parsed_log(res.data, res.hdr.count,
1341 entry_idx, &defs,
1342 SWITCHTEC_LOG_PARSE_TYPE_APP,
1343 log_file,
1344 get_ts_factor(dev->gen));
1345 if (ret < 0)
1346 goto ret_free_log_defs;
1347
1348 entry_idx += res.hdr.count;
1349 }
1350
1351 read += le32toh(res.hdr.count);
1352 cmd.start = res.hdr.next_start;
1353 }
1354
1355 ret = 0;
1356
1357ret_free_log_defs:
1358 free_log_defs(&defs);
1359 return ret;
1360}
1361
1362static int log_b_to_file(struct switchtec_dev *dev, int sub_cmd_id, int fd)
1363{
1364 int ret;
1365 int read = 0;
1366 struct log_b_retr_result res;
1367 struct log_b_retr cmd = {
1368 .sub_cmd_id = sub_cmd_id,
1369 .offset = 0,
1370 .length = htole32(sizeof(res.data)),
1371 };
1372
1373 res.hdr.remain = sizeof(res.data);
1374
1375 while (res.hdr.remain) {
1376 ret = switchtec_cmd(dev, MRPC_FWLOGRD, &cmd, sizeof(cmd),
1377 &res, sizeof(res));
1378 if (ret)
1379 return -1;
1380
1381 ret = write(fd, res.data, res.hdr.length);
1382 if (ret < 0)
1383 return ret;
1384
1385 read += le32toh(res.hdr.length);
1386 cmd.offset = htole32(read);
1387 }
1388
1389 return 0;
1390}
1391
1392static int log_c_to_file(struct switchtec_dev *dev, int sub_cmd_id, int fd)
1393{
1394 int ret;
1395 struct log_cmd {
1396 uint8_t subcmd;
1397 uint8_t rsvd[3];
1398 } cmd = {};
1399
1400 struct log_reply {
1401 uint8_t reason;
1402 uint8_t rsvd[3];
1403 uint32_t nvlog_version;
1404 uint32_t thread_handle;
1405 uint32_t fw_version;
1406 uint32_t timestamp1;
1407 uint32_t timestamp2;
1408 } reply;
1409
1410 cmd.subcmd = sub_cmd_id;
1411
1412 ret = switchtec_cmd(dev, MRPC_FWLOGRD, &cmd, sizeof(cmd),
1413 &reply, sizeof(reply));
1414 if (ret)
1415 return -1;
1416
1417 ret = write(fd, &reply, sizeof(reply));
1418 if (ret < 0)
1419 return ret;
1420
1421 return 0;
1422}
1423
1424static int log_ram_flash_to_file(struct switchtec_dev *dev,
1425 int gen5_cmd, int gen4_cmd, int gen4_cmd_lgcy,
1426 int fd, FILE *log_def_file,
1427 struct switchtec_log_file_info *info)
1428{
1429 int ret;
1430
1431 if (switchtec_is_gen5(dev)) {
1432 return log_a_to_file(dev, gen5_cmd, fd, log_def_file,
1433 info);
1434 } else {
1435 ret = log_a_to_file(dev, gen4_cmd, fd, log_def_file,
1436 info);
1437
1438 /* somehow hardware returns ERR_LOGC_PORT_ARDY_BIND
1439 * instead of ERR_SUBCMD_INVALID if this subcommand
1440 * is not supported, so we fall back to legacy
1441 * subcommand on ERR_LOGC_PORT_ARDY_BIND error as well
1442 */
1443 if (ret > 0 &&
1444 (ERRNO_MRPC(errno) == ERR_LOGC_PORT_ARDY_BIND ||
1445 ERRNO_MRPC(errno) == ERR_SUBCMD_INVALID))
1446 ret = log_a_to_file(dev, gen4_cmd_lgcy, fd,
1447 log_def_file, info);
1448
1449 return ret;
1450 }
1451}
1452
1462int switchtec_log_to_file(struct switchtec_dev *dev,
1463 enum switchtec_log_type type, int fd, FILE *log_def_file,
1464 struct switchtec_log_file_info *info)
1465{
1466 if (info)
1467 memset(info, 0, sizeof(*info));
1468
1469 switch (type) {
1470 case SWITCHTEC_LOG_RAM:
1471 return log_ram_flash_to_file(dev,
1472 MRPC_FWLOGRD_RAM_GEN5,
1473 MRPC_FWLOGRD_RAM_WITH_FLAG,
1474 MRPC_FWLOGRD_RAM,
1475 fd, log_def_file, info);
1476 case SWITCHTEC_LOG_FLASH:
1477 return log_ram_flash_to_file(dev,
1478 MRPC_FWLOGRD_FLASH_GEN5,
1479 MRPC_FWLOGRD_FLASH_WITH_FLAG,
1480 MRPC_FWLOGRD_FLASH,
1481 fd, log_def_file, info);
1482 case SWITCHTEC_LOG_MEMLOG:
1483 return log_b_to_file(dev, MRPC_FWLOGRD_MEMLOG, fd);
1484 case SWITCHTEC_LOG_REGS:
1485 return log_b_to_file(dev, MRPC_FWLOGRD_REGS, fd);
1486 case SWITCHTEC_LOG_THRD_STACK:
1487 return log_b_to_file(dev, MRPC_FWLOGRD_THRD_STACK, fd);
1488 case SWITCHTEC_LOG_SYS_STACK:
1489 return log_b_to_file(dev, MRPC_FWLOGRD_SYS_STACK, fd);
1490 case SWITCHTEC_LOG_THRD:
1491 return log_b_to_file(dev, MRPC_FWLOGRD_THRD, fd);
1492 case SWITCHTEC_LOG_NVHDR:
1493 return log_c_to_file(dev, MRPC_FWLOGRD_NVHDR, fd);
1494 };
1495
1496 errno = EINVAL;
1497 return -errno;
1498}
1499
1500static int parse_log_header(FILE *bin_log_file, uint32_t *fw_version,
1501 uint32_t *sdk_version)
1502{
1503 struct log_header {
1504 uint8_t magic[8];
1505 uint32_t fw_version;
1506 uint32_t sdk_version;
1507 uint32_t flags;
1508 uint32_t rsvd[3];
1509 } header;
1510
1511 char sig[8] = {'S', 'W', 'M', 'C', 'L', 'O', 'G', 'F'};
1512 int ret;
1513
1514 ret = fread(&header, sizeof(header), 1, bin_log_file);
1515 if (ret <= 0) {
1516 errno = EBADF;
1517 return -EBADF;
1518 }
1519
1520 if (memcmp(sig, header.magic, 8)) {
1521 rewind(bin_log_file);
1522 *fw_version = 0;
1523 *sdk_version = 0;
1524 return 0;
1525 }
1526
1527 *fw_version = header.fw_version;
1528 *sdk_version = header.sdk_version;
1529
1530 return 0;
1531}
1532
1543int switchtec_parse_log(FILE *bin_log_file, FILE *log_def_file,
1544 FILE *parsed_log_file,
1545 enum switchtec_log_parse_type log_type,
1546 enum switchtec_gen gen,
1547 struct switchtec_log_file_info *info)
1548{
1549 int ret;
1550 struct log_a_data log_data;
1551 struct log_defs defs = {
1552 .module_defs = NULL,
1553 .num_alloc = 0};
1554 int entry_idx = 0;
1555 uint32_t fw_version_log;
1556 uint32_t sdk_version_log;
1557 uint32_t fw_version_def;
1558 uint32_t sdk_version_def;
1559 enum switchtec_gen gen_file;
1560
1561 if (info)
1562 memset(info, 0, sizeof(*info));
1563
1564 if ((log_type != SWITCHTEC_LOG_PARSE_TYPE_APP) &&
1565 (log_type != SWITCHTEC_LOG_PARSE_TYPE_MAILBOX)) {
1566 errno = EINVAL;
1567 return -errno;
1568 }
1569
1570 ret = parse_log_header(bin_log_file, &fw_version_log,
1571 &sdk_version_log);
1572 if (ret)
1573 return ret;
1574 ret = parse_def_header(log_def_file, &fw_version_def,
1575 &sdk_version_def);
1576 if (ret)
1577 return ret;
1578
1579 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_MAILBOX) {
1580 fw_version_log = fw_version_def;
1581 sdk_version_log = sdk_version_def;
1582 }
1583
1584 if (info) {
1585 info->def_fw_version = fw_version_def;
1586 info->def_sdk_version = sdk_version_def;
1587
1588 info->log_fw_version = fw_version_log;
1589 info->log_sdk_version = sdk_version_log;
1590 }
1591 /* read the log definition file into defs */
1592 if (log_type == SWITCHTEC_LOG_PARSE_TYPE_APP)
1593 ret = read_app_log_defs(log_def_file, &defs);
1594 else
1595 ret = read_mailbox_log_defs(log_def_file, &defs);
1596
1597 if (ret < 0)
1598 return ret;
1599
1600 ret = append_log_header(fileno(parsed_log_file), sdk_version_log,
1601 fw_version_log, 0);
1602 if (ret < 0)
1603 return ret;
1604
1605 /* parse each log entry */
1606 while (fread(&log_data, sizeof(struct log_a_data), 1,
1607 bin_log_file) == 1) {
1608 if(fw_version_log)
1609 gen_file = switchtec_fw_version_to_gen(fw_version_log);
1610 else
1611 gen_file = switchtec_fw_version_to_gen(fw_version_def);
1612
1613 if (gen_file != SWITCHTEC_GEN_UNKNOWN &&
1614 gen != SWITCHTEC_GEN_UNKNOWN) {
1615 if (info)
1616 info->gen_ignored = true;
1617 } else if (gen_file == SWITCHTEC_GEN_UNKNOWN &&
1618 gen == SWITCHTEC_GEN_UNKNOWN) {
1619 if (info)
1620 info->gen_unknown = true;
1621 } else if (gen != SWITCHTEC_GEN_UNKNOWN) {
1622 gen_file = gen;
1623 }
1624
1625 ret = write_parsed_log(&log_data, 1, entry_idx, &defs,
1626 log_type, parsed_log_file,
1627 get_ts_factor(gen_file));
1628 if (ret < 0)
1629 goto ret_free_log_defs;
1630
1631 entry_idx++;
1632 }
1633
1634 if (ferror(bin_log_file)) {
1635 errno = SWITCHTEC_ERR_BIN_LOG_READ_ERROR;
1636 ret = -1;
1637 }
1638
1639 if (fw_version_def != fw_version_log ||
1640 sdk_version_def != sdk_version_log) {
1641 if (info)
1642 info->version_mismatch = true;
1643 ret = ENOEXEC;
1644 }
1645
1646ret_free_log_defs:
1647 free_log_defs(&defs);
1648 return ret;
1649}
1650
1658int switchtec_log_def_to_file(struct switchtec_dev *dev,
1659 enum switchtec_log_def_type type,
1660 FILE* file)
1661{
1662 int ret;
1663 struct log_cmd {
1664 uint8_t subcmd;
1665 uint8_t rsvd[3];
1666 uint16_t idx;
1667 uint16_t mod_id;
1668 } cmd = {};
1669
1670 struct log_reply {
1671 uint16_t end_of_data;
1672 uint16_t data_len;
1673 uint16_t next_idx;
1674 uint16_t next_mod_id;
1675 uint8_t data[MRPC_MAX_DATA_LEN - 16];
1676 } reply = {};
1677
1678 switch (type) {
1679 case SWITCHTEC_LOG_DEF_TYPE_APP:
1680 cmd.subcmd = MRPC_LOG_DEF_APP;
1681 break;
1682
1683 case SWITCHTEC_LOG_DEF_TYPE_MAILBOX:
1684 cmd.subcmd = MRPC_LOG_DEF_MAILBOX;
1685 break;
1686
1687 default:
1688 errno = EINVAL;
1689 return -errno;
1690 }
1691
1692 do {
1693 ret = switchtec_cmd(dev, MRPC_LOG_DEF_GET, &cmd, sizeof(cmd),
1694 &reply, sizeof(reply));
1695 if (ret)
1696 return -1;
1697
1698 ret = fwrite(reply.data, reply.data_len, 1, file);
1699 if (ret < 0)
1700 return ret;
1701
1702 cmd.idx = reply.next_idx;
1703 cmd.mod_id = reply.next_mod_id;
1704 } while (!reply.end_of_data);
1705
1706 return 0;
1707}
1708
1709static enum switchtec_gen map_to_gen(uint32_t gen)
1710{
1711 enum switchtec_gen ret = SWITCHTEC_GEN_UNKNOWN;
1712
1713 switch (gen) {
1714 case 0:
1715 ret = SWITCHTEC_GEN4;
1716 break;
1717 case 1:
1718 ret = SWITCHTEC_GEN5;
1719 break;
1720 default:
1721 ret = SWITCHTEC_GEN_UNKNOWN;
1722 break;
1723 }
1724
1725 return ret;
1726}
1727
1736int switchtec_get_device_info(struct switchtec_dev *dev,
1737 enum switchtec_boot_phase *phase,
1738 enum switchtec_gen *gen,
1739 enum switchtec_rev *rev)
1740{
1741 int ret;
1742 uint32_t ping_dw = 0;
1743 uint32_t dev_info;
1744 struct get_dev_info_reply {
1745 uint32_t dev_info;
1746 uint32_t ping_reply;
1747 } reply;
1748
1749 ping_dw = time(NULL);
1750
1751 /*
1752 * The I2C TWI Ping command also dumps information about the
1753 * revision and image phase.
1754 */
1755 ret = switchtec_cmd(dev, MRPC_I2C_TWI_PING, &ping_dw,
1756 sizeof(ping_dw),
1757 &reply, sizeof(reply));
1758 if (ret == 0) {
1759 if (ping_dw != ~reply.ping_reply)
1760 return -1;
1761
1762 dev_info = le32toh(reply.dev_info);
1763 if (phase)
1764 *phase = dev_info & 0xff;
1765 if (rev)
1766 *rev = (dev_info >> 8) & 0x0f;
1767 if (gen)
1768 *gen = map_to_gen((dev_info >> 12) & 0x0f);
1769 } else if (errno == EBADMSG || ERRNO_MRPC(errno) == ERR_CMD_INVALID) {
1770 if (phase)
1771 *phase = SWITCHTEC_BOOT_PHASE_FW;
1772 if (gen)
1773 *gen = SWITCHTEC_GEN3;
1774 if (rev)
1775 *rev = SWITCHTEC_REV_UNKNOWN;
1776
1777 errno = 0;
1778 } else {
1779 return -1;
1780 }
1781
1782 return 0;
1783}
1784
1791float switchtec_die_temp(struct switchtec_dev *dev)
1792{
1793 int ret;
1794 uint32_t sub_cmd_id;
1795 uint32_t temp;
1796
1797 if (switchtec_is_gen3(dev)) {
1798 sub_cmd_id = MRPC_DIETEMP_SET_MEAS;
1799 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1800 sizeof(sub_cmd_id), NULL, 0);
1801 if (ret)
1802 return -100.0;
1803
1804 sub_cmd_id = MRPC_DIETEMP_GET;
1805 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1806 sizeof(sub_cmd_id), &temp, sizeof(temp));
1807 if (ret)
1808 return -100.0;
1809 } else if (switchtec_is_gen4(dev)) {
1810 sub_cmd_id = MRPC_DIETEMP_GET_GEN4;
1811 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1812 sizeof(sub_cmd_id), &temp, sizeof(temp));
1813 if (ret)
1814 return -100.0;
1815 } else {
1816 sub_cmd_id = MRPC_DIETEMP_GET_GEN5;
1817 uint32_t temps[4];
1818 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1819 sizeof(sub_cmd_id), temps, sizeof(temps));
1820 if (ret)
1821 return -100.0;
1822 temp = (temps[0] + temps[1] + temps[2] + temps[3]) / 4;
1823 }
1824
1825 return le32toh(temp) / 100.;
1826}
1827
1835int switchtec_die_temps(struct switchtec_dev *dev, int nr_sensor,
1836 float *sensor_readings)
1837{
1838 int ret;
1839 uint32_t sub_cmd_id;
1840 uint32_t temp;
1841
1842 if (nr_sensor <= 0 || !sensor_readings)
1843 return 0;
1844
1845 if (switchtec_is_gen3(dev)) {
1846 sub_cmd_id = MRPC_DIETEMP_SET_MEAS;
1847 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1848 sizeof(sub_cmd_id), NULL, 0);
1849 if (ret)
1850 return -100.0;
1851
1852 sub_cmd_id = MRPC_DIETEMP_GET;
1853 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1854 sizeof(sub_cmd_id), &temp, sizeof(temp));
1855 if (ret)
1856 return -100.0;
1857
1858 sensor_readings[0] = le32toh(temp) / 100.;
1859 return 1;
1860 } else if (switchtec_is_gen4(dev)) {
1861 sub_cmd_id = MRPC_DIETEMP_GET_GEN4;
1862 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1863 sizeof(sub_cmd_id), &temp, sizeof(temp));
1864 if (ret)
1865 return -100.0;
1866
1867 sensor_readings[0] = le32toh(temp) / 100.;
1868 return 1;
1869 } else {
1870 sub_cmd_id = MRPC_DIETEMP_GET_GEN5;
1871 uint32_t temps[4];
1872 int i;
1873
1874 ret = switchtec_cmd(dev, MRPC_DIETEMP, &sub_cmd_id,
1875 sizeof(sub_cmd_id), temps, sizeof(temps));
1876 if (ret)
1877 return -100.0;
1878
1879 for (i = 0; i < nr_sensor && i < 4; i++)
1880 sensor_readings[i] = le32toh(temps[i]) / 100.;
1881
1882 return i;
1883 }
1884}
1885
1886int switchtec_bind_info(struct switchtec_dev *dev,
1887 struct switchtec_bind_status_out *status, int phy_port)
1888{
1889 struct switchtec_bind_status_in sub_cmd_id = {
1890 .sub_cmd = MRPC_PORT_INFO,
1891 .phys_port_id = phy_port
1892 };
1893
1894 return switchtec_cmd(dev, MRPC_PORTPARTP2P, &sub_cmd_id,
1895 sizeof(sub_cmd_id), status, sizeof(*status));
1896}
1897
1898int switchtec_bind(struct switchtec_dev *dev, int par_id, int log_port,
1899 int phy_port)
1900{
1901 uint32_t output;
1902
1903 struct switchtec_bind_in sub_cmd_id = {
1904 .sub_cmd = MRPC_PORT_BIND,
1905 .par_id = par_id,
1906 .log_port_id = log_port,
1907 .phys_port_id = phy_port
1908 };
1909
1910 return switchtec_cmd(dev, MRPC_PORTPARTP2P, &sub_cmd_id,
1911 sizeof(sub_cmd_id), &output, sizeof(output));
1912}
1913
1914int switchtec_unbind(struct switchtec_dev *dev, int par_id, int log_port)
1915{
1916 uint32_t output;
1917
1918 struct switchtec_unbind_in sub_cmd_id = {
1919 .sub_cmd = MRPC_PORT_UNBIND,
1920 .par_id = par_id,
1921 .log_port_id = log_port,
1922 .opt = 2
1923 };
1924
1925 return switchtec_cmd(dev, MRPC_PORTPARTP2P, &sub_cmd_id,
1926 sizeof(sub_cmd_id), &output, sizeof(output));
1927}
1928
1929static int __switchtec_calc_lane_id(struct switchtec_status *port, int lane_id)
1930{
1931 int lane;
1932
1933 if (lane_id >= port->neg_lnk_width) {
1934 errno = SWITCHTEC_ERR_INVALID_LANE;
1935 return -1;
1936 }
1937
1938 lane = port->port.phys_id * 2;
1939 if (!port->lane_reversal)
1940 lane += lane_id;
1941 else
1942 lane += port->cfg_lnk_width - 1 - lane_id;
1943
1944 switch (port->port.phys_id) {
1945 /* Trident (Gen4) - Ports 48 to 51 maps to 96 to 99 */
1946 case 48: return 96;
1947 case 49: return 97;
1948 case 50: return 98;
1949 case 51: return 99;
1950 /* Hrapoon (Gen5) - Ports 56 to 59 maps to 96 to 99 */
1951 case 56: return 96;
1952 case 57: return 97;
1953 case 58: return 98;
1954 case 59: return 99;
1955 default: return lane;
1956 }
1957}
1958
1967int switchtec_calc_lane_id(struct switchtec_dev *dev, int phys_port_id,
1968 int lane_id, struct switchtec_status *port)
1969{
1970 struct switchtec_status *status;
1971 int ports, i;
1972 int rc = 0;
1973
1974 ports = switchtec_status(dev, &status);
1975 if (ports < 0)
1976 return ports;
1977
1978 for (i = 0; i < ports; i++)
1979 if (status[i].port.phys_id == phys_port_id)
1980 break;
1981
1982 if (i == ports) {
1983 errno = SWITCHTEC_ERR_INVALID_PORT;
1984 rc = -1;
1985 goto out;
1986 }
1987
1988 if (port)
1989 *port = status[i];
1990
1991 rc = __switchtec_calc_lane_id(&status[i], lane_id);
1992
1993out:
1994 switchtec_status_free(status, ports);
1995 return rc;
1996}
1997
2007int switchtec_calc_port_lane(struct switchtec_dev *dev, int lane_id,
2008 int *phys_port_id, int *port_lane_id,
2009 struct switchtec_status *port)
2010{
2011 struct switchtec_status *status;
2012 int ports, i, p, lane;
2013 int rc = 0;
2014
2015 ports = switchtec_status(dev, &status);
2016 if (ports < 0)
2017 return ports;
2018
2019 if (lane_id >= 96) {
2020 if (dev->gen < SWITCHTEC_GEN5)
2021 p = lane_id - 96 + 48;
2022 else
2023 p = lane_id - 96 + 56;
2024
2025 for (i = 0; i < ports; i++)
2026 if (status[i].port.phys_id == p)
2027 break;
2028 } else {
2029 for (i = 0; i < ports; i++) {
2030 p = status[i].port.phys_id * 2;
2031 if (lane_id >= p && lane_id < p + status[i].cfg_lnk_width)
2032 break;
2033 }
2034 }
2035
2036 if (i == ports) {
2037 errno = SWITCHTEC_ERR_INVALID_PORT;
2038 rc = -1;
2039 goto out;
2040 }
2041
2042 if (port)
2043 *port = status[i];
2044
2045 if (phys_port_id)
2046 *phys_port_id = status[i].port.phys_id;
2047
2048 lane = lane_id - status[i].port.phys_id * 2;
2049 if (port->lane_reversal)
2050 lane = status[i].cfg_lnk_width - 1 - lane;
2051
2052 if (port_lane_id)
2053 *port_lane_id = lane;
2054
2055out:
2056 switchtec_status_free(status, ports);
2057 return rc;
2058}
2059
2071int switchtec_calc_lane_mask(struct switchtec_dev *dev, int phys_port_id,
2072 int lane_id, int num_lanes, int *lane_mask,
2073 struct switchtec_status *port)
2074{
2075 struct switchtec_status *status;
2076 int ports, i, l, lane;
2077 int rc = 0;
2078
2079 ports = switchtec_status(dev, &status);
2080 if (ports < 0)
2081 return ports;
2082
2083 for (i = 0; i < ports; i++)
2084 if (status[i].port.phys_id == phys_port_id)
2085 break;
2086
2087 if (i == ports) {
2088 errno = SWITCHTEC_ERR_INVALID_PORT;
2089 rc = -1;
2090 goto out;
2091 }
2092
2093 if (port)
2094 *port = status[i];
2095
2096 for (l = lane_id; l < lane_id + num_lanes; l++) {
2097 lane = __switchtec_calc_lane_id(&status[i], l);
2098 if (lane < 0) {
2099 rc = -1;
2100 goto out;
2101 }
2102
2103 lane_mask[lane >> 5] |= 1 << (lane & 0x1F);
2104 }
2105
2106out:
2107 switchtec_status_free(status, ports);
2108 return rc;
2109}
2110
2118bool switchtec_stack_bif_port_valid(struct switchtec_dev *dev, int stack_id,
2119 int port_id)
2120{
2121 if (dev->gen == SWITCHTEC_GEN4)
2122 return stack_id * 8 + port_id < 52;
2123
2124 return true;
2125}
2126
2134int switchtec_stack_bif_width(struct switchtec_dev *dev, int stack_id,
2135 int port_bif)
2136{
2137 if (!port_bif)
2138 return 1;
2139
2140 if (port_bif != 1 && port_bif != 2 && port_bif != 4 && port_bif != 8 &&
2141 port_bif != 16) {
2142 errno = -EINVAL;
2143 return -1;
2144 }
2145
2146 if (dev->gen == SWITCHTEC_GEN4 && stack_id == 6)
2147 return port_bif;
2148 else
2149 return (port_bif + 1) / 2;
2150}
2151
2159int switchtec_get_stack_bif(struct switchtec_dev *dev, int stack_id,
2160 int port_bif[SWITCHTEC_PORTS_PER_STACK])
2161{
2162 struct switchtec_stackbif out, in = {
2163 .sub_cmd = MRPC_STACKBIF_GET,
2164 .stack_id = stack_id,
2165 };
2166 int ret, i;
2167
2168 ret = switchtec_cmd(dev, MRPC_STACKBIF, &in, sizeof(in), &out,
2169 sizeof(out));
2170 if (ret)
2171 return ret;
2172
2173 for (i = 0; i < SWITCHTEC_PORTS_PER_STACK; i++) {
2174 if (!switchtec_stack_bif_port_valid(dev, stack_id, i)) {
2175 port_bif[i] = -1;
2176 continue;
2177 }
2178
2179 switch (out.code & 0xF) {
2180 case 0x0: port_bif[i] = 0; break;
2181 case 0x1: port_bif[i] = 2; break;
2182 case 0x2: port_bif[i] = 4; break;
2183 case 0x4: port_bif[i] = 8; break;
2184 case 0x8: port_bif[i] = 16; break;
2185 case 0xf: port_bif[i] = 1; break;
2186 default:
2187 errno = -EPROTO;
2188 return -1;
2189 }
2190 out.code >>= 4;
2191 }
2192
2193 return 0;
2194}
2195
2203int switchtec_set_stack_bif(struct switchtec_dev *dev, int stack_id,
2204 int port_bif[SWITCHTEC_PORTS_PER_STACK])
2205{
2206 struct switchtec_stackbif out, in = {
2207 .sub_cmd = MRPC_STACKBIF_SET,
2208 .stack_id = stack_id,
2209 };
2210 int i;
2211
2212 for (i = 0; i < SWITCHTEC_PORTS_PER_STACK; i++) {
2213 switch (port_bif[i]) {
2214 case 0: in.code |= 0x0 << (i * 4); break;
2215 case 1: in.code |= 0xf << (i * 4); break;
2216 case 2: in.code |= 0x1 << (i * 4); break;
2217 case 4: in.code |= 0x2 << (i * 4); break;
2218 case 8: in.code |= 0x4 << (i * 4); break;
2219 case 16: in.code |= 0x8 << (i * 4); break;
2220 default:
2221 errno = -EINVAL;
2222 return -1;
2223 }
2224 }
2225
2226 return switchtec_cmd(dev, MRPC_STACKBIF, &in, sizeof(in), &out,
2227 sizeof(out));
2228}
2229
struct switchtec_dev * switchtec_open(const char *device)
Open a Switchtec device by string.
Definition switchtec.c:263
void switchtec_list_free(struct switchtec_device_info *devlist)
Free a list of device info structures allocated by switchtec_list()
Definition switchtec.c:241
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.
Definition platform.c:164
void switchtec_perror(const char *str)
Print an error string to stdout.
Definition switchtec.c:743
int mrpc_error_cmd
The MRPC command ID when errno is set.
Definition switchtec.c:608
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()
Definition switchtec.c:581
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.
Definition switchtec.c:396
const char * switchtec_strerror(void)
Return a message coresponding to the last error.
Definition switchtec.c:620
static const struct switchtec_device_id switchtec_device_id_tbl[]
Supported Switchtec device id table.
Definition switchtec.c:89
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.
Definition switchtec.c:406
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.
Definition fw.c:393
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.
Definition switchtec.c:2134
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.
Definition switchtec.c:2071
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.
Definition switchtec.c:1462
static int read_mailbox_log_defs(FILE *log_def_file, struct log_defs *defs)
Read a mailbox log definition file and store the definitions.
Definition switchtec.c:982
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.
Definition switchtec.c:1543
float switchtec_die_temp(struct switchtec_dev *dev)
Get the die temperature of the switchtec device.
Definition switchtec.c:1791
int switchtec_die_temps(struct switchtec_dev *dev, int nr_sensor, float *sensor_readings)
Get the die temperature sensor readings of the switchtec device.
Definition switchtec.c:1835
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.
Definition switchtec.c:2159
static void free_log_defs(struct log_defs *defs)
Free log definition data.
Definition switchtec.c:802
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.
Definition switchtec.c:2118
int switchtec_hard_reset(struct switchtec_dev *dev)
Perform an MRPC hard reset command.
Definition switchtec.c:790
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.
Definition switchtec.c:1658
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.
Definition switchtec.c:1736
static int read_app_log_defs(FILE *log_def_file, struct log_defs *defs)
Read an app log definition file and store the definitions.
Definition switchtec.c:873
static int realloc_log_defs(struct log_defs *defs, int num_modules)
Allocate / reallocate log definition data.
Definition switchtec.c:827
int switchtec_echo(struct switchtec_dev *dev, uint32_t input, uint32_t *output)
Perform an MRPC echo command.
Definition switchtec.c:774
static bool parse_int(char *str, int *val)
Parse an integer from a string.
Definition switchtec.c:854
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.
Definition switchtec.c:2203
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.
Definition switchtec.c:1967
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.
Definition switchtec.c:2007
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.
Definition switchtec.c:1052
Log definitions for all modules.
Definition switchtec.c:72
struct module_log_defs * module_defs
per-module log definitions
Definition switchtec.c:73
int num_alloc
number of modules allocated
Definition switchtec.c:74
Module-specific log definitions.
Definition switchtec.c:63
char * mod_name
module name
Definition switchtec.c:64
int num_entries
number of log entries
Definition switchtec.c:66
char ** entries
log entry array
Definition switchtec.c:65
Switchtec device id to generation/variant mapping.
Definition switchtec.c:80
Represents a Switchtec device in the switchtec_list() function.
Definition switchtec.h:131
Information about log file and log definition file.
Definition switchtec.h:217
Port identification.
Definition switchtec.h:144
unsigned char upstream
1 if this is an upstream port
Definition switchtec.h:148
unsigned char partition
Partition the port is in.
Definition switchtec.h:145
unsigned char stk_id
Port number within the stack.
Definition switchtec.h:149
unsigned char log_id
Logical port number.
Definition switchtec.h:151
unsigned char phys_id
Physical port number.
Definition switchtec.h:150
unsigned char stack
Stack number.
Definition switchtec.h:147
Port status structure.
Definition switchtec.h:160
struct switchtec_port_id port
Port ID.
Definition switchtec.h:161
unsigned char link_up
1 if the link is up
Definition switchtec.h:164
unsigned char lane_reversal
Lane reversal.
Definition switchtec.h:168
unsigned int acs_ctrl
ACS Setting of the Port.
Definition switchtec.h:180
const char * lane_reversal_str
Lane reversal as a string.
Definition switchtec.h:169
unsigned char cfg_lnk_width
Configured link width.
Definition switchtec.h:162
unsigned char link_rate
Link rate/gen.
Definition switchtec.h:165
unsigned char first_act_lane
First active lane.
Definition switchtec.h:170
unsigned char neg_lnk_width
Negotiated link width.
Definition switchtec.h:163
uint16_t ltssm
Link state.
Definition switchtec.h:166
const char * ltssm_str
Link state as a string.
Definition switchtec.h:167
Main Switchtec header.
switchtec_log_parse_type
Log types to parse.
Definition switchtec.h:209
switchtec_rev
Device hardware revision.
Definition switchtec.h:96
switchtec_gen
The PCIe generations.
Definition switchtec.h:86
switchtec_log_def_type
Log definition data types.
Definition switchtec.h:231
switchtec_variant
The variant types of Switchtec device.
Definition switchtec.h:116
switchtec_log_type
Describe the type of logs too dump.
Definition switchtec.h:195
switchtec_boot_phase
Device boot phase.
Definition switchtec.h:106
static int switchtec_is_gen4(struct switchtec_dev *dev)
Return whether a Switchtec device is a Gen 4 device.
Definition switchtec.h:433
static int switchtec_max_supported_ports(struct switchtec_dev *dev)
Return the max number of ports of a Switchtec device.
Definition switchtec.h:449
static int switchtec_is_gen5(struct switchtec_dev *dev)
Return whether a Switchtec device is a Gen 5 device.
Definition switchtec.h:441
static int switchtec_is_pax_all(struct switchtec_dev *dev)
Return whether a Switchtec device is PAX(A).
Definition switchtec.h:550
static int switchtec_is_gen3(struct switchtec_dev *dev)
Return whether a Switchtec device is a Gen 3 device.
Definition switchtec.h:425