35#include <sys/eventhandler.h>
43#define msleep(x) do { \
47 pause("t4hw", (x) * hz / 1000); \
66 int polarity,
int attempts,
int delay,
u32 *valp)
71 if (!!(val & mask) == polarity) {
84 int polarity,
int attempts,
int delay)
122 unsigned int data_reg,
u32 *vals,
123 unsigned int nregs,
unsigned int start_idx)
145 unsigned int data_reg,
const u32 *vals,
146 unsigned int nregs,
unsigned int start_idx)
201 static const char *
const reason[] = {
203 "During Device Preparation",
204 "During Device Configuration",
205 "During Device Initialization",
207 "Insufficient Airflow",
215 CH_ERR(adap,
"firmware reports adapter error: %s (0x%08x)\n",
226 for ( ; nflit; nflit--, mbox_addr += 8)
236 "FW assertion at %.16s:%u, val0 %#x, val1 %#x\n",
251 uint32_t rx_pause_reg, tx_frames_reg;
277 uint32_t port_ctl_reg;
278 uint64_t tx_frames, rx_pause;
291 rx_pause != tx_state[i].rx_pause &&
292 tx_frames == tx_state[i].tx_frames) {
300#define X_CIM_PF_NOACCESS 0xeeeeeeee
329 int size,
void *rpl,
bool sleep_ok,
int timeout)
336 static const int delay[] = {
337 1, 1, 3, 5, 10, 10, 20, 50, 100
341 int i, ms, delay_idx, ret, next_tx_check;
352 if (size <= 0 || (size & 15) || size >
MBOX_LEN)
380 for (i = 0; i < 4; i++) {
414 memset(cmd_rpl, 0,
sizeof(cmd_rpl));
415 memcpy(cmd_rpl, cmd, size);
438 next_tx_check = 1000;
446 for (i = 0; i < timeout; i += ms) {
453 if (i >= next_tx_check) {
455 next_tx_check = i + 1000;
459 ms = delay[delay_idx];
489 memcpy(rpl, cmd_rpl, size);
499 CH_ERR(adap,
"command %#x in mbox %d timed out (0x%08x).\n",
500 *(
const u8 *)cmd, mbox, pcie_fw);
502 CH_DUMP_MBOX(adap, mbox, data_reg,
"current", NULL,
true);
504 adap->
flags &= ~FW_OK;
511 void *rpl,
bool sleep_ok)
520 u32 edc_ecc_err_addr_reg;
521 u32 edc_bist_status_rdata_reg;
524 CH_WARN(adap,
"%s: T4 NOT supported.\n", __func__);
528 CH_WARN(adap,
"%s: idx %d NOT supported.\n", __func__, idx);
536 "edc%d err addr 0x%x: 0x%x.\n",
537 idx, edc_ecc_err_addr_reg,
540 "bist: 0x%x, status %llx %llx %llx %llx %llx %llx %llx %llx %llx.\n",
541 edc_bist_status_rdata_reg,
542 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg),
543 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 8),
544 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 16),
545 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 24),
546 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 32),
547 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 40),
548 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 48),
549 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 56),
550 (
unsigned long long)
t4_read_reg64(adap, edc_bist_status_rdata_reg + 64));
570 u32 mc_bist_cmd_reg, mc_bist_cmd_addr_reg, mc_bist_cmd_len_reg;
571 u32 mc_bist_status_rdata_reg, mc_bist_data_pattern_reg;
591 t4_write_reg(adap, mc_bist_cmd_addr_reg, addr & ~0x3fU);
600#define MC_DATA(i) MC_BIST_STATUS_REG(mc_bist_status_rdata_reg, i)
602 for (i = 15; i >= 0; i--)
625 u32 edc_bist_cmd_reg, edc_bist_cmd_addr_reg, edc_bist_cmd_len_reg;
626 u32 edc_bist_cmd_data_pattern, edc_bist_status_rdata_reg;
641#define EDC_STRIDE_T5 (EDC_T51_BASE_ADDR - EDC_T50_BASE_ADDR)
642#define EDC_REG_T5(reg, idx) (reg + EDC_STRIDE_T5 * idx)
656 t4_write_reg(adap, edc_bist_cmd_addr_reg, addr & ~0x3fU);
665#define EDC_DATA(i) EDC_BIST_STATUS_REG(edc_bist_status_rdata_reg, i)
667 for (i = 15; i >= 0; i--)
693 u32 pos, start, end, offset;
699 if ((addr & 0x3) || (len & 0x3))
707 start = rounddown2(addr, 64);
708 end = roundup2(addr + len, 64);
709 offset = (addr - start)/
sizeof(
__be32);
711 for (pos = start; pos < end; pos += 64, offset = 0) {
727 while (offset < 16 && len > 0) {
728 *buf++ = data[offset++];
749 if (drv_fw_attach != 0) {
753 memset(&ldst_cmd, 0,
sizeof(ldst_cmd));
774 CH_WARN(adap,
"Firmware failed to return "
775 "Configuration Space register %d, err = %d\n",
796 switch (chip_version) {
810 "Unsupported chip version %d\n", chip_version);
826 static const unsigned int t4_reg_ranges[] = {
1285 static const unsigned int t4vf_reg_ranges[] = {
1297 static const unsigned int t5_reg_ranges[] = {
2062 static const unsigned int t5vf_reg_ranges[] = {
2074 static const unsigned int t6_reg_ranges[] = {
2632 static const unsigned int t6vf_reg_ranges[] = {
2644 u32 *buf_end = (
u32 *)(buf + buf_size);
2645 const unsigned int *reg_ranges;
2646 int reg_ranges_size, range;
2647 unsigned int chip_version =
chip_id(adap);
2653 switch (chip_version) {
2656 reg_ranges = t4vf_reg_ranges;
2657 reg_ranges_size =
ARRAY_SIZE(t4vf_reg_ranges);
2659 reg_ranges = t4_reg_ranges;
2666 reg_ranges = t5vf_reg_ranges;
2667 reg_ranges_size =
ARRAY_SIZE(t5vf_reg_ranges);
2669 reg_ranges = t5_reg_ranges;
2676 reg_ranges = t6vf_reg_ranges;
2677 reg_ranges_size =
ARRAY_SIZE(t6vf_reg_ranges);
2679 reg_ranges = t6_reg_ranges;
2686 "Unsupported chip version %d\n", chip_version);
2694 memset(buf, 0, buf_size);
2695 for (range = 0; range < reg_ranges_size; range += 2) {
2696 unsigned int reg = reg_ranges[range];
2697 unsigned int last_reg = reg_ranges[range + 1];
2698 u32 *bufp = (
u32 *)(buf + reg);
2704 while (reg <= last_reg && bufp < buf_end) {
2729#define EEPROM_DELAY 10
2730#define EEPROM_MAX_POLL 5000
2732#define EEPROM_STAT_ADDR 0x7bfc
2733#define VPD_SIZE 0x800
2734#define VPD_BASE 0x400
2735#define VPD_BASE_OLD 0
2737#define VPD_INFO_FLD_HDR_SIZE 3
2738#define CHELSIO_VPD_UNIQUE_ID 0x82
2778 }
while (--max_poll);
2817 CH_ERR(
adapter,
"VPD still busy from previous operation\n");
2874 CH_ERR(
adapter,
"VPD still busy from previous operation\n");
2905 }
while ((stats_reg & 0x1) && --max_poll);
2933 if (phys_addr < 1024)
2934 return phys_addr + (31 << 10);
2935 if (phys_addr < 1024 + fn)
2938 return phys_addr - 1024 - fn;
2966 unsigned int offset, len;
2970 vpdr = (
const void *)(vpd + offset);
2975 vpdr = (
const void *)(vpd + offset);
2976 if (++
tag != vpdr->vpdr_tag)
2987 if (memcmp(vpd + i , kw , 2) == 0){
3008 uint16_t device_id,
u32 *buf)
3011 int ec, sn, pn, na, md;
3013 const u8 *vpd = (
const u8 *)buf;
3032 for (i = 0; i <
VPD_LEN; i += 4) {
3038#define FIND_VPD_KW(var,name) do { \
3039 var = get_vpd_keyword_val(vpd, name, 0); \
3041 CH_ERR(adapter, "missing VPD keyword " name "\n"); \
3047 for (csum = 0; i >= 0; i--)
3052 "corrupted VPD EEPROM, actual csum %u\n", csum);
3070 memcpy(p->
pn, vpd + pn, min(i,
PN_LEN));
3076 if (device_id & 0x80)
3081 snprintf(p->
md,
sizeof(p->
md),
"unknown");
3084 memcpy(p->
md, vpd + md, min(i,
MD_LEN));
3118 int lock,
u32 *valp)
3122 if (!byte_cnt || byte_cnt > 4)
3149 if (!byte_cnt || byte_cnt > 4)
3178 if (--attempts == 0)
3199 unsigned int nwords,
u32 *data,
int byte_oriented)
3212 for ( ; nwords; nwords--, data++) {
3238 unsigned int n,
const u8 *data,
int byte_oriented)
3242 unsigned int i, c, left, val, offset = addr & 0xff;
3253 for (left = n; left; left -= c) {
3255 for (val = 0, i = 0; i < c; ++i)
3256 val = (val << 8) + *data++;
3277 if (memcmp(data - n, (
u8 *)buf + offset, n)) {
3279 "failed to correctly write the flash page at %#x\n",
3300 offsetof(
struct fw_hdr, fw_ver), 1,
3314 sizeof (*hdr) /
sizeof (uint32_t), (uint32_t *)hdr, 1);
3327 offsetof(
struct fw_hdr, fw_ver), 1,
3341 offsetof(
struct fw_hdr, tp_microcode_ver),
3357 struct exprom_header {
3358 unsigned char hdr_arr[16];
3359 unsigned char hdr_ver[4];
3366 ARRAY_SIZE(exprom_header_buf), exprom_header_buf,
3371 hdr = (
struct exprom_header *)exprom_header_buf;
3372 if (hdr->hdr_arr[0] != 0x55 || hdr->hdr_arr[1] != 0xaa)
3413 1, &scfgrev_param, vers);
3448 1, &vpdrev_param, vers);
3467 #define FIRST_RET(__getvinfo) \
3469 int __ret = __getvinfo; \
3470 if (__ret && !ret) \
3501 while (start <= end) {
3507 "erase of flash sector %d failed, error %d\n",
3544 const struct fw_hdr *hdr)
3556 "FW image (%d) is not suitable for this adapter (%d)\n",
3575 const u32 *p = (
const u32 *)fw_data;
3576 const struct fw_hdr *hdr = (
const struct fw_hdr *)fw_data;
3578 unsigned int fw_start_sec;
3579 unsigned int fw_start;
3580 unsigned int fw_size;
3593 CH_ERR(adap,
"FW image has no data\n");
3598 "FW image size not multiple of 512 bytes\n");
3603 "FW image size differs from size in FW header\n");
3606 if (size > fw_size) {
3607 CH_ERR(adap,
"FW image too large, max is %u bytes\n",
3614 for (csum = 0, i = 0; i < size /
sizeof(csum); i++)
3617 if (csum != 0xffffffff) {
3619 "corrupted firmware image, checksum %#x\n", csum);
3653 CH_ERR(adap,
"firmware download failed, error %d\n",
3667 memset(&c, 0,
sizeof(c));
3683 unsigned int *pif_req_wrptr,
3684 unsigned int *pif_rsp_wrptr)
3687 u32 cfg, val, req, rsp;
3697 *pif_req_wrptr = req;
3699 *pif_rsp_wrptr = rsp;
3702 for (j = 0; j < 6; j++) {
3726 for (j = 0; j < 5; j++) {
3741 for (i = 0; i < 8; i++) {
3742 u32 *p = la_buf + i;
3760 uint32_t caps32 = 0;
3762 #define CAP16_TO_CAP32(__cap) \
3764 if (caps16 & FW_PORT_CAP_##__cap) \
3765 caps32 |= FW_PORT_CAP32_##__cap; \
3785 #undef CAP16_TO_CAP32
3800 uint16_t caps16 = 0;
3802 #define CAP32_TO_CAP16(__cap) \
3804 if (caps32 & FW_PORT_CAP32_##__cap) \
3805 caps16 |= FW_PORT_CAP_##__cap; \
3825 #undef CAP32_TO_CAP16
3835 return (unset_means_none ?
FEC_NONE : 0);
3885 unsigned int aneg, fc, fec, speed, rcap;
3943 MPASS(powerof2(fec));
3984 rcap = aneg | speed | fc | fec;
3987 CH_WARN(adap,
"rcap 0x%08x, pcap 0x%08x, removed 0x%x\n", rcap,
3994 memset(&c, 0,
sizeof(c));
4026 memset(&c, 0,
sizeof(c));
4034 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
4048#define NONFATAL_IF_DISABLED 1
4073 u32 enable, fatal, leftover;
4083 CH_ALERT(adap,
"%c %s 0x%x = 0x%08x, E 0x%08x, F 0x%08x\n",
4087 for (details = ii->
details; details && details->
mask != 0; details++) {
4088 u32 msgbits = details->
mask & cause;
4092 CH_ALERT(adap,
" %c [0x%08x] %s\n", alert, msgbits,
4094 leftover &= ~msgbits;
4096 if (leftover != 0 && leftover != cause)
4097 CH_ALERT(adap,
" ? [0x%08x]\n", leftover);
4105 u32 additional_cause,
bool verbose)
4119 if (verbose || cause != 0)
4121 fatal = cause & ii->
fatal;
4124 cause |= additional_cause;
4130 if (!(
action->mask & cause))
4147 static const struct intr_details sysbus_intr_details[] = {
4148 {
F_RNPP,
"RXNP array parity error" },
4149 {
F_RPCP,
"RXPC array parity error" },
4150 {
F_RCIP,
"RXCIF array parity error" },
4151 {
F_RCCP,
"Rx completions control array parity error" },
4152 {
F_RFTP,
"RXFT array parity error" },
4155 static const struct intr_info sysbus_intr_info = {
4156 .
name =
"PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS",
4161 .details = sysbus_intr_details,
4164 static const struct intr_details pcie_port_intr_details[] = {
4165 {
F_TPCP,
"TXPC array parity error" },
4166 {
F_TNPP,
"TXNP array parity error" },
4167 {
F_TFTP,
"TXFT array parity error" },
4168 {
F_TCAP,
"TXCA array parity error" },
4169 {
F_TCIP,
"TXCIF array parity error" },
4170 {
F_RCAP,
"RXCA array parity error" },
4171 {
F_OTDD,
"outbound request TLP discarded" },
4172 {
F_RDPE,
"Rx data parity error" },
4173 {
F_TDUE,
"Tx uncorrectable data error" },
4176 static const struct intr_info pcie_port_intr_info = {
4177 .
name =
"PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS",
4183 .details = pcie_port_intr_details,
4186 static const struct intr_details pcie_intr_details[] = {
4194 {
F_PIOCPLPERR,
"PCIe PIO completion FIFO parity error" },
4195 {
F_PIOREQPERR,
"PCIe PIO request FIFO parity error" },
4197 {
F_CCNTPERR,
"PCIe CMD channel count parity error" },
4198 {
F_CREQPERR,
"PCIe CMD channel request parity error" },
4199 {
F_CRSPPERR,
"PCIe CMD channel response parity error" },
4200 {
F_DCNTPERR,
"PCIe DMA channel count parity error" },
4201 {
F_DREQPERR,
"PCIe DMA channel request parity error" },
4202 {
F_DRSPPERR,
"PCIe DMA channel response parity error" },
4203 {
F_HCNTPERR,
"PCIe HMA channel count parity error" },
4204 {
F_HREQPERR,
"PCIe HMA channel request parity error" },
4205 {
F_HRSPPERR,
"PCIe HMA channel response parity error" },
4206 {
F_CFGSNPPERR,
"PCIe config snoop FIFO parity error" },
4211 {
F_RXCPLPERR,
"PCIe Rx completion parity error" },
4212 {
F_RXWRPERR,
"PCIe Rx write parity error" },
4213 {
F_RPLPERR,
"PCIe replay buffer parity error" },
4219 static const struct intr_details t5_pcie_intr_details[] = {
4224 {
F_IPSOTPERR,
"PCIe IP SOT buffer SRAM parity error" },
4233 {
F_HRSPPERR,
"HMA channel response data SRAM parity error" },
4234 {
F_HREQRDPERR,
"HMA channel read request SRAM parity error" },
4235 {
F_HREQWRPERR,
"HMA channel write request SRAM parity error" },
4236 {
F_DRSPPERR,
"DMA channel response data SRAM parity error" },
4237 {
F_DREQRDPERR,
"DMA channel write request SRAM parity error" },
4238 {
F_CRSPPERR,
"CMD channel response data SRAM parity error" },
4239 {
F_CREQRDPERR,
"CMD channel read request SRAM parity error" },
4240 {
F_MSTTAGQPERR,
"PCIe master tag queue SRAM parity error" },
4241 {
F_TGTTAGQPERR,
"PCIe target tag queue FIFO parity error" },
4250 {
F_MSTGRPPERR,
"Master response read queue SRAM parity error" },
4254 .
name =
"PCIE_INT_CAUSE",
4257 .fatal = 0xffffffff,
4268 pcie_intr_info.
details = pcie_intr_details;
4270 pcie_intr_info.
details = t5_pcie_intr_details;
4283 { 0x3fffffff,
"TP parity error" },
4287 static const struct intr_info tp_intr_info = {
4288 .
name =
"TP_INT_CAUSE",
4291 .fatal = 0x7fffffff,
4293 .details = tp_intr_details,
4305 static const struct intr_info sge_int1_info = {
4306 .
name =
"SGE_INT_CAUSE1",
4309 .fatal = 0xffffffff,
4314 static const struct intr_info sge_int2_info = {
4315 .
name =
"SGE_INT_CAUSE2",
4318 .fatal = 0xffffffff,
4323 static const struct intr_details sge_int3_details[] = {
4325 "DBP pointer delivery for invalid context or QID" },
4327 "Invalid QID or header request by IDMA" },
4334 "SGE GTS with timer 0-5 for IQID > 1023" },
4336 "SGE received CPL exceeding IQE size" },
4342 "SGE IQID > 1023 received CPL for FL" },
4347 "Ingress context manager priority user error" },
4349 "Egress context manager priority user error" },
4355 { 0x0000000f,
"SGE context access for invalid queue" },
4358 static const struct intr_details t6_sge_int3_details[] = {
4360 "DBP pointer delivery for invalid context or QID" },
4362 "Invalid QID or header request by IDMA" },
4369 "SGE GTS with timer 0-5 for IQID > 1023" },
4371 "SGE received CPL exceeding IQE size" },
4377 "SGE IQID > 1023 received CPL for FL" },
4382 "Ingress context manager priority user error" },
4384 "Egress context manager priority user error" },
4387 "SGE WRE packet less than advertized length" },
4391 { 0x0000000f,
"SGE context access for invalid queue" },
4395 .
name =
"SGE_INT_CAUSE3",
4403 static const struct intr_info sge_int4_info = {
4404 .
name =
"SGE_INT_CAUSE4",
4412 static const struct intr_info sge_int5_info = {
4413 .
name =
"SGE_INT_CAUSE5",
4416 .fatal = 0xffffffff,
4421 static const struct intr_info sge_int6_info = {
4422 .
name =
"SGE_INT_CAUSE6",
4435 sge_int3_info.
details = sge_int3_details;
4437 sge_int3_info.
details = t6_sge_int3_details;
4454 CH_ERR(adap,
"SGE UNCAPTURED_ERROR set (clearing)\n");
4467 static const struct intr_details cim_host_intr_details[] = {
4474 "PL2CIM master response data parity error" },
4492 "CIM IBQ PCIe/SGE_HI parity error" },
4505 static const struct intr_info cim_host_intr_info = {
4506 .
name =
"CIM_HOST_INT_CAUSE",
4509 .fatal = 0x007fffe6,
4511 .details = cim_host_intr_details,
4514 static const struct intr_details cim_host_upacc_intr_details[] = {
4523 "CIM single write to PL space with illegal BEs" },
4525 "CIM single read from PL space with illegal BEs" },
4529 "CIM single write to CTL space with illegal BEs" },
4531 "CIM single read from CTL space with illegal BEs" },
4535 "CIM single write to EEPROM space with illegal BEs" },
4537 "CIM single read from EEPROM space with illegal BEs" },
4542 "CIM single read from flash space with illegal BEs" },
4547 "CIM single read from boot space with illegal BEs" },
4556 static const struct intr_info cim_host_upacc_intr_info = {
4557 .
name =
"CIM_HOST_UPACC_INT_CAUSE",
4560 .fatal = 0x3fffeeff,
4562 .details = cim_host_upacc_intr_details,
4565 static const struct intr_info cim_pf_host_intr_info = {
4566 .
name =
"CIM_PF_HOST_INT_CAUSE",
4606 static const struct intr_details ulprx_intr_details[] = {
4614 { 0x007fffff,
"ULPRX parity error" },
4617 static const struct intr_info ulprx_intr_info = {
4618 .
name =
"ULP_RX_INT_CAUSE",
4621 .fatal = 0x07ffffff,
4623 .details = ulprx_intr_details,
4626 static const struct intr_info ulprx_intr2_info = {
4627 .
name =
"ULP_RX_INT_CAUSE_2",
4648 static const struct intr_details ulptx_intr_details[] = {
4653 { 0x0fffffff,
"ULPTX parity error" },
4656 static const struct intr_info ulptx_intr_info = {
4657 .
name =
"ULP_TX_INT_CAUSE",
4660 .fatal = 0x0fffffff,
4662 .details = ulptx_intr_details,
4665 static const struct intr_info ulptx_intr2_info = {
4666 .
name =
"ULP_TX_INT_CAUSE_2",
4690 CH_ALERT(adap,
" - PM_TX_DBG_STAT%u (0x%x) = 0x%08x\n", i,
4702 static const struct intr_action pmtx_intr_actions[] = {
4706 static const struct intr_details pmtx_intr_details[] = {
4711 { 0x0f000000,
"PMTX icspi FIFO2X Rx framing error" },
4712 { 0x00f00000,
"PMTX icspi FIFO Rx framing error" },
4713 { 0x000f0000,
"PMTX icspi FIFO Tx framing error" },
4714 { 0x0000f000,
"PMTX oespi FIFO Rx framing error" },
4715 { 0x00000f00,
"PMTX oespi FIFO Tx framing error" },
4716 { 0x000000f0,
"PMTX oespi FIFO2X Tx framing error" },
4723 static const struct intr_info pmtx_intr_info = {
4724 .
name =
"PM_TX_INT_CAUSE",
4727 .fatal = 0xffffffff,
4729 .details = pmtx_intr_details,
4730 .actions = pmtx_intr_actions,
4741 static const struct intr_details pmrx_intr_details[] = {
4743 { 0x18000000,
"PMRX ospi overflow" },
4751 { 0x003c0000,
"PMRX iespi FIFO2X Rx framing error" },
4752 { 0x0003c000,
"PMRX iespi Rx framing error" },
4753 { 0x00003c00,
"PMRX iespi Tx framing error" },
4754 { 0x00000300,
"PMRX ocspi Rx framing error" },
4755 { 0x000000c0,
"PMRX ocspi Tx framing error" },
4756 { 0x00000030,
"PMRX ocspi FIFO2X Tx framing error" },
4763 static const struct intr_info pmrx_intr_info = {
4764 .
name =
"PM_RX_INT_CAUSE",
4767 .fatal = 0x1fffffff,
4769 .details = pmrx_intr_details,
4781 static const struct intr_details cplsw_intr_details[] = {
4795 static const struct intr_info cplsw_intr_info = {
4796 .
name =
"CPL_INTR_CAUSE",
4801 .details = cplsw_intr_details,
4808#define T4_LE_FATAL_MASK (F_PARITYERR | F_UNKNOWNCMD | F_REQQPARERR)
4809#define T5_LE_FATAL_MASK (T4_LE_FATAL_MASK | F_VFPARERR)
4810#define T6_LE_PERRCRC_MASK (F_PIPELINEERR | F_CLIPTCAMACCFAIL | \
4811 F_SRVSRAMACCFAIL | F_CLCAMCRCPARERR | F_CLCAMINTPERR | F_SSRAMINTPERR | \
4812 F_SRVSRAMPERR | F_VFSRAMPERR | F_TCAMINTPERR | F_TCAMCRCERR | \
4813 F_HASHTBLMEMACCERR | F_MAIFWRINTPERR | F_HASHTBLMEMCRCERR)
4814#define T6_LE_FATAL_MASK (T6_LE_PERRCRC_MASK | F_T6_UNKNOWNCMD | \
4815 F_TCAMACCFAIL | F_HASHTBLACCFAIL | F_CMDTIDERR | F_CMDPRSRINTERR | \
4816 F_TOTCNTERR | F_CLCAMFIFOERR | F_CLIPSUBERR)
4829 {
F_LIP0,
"LE 0 LIP error" },
4832 static const struct intr_details t6_le_intr_details[] = {
4833 {
F_CLIPSUBERR,
"LE CLIP CAM reverse substitution error" },
4848 {
F_T6_LIP0,
"LE found 0 LIP during CLIP substitution" },
4854 .
name =
"LE_DB_INT_CAUSE",
4864 le_intr_info.
details = le_intr_details;
4867 le_intr_info.
details = t6_le_intr_details;
4879 static const struct intr_details mps_rx_perr_intr_details[] = {
4880 { 0xffffffff,
"MPS Rx parity error" },
4883 static const struct intr_info mps_rx_perr_intr_info = {
4884 .
name =
"MPS_RX_PERR_INT_CAUSE",
4887 .fatal = 0xffffffff,
4889 .details = mps_rx_perr_intr_details,
4892 static const struct intr_details mps_tx_intr_details[] = {
4893 {
F_PORTERR,
"MPS Tx destination port is disabled" },
4894 {
F_FRMERR,
"MPS Tx framing error" },
4899 {
F_NCSIFIFO,
"MPS Tx NC-SI FIFO parity error" },
4903 static const struct intr_info mps_tx_intr_info = {
4904 .
name =
"MPS_TX_INT_CAUSE",
4909 .details = mps_tx_intr_details,
4912 static const struct intr_details mps_trc_intr_details[] = {
4918 static const struct intr_info mps_trc_intr_info = {
4919 .
name =
"MPS_TRC_INT_CAUSE",
4924 .details = mps_trc_intr_details,
4927 static const struct intr_details mps_stat_sram_intr_details[] = {
4928 { 0xffffffff,
"MPS statistics SRAM parity error" },
4931 static const struct intr_info mps_stat_sram_intr_info = {
4932 .
name =
"MPS_STAT_PERR_INT_CAUSE_SRAM",
4935 .fatal = 0x1fffffff,
4937 .details = mps_stat_sram_intr_details,
4940 static const struct intr_details mps_stat_tx_intr_details[] = {
4941 { 0xffffff,
"MPS statistics Tx FIFO parity error" },
4944 static const struct intr_info mps_stat_tx_intr_info = {
4945 .
name =
"MPS_STAT_PERR_INT_CAUSE_TX_FIFO",
4950 .details = mps_stat_tx_intr_details,
4953 static const struct intr_details mps_stat_rx_intr_details[] = {
4954 { 0xffffff,
"MPS statistics Rx FIFO parity error" },
4957 static const struct intr_info mps_stat_rx_intr_info = {
4958 .
name =
"MPS_STAT_PERR_INT_CAUSE_RX_FIFO",
4963 .details = mps_stat_rx_intr_details,
4966 static const struct intr_details mps_cls_intr_details[] = {
4967 {
F_HASHSRAM,
"MPS hash SRAM parity error" },
4972 static const struct intr_info mps_cls_intr_info = {
4973 .
name =
"MPS_CLS_INT_CAUSE",
4978 .details = mps_cls_intr_details,
4981 static const struct intr_details mps_stat_sram1_intr_details[] = {
4982 { 0xff,
"MPS statistics SRAM1 parity error" },
4985 static const struct intr_info mps_stat_sram1_intr_info = {
4986 .
name =
"MPS_STAT_PERR_INT_CAUSE_SRAM1",
4991 .details = mps_stat_sram1_intr_details,
5022 static const char name[4][5] = {
"EDC0",
"EDC1",
"MC0",
"MC1" };
5023 unsigned int count_reg, v;
5024 static const struct intr_details mem_intr_details[] = {
5032 .details = mem_intr_details,
5040 ii.
name =
"EDC0_INT_CAUSE";
5046 ii.
name =
"EDC1_INT_CAUSE";
5052 ii.
name =
"MC0_INT_CAUSE";
5064 ii.
name =
"MC1_INT_CAUSE";
5077 "%s: %u uncorrectable ECC data error(s)\n",
5084 "%s: %u correctable ECC data error(s)\n",
5099 "MA address wrap-around error by client %u to address %#x\n",
5112 static const struct intr_action ma_intr_actions[] = {
5116 static const struct intr_info ma_intr_info = {
5117 .
name =
"MA_INT_CAUSE",
5123 .actions = ma_intr_actions,
5125 static const struct intr_info ma_perr_status1 = {
5126 .
name =
"MA_PARITY_ERROR_STATUS1",
5129 .fatal = 0xffffffff,
5134 static const struct intr_info ma_perr_status2 = {
5135 .
name =
"MA_PARITY_ERROR_STATUS2",
5138 .fatal = 0xffffffff,
5159 static const struct intr_details smb_intr_details[] = {
5165 static const struct intr_info smb_intr_info = {
5166 .
name =
"SMB_INT_CAUSE",
5171 .details = smb_intr_details,
5183 static const struct intr_details ncsi_intr_details[] = {
5190 static const struct intr_info ncsi_intr_info = {
5191 .
name =
"NCSI_INT_CAUSE",
5197 .details = ncsi_intr_details,
5209 static const struct intr_details mac_intr_details[] = {
5219 snprintf(
name,
sizeof(
name),
"XGMAC_PORT%u_INT_CAUSE",
port);
5225 ii.
details = mac_intr_details;
5228 snprintf(
name,
sizeof(
name),
"MAC_PORT%u_INT_CAUSE",
port);
5234 ii.
details = mac_intr_details;
5240 snprintf(
name,
sizeof(
name),
"MAC_PORT%u_PERR_INT_CAUSE",
port);
5252 snprintf(
name,
sizeof(
name),
"MAC_PORT%u_PERR_INT_CAUSE_100G",
port);
5268 static const struct intr_details plpl_intr_details[] = {
5273 static const struct intr_info plpl_intr_info = {
5274 .
name =
"PL_PL_INT_CAUSE",
5279 .details = plpl_intr_details,
5330 static const struct intr_info pl_perr_cause = {
5331 .
name =
"PL_PERR_CAUSE",
5334 .fatal = 0xffffffff,
5336 .details = pl_intr_details,
5339 static const struct intr_action pl_intr_action[] = {
5365 static const struct intr_info pl_intr_info = {
5366 .
name =
"PL_INT_CAUSE",
5371 .details = pl_intr_details,
5372 .actions = pl_intr_action,
5377 if (verbose || perr != 0) {
5388#define PF_INTR_MASK (F_PFSW | F_PFCIM)
5495 for (i = 0; i < nchan; i++) {
5509 for (i = 0; i < nchan; i++) {
5540 u32 a = ((
u32)addr[0] << 16) | ((
u32)addr[1] << 8) | addr[2];
5541 u32 b = ((
u32)addr[3] << 16) | ((
u32)addr[4] << 8) | addr[5];
5566 int start,
int n,
const u16 *rspq,
unsigned int nrspq)
5569 const u16 *rsp = rspq;
5570 const u16 *rsp_end = rspq + nrspq;
5573 memset(&cmd, 0,
sizeof(cmd));
5586 int nq = min(n, 32);
5617 int nqbuf = min(3, nq);
5620 qbuf[0] = qbuf[1] = qbuf[2] = 0;
5621 while (nqbuf && nq_packed < 32) {
5658 memset(&c, 0,
sizeof(c));
5687 unsigned int flags,
unsigned int defq,
unsigned int skeyidx,
5692 memset(&c, 0,
sizeof(c));
5727 for (i = 0; i < rss_nentries / 2; ++i) {
5750 unsigned int nregs,
unsigned int start_index,
5751 unsigned int rw,
bool sleep_ok)
5757 for (i = 0; i < nregs; i++) {
5758 memset(&c, 0,
sizeof(c));
5794 u32 *buff,
u32 nregs,
u32 start_index,
int rw,
5811 goto indirect_access;
5841 u32 start_index,
bool sleep_ok)
5844 start_index, 1, sleep_ok);
5858 u32 start_index,
bool sleep_ok)
5861 __DECONST(
u32 *, buff), nregs, start_index, 0, sleep_ok);
5875 u32 start_index,
bool sleep_ok)
5878 nregs, start_index, 1, sleep_ok);
5895 start_index, 1, sleep_ok);
5925 u8 rss_key_addr_cnt = 16;
5935 rss_key_addr_cnt = 32;
5939 if (idx >= 0 && idx < rss_key_addr_cnt) {
5940 if (rss_key_addr_cnt > 16)
5961 u32 *valp,
bool sleep_ok)
5977 u32 val,
bool sleep_ok)
5995 u32 *vfl,
u32 *vfh,
bool sleep_ok)
5997 u32 vrt, mask, data;
6033 u32 vfl,
u32 vfh,
bool sleep_ok)
6035 u32 vrt, mask, data;
6131#define STAT_IDX(x) ((A_TP_MIB_TCP_##x) - A_TP_MIB_TCP_OUT_RST)
6132#define STAT(x) val[STAT_IDX(x)]
6133#define STAT64(x) (((u64)STAT(x##_HI) << 32) | STAT(x##_LO))
6306 st->
octets = ((
u64)val[2] << 32) | val[3];
6337 for (i = 0; i <
NMTUS; ++i) {
6357 unsigned int mtu, w;
6359 for (mtu = 0; mtu <
NMTUS; ++mtu)
6378 unsigned int mask,
unsigned int val)
6394 a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = a[8] = 1;
6419 b[0] = b[1] = b[2] = b[3] = b[4] = b[5] = b[6] = b[7] = b[8] = 0;
6422 b[13] = b[14] = b[15] = b[16] = 3;
6423 b[17] = b[18] = b[19] = b[20] = b[21] = 4;
6424 b[22] = b[23] = b[24] = b[25] = b[26] = b[27] = 5;
6430#define CC_MIN_INCR 2U
6445 const unsigned short *alpha,
const unsigned short *beta)
6447 static const unsigned int avg_pkts[
NCCTRL_WIN] = {
6448 2, 6, 10, 14, 20, 28, 40, 56, 80, 112, 160, 224, 320, 448, 640,
6449 896, 1281, 1792, 2560, 3584, 5120, 7168, 10240, 14336, 20480,
6450 28672, 40960, 57344, 81920, 114688, 163840, 229376
6455 for (i = 0; i <
NMTUS; ++i) {
6456 unsigned int mtu = mtus[i];
6457 unsigned int log2 = fls(mtu);
6459 if (!(mtu & ((1 << log2) >> 2)))
6467 inc = max(((mtu - 40) * alpha[w]) / avg_pkts[w],
6471 (w << 16) | (beta[w] << 13) | inc);
6486 unsigned int start,
unsigned int n)
6495 for (i = 0; i < n; i++, pace_vals++) {
6496 vals[i] = (1000 * *pace_vals + tick_ns / 2) / tick_ns;
6497 if (vals[i] > 0x7ff)
6499 if (*pace_vals && vals[i] == 0)
6502 for (i = 0; i < n; i++, start++)
6517 unsigned int v, tps, cpt, bpt, delta, mindelta = ~0;
6519 unsigned int selected_cpt = 0, selected_bpt = 0;
6523 for (cpt = 1; cpt <= 255; cpt++) {
6525 bpt = (kbps + tps / 2) / tps;
6526 if (bpt > 0 && bpt <= 255) {
6528 delta = v >= kbps ? v - kbps : kbps - v;
6529 if (delta < mindelta) {
6534 }
else if (selected_cpt)
6544 v = (v & 0xffff) | (selected_cpt << 16) | (selected_bpt << 24);
6546 v = (v & 0xffff0000) | selected_cpt | (selected_bpt << 8);
6565 ipg = (ipg + 5000) / 10000;
6594 return v * 62 + v / 2;
6639 int idx,
int enable)
6641 int i, ofst = idx * 4;
6642 u32 data_reg, mask_reg, cfg;
6645 if (idx < 0 || idx >=
NTRACE)
6648 if (tp == NULL || !enable) {
6669 if (tp->
snap_len > ((10 * 1024 / 4) - (2 * 8)))
6693 for (i = 0; i <
TRACE_LEN / 4; i++, data_reg += 4, mask_reg += 4) {
6722 int i, ofst = idx * 4;
6723 u32 data_reg, mask_reg;
6729 *enabled = !!(ctla &
F_TFEN);
6746 for (i = 0; i <
TRACE_LEN / 4; i++, data_reg += 4, mask_reg += 4) {
6747 tp->
mask[i] = ~t4_read_reg(adap, mask_reg);
6774 cycles[i] = (((
u64)data[0] << 32) | data[1]);
6801 cycles[i] = (((
u64)data[0] << 32) | data[1]);
6824 return idx == 0 ? 0xf : 0;
6826 return idx < 2 ? (3 << (2 * idx)) : 0;
6839 return idx == 0 ? all_chan : 0;
6841 return idx < 2 ? (3 << (2 * idx)) : 0;
6857 return (val >> (8 * idx)) & 0xff;
6868 static const char *
const port_type_description[] = {
6893 if (port_type <
ARRAY_SIZE(port_type_description))
6894 return port_type_description[port_type];
6914 for (i = 0, s = (
u64 *)stats, o = (
u64 *)offset ;
6934#define GET_STAT(name) \
6935 t4_read_reg64(adap, \
6936 (is_t4(adap) ? PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_##name##_L) : \
6937 T5_PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_##name##_L)))
6938#define GET_STAT_COM(name) t4_read_reg64(adap, A_MPS_STAT_##name##_L)
7036#define GET_STAT(name) \
7037 t4_read_reg64(adap, \
7039 PORT_REG(idx, A_MPS_PORT_STAT_LB_PORT_##name##_L) : \
7040 T5_PORT_REG(idx, A_MPS_PORT_STAT_LB_PORT_##name##_L)))
7041#define GET_STAT_COM(name) t4_read_reg64(adap, A_MPS_STAT_##name##_L)
7059 if (idx < adap->params.nports) {
7087 u32 mag_id_reg_l, mag_id_reg_h, port_cfg_reg;
7101 (addr[2] << 24) | (addr[3] << 16) |
7102 (addr[4] << 8) | addr[5]);
7104 (addr[0] << 8) | addr[1]);
7126 u64 mask0,
u64 mask1,
unsigned int crc,
bool enable)
7143#define EPIO_REG(name) \
7144 (is_t4(adap) ? PORT_REG(port, A_XGMAC_PORT_EPIO_##name) : \
7145 T5_PORT_REG(port, A_MAC_PORT_EPIO_##name))
7151 for (i = 0; i < NWOL_PAT; i++, map >>= 1) {
7185 memset(wr, 0,
sizeof(*wr));
7196#define INIT_CMD(var, cmd, rd_wr) do { \
7197 (var).op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_##cmd##_CMD) | \
7198 F_FW_CMD_REQUEST | \
7199 F_FW_CMD_##rd_wr); \
7200 (var).retval_len16 = cpu_to_be32(FW_LEN16(var)); \
7209 memset(&c, 0,
sizeof(c));
7219 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
7234 unsigned int mmd,
unsigned int reg,
unsigned int *valp)
7240 memset(&c, 0,
sizeof(c));
7250 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
7268 unsigned int mmd,
unsigned int reg,
unsigned int val)
7273 memset(&c, 0,
sizeof(c));
7284 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
7295 static const char *
const t4_decode[] = {
7297 "IDMA_PUSH_MORE_CPL_FIFO",
7298 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
7300 "IDMA_PHYSADDR_SEND_PCIEHDR",
7301 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
7302 "IDMA_PHYSADDR_SEND_PAYLOAD",
7303 "IDMA_SEND_FIFO_TO_IMSG",
7304 "IDMA_FL_REQ_DATA_FL_PREP",
7305 "IDMA_FL_REQ_DATA_FL",
7307 "IDMA_FL_H_REQ_HEADER_FL",
7308 "IDMA_FL_H_SEND_PCIEHDR",
7309 "IDMA_FL_H_PUSH_CPL_FIFO",
7310 "IDMA_FL_H_SEND_CPL",
7311 "IDMA_FL_H_SEND_IP_HDR_FIRST",
7312 "IDMA_FL_H_SEND_IP_HDR",
7313 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
7314 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
7315 "IDMA_FL_H_SEND_IP_HDR_PADDING",
7316 "IDMA_FL_D_SEND_PCIEHDR",
7317 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
7318 "IDMA_FL_D_REQ_NEXT_DATA_FL",
7319 "IDMA_FL_SEND_PCIEHDR",
7320 "IDMA_FL_PUSH_CPL_FIFO",
7322 "IDMA_FL_SEND_PAYLOAD_FIRST",
7323 "IDMA_FL_SEND_PAYLOAD",
7324 "IDMA_FL_REQ_NEXT_DATA_FL",
7325 "IDMA_FL_SEND_NEXT_PCIEHDR",
7326 "IDMA_FL_SEND_PADDING",
7327 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
7328 "IDMA_FL_SEND_FIFO_TO_IMSG",
7329 "IDMA_FL_REQ_DATAFL_DONE",
7330 "IDMA_FL_REQ_HEADERFL_DONE",
7332 static const char *
const t5_decode[] = {
7335 "IDMA_PUSH_MORE_CPL_FIFO",
7336 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
7337 "IDMA_SGEFLRFLUSH_SEND_PCIEHDR",
7338 "IDMA_PHYSADDR_SEND_PCIEHDR",
7339 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
7340 "IDMA_PHYSADDR_SEND_PAYLOAD",
7341 "IDMA_SEND_FIFO_TO_IMSG",
7342 "IDMA_FL_REQ_DATA_FL",
7344 "IDMA_FL_DROP_SEND_INC",
7345 "IDMA_FL_H_REQ_HEADER_FL",
7346 "IDMA_FL_H_SEND_PCIEHDR",
7347 "IDMA_FL_H_PUSH_CPL_FIFO",
7348 "IDMA_FL_H_SEND_CPL",
7349 "IDMA_FL_H_SEND_IP_HDR_FIRST",
7350 "IDMA_FL_H_SEND_IP_HDR",
7351 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
7352 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
7353 "IDMA_FL_H_SEND_IP_HDR_PADDING",
7354 "IDMA_FL_D_SEND_PCIEHDR",
7355 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
7356 "IDMA_FL_D_REQ_NEXT_DATA_FL",
7357 "IDMA_FL_SEND_PCIEHDR",
7358 "IDMA_FL_PUSH_CPL_FIFO",
7360 "IDMA_FL_SEND_PAYLOAD_FIRST",
7361 "IDMA_FL_SEND_PAYLOAD",
7362 "IDMA_FL_REQ_NEXT_DATA_FL",
7363 "IDMA_FL_SEND_NEXT_PCIEHDR",
7364 "IDMA_FL_SEND_PADDING",
7365 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
7367 static const char *
const t6_decode[] = {
7369 "IDMA_PUSH_MORE_CPL_FIFO",
7370 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
7371 "IDMA_SGEFLRFLUSH_SEND_PCIEHDR",
7372 "IDMA_PHYSADDR_SEND_PCIEHDR",
7373 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
7374 "IDMA_PHYSADDR_SEND_PAYLOAD",
7375 "IDMA_FL_REQ_DATA_FL",
7377 "IDMA_FL_DROP_SEND_INC",
7378 "IDMA_FL_H_REQ_HEADER_FL",
7379 "IDMA_FL_H_SEND_PCIEHDR",
7380 "IDMA_FL_H_PUSH_CPL_FIFO",
7381 "IDMA_FL_H_SEND_CPL",
7382 "IDMA_FL_H_SEND_IP_HDR_FIRST",
7383 "IDMA_FL_H_SEND_IP_HDR",
7384 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
7385 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
7386 "IDMA_FL_H_SEND_IP_HDR_PADDING",
7387 "IDMA_FL_D_SEND_PCIEHDR",
7388 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
7389 "IDMA_FL_D_REQ_NEXT_DATA_FL",
7390 "IDMA_FL_SEND_PCIEHDR",
7391 "IDMA_FL_PUSH_CPL_FIFO",
7393 "IDMA_FL_SEND_PAYLOAD_FIRST",
7394 "IDMA_FL_SEND_PAYLOAD",
7395 "IDMA_FL_REQ_NEXT_DATA_FL",
7396 "IDMA_FL_SEND_NEXT_PCIEHDR",
7397 "IDMA_FL_SEND_PADDING",
7398 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
7400 static const u32 sge_regs[] = {
7405 const char *
const *sge_idma_decode;
7406 int sge_idma_decode_nstates;
7413 switch (chip_version) {
7415 sge_idma_decode = (
const char *
const *)t4_decode;
7416 sge_idma_decode_nstates =
ARRAY_SIZE(t4_decode);
7420 sge_idma_decode = (
const char *
const *)t5_decode;
7421 sge_idma_decode_nstates =
ARRAY_SIZE(t5_decode);
7425 sge_idma_decode = (
const char *
const *)t6_decode;
7426 sge_idma_decode_nstates =
ARRAY_SIZE(t6_decode);
7430 CH_ERR(
adapter,
"Unsupported chip version %d\n", chip_version);
7434 if (state < sge_idma_decode_nstates)
7458 memset(&c, 0,
sizeof(c));
7468 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
7489 unsigned int master_mbox;
7493 memset(&c, 0,
sizeof(c));
7511 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
7513 if ((ret == -EBUSY || ret == -ETIMEDOUT) && retries-- > 0)
7541 master_mbox != mbox) {
7611 memset(&c, 0,
sizeof(c));
7613 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
7628 memset(&c, 0,
sizeof(c));
7631 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
7661 memset(&c, 0,
sizeof(c));
7665 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
7681 if (ret == 0 || force) {
7739 const u8 *fw_data,
unsigned int size,
int force)
7742 unsigned int bootstrap =
7751 if (ret < 0 && !force)
7756 if (ret < 0 || bootstrap)
7774 memset(&c, 0,
sizeof(c));
7776 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
7794 unsigned int vf,
unsigned int nparams,
const u32 *params,
7804 memset(&c, 0,
sizeof(c));
7811 for (i = 0; i < nparams; i++) {
7818 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
7820 for (i = 0, p = &c.
param[0].
val; i < nparams; i++, p += 2)
7826 unsigned int vf,
unsigned int nparams,
const u32 *params,
7847 unsigned int pf,
unsigned int vf,
7848 unsigned int nparams,
const u32 *params,
7849 const u32 *val,
int timeout)
7857 memset(&c, 0,
sizeof(c));
7886 unsigned int vf,
unsigned int nparams,
const u32 *params,
7915 unsigned int vf,
unsigned int txq,
unsigned int txq_eth_ctrl,
7916 unsigned int rxqi,
unsigned int rxq,
unsigned int tc,
7917 unsigned int vi,
unsigned int cmask,
unsigned int pmask,
7918 unsigned int nexact,
unsigned int rcaps,
unsigned int wxcaps)
7922 memset(&c, 0,
sizeof(c));
7938 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
7962 unsigned int port,
unsigned int pf,
unsigned int vf,
7963 unsigned int nmac,
u8 *mac,
u16 *rss_size,
7964 uint8_t *vfvld, uint16_t *vin,
7965 unsigned int portfunc,
unsigned int idstype)
7970 memset(&c, 0,
sizeof(c));
7982 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
8032 unsigned int pf,
unsigned int vf,
unsigned int nmac,
u8 *
mac,
8033 u16 *rss_size, uint8_t *vfvld, uint16_t *vin)
8050 unsigned int vf,
unsigned int viid)
8054 memset(&c, 0,
sizeof(c));
8063 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
8081 int mtu,
int promisc,
int all_multi,
int bcast,
int vlanex,
8098 memset(&c, 0,
sizeof(c));
8129 const u8 *addr,
const u8 *mask,
unsigned int vni,
8130 unsigned int vni_mask,
u8 dip_hit,
u8 lookup_type,
8138 memset(&c, 0,
sizeof(c));
8147 memcpy(p->macaddr, addr,
sizeof(p->macaddr));
8148 memcpy(p->macaddr_mask, mask,
sizeof(p->macaddr_mask));
8177 const u8 *addr,
const u8 *mask,
unsigned int idx,
8178 u8 lookup_type,
u8 port_id,
bool sleep_ok)
8182 struct fw_vi_mac_raw *p = &c.
u.
raw;
8185 memset(&c, 0,
sizeof(c));
8204 memcpy((
u8 *)&p->data1[0] + 2, addr, ETHER_ADDR_LEN);
8205 memcpy((
u8 *)&p->data1m[0] + 2, mask, ETHER_ADDR_LEN);
8240 unsigned int viid,
bool free,
unsigned int naddr,
8241 const u8 **addr,
u16 *idx,
u64 *hash,
bool sleep_ok)
8243 int offset, ret = 0;
8245 unsigned int nfilters = 0;
8247 unsigned int rem = naddr;
8249 if (naddr > max_naddr)
8252 for (offset = 0; offset < naddr ; ) {
8258 struct fw_vi_mac_exact *p;
8261 memset(&c, 0,
sizeof(c));
8270 for (i = 0, p = c.
u.
exact; i < fw_naddr; i++, p++) {
8274 memcpy(p->macaddr, addr[offset+i],
sizeof(p->macaddr));
8286 for (i = 0, p = c.
u.
exact; i < fw_naddr; i++, p++) {
8291 idx[offset+i] = (index >= max_naddr
8294 if (index < max_naddr)
8322 int idx,
bool sleep_ok)
8324 struct fw_vi_mac_exact *p;
8326 u8 addr[] = {0,0,0,0,0,0};
8330 memset(&c, 0,
sizeof(c));
8343 memcpy(p->macaddr, addr,
sizeof(p->macaddr));
8365 const u8 *addr,
const u8 *mask,
unsigned int idx,
8366 u8 lookup_type,
u8 port_id,
bool sleep_ok)
8369 struct fw_vi_mac_raw *p = &c.
u.
raw;
8372 memset(&c, 0,
sizeof(c));
8393 memcpy((
u8 *)&p->data1[0] + 2, addr, ETHER_ADDR_LEN);
8394 memcpy((
u8 *)&p->data1m[0] + 2, mask, ETHER_ADDR_LEN);
8413 unsigned int viid,
unsigned int naddr,
8414 const u8 **addr,
bool sleep_ok)
8416 int offset, ret = 0;
8418 unsigned int nfilters = 0;
8420 unsigned int rem = naddr;
8422 if (naddr > max_naddr)
8425 for (offset = 0; offset < (int)naddr ; ) {
8431 struct fw_vi_mac_exact *p;
8434 memset(&c, 0,
sizeof(c));
8444 for (i = 0, p = c.
u.
exact; i < (
int)fw_naddr; i++, p++) {
8448 memcpy(p->macaddr, addr[offset+i],
sizeof(p->macaddr));
8455 for (i = 0, p = c.
u.
exact; i < fw_naddr; i++, p++) {
8459 if (index < max_naddr)
8495 int idx,
const u8 *addr,
bool persist, uint16_t *smt_idx)
8499 struct fw_vi_mac_exact *p = c.
u.
exact;
8506 memset(&c, 0,
sizeof(c));
8514 memcpy(p->macaddr, addr,
sizeof(p->macaddr));
8516 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
8519 if (ret >= max_mac_addr)
8547 bool ucast,
u64 vec,
bool sleep_ok)
8552 memset(&c, 0,
sizeof(c));
8576 unsigned int viid,
bool rx_en,
bool tx_en,
bool dcb_en)
8580 memset(&c, 0,
sizeof(c));
8603 bool rx_en,
bool tx_en)
8618 unsigned int nblinks)
8622 memset(&c, 0,
sizeof(c));
8628 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
8647 unsigned int vf,
unsigned int iqtype,
unsigned int iqid,
8648 unsigned int fl0id,
unsigned int fl1id)
8652 memset(&c, 0,
sizeof(c));
8661 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
8678 unsigned int vf,
unsigned int iqtype,
unsigned int iqid,
8683 memset(&c, 0,
sizeof(c));
8692 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
8707 unsigned int vf,
unsigned int eqid)
8711 memset(&c, 0,
sizeof(c));
8718 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
8732 unsigned int vf,
unsigned int eqid)
8736 memset(&c, 0,
sizeof(c));
8743 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
8757 unsigned int vf,
unsigned int eqid)
8761 memset(&c, 0,
sizeof(c));
8768 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
8782 unsigned int vf,
unsigned int eqid)
8786 memset(&c, 0,
sizeof(c));
8793 return t4_wr_mbox(adap, mbox, &c,
sizeof(c), NULL);
8804 static const char *reason[] = {
8807 "Auto-negotiation Failure",
8809 "Insufficient Airflow",
8810 "Unable To Determine Reason",
8811 "No RX Signal Detected",
8816 return "Bad Reason Code";
8818 return reason[link_down_rc];
8826 #define TEST_SPEED_RETURN(__caps_speed, __speed) \
8828 if (caps & FW_PORT_CAP32_SPEED_##__caps_speed) \
8842 #undef TEST_SPEED_RETURN
8852 #define TEST_SPEED_RETURN(__caps_speed, __speed) \
8854 if (speed == __speed) \
8855 return FW_PORT_CAP32_SPEED_##__caps_speed; \
8868 #undef TEST_SPEED_RETURN
8878 #define TEST_SPEED_RETURN(__caps_speed) \
8880 if (caps & FW_PORT_CAP32_SPEED_##__caps_speed) \
8881 return FW_PORT_CAP32_SPEED_##__caps_speed; \
8894 #undef TEST_SPEED_RETURN
8908 uint32_t linkattr = 0;
8941 enum fw_port_action action,
bool *mod_changed,
bool *link_changed)
8946 int old_ptype, old_mtype;
8996 if (mod_changed != NULL)
8997 *mod_changed =
false;
8998 if (link_changed != NULL)
8999 *link_changed =
false;
9004 if (mod_changed != NULL)
9005 *mod_changed =
true;
9008 old_lc.
fec != lc->
fec || old_lc.
fc != lc->
fc) {
9009 if (link_changed != NULL)
9010 *link_changed =
true;
9029 memset(&cmd, 0,
sizeof(cmd));
9054 u8 opcode = *(
const u8 *)rpl;
9058 bool mod_changed, link_changed;
9124 static struct flash_desc supported_flash[] = {
9125 { 0x00150201, 4 << 20 },
9130 unsigned int part, manufacturer;
9131 unsigned int density, size = 0;
9150 for (part = 0; part <
ARRAY_SIZE(supported_flash); part++)
9153 supported_flash[part].
size_mb;
9168 manufacturer = flashid & 0xff;
9169 switch (manufacturer) {
9175 density = (flashid >> 16) & 0xff;
9177 case 0x14: size = 1 << 20;
break;
9178 case 0x15: size = 1 << 21;
break;
9179 case 0x16: size = 1 << 22;
break;
9180 case 0x17: size = 1 << 23;
break;
9181 case 0x18: size = 1 << 24;
break;
9182 case 0x19: size = 1 << 25;
break;
9183 case 0x20: size = 1 << 26;
break;
9184 case 0x21: size = 1 << 27;
break;
9185 case 0x22: size = 1 << 28;
break;
9194 density = (flashid >> 16) & 0xff;
9196 case 0x16: size = 1 << 25;
break;
9197 case 0x17: size = 1 << 26;
break;
9206 density = (flashid >> 16) & 0xff;
9208 case 0x17: size = 1 << 23;
break;
9209 case 0x18: size = 1 << 24;
break;
9218 density = (flashid >> 16) & 0xff;
9220 case 0x17: size = 1 << 23;
break;
9221 case 0x18: size = 1 << 24;
break;
9233 CH_WARN(
adapter,
"Unknown Flash Part, ID = %#x, assuming 4MB\n", flashid);
9278 .cng_ch_bits_log = 2,
9282 .mps_rplc_size = 128,
9292 .cng_ch_bits_log = 2,
9296 .mps_rplc_size = 128,
9306 .cng_ch_bits_log = 3,
9310 .mps_rplc_size = 256,
9469 unsigned int *pbar2_qid)
9471 unsigned int page_shift, page_size, qpp_shift, qpp_mask;
9472 u64 bar2_page_offset, bar2_qoffset;
9473 unsigned int bar2_qid, bar2_qid_offset, bar2_qinferred;
9484 page_size = 1 << page_shift;
9491 qpp_mask = (1 << qpp_shift) - 1;
9498 bar2_page_offset = ((
u64)(qid >> qpp_shift) << page_shift);
9499 bar2_qid = qid & qpp_mask;
9518 bar2_qoffset = bar2_page_offset;
9519 bar2_qinferred = (bar2_qid_offset < page_size);
9520 if (bar2_qinferred) {
9521 bar2_qoffset += bar2_qid_offset;
9525 *pbar2_qoffset = bar2_qoffset;
9526 *pbar2_qid = bar2_qid;
9542 unsigned int devlog_meminfo;
9553 unsigned int nentries, nentries128;
9559 nentries = (nentries128 + 1) * 128;
9568 memset(dparams, 0,
sizeof *dparams);
9579 memset(&devlog_cmd, 0,
sizeof devlog_cmd);
9583 ret =
t4_wr_mbox(adap, adap->
mbox, &devlog_cmd,
sizeof(devlog_cmd),
9688static inline uint16_t
9691 static const uint8_t width[] = {1, 3, 17, 17, 8, 8, 16, 9, 3, 1};
9693 uint16_t filter_mask;
9698 if ((filter_mode & (1 << i)) == 0)
9700 mask = (1 << width[i]) - 1;
9701 if ((hashmask & mask) == mask)
9702 filter_mask |= 1 << i;
9703 hashmask >>= width[i];
9706 return (filter_mask);
9716 uint32_t v, param[2], val[2];
9744 hash_mask |= (
u64)v << 32;
9782 u32 tx_len, rx_len,
r, v;
9790 for (chan = 0; chan <
MAX_NCHAN; chan++)
9810 rx_len = min(rx_len, v);
9811 tx_len = min(tx_len, v);
9837 for (sel = 1, field_shift = 0; sel < filter_sel; sel <<= 1) {
9882 for (i = 0, j = -1; i <= p->
port_id; i++) {
9945 for (i = 0; i < cim_num_obq; i++) {
9968 int i, err, attempts;
9972 if (qid > 5 || (n & 3))
9975 addr = qid * nwords;
9984 for (i = 0; i < n; i++, addr++) {
10011 unsigned int addr, v, nwords;
10014 if ((qid > (cim_num_obq - 1)) || (n & 3))
10026 for (i = 0; i < n; i++, addr++) {
10057 unsigned int *valp)
10064 for ( ; !ret && n--; addr += 4) {
10084 const unsigned int *valp)
10091 for ( ; !ret && n--; addr += 4) {
10116 unsigned int *valp)
10134 unsigned int cfg, val, idx;
10173 if (
is_t6(adap) && (idx & 0xf) >= 9)
10174 idx = (idx & 0xff0) + 0x10;
10202 bool last_incomplete;
10203 unsigned int i, cfg, val, idx;
10213 if (last_incomplete)
10229 if (last_incomplete)
10245#define SGE_IDMA_WARN_THRESH 1
10246#define SGE_IDMA_WARN_REPEAT 300
10285 int i, idma_same_state_cnt[2];
10298 for (i = 0; i < 2; i++) {
10299 u32 debug0, debug11;
10310 "resumed after %d seconds\n",
10349 idma->
idma_state[i] = (debug0 >> (i * 9)) & 0x3f;
10353 idma->
idma_qid[i] = (debug11 >> (i * 16)) & 0xffff;
10356 " state %u for %d seconds (debug0=%#x, debug11=%#x)\n",
10373 unsigned int naddr,
u8 *addr)
10377 memset(&cmd, 0,
sizeof(cmd));
10434 unsigned int *ipg,
bool sleep_ok)
10436 unsigned int v, addr, bpt, cpt;
10443 bpt = (v >> 8) & 0xff;
10449 *kbps = (v * bpt) / 125;
10472 int ret, i, n, cfg_addr;
10474 unsigned int flash_cfg_start_sec;
10485 CH_ERR(adap,
"cfg file too large, max is %u bytes\n",
10493 flash_cfg_start_sec + i - 1);
10498 if (ret || size == 0)
10517 CH_ERR(adap,
"config file %s failed %d\n",
10518 (size == 0 ?
"clear" :
"download"), ret);
10530 u32 params[1], val[1];
10627 u32 cur_header = 0;
10634 pcir_header = (
pcir_data_t *) &boot_data[cur_header +
10657 header->
cksum = 0x0;
10662 for (i = 0; i < (header->
size512 * 512); i++)
10663 csum += (
u8)boot_data[cur_header + i];
10669 boot_data[cur_header + 7] = -csum;
10671 }
else if (pcir_header->
code_type == 0x03) {
10691 cur_header += header->
size512 * 512;
10707 unsigned int boot_addr,
unsigned int size)
10713 uint16_t device_id;
10715 unsigned int boot_sector = (boot_addr * 1024 );
10722 CH_ERR(adap,
"boot image encroaching on firmware region\n");
10734 (boot_sector >> 16) + i - 1);
10740 if (ret || (size == 0))
10747 pcir_header = (
pcir_data_t *) &boot_data[pcir_offset];
10755 CH_ERR(adap,
"boot image too small/large\n");
10759#ifndef CHELSIO_T4_DIAGS
10764 CH_ERR(adap,
"Boot image missing signature\n");
10772 CH_ERR(adap,
"PCI header missing signature\n");
10780 CH_ERR(adap,
"Vendor ID missing signature\n");
10790 device_id = device_id & 0xf0ff;
10809 addr = boot_sector;
10819 (
const u8 *)header, 0);
10823 CH_ERR(adap,
"boot image download failed, error %d\n", ret);
10849 int ret, i, n, cfg_addr;
10851 unsigned int flash_cfg_start_sec;
10862 CH_ERR(adap,
"bootcfg file too large, max is %u bytes\n",
10870 flash_cfg_start_sec + i - 1);
10876 if (ret || size == 0)
10895 CH_ERR(adap,
"boot config data %s failed %d\n",
10896 (size == 0 ?
"clear" :
"download"), ret);
10914 static const uint8_t width[] = {1, 3, 17, 17, 8, 8, 16, 9, 3, 1};
10916 uint32_t param, val;
10917 uint16_t fmode, fmask;
10920 if (mode != -1 || mask != -1) {
10925 if (fmode & (1 << i))
10928 if (nbits > maxbits) {
10929 CH_ERR(adap,
"optional fields in the filter "
10930 "mode (0x%x) add up to %d bits "
10931 "(must be <= %db). Remove some fields and "
10932 "try again.\n", fmode, nbits, maxbits);
10941 if (fmode & (1 << i))
10943 if (nbits + width[i] <= maxbits) {
10946 if (nbits == maxbits)
10954 "filter mask will be changed from 0x%x to "
10955 "0x%x to comply with the filter mode (0x%x).\n",
10961 if ((fmode | fmask) != fmode) {
10963 "filter mask (0x%x) must be a subset of "
10964 "the filter mode (0x%x).\n", fmask, fmode);
10980 if (vnic_mode != -1) {
11008 u32 port_base_addr;
11021 for (i = 0; i < 4; i++)
11022 if (bgmap & (1 << i)) {
11043 int port,
unsigned int devid,
11044 unsigned int offset,
unsigned int len,
11045 u8 *buf,
bool write)
11048 unsigned int i2c_max =
sizeof(ldst_cmd.
u.
i2c.
data);
11055 if (offset < I2C_PAGE_SIZE && offset + len >
I2C_PAGE_SIZE)
11058 memset(&ldst_cmd, 0,
sizeof(ldst_cmd));
11069 unsigned int i2c_len = (len < i2c_max) ? len : i2c_max;
11075 memcpy(ldst_cmd.
u.
i2c.
data, buf, i2c_len);
11077 ret =
t4_wr_mbox(adap, mbox, &ldst_cmd,
sizeof(ldst_cmd),
11078 write ? NULL : &ldst_rpl);
11083 memcpy(buf, ldst_rpl.u.i2c.data, i2c_len);
11093 int port,
unsigned int devid,
11094 unsigned int offset,
unsigned int len,
11097 return t4_i2c_io(adap, mbox,
port, devid, offset, len, buf,
false);
11101 int port,
unsigned int devid,
11102 unsigned int offset,
unsigned int len,
11105 return t4_i2c_io(adap, mbox,
port, devid, offset, len, buf,
true);
11133 memset(&c, 0,
sizeof(c));
11140 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
11180 memset(&cmd, 0,
sizeof(cmd));
11195 int rateunit,
int ratemode,
int channel,
int cl,
11196 int minrate,
int maxrate,
int weight,
int pktsize,
11197 int burstsize,
int sleep_ok)
11201 memset(&cmd, 0,
sizeof(cmd));
11226 unsigned int maxrate,
int sleep_ok)
11230 memset(&cmd, 0,
sizeof(cmd));
11248 int weight,
int sleep_ok)
11252 if (weight < 0 || weight > 100)
11255 memset(&cmd, 0,
sizeof(cmd));
11273 int mode,
unsigned int maxrate,
int pktsize,
int sleep_ok)
11277 memset(&cmd, 0,
sizeof(cmd));
11312 unsigned int pf,
unsigned int vf,
11313 unsigned int timeout,
unsigned int action)
11316 unsigned int ticks;
11328 memset(&wdog, 0,
sizeof wdog);
11346 memset(&devlog_cmd, 0,
sizeof(devlog_cmd));
11351 sizeof(devlog_cmd), &devlog_cmd);
11363 memset(&devlog_cmd, 0,
sizeof(devlog_cmd));
11370 sizeof(devlog_cmd), &devlog_cmd);
11375 unsigned int param, val;
11406 unsigned int param, val;
11418 CH_ERR(adap,
"Querying FW using Ring backbone params command failed, err=%d\n",
11424 CH_ERR(adap,
"FW doesnot support ringbackbone features\n");
11430 CH_ERR(adap,
"Could not set Ringbackbone, err= %d\n",
11451 unsigned int enable;
11454 memset(&vlan_cmd, 0,
sizeof(vlan_cmd));
11468 vlan_cmd.
nvlan = 1;
11472 return t4_wr_mbox(adap, adap->
mbox, &vlan_cmd,
sizeof(vlan_cmd), NULL);
11491 const u8 *addr,
bool smac)
11495 struct fw_vi_mac_exact *p = c.
u.
exact;
11498 memset(&c, 0,
sizeof(c));
11506 memcpy(p->macaddr, addr,
sizeof(p->macaddr));
11511 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
11514 if (ret < max_mac_addr)
11540 int idx,
const u8 *addr,
bool persist,
u8 *smt_idx,
bool smac)
11544 struct fw_vi_mac_exact *p = c.
u.
exact;
11551 memset(&c, 0,
sizeof(c));
11561 memcpy(p->macaddr, addr,
sizeof(p->macaddr));
11563 ret =
t4_wr_mbox(adap, mbox, &c,
sizeof(c), &c);
11566 if (ret >= max_mac_addr)
static void t4_os_pci_read_cfg4(struct adapter *sc, int reg, uint32_t *val)
static uint32_t t4_read_reg(struct adapter *sc, uint32_t reg)
static void CH_DUMP_MBOX(struct adapter *sc, int mbox, const int reg, const char *msg, const __be64 *const p, const bool err)
void t4_os_portmod_changed(struct port_info *)
static struct port_info * adap2pinfo(struct adapter *sc, int idx)
static void t4_write_reg64(struct adapter *sc, uint32_t reg, uint64_t val)
static void t4_write_reg(struct adapter *sc, uint32_t reg, uint32_t val)
static int t4_use_ldst(struct adapter *sc)
static void t4_os_pci_read_cfg2(struct adapter *sc, int reg, uint16_t *val)
static void t4_os_set_hw_addr(struct port_info *pi, uint8_t hw_addr[])
#define ASSERT_SYNCHRONIZED_OP(sc)
int t4_os_find_pci_capability(struct adapter *, int)
static void t4_os_pci_write_cfg4(struct adapter *sc, int reg, uint32_t val)
static void t4_os_pci_write_cfg2(struct adapter *sc, int reg, uint16_t val)
void t4_os_link_changed(struct port_info *)
void t4_os_cim_err(struct adapter *)
static uint64_t t4_read_reg64(struct adapter *sc, uint32_t reg)
static int t4_wr_mbox_timeout(struct adapter *adap, int mbox, const void *cmd, int size, void *rpl, int timeout)
static unsigned int dack_ticks_to_usec(const struct adapter *adap, unsigned int ticks)
static int t4_wr_mbox(struct adapter *adap, int mbox, const void *cmd, int size, void *rpl)
static int is_t6(struct adapter *adap)
static unsigned int core_ticks_to_us(const struct adapter *adapter, unsigned int ticks)
void t4_fatal_err(struct adapter *adapter, bool fw_error)
static int chip_id(struct adapter *adap)
#define for_each_port(adapter, iter)
static int is_t4(struct adapter *adap)
static unsigned int core_ticks_per_usec(const struct adapter *adap)
static int is_t5(struct adapter *adap)
static int t4_wr_mbox_ns(struct adapter *adap, int mbox, const void *cmd, int size, void *rpl)
static const char *const region[]
static char * strstrip(char *s)
#define CH_WARN(adap, fmt,...)
#define CH_ERR(adap, fmt,...)
#define CH_WARN_RATELIMIT(adap, fmt,...)
#define CH_ALERT(adap, fmt,...)
#define PCI_EXP_LNKSTA_CLS
#define PCI_EXP_LNKSTA_NLW
#define DIV_ROUND_UP(x, y)
struct devlog_params devlog
unsigned short a_wnd[NCCTRL_WIN]
unsigned int smac_add_support
bool viid_smt_extn_support
struct vf_resources vfres
unsigned short b_wnd[NCCTRL_WIN]
const struct chip_params * chip_params
struct adapter_params params
struct port_info * port[MAX_NPORTS]
union fw_debug_cmd::fw_debug u
__be32 memtype_devlog_memaddr16_devlog
__be32 del_filter_to_l2tix
__be32 type_to_iqandstindex
union fw_ldst_cmd::fw_ldst u
struct fw_params_cmd::fw_params_param param[7]
__be32 r_caps_to_nethctrl
__be32 lstatus32_to_cbllen32
__be32 lstatus_to_modtype
union fw_port_cmd::fw_port u
union fw_sched_cmd::fw_sched u
union fw_vi_mac_cmd::fw_vi_mac u
bool(* action)(struct adapter *, int, bool)
const struct intr_details * details
const struct intr_action * actions
unsigned int vpd_cap_addr
struct link_config link_cfg
unsigned int idma_stalled[2]
unsigned int idma_state[2]
unsigned int idma_warn[2]
unsigned int idma_1s_thresh
int counter_val[SGE_NCOUNTERS]
int timer_val[SGE_NTIMERS]
u32 tcp6_in_errs[MAX_NCHAN]
u32 tnl_tx_drops[MAX_NCHAN]
u32 mac_in_errs[MAX_NCHAN]
u32 tnl_cong_drops[MAX_NCHAN]
u32 ofld_vlan_drops[MAX_NCHAN]
u32 tcp_in_errs[MAX_NCHAN]
u32 hdr_in_errs[MAX_NCHAN]
u32 ofld_chan_drops[MAX_NCHAN]
unsigned short tx_modq[MAX_NCHAN]
void t4_read_rss_vf_config(struct adapter *adapter, unsigned int index, u32 *vfl, u32 *vfh, bool sleep_ok)
#define GET_STAT_COM(name)
int t4_sched_params_cl_wrr(struct adapter *adapter, int channel, int cl, int weight, int sleep_ok)
uint32_t speed_to_fwcap(unsigned int speed)
void t4_set_reg_field(struct adapter *adapter, unsigned int addr, u32 mask, u32 val)
int t4_sched_params_cl_rl_kbps(struct adapter *adapter, int channel, int cl, int mode, unsigned int maxrate, int pktsize, int sleep_ok)
int t4_shutdown_adapter(struct adapter *adapter)
void t4_wol_magic_enable(struct adapter *adap, unsigned int port, const u8 *addr)
int t4_sge_ctxt_rd_bd(struct adapter *adap, unsigned int cid, enum ctxt_type ctype, u32 *data)
void t4_get_regs(struct adapter *adap, u8 *buf, size_t buf_size)
void t4_tp_get_tnl_stats(struct adapter *adap, struct tp_tnl_stats *st, bool sleep_ok)
static unsigned int t4_get_rx_e_chan_map(struct adapter *adap, int idx)
int t4_set_sched_bps(struct adapter *adap, int sched, unsigned int kbps)
static void t4_show_intr_info(struct adapter *adap, const struct intr_info *ii, u32 cause)
int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid, int start, int n, const u16 *rspq, unsigned int nrspq)
static void fw_asrt(struct adapter *adap, struct fw_debug_cmd *asrt)
int t4_fw_upgrade(struct adapter *adap, unsigned int mbox, const u8 *fw_data, unsigned int size, int force)
int t4_free_vi(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int viid)
static uint16_t fwcaps32_to_caps16(uint32_t caps32)
static void set_pcie_completion_timeout(struct adapter *adapter, u8 range)
int t4_fwaddrspace_write(struct adapter *adap, unsigned int mbox, u32 addr, u32 val)
void t4_read_cong_tbl(struct adapter *adap, u16 incr[NMTUS][NCCTRL_WIN])
struct pcir_data_structure pcir_data_t
static uint32_t fwcaps16_to_caps32(uint16_t caps16)
u32 t4_read_pcie_cfg4(struct adapter *adap, int reg, int drv_fw_attach)
int t4_free_mac_filt(struct adapter *adap, unsigned int mbox, unsigned int viid, unsigned int naddr, const u8 **addr, bool sleep_ok)
static void get_pci_mode(struct adapter *adapter, struct pci_params *p)
static int sf1_write(struct adapter *adapter, unsigned int byte_cnt, int cont, int lock, u32 val)
struct legacy_pci_expansion_rom_header legacy_pci_exp_rom_header_t
int t4_get_vpd_version(struct adapter *adapter, u32 *vers)
int t4_wr_mbox_meat_timeout(struct adapter *adap, int mbox, const void *cmd, int size, void *rpl, bool sleep_ok, int timeout)
static int t4_wait_op_done_val(struct adapter *adapter, int reg, u32 mask, int polarity, int attempts, int delay, u32 *valp)
static bool mem_intr_handler(struct adapter *adap, int idx, bool verbose)
void t4_write_rss_pf_mask(struct adapter *adapter, u32 pfmask, bool sleep_ok)
int t4_mc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
int t4_alloc_raw_mac_filt(struct adapter *adap, unsigned int viid, const u8 *addr, const u8 *mask, unsigned int idx, u8 lookup_type, u8 port_id, bool sleep_ok)
static bool ma_intr_handler(struct adapter *adap, int arg, bool verbose)
int t4_get_flash_params(struct adapter *adapter)
static int t4_fw_matches_chip(struct adapter *adap, const struct fw_hdr *hdr)
static bool le_intr_handler(struct adapter *adap, int arg, bool verbose)
static void modify_device_id(int device_id, u8 *boot_data)
static uint16_t hashmask_to_filtermask(uint64_t hashmask, uint16_t filter_mode)
static bool cplsw_intr_handler(struct adapter *adap, int arg, bool verbose)
int t4_write_flash(struct adapter *adapter, unsigned int addr, unsigned int n, const u8 *data, int byte_oriented)
static unsigned int t4_get_mps_bg_map(struct adapter *adap, int idx)
void t4_cim_read_ma_la(struct adapter *adap, u32 *ma_req, u32 *ma_rsp)
void t4_pmtx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
int t4_set_trace_filter(struct adapter *adap, const struct trace_params *tp, int idx, int enable)
uint32_t fwcap_top_speed(uint32_t caps)
void t4_tp_tm_pio_read(struct adapter *adap, u32 *buff, u32 nregs, u32 start_index, bool sleep_ok)
static int rd_rss_row(struct adapter *adap, int row, u32 *val)
int t4_seeprom_wp(struct adapter *adapter, int enable)
int t4_mem_read(struct adapter *adap, int mtype, u32 addr, u32 len, __be32 *buf)
int t4_set_filter_cfg(struct adapter *adap, int mode, int mask, int vnic_mode)
int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int iqtype, unsigned int iqid, unsigned int fl0id, unsigned int fl1id)
void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4, struct tp_tcp_stats *v6, bool sleep_ok)
int t4_cim_write(struct adapter *adap, unsigned int addr, unsigned int n, const unsigned int *valp)
static bool pmrx_intr_handler(struct adapter *adap, int arg, bool verbose)
void t4_idma_monitor_init(struct adapter *adapter, struct sge_idma_monitor_state *idma)
#define EDC_REG_T5(reg, idx)
int t4_sched_config(struct adapter *adapter, int type, int minmaxen, int sleep_ok)
int t4_query_params(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int nparams, const u32 *params, u32 *val)
static bool ma_wrap_status(struct adapter *adap, int arg, bool verbose)
int t4_eth_eq_stop(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int eqid)
static int t4_tp_fw_ldst_rw(struct adapter *adap, int cmd, u32 *vals, unsigned int nregs, unsigned int start_index, unsigned int rw, bool sleep_ok)
void t4_read_indirect(struct adapter *adap, unsigned int addr_reg, unsigned int data_reg, u32 *vals, unsigned int nregs, unsigned int start_idx)
void t4_sge_decode_idma_state(struct adapter *adapter, int state)
int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size)
void t4_get_tx_sched(struct adapter *adap, unsigned int sched, unsigned int *kbps, unsigned int *ipg, bool sleep_ok)
int t4_flash_erase_sectors(struct adapter *adapter, int start, int end)
#define SGE_IDMA_WARN_REPEAT
int t4_cim_ctl_read(struct adapter *adap, unsigned int addr, unsigned int n, unsigned int *valp)
int t4_query_params_rw(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int nparams, const u32 *params, u32 *val, int rw)
int t4_get_tp_version(struct adapter *adapter, u32 *vers)
int t4_read_rss(struct adapter *adapter, u16 *map)
static void get_mbox_rpl(struct adapter *adap, __be64 *rpl, int nflit, u32 mbox_addr)
const struct chip_params * t4_get_chip_params(int chipid)
int t4_set_sched_ipg(struct adapter *adap, int sched, unsigned int ipg)
static unsigned int t4_get_rx_c_chan(struct adapter *adap, int idx)
void t4_get_fcoe_stats(struct adapter *adap, unsigned int idx, struct tp_fcoe_stats *st, bool sleep_ok)
#define FIND_VPD_KW(var, name)
#define NONFATAL_IF_DISABLED
int t4_read_flash(struct adapter *adapter, unsigned int addr, unsigned int nwords, u32 *data, int byte_oriented)
const char * t4_get_port_type_description(enum fw_port_type port_type)
int t4_fwcache(struct adapter *adap, enum fw_params_param_dev_fwcache op)
void t4_write_rss_pf_map(struct adapter *adapter, u32 pfmap, bool sleep_ok)
int t4_fw_initialize(struct adapter *adap, unsigned int mbox)
static void handle_port_info(struct port_info *pi, const struct fw_port_cmd *p, enum fw_port_action action, bool *mod_changed, bool *link_changed)
static bool pmtx_intr_handler(struct adapter *adap, int arg, bool verbose)
void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log)
static int sf1_read(struct adapter *adapter, unsigned int byte_cnt, int cont, int lock, u32 *valp)
static void read_tx_state_one(struct adapter *sc, int i, struct port_tx_state *tx_state)
void t4_idma_monitor(struct adapter *adapter, struct sge_idma_monitor_state *idma, int hz, int ticks)
static char intr_alert_char(u32 cause, u32 enable, u32 fatal)
void t4_read_rss_pf_config(struct adapter *adapter, unsigned int index, u32 *valp, bool sleep_ok)
int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size, void *rpl, bool sleep_ok)
int t4_bar2_sge_qregs(struct adapter *adapter, unsigned int qid, enum t4_bar2_qtype qtype, int user, u64 *pbar2_qoffset, unsigned int *pbar2_qid)
static int get_vpd_keyword_val(const u8 *vpd, const char *kw, int region)
int t4_sge_ctxt_rd(struct adapter *adap, unsigned int mbox, unsigned int cid, enum ctxt_type ctype, u32 *data)
void t4_tp_get_proxy_stats(struct adapter *adap, struct tp_proxy_stats *st, bool sleep_ok)
static bool pcie_intr_handler(struct adapter *adap, int arg, bool verbose)
int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset)
int t4_get_bs_version(struct adapter *adapter, u32 *vers)
int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode, unsigned int flags)
int t4_fw_bye(struct adapter *adap, unsigned int mbox)
static int t4_cim_write1(struct adapter *adap, unsigned int addr, unsigned int val)
static bool ulprx_intr_handler(struct adapter *adap, int arg, bool verbose)
#define CAP32_TO_CAP16(__cap)
int t4_i2c_io(struct adapter *adap, unsigned int mbox, int port, unsigned int devid, unsigned int offset, unsigned int len, u8 *buf, bool write)
int t4_alloc_vi_func(struct adapter *adap, unsigned int mbox, unsigned int port, unsigned int pf, unsigned int vf, unsigned int nmac, u8 *mac, u16 *rss_size, uint8_t *vfvld, uint16_t *vin, unsigned int portfunc, unsigned int idstype)
int t4_set_params_timeout(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int nparams, const u32 *params, const u32 *val, int timeout)
int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr, unsigned int mmd, unsigned int reg, unsigned int *valp)
int t4_ctrl_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int eqid)
static bool plpl_intr_handler(struct adapter *adap, int arg, bool verbose)
#define SGE_IDMA_WARN_THRESH
int t4_i2c_rd(struct adapter *adap, unsigned int mbox, int port, unsigned int devid, unsigned int offset, unsigned int len, u8 *buf)
void t4_ulprx_read_la(struct adapter *adap, u32 *la_buf)
int t4_get_version_info(struct adapter *adapter)
int t4_i2c_wr(struct adapter *adap, unsigned int mbox, int port, unsigned int devid, unsigned int offset, unsigned int len, u8 *buf)
void t4_read_rss_key(struct adapter *adap, u32 *key, bool sleep_ok)
void t4_get_chan_txrate(struct adapter *adap, u64 *nic_rate, u64 *ofld_rate)
int t4_load_bootcfg(struct adapter *adap, const u8 *cfg_data, unsigned int size)
void t4_load_mtus(struct adapter *adap, const unsigned short *mtus, const unsigned short *alpha, const unsigned short *beta)
int t4_load_boot(struct adapter *adap, u8 *boot_data, unsigned int boot_addr, unsigned int size)
unsigned int t4_get_regs_len(struct adapter *adapter)
int t4_get_scfg_version(struct adapter *adapter, u32 *vers)
static bool mps_intr_handler(struct adapter *adap, int arg, bool verbose)
bool t4_slow_intr_handler(struct adapter *adap, bool verbose)
int t4_set_addr_hash(struct adapter *adap, unsigned int mbox, unsigned int viid, bool ucast, u64 vec, bool sleep_ok)
void t4_write_rss_pf_config(struct adapter *adapter, unsigned int index, u32 val, bool sleep_ok)
int t4_prep_adapter(struct adapter *adapter, u32 *buf)
u32 t4_hw_pci_read_cfg4(adapter_t *adap, int reg)
u32 t4_read_rss_pf_map(struct adapter *adapter, bool sleep_ok)
static int t4_edc_err_read(struct adapter *adap, int idx)
int t4_cim_read(struct adapter *adap, unsigned int addr, unsigned int n, unsigned int *valp)
int t4_eeprom_ptov(unsigned int phys_addr, unsigned int fn, unsigned int sz)
int t4_set_pace_tbl(struct adapter *adap, const unsigned int *pace_vals, unsigned int start, unsigned int n)
int t4_filter_field_shift(const struct adapter *adap, int filter_sel)
int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port, unsigned int pf, unsigned int vf, unsigned int nmac, u8 *mac, u16 *rss_size, uint8_t *vfvld, uint16_t *vin)
int t4_handle_fw_rpl(struct adapter *adap, const __be64 *rpl)
static int get_vpd_params(struct adapter *adapter, struct vpd_params *p, uint16_t device_id, u32 *buf)
void t4_clr_port_stats(struct adapter *adap, int idx)
int t5_fw_init_extern_mem(struct adapter *adap)
int t4_update_port_info(struct port_info *pi)
int t4_config_vi_rss(struct adapter *adapter, int mbox, unsigned int viid, unsigned int flags, unsigned int defq, unsigned int skeyidx, unsigned int skey)
int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr, unsigned int mmd, unsigned int reg, unsigned int val)
static int t4_flash_bootcfg_addr(struct adapter *adapter)
static void t4_tp_indirect_rw(struct adapter *adap, u32 reg_addr, u32 reg_data, u32 *buff, u32 nregs, u32 start_index, int rw, bool sleep_ok)
static int hash_mac_addr(const u8 *addr)
#define INIT_CMD(var, cmd, rd_wr)
void t4_intr_disable(struct adapter *adap)
int t4_iq_stop(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int iqtype, unsigned int iqid, unsigned int fl0id, unsigned int fl1id)
int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
static bool tp_intr_handler(struct adapter *adap, int arg, bool verbose)
void t4_tp_get_err_stats(struct adapter *adap, struct tp_err_stats *st, bool sleep_ok)
int t4_free_raw_mac_filt(struct adapter *adap, unsigned int viid, const u8 *addr, const u8 *mask, unsigned int idx, u8 lookup_type, u8 port_id, bool sleep_ok)
int t4_configure_add_smac(struct adapter *adap)
int t4_config_watchdog(struct adapter *adapter, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int timeout, unsigned int action)
int t4_seeprom_write(struct adapter *adapter, u32 addr, u32 data)
u32 t4_read_rss_pf_mask(struct adapter *adapter, bool sleep_ok)
void t4_get_usm_stats(struct adapter *adap, struct tp_usm_stats *st, bool sleep_ok)
static bool pmtx_dump_dbg_stats(struct adapter *adap, int arg, bool verbose)
int t4_load_cfg(struct adapter *adap, const u8 *cfg_data, unsigned int size)
int t4_sched_params_ch_rl(struct adapter *adapter, int channel, int ratemode, unsigned int maxrate, int sleep_ok)
int t4_fw_restart(struct adapter *adap, unsigned int mbox)
int t4_set_params(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int nparams, const u32 *params, const u32 *val)
static int flash_wait_op(struct adapter *adapter, int attempts, int delay)
int t4_del_mac(struct adapter *adap, unsigned int mbox, unsigned int viid, const u8 *addr, bool smac)
int t4_cfg_pfvf(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int txq, unsigned int txq_eth_ctrl, unsigned int rxqi, unsigned int rxq, unsigned int tc, unsigned int vi, unsigned int cmask, unsigned int pmask, unsigned int nexact, unsigned int rcaps, unsigned int wxcaps)
int t4_enable_vi(struct adapter *adap, unsigned int mbox, unsigned int viid, bool rx_en, bool tx_en)
int t4_free_encap_mac_filt(struct adapter *adap, unsigned int viid, int idx, bool sleep_ok)
#define VPD_INFO_FLD_HDR_SIZE
static uint32_t lstatus_to_fwcap(u32 lstatus)
void t4_write_rss_key(struct adapter *adap, const u32 *key, int idx, bool sleep_ok)
#define FIRST_RET(__getvinfo)
#define CAP16_TO_CAP32(__cap)
static bool mac_intr_handler(struct adapter *adap, int port, bool verbose)
void t4_tp_pio_write(struct adapter *adap, const u32 *buff, u32 nregs, u32 start_index, bool sleep_ok)
static bool sge_intr_handler(struct adapter *adap, int arg, bool verbose)
int t4_sge_ctxt_flush(struct adapter *adap, unsigned int mbox, int ctxt_type)
void t4_tp_get_tid_stats(struct adapter *adap, struct tp_tid_stats *st, bool sleep_ok)
#define CHELSIO_VPD_UNIQUE_ID
int t4_sched_params(struct adapter *adapter, int type, int level, int mode, int rateunit, int ratemode, int channel, int cl, int minrate, int maxrate, int weight, int pktsize, int burstsize, int sleep_ok)
int t4_configure_ringbb(struct adapter *adap)
int t4_set_devlog_level(struct adapter *adapter, unsigned int level)
static uint32_t fec_to_fwcap(int8_t fec)
int t4_init_devlog_params(struct adapter *adap, int fw_attach)
void t4_report_fw_error(struct adapter *adap)
#define X_CIM_PF_NOACCESS
static void read_filter_mode_and_ingress_config(struct adapter *adap)
void t4_read_cimq_cfg(struct adapter *adap, u16 *base, u16 *size, u16 *thres)
int t4_add_mac(struct adapter *adap, unsigned int mbox, unsigned int viid, int idx, const u8 *addr, bool persist, u8 *smt_idx, bool smac)
int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox, enum dev_master master, enum dev_state *state)
void t4_tp_get_rdma_stats(struct adapter *adap, struct tp_rdma_stats *st, bool sleep_ok)
int t4_link_l1cfg(struct adapter *adap, unsigned int mbox, unsigned int port, struct link_config *lc)
static bool ncsi_intr_handler(struct adapter *adap, int arg, bool verbose)
int t4_eth_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int eqid)
int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox, unsigned int viid, bool free, unsigned int naddr, const u8 **addr, u16 *idx, u64 *hash, bool sleep_ok)
int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map, u64 mask0, u64 mask1, unsigned int crc, bool enable)
int t4_cim_read_la(struct adapter *adap, u32 *la_buf, unsigned int *wrptr)
void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p)
static bool smb_intr_handler(struct adapter *adap, int arg, bool verbose)
void t4_write_rss_vf_config(struct adapter *adapter, unsigned int index, u32 vfl, u32 vfh, bool sleep_ok)
static bool ulptx_intr_handler(struct adapter *adap, int arg, bool verbose)
void t4_pmrx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
int t4_change_mac(struct adapter *adap, unsigned int mbox, unsigned int viid, int idx, const u8 *addr, bool persist, uint16_t *smt_idx)
void t4_tp_pio_read(struct adapter *adap, u32 *buff, u32 nregs, u32 start_index, bool sleep_ok)
struct efi_pci_expansion_rom_header efi_pci_exp_rom_header_t
static bool cim_intr_handler(struct adapter *adap, int arg, bool verbose)
static u64 chan_rate(struct adapter *adap, unsigned int bytes256)
int t4_get_fw_version(struct adapter *adapter, u32 *vers)
int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port)
int t4_enable_vi_params(struct adapter *adap, unsigned int mbox, unsigned int viid, bool rx_en, bool tx_en, bool dcb_en)
#define TEST_SPEED_RETURN(__caps_speed, __speed)
void t4_get_lb_stats(struct adapter *adap, int idx, struct lb_port_stats *p)
int t4_seeprom_read(struct adapter *adapter, u32 addr, u32 *data)
int t4_fw_halt(struct adapter *adap, unsigned int mbox, int force)
void t4_read_pace_tbl(struct adapter *adap, unsigned int pace_vals[NTX_SCHED])
int t4_get_devlog_level(struct adapter *adapter, unsigned int *level)
static int t4_seeprom_wait(struct adapter *adapter)
void t4_tp_read_la(struct adapter *adap, u64 *la_buf, unsigned int *wrptr)
void t4_tp_wr_bits_indirect(struct adapter *adap, unsigned int addr, unsigned int mask, unsigned int val)
void t4_cim_read_pif_la(struct adapter *adap, u32 *pif_req, u32 *pif_rsp, unsigned int *pif_req_wrptr, unsigned int *pif_rsp_wrptr)
void t4_write_indirect(struct adapter *adap, unsigned int addr_reg, unsigned int data_reg, const u32 *vals, unsigned int nregs, unsigned int start_idx)
static void check_tx_state(struct adapter *sc, struct port_tx_state *tx_state)
void t4_tp_mib_read(struct adapter *adap, u32 *buff, u32 nregs, u32 start_index, bool sleep_ok)
int t4_set_rxmode(struct adapter *adap, unsigned int mbox, unsigned int viid, int mtu, int promisc, int all_multi, int bcast, int vlanex, bool sleep_ok)
unsigned int fwcap_to_speed(uint32_t caps)
struct pci_expansion_rom_header pci_exp_rom_header_t
int t4_port_init(struct adapter *adap, int mbox, int pf, int vf, int port_id)
static bool t4_handle_intr(struct adapter *adap, const struct intr_info *ii, u32 additional_cause, bool verbose)
void t4_get_port_stats_offset(struct adapter *adap, int idx, struct port_stats *stats, struct port_stats *offset)
int t4_init_tp_params(struct adapter *adap)
int t4_init_sge_params(struct adapter *adapter)
const char * t4_link_down_rc_str(unsigned char link_down_rc)
void t4_intr_enable(struct adapter *adap)
void t4_intr_clear(struct adapter *adap)
static void read_tx_state(struct adapter *sc, struct port_tx_state *tx_state)
static void init_cong_ctrl(unsigned short *a, unsigned short *b)
int t4_get_fw_hdr(struct adapter *adapter, struct fw_hdr *hdr)
static int t4_wait_op_done(struct adapter *adapter, int reg, u32 mask, int polarity, int attempts, int delay)
int t4_read_cim_obq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
int t4_get_exprom_version(struct adapter *adapter, u32 *vers)
int t4_ofld_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, unsigned int vf, unsigned int eqid)
int t4_set_vf_mac(struct adapter *adapter, unsigned int pf, unsigned int vf, unsigned int naddr, u8 *addr)
int t4_read_cim_ibq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid)
int t4_set_vlan_acl(struct adapter *adap, unsigned int mbox, unsigned int vf, u16 vlan)
static int8_t fwcap_to_fec(uint32_t caps, bool unset_means_none)
int t4_flash_cfg_addr(struct adapter *adapter)
#define T6_LE_PERRCRC_MASK
int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid, unsigned int nblinks)
void t4_get_trace_filter(struct adapter *adap, struct trace_params *tp, int idx, int *enabled)
int t4_alloc_encap_mac_filt(struct adapter *adap, unsigned int viid, const u8 *addr, const u8 *mask, unsigned int vni, unsigned int vni_mask, u8 dip_hit, u8 lookup_type, bool sleep_ok)
void t4_tp_get_cpl_stats(struct adapter *adap, struct tp_cpl_stats *st, bool sleep_ok)
@ FLASH_FWBOOTSTRAP_MAX_SIZE
@ FLASH_FWBOOTSTRAP_START
@ FLASH_FWBOOTSTRAP_START_SEC
#define A_TP_VLAN_PRI_MAP
#define G_INGPACKBOUNDARY(x)
#define S_QUEUESPERPAGEPF1
#define A_SGE_DEBUG_DATA_LOW
#define F_ERR_DATA_CPL_ON_HIGH_QID1
#define G_PMMAXXFERLEN1(x)
#define A_PCIE_CFG_SPACE_REQ
#define A_PCIE_CORE_UTL_SYSTEM_BUS_AGENT_INTERRUPT_ENABLE
#define T5_PORT_REG(idx, reg)
#define F_TXFIFO_PRTY_ERR
#define F_NCSI2CIMINTFPARERR
#define A_MPS_PORT_STAT_RX_PORT_BYTES_L
#define A_TP_MIB_TCP_IN_ERR_0
#define F_MPS_DM_PRTY_ERR
#define F_MA_CIM_INTFPERR
#define F_BUNDLE_LEN_PARERR
#define A_PCIE_NONFAT_ERR
#define F_ECC_UE_INT_CAUSE
#define V_PILADBGRDPTR(x)
#define A_SGE_INGRESS_QUEUES_PER_PAGE_PF
#define A_TP_RSS_PF0_CONFIG
#define F_ECC_CE_INT_CAUSE
#define A_MAC_PORT_INT_CAUSE
#define A_SGE_DEBUG_DATA_HIGH_INDEX_10
#define A_PL_PF_INT_ENABLE
#define A_CIM_HOST_INT_CAUSE
#define A_CIM_HOST_INT_ENABLE
#define A_MAC_PORT_MAGIC_MACID_LO
#define A_TP_RSS_SECRET_KEY0
#define A_MPS_PORT_STAT_RX_PORT_LESS_64B_H
#define A_SGE_INT_ENABLE1
#define A_EDC_H_BIST_STATUS_RDATA
#define F_INGRESS_SIZE_ERR
#define A_MC_P_BIST_CMD_ADDR
#define A_MPS_TRC_INT_ENABLE
#define G_POLADBGWRPTR(x)
#define A_PM_RX_INT_ENABLE
#define A_TP_TX_MOD_Q1_Q0_TIMER_SEPARATOR
#define F_ERR_PCIE_ERROR3
#define F_BUNDLE_LEN_OVFL
#define F_PERR_CPL_128TO128_1
#define A_SGE_ITP_CONTROL
#define A_TP_MIB_TCP_RXT_SEG_LO
#define F_ERR_DATA_CPL_ON_HIGH_QID0
#define A_EDC_BIST_CMD_LEN
#define F_MEM_TO_INT_CAUSE
#define F_ERR_ING_PCIE_CHAN
#define NUM_MPS_T5_CLS_SRAM_L_INSTANCES
#define F_SE_CNT_MISMATCH_1
#define A_CIM_PF_HOST_INT_ENABLE
#define A_CIM_QUEUE_CONFIG_REF
#define PCIE_FW_REG(reg_addr, idx)
#define A_MA_INT_WRAP_STATUS
#define A_MPS_STAT_RX_BG_0_MAC_DROP_FRAME_L
#define A_TP_MIB_HDR_IN_ERR_0
#define A_MPS_TX_INT_ENABLE
#define V_BIST_CMD_GAP(x)
#define A_TP_RSS_CONFIG_VRT
#define A_UP_UP_DBG_LA_DATA
#define A_CIM_PO_LA_DEBUGDATA
#define A_MC_P_ECC_STATUS
#define F_MEM_PERR_INT_CAUSE
#define PORT_REG(idx, reg)
#define G_UPDBGLAWRPTR(x)
#define A_CIM_PF_MAILBOX_CTRL
#define A_TP_MIB_USM_PKTS
#define A_ULP_TX_INT_CAUSE_2
#define V_TFMINPKTSIZE(x)
#define A_MPS_TX_INT_CAUSE
#define F_ZERO_E_CMD_ERROR
#define F_ZERO_SWITCH_ERROR
#define A_ULP_TX_INT_ENABLE
#define A_PCIE_INT_ENABLE
#define A_SGE_DEBUG_INDEX
#define F_OBQSGERX1PARERR
#define F_T5_TFINVERTMATCH
#define V_TXTIMERSEPQ0(x)
#define F_RXFIFO_PRTY_ERR
#define NUM_MPS_CLS_SRAM_L_INSTANCES
#define A_PL_PF_INT_CAUSE
#define F_ERR_BAD_DB_PIDX3
#define A_CIM_OBQ_DBG_CFG
#define A_MPS_STAT_PERR_INT_CAUSE_SRAM
#define A_MPS_STAT_RX_BG_0_MAC_TRUNC_FRAME_L
#define F_REG_ADDRESS_ERR
#define F_ERR_PCIE_ERROR1
#define S_QUEUESPERPAGEPF0
#define A_MPS_PORT_STAT_TX_PORT_PPP7_H
#define A_PM_TX_INT_CAUSE
#define A_MC_P_BIST_DATA_PATTERN
#define G_PMMAXXFERLEN0(x)
#define A_PM_RX_INT_CAUSE
#define A_PM_TX_INT_ENABLE
#define S_HOSTPAGESIZEPF0
#define F_MA_INTF_SDC_ERR
#define F_ERR_INVALID_CIDX_INC
#define F_ERR_BAD_DB_PIDX2
#define A_EDC_BIST_DATA_PATTERN
#define F_DB_OPTIONS_PAR_ERROR
#define EDC_T5_REG(reg, idx)
#define G_MEM_WRAP_CLIENT_NUM(x)
#define VF_CIM_REG(reg_addr)
#define G_LKPTBLQUEUE1(x)
#define A_SGE_INT_ENABLE2
#define A_TP_MIB_TNL_IN_PKT_0
#define F_TIEQOUTPARERRINT
#define A_MPS_STAT_PERR_INT_CAUSE_TX_FIFO
#define A_MPS_PORT_STAT_TX_PORT_FRAMES_L
#define A_SGE_INT_ENABLE3
#define A_LE_DB_INT_ENABLE
#define A_PCIE_CFG_SPACE_DATA
#define A_TP_MIB_TCP_V6OUT_RST
#define V_TXTIMERSEPQ1(x)
#define A_PM_RX_STAT_COUNT
#define LE_HASH_MASK_GEN_IPV4T5(idx)
#define A_XGMAC_PORT_MAGIC_MACID_LO
#define A_NCSI_INT_ENABLE
#define V_UPDBGLARDPTR(x)
#define A_MC_P_BIST_CMD_LEN
#define A_XGMAC_PORT_CFG2
#define A_SGE_DEBUG_DATA_HIGH
#define A_TP_MIB_TNL_DROP_0
#define A_TP_MIB_CPL_IN_REQ_0
#define F_C_PCMD_PAR_ERROR
#define A_TP_MIB_TCP_OUT_RST
#define A_MAC_PORT_PERR_INT_EN_100G
#define A_PM_TX_STAT_CONFIG
#define A_MC_P_BIST_STATUS_RDATA
#define F_REQOVRLOOKUPINT
#define A_MPS_STAT_PERR_INT_ENABLE_RX_FIFO
#define F_T6_ACTCNTIPV6ZERO
#define A_TP_MIB_OFD_CHN_DROP_0
#define A_CIM_HOST_UPACC_INT_ENABLE
#define F_PBL_BOUND_ERR_CH2
#define F_PLCIM_MSTRSPDATAPARERR
#define A_MAC_PORT_PERR_INT_CAUSE
#define A_TP_DBG_LA_CONFIG
#define F_CIM_FRAMING_ERROR
#define A_TP_MIB_MAC_IN_ERR_0
#define A_MAC_PORT_PERR_INT_CAUSE_100G
#define F_ERR_BAD_DB_PIDX0
#define F_PCIE2CIMINTFPARERR
#define A_MPS_TRC_FILTER0_MATCH
#define V_POLADBGRDPTR(x)
#define A_MPS_PORT_STAT_RX_PORT_PAUSE_L
#define A_PCIE_CORE_UTL_PCI_EXPRESS_PORT_INTERRUPT_ENABLE
#define A_MPS_RX_PERR_INT_ENABLE
#define A_MPS_STAT_PERR_INT_ENABLE_SRAM
#define F_ERR_CPL_EXCEED_IQE_SIZE
#define A_MA_PARITY_ERROR_STATUS1
#define F_RSPOVRLOOKUPINT
#define A_SGE_INGRESS_RX_THRESHOLD
#define A_CIM_VF_EXT_MAILBOX_STATUS
#define F_T6_ACTCNTIPV6TZERO
#define A_MPS_VF_STAT_RX_VF_ERR_FRAMES_H
#define A_MPS_STAT_PERR_INT_CAUSE_RX_FIFO
#define A_EDC_BIST_CMD_ADDR
#define F_SGE2CIMINTFPARERR
#define A_MA_PARITY_ERROR_ENABLE1
#define A_ULP_RX_LA_RDDATA
#define A_MC_BIST_DATA_PATTERN
#define A_TP_TIMER_RESOLUTION
#define G_LKPTBLQUEUE0(x)
#define A_TP_MIB_FCOE_DROP_0
#define A_SGE_TIMER_VALUE_4_AND_5
#define A_SGE_DEBUG_DATA_LOW_INDEX_3
#define A_PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS
#define F_ERR_PCIE_ERROR2
#define F_ICSPI_PAR_ERROR
#define F_MSTTXFIFOPARINT
#define F_ZERO_C_CMD_ERROR
#define A_SGE_ERROR_STATS
#define A_SGE_DEBUG_DATA_LOW_INDEX_2
#define F_OCSPI_PAR_ERROR
#define A_SGE_FL_BUFFER_SIZE0
#define A_MPS_CLS_INT_CAUSE
#define A_TP_MIB_TCP_V6IN_ERR_0
#define A_MPS_TRC_FILTER0_DONT_CARE
#define V_TFINVERTMATCH(x)
#define A_TP_MIB_RQE_DFR_PKT
#define F_ERR_CPL_OPCODE_0
#define VF_PL_REG(reg_addr)
#define F_CIM_OP_MAP_PERR
#define A_MAC_PORT_PERR_INT_EN
#define A_MC_BIST_CMD_LEN
#define A_TP_RSS_LKP_TABLE
#define A_ULP_RX_INT_CAUSE_2
#define MYPF_REG(reg_addr)
#define A_MPS_STAT_PERR_INT_ENABLE_SRAM1
#define A_CIM_VF_EXT_MAILBOX_CTRL
#define A_ULP_RX_INT_ENABLE_2
#define G_DELAYEDACKRESOLUTION(x)
#define F_SE_CNT_MISMATCH_0
#define A_MAC_PORT_HSS_CFG0
#define G_EGRTHRESHOLD(x)
#define A_TP_MIB_OFD_VLN_DROP_0
#define F_MEM_WRAP_INT_CAUSE
#define A_EDC_H_BIST_CMD_LEN
#define A_SGE_TIMER_VALUE_0_AND_1
#define F_ERR_TIMER_ABOVE_MAX_QID
#define A_TP_TX_MOD_Q1_Q0_RATE_LIMIT
#define A_TP_MIB_CPL_OUT_RSP_0
#define V_TFCAPTUREMAX(x)
#define A_ULP_RX_INT_CAUSE
#define A_TP_MIB_TNL_LPBK_0
#define A_ULP_RX_LA_RDPTR
#define A_UP_UP_DBG_LA_CFG
#define G_INGPADBOUNDARY(x)
#define A_CIM_PF_HOST_INT_CAUSE
#define A_MAC_PORT_INT_EN
#define A_TP_MIB_TNL_CNG_DROP_0
#define F_ERROR_QID_VALID
#define A_SGE_HOST_PAGE_SIZE
#define A_PM_RX_STAT_CONFIG
#define A_TP_RSS_VFL_CONFIG
#define F_SGE_FRAMING_ERROR
#define A_MPS_STAT_PERR_INT_ENABLE_TX_FIFO
#define A_LE_DB_INT_CAUSE
#define A_CIM_IBQ_DBG_CFG
#define F_ULP2CIMINTFPARERR
#define A_MPS_TRC_FILTER1_MATCH
#define A_TP_MIB_OFD_ARP_DROP
#define M_QUEUESPERPAGEPF0
#define A_CIM_PF_MAILBOX_DATA
#define F_ERR_ING_CTXT_PRIO
#define A_XGMAC_PORT_INT_CAUSE
#define A_TP_DBG_LA_DATAL
#define F_OESPI_PAR_ERROR
#define A_PL_PL_INT_ENABLE
#define F_IPRXDATAGRPPERR
#define A_MAC_PORT_MAGIC_MACID_HI
#define F_PBL_BOUND_ERR_CH3
#define A_EDC_BIST_STATUS_RDATA
#define A_XGMAC_PORT_INT_EN
#define F_EGRSTATUSPAGESIZE
#define G_QUEFULLTHRSH(x)
#define A_CIM_PO_LA_MADEBUGDATA
#define A_CIM_PI_LA_MADEBUGDATA
#define T5_PORT_BASE(idx)
#define A_EDC_H_BIST_DATA_PATTERN
#define F_PERR_CPL_128TO128_0
#define A_MPS_CLS_INT_ENABLE
#define A_TP_PMM_TX_PAGE_SIZE
#define A_MPS_TRC_INT_CAUSE
#define A_XGMAC_PORT_MAGIC_MACID_HI
#define A_PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS
#define G_EGRTHRESHOLDPACKING(x)
#define A_PM_TX_STAT_COUNT
#define F_E_PCMD_PAR_ERROR
#define A_CIM_HOST_ACC_CTRL
#define A_ULP_RX_INT_ENABLE
#define F_ERR_EGR_CTXT_PRIO
#define A_MPS_TRC_FILTER_MATCH_CTL_A
#define A_MPS_RX_PERR_INT_CAUSE
#define M_HOSTPAGESIZEPF0
#define F_TIEQINPARERRINT
#define S_HOSTPAGESIZEPF1
#define A_MA_PARITY_ERROR_STATUS2
#define F_PBL_BOUND_ERR_CH0
#define F_ERR_PCIE_ERROR0
#define A_MPS_PORT_STAT_TX_PORT_BYTES_L
#define F_ERR_ITP_TIME_PAUSED
#define A_CIM_HOST_ACC_DATA
#define A_MA_PARITY_ERROR_ENABLE2
#define F_CIM_DM_PRTY_ERR
#define A_TP_RSS_VFH_CONFIG
#define A_SGE_VF_KDOORBELL
#define G_TFCAPTUREMAX(x)
#define F_T6_ACTCNTIPV4TZERO
#define A_PM_RX_DBG_STAT_MSB
#define F_PBL_BOUND_ERR_CH1
#define A_MC_BIST_CMD_ADDR
#define A_CIM_PI_LA_DEBUGDATA
#define F_IESPI_PAR_ERROR
#define G_TFMINPKTSIZE(x)
#define A_MPS_STAT_PERR_INT_CAUSE_SRAM1
#define F_T6_ACTCNTIPV4ZERO
#define A_TP_PMM_RX_PAGE_SIZE
#define A_PM_TX_DBG_STAT_MSB
#define A_CIM_OBQ_DBG_DATA
#define A_TP_MIB_FCOE_DDP_0
#define A_PM_TX_DBG_STAT0
#define F_ERR_BAD_DB_PIDX1
#define A_TP_MIB_TNL_OUT_PKT_0
#define V_QUENUMSELECT(x)
#define F_UNCAPTURED_ERROR
#define G_TIMERRESOLUTION(x)
#define VF_SGE_REG(reg_addr)
#define F_COUNTPAUSESTATTX
#define A_MC_BIST_STATUS_RDATA
#define F_TP2CIMINTFPARERR
#define A_ULP_RX_LA_WRPTR
#define A_CPL_INTR_ENABLE
#define A_TP_MIB_FCOE_BYTE_0_HI
#define VF_MPS_REG(reg_addr)
#define F_TP_FRAMING_ERROR
#define F_OBQSGERX0PARERR
#define A_SGE_INT_ENABLE4
#define A_SGE_EGRESS_QUEUES_PER_PAGE_PF
#define A_EDC_H_BIST_CMD_ADDR
#define F_COUNTPAUSESTATRX
#define A_MC_P_INT_ENABLE
#define A_PL_PL_INT_CAUSE
#define A_SGE_INT_ENABLE5
#define G_PILADBGWRPTR(x)
#define A_ULP_TX_INT_ENABLE_2
#define A_CIM_QUEUE_CONFIG_CTRL
#define A_CIM_HOST_UPACC_INT_CAUSE
#define V_T5_TFINVERTMATCH(x)
#define NUM_CIM_PF_MAILBOX_DATA_INSTANCES
#define A_SGE_INT_ENABLE6
#define A_EDC_H_ECC_ERR_ADDR
#define A_SGE_TIMER_VALUE_2_AND_3
#define A_ULP_TX_INT_CAUSE
#define G_MEM_WRAP_ADDRESS(x)
#define F_EGRESS_SIZE_ERR
#define F_MSTRXFIFOPARINT
#define A_TP_INGRESS_CONFIG
#define G_T6_EGRTHRESHOLDPACKING(x)
#define A_MPS_TRC_FILTER_MATCH_CTL_B
#define A_CIM_IBQ_DBG_DATA
#define EDC_REG(reg, idx)
#define A_XGMAC_PORT_HSS_CFG0
#define W_FT_FRAGMENTATION
#define X_INGPADBOUNDARY_SHIFT
#define X_T6_INGPADBOUNDARY_SHIFT
#define G_FW_PORT_CMD_MODTYPE(x)
#define V_FW_EQ_ETH_CMD_EQID(x)
#define V_FW_EQ_ETH_CMD_PFN(x)
#define V_FW_VI_MAC_CMD_VNI(x)
#define G_FW_VI_MAC_CMD_RAW_IDX(x)
@ FW_SCHED_PARAMS_UNIT_BITRATE
#define FW_VI_MAC_MAC_BASED_FREE
#define V_FW_ACL_VLAN_CMD_VFN(x)
#define V_FW_HELLO_CMD_MBASYNCNOT(x)
#define V_FW_PFVF_CMD_WX_CAPS(x)
#define FW_PORT_CAP32_FC_TX
#define V_FW_VI_RXMODE_CMD_VLANEXEN(x)
#define V_FW_RSS_VI_CONFIG_CMD_VIID(x)
#define V_FW_PARAMS_PARAM_FILTER_MASK(x)
#define F_FW_VI_ENABLE_CMD_LED
#define M_FW_PORT_CAP32_FEC
#define F_FW_RESET_CMD_HALT
#define V_FW_VI_MAC_CMD_DIP_HIT(x)
#define M_FW_VI_RXMODE_CMD_ALLMULTIEN
#define V_FW_VI_RXMODE_CMD_MTU(x)
#define V_FW_EQ_ETH_CMD_VFN(x)
#define V_FW_PFVF_CMD_NIQFLINT(x)
#define FW_PORT_CAP32_SPEED_1G
#define V_FW_PORT_CMD_PORTID(x)
#define V_FW_CMD_LEN16(x)
#define FW_PORT_CAP32_FEC_RS
static bool fec_supported(uint32_t caps)
#define V_FW_PARAMS_CMD_VFN(x)
#define FW_PORT_CAP32_FORCE_PAUSE
#define V_FW_PORT_CAP32_SPEED(x)
#define FW_CMD_HELLO_TIMEOUT
#define V_FW_PORT_CAP32_MDI(x)
#define F_FW_HELLO_CMD_ERR
#define F_FW_LDST_CMD_CTXTFLUSH
#define G_FW_HELLO_CMD_MBMASTER(x)
@ FW_LDST_ADDRSPC_SGE_INGC
@ FW_LDST_ADDRSPC_SGE_CONMC
@ FW_LDST_ADDRSPC_SGE_FLMC
@ FW_LDST_ADDRSPC_SGE_EGRC
@ FW_LDST_ADDRSPC_TP_TM_PIO
@ FW_LDST_ADDRSPC_FUNC_PCIE
@ FW_LDST_ADDRSPC_FIRMWARE
#define V_FW_VI_CMD_PORTID(x)
#define V_FW_VI_MAC_CMD_IDX(x)
#define G_FW_PARAMS_PARAM_FILTER_MODE(x)
#define V_FW_VI_MAC_CMD_ENTRY_TYPE(x)
#define V_FW_FILTER_WR_NOREPLY(x)
@ FW_VNIC_MODE_OUTER_VLAN
#define M_FW_PORT_CAP32_SPEED
#define G_FW_PORT_CMD_PORTID(x)
@ FW_PORT_ACTION_GET_PORT_INFO
@ FW_PORT_ACTION_L1_CFG32
@ FW_PORT_ACTION_GET_PORT_INFO32
#define G_FW_PORT_CMD_MDIOADDR(x)
#define F_FW_VI_MAC_CMD_VALID
#define V_FW_EQ_OFLD_CMD_VFN(x)
#define V_FW_PFVF_CMD_TC(x)
#define G_FW_DEVLOG_CMD_MEMADDR16_DEVLOG(x)
#define FW_VI_MAC_ID_BASED_FREE
#define V_FW_EQ_OFLD_CMD_EQID(x)
#define V_FW_VI_RXMODE_CMD_VIID(x)
#define V_FW_VI_RXMODE_CMD_ALLMULTIEN(x)
#define FW_PORT_CAP32_FEC_NO_FEC
#define V_FW_PFVF_CMD_CMASK(x)
#define V_FW_PFVF_CMD_VFN(x)
#define V_FW_ACL_MAC_CMD_PFN(x)
#define FW_PORT_CAP32_ANEG
#define V_FW_HDR_FW_VER_MICRO(x)
#define V_FW_RSS_IND_TBL_CMD_VIID(x)
#define V_FW_PFVF_CMD_NETHCTRL(x)
#define V_FW_LDST_CMD_FN(x)
#define V_FW_VI_MAC_CMD_RAW_IDX(x)
#define FW_CMD_HELLO_RETRIES
#define FW_RSS_GLB_CONFIG_CMD_MODE_MANUAL
#define V_FW_PFVF_CMD_NEQ(x)
#define FW_PORT_CAP32_SPEED_100G
#define M_FW_VI_RXMODE_CMD_PROMISCEN
@ FW_VI_MAC_TYPE_EXACTMAC_VNI
@ FW_VI_MAC_TYPE_EXACTMAC
#define V_FW_PARAMS_PARAM_Y(x)
#define FW_PORT_CAP32_FC_RX
#define F_FW_FILTER_WR_DEL_FILTER
#define F_FW_ACL_VLAN_CMD_EN
#define V_FW_PFVF_CMD_NVI(x)
#define V_FW_HELLO_CMD_MBMASTER(x)
#define V_FW_FILTER_WR_TID(x)
#define V_FW_HDR_FW_VER_MINOR(x)
#define V_FW_RSS_GLB_CONFIG_CMD_MODE(x)
#define FW_PORT_CAP32_FORCE_FEC
#define F_FW_HELLO_CMD_CLEARINIT
#define V_FW_PARAMS_PARAM_YZ(x)
#define G_FW_DEVLOG_CMD_MEMTYPE_DEVLOG(x)
#define M_FW_VI_RXMODE_CMD_MTU
#define F_FW_PORT_CMD_TXPAUSE
#define FW_PORT_CAP32_SPEED_10G
#define V_FW_RSS_IND_TBL_CMD_IQ2(x)
#define G_PCIE_FW_EVAL(x)
#define F_FW_VI_CMD_NORSS
#define F_FW_PORT_CMD_RXPAUSE
#define V_FW_CMD_RETVAL(x)
#define V_FW_HELLO_CMD_STAGE(x)
#define F_FW_ACL_VLAN_CMD_DROPNOVLAN
#define G_FW_PORT_CMD_ACTION(x)
#define G_PCIE_FW_PF_DEVLOG_MEMTYPE(x)
#define FW_T4VF_MBDATA_BASE_ADDR
#define G_FW_PARAMS_PARAM_FILTER_MASK(x)
#define G_FW_PORT_CMD_MDIOADDR32(x)
@ FW_PARAMS_PARAM_DEV_RSSINFO
@ FW_PARAMS_PARAM_DEV_TPCHMAP
@ FW_PARAMS_PARAM_DEV_FILTER
@ FW_PARAMS_PARAM_DEV_RING_BACKBONE
@ FW_PARAMS_PARAM_DEV_VPDREV
@ FW_PARAMS_PARAM_DEV_FWCACHE
@ FW_PARAMS_PARAM_DEV_SCFGREV
@ FW_PARAMS_PARAM_DEV_MCINIT
@ FW_PARAMS_PARAM_DEV_ADD_SMAC
#define G_FW_CMD_RETVAL(x)
#define G_FW_VI_CMD_VFVLD(x)
#define FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL
#define V_FW_PFVF_CMD_R_CAPS(x)
#define V_FW_FILTER_WR_RX_RPL_IQ(x)
#define F_FW_EQ_ETH_CMD_EQSTOP
#define V_FW_VI_RXMODE_CMD_PROMISCEN(x)
#define V_FW_PFVF_CMD_NEXACTF(x)
#define V_FW_IQ_CMD_PFN(x)
#define V_FW_VI_CMD_VIID(x)
#define F_FW_IQ_CMD_IQSTOP
#define F_FW_PORT_CMD_LSTATUS32
#define V_FW_PORT_CAP32_FEC(x)
#define FW_T6VF_MBDATA_BASE_ADDR
#define F_FW_HELLO_CMD_INIT
#define V_FW_VI_RXMODE_CMD_BROADCASTEN(x)
#define F_FW_EQ_CTRL_CMD_FREE
#define FW_PORT_CAP32_SPEED_50G
#define V_FW_VI_ENABLE_CMD_VIID(x)
#define V_FW_VI_MAC_CMD_VNI_MASK(x)
#define V_FW_IQ_CMD_TYPE(x)
#define G_FW_PORT_CMD_PORTTYPE32(x)
#define FW_PORT_CAP32_FEC_BASER_RS
#define F_FW_EQ_ETH_CMD_FREE
#define FW_VI_MAC_ADD_MAC
#define F_PCIE_FW_MASTER_VLD
#define V_FW_HELLO_CMD_MASTERDIS(x)
#define G_FW_VI_MAC_CMD_IDX(x)
#define V_FW_VI_ENABLE_CMD_IEN(x)
#define V_FW_VI_MAC_CMD_HASHUNIEN(x)
#define V_FW_PARAMS_MNEM(x)
#define V_FW_LDST_CMD_ADDRSPACE(x)
#define V_FW_PORT_CMD_LSPEED(x)
#define G_PCIE_FW_PF_DEVLOG_ADDR16(x)
#define V_FW_VI_CMD_VFN(x)
#define F_FW_VI_MAC_CMD_IS_SMAC
#define V_FW_PFVF_CMD_PMASK(x)
#define G_FW_VI_CMD_VIN(x)
#define V_FW_VI_CMD_TYPE(x)
#define V_FW_LDST_CMD_MMD(x)
#define V_FW_RSS_VI_CONFIG_CMD_DEFAULTQ(x)
#define G_FW_PORT_CMD_MODTYPE32(x)
#define PCIE_FW_PF_DEVLOG
#define V_FW_RSS_IND_TBL_CMD_IQ1(x)
#define V_FW_RSS_VI_CONFIG_CMD_SECRETKEYIDX(x)
#define V_FW_PORT_CMD_ACTION(x)
#define G_FW_PORT_CMD_LINKDNRC32(x)
#define G_FW_VI_MAC_CMD_SMTID(x)
#define F_FW_PORT_CMD_MDIOCAP32
#define FW_PORT_CAP32_SPEED_100M
#define G_FW_PORT_CMD_PTYPE(x)
#define V_FW_EQ_CTRL_CMD_EQID(x)
#define M_FW_VI_RXMODE_CMD_VLANEXEN
#define V_FW_HELLO_CMD_MASTERFORCE(x)
#define V_FW_VI_MAC_CMD_SMAC_RESULT(x)
#define F_FW_VI_CMD_ALLOC
#define F_FW_EQ_OFLD_CMD_FREE
#define FW_PORT_CAP32_SPEED_40G
#define V_FW_HDR_FW_VER_BUILD(x)
@ FW_SCHED_PARAMS_LEVEL_CL_RL
@ FW_SCHED_PARAMS_LEVEL_CH_RL
@ FW_SCHED_PARAMS_LEVEL_CL_WRR
#define V_FW_VI_ENABLE_CMD_EEN(x)
#define G_FW_VI_CMD_RSSSIZE(x)
#define V_FW_VI_MAC_CMD_VIID(x)
#define G_PCIE_FW_PF_DEVLOG_NENTRIES128(x)
#define V_FW_EQ_CTRL_CMD_VFN(x)
#define G_FW_PORT_CMD_LINKDNRC(x)
fw_params_param_dev_fwcache
#define V_FW_PARAMS_PARAM_X(x)
#define V_FW_HDR_FW_VER_MAJOR(x)
#define G_FW_VI_CMD_VIID(x)
#define FW_T4VF_REGMAP_SIZE
#define G_FW_VIID_VIVLD(x)
@ FW_SCHED_PARAMS_RATE_ABS
#define V_FW_LDST_CMD_NACCESS(x)
#define V_FW_VI_ENABLE_CMD_DCB_INFO(x)
@ FW_VI_MAC_MPS_TCAM_ENTRY
@ FW_VI_MAC_SMT_AND_MPSTCAM
#define V_FW_VI_CMD_FUNC(x)
#define M_FW_HELLO_CMD_MBMASTER
#define G_PCIE_FW_MASTER(x)
#define V_FW_VI_CMD_PFN(x)
#define V_FW_PARAMS_PARAM_FILTER_MODE(x)
#define V_FW_IQ_CMD_VFN(x)
#define V_FW_RSS_IND_TBL_CMD_IQ0(x)
#define F_FW_PORT_CMD_LSTATUS
#define V_FW_EQ_CTRL_CMD_PFN(x)
#define V_FW_PARAMS_CMD_PFN(x)
#define FW_CMD_MAX_TIMEOUT
#define F_FW_PORT_CMD_MDIOCAP
#define V_FW_PFVF_CMD_NIQ(x)
#define V_FW_ACL_MAC_CMD_VFN(x)
#define V_FW_PFVF_CMD_PFN(x)
#define FW_PORT_CAP32_SPEED_25G
@ FW_PARAM_DEV_FILTER_VNIC_MODE
@ FW_PARAM_DEV_FILTER_MODE_MASK
#define V_FW_VI_MAC_CMD_LOOKUP_TYPE(x)
#define F_FW_ACL_VLAN_CMD_FM
#define FW_LEN16(fw_struct)
#define V_FW_EQ_OFLD_CMD_PFN(x)
#define V_FW_ACL_VLAN_CMD_PFN(x)
#define V_FW_LDST_CMD_PADDR(x)
#define FW_VI_MAC_ADD_PERSIST_MAC
#define M_FW_VI_RXMODE_CMD_BROADCASTEN
#define V_FW_VI_MAC_CMD_FREEMACS(x)
struct fw_debug_cmd::fw_debug::fw_debug_assert assert
struct fw_ldst_cmd::fw_ldst::fw_ldst_idctxt idctxt
struct fw_ldst_cmd::fw_ldst::fw_ldst_addrval addrval
struct fw_ldst_cmd::fw_ldst::fw_ldst_i2c i2c
struct fw_ldst_cmd::fw_ldst::fw_ldst_mdio mdio
struct fw_ldst_cmd::fw_ldst::fw_ldst_pcie pcie
struct fw_port_cmd::fw_port::fw_port_l1cfg32 l1cfg32
struct fw_port_cmd::fw_port::fw_port_info info
struct fw_port_cmd::fw_port::fw_port_info32 info32
struct fw_port_cmd::fw_port::fw_port_l1cfg l1cfg
struct fw_sched_cmd::fw_sched::fw_sched_params params
struct fw_sched_cmd::fw_sched::fw_sched_config config
struct fw_vi_mac_cmd::fw_vi_mac::fw_vi_mac_vni exact_vni[2]
struct fw_vi_mac_cmd::fw_vi_mac::fw_vi_mac_hash hash
struct fw_vi_mac_cmd::fw_vi_mac::fw_vi_mac_raw raw
struct fw_vi_mac_cmd::fw_vi_mac::fw_vi_mac_exact exact[7]