2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2012, 2016 Chelsio Communications, Inc.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
34 #include <sys/param.h>
35 #include <sys/eventhandler.h>
39 #include "t4_regs_values.h"
40 #include "firmware/t4fw_interface.h"
43 #define msleep(x) do { \
47 pause("t4hw", (x) * hz / 1000); \
51 * t4_wait_op_done_val - wait until an operation is completed
52 * @adapter: the adapter performing the operation
53 * @reg: the register to check for completion
54 * @mask: a single-bit field within @reg that indicates completion
55 * @polarity: the value of the field when the operation is completed
56 * @attempts: number of check iterations
57 * @delay: delay in usecs between iterations
58 * @valp: where to store the value of the register at completion time
60 * Wait until an operation is completed by checking a bit in a register
61 * up to @attempts times. If @valp is not NULL the value of the register
62 * at the time it indicated completion is stored there. Returns 0 if the
63 * operation completes and -EAGAIN otherwise.
65 static int t4_wait_op_done_val(struct adapter *adapter, int reg, u32 mask,
66 int polarity, int attempts, int delay, u32 *valp)
69 u32 val = t4_read_reg(adapter, reg);
71 if (!!(val & mask) == polarity) {
83 static inline int t4_wait_op_done(struct adapter *adapter, int reg, u32 mask,
84 int polarity, int attempts, int delay)
86 return t4_wait_op_done_val(adapter, reg, mask, polarity, attempts,
91 * t4_set_reg_field - set a register field to a value
92 * @adapter: the adapter to program
93 * @addr: the register address
94 * @mask: specifies the portion of the register to modify
95 * @val: the new value for the register field
97 * Sets a register field specified by the supplied mask to the
100 void t4_set_reg_field(struct adapter *adapter, unsigned int addr, u32 mask,
103 u32 v = t4_read_reg(adapter, addr) & ~mask;
105 t4_write_reg(adapter, addr, v | val);
106 (void) t4_read_reg(adapter, addr); /* flush */
110 * t4_read_indirect - read indirectly addressed registers
112 * @addr_reg: register holding the indirect address
113 * @data_reg: register holding the value of the indirect register
114 * @vals: where the read register values are stored
115 * @nregs: how many indirect registers to read
116 * @start_idx: index of first indirect register to read
118 * Reads registers that are accessed indirectly through an address/data
121 void t4_read_indirect(struct adapter *adap, unsigned int addr_reg,
122 unsigned int data_reg, u32 *vals,
123 unsigned int nregs, unsigned int start_idx)
126 t4_write_reg(adap, addr_reg, start_idx);
127 *vals++ = t4_read_reg(adap, data_reg);
133 * t4_write_indirect - write indirectly addressed registers
135 * @addr_reg: register holding the indirect addresses
136 * @data_reg: register holding the value for the indirect registers
137 * @vals: values to write
138 * @nregs: how many indirect registers to write
139 * @start_idx: address of first indirect register to write
141 * Writes a sequential block of registers that are accessed indirectly
142 * through an address/data register pair.
144 void t4_write_indirect(struct adapter *adap, unsigned int addr_reg,
145 unsigned int data_reg, const u32 *vals,
146 unsigned int nregs, unsigned int start_idx)
149 t4_write_reg(adap, addr_reg, start_idx++);
150 t4_write_reg(adap, data_reg, *vals++);
155 * Read a 32-bit PCI Configuration Space register via the PCI-E backdoor
156 * mechanism. This guarantees that we get the real value even if we're
157 * operating within a Virtual Machine and the Hypervisor is trapping our
158 * Configuration Space accesses.
160 * N.B. This routine should only be used as a last resort: the firmware uses
161 * the backdoor registers on a regular basis and we can end up
162 * conflicting with it's uses!
164 u32 t4_hw_pci_read_cfg4(adapter_t *adap, int reg)
166 u32 req = V_FUNCTION(adap->pf) | V_REGISTER(reg);
169 if (chip_id(adap) <= CHELSIO_T5)
177 t4_write_reg(adap, A_PCIE_CFG_SPACE_REQ, req);
178 val = t4_read_reg(adap, A_PCIE_CFG_SPACE_DATA);
181 * Reset F_ENABLE to 0 so reads of PCIE_CFG_SPACE_DATA won't cause a
182 * Configuration Space read. (None of the other fields matter when
183 * F_ENABLE is 0 so a simple register write is easier than a
184 * read-modify-write via t4_set_reg_field().)
186 t4_write_reg(adap, A_PCIE_CFG_SPACE_REQ, 0);
192 * t4_report_fw_error - report firmware error
195 * The adapter firmware can indicate error conditions to the host.
196 * If the firmware has indicated an error, print out the reason for
197 * the firmware error.
199 static void t4_report_fw_error(struct adapter *adap)
201 static const char *const reason[] = {
202 "Crash", /* PCIE_FW_EVAL_CRASH */
203 "During Device Preparation", /* PCIE_FW_EVAL_PREP */
204 "During Device Configuration", /* PCIE_FW_EVAL_CONF */
205 "During Device Initialization", /* PCIE_FW_EVAL_INIT */
206 "Unexpected Event", /* PCIE_FW_EVAL_UNEXPECTEDEVENT */
207 "Insufficient Airflow", /* PCIE_FW_EVAL_OVERHEAT */
208 "Device Shutdown", /* PCIE_FW_EVAL_DEVICESHUTDOWN */
209 "Reserved", /* reserved */
213 pcie_fw = t4_read_reg(adap, A_PCIE_FW);
214 if (pcie_fw & F_PCIE_FW_ERR)
215 CH_ERR(adap, "Firmware reports adapter error: %s\n",
216 reason[G_PCIE_FW_EVAL(pcie_fw)]);
220 * Get the reply to a mailbox command and store it in @rpl in big-endian order.
222 static void get_mbox_rpl(struct adapter *adap, __be64 *rpl, int nflit,
225 for ( ; nflit; nflit--, mbox_addr += 8)
226 *rpl++ = cpu_to_be64(t4_read_reg64(adap, mbox_addr));
230 * Handle a FW assertion reported in a mailbox.
232 static void fw_asrt(struct adapter *adap, struct fw_debug_cmd *asrt)
235 "FW assertion at %.16s:%u, val0 %#x, val1 %#x\n",
236 asrt->u.assert.filename_0_7,
237 be32_to_cpu(asrt->u.assert.line),
238 be32_to_cpu(asrt->u.assert.x),
239 be32_to_cpu(asrt->u.assert.y));
242 struct port_tx_state {
248 read_tx_state_one(struct adapter *sc, int i, struct port_tx_state *tx_state)
250 uint32_t rx_pause_reg, tx_frames_reg;
253 tx_frames_reg = PORT_REG(i, A_MPS_PORT_STAT_TX_PORT_FRAMES_L);
254 rx_pause_reg = PORT_REG(i, A_MPS_PORT_STAT_RX_PORT_PAUSE_L);
256 tx_frames_reg = T5_PORT_REG(i, A_MPS_PORT_STAT_TX_PORT_FRAMES_L);
257 rx_pause_reg = T5_PORT_REG(i, A_MPS_PORT_STAT_RX_PORT_PAUSE_L);
260 tx_state->rx_pause = t4_read_reg64(sc, rx_pause_reg);
261 tx_state->tx_frames = t4_read_reg64(sc, tx_frames_reg);
265 read_tx_state(struct adapter *sc, struct port_tx_state *tx_state)
270 read_tx_state_one(sc, i, &tx_state[i]);
274 check_tx_state(struct adapter *sc, struct port_tx_state *tx_state)
276 uint32_t port_ctl_reg;
277 uint64_t tx_frames, rx_pause;
280 for_each_port(sc, i) {
281 rx_pause = tx_state[i].rx_pause;
282 tx_frames = tx_state[i].tx_frames;
283 read_tx_state_one(sc, i, &tx_state[i]); /* update */
286 port_ctl_reg = PORT_REG(i, A_MPS_PORT_CTL);
288 port_ctl_reg = T5_PORT_REG(i, A_MPS_PORT_CTL);
289 if (t4_read_reg(sc, port_ctl_reg) & F_PORTTXEN &&
290 rx_pause != tx_state[i].rx_pause &&
291 tx_frames == tx_state[i].tx_frames) {
292 t4_set_reg_field(sc, port_ctl_reg, F_PORTTXEN, 0);
294 t4_set_reg_field(sc, port_ctl_reg, F_PORTTXEN, F_PORTTXEN);
299 #define X_CIM_PF_NOACCESS 0xeeeeeeee
301 * t4_wr_mbox_meat_timeout - send a command to FW through the given mailbox
303 * @mbox: index of the mailbox to use
304 * @cmd: the command to write
305 * @size: command length in bytes
306 * @rpl: where to optionally store the reply
307 * @sleep_ok: if true we may sleep while awaiting command completion
308 * @timeout: time to wait for command to finish before timing out
309 * (negative implies @sleep_ok=false)
311 * Sends the given command to FW through the selected mailbox and waits
312 * for the FW to execute the command. If @rpl is not %NULL it is used to
313 * store the FW's reply to the command. The command and its optional
314 * reply are of the same length. Some FW commands like RESET and
315 * INITIALIZE can take a considerable amount of time to execute.
316 * @sleep_ok determines whether we may sleep while awaiting the response.
317 * If sleeping is allowed we use progressive backoff otherwise we spin.
318 * Note that passing in a negative @timeout is an alternate mechanism
319 * for specifying @sleep_ok=false. This is useful when a higher level
320 * interface allows for specification of @timeout but not @sleep_ok ...
322 * The return value is 0 on success or a negative errno on failure. A
323 * failure can happen either because we are not able to execute the
324 * command or FW executes it but signals an error. In the latter case
325 * the return value is the error code indicated by FW (negated).
327 int t4_wr_mbox_meat_timeout(struct adapter *adap, int mbox, const void *cmd,
328 int size, void *rpl, bool sleep_ok, int timeout)
331 * We delay in small increments at first in an effort to maintain
332 * responsiveness for simple, fast executing commands but then back
333 * off to larger delays to a maximum retry delay.
335 static const int delay[] = {
336 1, 1, 3, 5, 10, 10, 20, 50, 100
340 int i, ms, delay_idx, ret, next_tx_check;
341 const __be64 *p = cmd;
342 u32 data_reg = PF_REG(mbox, A_CIM_PF_MAILBOX_DATA);
343 u32 ctl_reg = PF_REG(mbox, A_CIM_PF_MAILBOX_CTRL);
345 __be64 cmd_rpl[MBOX_LEN/8];
347 struct port_tx_state tx_state[MAX_NPORTS];
349 if (adap->flags & CHK_MBOX_ACCESS)
350 ASSERT_SYNCHRONIZED_OP(adap);
352 if ((size & 15) || size > MBOX_LEN)
355 if (adap->flags & IS_VF) {
357 data_reg = FW_T6VF_MBDATA_BASE_ADDR;
359 data_reg = FW_T4VF_MBDATA_BASE_ADDR;
360 ctl_reg = VF_CIM_REG(A_CIM_VF_EXT_MAILBOX_CTRL);
364 * If we have a negative timeout, that implies that we can't sleep.
372 * Attempt to gain access to the mailbox.
374 for (i = 0; i < 4; i++) {
375 ctl = t4_read_reg(adap, ctl_reg);
377 if (v != X_MBOWNER_NONE)
382 * If we were unable to gain access, dequeue ourselves from the
383 * mailbox atomic access list and report the error to our caller.
385 if (v != X_MBOWNER_PL) {
386 t4_report_fw_error(adap);
387 ret = (v == X_MBOWNER_FW) ? -EBUSY : -ETIMEDOUT;
392 * If we gain ownership of the mailbox and there's a "valid" message
393 * in it, this is likely an asynchronous error message from the
394 * firmware. So we'll report that and then proceed on with attempting
395 * to issue our own command ... which may well fail if the error
396 * presaged the firmware crashing ...
398 if (ctl & F_MBMSGVALID) {
399 CH_ERR(adap, "found VALID command in mbox %u: %016llx %016llx "
400 "%016llx %016llx %016llx %016llx %016llx %016llx\n",
401 mbox, (unsigned long long)t4_read_reg64(adap, data_reg),
402 (unsigned long long)t4_read_reg64(adap, data_reg + 8),
403 (unsigned long long)t4_read_reg64(adap, data_reg + 16),
404 (unsigned long long)t4_read_reg64(adap, data_reg + 24),
405 (unsigned long long)t4_read_reg64(adap, data_reg + 32),
406 (unsigned long long)t4_read_reg64(adap, data_reg + 40),
407 (unsigned long long)t4_read_reg64(adap, data_reg + 48),
408 (unsigned long long)t4_read_reg64(adap, data_reg + 56));
412 * Copy in the new mailbox command and send it on its way ...
414 for (i = 0; i < size; i += 8, p++)
415 t4_write_reg64(adap, data_reg + i, be64_to_cpu(*p));
417 if (adap->flags & IS_VF) {
419 * For the VFs, the Mailbox Data "registers" are
420 * actually backed by T4's "MA" interface rather than
421 * PL Registers (as is the case for the PFs). Because
422 * these are in different coherency domains, the write
423 * to the VF's PL-register-backed Mailbox Control can
424 * race in front of the writes to the MA-backed VF
425 * Mailbox Data "registers". So we need to do a
426 * read-back on at least one byte of the VF Mailbox
427 * Data registers before doing the write to the VF
428 * Mailbox Control register.
430 t4_read_reg(adap, data_reg);
433 CH_DUMP_MBOX(adap, mbox, data_reg);
435 t4_write_reg(adap, ctl_reg, F_MBMSGVALID | V_MBOWNER(X_MBOWNER_FW));
436 read_tx_state(adap, &tx_state[0]); /* also flushes the write_reg */
437 next_tx_check = 1000;
442 * Loop waiting for the reply; bail out if we time out or the firmware
446 for (i = 0; i < timeout; i += ms) {
447 if (!(adap->flags & IS_VF)) {
448 pcie_fw = t4_read_reg(adap, A_PCIE_FW);
449 if (pcie_fw & F_PCIE_FW_ERR)
453 if (i >= next_tx_check) {
454 check_tx_state(adap, &tx_state[0]);
455 next_tx_check = i + 1000;
459 ms = delay[delay_idx]; /* last element may repeat */
460 if (delay_idx < ARRAY_SIZE(delay) - 1)
467 v = t4_read_reg(adap, ctl_reg);
468 if (v == X_CIM_PF_NOACCESS)
470 if (G_MBOWNER(v) == X_MBOWNER_PL) {
471 if (!(v & F_MBMSGVALID)) {
472 t4_write_reg(adap, ctl_reg,
473 V_MBOWNER(X_MBOWNER_NONE));
478 * Retrieve the command reply and release the mailbox.
480 get_mbox_rpl(adap, cmd_rpl, MBOX_LEN/8, data_reg);
481 t4_write_reg(adap, ctl_reg, V_MBOWNER(X_MBOWNER_NONE));
483 CH_DUMP_MBOX(adap, mbox, data_reg);
485 res = be64_to_cpu(cmd_rpl[0]);
486 if (G_FW_CMD_OP(res >> 32) == FW_DEBUG_CMD) {
487 fw_asrt(adap, (struct fw_debug_cmd *)cmd_rpl);
488 res = V_FW_CMD_RETVAL(EIO);
490 memcpy(rpl, cmd_rpl, size);
491 return -G_FW_CMD_RETVAL((int)res);
496 * We timed out waiting for a reply to our mailbox command. Report
497 * the error and also check to see if the firmware reported any
500 ret = (pcie_fw & F_PCIE_FW_ERR) ? -ENXIO : -ETIMEDOUT;
501 CH_ERR(adap, "command %#x in mailbox %d timed out\n",
502 *(const u8 *)cmd, mbox);
504 /* If DUMP_MBOX is set the mbox has already been dumped */
505 if ((adap->debug_flags & DF_DUMP_MBOX) == 0) {
507 CH_ERR(adap, "mbox: %016llx %016llx %016llx %016llx "
508 "%016llx %016llx %016llx %016llx\n",
509 (unsigned long long)be64_to_cpu(p[0]),
510 (unsigned long long)be64_to_cpu(p[1]),
511 (unsigned long long)be64_to_cpu(p[2]),
512 (unsigned long long)be64_to_cpu(p[3]),
513 (unsigned long long)be64_to_cpu(p[4]),
514 (unsigned long long)be64_to_cpu(p[5]),
515 (unsigned long long)be64_to_cpu(p[6]),
516 (unsigned long long)be64_to_cpu(p[7]));
519 t4_report_fw_error(adap);
524 int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size,
525 void *rpl, bool sleep_ok)
527 return t4_wr_mbox_meat_timeout(adap, mbox, cmd, size, rpl,
528 sleep_ok, FW_CMD_MAX_TIMEOUT);
532 static int t4_edc_err_read(struct adapter *adap, int idx)
534 u32 edc_ecc_err_addr_reg;
535 u32 edc_bist_status_rdata_reg;
538 CH_WARN(adap, "%s: T4 NOT supported.\n", __func__);
541 if (idx != MEM_EDC0 && idx != MEM_EDC1) {
542 CH_WARN(adap, "%s: idx %d NOT supported.\n", __func__, idx);
546 edc_ecc_err_addr_reg = EDC_T5_REG(A_EDC_H_ECC_ERR_ADDR, idx);
547 edc_bist_status_rdata_reg = EDC_T5_REG(A_EDC_H_BIST_STATUS_RDATA, idx);
550 "edc%d err addr 0x%x: 0x%x.\n",
551 idx, edc_ecc_err_addr_reg,
552 t4_read_reg(adap, edc_ecc_err_addr_reg));
554 "bist: 0x%x, status %llx %llx %llx %llx %llx %llx %llx %llx %llx.\n",
555 edc_bist_status_rdata_reg,
556 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg),
557 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 8),
558 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 16),
559 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 24),
560 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 32),
561 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 40),
562 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 48),
563 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 56),
564 (unsigned long long)t4_read_reg64(adap, edc_bist_status_rdata_reg + 64));
570 * t4_mc_read - read from MC through backdoor accesses
572 * @idx: which MC to access
573 * @addr: address of first byte requested
574 * @data: 64 bytes of data containing the requested address
575 * @ecc: where to store the corresponding 64-bit ECC word
577 * Read 64 bytes of data from MC starting at a 64-byte-aligned address
578 * that covers the requested address @addr. If @parity is not %NULL it
579 * is assigned the 64-bit ECC word for the read data.
581 int t4_mc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
584 u32 mc_bist_cmd_reg, mc_bist_cmd_addr_reg, mc_bist_cmd_len_reg;
585 u32 mc_bist_status_rdata_reg, mc_bist_data_pattern_reg;
588 mc_bist_cmd_reg = A_MC_BIST_CMD;
589 mc_bist_cmd_addr_reg = A_MC_BIST_CMD_ADDR;
590 mc_bist_cmd_len_reg = A_MC_BIST_CMD_LEN;
591 mc_bist_status_rdata_reg = A_MC_BIST_STATUS_RDATA;
592 mc_bist_data_pattern_reg = A_MC_BIST_DATA_PATTERN;
594 mc_bist_cmd_reg = MC_REG(A_MC_P_BIST_CMD, idx);
595 mc_bist_cmd_addr_reg = MC_REG(A_MC_P_BIST_CMD_ADDR, idx);
596 mc_bist_cmd_len_reg = MC_REG(A_MC_P_BIST_CMD_LEN, idx);
597 mc_bist_status_rdata_reg = MC_REG(A_MC_P_BIST_STATUS_RDATA,
599 mc_bist_data_pattern_reg = MC_REG(A_MC_P_BIST_DATA_PATTERN,
603 if (t4_read_reg(adap, mc_bist_cmd_reg) & F_START_BIST)
605 t4_write_reg(adap, mc_bist_cmd_addr_reg, addr & ~0x3fU);
606 t4_write_reg(adap, mc_bist_cmd_len_reg, 64);
607 t4_write_reg(adap, mc_bist_data_pattern_reg, 0xc);
608 t4_write_reg(adap, mc_bist_cmd_reg, V_BIST_OPCODE(1) |
609 F_START_BIST | V_BIST_CMD_GAP(1));
610 i = t4_wait_op_done(adap, mc_bist_cmd_reg, F_START_BIST, 0, 10, 1);
614 #define MC_DATA(i) MC_BIST_STATUS_REG(mc_bist_status_rdata_reg, i)
616 for (i = 15; i >= 0; i--)
617 *data++ = ntohl(t4_read_reg(adap, MC_DATA(i)));
619 *ecc = t4_read_reg64(adap, MC_DATA(16));
625 * t4_edc_read - read from EDC through backdoor accesses
627 * @idx: which EDC to access
628 * @addr: address of first byte requested
629 * @data: 64 bytes of data containing the requested address
630 * @ecc: where to store the corresponding 64-bit ECC word
632 * Read 64 bytes of data from EDC starting at a 64-byte-aligned address
633 * that covers the requested address @addr. If @parity is not %NULL it
634 * is assigned the 64-bit ECC word for the read data.
636 int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
639 u32 edc_bist_cmd_reg, edc_bist_cmd_addr_reg, edc_bist_cmd_len_reg;
640 u32 edc_bist_cmd_data_pattern, edc_bist_status_rdata_reg;
643 edc_bist_cmd_reg = EDC_REG(A_EDC_BIST_CMD, idx);
644 edc_bist_cmd_addr_reg = EDC_REG(A_EDC_BIST_CMD_ADDR, idx);
645 edc_bist_cmd_len_reg = EDC_REG(A_EDC_BIST_CMD_LEN, idx);
646 edc_bist_cmd_data_pattern = EDC_REG(A_EDC_BIST_DATA_PATTERN,
648 edc_bist_status_rdata_reg = EDC_REG(A_EDC_BIST_STATUS_RDATA,
652 * These macro are missing in t4_regs.h file.
653 * Added temporarily for testing.
655 #define EDC_STRIDE_T5 (EDC_T51_BASE_ADDR - EDC_T50_BASE_ADDR)
656 #define EDC_REG_T5(reg, idx) (reg + EDC_STRIDE_T5 * idx)
657 edc_bist_cmd_reg = EDC_REG_T5(A_EDC_H_BIST_CMD, idx);
658 edc_bist_cmd_addr_reg = EDC_REG_T5(A_EDC_H_BIST_CMD_ADDR, idx);
659 edc_bist_cmd_len_reg = EDC_REG_T5(A_EDC_H_BIST_CMD_LEN, idx);
660 edc_bist_cmd_data_pattern = EDC_REG_T5(A_EDC_H_BIST_DATA_PATTERN,
662 edc_bist_status_rdata_reg = EDC_REG_T5(A_EDC_H_BIST_STATUS_RDATA,
668 if (t4_read_reg(adap, edc_bist_cmd_reg) & F_START_BIST)
670 t4_write_reg(adap, edc_bist_cmd_addr_reg, addr & ~0x3fU);
671 t4_write_reg(adap, edc_bist_cmd_len_reg, 64);
672 t4_write_reg(adap, edc_bist_cmd_data_pattern, 0xc);
673 t4_write_reg(adap, edc_bist_cmd_reg,
674 V_BIST_OPCODE(1) | V_BIST_CMD_GAP(1) | F_START_BIST);
675 i = t4_wait_op_done(adap, edc_bist_cmd_reg, F_START_BIST, 0, 10, 1);
679 #define EDC_DATA(i) EDC_BIST_STATUS_REG(edc_bist_status_rdata_reg, i)
681 for (i = 15; i >= 0; i--)
682 *data++ = ntohl(t4_read_reg(adap, EDC_DATA(i)));
684 *ecc = t4_read_reg64(adap, EDC_DATA(16));
690 * t4_mem_read - read EDC 0, EDC 1 or MC into buffer
692 * @mtype: memory type: MEM_EDC0, MEM_EDC1 or MEM_MC
693 * @addr: address within indicated memory type
694 * @len: amount of memory to read
695 * @buf: host memory buffer
697 * Reads an [almost] arbitrary memory region in the firmware: the
698 * firmware memory address, length and host buffer must be aligned on
699 * 32-bit boudaries. The memory is returned as a raw byte sequence from
700 * the firmware's memory. If this memory contains data structures which
701 * contain multi-byte integers, it's the callers responsibility to
702 * perform appropriate byte order conversions.
704 int t4_mem_read(struct adapter *adap, int mtype, u32 addr, u32 len,
707 u32 pos, start, end, offset;
711 * Argument sanity checks ...
713 if ((addr & 0x3) || (len & 0x3))
717 * The underlaying EDC/MC read routines read 64 bytes at a time so we
718 * need to round down the start and round up the end. We'll start
719 * copying out of the first line at (addr - start) a word at a time.
721 start = rounddown2(addr, 64);
722 end = roundup2(addr + len, 64);
723 offset = (addr - start)/sizeof(__be32);
725 for (pos = start; pos < end; pos += 64, offset = 0) {
729 * Read the chip's memory block and bail if there's an error.
731 if ((mtype == MEM_MC) || (mtype == MEM_MC1))
732 ret = t4_mc_read(adap, mtype - MEM_MC, pos, data, NULL);
734 ret = t4_edc_read(adap, mtype, pos, data, NULL);
739 * Copy the data into the caller's memory buffer.
741 while (offset < 16 && len > 0) {
742 *buf++ = data[offset++];
743 len -= sizeof(__be32);
751 * Return the specified PCI-E Configuration Space register from our Physical
752 * Function. We try first via a Firmware LDST Command (if fw_attach != 0)
753 * since we prefer to let the firmware own all of these registers, but if that
754 * fails we go for it directly ourselves.
756 u32 t4_read_pcie_cfg4(struct adapter *adap, int reg, int drv_fw_attach)
760 * If fw_attach != 0, construct and send the Firmware LDST Command to
761 * retrieve the specified PCI-E Configuration Space register.
763 if (drv_fw_attach != 0) {
764 struct fw_ldst_cmd ldst_cmd;
767 memset(&ldst_cmd, 0, sizeof(ldst_cmd));
768 ldst_cmd.op_to_addrspace =
769 cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
772 V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_FUNC_PCIE));
773 ldst_cmd.cycles_to_len16 = cpu_to_be32(FW_LEN16(ldst_cmd));
774 ldst_cmd.u.pcie.select_naccess = V_FW_LDST_CMD_NACCESS(1);
775 ldst_cmd.u.pcie.ctrl_to_fn =
776 (F_FW_LDST_CMD_LC | V_FW_LDST_CMD_FN(adap->pf));
777 ldst_cmd.u.pcie.r = reg;
780 * If the LDST Command succeeds, return the result, otherwise
781 * fall through to reading it directly ourselves ...
783 ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd, sizeof(ldst_cmd),
786 return be32_to_cpu(ldst_cmd.u.pcie.data[0]);
788 CH_WARN(adap, "Firmware failed to return "
789 "Configuration Space register %d, err = %d\n",
794 * Read the desired Configuration Space register via the PCI-E
795 * Backdoor mechanism.
797 return t4_hw_pci_read_cfg4(adap, reg);
801 * t4_get_regs_len - return the size of the chips register set
802 * @adapter: the adapter
804 * Returns the size of the chip's BAR0 register space.
806 unsigned int t4_get_regs_len(struct adapter *adapter)
808 unsigned int chip_version = chip_id(adapter);
810 switch (chip_version) {
812 if (adapter->flags & IS_VF)
813 return FW_T4VF_REGMAP_SIZE;
814 return T4_REGMAP_SIZE;
818 if (adapter->flags & IS_VF)
819 return FW_T4VF_REGMAP_SIZE;
820 return T5_REGMAP_SIZE;
824 "Unsupported chip version %d\n", chip_version);
829 * t4_get_regs - read chip registers into provided buffer
831 * @buf: register buffer
832 * @buf_size: size (in bytes) of register buffer
834 * If the provided register buffer isn't large enough for the chip's
835 * full register range, the register dump will be truncated to the
836 * register buffer's size.
838 void t4_get_regs(struct adapter *adap, u8 *buf, size_t buf_size)
840 static const unsigned int t4_reg_ranges[] = {
1299 static const unsigned int t4vf_reg_ranges[] = {
1300 VF_SGE_REG(A_SGE_VF_KDOORBELL), VF_SGE_REG(A_SGE_VF_GTS),
1301 VF_MPS_REG(A_MPS_VF_CTL),
1302 VF_MPS_REG(A_MPS_VF_STAT_RX_VF_ERR_FRAMES_H),
1303 VF_PL_REG(A_PL_VF_WHOAMI), VF_PL_REG(A_PL_VF_WHOAMI),
1304 VF_CIM_REG(A_CIM_VF_EXT_MAILBOX_CTRL),
1305 VF_CIM_REG(A_CIM_VF_EXT_MAILBOX_STATUS),
1306 FW_T4VF_MBDATA_BASE_ADDR,
1307 FW_T4VF_MBDATA_BASE_ADDR +
1308 ((NUM_CIM_PF_MAILBOX_DATA_INSTANCES - 1) * 4),
1311 static const unsigned int t5_reg_ranges[] = {
2078 static const unsigned int t5vf_reg_ranges[] = {
2079 VF_SGE_REG(A_SGE_VF_KDOORBELL), VF_SGE_REG(A_SGE_VF_GTS),
2080 VF_MPS_REG(A_MPS_VF_CTL),
2081 VF_MPS_REG(A_MPS_VF_STAT_RX_VF_ERR_FRAMES_H),
2082 VF_PL_REG(A_PL_VF_WHOAMI), VF_PL_REG(A_PL_VF_REVISION),
2083 VF_CIM_REG(A_CIM_VF_EXT_MAILBOX_CTRL),
2084 VF_CIM_REG(A_CIM_VF_EXT_MAILBOX_STATUS),
2085 FW_T4VF_MBDATA_BASE_ADDR,
2086 FW_T4VF_MBDATA_BASE_ADDR +
2087 ((NUM_CIM_PF_MAILBOX_DATA_INSTANCES - 1) * 4),
2090 static const unsigned int t6_reg_ranges[] = {
2651 static const unsigned int t6vf_reg_ranges[] = {
2652 VF_SGE_REG(A_SGE_VF_KDOORBELL), VF_SGE_REG(A_SGE_VF_GTS),
2653 VF_MPS_REG(A_MPS_VF_CTL),
2654 VF_MPS_REG(A_MPS_VF_STAT_RX_VF_ERR_FRAMES_H),
2655 VF_PL_REG(A_PL_VF_WHOAMI), VF_PL_REG(A_PL_VF_REVISION),
2656 VF_CIM_REG(A_CIM_VF_EXT_MAILBOX_CTRL),
2657 VF_CIM_REG(A_CIM_VF_EXT_MAILBOX_STATUS),
2658 FW_T6VF_MBDATA_BASE_ADDR,
2659 FW_T6VF_MBDATA_BASE_ADDR +
2660 ((NUM_CIM_PF_MAILBOX_DATA_INSTANCES - 1) * 4),
2663 u32 *buf_end = (u32 *)(buf + buf_size);
2664 const unsigned int *reg_ranges;
2665 int reg_ranges_size, range;
2666 unsigned int chip_version = chip_id(adap);
2669 * Select the right set of register ranges to dump depending on the
2670 * adapter chip type.
2672 switch (chip_version) {
2674 if (adap->flags & IS_VF) {
2675 reg_ranges = t4vf_reg_ranges;
2676 reg_ranges_size = ARRAY_SIZE(t4vf_reg_ranges);
2678 reg_ranges = t4_reg_ranges;
2679 reg_ranges_size = ARRAY_SIZE(t4_reg_ranges);
2684 if (adap->flags & IS_VF) {
2685 reg_ranges = t5vf_reg_ranges;
2686 reg_ranges_size = ARRAY_SIZE(t5vf_reg_ranges);
2688 reg_ranges = t5_reg_ranges;
2689 reg_ranges_size = ARRAY_SIZE(t5_reg_ranges);
2694 if (adap->flags & IS_VF) {
2695 reg_ranges = t6vf_reg_ranges;
2696 reg_ranges_size = ARRAY_SIZE(t6vf_reg_ranges);
2698 reg_ranges = t6_reg_ranges;
2699 reg_ranges_size = ARRAY_SIZE(t6_reg_ranges);
2705 "Unsupported chip version %d\n", chip_version);
2710 * Clear the register buffer and insert the appropriate register
2711 * values selected by the above register ranges.
2713 memset(buf, 0, buf_size);
2714 for (range = 0; range < reg_ranges_size; range += 2) {
2715 unsigned int reg = reg_ranges[range];
2716 unsigned int last_reg = reg_ranges[range + 1];
2717 u32 *bufp = (u32 *)(buf + reg);
2720 * Iterate across the register range filling in the register
2721 * buffer but don't write past the end of the register buffer.
2723 while (reg <= last_reg && bufp < buf_end) {
2724 *bufp++ = t4_read_reg(adap, reg);
2731 * Partial EEPROM Vital Product Data structure. The VPD starts with one ID
2732 * header followed by one or more VPD-R sections, each with its own header.
2740 struct t4_vpdr_hdr {
2746 * EEPROM reads take a few tens of us while writes can take a bit over 5 ms.
2748 #define EEPROM_DELAY 10 /* 10us per poll spin */
2749 #define EEPROM_MAX_POLL 5000 /* x 5000 == 50ms */
2751 #define EEPROM_STAT_ADDR 0x7bfc
2752 #define VPD_SIZE 0x800
2753 #define VPD_BASE 0x400
2754 #define VPD_BASE_OLD 0
2755 #define VPD_LEN 1024
2756 #define VPD_INFO_FLD_HDR_SIZE 3
2757 #define CHELSIO_VPD_UNIQUE_ID 0x82
2760 * Small utility function to wait till any outstanding VPD Access is complete.
2761 * We have a per-adapter state variable "VPD Busy" to indicate when we have a
2762 * VPD Access in flight. This allows us to handle the problem of having a
2763 * previous VPD Access time out and prevent an attempt to inject a new VPD
2764 * Request before any in-flight VPD reguest has completed.
2766 static int t4_seeprom_wait(struct adapter *adapter)
2768 unsigned int base = adapter->params.pci.vpd_cap_addr;
2772 * If no VPD Access is in flight, we can just return success right
2775 if (!adapter->vpd_busy)
2779 * Poll the VPD Capability Address/Flag register waiting for it
2780 * to indicate that the operation is complete.
2782 max_poll = EEPROM_MAX_POLL;
2786 udelay(EEPROM_DELAY);
2787 t4_os_pci_read_cfg2(adapter, base + PCI_VPD_ADDR, &val);
2790 * If the operation is complete, mark the VPD as no longer
2791 * busy and return success.
2793 if ((val & PCI_VPD_ADDR_F) == adapter->vpd_flag) {
2794 adapter->vpd_busy = 0;
2797 } while (--max_poll);
2800 * Failure! Note that we leave the VPD Busy status set in order to
2801 * avoid pushing a new VPD Access request into the VPD Capability till
2802 * the current operation eventually succeeds. It's a bug to issue a
2803 * new request when an existing request is in flight and will result
2804 * in corrupt hardware state.
2810 * t4_seeprom_read - read a serial EEPROM location
2811 * @adapter: adapter to read
2812 * @addr: EEPROM virtual address
2813 * @data: where to store the read data
2815 * Read a 32-bit word from a location in serial EEPROM using the card's PCI
2816 * VPD capability. Note that this function must be called with a virtual
2819 int t4_seeprom_read(struct adapter *adapter, u32 addr, u32 *data)
2821 unsigned int base = adapter->params.pci.vpd_cap_addr;
2825 * VPD Accesses must alway be 4-byte aligned!
2827 if (addr >= EEPROMVSIZE || (addr & 3))
2831 * Wait for any previous operation which may still be in flight to
2834 ret = t4_seeprom_wait(adapter);
2836 CH_ERR(adapter, "VPD still busy from previous operation\n");
2841 * Issue our new VPD Read request, mark the VPD as being busy and wait
2842 * for our request to complete. If it doesn't complete, note the
2843 * error and return it to our caller. Note that we do not reset the
2846 t4_os_pci_write_cfg2(adapter, base + PCI_VPD_ADDR, (u16)addr);
2847 adapter->vpd_busy = 1;
2848 adapter->vpd_flag = PCI_VPD_ADDR_F;
2849 ret = t4_seeprom_wait(adapter);
2851 CH_ERR(adapter, "VPD read of address %#x failed\n", addr);
2856 * Grab the returned data, swizzle it into our endianness and
2859 t4_os_pci_read_cfg4(adapter, base + PCI_VPD_DATA, data);
2860 *data = le32_to_cpu(*data);
2865 * t4_seeprom_write - write a serial EEPROM location
2866 * @adapter: adapter to write
2867 * @addr: virtual EEPROM address
2868 * @data: value to write
2870 * Write a 32-bit word to a location in serial EEPROM using the card's PCI
2871 * VPD capability. Note that this function must be called with a virtual
2874 int t4_seeprom_write(struct adapter *adapter, u32 addr, u32 data)
2876 unsigned int base = adapter->params.pci.vpd_cap_addr;
2882 * VPD Accesses must alway be 4-byte aligned!
2884 if (addr >= EEPROMVSIZE || (addr & 3))
2888 * Wait for any previous operation which may still be in flight to
2891 ret = t4_seeprom_wait(adapter);
2893 CH_ERR(adapter, "VPD still busy from previous operation\n");
2898 * Issue our new VPD Read request, mark the VPD as being busy and wait
2899 * for our request to complete. If it doesn't complete, note the
2900 * error and return it to our caller. Note that we do not reset the
2903 t4_os_pci_write_cfg4(adapter, base + PCI_VPD_DATA,
2905 t4_os_pci_write_cfg2(adapter, base + PCI_VPD_ADDR,
2906 (u16)addr | PCI_VPD_ADDR_F);
2907 adapter->vpd_busy = 1;
2908 adapter->vpd_flag = 0;
2909 ret = t4_seeprom_wait(adapter);
2911 CH_ERR(adapter, "VPD write of address %#x failed\n", addr);
2916 * Reset PCI_VPD_DATA register after a transaction and wait for our
2917 * request to complete. If it doesn't complete, return error.
2919 t4_os_pci_write_cfg4(adapter, base + PCI_VPD_DATA, 0);
2920 max_poll = EEPROM_MAX_POLL;
2922 udelay(EEPROM_DELAY);
2923 t4_seeprom_read(adapter, EEPROM_STAT_ADDR, &stats_reg);
2924 } while ((stats_reg & 0x1) && --max_poll);
2928 /* Return success! */
2933 * t4_eeprom_ptov - translate a physical EEPROM address to virtual
2934 * @phys_addr: the physical EEPROM address
2935 * @fn: the PCI function number
2936 * @sz: size of function-specific area
2938 * Translate a physical EEPROM address to virtual. The first 1K is
2939 * accessed through virtual addresses starting at 31K, the rest is
2940 * accessed through virtual addresses starting at 0.
2942 * The mapping is as follows:
2943 * [0..1K) -> [31K..32K)
2944 * [1K..1K+A) -> [ES-A..ES)
2945 * [1K+A..ES) -> [0..ES-A-1K)
2947 * where A = @fn * @sz, and ES = EEPROM size.
2949 int t4_eeprom_ptov(unsigned int phys_addr, unsigned int fn, unsigned int sz)
2952 if (phys_addr < 1024)
2953 return phys_addr + (31 << 10);
2954 if (phys_addr < 1024 + fn)
2955 return EEPROMSIZE - fn + phys_addr - 1024;
2956 if (phys_addr < EEPROMSIZE)
2957 return phys_addr - 1024 - fn;
2962 * t4_seeprom_wp - enable/disable EEPROM write protection
2963 * @adapter: the adapter
2964 * @enable: whether to enable or disable write protection
2966 * Enables or disables write protection on the serial EEPROM.
2968 int t4_seeprom_wp(struct adapter *adapter, int enable)
2970 return t4_seeprom_write(adapter, EEPROM_STAT_ADDR, enable ? 0xc : 0);
2974 * get_vpd_keyword_val - Locates an information field keyword in the VPD
2975 * @vpd: Pointer to buffered vpd data structure
2976 * @kw: The keyword to search for
2977 * @region: VPD region to search (starting from 0)
2979 * Returns the value of the information field keyword or
2980 * -ENOENT otherwise.
2982 static int get_vpd_keyword_val(const u8 *vpd, const char *kw, int region)
2985 unsigned int offset, len;
2986 const struct t4_vpdr_hdr *vpdr;
2988 offset = sizeof(struct t4_vpd_hdr);
2989 vpdr = (const void *)(vpd + offset);
2990 tag = vpdr->vpdr_tag;
2991 len = (u16)vpdr->vpdr_len[0] + ((u16)vpdr->vpdr_len[1] << 8);
2993 offset += sizeof(struct t4_vpdr_hdr) + len;
2994 vpdr = (const void *)(vpd + offset);
2995 if (++tag != vpdr->vpdr_tag)
2997 len = (u16)vpdr->vpdr_len[0] + ((u16)vpdr->vpdr_len[1] << 8);
2999 offset += sizeof(struct t4_vpdr_hdr);
3001 if (offset + len > VPD_LEN) {
3005 for (i = offset; i + VPD_INFO_FLD_HDR_SIZE <= offset + len;) {
3006 if (memcmp(vpd + i , kw , 2) == 0){
3007 i += VPD_INFO_FLD_HDR_SIZE;
3011 i += VPD_INFO_FLD_HDR_SIZE + vpd[i+2];
3019 * get_vpd_params - read VPD parameters from VPD EEPROM
3020 * @adapter: adapter to read
3021 * @p: where to store the parameters
3022 * @vpd: caller provided temporary space to read the VPD into
3024 * Reads card parameters stored in VPD EEPROM.
3026 static int get_vpd_params(struct adapter *adapter, struct vpd_params *p,
3027 uint16_t device_id, u32 *buf)
3030 int ec, sn, pn, na, md;
3032 const u8 *vpd = (const u8 *)buf;
3035 * Card information normally starts at VPD_BASE but early cards had
3038 ret = t4_seeprom_read(adapter, VPD_BASE, buf);
3043 * The VPD shall have a unique identifier specified by the PCI SIG.
3044 * For chelsio adapters, the identifier is 0x82. The first byte of a VPD
3045 * shall be CHELSIO_VPD_UNIQUE_ID (0x82). The VPD programming software
3046 * is expected to automatically put this entry at the
3047 * beginning of the VPD.
3049 addr = *vpd == CHELSIO_VPD_UNIQUE_ID ? VPD_BASE : VPD_BASE_OLD;
3051 for (i = 0; i < VPD_LEN; i += 4) {
3052 ret = t4_seeprom_read(adapter, addr + i, buf++);
3057 #define FIND_VPD_KW(var,name) do { \
3058 var = get_vpd_keyword_val(vpd, name, 0); \
3060 CH_ERR(adapter, "missing VPD keyword " name "\n"); \
3065 FIND_VPD_KW(i, "RV");
3066 for (csum = 0; i >= 0; i--)
3071 "corrupted VPD EEPROM, actual csum %u\n", csum);
3075 FIND_VPD_KW(ec, "EC");
3076 FIND_VPD_KW(sn, "SN");
3077 FIND_VPD_KW(pn, "PN");
3078 FIND_VPD_KW(na, "NA");
3081 memcpy(p->id, vpd + offsetof(struct t4_vpd_hdr, id_data), ID_LEN);
3083 memcpy(p->ec, vpd + ec, EC_LEN);
3085 i = vpd[sn - VPD_INFO_FLD_HDR_SIZE + 2];
3086 memcpy(p->sn, vpd + sn, min(i, SERNUM_LEN));
3088 i = vpd[pn - VPD_INFO_FLD_HDR_SIZE + 2];
3089 memcpy(p->pn, vpd + pn, min(i, PN_LEN));
3090 strstrip((char *)p->pn);
3091 i = vpd[na - VPD_INFO_FLD_HDR_SIZE + 2];
3092 memcpy(p->na, vpd + na, min(i, MACADDR_LEN));
3093 strstrip((char *)p->na);
3095 if (device_id & 0x80)
3096 return 0; /* Custom card */
3098 md = get_vpd_keyword_val(vpd, "VF", 1);
3100 snprintf(p->md, sizeof(p->md), "unknown");
3102 i = vpd[md - VPD_INFO_FLD_HDR_SIZE + 2];
3103 memcpy(p->md, vpd + md, min(i, MD_LEN));
3104 strstrip((char *)p->md);
3110 /* serial flash and firmware constants and flash config file constants */
3112 SF_ATTEMPTS = 10, /* max retries for SF operations */
3114 /* flash command opcodes */
3115 SF_PROG_PAGE = 2, /* program 256B page */
3116 SF_WR_DISABLE = 4, /* disable writes */
3117 SF_RD_STATUS = 5, /* read status register */
3118 SF_WR_ENABLE = 6, /* enable writes */
3119 SF_RD_DATA_FAST = 0xb, /* read flash */
3120 SF_RD_ID = 0x9f, /* read ID */
3121 SF_ERASE_SECTOR = 0xd8, /* erase 64KB sector */
3125 * sf1_read - read data from the serial flash
3126 * @adapter: the adapter
3127 * @byte_cnt: number of bytes to read
3128 * @cont: whether another operation will be chained
3129 * @lock: whether to lock SF for PL access only
3130 * @valp: where to store the read data
3132 * Reads up to 4 bytes of data from the serial flash. The location of
3133 * the read needs to be specified prior to calling this by issuing the
3134 * appropriate commands to the serial flash.
3136 static int sf1_read(struct adapter *adapter, unsigned int byte_cnt, int cont,
3137 int lock, u32 *valp)
3141 if (!byte_cnt || byte_cnt > 4)
3143 if (t4_read_reg(adapter, A_SF_OP) & F_BUSY)
3145 t4_write_reg(adapter, A_SF_OP,
3146 V_SF_LOCK(lock) | V_CONT(cont) | V_BYTECNT(byte_cnt - 1));
3147 ret = t4_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 5);
3149 *valp = t4_read_reg(adapter, A_SF_DATA);
3154 * sf1_write - write data to the serial flash
3155 * @adapter: the adapter
3156 * @byte_cnt: number of bytes to write
3157 * @cont: whether another operation will be chained
3158 * @lock: whether to lock SF for PL access only
3159 * @val: value to write
3161 * Writes up to 4 bytes of data to the serial flash. The location of
3162 * the write needs to be specified prior to calling this by issuing the
3163 * appropriate commands to the serial flash.
3165 static int sf1_write(struct adapter *adapter, unsigned int byte_cnt, int cont,
3168 if (!byte_cnt || byte_cnt > 4)
3170 if (t4_read_reg(adapter, A_SF_OP) & F_BUSY)
3172 t4_write_reg(adapter, A_SF_DATA, val);
3173 t4_write_reg(adapter, A_SF_OP, V_SF_LOCK(lock) |
3174 V_CONT(cont) | V_BYTECNT(byte_cnt - 1) | V_OP(1));
3175 return t4_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 5);
3179 * flash_wait_op - wait for a flash operation to complete
3180 * @adapter: the adapter
3181 * @attempts: max number of polls of the status register
3182 * @delay: delay between polls in ms
3184 * Wait for a flash operation to complete by polling the status register.
3186 static int flash_wait_op(struct adapter *adapter, int attempts, int delay)
3192 if ((ret = sf1_write(adapter, 1, 1, 1, SF_RD_STATUS)) != 0 ||
3193 (ret = sf1_read(adapter, 1, 0, 1, &status)) != 0)
3197 if (--attempts == 0)
3205 * t4_read_flash - read words from serial flash
3206 * @adapter: the adapter
3207 * @addr: the start address for the read
3208 * @nwords: how many 32-bit words to read
3209 * @data: where to store the read data
3210 * @byte_oriented: whether to store data as bytes or as words
3212 * Read the specified number of 32-bit words from the serial flash.
3213 * If @byte_oriented is set the read data is stored as a byte array
3214 * (i.e., big-endian), otherwise as 32-bit words in the platform's
3215 * natural endianness.
3217 int t4_read_flash(struct adapter *adapter, unsigned int addr,
3218 unsigned int nwords, u32 *data, int byte_oriented)
3222 if (addr + nwords * sizeof(u32) > adapter->params.sf_size || (addr & 3))
3225 addr = swab32(addr) | SF_RD_DATA_FAST;
3227 if ((ret = sf1_write(adapter, 4, 1, 0, addr)) != 0 ||
3228 (ret = sf1_read(adapter, 1, 1, 0, data)) != 0)
3231 for ( ; nwords; nwords--, data++) {
3232 ret = sf1_read(adapter, 4, nwords > 1, nwords == 1, data);
3234 t4_write_reg(adapter, A_SF_OP, 0); /* unlock SF */
3238 *data = (__force __u32)(cpu_to_be32(*data));
3244 * t4_write_flash - write up to a page of data to the serial flash
3245 * @adapter: the adapter
3246 * @addr: the start address to write
3247 * @n: length of data to write in bytes
3248 * @data: the data to write
3249 * @byte_oriented: whether to store data as bytes or as words
3251 * Writes up to a page of data (256 bytes) to the serial flash starting
3252 * at the given address. All the data must be written to the same page.
3253 * If @byte_oriented is set the write data is stored as byte stream
3254 * (i.e. matches what on disk), otherwise in big-endian.
3256 int t4_write_flash(struct adapter *adapter, unsigned int addr,
3257 unsigned int n, const u8 *data, int byte_oriented)
3260 u32 buf[SF_PAGE_SIZE / 4];
3261 unsigned int i, c, left, val, offset = addr & 0xff;
3263 if (addr >= adapter->params.sf_size || offset + n > SF_PAGE_SIZE)
3266 val = swab32(addr) | SF_PROG_PAGE;
3268 if ((ret = sf1_write(adapter, 1, 0, 1, SF_WR_ENABLE)) != 0 ||
3269 (ret = sf1_write(adapter, 4, 1, 1, val)) != 0)
3272 for (left = n; left; left -= c) {
3274 for (val = 0, i = 0; i < c; ++i)
3275 val = (val << 8) + *data++;
3278 val = cpu_to_be32(val);
3280 ret = sf1_write(adapter, c, c != left, 1, val);
3284 ret = flash_wait_op(adapter, 8, 1);
3288 t4_write_reg(adapter, A_SF_OP, 0); /* unlock SF */
3290 /* Read the page to verify the write succeeded */
3291 ret = t4_read_flash(adapter, addr & ~0xff, ARRAY_SIZE(buf), buf,
3296 if (memcmp(data - n, (u8 *)buf + offset, n)) {
3298 "failed to correctly write the flash page at %#x\n",
3305 t4_write_reg(adapter, A_SF_OP, 0); /* unlock SF */
3310 * t4_get_fw_version - read the firmware version
3311 * @adapter: the adapter
3312 * @vers: where to place the version
3314 * Reads the FW version from flash.
3316 int t4_get_fw_version(struct adapter *adapter, u32 *vers)
3318 return t4_read_flash(adapter, FLASH_FW_START +
3319 offsetof(struct fw_hdr, fw_ver), 1,
3324 * t4_get_bs_version - read the firmware bootstrap version
3325 * @adapter: the adapter
3326 * @vers: where to place the version
3328 * Reads the FW Bootstrap version from flash.
3330 int t4_get_bs_version(struct adapter *adapter, u32 *vers)
3332 return t4_read_flash(adapter, FLASH_FWBOOTSTRAP_START +
3333 offsetof(struct fw_hdr, fw_ver), 1,
3338 * t4_get_tp_version - read the TP microcode version
3339 * @adapter: the adapter
3340 * @vers: where to place the version
3342 * Reads the TP microcode version from flash.
3344 int t4_get_tp_version(struct adapter *adapter, u32 *vers)
3346 return t4_read_flash(adapter, FLASH_FW_START +
3347 offsetof(struct fw_hdr, tp_microcode_ver),
3352 * t4_get_exprom_version - return the Expansion ROM version (if any)
3353 * @adapter: the adapter
3354 * @vers: where to place the version
3356 * Reads the Expansion ROM header from FLASH and returns the version
3357 * number (if present) through the @vers return value pointer. We return
3358 * this in the Firmware Version Format since it's convenient. Return
3359 * 0 on success, -ENOENT if no Expansion ROM is present.
3361 int t4_get_exprom_version(struct adapter *adap, u32 *vers)
3363 struct exprom_header {
3364 unsigned char hdr_arr[16]; /* must start with 0x55aa */
3365 unsigned char hdr_ver[4]; /* Expansion ROM version */
3367 u32 exprom_header_buf[DIV_ROUND_UP(sizeof(struct exprom_header),
3371 ret = t4_read_flash(adap, FLASH_EXP_ROM_START,
3372 ARRAY_SIZE(exprom_header_buf), exprom_header_buf,
3377 hdr = (struct exprom_header *)exprom_header_buf;
3378 if (hdr->hdr_arr[0] != 0x55 || hdr->hdr_arr[1] != 0xaa)
3381 *vers = (V_FW_HDR_FW_VER_MAJOR(hdr->hdr_ver[0]) |
3382 V_FW_HDR_FW_VER_MINOR(hdr->hdr_ver[1]) |
3383 V_FW_HDR_FW_VER_MICRO(hdr->hdr_ver[2]) |
3384 V_FW_HDR_FW_VER_BUILD(hdr->hdr_ver[3]));
3389 * t4_get_scfg_version - return the Serial Configuration version
3390 * @adapter: the adapter
3391 * @vers: where to place the version
3393 * Reads the Serial Configuration Version via the Firmware interface
3394 * (thus this can only be called once we're ready to issue Firmware
3395 * commands). The format of the Serial Configuration version is
3396 * adapter specific. Returns 0 on success, an error on failure.
3398 * Note that early versions of the Firmware didn't include the ability
3399 * to retrieve the Serial Configuration version, so we zero-out the
3400 * return-value parameter in that case to avoid leaving it with
3403 * Also note that the Firmware will return its cached copy of the Serial
3404 * Initialization Revision ID, not the actual Revision ID as written in
3405 * the Serial EEPROM. This is only an issue if a new VPD has been written
3406 * and the Firmware/Chip haven't yet gone through a RESET sequence. So
3407 * it's best to defer calling this routine till after a FW_RESET_CMD has
3408 * been issued if the Host Driver will be performing a full adapter
3411 int t4_get_scfg_version(struct adapter *adapter, u32 *vers)
3416 scfgrev_param = (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
3417 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_SCFGREV));
3418 ret = t4_query_params(adapter, adapter->mbox, adapter->pf, 0,
3419 1, &scfgrev_param, vers);
3426 * t4_get_vpd_version - return the VPD version
3427 * @adapter: the adapter
3428 * @vers: where to place the version
3430 * Reads the VPD via the Firmware interface (thus this can only be called
3431 * once we're ready to issue Firmware commands). The format of the
3432 * VPD version is adapter specific. Returns 0 on success, an error on
3435 * Note that early versions of the Firmware didn't include the ability
3436 * to retrieve the VPD version, so we zero-out the return-value parameter
3437 * in that case to avoid leaving it with garbage in it.
3439 * Also note that the Firmware will return its cached copy of the VPD
3440 * Revision ID, not the actual Revision ID as written in the Serial
3441 * EEPROM. This is only an issue if a new VPD has been written and the
3442 * Firmware/Chip haven't yet gone through a RESET sequence. So it's best
3443 * to defer calling this routine till after a FW_RESET_CMD has been issued
3444 * if the Host Driver will be performing a full adapter initialization.
3446 int t4_get_vpd_version(struct adapter *adapter, u32 *vers)
3451 vpdrev_param = (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
3452 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_VPDREV));
3453 ret = t4_query_params(adapter, adapter->mbox, adapter->pf, 0,
3454 1, &vpdrev_param, vers);
3461 * t4_get_version_info - extract various chip/firmware version information
3462 * @adapter: the adapter
3464 * Reads various chip/firmware version numbers and stores them into the
3465 * adapter Adapter Parameters structure. If any of the efforts fails
3466 * the first failure will be returned, but all of the version numbers
3469 int t4_get_version_info(struct adapter *adapter)
3473 #define FIRST_RET(__getvinfo) \
3475 int __ret = __getvinfo; \
3476 if (__ret && !ret) \
3480 FIRST_RET(t4_get_fw_version(adapter, &adapter->params.fw_vers));
3481 FIRST_RET(t4_get_bs_version(adapter, &adapter->params.bs_vers));
3482 FIRST_RET(t4_get_tp_version(adapter, &adapter->params.tp_vers));
3483 FIRST_RET(t4_get_exprom_version(adapter, &adapter->params.er_vers));
3484 FIRST_RET(t4_get_scfg_version(adapter, &adapter->params.scfg_vers));
3485 FIRST_RET(t4_get_vpd_version(adapter, &adapter->params.vpd_vers));
3493 * t4_flash_erase_sectors - erase a range of flash sectors
3494 * @adapter: the adapter
3495 * @start: the first sector to erase
3496 * @end: the last sector to erase
3498 * Erases the sectors in the given inclusive range.
3500 int t4_flash_erase_sectors(struct adapter *adapter, int start, int end)
3504 if (end >= adapter->params.sf_nsec)
3507 while (start <= end) {
3508 if ((ret = sf1_write(adapter, 1, 0, 1, SF_WR_ENABLE)) != 0 ||
3509 (ret = sf1_write(adapter, 4, 0, 1,
3510 SF_ERASE_SECTOR | (start << 8))) != 0 ||
3511 (ret = flash_wait_op(adapter, 14, 500)) != 0) {
3513 "erase of flash sector %d failed, error %d\n",
3519 t4_write_reg(adapter, A_SF_OP, 0); /* unlock SF */
3524 * t4_flash_cfg_addr - return the address of the flash configuration file
3525 * @adapter: the adapter
3527 * Return the address within the flash where the Firmware Configuration
3528 * File is stored, or an error if the device FLASH is too small to contain
3529 * a Firmware Configuration File.
3531 int t4_flash_cfg_addr(struct adapter *adapter)
3534 * If the device FLASH isn't large enough to hold a Firmware
3535 * Configuration File, return an error.
3537 if (adapter->params.sf_size < FLASH_CFG_START + FLASH_CFG_MAX_SIZE)
3540 return FLASH_CFG_START;
3544 * Return TRUE if the specified firmware matches the adapter. I.e. T4
3545 * firmware for T4 adapters, T5 firmware for T5 adapters, etc. We go ahead
3546 * and emit an error message for mismatched firmware to save our caller the
3549 static int t4_fw_matches_chip(struct adapter *adap,
3550 const struct fw_hdr *hdr)
3553 * The expression below will return FALSE for any unsupported adapter
3554 * which will keep us "honest" in the future ...
3556 if ((is_t4(adap) && hdr->chip == FW_HDR_CHIP_T4) ||
3557 (is_t5(adap) && hdr->chip == FW_HDR_CHIP_T5) ||
3558 (is_t6(adap) && hdr->chip == FW_HDR_CHIP_T6))
3562 "FW image (%d) is not suitable for this adapter (%d)\n",
3563 hdr->chip, chip_id(adap));
3568 * t4_load_fw - download firmware
3569 * @adap: the adapter
3570 * @fw_data: the firmware image to write
3573 * Write the supplied firmware image to the card's serial flash.
3575 int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size)
3580 u8 first_page[SF_PAGE_SIZE];
3581 const u32 *p = (const u32 *)fw_data;
3582 const struct fw_hdr *hdr = (const struct fw_hdr *)fw_data;
3583 unsigned int sf_sec_size = adap->params.sf_size / adap->params.sf_nsec;
3584 unsigned int fw_start_sec;
3585 unsigned int fw_start;
3586 unsigned int fw_size;
3588 if (ntohl(hdr->magic) == FW_HDR_MAGIC_BOOTSTRAP) {
3589 fw_start_sec = FLASH_FWBOOTSTRAP_START_SEC;
3590 fw_start = FLASH_FWBOOTSTRAP_START;
3591 fw_size = FLASH_FWBOOTSTRAP_MAX_SIZE;
3593 fw_start_sec = FLASH_FW_START_SEC;
3594 fw_start = FLASH_FW_START;
3595 fw_size = FLASH_FW_MAX_SIZE;
3599 CH_ERR(adap, "FW image has no data\n");
3604 "FW image size not multiple of 512 bytes\n");
3607 if ((unsigned int) be16_to_cpu(hdr->len512) * 512 != size) {
3609 "FW image size differs from size in FW header\n");
3612 if (size > fw_size) {
3613 CH_ERR(adap, "FW image too large, max is %u bytes\n",
3617 if (!t4_fw_matches_chip(adap, hdr))
3620 for (csum = 0, i = 0; i < size / sizeof(csum); i++)
3621 csum += be32_to_cpu(p[i]);
3623 if (csum != 0xffffffff) {
3625 "corrupted firmware image, checksum %#x\n", csum);
3629 i = DIV_ROUND_UP(size, sf_sec_size); /* # of sectors spanned */
3630 ret = t4_flash_erase_sectors(adap, fw_start_sec, fw_start_sec + i - 1);
3635 * We write the correct version at the end so the driver can see a bad
3636 * version if the FW write fails. Start by writing a copy of the
3637 * first page with a bad version.
3639 memcpy(first_page, fw_data, SF_PAGE_SIZE);
3640 ((struct fw_hdr *)first_page)->fw_ver = cpu_to_be32(0xffffffff);
3641 ret = t4_write_flash(adap, fw_start, SF_PAGE_SIZE, first_page, 1);
3646 for (size -= SF_PAGE_SIZE; size; size -= SF_PAGE_SIZE) {
3647 addr += SF_PAGE_SIZE;
3648 fw_data += SF_PAGE_SIZE;
3649 ret = t4_write_flash(adap, addr, SF_PAGE_SIZE, fw_data, 1);
3654 ret = t4_write_flash(adap,
3655 fw_start + offsetof(struct fw_hdr, fw_ver),
3656 sizeof(hdr->fw_ver), (const u8 *)&hdr->fw_ver, 1);
3659 CH_ERR(adap, "firmware download failed, error %d\n",
3665 * t4_fwcache - firmware cache operation
3666 * @adap: the adapter
3667 * @op : the operation (flush or flush and invalidate)
3669 int t4_fwcache(struct adapter *adap, enum fw_params_param_dev_fwcache op)
3671 struct fw_params_cmd c;
3673 memset(&c, 0, sizeof(c));
3675 cpu_to_be32(V_FW_CMD_OP(FW_PARAMS_CMD) |
3676 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
3677 V_FW_PARAMS_CMD_PFN(adap->pf) |
3678 V_FW_PARAMS_CMD_VFN(0));
3679 c.retval_len16 = cpu_to_be32(FW_LEN16(c));
3681 cpu_to_be32(V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
3682 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_FWCACHE));
3683 c.param[0].val = (__force __be32)op;
3685 return t4_wr_mbox(adap, adap->mbox, &c, sizeof(c), NULL);
3688 void t4_cim_read_pif_la(struct adapter *adap, u32 *pif_req, u32 *pif_rsp,
3689 unsigned int *pif_req_wrptr,
3690 unsigned int *pif_rsp_wrptr)
3693 u32 cfg, val, req, rsp;
3695 cfg = t4_read_reg(adap, A_CIM_DEBUGCFG);
3696 if (cfg & F_LADBGEN)
3697 t4_write_reg(adap, A_CIM_DEBUGCFG, cfg ^ F_LADBGEN);
3699 val = t4_read_reg(adap, A_CIM_DEBUGSTS);
3700 req = G_POLADBGWRPTR(val);
3701 rsp = G_PILADBGWRPTR(val);
3703 *pif_req_wrptr = req;
3705 *pif_rsp_wrptr = rsp;
3707 for (i = 0; i < CIM_PIFLA_SIZE; i++) {
3708 for (j = 0; j < 6; j++) {
3709 t4_write_reg(adap, A_CIM_DEBUGCFG, V_POLADBGRDPTR(req) |
3710 V_PILADBGRDPTR(rsp));
3711 *pif_req++ = t4_read_reg(adap, A_CIM_PO_LA_DEBUGDATA);
3712 *pif_rsp++ = t4_read_reg(adap, A_CIM_PI_LA_DEBUGDATA);
3716 req = (req + 2) & M_POLADBGRDPTR;
3717 rsp = (rsp + 2) & M_PILADBGRDPTR;
3719 t4_write_reg(adap, A_CIM_DEBUGCFG, cfg);
3722 void t4_cim_read_ma_la(struct adapter *adap, u32 *ma_req, u32 *ma_rsp)
3727 cfg = t4_read_reg(adap, A_CIM_DEBUGCFG);
3728 if (cfg & F_LADBGEN)
3729 t4_write_reg(adap, A_CIM_DEBUGCFG, cfg ^ F_LADBGEN);
3731 for (i = 0; i < CIM_MALA_SIZE; i++) {
3732 for (j = 0; j < 5; j++) {
3734 t4_write_reg(adap, A_CIM_DEBUGCFG, V_POLADBGRDPTR(idx) |
3735 V_PILADBGRDPTR(idx));
3736 *ma_req++ = t4_read_reg(adap, A_CIM_PO_LA_MADEBUGDATA);
3737 *ma_rsp++ = t4_read_reg(adap, A_CIM_PI_LA_MADEBUGDATA);
3740 t4_write_reg(adap, A_CIM_DEBUGCFG, cfg);
3743 void t4_ulprx_read_la(struct adapter *adap, u32 *la_buf)
3747 for (i = 0; i < 8; i++) {
3748 u32 *p = la_buf + i;
3750 t4_write_reg(adap, A_ULP_RX_LA_CTL, i);
3751 j = t4_read_reg(adap, A_ULP_RX_LA_WRPTR);
3752 t4_write_reg(adap, A_ULP_RX_LA_RDPTR, j);
3753 for (j = 0; j < ULPRX_LA_SIZE; j++, p += 8)
3754 *p = t4_read_reg(adap, A_ULP_RX_LA_RDDATA);
3759 * fwcaps16_to_caps32 - convert 16-bit Port Capabilities to 32-bits
3760 * @caps16: a 16-bit Port Capabilities value
3762 * Returns the equivalent 32-bit Port Capabilities value.
3764 static uint32_t fwcaps16_to_caps32(uint16_t caps16)
3766 uint32_t caps32 = 0;
3768 #define CAP16_TO_CAP32(__cap) \
3770 if (caps16 & FW_PORT_CAP_##__cap) \
3771 caps32 |= FW_PORT_CAP32_##__cap; \
3774 CAP16_TO_CAP32(SPEED_100M);
3775 CAP16_TO_CAP32(SPEED_1G);
3776 CAP16_TO_CAP32(SPEED_25G);
3777 CAP16_TO_CAP32(SPEED_10G);
3778 CAP16_TO_CAP32(SPEED_40G);
3779 CAP16_TO_CAP32(SPEED_100G);
3780 CAP16_TO_CAP32(FC_RX);
3781 CAP16_TO_CAP32(FC_TX);
3782 CAP16_TO_CAP32(ANEG);
3783 CAP16_TO_CAP32(FORCE_PAUSE);
3784 CAP16_TO_CAP32(MDIAUTO);
3785 CAP16_TO_CAP32(MDISTRAIGHT);
3786 CAP16_TO_CAP32(FEC_RS);
3787 CAP16_TO_CAP32(FEC_BASER_RS);
3788 CAP16_TO_CAP32(802_3_PAUSE);
3789 CAP16_TO_CAP32(802_3_ASM_DIR);
3791 #undef CAP16_TO_CAP32
3797 * fwcaps32_to_caps16 - convert 32-bit Port Capabilities to 16-bits
3798 * @caps32: a 32-bit Port Capabilities value
3800 * Returns the equivalent 16-bit Port Capabilities value. Note that
3801 * not all 32-bit Port Capabilities can be represented in the 16-bit
3802 * Port Capabilities and some fields/values may not make it.
3804 static uint16_t fwcaps32_to_caps16(uint32_t caps32)
3806 uint16_t caps16 = 0;
3808 #define CAP32_TO_CAP16(__cap) \
3810 if (caps32 & FW_PORT_CAP32_##__cap) \
3811 caps16 |= FW_PORT_CAP_##__cap; \
3814 CAP32_TO_CAP16(SPEED_100M);
3815 CAP32_TO_CAP16(SPEED_1G);
3816 CAP32_TO_CAP16(SPEED_10G);
3817 CAP32_TO_CAP16(SPEED_25G);
3818 CAP32_TO_CAP16(SPEED_40G);
3819 CAP32_TO_CAP16(SPEED_100G);
3820 CAP32_TO_CAP16(FC_RX);
3821 CAP32_TO_CAP16(FC_TX);
3822 CAP32_TO_CAP16(802_3_PAUSE);
3823 CAP32_TO_CAP16(802_3_ASM_DIR);
3824 CAP32_TO_CAP16(ANEG);
3825 CAP32_TO_CAP16(FORCE_PAUSE);
3826 CAP32_TO_CAP16(MDIAUTO);
3827 CAP32_TO_CAP16(MDISTRAIGHT);
3828 CAP32_TO_CAP16(FEC_RS);
3829 CAP32_TO_CAP16(FEC_BASER_RS);
3831 #undef CAP32_TO_CAP16
3837 is_bt(struct port_info *pi)
3840 return (pi->port_type == FW_PORT_TYPE_BT_SGMII ||
3841 pi->port_type == FW_PORT_TYPE_BT_XFI ||
3842 pi->port_type == FW_PORT_TYPE_BT_XAUI);
3846 * t4_link_l1cfg - apply link configuration to MAC/PHY
3847 * @phy: the PHY to setup
3848 * @mac: the MAC to setup
3849 * @lc: the requested link configuration
3851 * Set up a port's MAC and PHY according to a desired link configuration.
3852 * - If the PHY can auto-negotiate first decide what to advertise, then
3853 * enable/disable auto-negotiation as desired, and reset.
3854 * - If the PHY does not auto-negotiate just reset it.
3855 * - If auto-negotiation is off set the MAC to the proper speed/duplex/FC,
3856 * otherwise do it later based on the outcome of auto-negotiation.
3858 int t4_link_l1cfg(struct adapter *adap, unsigned int mbox, unsigned int port,
3859 struct link_config *lc)
3861 struct fw_port_cmd c;
3862 unsigned int mdi = V_FW_PORT_CAP32_MDI(FW_PORT_CAP32_MDI_AUTO);
3863 unsigned int aneg, fc, fec, speed, rcap;
3866 if (lc->requested_fc & PAUSE_RX)
3867 fc |= FW_PORT_CAP32_FC_RX;
3868 if (lc->requested_fc & PAUSE_TX)
3869 fc |= FW_PORT_CAP32_FC_TX;
3870 if (!(lc->requested_fc & PAUSE_AUTONEG))
3871 fc |= FW_PORT_CAP32_FORCE_PAUSE;
3874 if (lc->requested_fec == FEC_AUTO)
3877 if (lc->requested_fec & FEC_RS)
3878 fec |= FW_PORT_CAP32_FEC_RS;
3879 if (lc->requested_fec & FEC_BASER_RS)
3880 fec |= FW_PORT_CAP32_FEC_BASER_RS;
3883 if (lc->requested_aneg == AUTONEG_DISABLE)
3885 else if (lc->requested_aneg == AUTONEG_ENABLE)
3886 aneg = FW_PORT_CAP32_ANEG;
3888 aneg = lc->supported & FW_PORT_CAP32_ANEG;
3891 speed = lc->supported & V_FW_PORT_CAP32_SPEED(M_FW_PORT_CAP32_SPEED);
3892 } else if (lc->requested_speed != 0)
3893 speed = speed_to_fwcap(lc->requested_speed);
3895 speed = fwcap_top_speed(lc->supported);
3897 /* Force AN on for BT cards. */
3898 if (is_bt(adap->port[port]))
3899 aneg = lc->supported & FW_PORT_CAP32_ANEG;
3901 rcap = aneg | speed | fc | fec;
3902 if ((rcap | lc->supported) != lc->supported) {
3904 CH_WARN(adap, "rcap 0x%08x, pcap 0x%08x\n", rcap,
3907 rcap &= lc->supported;
3911 memset(&c, 0, sizeof(c));
3912 c.op_to_portid = cpu_to_be32(V_FW_CMD_OP(FW_PORT_CMD) |
3913 F_FW_CMD_REQUEST | F_FW_CMD_EXEC |
3914 V_FW_PORT_CMD_PORTID(port));
3915 if (adap->params.port_caps32) {
3917 cpu_to_be32(V_FW_PORT_CMD_ACTION(FW_PORT_ACTION_L1_CFG32) |
3919 c.u.l1cfg32.rcap32 = cpu_to_be32(rcap);
3922 cpu_to_be32(V_FW_PORT_CMD_ACTION(FW_PORT_ACTION_L1_CFG) |
3924 c.u.l1cfg.rcap = cpu_to_be32(fwcaps32_to_caps16(rcap));
3927 return t4_wr_mbox_ns(adap, mbox, &c, sizeof(c), NULL);
3931 * t4_restart_aneg - restart autonegotiation
3932 * @adap: the adapter
3933 * @mbox: mbox to use for the FW command
3934 * @port: the port id
3936 * Restarts autonegotiation for the selected port.
3938 int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port)
3940 struct fw_port_cmd c;
3942 memset(&c, 0, sizeof(c));
3943 c.op_to_portid = cpu_to_be32(V_FW_CMD_OP(FW_PORT_CMD) |
3944 F_FW_CMD_REQUEST | F_FW_CMD_EXEC |
3945 V_FW_PORT_CMD_PORTID(port));
3947 cpu_to_be32(V_FW_PORT_CMD_ACTION(FW_PORT_ACTION_L1_CFG) |
3949 c.u.l1cfg.rcap = cpu_to_be32(FW_PORT_CAP_ANEG);
3950 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
3953 typedef void (*int_handler_t)(struct adapter *adap);
3956 unsigned int mask; /* bits to check in interrupt status */
3957 const char *msg; /* message to print or NULL */
3958 short stat_idx; /* stat counter to increment or -1 */
3959 unsigned short fatal; /* whether the condition reported is fatal */
3960 int_handler_t int_handler; /* platform-specific int handler */
3964 * t4_handle_intr_status - table driven interrupt handler
3965 * @adapter: the adapter that generated the interrupt
3966 * @reg: the interrupt status register to process
3967 * @acts: table of interrupt actions
3969 * A table driven interrupt handler that applies a set of masks to an
3970 * interrupt status word and performs the corresponding actions if the
3971 * interrupts described by the mask have occurred. The actions include
3972 * optionally emitting a warning or alert message. The table is terminated
3973 * by an entry specifying mask 0. Returns the number of fatal interrupt
3976 static int t4_handle_intr_status(struct adapter *adapter, unsigned int reg,
3977 const struct intr_info *acts)
3980 unsigned int mask = 0;
3981 unsigned int status = t4_read_reg(adapter, reg);
3983 for ( ; acts->mask; ++acts) {
3984 if (!(status & acts->mask))
3988 CH_ALERT(adapter, "%s (0x%x)\n", acts->msg,
3989 status & acts->mask);
3990 } else if (acts->msg)
3991 CH_WARN_RATELIMIT(adapter, "%s (0x%x)\n", acts->msg,
3992 status & acts->mask);
3993 if (acts->int_handler)
3994 acts->int_handler(adapter);
3998 if (status) /* clear processed interrupts */
3999 t4_write_reg(adapter, reg, status);
4004 * Interrupt handler for the PCIE module.
4006 static void pcie_intr_handler(struct adapter *adapter)
4008 static const struct intr_info sysbus_intr_info[] = {
4009 { F_RNPP, "RXNP array parity error", -1, 1 },
4010 { F_RPCP, "RXPC array parity error", -1, 1 },
4011 { F_RCIP, "RXCIF array parity error", -1, 1 },
4012 { F_RCCP, "Rx completions control array parity error", -1, 1 },
4013 { F_RFTP, "RXFT array parity error", -1, 1 },
4016 static const struct intr_info pcie_port_intr_info[] = {
4017 { F_TPCP, "TXPC array parity error", -1, 1 },
4018 { F_TNPP, "TXNP array parity error", -1, 1 },
4019 { F_TFTP, "TXFT array parity error", -1, 1 },
4020 { F_TCAP, "TXCA array parity error", -1, 1 },
4021 { F_TCIP, "TXCIF array parity error", -1, 1 },
4022 { F_RCAP, "RXCA array parity error", -1, 1 },
4023 { F_OTDD, "outbound request TLP discarded", -1, 1 },
4024 { F_RDPE, "Rx data parity error", -1, 1 },
4025 { F_TDUE, "Tx uncorrectable data error", -1, 1 },
4028 static const struct intr_info pcie_intr_info[] = {
4029 { F_MSIADDRLPERR, "MSI AddrL parity error", -1, 1 },
4030 { F_MSIADDRHPERR, "MSI AddrH parity error", -1, 1 },
4031 { F_MSIDATAPERR, "MSI data parity error", -1, 1 },
4032 { F_MSIXADDRLPERR, "MSI-X AddrL parity error", -1, 1 },
4033 { F_MSIXADDRHPERR, "MSI-X AddrH parity error", -1, 1 },
4034 { F_MSIXDATAPERR, "MSI-X data parity error", -1, 1 },
4035 { F_MSIXDIPERR, "MSI-X DI parity error", -1, 1 },
4036 { F_PIOCPLPERR, "PCI PIO completion FIFO parity error", -1, 1 },
4037 { F_PIOREQPERR, "PCI PIO request FIFO parity error", -1, 1 },
4038 { F_TARTAGPERR, "PCI PCI target tag FIFO parity error", -1, 1 },
4039 { F_CCNTPERR, "PCI CMD channel count parity error", -1, 1 },
4040 { F_CREQPERR, "PCI CMD channel request parity error", -1, 1 },
4041 { F_CRSPPERR, "PCI CMD channel response parity error", -1, 1 },
4042 { F_DCNTPERR, "PCI DMA channel count parity error", -1, 1 },
4043 { F_DREQPERR, "PCI DMA channel request parity error", -1, 1 },
4044 { F_DRSPPERR, "PCI DMA channel response parity error", -1, 1 },
4045 { F_HCNTPERR, "PCI HMA channel count parity error", -1, 1 },
4046 { F_HREQPERR, "PCI HMA channel request parity error", -1, 1 },
4047 { F_HRSPPERR, "PCI HMA channel response parity error", -1, 1 },
4048 { F_CFGSNPPERR, "PCI config snoop FIFO parity error", -1, 1 },
4049 { F_FIDPERR, "PCI FID parity error", -1, 1 },
4050 { F_INTXCLRPERR, "PCI INTx clear parity error", -1, 1 },
4051 { F_MATAGPERR, "PCI MA tag parity error", -1, 1 },
4052 { F_PIOTAGPERR, "PCI PIO tag parity error", -1, 1 },
4053 { F_RXCPLPERR, "PCI Rx completion parity error", -1, 1 },
4054 { F_RXWRPERR, "PCI Rx write parity error", -1, 1 },
4055 { F_RPLPERR, "PCI replay buffer parity error", -1, 1 },
4056 { F_PCIESINT, "PCI core secondary fault", -1, 1 },
4057 { F_PCIEPINT, "PCI core primary fault", -1, 1 },
4058 { F_UNXSPLCPLERR, "PCI unexpected split completion error", -1,
4063 static const struct intr_info t5_pcie_intr_info[] = {
4064 { F_MSTGRPPERR, "Master Response Read Queue parity error",
4066 { F_MSTTIMEOUTPERR, "Master Timeout FIFO parity error", -1, 1 },
4067 { F_MSIXSTIPERR, "MSI-X STI SRAM parity error", -1, 1 },
4068 { F_MSIXADDRLPERR, "MSI-X AddrL parity error", -1, 1 },
4069 { F_MSIXADDRHPERR, "MSI-X AddrH parity error", -1, 1 },
4070 { F_MSIXDATAPERR, "MSI-X data parity error", -1, 1 },
4071 { F_MSIXDIPERR, "MSI-X DI parity error", -1, 1 },
4072 { F_PIOCPLGRPPERR, "PCI PIO completion Group FIFO parity error",
4074 { F_PIOREQGRPPERR, "PCI PIO request Group FIFO parity error",
4076 { F_TARTAGPERR, "PCI PCI target tag FIFO parity error", -1, 1 },
4077 { F_MSTTAGQPERR, "PCI master tag queue parity error", -1, 1 },
4078 { F_CREQPERR, "PCI CMD channel request parity error", -1, 1 },
4079 { F_CRSPPERR, "PCI CMD channel response parity error", -1, 1 },
4080 { F_DREQWRPERR, "PCI DMA channel write request parity error",
4082 { F_DREQPERR, "PCI DMA channel request parity error", -1, 1 },
4083 { F_DRSPPERR, "PCI DMA channel response parity error", -1, 1 },
4084 { F_HREQWRPERR, "PCI HMA channel count parity error", -1, 1 },
4085 { F_HREQPERR, "PCI HMA channel request parity error", -1, 1 },
4086 { F_HRSPPERR, "PCI HMA channel response parity error", -1, 1 },
4087 { F_CFGSNPPERR, "PCI config snoop FIFO parity error", -1, 1 },
4088 { F_FIDPERR, "PCI FID parity error", -1, 1 },
4089 { F_VFIDPERR, "PCI INTx clear parity error", -1, 1 },
4090 { F_MAGRPPERR, "PCI MA group FIFO parity error", -1, 1 },
4091 { F_PIOTAGPERR, "PCI PIO tag parity error", -1, 1 },
4092 { F_IPRXHDRGRPPERR, "PCI IP Rx header group parity error",
4094 { F_IPRXDATAGRPPERR, "PCI IP Rx data group parity error",
4096 { F_RPLPERR, "PCI IP replay buffer parity error", -1, 1 },
4097 { F_IPSOTPERR, "PCI IP SOT buffer parity error", -1, 1 },
4098 { F_TRGT1GRPPERR, "PCI TRGT1 group FIFOs parity error", -1, 1 },
4099 { F_READRSPERR, "Outbound read error", -1,
4107 fat = t4_handle_intr_status(adapter,
4108 A_PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS,
4110 t4_handle_intr_status(adapter,
4111 A_PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS,
4112 pcie_port_intr_info) +
4113 t4_handle_intr_status(adapter, A_PCIE_INT_CAUSE,
4116 fat = t4_handle_intr_status(adapter, A_PCIE_INT_CAUSE,
4119 t4_fatal_err(adapter);
4123 * TP interrupt handler.
4125 static void tp_intr_handler(struct adapter *adapter)
4127 static const struct intr_info tp_intr_info[] = {
4128 { 0x3fffffff, "TP parity error", -1, 1 },
4129 { F_FLMTXFLSTEMPTY, "TP out of Tx pages", -1, 1 },
4133 if (t4_handle_intr_status(adapter, A_TP_INT_CAUSE, tp_intr_info))
4134 t4_fatal_err(adapter);
4138 * SGE interrupt handler.
4140 static void sge_intr_handler(struct adapter *adapter)
4145 static const struct intr_info sge_intr_info[] = {
4146 { F_ERR_CPL_EXCEED_IQE_SIZE,
4147 "SGE received CPL exceeding IQE size", -1, 1 },
4148 { F_ERR_INVALID_CIDX_INC,
4149 "SGE GTS CIDX increment too large", -1, 0 },
4150 { F_ERR_CPL_OPCODE_0, "SGE received 0-length CPL", -1, 0 },
4151 { F_DBFIFO_LP_INT, NULL, -1, 0, t4_db_full },
4152 { F_ERR_DATA_CPL_ON_HIGH_QID1 | F_ERR_DATA_CPL_ON_HIGH_QID0,
4153 "SGE IQID > 1023 received CPL for FL", -1, 0 },
4154 { F_ERR_BAD_DB_PIDX3, "SGE DBP 3 pidx increment too large", -1,
4156 { F_ERR_BAD_DB_PIDX2, "SGE DBP 2 pidx increment too large", -1,
4158 { F_ERR_BAD_DB_PIDX1, "SGE DBP 1 pidx increment too large", -1,
4160 { F_ERR_BAD_DB_PIDX0, "SGE DBP 0 pidx increment too large", -1,
4162 { F_ERR_ING_CTXT_PRIO,
4163 "SGE too many priority ingress contexts", -1, 0 },
4164 { F_INGRESS_SIZE_ERR, "SGE illegal ingress QID", -1, 0 },
4165 { F_EGRESS_SIZE_ERR, "SGE illegal egress QID", -1, 0 },
4166 { F_ERR_PCIE_ERROR0 | F_ERR_PCIE_ERROR1 |
4167 F_ERR_PCIE_ERROR2 | F_ERR_PCIE_ERROR3,
4168 "SGE PCIe error for a DBP thread", -1, 0 },
4172 static const struct intr_info t4t5_sge_intr_info[] = {
4173 { F_ERR_DROPPED_DB, NULL, -1, 0, t4_db_dropped },
4174 { F_DBFIFO_HP_INT, NULL, -1, 0, t4_db_full },
4175 { F_ERR_EGR_CTXT_PRIO,
4176 "SGE too many priority egress contexts", -1, 0 },
4181 * For now, treat below interrupts as fatal so that we disable SGE and
4182 * get better debug */
4183 static const struct intr_info t6_sge_intr_info[] = {
4185 "SGE Actual WRE packet is less than advertized length",
4190 v = (u64)t4_read_reg(adapter, A_SGE_INT_CAUSE1) |
4191 ((u64)t4_read_reg(adapter, A_SGE_INT_CAUSE2) << 32);
4193 CH_ALERT(adapter, "SGE parity error (%#llx)\n",
4194 (unsigned long long)v);
4195 t4_write_reg(adapter, A_SGE_INT_CAUSE1, v);
4196 t4_write_reg(adapter, A_SGE_INT_CAUSE2, v >> 32);
4199 v |= t4_handle_intr_status(adapter, A_SGE_INT_CAUSE3, sge_intr_info);
4200 if (chip_id(adapter) <= CHELSIO_T5)
4201 v |= t4_handle_intr_status(adapter, A_SGE_INT_CAUSE3,
4202 t4t5_sge_intr_info);
4204 v |= t4_handle_intr_status(adapter, A_SGE_INT_CAUSE3,
4207 err = t4_read_reg(adapter, A_SGE_ERROR_STATS);
4208 if (err & F_ERROR_QID_VALID) {
4209 CH_ERR(adapter, "SGE error for queue %u\n", G_ERROR_QID(err));
4210 if (err & F_UNCAPTURED_ERROR)
4211 CH_ERR(adapter, "SGE UNCAPTURED_ERROR set (clearing)\n");
4212 t4_write_reg(adapter, A_SGE_ERROR_STATS, F_ERROR_QID_VALID |
4213 F_UNCAPTURED_ERROR);
4217 t4_fatal_err(adapter);
4220 #define CIM_OBQ_INTR (F_OBQULP0PARERR | F_OBQULP1PARERR | F_OBQULP2PARERR |\
4221 F_OBQULP3PARERR | F_OBQSGEPARERR | F_OBQNCSIPARERR)
4222 #define CIM_IBQ_INTR (F_IBQTP0PARERR | F_IBQTP1PARERR | F_IBQULPPARERR |\
4223 F_IBQSGEHIPARERR | F_IBQSGELOPARERR | F_IBQNCSIPARERR)
4226 * CIM interrupt handler.
4228 static void cim_intr_handler(struct adapter *adapter)
4230 static const struct intr_info cim_intr_info[] = {
4231 { F_PREFDROPINT, "CIM control register prefetch drop", -1, 1 },
4232 { CIM_OBQ_INTR, "CIM OBQ parity error", -1, 1 },
4233 { CIM_IBQ_INTR, "CIM IBQ parity error", -1, 1 },
4234 { F_MBUPPARERR, "CIM mailbox uP parity error", -1, 1 },
4235 { F_MBHOSTPARERR, "CIM mailbox host parity error", -1, 1 },
4236 { F_TIEQINPARERRINT, "CIM TIEQ outgoing parity error", -1, 1 },
4237 { F_TIEQOUTPARERRINT, "CIM TIEQ incoming parity error", -1, 1 },
4238 { F_TIMER0INT, "CIM TIMER0 interrupt", -1, 1 },
4241 static const struct intr_info cim_upintr_info[] = {
4242 { F_RSVDSPACEINT, "CIM reserved space access", -1, 1 },
4243 { F_ILLTRANSINT, "CIM illegal transaction", -1, 1 },
4244 { F_ILLWRINT, "CIM illegal write", -1, 1 },
4245 { F_ILLRDINT, "CIM illegal read", -1, 1 },
4246 { F_ILLRDBEINT, "CIM illegal read BE", -1, 1 },
4247 { F_ILLWRBEINT, "CIM illegal write BE", -1, 1 },
4248 { F_SGLRDBOOTINT, "CIM single read from boot space", -1, 1 },
4249 { F_SGLWRBOOTINT, "CIM single write to boot space", -1, 1 },
4250 { F_BLKWRBOOTINT, "CIM block write to boot space", -1, 1 },
4251 { F_SGLRDFLASHINT, "CIM single read from flash space", -1, 1 },
4252 { F_SGLWRFLASHINT, "CIM single write to flash space", -1, 1 },
4253 { F_BLKWRFLASHINT, "CIM block write to flash space", -1, 1 },
4254 { F_SGLRDEEPROMINT, "CIM single EEPROM read", -1, 1 },
4255 { F_SGLWREEPROMINT, "CIM single EEPROM write", -1, 1 },
4256 { F_BLKRDEEPROMINT, "CIM block EEPROM read", -1, 1 },
4257 { F_BLKWREEPROMINT, "CIM block EEPROM write", -1, 1 },
4258 { F_SGLRDCTLINT , "CIM single read from CTL space", -1, 1 },
4259 { F_SGLWRCTLINT , "CIM single write to CTL space", -1, 1 },
4260 { F_BLKRDCTLINT , "CIM block read from CTL space", -1, 1 },
4261 { F_BLKWRCTLINT , "CIM block write to CTL space", -1, 1 },
4262 { F_SGLRDPLINT , "CIM single read from PL space", -1, 1 },
4263 { F_SGLWRPLINT , "CIM single write to PL space", -1, 1 },
4264 { F_BLKRDPLINT , "CIM block read from PL space", -1, 1 },
4265 { F_BLKWRPLINT , "CIM block write to PL space", -1, 1 },
4266 { F_REQOVRLOOKUPINT , "CIM request FIFO overwrite", -1, 1 },
4267 { F_RSPOVRLOOKUPINT , "CIM response FIFO overwrite", -1, 1 },
4268 { F_TIMEOUTINT , "CIM PIF timeout", -1, 1 },
4269 { F_TIMEOUTMAINT , "CIM PIF MA timeout", -1, 1 },
4275 fw_err = t4_read_reg(adapter, A_PCIE_FW);
4276 if (fw_err & F_PCIE_FW_ERR)
4277 t4_report_fw_error(adapter);
4279 /* When the Firmware detects an internal error which normally wouldn't
4280 * raise a Host Interrupt, it forces a CIM Timer0 interrupt in order
4281 * to make sure the Host sees the Firmware Crash. So if we have a
4282 * Timer0 interrupt and don't see a Firmware Crash, ignore the Timer0
4285 val = t4_read_reg(adapter, A_CIM_HOST_INT_CAUSE);
4286 if (val & F_TIMER0INT)
4287 if (!(fw_err & F_PCIE_FW_ERR) ||
4288 (G_PCIE_FW_EVAL(fw_err) != PCIE_FW_EVAL_CRASH))
4289 t4_write_reg(adapter, A_CIM_HOST_INT_CAUSE,
4292 fat = t4_handle_intr_status(adapter, A_CIM_HOST_INT_CAUSE,
4294 t4_handle_intr_status(adapter, A_CIM_HOST_UPACC_INT_CAUSE,
4297 t4_fatal_err(adapter);
4301 * ULP RX interrupt handler.
4303 static void ulprx_intr_handler(struct adapter *adapter)
4305 static const struct intr_info ulprx_intr_info[] = {
4306 { F_CAUSE_CTX_1, "ULPRX channel 1 context error", -1, 1 },
4307 { F_CAUSE_CTX_0, "ULPRX channel 0 context error", -1, 1 },
4308 { 0x7fffff, "ULPRX parity error", -1, 1 },
4312 if (t4_handle_intr_status(adapter, A_ULP_RX_INT_CAUSE, ulprx_intr_info))
4313 t4_fatal_err(adapter);
4317 * ULP TX interrupt handler.
4319 static void ulptx_intr_handler(struct adapter *adapter)
4321 static const struct intr_info ulptx_intr_info[] = {
4322 { F_PBL_BOUND_ERR_CH3, "ULPTX channel 3 PBL out of bounds", -1,
4324 { F_PBL_BOUND_ERR_CH2, "ULPTX channel 2 PBL out of bounds", -1,
4326 { F_PBL_BOUND_ERR_CH1, "ULPTX channel 1 PBL out of bounds", -1,
4328 { F_PBL_BOUND_ERR_CH0, "ULPTX channel 0 PBL out of bounds", -1,
4330 { 0xfffffff, "ULPTX parity error", -1, 1 },
4334 if (t4_handle_intr_status(adapter, A_ULP_TX_INT_CAUSE, ulptx_intr_info))
4335 t4_fatal_err(adapter);
4339 * PM TX interrupt handler.
4341 static void pmtx_intr_handler(struct adapter *adapter)
4343 static const struct intr_info pmtx_intr_info[] = {
4344 { F_PCMD_LEN_OVFL0, "PMTX channel 0 pcmd too large", -1, 1 },
4345 { F_PCMD_LEN_OVFL1, "PMTX channel 1 pcmd too large", -1, 1 },
4346 { F_PCMD_LEN_OVFL2, "PMTX channel 2 pcmd too large", -1, 1 },
4347 { F_ZERO_C_CMD_ERROR, "PMTX 0-length pcmd", -1, 1 },
4348 { 0xffffff0, "PMTX framing error", -1, 1 },
4349 { F_OESPI_PAR_ERROR, "PMTX oespi parity error", -1, 1 },
4350 { F_DB_OPTIONS_PAR_ERROR, "PMTX db_options parity error", -1,
4352 { F_ICSPI_PAR_ERROR, "PMTX icspi parity error", -1, 1 },
4353 { F_C_PCMD_PAR_ERROR, "PMTX c_pcmd parity error", -1, 1},
4357 if (t4_handle_intr_status(adapter, A_PM_TX_INT_CAUSE, pmtx_intr_info))
4358 t4_fatal_err(adapter);
4362 * PM RX interrupt handler.
4364 static void pmrx_intr_handler(struct adapter *adapter)
4366 static const struct intr_info pmrx_intr_info[] = {
4367 { F_ZERO_E_CMD_ERROR, "PMRX 0-length pcmd", -1, 1 },
4368 { 0x3ffff0, "PMRX framing error", -1, 1 },
4369 { F_OCSPI_PAR_ERROR, "PMRX ocspi parity error", -1, 1 },
4370 { F_DB_OPTIONS_PAR_ERROR, "PMRX db_options parity error", -1,
4372 { F_IESPI_PAR_ERROR, "PMRX iespi parity error", -1, 1 },
4373 { F_E_PCMD_PAR_ERROR, "PMRX e_pcmd parity error", -1, 1},
4377 if (t4_handle_intr_status(adapter, A_PM_RX_INT_CAUSE, pmrx_intr_info))
4378 t4_fatal_err(adapter);
4382 * CPL switch interrupt handler.
4384 static void cplsw_intr_handler(struct adapter *adapter)
4386 static const struct intr_info cplsw_intr_info[] = {
4387 { F_CIM_OP_MAP_PERR, "CPLSW CIM op_map parity error", -1, 1 },
4388 { F_CIM_OVFL_ERROR, "CPLSW CIM overflow", -1, 1 },
4389 { F_TP_FRAMING_ERROR, "CPLSW TP framing error", -1, 1 },
4390 { F_SGE_FRAMING_ERROR, "CPLSW SGE framing error", -1, 1 },
4391 { F_CIM_FRAMING_ERROR, "CPLSW CIM framing error", -1, 1 },
4392 { F_ZERO_SWITCH_ERROR, "CPLSW no-switch error", -1, 1 },
4396 if (t4_handle_intr_status(adapter, A_CPL_INTR_CAUSE, cplsw_intr_info))
4397 t4_fatal_err(adapter);
4401 * LE interrupt handler.
4403 static void le_intr_handler(struct adapter *adap)
4405 unsigned int chip_ver = chip_id(adap);
4406 static const struct intr_info le_intr_info[] = {
4407 { F_LIPMISS, "LE LIP miss", -1, 0 },
4408 { F_LIP0, "LE 0 LIP error", -1, 0 },
4409 { F_PARITYERR, "LE parity error", -1, 1 },
4410 { F_UNKNOWNCMD, "LE unknown command", -1, 1 },
4411 { F_REQQPARERR, "LE request queue parity error", -1, 1 },
4415 static const struct intr_info t6_le_intr_info[] = {
4416 { F_T6_LIPMISS, "LE LIP miss", -1, 0 },
4417 { F_T6_LIP0, "LE 0 LIP error", -1, 0 },
4418 { F_TCAMINTPERR, "LE parity error", -1, 1 },
4419 { F_T6_UNKNOWNCMD, "LE unknown command", -1, 1 },
4420 { F_SSRAMINTPERR, "LE request queue parity error", -1, 1 },
4424 if (t4_handle_intr_status(adap, A_LE_DB_INT_CAUSE,
4425 (chip_ver <= CHELSIO_T5) ?
4426 le_intr_info : t6_le_intr_info))
4431 * MPS interrupt handler.
4433 static void mps_intr_handler(struct adapter *adapter)
4435 static const struct intr_info mps_rx_intr_info[] = {
4436 { 0xffffff, "MPS Rx parity error", -1, 1 },
4439 static const struct intr_info mps_tx_intr_info[] = {
4440 { V_TPFIFO(M_TPFIFO), "MPS Tx TP FIFO parity error", -1, 1 },
4441 { F_NCSIFIFO, "MPS Tx NC-SI FIFO parity error", -1, 1 },
4442 { V_TXDATAFIFO(M_TXDATAFIFO), "MPS Tx data FIFO parity error",
4444 { V_TXDESCFIFO(M_TXDESCFIFO), "MPS Tx desc FIFO parity error",
4446 { F_BUBBLE, "MPS Tx underflow", -1, 1 },
4447 { F_SECNTERR, "MPS Tx SOP/EOP error", -1, 1 },
4448 { F_FRMERR, "MPS Tx framing error", -1, 1 },
4451 static const struct intr_info mps_trc_intr_info[] = {
4452 { V_FILTMEM(M_FILTMEM), "MPS TRC filter parity error", -1, 1 },
4453 { V_PKTFIFO(M_PKTFIFO), "MPS TRC packet FIFO parity error", -1,
4455 { F_MISCPERR, "MPS TRC misc parity error", -1, 1 },
4458 static const struct intr_info mps_stat_sram_intr_info[] = {
4459 { 0x1fffff, "MPS statistics SRAM parity error", -1, 1 },
4462 static const struct intr_info mps_stat_tx_intr_info[] = {
4463 { 0xfffff, "MPS statistics Tx FIFO parity error", -1, 1 },
4466 static const struct intr_info mps_stat_rx_intr_info[] = {
4467 { 0xffffff, "MPS statistics Rx FIFO parity error", -1, 1 },
4470 static const struct intr_info mps_cls_intr_info[] = {
4471 { F_MATCHSRAM, "MPS match SRAM parity error", -1, 1 },
4472 { F_MATCHTCAM, "MPS match TCAM parity error", -1, 1 },
4473 { F_HASHSRAM, "MPS hash SRAM parity error", -1, 1 },
4479 fat = t4_handle_intr_status(adapter, A_MPS_RX_PERR_INT_CAUSE,
4481 t4_handle_intr_status(adapter, A_MPS_TX_INT_CAUSE,
4483 t4_handle_intr_status(adapter, A_MPS_TRC_INT_CAUSE,
4484 mps_trc_intr_info) +
4485 t4_handle_intr_status(adapter, A_MPS_STAT_PERR_INT_CAUSE_SRAM,
4486 mps_stat_sram_intr_info) +
4487 t4_handle_intr_status(adapter, A_MPS_STAT_PERR_INT_CAUSE_TX_FIFO,
4488 mps_stat_tx_intr_info) +
4489 t4_handle_intr_status(adapter, A_MPS_STAT_PERR_INT_CAUSE_RX_FIFO,
4490 mps_stat_rx_intr_info) +
4491 t4_handle_intr_status(adapter, A_MPS_CLS_INT_CAUSE,
4494 t4_write_reg(adapter, A_MPS_INT_CAUSE, 0);
4495 t4_read_reg(adapter, A_MPS_INT_CAUSE); /* flush */
4497 t4_fatal_err(adapter);
4500 #define MEM_INT_MASK (F_PERR_INT_CAUSE | F_ECC_CE_INT_CAUSE | \
4504 * EDC/MC interrupt handler.
4506 static void mem_intr_handler(struct adapter *adapter, int idx)
4508 static const char name[4][7] = { "EDC0", "EDC1", "MC/MC0", "MC1" };
4510 unsigned int addr, cnt_addr, v;
4512 if (idx <= MEM_EDC1) {
4513 addr = EDC_REG(A_EDC_INT_CAUSE, idx);
4514 cnt_addr = EDC_REG(A_EDC_ECC_STATUS, idx);
4515 } else if (idx == MEM_MC) {
4516 if (is_t4(adapter)) {
4517 addr = A_MC_INT_CAUSE;
4518 cnt_addr = A_MC_ECC_STATUS;
4520 addr = A_MC_P_INT_CAUSE;
4521 cnt_addr = A_MC_P_ECC_STATUS;
4524 addr = MC_REG(A_MC_P_INT_CAUSE, 1);
4525 cnt_addr = MC_REG(A_MC_P_ECC_STATUS, 1);
4528 v = t4_read_reg(adapter, addr) & MEM_INT_MASK;
4529 if (v & F_PERR_INT_CAUSE)
4530 CH_ALERT(adapter, "%s FIFO parity error\n",
4532 if (v & F_ECC_CE_INT_CAUSE) {
4533 u32 cnt = G_ECC_CECNT(t4_read_reg(adapter, cnt_addr));
4535 if (idx <= MEM_EDC1)
4536 t4_edc_err_read(adapter, idx);
4538 t4_write_reg(adapter, cnt_addr, V_ECC_CECNT(M_ECC_CECNT));
4539 CH_WARN_RATELIMIT(adapter,
4540 "%u %s correctable ECC data error%s\n",
4541 cnt, name[idx], cnt > 1 ? "s" : "");
4543 if (v & F_ECC_UE_INT_CAUSE)
4545 "%s uncorrectable ECC data error\n", name[idx]);
4547 t4_write_reg(adapter, addr, v);
4548 if (v & (F_PERR_INT_CAUSE | F_ECC_UE_INT_CAUSE))
4549 t4_fatal_err(adapter);
4553 * MA interrupt handler.
4555 static void ma_intr_handler(struct adapter *adapter)
4557 u32 v, status = t4_read_reg(adapter, A_MA_INT_CAUSE);
4559 if (status & F_MEM_PERR_INT_CAUSE) {
4561 "MA parity error, parity status %#x\n",
4562 t4_read_reg(adapter, A_MA_PARITY_ERROR_STATUS1));
4565 "MA parity error, parity status %#x\n",
4566 t4_read_reg(adapter,
4567 A_MA_PARITY_ERROR_STATUS2));
4569 if (status & F_MEM_WRAP_INT_CAUSE) {
4570 v = t4_read_reg(adapter, A_MA_INT_WRAP_STATUS);
4571 CH_ALERT(adapter, "MA address wrap-around error by "
4572 "client %u to address %#x\n",
4573 G_MEM_WRAP_CLIENT_NUM(v),
4574 G_MEM_WRAP_ADDRESS(v) << 4);
4576 t4_write_reg(adapter, A_MA_INT_CAUSE, status);
4577 t4_fatal_err(adapter);
4581 * SMB interrupt handler.
4583 static void smb_intr_handler(struct adapter *adap)
4585 static const struct intr_info smb_intr_info[] = {
4586 { F_MSTTXFIFOPARINT, "SMB master Tx FIFO parity error", -1, 1 },
4587 { F_MSTRXFIFOPARINT, "SMB master Rx FIFO parity error", -1, 1 },
4588 { F_SLVFIFOPARINT, "SMB slave FIFO parity error", -1, 1 },
4592 if (t4_handle_intr_status(adap, A_SMB_INT_CAUSE, smb_intr_info))
4597 * NC-SI interrupt handler.
4599 static void ncsi_intr_handler(struct adapter *adap)
4601 static const struct intr_info ncsi_intr_info[] = {
4602 { F_CIM_DM_PRTY_ERR, "NC-SI CIM parity error", -1, 1 },
4603 { F_MPS_DM_PRTY_ERR, "NC-SI MPS parity error", -1, 1 },
4604 { F_TXFIFO_PRTY_ERR, "NC-SI Tx FIFO parity error", -1, 1 },
4605 { F_RXFIFO_PRTY_ERR, "NC-SI Rx FIFO parity error", -1, 1 },
4609 if (t4_handle_intr_status(adap, A_NCSI_INT_CAUSE, ncsi_intr_info))
4614 * XGMAC interrupt handler.
4616 static void xgmac_intr_handler(struct adapter *adap, int port)
4618 u32 v, int_cause_reg;
4621 int_cause_reg = PORT_REG(port, A_XGMAC_PORT_INT_CAUSE);
4623 int_cause_reg = T5_PORT_REG(port, A_MAC_PORT_INT_CAUSE);
4625 v = t4_read_reg(adap, int_cause_reg);
4627 v &= (F_TXFIFO_PRTY_ERR | F_RXFIFO_PRTY_ERR);
4631 if (v & F_TXFIFO_PRTY_ERR)
4632 CH_ALERT(adap, "XGMAC %d Tx FIFO parity error\n",
4634 if (v & F_RXFIFO_PRTY_ERR)
4635 CH_ALERT(adap, "XGMAC %d Rx FIFO parity error\n",
4637 t4_write_reg(adap, int_cause_reg, v);
4642 * PL interrupt handler.
4644 static void pl_intr_handler(struct adapter *adap)
4646 static const struct intr_info pl_intr_info[] = {
4647 { F_FATALPERR, "Fatal parity error", -1, 1 },
4648 { F_PERRVFID, "PL VFID_MAP parity error", -1, 1 },
4652 static const struct intr_info t5_pl_intr_info[] = {
4653 { F_FATALPERR, "Fatal parity error", -1, 1 },
4657 if (t4_handle_intr_status(adap, A_PL_PL_INT_CAUSE,
4659 pl_intr_info : t5_pl_intr_info))
4663 #define PF_INTR_MASK (F_PFSW | F_PFCIM)
4666 * t4_slow_intr_handler - control path interrupt handler
4667 * @adapter: the adapter
4669 * T4 interrupt handler for non-data global interrupt events, e.g., errors.
4670 * The designation 'slow' is because it involves register reads, while
4671 * data interrupts typically don't involve any MMIOs.
4673 int t4_slow_intr_handler(struct adapter *adapter)
4675 u32 cause = t4_read_reg(adapter, A_PL_INT_CAUSE);
4677 if (!(cause & GLBL_INTR_MASK))
4680 cim_intr_handler(adapter);
4682 mps_intr_handler(adapter);
4684 ncsi_intr_handler(adapter);
4686 pl_intr_handler(adapter);
4688 smb_intr_handler(adapter);
4690 xgmac_intr_handler(adapter, 0);
4692 xgmac_intr_handler(adapter, 1);
4694 xgmac_intr_handler(adapter, 2);
4696 xgmac_intr_handler(adapter, 3);
4698 pcie_intr_handler(adapter);
4700 mem_intr_handler(adapter, MEM_MC);
4701 if (is_t5(adapter) && (cause & F_MC1))
4702 mem_intr_handler(adapter, MEM_MC1);
4704 mem_intr_handler(adapter, MEM_EDC0);
4706 mem_intr_handler(adapter, MEM_EDC1);
4708 le_intr_handler(adapter);
4710 tp_intr_handler(adapter);
4712 ma_intr_handler(adapter);
4713 if (cause & F_PM_TX)
4714 pmtx_intr_handler(adapter);
4715 if (cause & F_PM_RX)
4716 pmrx_intr_handler(adapter);
4717 if (cause & F_ULP_RX)
4718 ulprx_intr_handler(adapter);
4719 if (cause & F_CPL_SWITCH)
4720 cplsw_intr_handler(adapter);
4722 sge_intr_handler(adapter);
4723 if (cause & F_ULP_TX)
4724 ulptx_intr_handler(adapter);
4726 /* Clear the interrupts just processed for which we are the master. */
4727 t4_write_reg(adapter, A_PL_INT_CAUSE, cause & GLBL_INTR_MASK);
4728 (void)t4_read_reg(adapter, A_PL_INT_CAUSE); /* flush */
4733 * t4_intr_enable - enable interrupts
4734 * @adapter: the adapter whose interrupts should be enabled
4736 * Enable PF-specific interrupts for the calling function and the top-level
4737 * interrupt concentrator for global interrupts. Interrupts are already
4738 * enabled at each module, here we just enable the roots of the interrupt
4741 * Note: this function should be called only when the driver manages
4742 * non PF-specific interrupts from the various HW modules. Only one PCI
4743 * function at a time should be doing this.
4745 void t4_intr_enable(struct adapter *adapter)
4748 u32 whoami = t4_read_reg(adapter, A_PL_WHOAMI);
4749 u32 pf = (chip_id(adapter) <= CHELSIO_T5
4750 ? G_SOURCEPF(whoami)
4751 : G_T6_SOURCEPF(whoami));
4753 if (chip_id(adapter) <= CHELSIO_T5)
4754 val = F_ERR_DROPPED_DB | F_ERR_EGR_CTXT_PRIO | F_DBFIFO_HP_INT;
4756 val = F_ERR_PCIE_ERROR0 | F_ERR_PCIE_ERROR1 | F_FATAL_WRE_LEN;
4757 t4_write_reg(adapter, A_SGE_INT_ENABLE3, F_ERR_CPL_EXCEED_IQE_SIZE |
4758 F_ERR_INVALID_CIDX_INC | F_ERR_CPL_OPCODE_0 |
4759 F_ERR_DATA_CPL_ON_HIGH_QID1 | F_INGRESS_SIZE_ERR |
4760 F_ERR_DATA_CPL_ON_HIGH_QID0 | F_ERR_BAD_DB_PIDX3 |
4761 F_ERR_BAD_DB_PIDX2 | F_ERR_BAD_DB_PIDX1 |
4762 F_ERR_BAD_DB_PIDX0 | F_ERR_ING_CTXT_PRIO |
4763 F_DBFIFO_LP_INT | F_EGRESS_SIZE_ERR | val);
4764 t4_write_reg(adapter, MYPF_REG(A_PL_PF_INT_ENABLE), PF_INTR_MASK);
4765 t4_set_reg_field(adapter, A_PL_INT_MAP0, 0, 1 << pf);
4769 * t4_intr_disable - disable interrupts
4770 * @adapter: the adapter whose interrupts should be disabled
4772 * Disable interrupts. We only disable the top-level interrupt
4773 * concentrators. The caller must be a PCI function managing global
4776 void t4_intr_disable(struct adapter *adapter)
4778 u32 whoami = t4_read_reg(adapter, A_PL_WHOAMI);
4779 u32 pf = (chip_id(adapter) <= CHELSIO_T5
4780 ? G_SOURCEPF(whoami)
4781 : G_T6_SOURCEPF(whoami));
4783 t4_write_reg(adapter, MYPF_REG(A_PL_PF_INT_ENABLE), 0);
4784 t4_set_reg_field(adapter, A_PL_INT_MAP0, 1 << pf, 0);
4788 * t4_intr_clear - clear all interrupts
4789 * @adapter: the adapter whose interrupts should be cleared
4791 * Clears all interrupts. The caller must be a PCI function managing
4792 * global interrupts.
4794 void t4_intr_clear(struct adapter *adapter)
4796 static const unsigned int cause_reg[] = {
4797 A_SGE_INT_CAUSE1, A_SGE_INT_CAUSE2, A_SGE_INT_CAUSE3,
4798 A_PCIE_NONFAT_ERR, A_PCIE_INT_CAUSE,
4799 A_MA_INT_WRAP_STATUS, A_MA_PARITY_ERROR_STATUS1, A_MA_INT_CAUSE,
4800 A_EDC_INT_CAUSE, EDC_REG(A_EDC_INT_CAUSE, 1),
4801 A_CIM_HOST_INT_CAUSE, A_CIM_HOST_UPACC_INT_CAUSE,
4802 MYPF_REG(A_CIM_PF_HOST_INT_CAUSE),
4804 A_ULP_RX_INT_CAUSE, A_ULP_TX_INT_CAUSE,
4805 A_PM_RX_INT_CAUSE, A_PM_TX_INT_CAUSE,
4806 A_MPS_RX_PERR_INT_CAUSE,
4808 MYPF_REG(A_PL_PF_INT_CAUSE),
4815 for (i = 0; i < ARRAY_SIZE(cause_reg); ++i)
4816 t4_write_reg(adapter, cause_reg[i], 0xffffffff);
4818 t4_write_reg(adapter, is_t4(adapter) ? A_MC_INT_CAUSE :
4819 A_MC_P_INT_CAUSE, 0xffffffff);
4821 if (is_t4(adapter)) {
4822 t4_write_reg(adapter, A_PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS,
4824 t4_write_reg(adapter, A_PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS,
4827 t4_write_reg(adapter, A_MA_PARITY_ERROR_STATUS2, 0xffffffff);
4829 t4_write_reg(adapter, A_PL_INT_CAUSE, GLBL_INTR_MASK);
4830 (void) t4_read_reg(adapter, A_PL_INT_CAUSE); /* flush */
4834 * hash_mac_addr - return the hash value of a MAC address
4835 * @addr: the 48-bit Ethernet MAC address
4837 * Hashes a MAC address according to the hash function used by HW inexact
4838 * (hash) address matching.
4840 static int hash_mac_addr(const u8 *addr)
4842 u32 a = ((u32)addr[0] << 16) | ((u32)addr[1] << 8) | addr[2];
4843 u32 b = ((u32)addr[3] << 16) | ((u32)addr[4] << 8) | addr[5];
4851 * t4_config_rss_range - configure a portion of the RSS mapping table
4852 * @adapter: the adapter
4853 * @mbox: mbox to use for the FW command
4854 * @viid: virtual interface whose RSS subtable is to be written
4855 * @start: start entry in the table to write
4856 * @n: how many table entries to write
4857 * @rspq: values for the "response queue" (Ingress Queue) lookup table
4858 * @nrspq: number of values in @rspq
4860 * Programs the selected part of the VI's RSS mapping table with the
4861 * provided values. If @nrspq < @n the supplied values are used repeatedly
4862 * until the full table range is populated.
4864 * The caller must ensure the values in @rspq are in the range allowed for
4867 int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid,
4868 int start, int n, const u16 *rspq, unsigned int nrspq)
4871 const u16 *rsp = rspq;
4872 const u16 *rsp_end = rspq + nrspq;
4873 struct fw_rss_ind_tbl_cmd cmd;
4875 memset(&cmd, 0, sizeof(cmd));
4876 cmd.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_RSS_IND_TBL_CMD) |
4877 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
4878 V_FW_RSS_IND_TBL_CMD_VIID(viid));
4879 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
4882 * Each firmware RSS command can accommodate up to 32 RSS Ingress
4883 * Queue Identifiers. These Ingress Queue IDs are packed three to
4884 * a 32-bit word as 10-bit values with the upper remaining 2 bits
4888 int nq = min(n, 32);
4890 __be32 *qp = &cmd.iq0_to_iq2;
4893 * Set up the firmware RSS command header to send the next
4894 * "nq" Ingress Queue IDs to the firmware.
4896 cmd.niqid = cpu_to_be16(nq);
4897 cmd.startidx = cpu_to_be16(start);
4900 * "nq" more done for the start of the next loop.
4906 * While there are still Ingress Queue IDs to stuff into the
4907 * current firmware RSS command, retrieve them from the
4908 * Ingress Queue ID array and insert them into the command.
4912 * Grab up to the next 3 Ingress Queue IDs (wrapping
4913 * around the Ingress Queue ID array if necessary) and
4914 * insert them into the firmware RSS command at the
4915 * current 3-tuple position within the commad.
4919 int nqbuf = min(3, nq);
4922 qbuf[0] = qbuf[1] = qbuf[2] = 0;
4923 while (nqbuf && nq_packed < 32) {
4930 *qp++ = cpu_to_be32(V_FW_RSS_IND_TBL_CMD_IQ0(qbuf[0]) |
4931 V_FW_RSS_IND_TBL_CMD_IQ1(qbuf[1]) |
4932 V_FW_RSS_IND_TBL_CMD_IQ2(qbuf[2]));
4936 * Send this portion of the RRS table update to the firmware;
4937 * bail out on any errors.
4939 ret = t4_wr_mbox(adapter, mbox, &cmd, sizeof(cmd), NULL);
4947 * t4_config_glbl_rss - configure the global RSS mode
4948 * @adapter: the adapter
4949 * @mbox: mbox to use for the FW command
4950 * @mode: global RSS mode
4951 * @flags: mode-specific flags
4953 * Sets the global RSS mode.
4955 int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
4958 struct fw_rss_glb_config_cmd c;
4960 memset(&c, 0, sizeof(c));
4961 c.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_RSS_GLB_CONFIG_CMD) |
4962 F_FW_CMD_REQUEST | F_FW_CMD_WRITE);
4963 c.retval_len16 = cpu_to_be32(FW_LEN16(c));
4964 if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_MANUAL) {
4965 c.u.manual.mode_pkd =
4966 cpu_to_be32(V_FW_RSS_GLB_CONFIG_CMD_MODE(mode));
4967 } else if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
4968 c.u.basicvirtual.mode_keymode =
4969 cpu_to_be32(V_FW_RSS_GLB_CONFIG_CMD_MODE(mode));
4970 c.u.basicvirtual.synmapen_to_hashtoeplitz = cpu_to_be32(flags);
4973 return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL);
4977 * t4_config_vi_rss - configure per VI RSS settings
4978 * @adapter: the adapter
4979 * @mbox: mbox to use for the FW command
4982 * @defq: id of the default RSS queue for the VI.
4983 * @skeyidx: RSS secret key table index for non-global mode
4984 * @skey: RSS vf_scramble key for VI.
4986 * Configures VI-specific RSS properties.
4988 int t4_config_vi_rss(struct adapter *adapter, int mbox, unsigned int viid,
4989 unsigned int flags, unsigned int defq, unsigned int skeyidx,
4992 struct fw_rss_vi_config_cmd c;
4994 memset(&c, 0, sizeof(c));
4995 c.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_RSS_VI_CONFIG_CMD) |
4996 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
4997 V_FW_RSS_VI_CONFIG_CMD_VIID(viid));
4998 c.retval_len16 = cpu_to_be32(FW_LEN16(c));
4999 c.u.basicvirtual.defaultq_to_udpen = cpu_to_be32(flags |
5000 V_FW_RSS_VI_CONFIG_CMD_DEFAULTQ(defq));
5001 c.u.basicvirtual.secretkeyidx_pkd = cpu_to_be32(
5002 V_FW_RSS_VI_CONFIG_CMD_SECRETKEYIDX(skeyidx));
5003 c.u.basicvirtual.secretkeyxor = cpu_to_be32(skey);
5005 return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL);
5008 /* Read an RSS table row */
5009 static int rd_rss_row(struct adapter *adap, int row, u32 *val)
5011 t4_write_reg(adap, A_TP_RSS_LKP_TABLE, 0xfff00000 | row);
5012 return t4_wait_op_done_val(adap, A_TP_RSS_LKP_TABLE, F_LKPTBLROWVLD, 1,
5017 * t4_read_rss - read the contents of the RSS mapping table
5018 * @adapter: the adapter
5019 * @map: holds the contents of the RSS mapping table
5021 * Reads the contents of the RSS hash->queue mapping table.
5023 int t4_read_rss(struct adapter *adapter, u16 *map)
5028 for (i = 0; i < RSS_NENTRIES / 2; ++i) {
5029 ret = rd_rss_row(adapter, i, &val);
5032 *map++ = G_LKPTBLQUEUE0(val);
5033 *map++ = G_LKPTBLQUEUE1(val);
5039 * t4_tp_fw_ldst_rw - Access TP indirect register through LDST
5040 * @adap: the adapter
5041 * @cmd: TP fw ldst address space type
5042 * @vals: where the indirect register values are stored/written
5043 * @nregs: how many indirect registers to read/write
5044 * @start_idx: index of first indirect register to read/write
5045 * @rw: Read (1) or Write (0)
5046 * @sleep_ok: if true we may sleep while awaiting command completion
5048 * Access TP indirect registers through LDST
5050 static int t4_tp_fw_ldst_rw(struct adapter *adap, int cmd, u32 *vals,
5051 unsigned int nregs, unsigned int start_index,
5052 unsigned int rw, bool sleep_ok)
5056 struct fw_ldst_cmd c;
5058 for (i = 0; i < nregs; i++) {
5059 memset(&c, 0, sizeof(c));
5060 c.op_to_addrspace = cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
5062 (rw ? F_FW_CMD_READ :
5064 V_FW_LDST_CMD_ADDRSPACE(cmd));
5065 c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
5067 c.u.addrval.addr = cpu_to_be32(start_index + i);
5068 c.u.addrval.val = rw ? 0 : cpu_to_be32(vals[i]);
5069 ret = t4_wr_mbox_meat(adap, adap->mbox, &c, sizeof(c), &c,
5075 vals[i] = be32_to_cpu(c.u.addrval.val);
5081 * t4_tp_indirect_rw - Read/Write TP indirect register through LDST or backdoor
5082 * @adap: the adapter
5083 * @reg_addr: Address Register
5084 * @reg_data: Data register
5085 * @buff: where the indirect register values are stored/written
5086 * @nregs: how many indirect registers to read/write
5087 * @start_index: index of first indirect register to read/write
5088 * @rw: READ(1) or WRITE(0)
5089 * @sleep_ok: if true we may sleep while awaiting command completion
5091 * Read/Write TP indirect registers through LDST if possible.
5092 * Else, use backdoor access
5094 static void t4_tp_indirect_rw(struct adapter *adap, u32 reg_addr, u32 reg_data,
5095 u32 *buff, u32 nregs, u32 start_index, int rw,
5103 cmd = FW_LDST_ADDRSPC_TP_PIO;
5105 case A_TP_TM_PIO_ADDR:
5106 cmd = FW_LDST_ADDRSPC_TP_TM_PIO;
5108 case A_TP_MIB_INDEX:
5109 cmd = FW_LDST_ADDRSPC_TP_MIB;
5112 goto indirect_access;
5115 if (t4_use_ldst(adap))
5116 rc = t4_tp_fw_ldst_rw(adap, cmd, buff, nregs, start_index, rw,
5123 t4_read_indirect(adap, reg_addr, reg_data, buff, nregs,
5126 t4_write_indirect(adap, reg_addr, reg_data, buff, nregs,
5132 * t4_tp_pio_read - Read TP PIO registers
5133 * @adap: the adapter
5134 * @buff: where the indirect register values are written
5135 * @nregs: how many indirect registers to read
5136 * @start_index: index of first indirect register to read
5137 * @sleep_ok: if true we may sleep while awaiting command completion
5139 * Read TP PIO Registers
5141 void t4_tp_pio_read(struct adapter *adap, u32 *buff, u32 nregs,
5142 u32 start_index, bool sleep_ok)
5144 t4_tp_indirect_rw(adap, A_TP_PIO_ADDR, A_TP_PIO_DATA, buff, nregs,
5145 start_index, 1, sleep_ok);
5149 * t4_tp_pio_write - Write TP PIO registers
5150 * @adap: the adapter
5151 * @buff: where the indirect register values are stored
5152 * @nregs: how many indirect registers to write
5153 * @start_index: index of first indirect register to write
5154 * @sleep_ok: if true we may sleep while awaiting command completion
5156 * Write TP PIO Registers
5158 void t4_tp_pio_write(struct adapter *adap, const u32 *buff, u32 nregs,
5159 u32 start_index, bool sleep_ok)
5161 t4_tp_indirect_rw(adap, A_TP_PIO_ADDR, A_TP_PIO_DATA,
5162 __DECONST(u32 *, buff), nregs, start_index, 0, sleep_ok);
5166 * t4_tp_tm_pio_read - Read TP TM PIO registers
5167 * @adap: the adapter
5168 * @buff: where the indirect register values are written
5169 * @nregs: how many indirect registers to read
5170 * @start_index: index of first indirect register to read
5171 * @sleep_ok: if true we may sleep while awaiting command completion
5173 * Read TP TM PIO Registers
5175 void t4_tp_tm_pio_read(struct adapter *adap, u32 *buff, u32 nregs,
5176 u32 start_index, bool sleep_ok)
5178 t4_tp_indirect_rw(adap, A_TP_TM_PIO_ADDR, A_TP_TM_PIO_DATA, buff,
5179 nregs, start_index, 1, sleep_ok);
5183 * t4_tp_mib_read - Read TP MIB registers
5184 * @adap: the adapter
5185 * @buff: where the indirect register values are written
5186 * @nregs: how many indirect registers to read
5187 * @start_index: index of first indirect register to read
5188 * @sleep_ok: if true we may sleep while awaiting command completion
5190 * Read TP MIB Registers
5192 void t4_tp_mib_read(struct adapter *adap, u32 *buff, u32 nregs, u32 start_index,
5195 t4_tp_indirect_rw(adap, A_TP_MIB_INDEX, A_TP_MIB_DATA, buff, nregs,
5196 start_index, 1, sleep_ok);
5200 * t4_read_rss_key - read the global RSS key
5201 * @adap: the adapter
5202 * @key: 10-entry array holding the 320-bit RSS key
5203 * @sleep_ok: if true we may sleep while awaiting command completion
5205 * Reads the global 320-bit RSS key.
5207 void t4_read_rss_key(struct adapter *adap, u32 *key, bool sleep_ok)
5209 t4_tp_pio_read(adap, key, 10, A_TP_RSS_SECRET_KEY0, sleep_ok);
5213 * t4_write_rss_key - program one of the RSS keys
5214 * @adap: the adapter
5215 * @key: 10-entry array holding the 320-bit RSS key
5216 * @idx: which RSS key to write
5217 * @sleep_ok: if true we may sleep while awaiting command completion
5219 * Writes one of the RSS keys with the given 320-bit value. If @idx is
5220 * 0..15 the corresponding entry in the RSS key table is written,
5221 * otherwise the global RSS key is written.
5223 void t4_write_rss_key(struct adapter *adap, const u32 *key, int idx,
5226 u8 rss_key_addr_cnt = 16;
5227 u32 vrt = t4_read_reg(adap, A_TP_RSS_CONFIG_VRT);
5230 * T6 and later: for KeyMode 3 (per-vf and per-vf scramble),
5231 * allows access to key addresses 16-63 by using KeyWrAddrX
5232 * as index[5:4](upper 2) into key table
5234 if ((chip_id(adap) > CHELSIO_T5) &&
5235 (vrt & F_KEYEXTEND) && (G_KEYMODE(vrt) == 3))
5236 rss_key_addr_cnt = 32;
5238 t4_tp_pio_write(adap, key, 10, A_TP_RSS_SECRET_KEY0, sleep_ok);
5240 if (idx >= 0 && idx < rss_key_addr_cnt) {
5241 if (rss_key_addr_cnt > 16)
5242 t4_write_reg(adap, A_TP_RSS_CONFIG_VRT,
5243 vrt | V_KEYWRADDRX(idx >> 4) |
5244 V_T6_VFWRADDR(idx) | F_KEYWREN);
5246 t4_write_reg(adap, A_TP_RSS_CONFIG_VRT,
5247 vrt| V_KEYWRADDR(idx) | F_KEYWREN);
5252 * t4_read_rss_pf_config - read PF RSS Configuration Table
5253 * @adapter: the adapter
5254 * @index: the entry in the PF RSS table to read
5255 * @valp: where to store the returned value
5256 * @sleep_ok: if true we may sleep while awaiting command completion
5258 * Reads the PF RSS Configuration Table at the specified index and returns
5259 * the value found there.
5261 void t4_read_rss_pf_config(struct adapter *adapter, unsigned int index,
5262 u32 *valp, bool sleep_ok)
5264 t4_tp_pio_read(adapter, valp, 1, A_TP_RSS_PF0_CONFIG + index, sleep_ok);
5268 * t4_write_rss_pf_config - write PF RSS Configuration Table
5269 * @adapter: the adapter
5270 * @index: the entry in the VF RSS table to read
5271 * @val: the value to store
5272 * @sleep_ok: if true we may sleep while awaiting command completion
5274 * Writes the PF RSS Configuration Table at the specified index with the
5277 void t4_write_rss_pf_config(struct adapter *adapter, unsigned int index,
5278 u32 val, bool sleep_ok)
5280 t4_tp_pio_write(adapter, &val, 1, A_TP_RSS_PF0_CONFIG + index,
5285 * t4_read_rss_vf_config - read VF RSS Configuration Table
5286 * @adapter: the adapter
5287 * @index: the entry in the VF RSS table to read
5288 * @vfl: where to store the returned VFL
5289 * @vfh: where to store the returned VFH
5290 * @sleep_ok: if true we may sleep while awaiting command completion
5292 * Reads the VF RSS Configuration Table at the specified index and returns
5293 * the (VFL, VFH) values found there.
5295 void t4_read_rss_vf_config(struct adapter *adapter, unsigned int index,
5296 u32 *vfl, u32 *vfh, bool sleep_ok)
5298 u32 vrt, mask, data;
5300 if (chip_id(adapter) <= CHELSIO_T5) {
5301 mask = V_VFWRADDR(M_VFWRADDR);
5302 data = V_VFWRADDR(index);
5304 mask = V_T6_VFWRADDR(M_T6_VFWRADDR);
5305 data = V_T6_VFWRADDR(index);
5308 * Request that the index'th VF Table values be read into VFL/VFH.
5310 vrt = t4_read_reg(adapter, A_TP_RSS_CONFIG_VRT);
5311 vrt &= ~(F_VFRDRG | F_VFWREN | F_KEYWREN | mask);
5312 vrt |= data | F_VFRDEN;
5313 t4_write_reg(adapter, A_TP_RSS_CONFIG_VRT, vrt);
5316 * Grab the VFL/VFH values ...
5318 t4_tp_pio_read(adapter, vfl, 1, A_TP_RSS_VFL_CONFIG, sleep_ok);
5319 t4_tp_pio_read(adapter, vfh, 1, A_TP_RSS_VFH_CONFIG, sleep_ok);
5323 * t4_write_rss_vf_config - write VF RSS Configuration Table
5325 * @adapter: the adapter
5326 * @index: the entry in the VF RSS table to write
5327 * @vfl: the VFL to store
5328 * @vfh: the VFH to store
5330 * Writes the VF RSS Configuration Table at the specified index with the
5331 * specified (VFL, VFH) values.
5333 void t4_write_rss_vf_config(struct adapter *adapter, unsigned int index,
5334 u32 vfl, u32 vfh, bool sleep_ok)
5336 u32 vrt, mask, data;
5338 if (chip_id(adapter) <= CHELSIO_T5) {
5339 mask = V_VFWRADDR(M_VFWRADDR);
5340 data = V_VFWRADDR(index);
5342 mask = V_T6_VFWRADDR(M_T6_VFWRADDR);
5343 data = V_T6_VFWRADDR(index);
5347 * Load up VFL/VFH with the values to be written ...
5349 t4_tp_pio_write(adapter, &vfl, 1, A_TP_RSS_VFL_CONFIG, sleep_ok);
5350 t4_tp_pio_write(adapter, &vfh, 1, A_TP_RSS_VFH_CONFIG, sleep_ok);
5353 * Write the VFL/VFH into the VF Table at index'th location.
5355 vrt = t4_read_reg(adapter, A_TP_RSS_CONFIG_VRT);
5356 vrt &= ~(F_VFRDRG | F_VFWREN | F_KEYWREN | mask);
5357 vrt |= data | F_VFRDEN;
5358 t4_write_reg(adapter, A_TP_RSS_CONFIG_VRT, vrt);
5362 * t4_read_rss_pf_map - read PF RSS Map
5363 * @adapter: the adapter
5364 * @sleep_ok: if true we may sleep while awaiting command completion
5366 * Reads the PF RSS Map register and returns its value.
5368 u32 t4_read_rss_pf_map(struct adapter *adapter, bool sleep_ok)
5372 t4_tp_pio_read(adapter, &pfmap, 1, A_TP_RSS_PF_MAP, sleep_ok);
5378 * t4_write_rss_pf_map - write PF RSS Map
5379 * @adapter: the adapter
5380 * @pfmap: PF RSS Map value
5382 * Writes the specified value to the PF RSS Map register.
5384 void t4_write_rss_pf_map(struct adapter *adapter, u32 pfmap, bool sleep_ok)
5386 t4_tp_pio_write(adapter, &pfmap, 1, A_TP_RSS_PF_MAP, sleep_ok);
5390 * t4_read_rss_pf_mask - read PF RSS Mask
5391 * @adapter: the adapter
5392 * @sleep_ok: if true we may sleep while awaiting command completion
5394 * Reads the PF RSS Mask register and returns its value.
5396 u32 t4_read_rss_pf_mask(struct adapter *adapter, bool sleep_ok)
5400 t4_tp_pio_read(adapter, &pfmask, 1, A_TP_RSS_PF_MSK, sleep_ok);
5406 * t4_write_rss_pf_mask - write PF RSS Mask
5407 * @adapter: the adapter
5408 * @pfmask: PF RSS Mask value
5410 * Writes the specified value to the PF RSS Mask register.
5412 void t4_write_rss_pf_mask(struct adapter *adapter, u32 pfmask, bool sleep_ok)
5414 t4_tp_pio_write(adapter, &pfmask, 1, A_TP_RSS_PF_MSK, sleep_ok);
5418 * t4_tp_get_tcp_stats - read TP's TCP MIB counters
5419 * @adap: the adapter
5420 * @v4: holds the TCP/IP counter values
5421 * @v6: holds the TCP/IPv6 counter values
5422 * @sleep_ok: if true we may sleep while awaiting command completion
5424 * Returns the values of TP's TCP/IP and TCP/IPv6 MIB counters.
5425 * Either @v4 or @v6 may be %NULL to skip the corresponding stats.
5427 void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
5428 struct tp_tcp_stats *v6, bool sleep_ok)
5430 u32 val[A_TP_MIB_TCP_RXT_SEG_LO - A_TP_MIB_TCP_OUT_RST + 1];
5432 #define STAT_IDX(x) ((A_TP_MIB_TCP_##x) - A_TP_MIB_TCP_OUT_RST)
5433 #define STAT(x) val[STAT_IDX(x)]
5434 #define STAT64(x) (((u64)STAT(x##_HI) << 32) | STAT(x##_LO))
5437 t4_tp_mib_read(adap, val, ARRAY_SIZE(val),
5438 A_TP_MIB_TCP_OUT_RST, sleep_ok);
5439 v4->tcp_out_rsts = STAT(OUT_RST);
5440 v4->tcp_in_segs = STAT64(IN_SEG);
5441 v4->tcp_out_segs = STAT64(OUT_SEG);
5442 v4->tcp_retrans_segs = STAT64(RXT_SEG);
5445 t4_tp_mib_read(adap, val, ARRAY_SIZE(val),
5446 A_TP_MIB_TCP_V6OUT_RST, sleep_ok);
5447 v6->tcp_out_rsts = STAT(OUT_RST);
5448 v6->tcp_in_segs = STAT64(IN_SEG);
5449 v6->tcp_out_segs = STAT64(OUT_SEG);
5450 v6->tcp_retrans_segs = STAT64(RXT_SEG);
5458 * t4_tp_get_err_stats - read TP's error MIB counters
5459 * @adap: the adapter
5460 * @st: holds the counter values
5461 * @sleep_ok: if true we may sleep while awaiting command completion
5463 * Returns the values of TP's error counters.
5465 void t4_tp_get_err_stats(struct adapter *adap, struct tp_err_stats *st,
5468 int nchan = adap->chip_params->nchan;
5470 t4_tp_mib_read(adap, st->mac_in_errs, nchan, A_TP_MIB_MAC_IN_ERR_0,
5473 t4_tp_mib_read(adap, st->hdr_in_errs, nchan, A_TP_MIB_HDR_IN_ERR_0,
5476 t4_tp_mib_read(adap, st->tcp_in_errs, nchan, A_TP_MIB_TCP_IN_ERR_0,
5479 t4_tp_mib_read(adap, st->tnl_cong_drops, nchan,
5480 A_TP_MIB_TNL_CNG_DROP_0, sleep_ok);
5482 t4_tp_mib_read(adap, st->ofld_chan_drops, nchan,
5483 A_TP_MIB_OFD_CHN_DROP_0, sleep_ok);
5485 t4_tp_mib_read(adap, st->tnl_tx_drops, nchan, A_TP_MIB_TNL_DROP_0,
5488 t4_tp_mib_read(adap, st->ofld_vlan_drops, nchan,
5489 A_TP_MIB_OFD_VLN_DROP_0, sleep_ok);
5491 t4_tp_mib_read(adap, st->tcp6_in_errs, nchan,
5492 A_TP_MIB_TCP_V6IN_ERR_0, sleep_ok);
5494 t4_tp_mib_read(adap, &st->ofld_no_neigh, 2, A_TP_MIB_OFD_ARP_DROP,
5499 * t4_tp_get_proxy_stats - read TP's proxy MIB counters
5500 * @adap: the adapter
5501 * @st: holds the counter values
5503 * Returns the values of TP's proxy counters.
5505 void t4_tp_get_proxy_stats(struct adapter *adap, struct tp_proxy_stats *st,
5508 int nchan = adap->chip_params->nchan;
5510 t4_tp_mib_read(adap, st->proxy, nchan, A_TP_MIB_TNL_LPBK_0, sleep_ok);
5514 * t4_tp_get_cpl_stats - read TP's CPL MIB counters
5515 * @adap: the adapter
5516 * @st: holds the counter values
5517 * @sleep_ok: if true we may sleep while awaiting command completion
5519 * Returns the values of TP's CPL counters.
5521 void t4_tp_get_cpl_stats(struct adapter *adap, struct tp_cpl_stats *st,
5524 int nchan = adap->chip_params->nchan;
5526 t4_tp_mib_read(adap, st->req, nchan, A_TP_MIB_CPL_IN_REQ_0, sleep_ok);
5528 t4_tp_mib_read(adap, st->rsp, nchan, A_TP_MIB_CPL_OUT_RSP_0, sleep_ok);
5532 * t4_tp_get_rdma_stats - read TP's RDMA MIB counters
5533 * @adap: the adapter
5534 * @st: holds the counter values
5536 * Returns the values of TP's RDMA counters.
5538 void t4_tp_get_rdma_stats(struct adapter *adap, struct tp_rdma_stats *st,
5541 t4_tp_mib_read(adap, &st->rqe_dfr_pkt, 2, A_TP_MIB_RQE_DFR_PKT,
5546 * t4_get_fcoe_stats - read TP's FCoE MIB counters for a port
5547 * @adap: the adapter
5548 * @idx: the port index
5549 * @st: holds the counter values
5550 * @sleep_ok: if true we may sleep while awaiting command completion
5552 * Returns the values of TP's FCoE counters for the selected port.
5554 void t4_get_fcoe_stats(struct adapter *adap, unsigned int idx,
5555 struct tp_fcoe_stats *st, bool sleep_ok)
5559 t4_tp_mib_read(adap, &st->frames_ddp, 1, A_TP_MIB_FCOE_DDP_0 + idx,
5562 t4_tp_mib_read(adap, &st->frames_drop, 1,
5563 A_TP_MIB_FCOE_DROP_0 + idx, sleep_ok);
5565 t4_tp_mib_read(adap, val, 2, A_TP_MIB_FCOE_BYTE_0_HI + 2 * idx,
5568 st->octets_ddp = ((u64)val[0] << 32) | val[1];
5572 * t4_get_usm_stats - read TP's non-TCP DDP MIB counters
5573 * @adap: the adapter
5574 * @st: holds the counter values
5575 * @sleep_ok: if true we may sleep while awaiting command completion
5577 * Returns the values of TP's counters for non-TCP directly-placed packets.
5579 void t4_get_usm_stats(struct adapter *adap, struct tp_usm_stats *st,
5584 t4_tp_mib_read(adap, val, 4, A_TP_MIB_USM_PKTS, sleep_ok);
5586 st->frames = val[0];
5588 st->octets = ((u64)val[2] << 32) | val[3];
5592 * t4_read_mtu_tbl - returns the values in the HW path MTU table
5593 * @adap: the adapter
5594 * @mtus: where to store the MTU values
5595 * @mtu_log: where to store the MTU base-2 log (may be %NULL)
5597 * Reads the HW path MTU table.
5599 void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log)
5604 for (i = 0; i < NMTUS; ++i) {
5605 t4_write_reg(adap, A_TP_MTU_TABLE,
5606 V_MTUINDEX(0xff) | V_MTUVALUE(i));
5607 v = t4_read_reg(adap, A_TP_MTU_TABLE);
5608 mtus[i] = G_MTUVALUE(v);
5610 mtu_log[i] = G_MTUWIDTH(v);
5615 * t4_read_cong_tbl - reads the congestion control table
5616 * @adap: the adapter
5617 * @incr: where to store the alpha values
5619 * Reads the additive increments programmed into the HW congestion
5622 void t4_read_cong_tbl(struct adapter *adap, u16 incr[NMTUS][NCCTRL_WIN])
5624 unsigned int mtu, w;
5626 for (mtu = 0; mtu < NMTUS; ++mtu)
5627 for (w = 0; w < NCCTRL_WIN; ++w) {
5628 t4_write_reg(adap, A_TP_CCTRL_TABLE,
5629 V_ROWINDEX(0xffff) | (mtu << 5) | w);
5630 incr[mtu][w] = (u16)t4_read_reg(adap,
5631 A_TP_CCTRL_TABLE) & 0x1fff;
5636 * t4_tp_wr_bits_indirect - set/clear bits in an indirect TP register
5637 * @adap: the adapter
5638 * @addr: the indirect TP register address
5639 * @mask: specifies the field within the register to modify
5640 * @val: new value for the field
5642 * Sets a field of an indirect TP register to the given value.
5644 void t4_tp_wr_bits_indirect(struct adapter *adap, unsigned int addr,
5645 unsigned int mask, unsigned int val)
5647 t4_write_reg(adap, A_TP_PIO_ADDR, addr);
5648 val |= t4_read_reg(adap, A_TP_PIO_DATA) & ~mask;
5649 t4_write_reg(adap, A_TP_PIO_DATA, val);
5653 * init_cong_ctrl - initialize congestion control parameters
5654 * @a: the alpha values for congestion control
5655 * @b: the beta values for congestion control
5657 * Initialize the congestion control parameters.
5659 static void init_cong_ctrl(unsigned short *a, unsigned short *b)
5661 a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = a[8] = 1;
5686 b[0] = b[1] = b[2] = b[3] = b[4] = b[5] = b[6] = b[7] = b[8] = 0;
5689 b[13] = b[14] = b[15] = b[16] = 3;
5690 b[17] = b[18] = b[19] = b[20] = b[21] = 4;
5691 b[22] = b[23] = b[24] = b[25] = b[26] = b[27] = 5;
5696 /* The minimum additive increment value for the congestion control table */
5697 #define CC_MIN_INCR 2U
5700 * t4_load_mtus - write the MTU and congestion control HW tables
5701 * @adap: the adapter
5702 * @mtus: the values for the MTU table
5703 * @alpha: the values for the congestion control alpha parameter
5704 * @beta: the values for the congestion control beta parameter
5706 * Write the HW MTU table with the supplied MTUs and the high-speed
5707 * congestion control table with the supplied alpha, beta, and MTUs.
5708 * We write the two tables together because the additive increments
5709 * depend on the MTUs.
5711 void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
5712 const unsigned short *alpha, const unsigned short *beta)
5714 static const unsigned int avg_pkts[NCCTRL_WIN] = {
5715 2, 6, 10, 14, 20, 28, 40, 56, 80, 112, 160, 224, 320, 448, 640,
5716 896, 1281, 1792, 2560, 3584, 5120, 7168, 10240, 14336, 20480,
5717 28672, 40960, 57344, 81920, 114688, 163840, 229376
5722 for (i = 0; i < NMTUS; ++i) {
5723 unsigned int mtu = mtus[i];
5724 unsigned int log2 = fls(mtu);
5726 if (!(mtu & ((1 << log2) >> 2))) /* round */
5728 t4_write_reg(adap, A_TP_MTU_TABLE, V_MTUINDEX(i) |
5729 V_MTUWIDTH(log2) | V_MTUVALUE(mtu));
5731 for (w = 0; w < NCCTRL_WIN; ++w) {
5734 inc = max(((mtu - 40) * alpha[w]) / avg_pkts[w],
5737 t4_write_reg(adap, A_TP_CCTRL_TABLE, (i << 21) |
5738 (w << 16) | (beta[w] << 13) | inc);
5744 * t4_set_pace_tbl - set the pace table
5745 * @adap: the adapter
5746 * @pace_vals: the pace values in microseconds
5747 * @start: index of the first entry in the HW pace table to set
5748 * @n: how many entries to set
5750 * Sets (a subset of the) HW pace table.
5752 int t4_set_pace_tbl(struct adapter *adap, const unsigned int *pace_vals,
5753 unsigned int start, unsigned int n)
5755 unsigned int vals[NTX_SCHED], i;
5756 unsigned int tick_ns = dack_ticks_to_usec(adap, 1000);
5761 /* convert values from us to dack ticks, rounding to closest value */
5762 for (i = 0; i < n; i++, pace_vals++) {
5763 vals[i] = (1000 * *pace_vals + tick_ns / 2) / tick_ns;
5764 if (vals[i] > 0x7ff)
5766 if (*pace_vals && vals[i] == 0)
5769 for (i = 0; i < n; i++, start++)
5770 t4_write_reg(adap, A_TP_PACE_TABLE, (start << 16) | vals[i]);
5775 * t4_set_sched_bps - set the bit rate for a HW traffic scheduler
5776 * @adap: the adapter
5777 * @kbps: target rate in Kbps
5778 * @sched: the scheduler index
5780 * Configure a Tx HW scheduler for the target rate.
5782 int t4_set_sched_bps(struct adapter *adap, int sched, unsigned int kbps)
5784 unsigned int v, tps, cpt, bpt, delta, mindelta = ~0;
5785 unsigned int clk = adap->params.vpd.cclk * 1000;
5786 unsigned int selected_cpt = 0, selected_bpt = 0;
5789 kbps *= 125; /* -> bytes */
5790 for (cpt = 1; cpt <= 255; cpt++) {
5792 bpt = (kbps + tps / 2) / tps;
5793 if (bpt > 0 && bpt <= 255) {
5795 delta = v >= kbps ? v - kbps : kbps - v;
5796 if (delta < mindelta) {
5801 } else if (selected_cpt)
5807 t4_write_reg(adap, A_TP_TM_PIO_ADDR,
5808 A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2);
5809 v = t4_read_reg(adap, A_TP_TM_PIO_DATA);
5811 v = (v & 0xffff) | (selected_cpt << 16) | (selected_bpt << 24);
5813 v = (v & 0xffff0000) | selected_cpt | (selected_bpt << 8);
5814 t4_write_reg(adap, A_TP_TM_PIO_DATA, v);
5819 * t4_set_sched_ipg - set the IPG for a Tx HW packet rate scheduler
5820 * @adap: the adapter
5821 * @sched: the scheduler index
5822 * @ipg: the interpacket delay in tenths of nanoseconds
5824 * Set the interpacket delay for a HW packet rate scheduler.
5826 int t4_set_sched_ipg(struct adapter *adap, int sched, unsigned int ipg)
5828 unsigned int v, addr = A_TP_TX_MOD_Q1_Q0_TIMER_SEPARATOR - sched / 2;
5830 /* convert ipg to nearest number of core clocks */
5831 ipg *= core_ticks_per_usec(adap);
5832 ipg = (ipg + 5000) / 10000;
5833 if (ipg > M_TXTIMERSEPQ0)
5836 t4_write_reg(adap, A_TP_TM_PIO_ADDR, addr);
5837 v = t4_read_reg(adap, A_TP_TM_PIO_DATA);
5839 v = (v & V_TXTIMERSEPQ0(M_TXTIMERSEPQ0)) | V_TXTIMERSEPQ1(ipg);
5841 v = (v & V_TXTIMERSEPQ1(M_TXTIMERSEPQ1)) | V_TXTIMERSEPQ0(ipg);
5842 t4_write_reg(adap, A_TP_TM_PIO_DATA, v);
5843 t4_read_reg(adap, A_TP_TM_PIO_DATA);
5848 * Calculates a rate in bytes/s given the number of 256-byte units per 4K core
5849 * clocks. The formula is
5851 * bytes/s = bytes256 * 256 * ClkFreq / 4096
5853 * which is equivalent to
5855 * bytes/s = 62.5 * bytes256 * ClkFreq_ms
5857 static u64 chan_rate(struct adapter *adap, unsigned int bytes256)
5859 u64 v = (u64)bytes256 * adap->params.vpd.cclk;
5861 return v * 62 + v / 2;
5865 * t4_get_chan_txrate - get the current per channel Tx rates
5866 * @adap: the adapter
5867 * @nic_rate: rates for NIC traffic
5868 * @ofld_rate: rates for offloaded traffic
5870 * Return the current Tx rates in bytes/s for NIC and offloaded traffic
5873 void t4_get_chan_txrate(struct adapter *adap, u64 *nic_rate, u64 *ofld_rate)
5877 v = t4_read_reg(adap, A_TP_TX_TRATE);
5878 nic_rate[0] = chan_rate(adap, G_TNLRATE0(v));
5879 nic_rate[1] = chan_rate(adap, G_TNLRATE1(v));
5880 if (adap->chip_params->nchan > 2) {
5881 nic_rate[2] = chan_rate(adap, G_TNLRATE2(v));
5882 nic_rate[3] = chan_rate(adap, G_TNLRATE3(v));
5885 v = t4_read_reg(adap, A_TP_TX_ORATE);
5886 ofld_rate[0] = chan_rate(adap, G_OFDRATE0(v));
5887 ofld_rate[1] = chan_rate(adap, G_OFDRATE1(v));
5888 if (adap->chip_params->nchan > 2) {
5889 ofld_rate[2] = chan_rate(adap, G_OFDRATE2(v));
5890 ofld_rate[3] = chan_rate(adap, G_OFDRATE3(v));
5895 * t4_set_trace_filter - configure one of the tracing filters
5896 * @adap: the adapter
5897 * @tp: the desired trace filter parameters
5898 * @idx: which filter to configure
5899 * @enable: whether to enable or disable the filter
5901 * Configures one of the tracing filters available in HW. If @tp is %NULL
5902 * it indicates that the filter is already written in the register and it
5903 * just needs to be enabled or disabled.
5905 int t4_set_trace_filter(struct adapter *adap, const struct trace_params *tp,
5906 int idx, int enable)
5908 int i, ofst = idx * 4;
5909 u32 data_reg, mask_reg, cfg;
5910 u32 multitrc = F_TRCMULTIFILTER;
5911 u32 en = is_t4(adap) ? F_TFEN : F_T5_TFEN;
5913 if (idx < 0 || idx >= NTRACE)
5916 if (tp == NULL || !enable) {
5917 t4_set_reg_field(adap, A_MPS_TRC_FILTER_MATCH_CTL_A + ofst, en,
5923 * TODO - After T4 data book is updated, specify the exact
5926 * See T4 data book - MPS section for a complete description
5927 * of the below if..else handling of A_MPS_TRC_CFG register
5930 cfg = t4_read_reg(adap, A_MPS_TRC_CFG);
5931 if (cfg & F_TRCMULTIFILTER) {
5933 * If multiple tracers are enabled, then maximum
5934 * capture size is 2.5KB (FIFO size of a single channel)
5935 * minus 2 flits for CPL_TRACE_PKT header.
5937 if (tp->snap_len > ((10 * 1024 / 4) - (2 * 8)))
5941 * If multiple tracers are disabled, to avoid deadlocks
5942 * maximum packet capture size of 9600 bytes is recommended.
5943 * Also in this mode, only trace0 can be enabled and running.
5946 if (tp->snap_len > 9600 || idx)
5950 if (tp->port > (is_t4(adap) ? 11 : 19) || tp->invert > 1 ||
5951 tp->skip_len > M_TFLENGTH || tp->skip_ofst > M_TFOFFSET ||
5952 tp->min_len > M_TFMINPKTSIZE)
5955 /* stop the tracer we'll be changing */
5956 t4_set_reg_field(adap, A_MPS_TRC_FILTER_MATCH_CTL_A + ofst, en, 0);
5958 idx *= (A_MPS_TRC_FILTER1_MATCH - A_MPS_TRC_FILTER0_MATCH);
5959 data_reg = A_MPS_TRC_FILTER0_MATCH + idx;
5960 mask_reg = A_MPS_TRC_FILTER0_DONT_CARE + idx;
5962 for (i = 0; i < TRACE_LEN / 4; i++, data_reg += 4, mask_reg += 4) {
5963 t4_write_reg(adap, data_reg, tp->data[i]);
5964 t4_write_reg(adap, mask_reg, ~tp->mask[i]);
5966 t4_write_reg(adap, A_MPS_TRC_FILTER_MATCH_CTL_B + ofst,
5967 V_TFCAPTUREMAX(tp->snap_len) |
5968 V_TFMINPKTSIZE(tp->min_len));
5969 t4_write_reg(adap, A_MPS_TRC_FILTER_MATCH_CTL_A + ofst,
5970 V_TFOFFSET(tp->skip_ofst) | V_TFLENGTH(tp->skip_len) | en |
5972 V_TFPORT(tp->port) | V_TFINVERTMATCH(tp->invert) :
5973 V_T5_TFPORT(tp->port) | V_T5_TFINVERTMATCH(tp->invert)));
5979 * t4_get_trace_filter - query one of the tracing filters
5980 * @adap: the adapter
5981 * @tp: the current trace filter parameters
5982 * @idx: which trace filter to query
5983 * @enabled: non-zero if the filter is enabled
5985 * Returns the current settings of one of the HW tracing filters.
5987 void t4_get_trace_filter(struct adapter *adap, struct trace_params *tp, int idx,
5991 int i, ofst = idx * 4;
5992 u32 data_reg, mask_reg;
5994 ctla = t4_read_reg(adap, A_MPS_TRC_FILTER_MATCH_CTL_A + ofst);
5995 ctlb = t4_read_reg(adap, A_MPS_TRC_FILTER_MATCH_CTL_B + ofst);
5998 *enabled = !!(ctla & F_TFEN);
5999 tp->port = G_TFPORT(ctla);
6000 tp->invert = !!(ctla & F_TFINVERTMATCH);
6002 *enabled = !!(ctla & F_T5_TFEN);
6003 tp->port = G_T5_TFPORT(ctla);
6004 tp->invert = !!(ctla & F_T5_TFINVERTMATCH);
6006 tp->snap_len = G_TFCAPTUREMAX(ctlb);
6007 tp->min_len = G_TFMINPKTSIZE(ctlb);
6008 tp->skip_ofst = G_TFOFFSET(ctla);
6009 tp->skip_len = G_TFLENGTH(ctla);
6011 ofst = (A_MPS_TRC_FILTER1_MATCH - A_MPS_TRC_FILTER0_MATCH) * idx;
6012 data_reg = A_MPS_TRC_FILTER0_MATCH + ofst;
6013 mask_reg = A_MPS_TRC_FILTER0_DONT_CARE + ofst;
6015 for (i = 0; i < TRACE_LEN / 4; i++, data_reg += 4, mask_reg += 4) {
6016 tp->mask[i] = ~t4_read_reg(adap, mask_reg);
6017 tp->data[i] = t4_read_reg(adap, data_reg) & tp->mask[i];
6022 * t4_pmtx_get_stats - returns the HW stats from PMTX
6023 * @adap: the adapter
6024 * @cnt: where to store the count statistics
6025 * @cycles: where to store the cycle statistics
6027 * Returns performance statistics from PMTX.
6029 void t4_pmtx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
6034 for (i = 0; i < adap->chip_params->pm_stats_cnt; i++) {
6035 t4_write_reg(adap, A_PM_TX_STAT_CONFIG, i + 1);
6036 cnt[i] = t4_read_reg(adap, A_PM_TX_STAT_COUNT);
6038 cycles[i] = t4_read_reg64(adap, A_PM_TX_STAT_LSB);
6040 t4_read_indirect(adap, A_PM_TX_DBG_CTRL,
6041 A_PM_TX_DBG_DATA, data, 2,
6042 A_PM_TX_DBG_STAT_MSB);
6043 cycles[i] = (((u64)data[0] << 32) | data[1]);
6049 * t4_pmrx_get_stats - returns the HW stats from PMRX
6050 * @adap: the adapter
6051 * @cnt: where to store the count statistics
6052 * @cycles: where to store the cycle statistics
6054 * Returns performance statistics from PMRX.
6056 void t4_pmrx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
6061 for (i = 0; i < adap->chip_params->pm_stats_cnt; i++) {
6062 t4_write_reg(adap, A_PM_RX_STAT_CONFIG, i + 1);
6063 cnt[i] = t4_read_reg(adap, A_PM_RX_STAT_COUNT);
6065 cycles[i] = t4_read_reg64(adap, A_PM_RX_STAT_LSB);
6067 t4_read_indirect(adap, A_PM_RX_DBG_CTRL,
6068 A_PM_RX_DBG_DATA, data, 2,
6069 A_PM_RX_DBG_STAT_MSB);
6070 cycles[i] = (((u64)data[0] << 32) | data[1]);
6076 * t4_get_mps_bg_map - return the buffer groups associated with a port
6077 * @adap: the adapter
6078 * @idx: the port index
6080 * Returns a bitmap indicating which MPS buffer groups are associated
6081 * with the given port. Bit i is set if buffer group i is used by the
6084 static unsigned int t4_get_mps_bg_map(struct adapter *adap, int idx)
6088 if (adap->params.mps_bg_map)
6089 return ((adap->params.mps_bg_map >> (idx << 3)) & 0xff);
6091 n = G_NUMPORTS(t4_read_reg(adap, A_MPS_CMN_CTL));
6093 return idx == 0 ? 0xf : 0;
6094 if (n == 1 && chip_id(adap) <= CHELSIO_T5)
6095 return idx < 2 ? (3 << (2 * idx)) : 0;
6100 * TP RX e-channels associated with the port.
6102 static unsigned int t4_get_rx_e_chan_map(struct adapter *adap, int idx)
6104 u32 n = G_NUMPORTS(t4_read_reg(adap, A_MPS_CMN_CTL));
6107 return idx == 0 ? 0xf : 0;
6108 if (n == 1 && chip_id(adap) <= CHELSIO_T5)
6109 return idx < 2 ? (3 << (2 * idx)) : 0;
6114 * t4_get_port_type_description - return Port Type string description
6115 * @port_type: firmware Port Type enumeration
6117 const char *t4_get_port_type_description(enum fw_port_type port_type)
6119 static const char *const port_type_description[] = {
6144 if (port_type < ARRAY_SIZE(port_type_description))
6145 return port_type_description[port_type];
6150 * t4_get_port_stats_offset - collect port stats relative to a previous
6152 * @adap: The adapter
6154 * @stats: Current stats to fill
6155 * @offset: Previous stats snapshot
6157 void t4_get_port_stats_offset(struct adapter *adap, int idx,
6158 struct port_stats *stats,
6159 struct port_stats *offset)
6164 t4_get_port_stats(adap, idx, stats);
6165 for (i = 0, s = (u64 *)stats, o = (u64 *)offset ;
6166 i < (sizeof(struct port_stats)/sizeof(u64)) ;
6172 * t4_get_port_stats - collect port statistics
6173 * @adap: the adapter
6174 * @idx: the port index
6175 * @p: the stats structure to fill
6177 * Collect statistics related to the given port from HW.
6179 void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p)
6181 u32 bgmap = adap2pinfo(adap, idx)->mps_bg_map;
6182 u32 stat_ctl = t4_read_reg(adap, A_MPS_STAT_CTL);
6184 #define GET_STAT(name) \
6185 t4_read_reg64(adap, \
6186 (is_t4(adap) ? PORT_REG(idx, A_MPS_PORT_STAT_##name##_L) : \
6187 T5_PORT_REG(idx, A_MPS_PORT_STAT_##name##_L)))
6188 #define GET_STAT_COM(name) t4_read_reg64(adap, A_MPS_STAT_##name##_L)
6190 p->tx_pause = GET_STAT(TX_PORT_PAUSE);
6191 p->tx_octets = GET_STAT(TX_PORT_BYTES);
6192 p->tx_frames = GET_STAT(TX_PORT_FRAMES);
6193 p->tx_bcast_frames = GET_STAT(TX_PORT_BCAST);
6194 p->tx_mcast_frames = GET_STAT(TX_PORT_MCAST);
6195 p->tx_ucast_frames = GET_STAT(TX_PORT_UCAST);
6196 p->tx_error_frames = GET_STAT(TX_PORT_ERROR);
6197 p->tx_frames_64 = GET_STAT(TX_PORT_64B);
6198 p->tx_frames_65_127 = GET_STAT(TX_PORT_65B_127B);
6199 p->tx_frames_128_255 = GET_STAT(TX_PORT_128B_255B);
6200 p->tx_frames_256_511 = GET_STAT(TX_PORT_256B_511B);
6201 p->tx_frames_512_1023 = GET_STAT(TX_PORT_512B_1023B);
6202 p->tx_frames_1024_1518 = GET_STAT(TX_PORT_1024B_1518B);
6203 p->tx_frames_1519_max = GET_STAT(TX_PORT_1519B_MAX);
6204 p->tx_drop = GET_STAT(TX_PORT_DROP);
6205 p->tx_ppp0 = GET_STAT(TX_PORT_PPP0);
6206 p->tx_ppp1 = GET_STAT(TX_PORT_PPP1);
6207 p->tx_ppp2 = GET_STAT(TX_PORT_PPP2);
6208 p->tx_ppp3 = GET_STAT(TX_PORT_PPP3);
6209 p->tx_ppp4 = GET_STAT(TX_PORT_PPP4);
6210 p->tx_ppp5 = GET_STAT(TX_PORT_PPP5);
6211 p->tx_ppp6 = GET_STAT(TX_PORT_PPP6);
6212 p->tx_ppp7 = GET_STAT(TX_PORT_PPP7);
6214 if (chip_id(adap) >= CHELSIO_T5) {
6215 if (stat_ctl & F_COUNTPAUSESTATTX) {
6216 p->tx_frames -= p->tx_pause;
6217 p->tx_octets -= p->tx_pause * 64;
6219 if (stat_ctl & F_COUNTPAUSEMCTX)
6220 p->tx_mcast_frames -= p->tx_pause;
6223 p->rx_pause = GET_STAT(RX_PORT_PAUSE);
6224 p->rx_octets = GET_STAT(RX_PORT_BYTES);
6225 p->rx_frames = GET_STAT(RX_PORT_FRAMES);
6226 p->rx_bcast_frames = GET_STAT(RX_PORT_BCAST);
6227 p->rx_mcast_frames = GET_STAT(RX_PORT_MCAST);
6228 p->rx_ucast_frames = GET_STAT(RX_PORT_UCAST);
6229 p->rx_too_long = GET_STAT(RX_PORT_MTU_ERROR);
6230 p->rx_jabber = GET_STAT(RX_PORT_MTU_CRC_ERROR);
6231 p->rx_fcs_err = GET_STAT(RX_PORT_CRC_ERROR);
6232 p->rx_len_err = GET_STAT(RX_PORT_LEN_ERROR);
6233 p->rx_symbol_err = GET_STAT(RX_PORT_SYM_ERROR);
6234 p->rx_runt = GET_STAT(RX_PORT_LESS_64B);
6235 p->rx_frames_64 = GET_STAT(RX_PORT_64B);
6236 p->rx_frames_65_127 = GET_STAT(RX_PORT_65B_127B);
6237 p->rx_frames_128_255 = GET_STAT(RX_PORT_128B_255B);
6238 p->rx_frames_256_511 = GET_STAT(RX_PORT_256B_511B);
6239 p->rx_frames_512_1023 = GET_STAT(RX_PORT_512B_1023B);
6240 p->rx_frames_1024_1518 = GET_STAT(RX_PORT_1024B_1518B);
6241 p->rx_frames_1519_max = GET_STAT(RX_PORT_1519B_MAX);
6242 p->rx_ppp0 = GET_STAT(RX_PORT_PPP0);
6243 p->rx_ppp1 = GET_STAT(RX_PORT_PPP1);
6244 p->rx_ppp2 = GET_STAT(RX_PORT_PPP2);
6245 p->rx_ppp3 = GET_STAT(RX_PORT_PPP3);
6246 p->rx_ppp4 = GET_STAT(RX_PORT_PPP4);
6247 p->rx_ppp5 = GET_STAT(RX_PORT_PPP5);
6248 p->rx_ppp6 = GET_STAT(RX_PORT_PPP6);
6249 p->rx_ppp7 = GET_STAT(RX_PORT_PPP7);
6251 if (chip_id(adap) >= CHELSIO_T5) {
6252 if (stat_ctl & F_COUNTPAUSESTATRX) {
6253 p->rx_frames -= p->rx_pause;
6254 p->rx_octets -= p->rx_pause * 64;
6256 if (stat_ctl & F_COUNTPAUSEMCRX)
6257 p->rx_mcast_frames -= p->rx_pause;
6260 p->rx_ovflow0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_MAC_DROP_FRAME) : 0;
6261 p->rx_ovflow1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_MAC_DROP_FRAME) : 0;
6262 p->rx_ovflow2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_MAC_DROP_FRAME) : 0;
6263 p->rx_ovflow3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_MAC_DROP_FRAME) : 0;
6264 p->rx_trunc0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_MAC_TRUNC_FRAME) : 0;
6265 p->rx_trunc1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_MAC_TRUNC_FRAME) : 0;
6266 p->rx_trunc2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_MAC_TRUNC_FRAME) : 0;
6267 p->rx_trunc3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_MAC_TRUNC_FRAME) : 0;
6274 * t4_get_lb_stats - collect loopback port statistics
6275 * @adap: the adapter
6276 * @idx: the loopback port index
6277 * @p: the stats structure to fill
6279 * Return HW statistics for the given loopback port.
6281 void t4_get_lb_stats(struct adapter *adap, int idx, struct lb_port_stats *p)
6283 u32 bgmap = adap2pinfo(adap, idx)->mps_bg_map;
6285 #define GET_STAT(name) \
6286 t4_read_reg64(adap, \
6288 PORT_REG(idx, A_MPS_PORT_STAT_LB_PORT_##name##_L) : \
6289 T5_PORT_REG(idx, A_MPS_PORT_STAT_LB_PORT_##name##_L)))
6290 #define GET_STAT_COM(name) t4_read_reg64(adap, A_MPS_STAT_##name##_L)
6292 p->octets = GET_STAT(BYTES);
6293 p->frames = GET_STAT(FRAMES);
6294 p->bcast_frames = GET_STAT(BCAST);
6295 p->mcast_frames = GET_STAT(MCAST);
6296 p->ucast_frames = GET_STAT(UCAST);
6297 p->error_frames = GET_STAT(ERROR);
6299 p->frames_64 = GET_STAT(64B);
6300 p->frames_65_127 = GET_STAT(65B_127B);
6301 p->frames_128_255 = GET_STAT(128B_255B);
6302 p->frames_256_511 = GET_STAT(256B_511B);
6303 p->frames_512_1023 = GET_STAT(512B_1023B);
6304 p->frames_1024_1518 = GET_STAT(1024B_1518B);
6305 p->frames_1519_max = GET_STAT(1519B_MAX);
6306 p->drop = GET_STAT(DROP_FRAMES);
6308 p->ovflow0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_LB_DROP_FRAME) : 0;
6309 p->ovflow1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_LB_DROP_FRAME) : 0;
6310 p->ovflow2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_LB_DROP_FRAME) : 0;
6311 p->ovflow3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_LB_DROP_FRAME) : 0;
6312 p->trunc0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_LB_TRUNC_FRAME) : 0;
6313 p->trunc1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_LB_TRUNC_FRAME) : 0;
6314 p->trunc2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_LB_TRUNC_FRAME) : 0;
6315 p->trunc3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_LB_TRUNC_FRAME) : 0;
6322 * t4_wol_magic_enable - enable/disable magic packet WoL
6323 * @adap: the adapter
6324 * @port: the physical port index
6325 * @addr: MAC address expected in magic packets, %NULL to disable
6327 * Enables/disables magic packet wake-on-LAN for the selected port.
6329 void t4_wol_magic_enable(struct adapter *adap, unsigned int port,
6332 u32 mag_id_reg_l, mag_id_reg_h, port_cfg_reg;
6335 mag_id_reg_l = PORT_REG(port, A_XGMAC_PORT_MAGIC_MACID_LO);
6336 mag_id_reg_h = PORT_REG(port, A_XGMAC_PORT_MAGIC_MACID_HI);
6337 port_cfg_reg = PORT_REG(port, A_XGMAC_PORT_CFG2);
6339 mag_id_reg_l = T5_PORT_REG(port, A_MAC_PORT_MAGIC_MACID_LO);
6340 mag_id_reg_h = T5_PORT_REG(port, A_MAC_PORT_MAGIC_MACID_HI);
6341 port_cfg_reg = T5_PORT_REG(port, A_MAC_PORT_CFG2);
6345 t4_write_reg(adap, mag_id_reg_l,
6346 (addr[2] << 24) | (addr[3] << 16) |
6347 (addr[4] << 8) | addr[5]);
6348 t4_write_reg(adap, mag_id_reg_h,
6349 (addr[0] << 8) | addr[1]);
6351 t4_set_reg_field(adap, port_cfg_reg, F_MAGICEN,
6352 V_MAGICEN(addr != NULL));
6356 * t4_wol_pat_enable - enable/disable pattern-based WoL
6357 * @adap: the adapter
6358 * @port: the physical port index
6359 * @map: bitmap of which HW pattern filters to set
6360 * @mask0: byte mask for bytes 0-63 of a packet
6361 * @mask1: byte mask for bytes 64-127 of a packet
6362 * @crc: Ethernet CRC for selected bytes
6363 * @enable: enable/disable switch
6365 * Sets the pattern filters indicated in @map to mask out the bytes
6366 * specified in @mask0/@mask1 in received packets and compare the CRC of
6367 * the resulting packet against @crc. If @enable is %true pattern-based
6368 * WoL is enabled, otherwise disabled.
6370 int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map,
6371 u64 mask0, u64 mask1, unsigned int crc, bool enable)
6377 port_cfg_reg = PORT_REG(port, A_XGMAC_PORT_CFG2);
6379 port_cfg_reg = T5_PORT_REG(port, A_MAC_PORT_CFG2);
6382 t4_set_reg_field(adap, port_cfg_reg, F_PATEN, 0);
6388 #define EPIO_REG(name) \
6389 (is_t4(adap) ? PORT_REG(port, A_XGMAC_PORT_EPIO_##name) : \
6390 T5_PORT_REG(port, A_MAC_PORT_EPIO_##name))
6392 t4_write_reg(adap, EPIO_REG(DATA1), mask0 >> 32);
6393 t4_write_reg(adap, EPIO_REG(DATA2), mask1);
6394 t4_write_reg(adap, EPIO_REG(DATA3), mask1 >> 32);
6396 for (i = 0; i < NWOL_PAT; i++, map >>= 1) {
6400 /* write byte masks */
6401 t4_write_reg(adap, EPIO_REG(DATA0), mask0);
6402 t4_write_reg(adap, EPIO_REG(OP), V_ADDRESS(i) | F_EPIOWR);
6403 t4_read_reg(adap, EPIO_REG(OP)); /* flush */
6404 if (t4_read_reg(adap, EPIO_REG(OP)) & F_BUSY)
6408 t4_write_reg(adap, EPIO_REG(DATA0), crc);
6409 t4_write_reg(adap, EPIO_REG(OP), V_ADDRESS(i + 32) | F_EPIOWR);
6410 t4_read_reg(adap, EPIO_REG(OP)); /* flush */
6411 if (t4_read_reg(adap, EPIO_REG(OP)) & F_BUSY)
6416 t4_set_reg_field(adap, port_cfg_reg, 0, F_PATEN);
6420 /* t4_mk_filtdelwr - create a delete filter WR
6421 * @ftid: the filter ID
6422 * @wr: the filter work request to populate
6423 * @qid: ingress queue to receive the delete notification
6425 * Creates a filter work request to delete the supplied filter. If @qid is
6426 * negative the delete notification is suppressed.
6428 void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid)
6430 memset(wr, 0, sizeof(*wr));
6431 wr->op_pkd = cpu_to_be32(V_FW_WR_OP(FW_FILTER_WR));
6432 wr->len16_pkd = cpu_to_be32(V_FW_WR_LEN16(sizeof(*wr) / 16));
6433 wr->tid_to_iq = cpu_to_be32(V_FW_FILTER_WR_TID(ftid) |
6434 V_FW_FILTER_WR_NOREPLY(qid < 0));
6435 wr->del_filter_to_l2tix = cpu_to_be32(F_FW_FILTER_WR_DEL_FILTER);
6437 wr->rx_chan_rx_rpl_iq =
6438 cpu_to_be16(V_FW_FILTER_WR_RX_RPL_IQ(qid));
6441 #define INIT_CMD(var, cmd, rd_wr) do { \
6442 (var).op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_##cmd##_CMD) | \
6443 F_FW_CMD_REQUEST | \
6444 F_FW_CMD_##rd_wr); \
6445 (var).retval_len16 = cpu_to_be32(FW_LEN16(var)); \
6448 int t4_fwaddrspace_write(struct adapter *adap, unsigned int mbox,
6452 struct fw_ldst_cmd c;
6454 memset(&c, 0, sizeof(c));
6455 ldst_addrspace = V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_FIRMWARE);
6456 c.op_to_addrspace = cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
6460 c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
6461 c.u.addrval.addr = cpu_to_be32(addr);
6462 c.u.addrval.val = cpu_to_be32(val);
6464 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
6468 * t4_mdio_rd - read a PHY register through MDIO
6469 * @adap: the adapter
6470 * @mbox: mailbox to use for the FW command
6471 * @phy_addr: the PHY address
6472 * @mmd: the PHY MMD to access (0 for clause 22 PHYs)
6473 * @reg: the register to read
6474 * @valp: where to store the value
6476 * Issues a FW command through the given mailbox to read a PHY register.
6478 int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
6479 unsigned int mmd, unsigned int reg, unsigned int *valp)
6483 struct fw_ldst_cmd c;
6485 memset(&c, 0, sizeof(c));
6486 ldst_addrspace = V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_MDIO);
6487 c.op_to_addrspace = cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
6488 F_FW_CMD_REQUEST | F_FW_CMD_READ |
6490 c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
6491 c.u.mdio.paddr_mmd = cpu_to_be16(V_FW_LDST_CMD_PADDR(phy_addr) |
6492 V_FW_LDST_CMD_MMD(mmd));
6493 c.u.mdio.raddr = cpu_to_be16(reg);
6495 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
6497 *valp = be16_to_cpu(c.u.mdio.rval);
6502 * t4_mdio_wr - write a PHY register through MDIO
6503 * @adap: the adapter
6504 * @mbox: mailbox to use for the FW command
6505 * @phy_addr: the PHY address
6506 * @mmd: the PHY MMD to access (0 for clause 22 PHYs)
6507 * @reg: the register to write
6508 * @valp: value to write
6510 * Issues a FW command through the given mailbox to write a PHY register.
6512 int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
6513 unsigned int mmd, unsigned int reg, unsigned int val)
6516 struct fw_ldst_cmd c;
6518 memset(&c, 0, sizeof(c));
6519 ldst_addrspace = V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_MDIO);
6520 c.op_to_addrspace = cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
6521 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
6523 c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
6524 c.u.mdio.paddr_mmd = cpu_to_be16(V_FW_LDST_CMD_PADDR(phy_addr) |
6525 V_FW_LDST_CMD_MMD(mmd));
6526 c.u.mdio.raddr = cpu_to_be16(reg);
6527 c.u.mdio.rval = cpu_to_be16(val);
6529 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
6534 * t4_sge_decode_idma_state - decode the idma state
6535 * @adap: the adapter
6536 * @state: the state idma is stuck in
6538 void t4_sge_decode_idma_state(struct adapter *adapter, int state)
6540 static const char * const t4_decode[] = {
6542 "IDMA_PUSH_MORE_CPL_FIFO",
6543 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
6545 "IDMA_PHYSADDR_SEND_PCIEHDR",
6546 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
6547 "IDMA_PHYSADDR_SEND_PAYLOAD",
6548 "IDMA_SEND_FIFO_TO_IMSG",
6549 "IDMA_FL_REQ_DATA_FL_PREP",
6550 "IDMA_FL_REQ_DATA_FL",
6552 "IDMA_FL_H_REQ_HEADER_FL",
6553 "IDMA_FL_H_SEND_PCIEHDR",
6554 "IDMA_FL_H_PUSH_CPL_FIFO",
6555 "IDMA_FL_H_SEND_CPL",
6556 "IDMA_FL_H_SEND_IP_HDR_FIRST",
6557 "IDMA_FL_H_SEND_IP_HDR",
6558 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
6559 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
6560 "IDMA_FL_H_SEND_IP_HDR_PADDING",
6561 "IDMA_FL_D_SEND_PCIEHDR",
6562 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
6563 "IDMA_FL_D_REQ_NEXT_DATA_FL",
6564 "IDMA_FL_SEND_PCIEHDR",
6565 "IDMA_FL_PUSH_CPL_FIFO",
6567 "IDMA_FL_SEND_PAYLOAD_FIRST",
6568 "IDMA_FL_SEND_PAYLOAD",
6569 "IDMA_FL_REQ_NEXT_DATA_FL",
6570 "IDMA_FL_SEND_NEXT_PCIEHDR",
6571 "IDMA_FL_SEND_PADDING",
6572 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
6573 "IDMA_FL_SEND_FIFO_TO_IMSG",
6574 "IDMA_FL_REQ_DATAFL_DONE",
6575 "IDMA_FL_REQ_HEADERFL_DONE",
6577 static const char * const t5_decode[] = {
6580 "IDMA_PUSH_MORE_CPL_FIFO",
6581 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
6582 "IDMA_SGEFLRFLUSH_SEND_PCIEHDR",
6583 "IDMA_PHYSADDR_SEND_PCIEHDR",
6584 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
6585 "IDMA_PHYSADDR_SEND_PAYLOAD",
6586 "IDMA_SEND_FIFO_TO_IMSG",
6587 "IDMA_FL_REQ_DATA_FL",
6589 "IDMA_FL_DROP_SEND_INC",
6590 "IDMA_FL_H_REQ_HEADER_FL",
6591 "IDMA_FL_H_SEND_PCIEHDR",
6592 "IDMA_FL_H_PUSH_CPL_FIFO",
6593 "IDMA_FL_H_SEND_CPL",
6594 "IDMA_FL_H_SEND_IP_HDR_FIRST",
6595 "IDMA_FL_H_SEND_IP_HDR",
6596 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
6597 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
6598 "IDMA_FL_H_SEND_IP_HDR_PADDING",
6599 "IDMA_FL_D_SEND_PCIEHDR",
6600 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
6601 "IDMA_FL_D_REQ_NEXT_DATA_FL",
6602 "IDMA_FL_SEND_PCIEHDR",
6603 "IDMA_FL_PUSH_CPL_FIFO",
6605 "IDMA_FL_SEND_PAYLOAD_FIRST",
6606 "IDMA_FL_SEND_PAYLOAD",
6607 "IDMA_FL_REQ_NEXT_DATA_FL",
6608 "IDMA_FL_SEND_NEXT_PCIEHDR",
6609 "IDMA_FL_SEND_PADDING",
6610 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
6612 static const char * const t6_decode[] = {
6614 "IDMA_PUSH_MORE_CPL_FIFO",
6615 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
6616 "IDMA_SGEFLRFLUSH_SEND_PCIEHDR",
6617 "IDMA_PHYSADDR_SEND_PCIEHDR",
6618 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
6619 "IDMA_PHYSADDR_SEND_PAYLOAD",
6620 "IDMA_FL_REQ_DATA_FL",
6622 "IDMA_FL_DROP_SEND_INC",
6623 "IDMA_FL_H_REQ_HEADER_FL",
6624 "IDMA_FL_H_SEND_PCIEHDR",
6625 "IDMA_FL_H_PUSH_CPL_FIFO",
6626 "IDMA_FL_H_SEND_CPL",
6627 "IDMA_FL_H_SEND_IP_HDR_FIRST",
6628 "IDMA_FL_H_SEND_IP_HDR",
6629 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
6630 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
6631 "IDMA_FL_H_SEND_IP_HDR_PADDING",
6632 "IDMA_FL_D_SEND_PCIEHDR",
6633 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
6634 "IDMA_FL_D_REQ_NEXT_DATA_FL",
6635 "IDMA_FL_SEND_PCIEHDR",
6636 "IDMA_FL_PUSH_CPL_FIFO",
6638 "IDMA_FL_SEND_PAYLOAD_FIRST",
6639 "IDMA_FL_SEND_PAYLOAD",
6640 "IDMA_FL_REQ_NEXT_DATA_FL",
6641 "IDMA_FL_SEND_NEXT_PCIEHDR",
6642 "IDMA_FL_SEND_PADDING",
6643 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
6645 static const u32 sge_regs[] = {
6646 A_SGE_DEBUG_DATA_LOW_INDEX_2,
6647 A_SGE_DEBUG_DATA_LOW_INDEX_3,
6648 A_SGE_DEBUG_DATA_HIGH_INDEX_10,
6650 const char * const *sge_idma_decode;
6651 int sge_idma_decode_nstates;
6653 unsigned int chip_version = chip_id(adapter);
6655 /* Select the right set of decode strings to dump depending on the
6656 * adapter chip type.
6658 switch (chip_version) {
6660 sge_idma_decode = (const char * const *)t4_decode;
6661 sge_idma_decode_nstates = ARRAY_SIZE(t4_decode);
6665 sge_idma_decode = (const char * const *)t5_decode;
6666 sge_idma_decode_nstates = ARRAY_SIZE(t5_decode);
6670 sge_idma_decode = (const char * const *)t6_decode;
6671 sge_idma_decode_nstates = ARRAY_SIZE(t6_decode);
6675 CH_ERR(adapter, "Unsupported chip version %d\n", chip_version);
6679 if (state < sge_idma_decode_nstates)
6680 CH_WARN(adapter, "idma state %s\n", sge_idma_decode[state]);
6682 CH_WARN(adapter, "idma state %d unknown\n", state);
6684 for (i = 0; i < ARRAY_SIZE(sge_regs); i++)
6685 CH_WARN(adapter, "SGE register %#x value %#x\n",
6686 sge_regs[i], t4_read_reg(adapter, sge_regs[i]));
6690 * t4_sge_ctxt_flush - flush the SGE context cache
6691 * @adap: the adapter
6692 * @mbox: mailbox to use for the FW command
6694 * Issues a FW command through the given mailbox to flush the
6695 * SGE context cache.
6697 int t4_sge_ctxt_flush(struct adapter *adap, unsigned int mbox)
6701 struct fw_ldst_cmd c;
6703 memset(&c, 0, sizeof(c));
6704 ldst_addrspace = V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_SGE_EGRC);
6705 c.op_to_addrspace = cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
6706 F_FW_CMD_REQUEST | F_FW_CMD_READ |
6708 c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
6709 c.u.idctxt.msg_ctxtflush = cpu_to_be32(F_FW_LDST_CMD_CTXTFLUSH);
6711 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
6716 * t4_fw_hello - establish communication with FW
6717 * @adap: the adapter
6718 * @mbox: mailbox to use for the FW command
6719 * @evt_mbox: mailbox to receive async FW events
6720 * @master: specifies the caller's willingness to be the device master
6721 * @state: returns the current device state (if non-NULL)
6723 * Issues a command to establish communication with FW. Returns either
6724 * an error (negative integer) or the mailbox of the Master PF.
6726 int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox,
6727 enum dev_master master, enum dev_state *state)
6730 struct fw_hello_cmd c;
6732 unsigned int master_mbox;
6733 int retries = FW_CMD_HELLO_RETRIES;
6736 memset(&c, 0, sizeof(c));
6737 INIT_CMD(c, HELLO, WRITE);
6738 c.err_to_clearinit = cpu_to_be32(
6739 V_FW_HELLO_CMD_MASTERDIS(master == MASTER_CANT) |
6740 V_FW_HELLO_CMD_MASTERFORCE(master == MASTER_MUST) |
6741 V_FW_HELLO_CMD_MBMASTER(master == MASTER_MUST ?
6742 mbox : M_FW_HELLO_CMD_MBMASTER) |
6743 V_FW_HELLO_CMD_MBASYNCNOT(evt_mbox) |
6744 V_FW_HELLO_CMD_STAGE(FW_HELLO_CMD_STAGE_OS) |
6745 F_FW_HELLO_CMD_CLEARINIT);
6748 * Issue the HELLO command to the firmware. If it's not successful
6749 * but indicates that we got a "busy" or "timeout" condition, retry
6750 * the HELLO until we exhaust our retry limit. If we do exceed our
6751 * retry limit, check to see if the firmware left us any error
6752 * information and report that if so ...
6754 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
6755 if (ret != FW_SUCCESS) {
6756 if ((ret == -EBUSY || ret == -ETIMEDOUT) && retries-- > 0)
6758 if (t4_read_reg(adap, A_PCIE_FW) & F_PCIE_FW_ERR)
6759 t4_report_fw_error(adap);
6763 v = be32_to_cpu(c.err_to_clearinit);
6764 master_mbox = G_FW_HELLO_CMD_MBMASTER(v);
6766 if (v & F_FW_HELLO_CMD_ERR)
6767 *state = DEV_STATE_ERR;
6768 else if (v & F_FW_HELLO_CMD_INIT)
6769 *state = DEV_STATE_INIT;
6771 *state = DEV_STATE_UNINIT;
6775 * If we're not the Master PF then we need to wait around for the
6776 * Master PF Driver to finish setting up the adapter.
6778 * Note that we also do this wait if we're a non-Master-capable PF and
6779 * there is no current Master PF; a Master PF may show up momentarily
6780 * and we wouldn't want to fail pointlessly. (This can happen when an
6781 * OS loads lots of different drivers rapidly at the same time). In
6782 * this case, the Master PF returned by the firmware will be
6783 * M_PCIE_FW_MASTER so the test below will work ...
6785 if ((v & (F_FW_HELLO_CMD_ERR|F_FW_HELLO_CMD_INIT)) == 0 &&
6786 master_mbox != mbox) {
6787 int waiting = FW_CMD_HELLO_TIMEOUT;
6790 * Wait for the firmware to either indicate an error or
6791 * initialized state. If we see either of these we bail out
6792 * and report the issue to the caller. If we exhaust the
6793 * "hello timeout" and we haven't exhausted our retries, try
6794 * again. Otherwise bail with a timeout error.
6803 * If neither Error nor Initialialized are indicated
6804 * by the firmware keep waiting till we exhaust our
6805 * timeout ... and then retry if we haven't exhausted
6808 pcie_fw = t4_read_reg(adap, A_PCIE_FW);
6809 if (!(pcie_fw & (F_PCIE_FW_ERR|F_PCIE_FW_INIT))) {
6820 * We either have an Error or Initialized condition
6821 * report errors preferentially.
6824 if (pcie_fw & F_PCIE_FW_ERR)
6825 *state = DEV_STATE_ERR;
6826 else if (pcie_fw & F_PCIE_FW_INIT)
6827 *state = DEV_STATE_INIT;
6831 * If we arrived before a Master PF was selected and
6832 * there's not a valid Master PF, grab its identity
6835 if (master_mbox == M_PCIE_FW_MASTER &&
6836 (pcie_fw & F_PCIE_FW_MASTER_VLD))
6837 master_mbox = G_PCIE_FW_MASTER(pcie_fw);
6846 * t4_fw_bye - end communication with FW
6847 * @adap: the adapter
6848 * @mbox: mailbox to use for the FW command
6850 * Issues a command to terminate communication with FW.
6852 int t4_fw_bye(struct adapter *adap, unsigned int mbox)
6854 struct fw_bye_cmd c;
6856 memset(&c, 0, sizeof(c));
6857 INIT_CMD(c, BYE, WRITE);
6858 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
6862 * t4_fw_reset - issue a reset to FW
6863 * @adap: the adapter
6864 * @mbox: mailbox to use for the FW command
6865 * @reset: specifies the type of reset to perform
6867 * Issues a reset command of the specified type to FW.
6869 int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset)
6871 struct fw_reset_cmd c;
6873 memset(&c, 0, sizeof(c));
6874 INIT_CMD(c, RESET, WRITE);
6875 c.val = cpu_to_be32(reset);
6876 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
6880 * t4_fw_halt - issue a reset/halt to FW and put uP into RESET
6881 * @adap: the adapter
6882 * @mbox: mailbox to use for the FW RESET command (if desired)
6883 * @force: force uP into RESET even if FW RESET command fails
6885 * Issues a RESET command to firmware (if desired) with a HALT indication
6886 * and then puts the microprocessor into RESET state. The RESET command
6887 * will only be issued if a legitimate mailbox is provided (mbox <=
6888 * M_PCIE_FW_MASTER).
6890 * This is generally used in order for the host to safely manipulate the
6891 * adapter without fear of conflicting with whatever the firmware might
6892 * be doing. The only way out of this state is to RESTART the firmware
6895 int t4_fw_halt(struct adapter *adap, unsigned int mbox, int force)
6900 * If a legitimate mailbox is provided, issue a RESET command
6901 * with a HALT indication.
6903 if (mbox <= M_PCIE_FW_MASTER) {
6904 struct fw_reset_cmd c;
6906 memset(&c, 0, sizeof(c));
6907 INIT_CMD(c, RESET, WRITE);
6908 c.val = cpu_to_be32(F_PIORST | F_PIORSTMODE);
6909 c.halt_pkd = cpu_to_be32(F_FW_RESET_CMD_HALT);
6910 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
6914 * Normally we won't complete the operation if the firmware RESET
6915 * command fails but if our caller insists we'll go ahead and put the
6916 * uP into RESET. This can be useful if the firmware is hung or even
6917 * missing ... We'll have to take the risk of putting the uP into
6918 * RESET without the cooperation of firmware in that case.
6920 * We also force the firmware's HALT flag to be on in case we bypassed
6921 * the firmware RESET command above or we're dealing with old firmware
6922 * which doesn't have the HALT capability. This will serve as a flag
6923 * for the incoming firmware to know that it's coming out of a HALT
6924 * rather than a RESET ... if it's new enough to understand that ...
6926 if (ret == 0 || force) {
6927 t4_set_reg_field(adap, A_CIM_BOOT_CFG, F_UPCRST, F_UPCRST);
6928 t4_set_reg_field(adap, A_PCIE_FW, F_PCIE_FW_HALT,
6933 * And we always return the result of the firmware RESET command
6934 * even when we force the uP into RESET ...
6940 * t4_fw_restart - restart the firmware by taking the uP out of RESET
6941 * @adap: the adapter
6942 * @reset: if we want to do a RESET to restart things
6944 * Restart firmware previously halted by t4_fw_halt(). On successful
6945 * return the previous PF Master remains as the new PF Master and there
6946 * is no need to issue a new HELLO command, etc.
6948 * We do this in two ways:
6950 * 1. If we're dealing with newer firmware we'll simply want to take
6951 * the chip's microprocessor out of RESET. This will cause the
6952 * firmware to start up from its start vector. And then we'll loop
6953 * until the firmware indicates it's started again (PCIE_FW.HALT
6954 * reset to 0) or we timeout.
6956 * 2. If we're dealing with older firmware then we'll need to RESET
6957 * the chip since older firmware won't recognize the PCIE_FW.HALT
6958 * flag and automatically RESET itself on startup.
6960 int t4_fw_restart(struct adapter *adap, unsigned int mbox, int reset)
6964 * Since we're directing the RESET instead of the firmware
6965 * doing it automatically, we need to clear the PCIE_FW.HALT
6968 t4_set_reg_field(adap, A_PCIE_FW, F_PCIE_FW_HALT, 0);
6971 * If we've been given a valid mailbox, first try to get the
6972 * firmware to do the RESET. If that works, great and we can
6973 * return success. Otherwise, if we haven't been given a
6974 * valid mailbox or the RESET command failed, fall back to
6975 * hitting the chip with a hammer.
6977 if (mbox <= M_PCIE_FW_MASTER) {
6978 t4_set_reg_field(adap, A_CIM_BOOT_CFG, F_UPCRST, 0);
6980 if (t4_fw_reset(adap, mbox,
6981 F_PIORST | F_PIORSTMODE) == 0)
6985 t4_write_reg(adap, A_PL_RST, F_PIORST | F_PIORSTMODE);
6990 t4_set_reg_field(adap, A_CIM_BOOT_CFG, F_UPCRST, 0);
6991 for (ms = 0; ms < FW_CMD_MAX_TIMEOUT; ) {
6992 if (!(t4_read_reg(adap, A_PCIE_FW) & F_PCIE_FW_HALT))
7003 * t4_fw_upgrade - perform all of the steps necessary to upgrade FW
7004 * @adap: the adapter
7005 * @mbox: mailbox to use for the FW RESET command (if desired)
7006 * @fw_data: the firmware image to write
7008 * @force: force upgrade even if firmware doesn't cooperate
7010 * Perform all of the steps necessary for upgrading an adapter's
7011 * firmware image. Normally this requires the cooperation of the
7012 * existing firmware in order to halt all existing activities
7013 * but if an invalid mailbox token is passed in we skip that step
7014 * (though we'll still put the adapter microprocessor into RESET in
7017 * On successful return the new firmware will have been loaded and
7018 * the adapter will have been fully RESET losing all previous setup
7019 * state. On unsuccessful return the adapter may be completely hosed ...
7020 * positive errno indicates that the adapter is ~probably~ intact, a
7021 * negative errno indicates that things are looking bad ...
7023 int t4_fw_upgrade(struct adapter *adap, unsigned int mbox,
7024 const u8 *fw_data, unsigned int size, int force)
7026 const struct fw_hdr *fw_hdr = (const struct fw_hdr *)fw_data;
7027 unsigned int bootstrap =
7028 be32_to_cpu(fw_hdr->magic) == FW_HDR_MAGIC_BOOTSTRAP;
7031 if (!t4_fw_matches_chip(adap, fw_hdr))
7035 ret = t4_fw_halt(adap, mbox, force);
7036 if (ret < 0 && !force)
7040 ret = t4_load_fw(adap, fw_data, size);
7041 if (ret < 0 || bootstrap)
7045 * Older versions of the firmware don't understand the new
7046 * PCIE_FW.HALT flag and so won't know to perform a RESET when they
7047 * restart. So for newly loaded older firmware we'll have to do the
7048 * RESET for it so it starts up on a clean slate. We can tell if
7049 * the newly loaded firmware will handle this right by checking
7050 * its header flags to see if it advertises the capability.
7052 reset = ((be32_to_cpu(fw_hdr->flags) & FW_HDR_FLAGS_RESET_HALT) == 0);
7053 return t4_fw_restart(adap, mbox, reset);
7057 * Card doesn't have a firmware, install one.
7059 int t4_fw_forceinstall(struct adapter *adap, const u8 *fw_data,
7062 const struct fw_hdr *fw_hdr = (const struct fw_hdr *)fw_data;
7063 unsigned int bootstrap =
7064 be32_to_cpu(fw_hdr->magic) == FW_HDR_MAGIC_BOOTSTRAP;
7067 if (!t4_fw_matches_chip(adap, fw_hdr) || bootstrap)
7070 t4_set_reg_field(adap, A_CIM_BOOT_CFG, F_UPCRST, F_UPCRST);
7071 t4_write_reg(adap, A_PCIE_FW, 0); /* Clobber internal state */
7072 ret = t4_load_fw(adap, fw_data, size);
7075 t4_write_reg(adap, A_PL_RST, F_PIORST | F_PIORSTMODE);
7082 * t4_fw_initialize - ask FW to initialize the device
7083 * @adap: the adapter
7084 * @mbox: mailbox to use for the FW command
7086 * Issues a command to FW to partially initialize the device. This
7087 * performs initialization that generally doesn't depend on user input.
7089 int t4_fw_initialize(struct adapter *adap, unsigned int mbox)
7091 struct fw_initialize_cmd c;
7093 memset(&c, 0, sizeof(c));
7094 INIT_CMD(c, INITIALIZE, WRITE);
7095 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7099 * t4_query_params_rw - query FW or device parameters
7100 * @adap: the adapter
7101 * @mbox: mailbox to use for the FW command
7104 * @nparams: the number of parameters
7105 * @params: the parameter names
7106 * @val: the parameter values
7107 * @rw: Write and read flag
7109 * Reads the value of FW or device parameters. Up to 7 parameters can be
7112 int t4_query_params_rw(struct adapter *adap, unsigned int mbox, unsigned int pf,
7113 unsigned int vf, unsigned int nparams, const u32 *params,
7117 struct fw_params_cmd c;
7118 __be32 *p = &c.param[0].mnem;
7123 memset(&c, 0, sizeof(c));
7124 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_PARAMS_CMD) |
7125 F_FW_CMD_REQUEST | F_FW_CMD_READ |
7126 V_FW_PARAMS_CMD_PFN(pf) |
7127 V_FW_PARAMS_CMD_VFN(vf));
7128 c.retval_len16 = cpu_to_be32(FW_LEN16(c));
7130 for (i = 0; i < nparams; i++) {
7131 *p++ = cpu_to_be32(*params++);
7133 *p = cpu_to_be32(*(val + i));
7137 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
7139 for (i = 0, p = &c.param[0].val; i < nparams; i++, p += 2)
7140 *val++ = be32_to_cpu(*p);
7144 int t4_query_params(struct adapter *adap, unsigned int mbox, unsigned int pf,
7145 unsigned int vf, unsigned int nparams, const u32 *params,
7148 return t4_query_params_rw(adap, mbox, pf, vf, nparams, params, val, 0);
7152 * t4_set_params_timeout - sets FW or device parameters
7153 * @adap: the adapter
7154 * @mbox: mailbox to use for the FW command
7157 * @nparams: the number of parameters
7158 * @params: the parameter names
7159 * @val: the parameter values
7160 * @timeout: the timeout time
7162 * Sets the value of FW or device parameters. Up to 7 parameters can be
7163 * specified at once.
7165 int t4_set_params_timeout(struct adapter *adap, unsigned int mbox,
7166 unsigned int pf, unsigned int vf,
7167 unsigned int nparams, const u32 *params,
7168 const u32 *val, int timeout)
7170 struct fw_params_cmd c;
7171 __be32 *p = &c.param[0].mnem;
7176 memset(&c, 0, sizeof(c));
7177 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_PARAMS_CMD) |
7178 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
7179 V_FW_PARAMS_CMD_PFN(pf) |
7180 V_FW_PARAMS_CMD_VFN(vf));
7181 c.retval_len16 = cpu_to_be32(FW_LEN16(c));
7184 *p++ = cpu_to_be32(*params++);
7185 *p++ = cpu_to_be32(*val++);
7188 return t4_wr_mbox_timeout(adap, mbox, &c, sizeof(c), NULL, timeout);
7192 * t4_set_params - sets FW or device parameters
7193 * @adap: the adapter
7194 * @mbox: mailbox to use for the FW command
7197 * @nparams: the number of parameters
7198 * @params: the parameter names
7199 * @val: the parameter values
7201 * Sets the value of FW or device parameters. Up to 7 parameters can be
7202 * specified at once.
7204 int t4_set_params(struct adapter *adap, unsigned int mbox, unsigned int pf,
7205 unsigned int vf, unsigned int nparams, const u32 *params,
7208 return t4_set_params_timeout(adap, mbox, pf, vf, nparams, params, val,
7209 FW_CMD_MAX_TIMEOUT);
7213 * t4_cfg_pfvf - configure PF/VF resource limits
7214 * @adap: the adapter
7215 * @mbox: mailbox to use for the FW command
7216 * @pf: the PF being configured
7217 * @vf: the VF being configured
7218 * @txq: the max number of egress queues
7219 * @txq_eth_ctrl: the max number of egress Ethernet or control queues
7220 * @rxqi: the max number of interrupt-capable ingress queues
7221 * @rxq: the max number of interruptless ingress queues
7222 * @tc: the PCI traffic class
7223 * @vi: the max number of virtual interfaces
7224 * @cmask: the channel access rights mask for the PF/VF
7225 * @pmask: the port access rights mask for the PF/VF
7226 * @nexact: the maximum number of exact MPS filters
7227 * @rcaps: read capabilities
7228 * @wxcaps: write/execute capabilities
7230 * Configures resource limits and capabilities for a physical or virtual
7233 int t4_cfg_pfvf(struct adapter *adap, unsigned int mbox, unsigned int pf,
7234 unsigned int vf, unsigned int txq, unsigned int txq_eth_ctrl,
7235 unsigned int rxqi, unsigned int rxq, unsigned int tc,
7236 unsigned int vi, unsigned int cmask, unsigned int pmask,
7237 unsigned int nexact, unsigned int rcaps, unsigned int wxcaps)
7239 struct fw_pfvf_cmd c;
7241 memset(&c, 0, sizeof(c));
7242 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_PFVF_CMD) | F_FW_CMD_REQUEST |
7243 F_FW_CMD_WRITE | V_FW_PFVF_CMD_PFN(pf) |
7244 V_FW_PFVF_CMD_VFN(vf));
7245 c.retval_len16 = cpu_to_be32(FW_LEN16(c));
7246 c.niqflint_niq = cpu_to_be32(V_FW_PFVF_CMD_NIQFLINT(rxqi) |
7247 V_FW_PFVF_CMD_NIQ(rxq));
7248 c.type_to_neq = cpu_to_be32(V_FW_PFVF_CMD_CMASK(cmask) |
7249 V_FW_PFVF_CMD_PMASK(pmask) |
7250 V_FW_PFVF_CMD_NEQ(txq));
7251 c.tc_to_nexactf = cpu_to_be32(V_FW_PFVF_CMD_TC(tc) |
7252 V_FW_PFVF_CMD_NVI(vi) |
7253 V_FW_PFVF_CMD_NEXACTF(nexact));
7254 c.r_caps_to_nethctrl = cpu_to_be32(V_FW_PFVF_CMD_R_CAPS(rcaps) |
7255 V_FW_PFVF_CMD_WX_CAPS(wxcaps) |
7256 V_FW_PFVF_CMD_NETHCTRL(txq_eth_ctrl));
7257 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7261 * t4_alloc_vi_func - allocate a virtual interface
7262 * @adap: the adapter
7263 * @mbox: mailbox to use for the FW command
7264 * @port: physical port associated with the VI
7265 * @pf: the PF owning the VI
7266 * @vf: the VF owning the VI
7267 * @nmac: number of MAC addresses needed (1 to 5)
7268 * @mac: the MAC addresses of the VI
7269 * @rss_size: size of RSS table slice associated with this VI
7270 * @portfunc: which Port Application Function MAC Address is desired
7271 * @idstype: Intrusion Detection Type
7273 * Allocates a virtual interface for the given physical port. If @mac is
7274 * not %NULL it contains the MAC addresses of the VI as assigned by FW.
7275 * If @rss_size is %NULL the VI is not assigned any RSS slice by FW.
7276 * @mac should be large enough to hold @nmac Ethernet addresses, they are
7277 * stored consecutively so the space needed is @nmac * 6 bytes.
7278 * Returns a negative error number or the non-negative VI id.
7280 int t4_alloc_vi_func(struct adapter *adap, unsigned int mbox,
7281 unsigned int port, unsigned int pf, unsigned int vf,
7282 unsigned int nmac, u8 *mac, u16 *rss_size,
7283 unsigned int portfunc, unsigned int idstype)
7288 memset(&c, 0, sizeof(c));
7289 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_VI_CMD) | F_FW_CMD_REQUEST |
7290 F_FW_CMD_WRITE | F_FW_CMD_EXEC |
7291 V_FW_VI_CMD_PFN(pf) | V_FW_VI_CMD_VFN(vf));
7292 c.alloc_to_len16 = cpu_to_be32(F_FW_VI_CMD_ALLOC | FW_LEN16(c));
7293 c.type_to_viid = cpu_to_be16(V_FW_VI_CMD_TYPE(idstype) |
7294 V_FW_VI_CMD_FUNC(portfunc));
7295 c.portid_pkd = V_FW_VI_CMD_PORTID(port);
7298 c.norss_rsssize = F_FW_VI_CMD_NORSS;
7300 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
7305 memcpy(mac, c.mac, sizeof(c.mac));
7308 memcpy(mac + 24, c.nmac3, sizeof(c.nmac3));
7310 memcpy(mac + 18, c.nmac2, sizeof(c.nmac2));
7312 memcpy(mac + 12, c.nmac1, sizeof(c.nmac1));
7314 memcpy(mac + 6, c.nmac0, sizeof(c.nmac0));
7318 *rss_size = G_FW_VI_CMD_RSSSIZE(be16_to_cpu(c.norss_rsssize));
7319 return G_FW_VI_CMD_VIID(be16_to_cpu(c.type_to_viid));
7323 * t4_alloc_vi - allocate an [Ethernet Function] virtual interface
7324 * @adap: the adapter
7325 * @mbox: mailbox to use for the FW command
7326 * @port: physical port associated with the VI
7327 * @pf: the PF owning the VI
7328 * @vf: the VF owning the VI
7329 * @nmac: number of MAC addresses needed (1 to 5)
7330 * @mac: the MAC addresses of the VI
7331 * @rss_size: size of RSS table slice associated with this VI
7333 * backwards compatible and convieniance routine to allocate a Virtual
7334 * Interface with a Ethernet Port Application Function and Intrustion
7335 * Detection System disabled.
7337 int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port,
7338 unsigned int pf, unsigned int vf, unsigned int nmac, u8 *mac,
7341 return t4_alloc_vi_func(adap, mbox, port, pf, vf, nmac, mac, rss_size,
7346 * t4_free_vi - free a virtual interface
7347 * @adap: the adapter
7348 * @mbox: mailbox to use for the FW command
7349 * @pf: the PF owning the VI
7350 * @vf: the VF owning the VI
7351 * @viid: virtual interface identifiler
7353 * Free a previously allocated virtual interface.
7355 int t4_free_vi(struct adapter *adap, unsigned int mbox, unsigned int pf,
7356 unsigned int vf, unsigned int viid)
7360 memset(&c, 0, sizeof(c));
7361 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_VI_CMD) |
7364 V_FW_VI_CMD_PFN(pf) |
7365 V_FW_VI_CMD_VFN(vf));
7366 c.alloc_to_len16 = cpu_to_be32(F_FW_VI_CMD_FREE | FW_LEN16(c));
7367 c.type_to_viid = cpu_to_be16(V_FW_VI_CMD_VIID(viid));
7369 return t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
7373 * t4_set_rxmode - set Rx properties of a virtual interface
7374 * @adap: the adapter
7375 * @mbox: mailbox to use for the FW command
7377 * @mtu: the new MTU or -1
7378 * @promisc: 1 to enable promiscuous mode, 0 to disable it, -1 no change
7379 * @all_multi: 1 to enable all-multi mode, 0 to disable it, -1 no change
7380 * @bcast: 1 to enable broadcast Rx, 0 to disable it, -1 no change
7381 * @vlanex: 1 to enable HW VLAN extraction, 0 to disable it, -1 no change
7382 * @sleep_ok: if true we may sleep while awaiting command completion
7384 * Sets Rx properties of a virtual interface.
7386 int t4_set_rxmode(struct adapter *adap, unsigned int mbox, unsigned int viid,
7387 int mtu, int promisc, int all_multi, int bcast, int vlanex,
7390 struct fw_vi_rxmode_cmd c;
7392 /* convert to FW values */
7394 mtu = M_FW_VI_RXMODE_CMD_MTU;
7396 promisc = M_FW_VI_RXMODE_CMD_PROMISCEN;
7398 all_multi = M_FW_VI_RXMODE_CMD_ALLMULTIEN;
7400 bcast = M_FW_VI_RXMODE_CMD_BROADCASTEN;
7402 vlanex = M_FW_VI_RXMODE_CMD_VLANEXEN;
7404 memset(&c, 0, sizeof(c));
7405 c.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_VI_RXMODE_CMD) |
7406 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
7407 V_FW_VI_RXMODE_CMD_VIID(viid));
7408 c.retval_len16 = cpu_to_be32(FW_LEN16(c));
7410 cpu_to_be32(V_FW_VI_RXMODE_CMD_MTU(mtu) |
7411 V_FW_VI_RXMODE_CMD_PROMISCEN(promisc) |
7412 V_FW_VI_RXMODE_CMD_ALLMULTIEN(all_multi) |
7413 V_FW_VI_RXMODE_CMD_BROADCASTEN(bcast) |
7414 V_FW_VI_RXMODE_CMD_VLANEXEN(vlanex));
7415 return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok);
7419 * t4_alloc_mac_filt - allocates exact-match filters for MAC addresses
7420 * @adap: the adapter
7421 * @mbox: mailbox to use for the FW command
7423 * @free: if true any existing filters for this VI id are first removed
7424 * @naddr: the number of MAC addresses to allocate filters for (up to 7)
7425 * @addr: the MAC address(es)
7426 * @idx: where to store the index of each allocated filter
7427 * @hash: pointer to hash address filter bitmap
7428 * @sleep_ok: call is allowed to sleep
7430 * Allocates an exact-match filter for each of the supplied addresses and
7431 * sets it to the corresponding address. If @idx is not %NULL it should
7432 * have at least @naddr entries, each of which will be set to the index of
7433 * the filter allocated for the corresponding MAC address. If a filter
7434 * could not be allocated for an address its index is set to 0xffff.
7435 * If @hash is not %NULL addresses that fail to allocate an exact filter
7436 * are hashed and update the hash filter bitmap pointed at by @hash.
7438 * Returns a negative error number or the number of filters allocated.
7440 int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox,
7441 unsigned int viid, bool free, unsigned int naddr,
7442 const u8 **addr, u16 *idx, u64 *hash, bool sleep_ok)
7444 int offset, ret = 0;
7445 struct fw_vi_mac_cmd c;
7446 unsigned int nfilters = 0;
7447 unsigned int max_naddr = adap->chip_params->mps_tcam_size;
7448 unsigned int rem = naddr;
7450 if (naddr > max_naddr)
7453 for (offset = 0; offset < naddr ; /**/) {
7454 unsigned int fw_naddr = (rem < ARRAY_SIZE(c.u.exact)
7456 : ARRAY_SIZE(c.u.exact));
7457 size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,
7458 u.exact[fw_naddr]), 16);
7459 struct fw_vi_mac_exact *p;
7462 memset(&c, 0, sizeof(c));
7463 c.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_VI_MAC_CMD) |
7466 V_FW_CMD_EXEC(free) |
7467 V_FW_VI_MAC_CMD_VIID(viid));
7468 c.freemacs_to_len16 = cpu_to_be32(V_FW_VI_MAC_CMD_FREEMACS(free) |
7469 V_FW_CMD_LEN16(len16));
7471 for (i = 0, p = c.u.exact; i < fw_naddr; i++, p++) {
7473 cpu_to_be16(F_FW_VI_MAC_CMD_VALID |
7474 V_FW_VI_MAC_CMD_IDX(FW_VI_MAC_ADD_MAC));
7475 memcpy(p->macaddr, addr[offset+i], sizeof(p->macaddr));
7479 * It's okay if we run out of space in our MAC address arena.
7480 * Some of the addresses we submit may get stored so we need
7481 * to run through the reply to see what the results were ...
7483 ret = t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), &c, sleep_ok);
7484 if (ret && ret != -FW_ENOMEM)
7487 for (i = 0, p = c.u.exact; i < fw_naddr; i++, p++) {
7488 u16 index = G_FW_VI_MAC_CMD_IDX(
7489 be16_to_cpu(p->valid_to_idx));
7492 idx[offset+i] = (index >= max_naddr
7495 if (index < max_naddr)
7498 *hash |= (1ULL << hash_mac_addr(addr[offset+i]));
7506 if (ret == 0 || ret == -FW_ENOMEM)
7512 * t4_change_mac - modifies the exact-match filter for a MAC address
7513 * @adap: the adapter
7514 * @mbox: mailbox to use for the FW command
7516 * @idx: index of existing filter for old value of MAC address, or -1
7517 * @addr: the new MAC address value
7518 * @persist: whether a new MAC allocation should be persistent
7519 * @add_smt: if true also add the address to the HW SMT
7521 * Modifies an exact-match filter and sets it to the new MAC address if
7522 * @idx >= 0, or adds the MAC address to a new filter if @idx < 0. In the
7523 * latter case the address is added persistently if @persist is %true.
7525 * Note that in general it is not possible to modify the value of a given
7526 * filter so the generic way to modify an address filter is to free the one
7527 * being used by the old address value and allocate a new filter for the
7528 * new address value.
7530 * Returns a negative error number or the index of the filter with the new
7531 * MAC value. Note that this index may differ from @idx.
7533 int t4_change_mac(struct adapter *adap, unsigned int mbox, unsigned int viid,
7534 int idx, const u8 *addr, bool persist, bool add_smt)
7537 struct fw_vi_mac_cmd c;
7538 struct fw_vi_mac_exact *p = c.u.exact;
7539 unsigned int max_mac_addr = adap->chip_params->mps_tcam_size;
7541 if (idx < 0) /* new allocation */
7542 idx = persist ? FW_VI_MAC_ADD_PERSIST_MAC : FW_VI_MAC_ADD_MAC;
7543 mode = add_smt ? FW_VI_MAC_SMT_AND_MPSTCAM : FW_VI_MAC_MPS_TCAM_ENTRY;
7545 memset(&c, 0, sizeof(c));
7546 c.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_VI_MAC_CMD) |
7547 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
7548 V_FW_VI_MAC_CMD_VIID(viid));
7549 c.freemacs_to_len16 = cpu_to_be32(V_FW_CMD_LEN16(1));
7550 p->valid_to_idx = cpu_to_be16(F_FW_VI_MAC_CMD_VALID |
7551 V_FW_VI_MAC_CMD_SMAC_RESULT(mode) |
7552 V_FW_VI_MAC_CMD_IDX(idx));
7553 memcpy(p->macaddr, addr, sizeof(p->macaddr));
7555 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
7557 ret = G_FW_VI_MAC_CMD_IDX(be16_to_cpu(p->valid_to_idx));
7558 if (ret >= max_mac_addr)
7565 * t4_set_addr_hash - program the MAC inexact-match hash filter
7566 * @adap: the adapter
7567 * @mbox: mailbox to use for the FW command
7569 * @ucast: whether the hash filter should also match unicast addresses
7570 * @vec: the value to be written to the hash filter
7571 * @sleep_ok: call is allowed to sleep
7573 * Sets the 64-bit inexact-match hash filter for a virtual interface.
7575 int t4_set_addr_hash(struct adapter *adap, unsigned int mbox, unsigned int viid,
7576 bool ucast, u64 vec, bool sleep_ok)
7578 struct fw_vi_mac_cmd c;
7581 memset(&c, 0, sizeof(c));
7582 c.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_VI_MAC_CMD) |
7583 F_FW_CMD_REQUEST | F_FW_CMD_WRITE |
7584 V_FW_VI_ENABLE_CMD_VIID(viid));
7585 val = V_FW_VI_MAC_CMD_ENTRY_TYPE(FW_VI_MAC_TYPE_HASHVEC) |
7586 V_FW_VI_MAC_CMD_HASHUNIEN(ucast) | V_FW_CMD_LEN16(1);
7587 c.freemacs_to_len16 = cpu_to_be32(val);
7588 c.u.hash.hashvec = cpu_to_be64(vec);
7589 return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok);
7593 * t4_enable_vi_params - enable/disable a virtual interface
7594 * @adap: the adapter
7595 * @mbox: mailbox to use for the FW command
7597 * @rx_en: 1=enable Rx, 0=disable Rx
7598 * @tx_en: 1=enable Tx, 0=disable Tx
7599 * @dcb_en: 1=enable delivery of Data Center Bridging messages.
7601 * Enables/disables a virtual interface. Note that setting DCB Enable
7602 * only makes sense when enabling a Virtual Interface ...
7604 int t4_enable_vi_params(struct adapter *adap, unsigned int mbox,
7605 unsigned int viid, bool rx_en, bool tx_en, bool dcb_en)
7607 struct fw_vi_enable_cmd c;
7609 memset(&c, 0, sizeof(c));
7610 c.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_VI_ENABLE_CMD) |
7611 F_FW_CMD_REQUEST | F_FW_CMD_EXEC |
7612 V_FW_VI_ENABLE_CMD_VIID(viid));
7613 c.ien_to_len16 = cpu_to_be32(V_FW_VI_ENABLE_CMD_IEN(rx_en) |
7614 V_FW_VI_ENABLE_CMD_EEN(tx_en) |
7615 V_FW_VI_ENABLE_CMD_DCB_INFO(dcb_en) |
7617 return t4_wr_mbox_ns(adap, mbox, &c, sizeof(c), NULL);
7621 * t4_enable_vi - enable/disable a virtual interface
7622 * @adap: the adapter
7623 * @mbox: mailbox to use for the FW command
7625 * @rx_en: 1=enable Rx, 0=disable Rx
7626 * @tx_en: 1=enable Tx, 0=disable Tx
7628 * Enables/disables a virtual interface. Note that setting DCB Enable
7629 * only makes sense when enabling a Virtual Interface ...
7631 int t4_enable_vi(struct adapter *adap, unsigned int mbox, unsigned int viid,
7632 bool rx_en, bool tx_en)
7634 return t4_enable_vi_params(adap, mbox, viid, rx_en, tx_en, 0);
7638 * t4_identify_port - identify a VI's port by blinking its LED
7639 * @adap: the adapter
7640 * @mbox: mailbox to use for the FW command
7642 * @nblinks: how many times to blink LED at 2.5 Hz
7644 * Identifies a VI's port by blinking its LED.
7646 int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid,
7647 unsigned int nblinks)
7649 struct fw_vi_enable_cmd c;
7651 memset(&c, 0, sizeof(c));
7652 c.op_to_viid = cpu_to_be32(V_FW_CMD_OP(FW_VI_ENABLE_CMD) |
7653 F_FW_CMD_REQUEST | F_FW_CMD_EXEC |
7654 V_FW_VI_ENABLE_CMD_VIID(viid));
7655 c.ien_to_len16 = cpu_to_be32(F_FW_VI_ENABLE_CMD_LED | FW_LEN16(c));
7656 c.blinkdur = cpu_to_be16(nblinks);
7657 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7661 * t4_iq_stop - stop an ingress queue and its FLs
7662 * @adap: the adapter
7663 * @mbox: mailbox to use for the FW command
7664 * @pf: the PF owning the queues
7665 * @vf: the VF owning the queues
7666 * @iqtype: the ingress queue type (FW_IQ_TYPE_FL_INT_CAP, etc.)
7667 * @iqid: ingress queue id
7668 * @fl0id: FL0 queue id or 0xffff if no attached FL0
7669 * @fl1id: FL1 queue id or 0xffff if no attached FL1
7671 * Stops an ingress queue and its associated FLs, if any. This causes
7672 * any current or future data/messages destined for these queues to be
7675 int t4_iq_stop(struct adapter *adap, unsigned int mbox, unsigned int pf,
7676 unsigned int vf, unsigned int iqtype, unsigned int iqid,
7677 unsigned int fl0id, unsigned int fl1id)
7681 memset(&c, 0, sizeof(c));
7682 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_IQ_CMD) | F_FW_CMD_REQUEST |
7683 F_FW_CMD_EXEC | V_FW_IQ_CMD_PFN(pf) |
7684 V_FW_IQ_CMD_VFN(vf));
7685 c.alloc_to_len16 = cpu_to_be32(F_FW_IQ_CMD_IQSTOP | FW_LEN16(c));
7686 c.type_to_iqandstindex = cpu_to_be32(V_FW_IQ_CMD_TYPE(iqtype));
7687 c.iqid = cpu_to_be16(iqid);
7688 c.fl0id = cpu_to_be16(fl0id);
7689 c.fl1id = cpu_to_be16(fl1id);
7690 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7694 * t4_iq_free - free an ingress queue and its FLs
7695 * @adap: the adapter
7696 * @mbox: mailbox to use for the FW command
7697 * @pf: the PF owning the queues
7698 * @vf: the VF owning the queues
7699 * @iqtype: the ingress queue type (FW_IQ_TYPE_FL_INT_CAP, etc.)
7700 * @iqid: ingress queue id
7701 * @fl0id: FL0 queue id or 0xffff if no attached FL0
7702 * @fl1id: FL1 queue id or 0xffff if no attached FL1
7704 * Frees an ingress queue and its associated FLs, if any.
7706 int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
7707 unsigned int vf, unsigned int iqtype, unsigned int iqid,
7708 unsigned int fl0id, unsigned int fl1id)
7712 memset(&c, 0, sizeof(c));
7713 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_IQ_CMD) | F_FW_CMD_REQUEST |
7714 F_FW_CMD_EXEC | V_FW_IQ_CMD_PFN(pf) |
7715 V_FW_IQ_CMD_VFN(vf));
7716 c.alloc_to_len16 = cpu_to_be32(F_FW_IQ_CMD_FREE | FW_LEN16(c));
7717 c.type_to_iqandstindex = cpu_to_be32(V_FW_IQ_CMD_TYPE(iqtype));
7718 c.iqid = cpu_to_be16(iqid);
7719 c.fl0id = cpu_to_be16(fl0id);
7720 c.fl1id = cpu_to_be16(fl1id);
7721 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7725 * t4_eth_eq_free - free an Ethernet egress queue
7726 * @adap: the adapter
7727 * @mbox: mailbox to use for the FW command
7728 * @pf: the PF owning the queue
7729 * @vf: the VF owning the queue
7730 * @eqid: egress queue id
7732 * Frees an Ethernet egress queue.
7734 int t4_eth_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
7735 unsigned int vf, unsigned int eqid)
7737 struct fw_eq_eth_cmd c;
7739 memset(&c, 0, sizeof(c));
7740 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_EQ_ETH_CMD) |
7741 F_FW_CMD_REQUEST | F_FW_CMD_EXEC |
7742 V_FW_EQ_ETH_CMD_PFN(pf) |
7743 V_FW_EQ_ETH_CMD_VFN(vf));
7744 c.alloc_to_len16 = cpu_to_be32(F_FW_EQ_ETH_CMD_FREE | FW_LEN16(c));
7745 c.eqid_pkd = cpu_to_be32(V_FW_EQ_ETH_CMD_EQID(eqid));
7746 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7750 * t4_ctrl_eq_free - free a control egress queue
7751 * @adap: the adapter
7752 * @mbox: mailbox to use for the FW command
7753 * @pf: the PF owning the queue
7754 * @vf: the VF owning the queue
7755 * @eqid: egress queue id
7757 * Frees a control egress queue.
7759 int t4_ctrl_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
7760 unsigned int vf, unsigned int eqid)
7762 struct fw_eq_ctrl_cmd c;
7764 memset(&c, 0, sizeof(c));
7765 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_EQ_CTRL_CMD) |
7766 F_FW_CMD_REQUEST | F_FW_CMD_EXEC |
7767 V_FW_EQ_CTRL_CMD_PFN(pf) |
7768 V_FW_EQ_CTRL_CMD_VFN(vf));
7769 c.alloc_to_len16 = cpu_to_be32(F_FW_EQ_CTRL_CMD_FREE | FW_LEN16(c));
7770 c.cmpliqid_eqid = cpu_to_be32(V_FW_EQ_CTRL_CMD_EQID(eqid));
7771 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7775 * t4_ofld_eq_free - free an offload egress queue
7776 * @adap: the adapter
7777 * @mbox: mailbox to use for the FW command
7778 * @pf: the PF owning the queue
7779 * @vf: the VF owning the queue
7780 * @eqid: egress queue id
7782 * Frees a control egress queue.
7784 int t4_ofld_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
7785 unsigned int vf, unsigned int eqid)
7787 struct fw_eq_ofld_cmd c;
7789 memset(&c, 0, sizeof(c));
7790 c.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_EQ_OFLD_CMD) |
7791 F_FW_CMD_REQUEST | F_FW_CMD_EXEC |
7792 V_FW_EQ_OFLD_CMD_PFN(pf) |
7793 V_FW_EQ_OFLD_CMD_VFN(vf));
7794 c.alloc_to_len16 = cpu_to_be32(F_FW_EQ_OFLD_CMD_FREE | FW_LEN16(c));
7795 c.eqid_pkd = cpu_to_be32(V_FW_EQ_OFLD_CMD_EQID(eqid));
7796 return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
7800 * t4_link_down_rc_str - return a string for a Link Down Reason Code
7801 * @link_down_rc: Link Down Reason Code
7803 * Returns a string representation of the Link Down Reason Code.
7805 const char *t4_link_down_rc_str(unsigned char link_down_rc)
7807 static const char *reason[] = {
7810 "Auto-negotiation Failure",
7812 "Insufficient Airflow",
7813 "Unable To Determine Reason",
7814 "No RX Signal Detected",
7818 if (link_down_rc >= ARRAY_SIZE(reason))
7819 return "Bad Reason Code";
7821 return reason[link_down_rc];
7825 * Return the highest speed set in the port capabilities, in Mb/s.
7827 unsigned int fwcap_to_speed(uint32_t caps)
7829 #define TEST_SPEED_RETURN(__caps_speed, __speed) \
7831 if (caps & FW_PORT_CAP32_SPEED_##__caps_speed) \
7835 TEST_SPEED_RETURN(400G, 400000);
7836 TEST_SPEED_RETURN(200G, 200000);
7837 TEST_SPEED_RETURN(100G, 100000);
7838 TEST_SPEED_RETURN(50G, 50000);
7839 TEST_SPEED_RETURN(40G, 40000);
7840 TEST_SPEED_RETURN(25G, 25000);
7841 TEST_SPEED_RETURN(10G, 10000);
7842 TEST_SPEED_RETURN(1G, 1000);
7843 TEST_SPEED_RETURN(100M, 100);
7845 #undef TEST_SPEED_RETURN
7851 * Return the port capabilities bit for the given speed, which is in Mb/s.
7853 uint32_t speed_to_fwcap(unsigned int speed)
7855 #define TEST_SPEED_RETURN(__caps_speed, __speed) \
7857 if (speed == __speed) \
7858 return FW_PORT_CAP32_SPEED_##__caps_speed; \
7861 TEST_SPEED_RETURN(400G, 400000);
7862 TEST_SPEED_RETURN(200G, 200000);
7863 TEST_SPEED_RETURN(100G, 100000);
7864 TEST_SPEED_RETURN(50G, 50000);
7865 TEST_SPEED_RETURN(40G, 40000);
7866 TEST_SPEED_RETURN(25G, 25000);
7867 TEST_SPEED_RETURN(10G, 10000);
7868 TEST_SPEED_RETURN(1G, 1000);
7869 TEST_SPEED_RETURN(100M, 100);
7871 #undef TEST_SPEED_RETURN
7877 * Return the port capabilities bit for the highest speed in the capabilities.
7879 uint32_t fwcap_top_speed(uint32_t caps)
7881 #define TEST_SPEED_RETURN(__caps_speed) \
7883 if (caps & FW_PORT_CAP32_SPEED_##__caps_speed) \
7884 return FW_PORT_CAP32_SPEED_##__caps_speed; \
7887 TEST_SPEED_RETURN(400G);
7888 TEST_SPEED_RETURN(200G);
7889 TEST_SPEED_RETURN(100G);
7890 TEST_SPEED_RETURN(50G);
7891 TEST_SPEED_RETURN(40G);
7892 TEST_SPEED_RETURN(25G);
7893 TEST_SPEED_RETURN(10G);
7894 TEST_SPEED_RETURN(1G);
7895 TEST_SPEED_RETURN(100M);
7897 #undef TEST_SPEED_RETURN
7904 * lstatus_to_fwcap - translate old lstatus to 32-bit Port Capabilities
7905 * @lstatus: old FW_PORT_ACTION_GET_PORT_INFO lstatus value
7907 * Translates old FW_PORT_ACTION_GET_PORT_INFO lstatus field into new
7908 * 32-bit Port Capabilities value.
7910 static uint32_t lstatus_to_fwcap(u32 lstatus)
7912 uint32_t linkattr = 0;
7915 * Unfortunately the format of the Link Status in the old
7916 * 16-bit Port Information message isn't the same as the
7917 * 16-bit Port Capabilities bitfield used everywhere else ...
7919 if (lstatus & F_FW_PORT_CMD_RXPAUSE)
7920 linkattr |= FW_PORT_CAP32_FC_RX;
7921 if (lstatus & F_FW_PORT_CMD_TXPAUSE)
7922 linkattr |= FW_PORT_CAP32_FC_TX;
7923 if (lstatus & V_FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_100M))
7924 linkattr |= FW_PORT_CAP32_SPEED_100M;
7925 if (lstatus & V_FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_1G))
7926 linkattr |= FW_PORT_CAP32_SPEED_1G;
7927 if (lstatus & V_FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_10G))
7928 linkattr |= FW_PORT_CAP32_SPEED_10G;
7929 if (lstatus & V_FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_25G))
7930 linkattr |= FW_PORT_CAP32_SPEED_25G;
7931 if (lstatus & V_FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_40G))
7932 linkattr |= FW_PORT_CAP32_SPEED_40G;
7933 if (lstatus & V_FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_100G))
7934 linkattr |= FW_PORT_CAP32_SPEED_100G;
7940 * Updates all fields owned by the common code in port_info and link_config
7941 * based on information provided by the firmware. Does not touch any
7942 * requested_* field.
7944 static void handle_port_info(struct port_info *pi, const struct fw_port_cmd *p,
7945 enum fw_port_action action, bool *mod_changed, bool *link_changed)
7947 struct link_config old_lc, *lc = &pi->link_cfg;
7948 unsigned char fc, fec;
7950 int old_ptype, old_mtype;
7952 old_ptype = pi->port_type;
7953 old_mtype = pi->mod_type;
7955 if (action == FW_PORT_ACTION_GET_PORT_INFO) {
7956 stat = be32_to_cpu(p->u.info.lstatus_to_modtype);
7958 pi->port_type = G_FW_PORT_CMD_PTYPE(stat);
7959 pi->mod_type = G_FW_PORT_CMD_MODTYPE(stat);
7960 pi->mdio_addr = stat & F_FW_PORT_CMD_MDIOCAP ?
7961 G_FW_PORT_CMD_MDIOADDR(stat) : -1;
7963 lc->supported = fwcaps16_to_caps32(be16_to_cpu(p->u.info.pcap));
7964 lc->advertising = fwcaps16_to_caps32(be16_to_cpu(p->u.info.acap));
7965 lc->lp_advertising = fwcaps16_to_caps32(be16_to_cpu(p->u.info.lpacap));
7966 lc->link_ok = (stat & F_FW_PORT_CMD_LSTATUS) != 0;
7967 lc->link_down_rc = G_FW_PORT_CMD_LINKDNRC(stat);
7969 linkattr = lstatus_to_fwcap(stat);
7970 } else if (action == FW_PORT_ACTION_GET_PORT_INFO32) {
7971 stat = be32_to_cpu(p->u.info32.lstatus32_to_cbllen32);
7973 pi->port_type = G_FW_PORT_CMD_PORTTYPE32(stat);
7974 pi->mod_type = G_FW_PORT_CMD_MODTYPE32(stat);
7975 pi->mdio_addr = stat & F_FW_PORT_CMD_MDIOCAP32 ?
7976 G_FW_PORT_CMD_MDIOADDR32(stat) : -1;
7978 lc->supported = be32_to_cpu(p->u.info32.pcaps32);
7979 lc->advertising = be32_to_cpu(p->u.info32.acaps32);
7980 lc->lp_advertising = be16_to_cpu(p->u.info32.lpacaps32);
7981 lc->link_ok = (stat & F_FW_PORT_CMD_LSTATUS32) != 0;
7982 lc->link_down_rc = G_FW_PORT_CMD_LINKDNRC32(stat);
7984 linkattr = be32_to_cpu(p->u.info32.linkattr32);
7986 CH_ERR(pi->adapter, "bad port_info action 0x%x\n", action);
7990 lc->speed = fwcap_to_speed(linkattr);
7993 if (linkattr & FW_PORT_CAP32_FC_RX)
7995 if (linkattr & FW_PORT_CAP32_FC_TX)
8000 if (linkattr & FW_PORT_CAP32_FEC_RS)
8002 if (linkattr & FW_PORT_CAP32_FEC_BASER_RS)
8003 fec |= FEC_BASER_RS;
8006 if (mod_changed != NULL)
8007 *mod_changed = false;
8008 if (link_changed != NULL)
8009 *link_changed = false;
8010 if (old_ptype != pi->port_type || old_mtype != pi->mod_type ||
8011 old_lc.supported != lc->supported) {
8012 if (pi->mod_type != FW_PORT_MOD_TYPE_NONE) {
8013 lc->fec_hint = lc->advertising &
8014 V_FW_PORT_CAP32_FEC(M_FW_PORT_CAP32_FEC);
8016 if (mod_changed != NULL)
8017 *mod_changed = true;
8019 if (old_lc.link_ok != lc->link_ok || old_lc.speed != lc->speed ||
8020 old_lc.fec != lc->fec || old_lc.fc != lc->fc) {
8021 if (link_changed != NULL)
8022 *link_changed = true;
8027 * t4_update_port_info - retrieve and update port information if changed
8028 * @pi: the port_info
8030 * We issue a Get Port Information Command to the Firmware and, if
8031 * successful, we check to see if anything is different from what we
8032 * last recorded and update things accordingly.
8034 int t4_update_port_info(struct port_info *pi)
8036 struct adapter *sc = pi->adapter;
8037 struct fw_port_cmd cmd;
8038 enum fw_port_action action;
8041 memset(&cmd, 0, sizeof(cmd));
8042 cmd.op_to_portid = cpu_to_be32(V_FW_CMD_OP(FW_PORT_CMD) |
8043 F_FW_CMD_REQUEST | F_FW_CMD_READ |
8044 V_FW_PORT_CMD_PORTID(pi->tx_chan));
8045 action = sc->params.port_caps32 ? FW_PORT_ACTION_GET_PORT_INFO32 :
8046 FW_PORT_ACTION_GET_PORT_INFO;
8047 cmd.action_to_len16 = cpu_to_be32(V_FW_PORT_CMD_ACTION(action) |
8049 ret = t4_wr_mbox_ns(sc, sc->mbox, &cmd, sizeof(cmd), &cmd);
8053 handle_port_info(pi, &cmd, action, NULL, NULL);
8058 * t4_handle_fw_rpl - process a FW reply message
8059 * @adap: the adapter
8060 * @rpl: start of the FW message
8062 * Processes a FW message, such as link state change messages.
8064 int t4_handle_fw_rpl(struct adapter *adap, const __be64 *rpl)
8066 u8 opcode = *(const u8 *)rpl;
8067 const struct fw_port_cmd *p = (const void *)rpl;
8068 enum fw_port_action action =
8069 G_FW_PORT_CMD_ACTION(be32_to_cpu(p->action_to_len16));
8070 bool mod_changed, link_changed;
8072 if (opcode == FW_PORT_CMD &&
8073 (action == FW_PORT_ACTION_GET_PORT_INFO ||
8074 action == FW_PORT_ACTION_GET_PORT_INFO32)) {
8075 /* link/module state change message */
8077 int chan = G_FW_PORT_CMD_PORTID(be32_to_cpu(p->op_to_portid));
8078 struct port_info *pi = NULL;
8079 struct link_config *lc;
8081 for_each_port(adap, i) {
8082 pi = adap2pinfo(adap, i);
8083 if (pi->tx_chan == chan)
8089 handle_port_info(pi, p, action, &mod_changed, &link_changed);
8092 t4_os_portmod_changed(pi);
8095 t4_os_link_changed(pi);
8099 CH_WARN_RATELIMIT(adap, "Unknown firmware reply %d\n", opcode);
8106 * get_pci_mode - determine a card's PCI mode
8107 * @adapter: the adapter
8108 * @p: where to store the PCI settings
8110 * Determines a card's PCI mode and associated parameters, such as speed
8113 static void get_pci_mode(struct adapter *adapter,
8114 struct pci_params *p)
8119 pcie_cap = t4_os_find_pci_capability(adapter, PCI_CAP_ID_EXP);
8121 t4_os_pci_read_cfg2(adapter, pcie_cap + PCI_EXP_LNKSTA, &val);
8122 p->speed = val & PCI_EXP_LNKSTA_CLS;
8123 p->width = (val & PCI_EXP_LNKSTA_NLW) >> 4;
8128 u32 vendor_and_model_id;
8132 int t4_get_flash_params(struct adapter *adapter)
8135 * Table for non-standard supported Flash parts. Note, all Flash
8136 * parts must have 64KB sectors.
8138 static struct flash_desc supported_flash[] = {
8139 { 0x00150201, 4 << 20 }, /* Spansion 4MB S25FL032P */
8144 unsigned int part, manufacturer;
8145 unsigned int density, size = 0;
8149 * Issue a Read ID Command to the Flash part. We decode supported
8150 * Flash parts and their sizes from this. There's a newer Query
8151 * Command which can retrieve detailed geometry information but many
8152 * Flash parts don't support it.
8154 ret = sf1_write(adapter, 1, 1, 0, SF_RD_ID);
8156 ret = sf1_read(adapter, 3, 0, 1, &flashid);
8157 t4_write_reg(adapter, A_SF_OP, 0); /* unlock SF */
8162 * Check to see if it's one of our non-standard supported Flash parts.
8164 for (part = 0; part < ARRAY_SIZE(supported_flash); part++)
8165 if (supported_flash[part].vendor_and_model_id == flashid) {
8166 adapter->params.sf_size =
8167 supported_flash[part].size_mb;
8168 adapter->params.sf_nsec =
8169 adapter->params.sf_size / SF_SEC_SIZE;
8174 * Decode Flash part size. The code below looks repetative with
8175 * common encodings, but that's not guaranteed in the JEDEC
8176 * specification for the Read JADEC ID command. The only thing that
8177 * we're guaranteed by the JADEC specification is where the
8178 * Manufacturer ID is in the returned result. After that each
8179 * Manufacturer ~could~ encode things completely differently.
8180 * Note, all Flash parts must have 64KB sectors.
8182 manufacturer = flashid & 0xff;
8183 switch (manufacturer) {
8184 case 0x20: /* Micron/Numonix */
8186 * This Density -> Size decoding table is taken from Micron
8189 density = (flashid >> 16) & 0xff;
8191 case 0x14: size = 1 << 20; break; /* 1MB */
8192 case 0x15: size = 1 << 21; break; /* 2MB */
8193 case 0x16: size = 1 << 22; break; /* 4MB */
8194 case 0x17: size = 1 << 23; break; /* 8MB */
8195 case 0x18: size = 1 << 24; break; /* 16MB */
8196 case 0x19: size = 1 << 25; break; /* 32MB */
8197 case 0x20: size = 1 << 26; break; /* 64MB */
8198 case 0x21: size = 1 << 27; break; /* 128MB */
8199 case 0x22: size = 1 << 28; break; /* 256MB */
8203 case 0x9d: /* ISSI -- Integrated Silicon Solution, Inc. */
8205 * This Density -> Size decoding table is taken from ISSI
8208 density = (flashid >> 16) & 0xff;
8210 case 0x16: size = 1 << 25; break; /* 32MB */
8211 case 0x17: size = 1 << 26; break; /* 64MB */
8215 case 0xc2: /* Macronix */
8217 * This Density -> Size decoding table is taken from Macronix
8220 density = (flashid >> 16) & 0xff;
8222 case 0x17: size = 1 << 23; break; /* 8MB */
8223 case 0x18: size = 1 << 24; break; /* 16MB */
8227 case 0xef: /* Winbond */
8229 * This Density -> Size decoding table is taken from Winbond
8232 density = (flashid >> 16) & 0xff;
8234 case 0x17: size = 1 << 23; break; /* 8MB */
8235 case 0x18: size = 1 << 24; break; /* 16MB */
8240 /* If we didn't recognize the FLASH part, that's no real issue: the
8241 * Hardware/Software contract says that Hardware will _*ALWAYS*_
8242 * use a FLASH part which is at least 4MB in size and has 64KB
8243 * sectors. The unrecognized FLASH part is likely to be much larger
8244 * than 4MB, but that's all we really need.
8247 CH_WARN(adapter, "Unknown Flash Part, ID = %#x, assuming 4MB\n", flashid);
8252 * Store decoded Flash size and fall through into vetting code.
8254 adapter->params.sf_size = size;
8255 adapter->params.sf_nsec = size / SF_SEC_SIZE;
8259 * We should ~probably~ reject adapters with FLASHes which are too
8260 * small but we have some legacy FPGAs with small FLASHes that we'd
8261 * still like to use. So instead we emit a scary message ...
8263 if (adapter->params.sf_size < FLASH_MIN_SIZE)
8264 CH_WARN(adapter, "WARNING: Flash Part ID %#x, size %#x < %#x\n",
8265 flashid, adapter->params.sf_size, FLASH_MIN_SIZE);
8270 static void set_pcie_completion_timeout(struct adapter *adapter,
8276 pcie_cap = t4_os_find_pci_capability(adapter, PCI_CAP_ID_EXP);
8278 t4_os_pci_read_cfg2(adapter, pcie_cap + PCI_EXP_DEVCTL2, &val);
8281 t4_os_pci_write_cfg2(adapter, pcie_cap + PCI_EXP_DEVCTL2, val);
8285 const struct chip_params *t4_get_chip_params(int chipid)
8287 static const struct chip_params chip_params[] = {
8291 .pm_stats_cnt = PM_NSTATS,
8292 .cng_ch_bits_log = 2,
8294 .cim_num_obq = CIM_NUM_OBQ,
8295 .mps_rplc_size = 128,
8297 .sge_fl_db = F_DBPRIO,
8298 .mps_tcam_size = NUM_MPS_CLS_SRAM_L_INSTANCES,
8303 .pm_stats_cnt = PM_NSTATS,
8304 .cng_ch_bits_log = 2,
8306 .cim_num_obq = CIM_NUM_OBQ_T5,
8307 .mps_rplc_size = 128,
8309 .sge_fl_db = F_DBPRIO | F_DBTYPE,
8310 .mps_tcam_size = NUM_MPS_T5_CLS_SRAM_L_INSTANCES,
8315 .pm_stats_cnt = T6_PM_NSTATS,
8316 .cng_ch_bits_log = 3,
8318 .cim_num_obq = CIM_NUM_OBQ_T5,
8319 .mps_rplc_size = 256,
8322 .mps_tcam_size = NUM_MPS_T5_CLS_SRAM_L_INSTANCES,
8326 chipid -= CHELSIO_T4;
8327 if (chipid < 0 || chipid >= ARRAY_SIZE(chip_params))
8330 return &chip_params[chipid];
8334 * t4_prep_adapter - prepare SW and HW for operation
8335 * @adapter: the adapter
8336 * @buf: temporary space of at least VPD_LEN size provided by the caller.
8338 * Initialize adapter SW state for the various HW modules, set initial
8339 * values for some adapter tunables, take PHYs out of reset, and
8340 * initialize the MDIO interface.
8342 int t4_prep_adapter(struct adapter *adapter, u32 *buf)
8348 get_pci_mode(adapter, &adapter->params.pci);
8350 pl_rev = t4_read_reg(adapter, A_PL_REV);
8351 adapter->params.chipid = G_CHIPID(pl_rev);
8352 adapter->params.rev = G_REV(pl_rev);
8353 if (adapter->params.chipid == 0) {
8354 /* T4 did not have chipid in PL_REV (T5 onwards do) */
8355 adapter->params.chipid = CHELSIO_T4;
8357 /* T4A1 chip is not supported */
8358 if (adapter->params.rev == 1) {
8359 CH_ALERT(adapter, "T4 rev 1 chip is not supported.\n");
8364 adapter->chip_params = t4_get_chip_params(chip_id(adapter));
8365 if (adapter->chip_params == NULL)
8368 adapter->params.pci.vpd_cap_addr =
8369 t4_os_find_pci_capability(adapter, PCI_CAP_ID_VPD);
8371 ret = t4_get_flash_params(adapter);
8375 /* Cards with real ASICs have the chipid in the PCIe device id */
8376 t4_os_pci_read_cfg2(adapter, PCI_DEVICE_ID, &device_id);
8377 if (device_id >> 12 == chip_id(adapter))
8378 adapter->params.cim_la_size = CIMLA_SIZE;
8381 adapter->params.fpga = 1;
8382 adapter->params.cim_la_size = 2 * CIMLA_SIZE;
8385 ret = get_vpd_params(adapter, &adapter->params.vpd, device_id, buf);
8389 init_cong_ctrl(adapter->params.a_wnd, adapter->params.b_wnd);
8392 * Default port and clock for debugging in case we can't reach FW.
8394 adapter->params.nports = 1;
8395 adapter->params.portvec = 1;
8396 adapter->params.vpd.cclk = 50000;
8398 /* Set pci completion timeout value to 4 seconds. */
8399 set_pcie_completion_timeout(adapter, 0xd);
8404 * t4_shutdown_adapter - shut down adapter, host & wire
8405 * @adapter: the adapter
8407 * Perform an emergency shutdown of the adapter and stop it from
8408 * continuing any further communication on the ports or DMA to the
8409 * host. This is typically used when the adapter and/or firmware
8410 * have crashed and we want to prevent any further accidental
8411 * communication with the rest of the world. This will also force
8412 * the port Link Status to go down -- if register writes work --
8413 * which should help our peers figure out that we're down.
8415 int t4_shutdown_adapter(struct adapter *adapter)
8419 t4_intr_disable(adapter);
8420 t4_write_reg(adapter, A_DBG_GPIO_EN, 0);
8421 for_each_port(adapter, port) {
8422 u32 a_port_cfg = is_t4(adapter) ?
8423 PORT_REG(port, A_XGMAC_PORT_CFG) :
8424 T5_PORT_REG(port, A_MAC_PORT_CFG);
8426 t4_write_reg(adapter, a_port_cfg,
8427 t4_read_reg(adapter, a_port_cfg)
8428 & ~V_SIGNAL_DET(1));
8430 t4_set_reg_field(adapter, A_SGE_CONTROL, F_GLOBALENABLE, 0);
8436 * t4_bar2_sge_qregs - return BAR2 SGE Queue register information
8437 * @adapter: the adapter
8438 * @qid: the Queue ID
8439 * @qtype: the Ingress or Egress type for @qid
8440 * @user: true if this request is for a user mode queue
8441 * @pbar2_qoffset: BAR2 Queue Offset
8442 * @pbar2_qid: BAR2 Queue ID or 0 for Queue ID inferred SGE Queues
8444 * Returns the BAR2 SGE Queue Registers information associated with the
8445 * indicated Absolute Queue ID. These are passed back in return value
8446 * pointers. @qtype should be T4_BAR2_QTYPE_EGRESS for Egress Queue
8447 * and T4_BAR2_QTYPE_INGRESS for Ingress Queues.
8449 * This may return an error which indicates that BAR2 SGE Queue
8450 * registers aren't available. If an error is not returned, then the
8451 * following values are returned:
8453 * *@pbar2_qoffset: the BAR2 Offset of the @qid Registers
8454 * *@pbar2_qid: the BAR2 SGE Queue ID or 0 of @qid
8456 * If the returned BAR2 Queue ID is 0, then BAR2 SGE registers which
8457 * require the "Inferred Queue ID" ability may be used. E.g. the
8458 * Write Combining Doorbell Buffer. If the BAR2 Queue ID is not 0,
8459 * then these "Inferred Queue ID" register may not be used.
8461 int t4_bar2_sge_qregs(struct adapter *adapter,
8463 enum t4_bar2_qtype qtype,
8466 unsigned int *pbar2_qid)
8468 unsigned int page_shift, page_size, qpp_shift, qpp_mask;
8469 u64 bar2_page_offset, bar2_qoffset;
8470 unsigned int bar2_qid, bar2_qid_offset, bar2_qinferred;
8472 /* T4 doesn't support BAR2 SGE Queue registers for kernel
8475 if (!user && is_t4(adapter))
8478 /* Get our SGE Page Size parameters.
8480 page_shift = adapter->params.sge.page_shift;
8481 page_size = 1 << page_shift;
8483 /* Get the right Queues per Page parameters for our Queue.
8485 qpp_shift = (qtype == T4_BAR2_QTYPE_EGRESS
8486 ? adapter->params.sge.eq_s_qpp
8487 : adapter->params.sge.iq_s_qpp);
8488 qpp_mask = (1 << qpp_shift) - 1;
8490 /* Calculate the basics of the BAR2 SGE Queue register area:
8491 * o The BAR2 page the Queue registers will be in.
8492 * o The BAR2 Queue ID.
8493 * o The BAR2 Queue ID Offset into the BAR2 page.
8495 bar2_page_offset = ((u64)(qid >> qpp_shift) << page_shift);
8496 bar2_qid = qid & qpp_mask;
8497 bar2_qid_offset = bar2_qid * SGE_UDB_SIZE;
8499 /* If the BAR2 Queue ID Offset is less than the Page Size, then the
8500 * hardware will infer the Absolute Queue ID simply from the writes to
8501 * the BAR2 Queue ID Offset within the BAR2 Page (and we need to use a
8502 * BAR2 Queue ID of 0 for those writes). Otherwise, we'll simply
8503 * write to the first BAR2 SGE Queue Area within the BAR2 Page with
8504 * the BAR2 Queue ID and the hardware will infer the Absolute Queue ID
8505 * from the BAR2 Page and BAR2 Queue ID.
8507 * One important censequence of this is that some BAR2 SGE registers
8508 * have a "Queue ID" field and we can write the BAR2 SGE Queue ID
8509 * there. But other registers synthesize the SGE Queue ID purely
8510 * from the writes to the registers -- the Write Combined Doorbell
8511 * Buffer is a good example. These BAR2 SGE Registers are only
8512 * available for those BAR2 SGE Register areas where the SGE Absolute
8513 * Queue ID can be inferred from simple writes.
8515 bar2_qoffset = bar2_page_offset;
8516 bar2_qinferred = (bar2_qid_offset < page_size);
8517 if (bar2_qinferred) {
8518 bar2_qoffset += bar2_qid_offset;
8522 *pbar2_qoffset = bar2_qoffset;
8523 *pbar2_qid = bar2_qid;
8528 * t4_init_devlog_params - initialize adapter->params.devlog
8529 * @adap: the adapter
8530 * @fw_attach: whether we can talk to the firmware
8532 * Initialize various fields of the adapter's Firmware Device Log
8533 * Parameters structure.
8535 int t4_init_devlog_params(struct adapter *adap, int fw_attach)
8537 struct devlog_params *dparams = &adap->params.devlog;
8539 unsigned int devlog_meminfo;
8540 struct fw_devlog_cmd devlog_cmd;
8543 /* If we're dealing with newer firmware, the Device Log Paramerters
8544 * are stored in a designated register which allows us to access the
8545 * Device Log even if we can't talk to the firmware.
8548 t4_read_reg(adap, PCIE_FW_REG(A_PCIE_FW_PF, PCIE_FW_PF_DEVLOG));
8550 unsigned int nentries, nentries128;
8552 dparams->memtype = G_PCIE_FW_PF_DEVLOG_MEMTYPE(pf_dparams);
8553 dparams->start = G_PCIE_FW_PF_DEVLOG_ADDR16(pf_dparams) << 4;
8555 nentries128 = G_PCIE_FW_PF_DEVLOG_NENTRIES128(pf_dparams);
8556 nentries = (nentries128 + 1) * 128;
8557 dparams->size = nentries * sizeof(struct fw_devlog_e);
8563 * For any failing returns ...
8565 memset(dparams, 0, sizeof *dparams);
8568 * If we can't talk to the firmware, there's really nothing we can do
8574 /* Otherwise, ask the firmware for it's Device Log Parameters.
8576 memset(&devlog_cmd, 0, sizeof devlog_cmd);
8577 devlog_cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_DEVLOG_CMD) |
8578 F_FW_CMD_REQUEST | F_FW_CMD_READ);
8579 devlog_cmd.retval_len16 = cpu_to_be32(FW_LEN16(devlog_cmd));
8580 ret = t4_wr_mbox(adap, adap->mbox, &devlog_cmd, sizeof(devlog_cmd),
8586 be32_to_cpu(devlog_cmd.memtype_devlog_memaddr16_devlog);
8587 dparams->memtype = G_FW_DEVLOG_CMD_MEMTYPE_DEVLOG(devlog_meminfo);
8588 dparams->start = G_FW_DEVLOG_CMD_MEMADDR16_DEVLOG(devlog_meminfo) << 4;
8589 dparams->size = be32_to_cpu(devlog_cmd.memsize_devlog);
8595 * t4_init_sge_params - initialize adap->params.sge
8596 * @adapter: the adapter
8598 * Initialize various fields of the adapter's SGE Parameters structure.
8600 int t4_init_sge_params(struct adapter *adapter)
8603 struct sge_params *sp = &adapter->params.sge;
8604 unsigned i, tscale = 1;
8606 r = t4_read_reg(adapter, A_SGE_INGRESS_RX_THRESHOLD);
8607 sp->counter_val[0] = G_THRESHOLD_0(r);
8608 sp->counter_val[1] = G_THRESHOLD_1(r);
8609 sp->counter_val[2] = G_THRESHOLD_2(r);
8610 sp->counter_val[3] = G_THRESHOLD_3(r);
8612 if (chip_id(adapter) >= CHELSIO_T6) {
8613 r = t4_read_reg(adapter, A_SGE_ITP_CONTROL);
8614 tscale = G_TSCALE(r);
8621 r = t4_read_reg(adapter, A_SGE_TIMER_VALUE_0_AND_1);
8622 sp->timer_val[0] = core_ticks_to_us(adapter, G_TIMERVALUE0(r)) * tscale;
8623 sp->timer_val[1] = core_ticks_to_us(adapter, G_TIMERVALUE1(r)) * tscale;
8624 r = t4_read_reg(adapter, A_SGE_TIMER_VALUE_2_AND_3);
8625 sp->timer_val[2] = core_ticks_to_us(adapter, G_TIMERVALUE2(r)) * tscale;
8626 sp->timer_val[3] = core_ticks_to_us(adapter, G_TIMERVALUE3(r)) * tscale;
8627 r = t4_read_reg(adapter, A_SGE_TIMER_VALUE_4_AND_5);
8628 sp->timer_val[4] = core_ticks_to_us(adapter, G_TIMERVALUE4(r)) * tscale;
8629 sp->timer_val[5] = core_ticks_to_us(adapter, G_TIMERVALUE5(r)) * tscale;
8631 r = t4_read_reg(adapter, A_SGE_CONM_CTRL);
8632 sp->fl_starve_threshold = G_EGRTHRESHOLD(r) * 2 + 1;
8634 sp->fl_starve_threshold2 = sp->fl_starve_threshold;
8635 else if (is_t5(adapter))
8636 sp->fl_starve_threshold2 = G_EGRTHRESHOLDPACKING(r) * 2 + 1;
8638 sp->fl_starve_threshold2 = G_T6_EGRTHRESHOLDPACKING(r) * 2 + 1;
8640 /* egress queues: log2 of # of doorbells per BAR2 page */
8641 r = t4_read_reg(adapter, A_SGE_EGRESS_QUEUES_PER_PAGE_PF);
8642 r >>= S_QUEUESPERPAGEPF0 +
8643 (S_QUEUESPERPAGEPF1 - S_QUEUESPERPAGEPF0) * adapter->pf;
8644 sp->eq_s_qpp = r & M_QUEUESPERPAGEPF0;
8646 /* ingress queues: log2 of # of doorbells per BAR2 page */
8647 r = t4_read_reg(adapter, A_SGE_INGRESS_QUEUES_PER_PAGE_PF);
8648 r >>= S_QUEUESPERPAGEPF0 +
8649 (S_QUEUESPERPAGEPF1 - S_QUEUESPERPAGEPF0) * adapter->pf;
8650 sp->iq_s_qpp = r & M_QUEUESPERPAGEPF0;
8652 r = t4_read_reg(adapter, A_SGE_HOST_PAGE_SIZE);
8653 r >>= S_HOSTPAGESIZEPF0 +
8654 (S_HOSTPAGESIZEPF1 - S_HOSTPAGESIZEPF0) * adapter->pf;
8655 sp->page_shift = (r & M_HOSTPAGESIZEPF0) + 10;
8657 r = t4_read_reg(adapter, A_SGE_CONTROL);
8658 sp->sge_control = r;
8659 sp->spg_len = r & F_EGRSTATUSPAGESIZE ? 128 : 64;
8660 sp->fl_pktshift = G_PKTSHIFT(r);
8661 if (chip_id(adapter) <= CHELSIO_T5) {
8662 sp->pad_boundary = 1 << (G_INGPADBOUNDARY(r) +
8663 X_INGPADBOUNDARY_SHIFT);
8665 sp->pad_boundary = 1 << (G_INGPADBOUNDARY(r) +
8666 X_T6_INGPADBOUNDARY_SHIFT);
8669 sp->pack_boundary = sp->pad_boundary;
8671 r = t4_read_reg(adapter, A_SGE_CONTROL2);
8672 if (G_INGPACKBOUNDARY(r) == 0)
8673 sp->pack_boundary = 16;
8675 sp->pack_boundary = 1 << (G_INGPACKBOUNDARY(r) + 5);
8677 for (i = 0; i < SGE_FLBUF_SIZES; i++)
8678 sp->sge_fl_buffer_size[i] = t4_read_reg(adapter,
8679 A_SGE_FL_BUFFER_SIZE0 + (4 * i));
8685 * Read and cache the adapter's compressed filter mode and ingress config.
8687 static void read_filter_mode_and_ingress_config(struct adapter *adap,
8691 struct tp_params *tpp = &adap->params.tp;
8693 t4_tp_pio_read(adap, &tpp->vlan_pri_map, 1, A_TP_VLAN_PRI_MAP,
8695 t4_tp_pio_read(adap, &tpp->ingress_config, 1, A_TP_INGRESS_CONFIG,
8699 * Now that we have TP_VLAN_PRI_MAP cached, we can calculate the field
8700 * shift positions of several elements of the Compressed Filter Tuple
8701 * for this adapter which we need frequently ...
8703 tpp->fcoe_shift = t4_filter_field_shift(adap, F_FCOE);
8704 tpp->port_shift = t4_filter_field_shift(adap, F_PORT);
8705 tpp->vnic_shift = t4_filter_field_shift(adap, F_VNIC_ID);
8706 tpp->vlan_shift = t4_filter_field_shift(adap, F_VLAN);
8707 tpp->tos_shift = t4_filter_field_shift(adap, F_TOS);
8708 tpp->protocol_shift = t4_filter_field_shift(adap, F_PROTOCOL);
8709 tpp->ethertype_shift = t4_filter_field_shift(adap, F_ETHERTYPE);
8710 tpp->macmatch_shift = t4_filter_field_shift(adap, F_MACMATCH);
8711 tpp->matchtype_shift = t4_filter_field_shift(adap, F_MPSHITTYPE);
8712 tpp->frag_shift = t4_filter_field_shift(adap, F_FRAGMENTATION);
8714 if (chip_id(adap) > CHELSIO_T4) {
8715 v = t4_read_reg(adap, LE_HASH_MASK_GEN_IPV4T5(3));
8716 adap->params.tp.hash_filter_mask = v;
8717 v = t4_read_reg(adap, LE_HASH_MASK_GEN_IPV4T5(4));
8718 adap->params.tp.hash_filter_mask |= (u64)v << 32;
8723 * t4_init_tp_params - initialize adap->params.tp
8724 * @adap: the adapter
8726 * Initialize various fields of the adapter's TP Parameters structure.
8728 int t4_init_tp_params(struct adapter *adap, bool sleep_ok)
8732 struct tp_params *tpp = &adap->params.tp;
8734 v = t4_read_reg(adap, A_TP_TIMER_RESOLUTION);
8735 tpp->tre = G_TIMERRESOLUTION(v);
8736 tpp->dack_re = G_DELAYEDACKRESOLUTION(v);
8738 /* MODQ_REQ_MAP defaults to setting queues 0-3 to chan 0-3 */
8739 for (chan = 0; chan < MAX_NCHAN; chan++)
8740 tpp->tx_modq[chan] = chan;
8742 read_filter_mode_and_ingress_config(adap, sleep_ok);
8745 * Cache a mask of the bits that represent the error vector portion of
8746 * rx_pkt.err_vec. T6+ can use a compressed error vector to make room
8747 * for information about outer encapsulation (GENEVE/VXLAN/NVGRE).
8749 tpp->err_vec_mask = htobe16(0xffff);
8750 if (chip_id(adap) > CHELSIO_T5) {
8751 v = t4_read_reg(adap, A_TP_OUT_CONFIG);
8752 if (v & F_CRXPKTENC) {
8754 htobe16(V_T6_COMPR_RXERR_VEC(M_T6_COMPR_RXERR_VEC));
8762 * t4_filter_field_shift - calculate filter field shift
8763 * @adap: the adapter
8764 * @filter_sel: the desired field (from TP_VLAN_PRI_MAP bits)
8766 * Return the shift position of a filter field within the Compressed
8767 * Filter Tuple. The filter field is specified via its selection bit
8768 * within TP_VLAN_PRI_MAL (filter mode). E.g. F_VLAN.
8770 int t4_filter_field_shift(const struct adapter *adap, int filter_sel)
8772 unsigned int filter_mode = adap->params.tp.vlan_pri_map;
8776 if ((filter_mode & filter_sel) == 0)
8779 for (sel = 1, field_shift = 0; sel < filter_sel; sel <<= 1) {
8780 switch (filter_mode & sel) {
8782 field_shift += W_FT_FCOE;
8785 field_shift += W_FT_PORT;
8788 field_shift += W_FT_VNIC_ID;
8791 field_shift += W_FT_VLAN;
8794 field_shift += W_FT_TOS;
8797 field_shift += W_FT_PROTOCOL;
8800 field_shift += W_FT_ETHERTYPE;
8803 field_shift += W_FT_MACMATCH;
8806 field_shift += W_FT_MPSHITTYPE;
8808 case F_FRAGMENTATION:
8809 field_shift += W_FT_FRAGMENTATION;
8816 int t4_port_init(struct adapter *adap, int mbox, int pf, int vf, int port_id)
8821 struct port_info *p = adap2pinfo(adap, port_id);
8824 for (i = 0, j = -1; i <= p->port_id; i++) {
8827 } while ((adap->params.portvec & (1 << j)) == 0);
8831 p->mps_bg_map = t4_get_mps_bg_map(adap, j);
8832 p->rx_e_chan_map = t4_get_rx_e_chan_map(adap, j);
8835 if (!(adap->flags & IS_VF) ||
8836 adap->params.vfres.r_caps & FW_CMD_CAP_PORT) {
8837 t4_update_port_info(p);
8840 ret = t4_alloc_vi(adap, mbox, j, pf, vf, 1, addr, &rss_size);
8844 p->vi[0].viid = ret;
8845 if (chip_id(adap) <= CHELSIO_T5)
8846 p->vi[0].smt_idx = (ret & 0x7f) << 1;
8848 p->vi[0].smt_idx = (ret & 0x7f);
8849 p->vi[0].rss_size = rss_size;
8850 t4_os_set_hw_addr(p, addr);
8852 param = V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
8853 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_RSSINFO) |
8854 V_FW_PARAMS_PARAM_YZ(p->vi[0].viid);
8855 ret = t4_query_params(adap, mbox, pf, vf, 1, ¶m, &val);
8857 p->vi[0].rss_base = 0xffff;
8859 /* MPASS((val >> 16) == rss_size); */
8860 p->vi[0].rss_base = val & 0xffff;
8867 * t4_read_cimq_cfg - read CIM queue configuration
8868 * @adap: the adapter
8869 * @base: holds the queue base addresses in bytes
8870 * @size: holds the queue sizes in bytes
8871 * @thres: holds the queue full thresholds in bytes
8873 * Returns the current configuration of the CIM queues, starting with
8874 * the IBQs, then the OBQs.
8876 void t4_read_cimq_cfg(struct adapter *adap, u16 *base, u16 *size, u16 *thres)
8879 int cim_num_obq = adap->chip_params->cim_num_obq;
8881 for (i = 0; i < CIM_NUM_IBQ; i++) {
8882 t4_write_reg(adap, A_CIM_QUEUE_CONFIG_REF, F_IBQSELECT |
8884 v = t4_read_reg(adap, A_CIM_QUEUE_CONFIG_CTRL);
8885 /* value is in 256-byte units */
8886 *base++ = G_CIMQBASE(v) * 256;
8887 *size++ = G_CIMQSIZE(v) * 256;
8888 *thres++ = G_QUEFULLTHRSH(v) * 8; /* 8-byte unit */
8890 for (i = 0; i < cim_num_obq; i++) {
8891 t4_write_reg(adap, A_CIM_QUEUE_CONFIG_REF, F_OBQSELECT |
8893 v = t4_read_reg(adap, A_CIM_QUEUE_CONFIG_CTRL);
8894 /* value is in 256-byte units */
8895 *base++ = G_CIMQBASE(v) * 256;
8896 *size++ = G_CIMQSIZE(v) * 256;
8901 * t4_read_cim_ibq - read the contents of a CIM inbound queue
8902 * @adap: the adapter
8903 * @qid: the queue index
8904 * @data: where to store the queue contents
8905 * @n: capacity of @data in 32-bit words
8907 * Reads the contents of the selected CIM queue starting at address 0 up
8908 * to the capacity of @data. @n must be a multiple of 4. Returns < 0 on
8909 * error and the number of 32-bit words actually read on success.
8911 int t4_read_cim_ibq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
8913 int i, err, attempts;
8915 const unsigned int nwords = CIM_IBQ_SIZE * 4;
8917 if (qid > 5 || (n & 3))
8920 addr = qid * nwords;
8924 /* It might take 3-10ms before the IBQ debug read access is allowed.
8925 * Wait for 1 Sec with a delay of 1 usec.
8929 for (i = 0; i < n; i++, addr++) {
8930 t4_write_reg(adap, A_CIM_IBQ_DBG_CFG, V_IBQDBGADDR(addr) |
8932 err = t4_wait_op_done(adap, A_CIM_IBQ_DBG_CFG, F_IBQDBGBUSY, 0,
8936 *data++ = t4_read_reg(adap, A_CIM_IBQ_DBG_DATA);
8938 t4_write_reg(adap, A_CIM_IBQ_DBG_CFG, 0);
8943 * t4_read_cim_obq - read the contents of a CIM outbound queue
8944 * @adap: the adapter
8945 * @qid: the queue index
8946 * @data: where to store the queue contents
8947 * @n: capacity of @data in 32-bit words
8949 * Reads the contents of the selected CIM queue starting at address 0 up
8950 * to the capacity of @data. @n must be a multiple of 4. Returns < 0 on
8951 * error and the number of 32-bit words actually read on success.
8953 int t4_read_cim_obq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
8956 unsigned int addr, v, nwords;
8957 int cim_num_obq = adap->chip_params->cim_num_obq;
8959 if ((qid > (cim_num_obq - 1)) || (n & 3))
8962 t4_write_reg(adap, A_CIM_QUEUE_CONFIG_REF, F_OBQSELECT |
8963 V_QUENUMSELECT(qid));
8964 v = t4_read_reg(adap, A_CIM_QUEUE_CONFIG_CTRL);
8966 addr = G_CIMQBASE(v) * 64; /* muliple of 256 -> muliple of 4 */
8967 nwords = G_CIMQSIZE(v) * 64; /* same */
8971 for (i = 0; i < n; i++, addr++) {
8972 t4_write_reg(adap, A_CIM_OBQ_DBG_CFG, V_OBQDBGADDR(addr) |
8974 err = t4_wait_op_done(adap, A_CIM_OBQ_DBG_CFG, F_OBQDBGBUSY, 0,
8978 *data++ = t4_read_reg(adap, A_CIM_OBQ_DBG_DATA);
8980 t4_write_reg(adap, A_CIM_OBQ_DBG_CFG, 0);
8986 CIM_CTL_BASE = 0x2000,
8987 CIM_PBT_ADDR_BASE = 0x2800,
8988 CIM_PBT_LRF_BASE = 0x3000,
8989 CIM_PBT_DATA_BASE = 0x3800
8993 * t4_cim_read - read a block from CIM internal address space
8994 * @adap: the adapter
8995 * @addr: the start address within the CIM address space
8996 * @n: number of words to read
8997 * @valp: where to store the result
8999 * Reads a block of 4-byte words from the CIM intenal address space.
9001 int t4_cim_read(struct adapter *adap, unsigned int addr, unsigned int n,
9006 if (t4_read_reg(adap, A_CIM_HOST_ACC_CTRL) & F_HOSTBUSY)
9009 for ( ; !ret && n--; addr += 4) {
9010 t4_write_reg(adap, A_CIM_HOST_ACC_CTRL, addr);
9011 ret = t4_wait_op_done(adap, A_CIM_HOST_ACC_CTRL, F_HOSTBUSY,
9014 *valp++ = t4_read_reg(adap, A_CIM_HOST_ACC_DATA);
9020 * t4_cim_write - write a block into CIM internal address space
9021 * @adap: the adapter
9022 * @addr: the start address within the CIM address space
9023 * @n: number of words to write
9024 * @valp: set of values to write
9026 * Writes a block of 4-byte words into the CIM intenal address space.
9028 int t4_cim_write(struct adapter *adap, unsigned int addr, unsigned int n,
9029 const unsigned int *valp)
9033 if (t4_read_reg(adap, A_CIM_HOST_ACC_CTRL) & F_HOSTBUSY)
9036 for ( ; !ret && n--; addr += 4) {
9037 t4_write_reg(adap, A_CIM_HOST_ACC_DATA, *valp++);
9038 t4_write_reg(adap, A_CIM_HOST_ACC_CTRL, addr | F_HOSTWRITE);
9039 ret = t4_wait_op_done(adap, A_CIM_HOST_ACC_CTRL, F_HOSTBUSY,
9045 static int t4_cim_write1(struct adapter *adap, unsigned int addr,
9048 return t4_cim_write(adap, addr, 1, &val);
9052 * t4_cim_ctl_read - read a block from CIM control region
9053 * @adap: the adapter
9054 * @addr: the start address within the CIM control region
9055 * @n: number of words to read
9056 * @valp: where to store the result
9058 * Reads a block of 4-byte words from the CIM control region.
9060 int t4_cim_ctl_read(struct adapter *adap, unsigned int addr, unsigned int n,
9063 return t4_cim_read(adap, addr + CIM_CTL_BASE, n, valp);
9067 * t4_cim_read_la - read CIM LA capture buffer
9068 * @adap: the adapter
9069 * @la_buf: where to store the LA data
9070 * @wrptr: the HW write pointer within the capture buffer
9072 * Reads the contents of the CIM LA buffer with the most recent entry at
9073 * the end of the returned data and with the entry at @wrptr first.
9074 * We try to leave the LA in the running state we find it in.
9076 int t4_cim_read_la(struct adapter *adap, u32 *la_buf, unsigned int *wrptr)
9079 unsigned int cfg, val, idx;
9081 ret = t4_cim_read(adap, A_UP_UP_DBG_LA_CFG, 1, &cfg);
9085 if (cfg & F_UPDBGLAEN) { /* LA is running, freeze it */
9086 ret = t4_cim_write1(adap, A_UP_UP_DBG_LA_CFG, 0);
9091 ret = t4_cim_read(adap, A_UP_UP_DBG_LA_CFG, 1, &val);
9095 idx = G_UPDBGLAWRPTR(val);
9099 for (i = 0; i < adap->params.cim_la_size; i++) {
9100 ret = t4_cim_write1(adap, A_UP_UP_DBG_LA_CFG,
9101 V_UPDBGLARDPTR(idx) | F_UPDBGLARDEN);
9104 ret = t4_cim_read(adap, A_UP_UP_DBG_LA_CFG, 1, &val);
9107 if (val & F_UPDBGLARDEN) {
9111 ret = t4_cim_read(adap, A_UP_UP_DBG_LA_DATA, 1, &la_buf[i]);
9115 /* address can't exceed 0xfff (UpDbgLaRdPtr is of 12-bits) */
9116 idx = (idx + 1) & M_UPDBGLARDPTR;
9118 * Bits 0-3 of UpDbgLaRdPtr can be between 0000 to 1001 to
9119 * identify the 32-bit portion of the full 312-bit data
9122 while ((idx & 0xf) > 9)
9123 idx = (idx + 1) % M_UPDBGLARDPTR;
9126 if (cfg & F_UPDBGLAEN) {
9127 int r = t4_cim_write1(adap, A_UP_UP_DBG_LA_CFG,
9128 cfg & ~F_UPDBGLARDEN);
9136 * t4_tp_read_la - read TP LA capture buffer
9137 * @adap: the adapter
9138 * @la_buf: where to store the LA data
9139 * @wrptr: the HW write pointer within the capture buffer
9141 * Reads the contents of the TP LA buffer with the most recent entry at
9142 * the end of the returned data and with the entry at @wrptr first.
9143 * We leave the LA in the running state we find it in.
9145 void t4_tp_read_la(struct adapter *adap, u64 *la_buf, unsigned int *wrptr)
9147 bool last_incomplete;
9148 unsigned int i, cfg, val, idx;
9150 cfg = t4_read_reg(adap, A_TP_DBG_LA_CONFIG) & 0xffff;
9151 if (cfg & F_DBGLAENABLE) /* freeze LA */
9152 t4_write_reg(adap, A_TP_DBG_LA_CONFIG,
9153 adap->params.tp.la_mask | (cfg ^ F_DBGLAENABLE));
9155 val = t4_read_reg(adap, A_TP_DBG_LA_CONFIG);
9156 idx = G_DBGLAWPTR(val);
9157 last_incomplete = G_DBGLAMODE(val) >= 2 && (val & F_DBGLAWHLF) == 0;
9158 if (last_incomplete)
9159 idx = (idx + 1) & M_DBGLARPTR;
9164 val &= ~V_DBGLARPTR(M_DBGLARPTR);
9165 val |= adap->params.tp.la_mask;
9167 for (i = 0; i < TPLA_SIZE; i++) {
9168 t4_write_reg(adap, A_TP_DBG_LA_CONFIG, V_DBGLARPTR(idx) | val);
9169 la_buf[i] = t4_read_reg64(adap, A_TP_DBG_LA_DATAL);
9170 idx = (idx + 1) & M_DBGLARPTR;
9173 /* Wipe out last entry if it isn't valid */
9174 if (last_incomplete)
9175 la_buf[TPLA_SIZE - 1] = ~0ULL;
9177 if (cfg & F_DBGLAENABLE) /* restore running state */
9178 t4_write_reg(adap, A_TP_DBG_LA_CONFIG,
9179 cfg | adap->params.tp.la_mask);
9183 * SGE Hung Ingress DMA Warning Threshold time and Warning Repeat Rate (in
9184 * seconds). If we find one of the SGE Ingress DMA State Machines in the same
9185 * state for more than the Warning Threshold then we'll issue a warning about
9186 * a potential hang. We'll repeat the warning as the SGE Ingress DMA Channel
9187 * appears to be hung every Warning Repeat second till the situation clears.
9188 * If the situation clears, we'll note that as well.
9190 #define SGE_IDMA_WARN_THRESH 1
9191 #define SGE_IDMA_WARN_REPEAT 300
9194 * t4_idma_monitor_init - initialize SGE Ingress DMA Monitor
9195 * @adapter: the adapter
9196 * @idma: the adapter IDMA Monitor state
9198 * Initialize the state of an SGE Ingress DMA Monitor.
9200 void t4_idma_monitor_init(struct adapter *adapter,
9201 struct sge_idma_monitor_state *idma)
9203 /* Initialize the state variables for detecting an SGE Ingress DMA
9204 * hang. The SGE has internal counters which count up on each clock
9205 * tick whenever the SGE finds its Ingress DMA State Engines in the
9206 * same state they were on the previous clock tick. The clock used is
9207 * the Core Clock so we have a limit on the maximum "time" they can
9208 * record; typically a very small number of seconds. For instance,
9209 * with a 600MHz Core Clock, we can only count up to a bit more than
9210 * 7s. So we'll synthesize a larger counter in order to not run the
9211 * risk of having the "timers" overflow and give us the flexibility to
9212 * maintain a Hung SGE State Machine of our own which operates across
9213 * a longer time frame.
9215 idma->idma_1s_thresh = core_ticks_per_usec(adapter) * 1000000; /* 1s */
9216 idma->idma_stalled[0] = idma->idma_stalled[1] = 0;
9220 * t4_idma_monitor - monitor SGE Ingress DMA state
9221 * @adapter: the adapter
9222 * @idma: the adapter IDMA Monitor state
9223 * @hz: number of ticks/second
9224 * @ticks: number of ticks since the last IDMA Monitor call
9226 void t4_idma_monitor(struct adapter *adapter,
9227 struct sge_idma_monitor_state *idma,
9230 int i, idma_same_state_cnt[2];
9232 /* Read the SGE Debug Ingress DMA Same State Count registers. These
9233 * are counters inside the SGE which count up on each clock when the
9234 * SGE finds its Ingress DMA State Engines in the same states they
9235 * were in the previous clock. The counters will peg out at
9236 * 0xffffffff without wrapping around so once they pass the 1s
9237 * threshold they'll stay above that till the IDMA state changes.
9239 t4_write_reg(adapter, A_SGE_DEBUG_INDEX, 13);
9240 idma_same_state_cnt[0] = t4_read_reg(adapter, A_SGE_DEBUG_DATA_HIGH);
9241 idma_same_state_cnt[1] = t4_read_reg(adapter, A_SGE_DEBUG_DATA_LOW);
9243 for (i = 0; i < 2; i++) {
9244 u32 debug0, debug11;
9246 /* If the Ingress DMA Same State Counter ("timer") is less
9247 * than 1s, then we can reset our synthesized Stall Timer and
9248 * continue. If we have previously emitted warnings about a
9249 * potential stalled Ingress Queue, issue a note indicating
9250 * that the Ingress Queue has resumed forward progress.
9252 if (idma_same_state_cnt[i] < idma->idma_1s_thresh) {
9253 if (idma->idma_stalled[i] >= SGE_IDMA_WARN_THRESH*hz)
9254 CH_WARN(adapter, "SGE idma%d, queue %u, "
9255 "resumed after %d seconds\n",
9256 i, idma->idma_qid[i],
9257 idma->idma_stalled[i]/hz);
9258 idma->idma_stalled[i] = 0;
9262 /* Synthesize an SGE Ingress DMA Same State Timer in the Hz
9263 * domain. The first time we get here it'll be because we
9264 * passed the 1s Threshold; each additional time it'll be
9265 * because the RX Timer Callback is being fired on its regular
9268 * If the stall is below our Potential Hung Ingress Queue
9269 * Warning Threshold, continue.
9271 if (idma->idma_stalled[i] == 0) {
9272 idma->idma_stalled[i] = hz;
9273 idma->idma_warn[i] = 0;
9275 idma->idma_stalled[i] += ticks;
9276 idma->idma_warn[i] -= ticks;
9279 if (idma->idma_stalled[i] < SGE_IDMA_WARN_THRESH*hz)
9282 /* We'll issue a warning every SGE_IDMA_WARN_REPEAT seconds.
9284 if (idma->idma_warn[i] > 0)
9286 idma->idma_warn[i] = SGE_IDMA_WARN_REPEAT*hz;
9288 /* Read and save the SGE IDMA State and Queue ID information.
9289 * We do this every time in case it changes across time ...
9290 * can't be too careful ...
9292 t4_write_reg(adapter, A_SGE_DEBUG_INDEX, 0);
9293 debug0 = t4_read_reg(adapter, A_SGE_DEBUG_DATA_LOW);
9294 idma->idma_state[i] = (debug0 >> (i * 9)) & 0x3f;
9296 t4_write_reg(adapter, A_SGE_DEBUG_INDEX, 11);
9297 debug11 = t4_read_reg(adapter, A_SGE_DEBUG_DATA_LOW);
9298 idma->idma_qid[i] = (debug11 >> (i * 16)) & 0xffff;
9300 CH_WARN(adapter, "SGE idma%u, queue %u, potentially stuck in "
9301 " state %u for %d seconds (debug0=%#x, debug11=%#x)\n",
9302 i, idma->idma_qid[i], idma->idma_state[i],
9303 idma->idma_stalled[i]/hz,
9305 t4_sge_decode_idma_state(adapter, idma->idma_state[i]);
9310 * t4_read_pace_tbl - read the pace table
9311 * @adap: the adapter
9312 * @pace_vals: holds the returned values
9314 * Returns the values of TP's pace table in microseconds.
9316 void t4_read_pace_tbl(struct adapter *adap, unsigned int pace_vals[NTX_SCHED])
9320 for (i = 0; i < NTX_SCHED; i++) {
9321 t4_write_reg(adap, A_TP_PACE_TABLE, 0xffff0000 + i);
9322 v = t4_read_reg(adap, A_TP_PACE_TABLE);
9323 pace_vals[i] = dack_ticks_to_usec(adap, v);
9328 * t4_get_tx_sched - get the configuration of a Tx HW traffic scheduler
9329 * @adap: the adapter
9330 * @sched: the scheduler index
9331 * @kbps: the byte rate in Kbps
9332 * @ipg: the interpacket delay in tenths of nanoseconds
9334 * Return the current configuration of a HW Tx scheduler.
9336 void t4_get_tx_sched(struct adapter *adap, unsigned int sched, unsigned int *kbps,
9337 unsigned int *ipg, bool sleep_ok)
9339 unsigned int v, addr, bpt, cpt;
9342 addr = A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2;
9343 t4_tp_tm_pio_read(adap, &v, 1, addr, sleep_ok);
9346 bpt = (v >> 8) & 0xff;
9349 *kbps = 0; /* scheduler disabled */
9351 v = (adap->params.vpd.cclk * 1000) / cpt; /* ticks/s */
9352 *kbps = (v * bpt) / 125;
9356 addr = A_TP_TX_MOD_Q1_Q0_TIMER_SEPARATOR - sched / 2;
9357 t4_tp_tm_pio_read(adap, &v, 1, addr, sleep_ok);
9361 *ipg = (10000 * v) / core_ticks_per_usec(adap);
9366 * t4_load_cfg - download config file
9367 * @adap: the adapter
9368 * @cfg_data: the cfg text file to write
9369 * @size: text file size
9371 * Write the supplied config text file to the card's serial flash.
9373 int t4_load_cfg(struct adapter *adap, const u8 *cfg_data, unsigned int size)
9375 int ret, i, n, cfg_addr;
9377 unsigned int flash_cfg_start_sec;
9378 unsigned int sf_sec_size = adap->params.sf_size / adap->params.sf_nsec;
9380 cfg_addr = t4_flash_cfg_addr(adap);
9385 flash_cfg_start_sec = addr / SF_SEC_SIZE;
9387 if (size > FLASH_CFG_MAX_SIZE) {
9388 CH_ERR(adap, "cfg file too large, max is %u bytes\n",
9389 FLASH_CFG_MAX_SIZE);
9393 i = DIV_ROUND_UP(FLASH_CFG_MAX_SIZE, /* # of sectors spanned */
9395 ret = t4_flash_erase_sectors(adap, flash_cfg_start_sec,
9396 flash_cfg_start_sec + i - 1);
9398 * If size == 0 then we're simply erasing the FLASH sectors associated
9399 * with the on-adapter Firmware Configuration File.
9401 if (ret || size == 0)
9404 /* this will write to the flash up to SF_PAGE_SIZE at a time */
9405 for (i = 0; i< size; i+= SF_PAGE_SIZE) {
9406 if ( (size - i) < SF_PAGE_SIZE)
9410 ret = t4_write_flash(adap, addr, n, cfg_data, 1);
9414 addr += SF_PAGE_SIZE;
9415 cfg_data += SF_PAGE_SIZE;
9420 CH_ERR(adap, "config file %s failed %d\n",
9421 (size == 0 ? "clear" : "download"), ret);
9426 * t5_fw_init_extern_mem - initialize the external memory
9427 * @adap: the adapter
9429 * Initializes the external memory on T5.
9431 int t5_fw_init_extern_mem(struct adapter *adap)
9433 u32 params[1], val[1];
9439 val[0] = 0xff; /* Initialize all MCs */
9440 params[0] = (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
9441 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_MCINIT));
9442 ret = t4_set_params_timeout(adap, adap->mbox, adap->pf, 0, 1, params, val,
9443 FW_CMD_MAX_TIMEOUT);
9448 /* BIOS boot headers */
9449 typedef struct pci_expansion_rom_header {
9450 u8 signature[2]; /* ROM Signature. Should be 0xaa55 */
9451 u8 reserved[22]; /* Reserved per processor Architecture data */
9452 u8 pcir_offset[2]; /* Offset to PCI Data Structure */
9453 } pci_exp_rom_header_t; /* PCI_EXPANSION_ROM_HEADER */
9455 /* Legacy PCI Expansion ROM Header */
9456 typedef struct legacy_pci_expansion_rom_header {
9457 u8 signature[2]; /* ROM Signature. Should be 0xaa55 */
9458 u8 size512; /* Current Image Size in units of 512 bytes */
9459 u8 initentry_point[4];
9460 u8 cksum; /* Checksum computed on the entire Image */
9461 u8 reserved[16]; /* Reserved */
9462 u8 pcir_offset[2]; /* Offset to PCI Data Struture */
9463 } legacy_pci_exp_rom_header_t; /* LEGACY_PCI_EXPANSION_ROM_HEADER */
9465 /* EFI PCI Expansion ROM Header */
9466 typedef struct efi_pci_expansion_rom_header {
9467 u8 signature[2]; // ROM signature. The value 0xaa55
9468 u8 initialization_size[2]; /* Units 512. Includes this header */
9469 u8 efi_signature[4]; /* Signature from EFI image header. 0x0EF1 */
9470 u8 efi_subsystem[2]; /* Subsystem value for EFI image header */
9471 u8 efi_machine_type[2]; /* Machine type from EFI image header */
9472 u8 compression_type[2]; /* Compression type. */
9474 * Compression type definition
9477 * 0x2-0xFFFF: Reserved
9479 u8 reserved[8]; /* Reserved */
9480 u8 efi_image_header_offset[2]; /* Offset to EFI Image */
9481 u8 pcir_offset[2]; /* Offset to PCI Data Structure */
9482 } efi_pci_exp_rom_header_t; /* EFI PCI Expansion ROM Header */
9484 /* PCI Data Structure Format */
9485 typedef struct pcir_data_structure { /* PCI Data Structure */
9486 u8 signature[4]; /* Signature. The string "PCIR" */
9487 u8 vendor_id[2]; /* Vendor Identification */
9488 u8 device_id[2]; /* Device Identification */
9489 u8 vital_product[2]; /* Pointer to Vital Product Data */
9490 u8 length[2]; /* PCIR Data Structure Length */
9491 u8 revision; /* PCIR Data Structure Revision */
9492 u8 class_code[3]; /* Class Code */
9493 u8 image_length[2]; /* Image Length. Multiple of 512B */
9494 u8 code_revision[2]; /* Revision Level of Code/Data */
9495 u8 code_type; /* Code Type. */
9497 * PCI Expansion ROM Code Types
9498 * 0x00: Intel IA-32, PC-AT compatible. Legacy
9499 * 0x01: Open Firmware standard for PCI. FCODE
9500 * 0x02: Hewlett-Packard PA RISC. HP reserved
9501 * 0x03: EFI Image. EFI
9502 * 0x04-0xFF: Reserved.
9504 u8 indicator; /* Indicator. Identifies the last image in the ROM */
9505 u8 reserved[2]; /* Reserved */
9506 } pcir_data_t; /* PCI__DATA_STRUCTURE */
9508 /* BOOT constants */
9510 BOOT_FLASH_BOOT_ADDR = 0x0,/* start address of boot image in flash */
9511 BOOT_SIGNATURE = 0xaa55, /* signature of BIOS boot ROM */
9512 BOOT_SIZE_INC = 512, /* image size measured in 512B chunks */
9513 BOOT_MIN_SIZE = sizeof(pci_exp_rom_header_t), /* basic header */
9514 BOOT_MAX_SIZE = 1024*BOOT_SIZE_INC, /* 1 byte * length increment */
9515 VENDOR_ID = 0x1425, /* Vendor ID */
9516 PCIR_SIGNATURE = 0x52494350 /* PCIR signature */
9520 * modify_device_id - Modifies the device ID of the Boot BIOS image
9521 * @adatper: the device ID to write.
9522 * @boot_data: the boot image to modify.
9524 * Write the supplied device ID to the boot BIOS image.
9526 static void modify_device_id(int device_id, u8 *boot_data)
9528 legacy_pci_exp_rom_header_t *header;
9529 pcir_data_t *pcir_header;
9533 * Loop through all chained images and change the device ID's
9536 header = (legacy_pci_exp_rom_header_t *) &boot_data[cur_header];
9537 pcir_header = (pcir_data_t *) &boot_data[cur_header +
9538 le16_to_cpu(*(u16*)header->pcir_offset)];
9541 * Only modify the Device ID if code type is Legacy or HP.
9542 * 0x00: Okay to modify
9543 * 0x01: FCODE. Do not be modify
9544 * 0x03: Okay to modify
9545 * 0x04-0xFF: Do not modify
9547 if (pcir_header->code_type == 0x00) {
9552 * Modify Device ID to match current adatper
9554 *(u16*) pcir_header->device_id = device_id;
9557 * Set checksum temporarily to 0.
9558 * We will recalculate it later.
9560 header->cksum = 0x0;
9563 * Calculate and update checksum
9565 for (i = 0; i < (header->size512 * 512); i++)
9566 csum += (u8)boot_data[cur_header + i];
9569 * Invert summed value to create the checksum
9570 * Writing new checksum value directly to the boot data
9572 boot_data[cur_header + 7] = -csum;
9574 } else if (pcir_header->code_type == 0x03) {
9577 * Modify Device ID to match current adatper
9579 *(u16*) pcir_header->device_id = device_id;
9585 * Check indicator element to identify if this is the last
9588 if (pcir_header->indicator & 0x80)
9592 * Move header pointer up to the next image in the ROM.
9594 cur_header += header->size512 * 512;
9599 * t4_load_boot - download boot flash
9600 * @adapter: the adapter
9601 * @boot_data: the boot image to write
9602 * @boot_addr: offset in flash to write boot_data
9605 * Write the supplied boot image to the card's serial flash.
9606 * The boot image has the following sections: a 28-byte header and the
9609 int t4_load_boot(struct adapter *adap, u8 *boot_data,
9610 unsigned int boot_addr, unsigned int size)
9612 pci_exp_rom_header_t *header;
9614 pcir_data_t *pcir_header;
9618 unsigned int boot_sector = (boot_addr * 1024 );
9619 unsigned int sf_sec_size = adap->params.sf_size / adap->params.sf_nsec;
9622 * Make sure the boot image does not encroach on the firmware region
9624 if ((boot_sector + size) >> 16 > FLASH_FW_START_SEC) {
9625 CH_ERR(adap, "boot image encroaching on firmware region\n");
9630 * The boot sector is comprised of the Expansion-ROM boot, iSCSI boot,
9631 * and Boot configuration data sections. These 3 boot sections span
9632 * sectors 0 to 7 in flash and live right before the FW image location.
9634 i = DIV_ROUND_UP(size ? size : FLASH_FW_START,
9636 ret = t4_flash_erase_sectors(adap, boot_sector >> 16,
9637 (boot_sector >> 16) + i - 1);
9640 * If size == 0 then we're simply erasing the FLASH sectors associated
9641 * with the on-adapter option ROM file
9643 if (ret || (size == 0))
9646 /* Get boot header */
9647 header = (pci_exp_rom_header_t *)boot_data;
9648 pcir_offset = le16_to_cpu(*(u16 *)header->pcir_offset);
9649 /* PCIR Data Structure */
9650 pcir_header = (pcir_data_t *) &boot_data[pcir_offset];
9653 * Perform some primitive sanity testing to avoid accidentally
9654 * writing garbage over the boot sectors. We ought to check for
9655 * more but it's not worth it for now ...
9657 if (size < BOOT_MIN_SIZE || size > BOOT_MAX_SIZE) {
9658 CH_ERR(adap, "boot image too small/large\n");
9662 #ifndef CHELSIO_T4_DIAGS
9664 * Check BOOT ROM header signature
9666 if (le16_to_cpu(*(u16*)header->signature) != BOOT_SIGNATURE ) {
9667 CH_ERR(adap, "Boot image missing signature\n");
9672 * Check PCI header signature
9674 if (le32_to_cpu(*(u32*)pcir_header->signature) != PCIR_SIGNATURE) {
9675 CH_ERR(adap, "PCI header missing signature\n");
9680 * Check Vendor ID matches Chelsio ID
9682 if (le16_to_cpu(*(u16*)pcir_header->vendor_id) != VENDOR_ID) {
9683 CH_ERR(adap, "Vendor ID missing signature\n");
9689 * Retrieve adapter's device ID
9691 t4_os_pci_read_cfg2(adap, PCI_DEVICE_ID, &device_id);
9692 /* Want to deal with PF 0 so I strip off PF 4 indicator */
9693 device_id = device_id & 0xf0ff;
9696 * Check PCIE Device ID
9698 if (le16_to_cpu(*(u16*)pcir_header->device_id) != device_id) {
9700 * Change the device ID in the Boot BIOS image to match
9701 * the Device ID of the current adapter.
9703 modify_device_id(device_id, boot_data);
9707 * Skip over the first SF_PAGE_SIZE worth of data and write it after
9708 * we finish copying the rest of the boot image. This will ensure
9709 * that the BIOS boot header will only be written if the boot image
9710 * was written in full.
9713 for (size -= SF_PAGE_SIZE; size; size -= SF_PAGE_SIZE) {
9714 addr += SF_PAGE_SIZE;
9715 boot_data += SF_PAGE_SIZE;
9716 ret = t4_write_flash(adap, addr, SF_PAGE_SIZE, boot_data, 0);
9721 ret = t4_write_flash(adap, boot_sector, SF_PAGE_SIZE,
9722 (const u8 *)header, 0);
9726 CH_ERR(adap, "boot image download failed, error %d\n", ret);
9731 * t4_flash_bootcfg_addr - return the address of the flash optionrom configuration
9732 * @adapter: the adapter
9734 * Return the address within the flash where the OptionROM Configuration
9735 * is stored, or an error if the device FLASH is too small to contain
9736 * a OptionROM Configuration.
9738 static int t4_flash_bootcfg_addr(struct adapter *adapter)
9741 * If the device FLASH isn't large enough to hold a Firmware
9742 * Configuration File, return an error.
9744 if (adapter->params.sf_size < FLASH_BOOTCFG_START + FLASH_BOOTCFG_MAX_SIZE)
9747 return FLASH_BOOTCFG_START;
9750 int t4_load_bootcfg(struct adapter *adap,const u8 *cfg_data, unsigned int size)
9752 int ret, i, n, cfg_addr;
9754 unsigned int flash_cfg_start_sec;
9755 unsigned int sf_sec_size = adap->params.sf_size / adap->params.sf_nsec;
9757 cfg_addr = t4_flash_bootcfg_addr(adap);
9762 flash_cfg_start_sec = addr / SF_SEC_SIZE;
9764 if (size > FLASH_BOOTCFG_MAX_SIZE) {
9765 CH_ERR(adap, "bootcfg file too large, max is %u bytes\n",
9766 FLASH_BOOTCFG_MAX_SIZE);
9770 i = DIV_ROUND_UP(FLASH_BOOTCFG_MAX_SIZE,/* # of sectors spanned */
9772 ret = t4_flash_erase_sectors(adap, flash_cfg_start_sec,
9773 flash_cfg_start_sec + i - 1);
9776 * If size == 0 then we're simply erasing the FLASH sectors associated
9777 * with the on-adapter OptionROM Configuration File.
9779 if (ret || size == 0)
9782 /* this will write to the flash up to SF_PAGE_SIZE at a time */
9783 for (i = 0; i< size; i+= SF_PAGE_SIZE) {
9784 if ( (size - i) < SF_PAGE_SIZE)
9788 ret = t4_write_flash(adap, addr, n, cfg_data, 0);
9792 addr += SF_PAGE_SIZE;
9793 cfg_data += SF_PAGE_SIZE;
9798 CH_ERR(adap, "boot config data %s failed %d\n",
9799 (size == 0 ? "clear" : "download"), ret);
9804 * t4_set_filter_mode - configure the optional components of filter tuples
9805 * @adap: the adapter
9806 * @mode_map: a bitmap selcting which optional filter components to enable
9807 * @sleep_ok: if true we may sleep while awaiting command completion
9809 * Sets the filter mode by selecting the optional components to enable
9810 * in filter tuples. Returns 0 on success and a negative error if the
9811 * requested mode needs more bits than are available for optional
9814 int t4_set_filter_mode(struct adapter *adap, unsigned int mode_map,
9817 static u8 width[] = { 1, 3, 17, 17, 8, 8, 16, 9, 3, 1 };
9821 for (i = S_FCOE; i <= S_FRAGMENTATION; i++)
9822 if (mode_map & (1 << i))
9824 if (nbits > FILTER_OPT_LEN)
9826 t4_tp_pio_write(adap, &mode_map, 1, A_TP_VLAN_PRI_MAP, sleep_ok);
9827 read_filter_mode_and_ingress_config(adap, sleep_ok);
9833 * t4_clr_port_stats - clear port statistics
9834 * @adap: the adapter
9835 * @idx: the port index
9837 * Clear HW statistics for the given port.
9839 void t4_clr_port_stats(struct adapter *adap, int idx)
9842 u32 bgmap = adap2pinfo(adap, idx)->mps_bg_map;
9846 port_base_addr = PORT_BASE(idx);
9848 port_base_addr = T5_PORT_BASE(idx);
9850 for (i = A_MPS_PORT_STAT_TX_PORT_BYTES_L;
9851 i <= A_MPS_PORT_STAT_TX_PORT_PPP7_H; i += 8)
9852 t4_write_reg(adap, port_base_addr + i, 0);
9853 for (i = A_MPS_PORT_STAT_RX_PORT_BYTES_L;
9854 i <= A_MPS_PORT_STAT_RX_PORT_LESS_64B_H; i += 8)
9855 t4_write_reg(adap, port_base_addr + i, 0);
9856 for (i = 0; i < 4; i++)
9857 if (bgmap & (1 << i)) {
9859 A_MPS_STAT_RX_BG_0_MAC_DROP_FRAME_L + i * 8, 0);
9861 A_MPS_STAT_RX_BG_0_MAC_TRUNC_FRAME_L + i * 8, 0);
9866 * t4_i2c_rd - read I2C data from adapter
9867 * @adap: the adapter
9868 * @port: Port number if per-port device; <0 if not
9869 * @devid: per-port device ID or absolute device ID
9870 * @offset: byte offset into device I2C space
9871 * @len: byte length of I2C space data
9872 * @buf: buffer in which to return I2C data
9874 * Reads the I2C data from the indicated device and location.
9876 int t4_i2c_rd(struct adapter *adap, unsigned int mbox,
9877 int port, unsigned int devid,
9878 unsigned int offset, unsigned int len,
9882 struct fw_ldst_cmd ldst;
9888 len > sizeof ldst.u.i2c.data)
9891 memset(&ldst, 0, sizeof ldst);
9892 ldst_addrspace = V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_I2C);
9893 ldst.op_to_addrspace =
9894 cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
9898 ldst.cycles_to_len16 = cpu_to_be32(FW_LEN16(ldst));
9899 ldst.u.i2c.pid = (port < 0 ? 0xff : port);
9900 ldst.u.i2c.did = devid;
9901 ldst.u.i2c.boffset = offset;
9902 ldst.u.i2c.blen = len;
9903 ret = t4_wr_mbox(adap, mbox, &ldst, sizeof ldst, &ldst);
9905 memcpy(buf, ldst.u.i2c.data, len);
9910 * t4_i2c_wr - write I2C data to adapter
9911 * @adap: the adapter
9912 * @port: Port number if per-port device; <0 if not
9913 * @devid: per-port device ID or absolute device ID
9914 * @offset: byte offset into device I2C space
9915 * @len: byte length of I2C space data
9916 * @buf: buffer containing new I2C data
9918 * Write the I2C data to the indicated device and location.
9920 int t4_i2c_wr(struct adapter *adap, unsigned int mbox,
9921 int port, unsigned int devid,
9922 unsigned int offset, unsigned int len,
9926 struct fw_ldst_cmd ldst;
9931 len > sizeof ldst.u.i2c.data)
9934 memset(&ldst, 0, sizeof ldst);
9935 ldst_addrspace = V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_I2C);
9936 ldst.op_to_addrspace =
9937 cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
9941 ldst.cycles_to_len16 = cpu_to_be32(FW_LEN16(ldst));
9942 ldst.u.i2c.pid = (port < 0 ? 0xff : port);
9943 ldst.u.i2c.did = devid;
9944 ldst.u.i2c.boffset = offset;
9945 ldst.u.i2c.blen = len;
9946 memcpy(ldst.u.i2c.data, buf, len);
9947 return t4_wr_mbox(adap, mbox, &ldst, sizeof ldst, &ldst);
9951 * t4_sge_ctxt_rd - read an SGE context through FW
9952 * @adap: the adapter
9953 * @mbox: mailbox to use for the FW command
9954 * @cid: the context id
9955 * @ctype: the context type
9956 * @data: where to store the context data
9958 * Issues a FW command through the given mailbox to read an SGE context.
9960 int t4_sge_ctxt_rd(struct adapter *adap, unsigned int mbox, unsigned int cid,
9961 enum ctxt_type ctype, u32 *data)
9964 struct fw_ldst_cmd c;
9966 if (ctype == CTXT_EGRESS)
9967 ret = FW_LDST_ADDRSPC_SGE_EGRC;
9968 else if (ctype == CTXT_INGRESS)
9969 ret = FW_LDST_ADDRSPC_SGE_INGC;
9970 else if (ctype == CTXT_FLM)
9971 ret = FW_LDST_ADDRSPC_SGE_FLMC;
9973 ret = FW_LDST_ADDRSPC_SGE_CONMC;
9975 memset(&c, 0, sizeof(c));
9976 c.op_to_addrspace = cpu_to_be32(V_FW_CMD_OP(FW_LDST_CMD) |
9977 F_FW_CMD_REQUEST | F_FW_CMD_READ |
9978 V_FW_LDST_CMD_ADDRSPACE(ret));
9979 c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
9980 c.u.idctxt.physid = cpu_to_be32(cid);
9982 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
9984 data[0] = be32_to_cpu(c.u.idctxt.ctxt_data0);
9985 data[1] = be32_to_cpu(c.u.idctxt.ctxt_data1);
9986 data[2] = be32_to_cpu(c.u.idctxt.ctxt_data2);
9987 data[3] = be32_to_cpu(c.u.idctxt.ctxt_data3);
9988 data[4] = be32_to_cpu(c.u.idctxt.ctxt_data4);
9989 data[5] = be32_to_cpu(c.u.idctxt.ctxt_data5);
9995 * t4_sge_ctxt_rd_bd - read an SGE context bypassing FW
9996 * @adap: the adapter
9997 * @cid: the context id
9998 * @ctype: the context type
9999 * @data: where to store the context data
10001 * Reads an SGE context directly, bypassing FW. This is only for
10002 * debugging when FW is unavailable.
10004 int t4_sge_ctxt_rd_bd(struct adapter *adap, unsigned int cid, enum ctxt_type ctype,
10009 t4_write_reg(adap, A_SGE_CTXT_CMD, V_CTXTQID(cid) | V_CTXTTYPE(ctype));
10010 ret = t4_wait_op_done(adap, A_SGE_CTXT_CMD, F_BUSY, 0, 3, 1);
10012 for (i = A_SGE_CTXT_DATA0; i <= A_SGE_CTXT_DATA5; i += 4)
10013 *data++ = t4_read_reg(adap, i);
10017 int t4_sched_config(struct adapter *adapter, int type, int minmaxen,
10020 struct fw_sched_cmd cmd;
10022 memset(&cmd, 0, sizeof(cmd));
10023 cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_SCHED_CMD) |
10026 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
10028 cmd.u.config.sc = FW_SCHED_SC_CONFIG;
10029 cmd.u.config.type = type;
10030 cmd.u.config.minmaxen = minmaxen;
10032 return t4_wr_mbox_meat(adapter,adapter->mbox, &cmd, sizeof(cmd),
10036 int t4_sched_params(struct adapter *adapter, int type, int level, int mode,
10037 int rateunit, int ratemode, int channel, int cl,
10038 int minrate, int maxrate, int weight, int pktsize,
10039 int burstsize, int sleep_ok)
10041 struct fw_sched_cmd cmd;
10043 memset(&cmd, 0, sizeof(cmd));
10044 cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_SCHED_CMD) |
10047 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
10049 cmd.u.params.sc = FW_SCHED_SC_PARAMS;
10050 cmd.u.params.type = type;
10051 cmd.u.params.level = level;
10052 cmd.u.params.mode = mode;
10053 cmd.u.params.ch = channel;
10054 cmd.u.params.cl = cl;
10055 cmd.u.params.unit = rateunit;
10056 cmd.u.params.rate = ratemode;
10057 cmd.u.params.min = cpu_to_be32(minrate);
10058 cmd.u.params.max = cpu_to_be32(maxrate);
10059 cmd.u.params.weight = cpu_to_be16(weight);
10060 cmd.u.params.pktsize = cpu_to_be16(pktsize);
10061 cmd.u.params.burstsize = cpu_to_be16(burstsize);
10063 return t4_wr_mbox_meat(adapter,adapter->mbox, &cmd, sizeof(cmd),
10067 int t4_sched_params_ch_rl(struct adapter *adapter, int channel, int ratemode,
10068 unsigned int maxrate, int sleep_ok)
10070 struct fw_sched_cmd cmd;
10072 memset(&cmd, 0, sizeof(cmd));
10073 cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_SCHED_CMD) |
10076 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
10078 cmd.u.params.sc = FW_SCHED_SC_PARAMS;
10079 cmd.u.params.type = FW_SCHED_TYPE_PKTSCHED;
10080 cmd.u.params.level = FW_SCHED_PARAMS_LEVEL_CH_RL;
10081 cmd.u.params.ch = channel;
10082 cmd.u.params.rate = ratemode; /* REL or ABS */
10083 cmd.u.params.max = cpu_to_be32(maxrate);/* % or kbps */
10085 return t4_wr_mbox_meat(adapter,adapter->mbox, &cmd, sizeof(cmd),
10089 int t4_sched_params_cl_wrr(struct adapter *adapter, int channel, int cl,
10090 int weight, int sleep_ok)
10092 struct fw_sched_cmd cmd;
10094 if (weight < 0 || weight > 100)
10097 memset(&cmd, 0, sizeof(cmd));
10098 cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_SCHED_CMD) |
10101 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
10103 cmd.u.params.sc = FW_SCHED_SC_PARAMS;
10104 cmd.u.params.type = FW_SCHED_TYPE_PKTSCHED;
10105 cmd.u.params.level = FW_SCHED_PARAMS_LEVEL_CL_WRR;
10106 cmd.u.params.ch = channel;
10107 cmd.u.params.cl = cl;
10108 cmd.u.params.weight = cpu_to_be16(weight);
10110 return t4_wr_mbox_meat(adapter,adapter->mbox, &cmd, sizeof(cmd),
10114 int t4_sched_params_cl_rl_kbps(struct adapter *adapter, int channel, int cl,
10115 int mode, unsigned int maxrate, int pktsize, int sleep_ok)
10117 struct fw_sched_cmd cmd;
10119 memset(&cmd, 0, sizeof(cmd));
10120 cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_SCHED_CMD) |
10123 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
10125 cmd.u.params.sc = FW_SCHED_SC_PARAMS;
10126 cmd.u.params.type = FW_SCHED_TYPE_PKTSCHED;
10127 cmd.u.params.level = FW_SCHED_PARAMS_LEVEL_CL_RL;
10128 cmd.u.params.mode = mode;
10129 cmd.u.params.ch = channel;
10130 cmd.u.params.cl = cl;
10131 cmd.u.params.unit = FW_SCHED_PARAMS_UNIT_BITRATE;
10132 cmd.u.params.rate = FW_SCHED_PARAMS_RATE_ABS;
10133 cmd.u.params.max = cpu_to_be32(maxrate);
10134 cmd.u.params.pktsize = cpu_to_be16(pktsize);
10136 return t4_wr_mbox_meat(adapter,adapter->mbox, &cmd, sizeof(cmd),
10141 * t4_config_watchdog - configure (enable/disable) a watchdog timer
10142 * @adapter: the adapter
10143 * @mbox: mailbox to use for the FW command
10144 * @pf: the PF owning the queue
10145 * @vf: the VF owning the queue
10146 * @timeout: watchdog timeout in ms
10147 * @action: watchdog timer / action
10149 * There are separate watchdog timers for each possible watchdog
10150 * action. Configure one of the watchdog timers by setting a non-zero
10151 * timeout. Disable a watchdog timer by using a timeout of zero.
10153 int t4_config_watchdog(struct adapter *adapter, unsigned int mbox,
10154 unsigned int pf, unsigned int vf,
10155 unsigned int timeout, unsigned int action)
10157 struct fw_watchdog_cmd wdog;
10158 unsigned int ticks;
10161 * The watchdog command expects a timeout in units of 10ms so we need
10162 * to convert it here (via rounding) and force a minimum of one 10ms
10163 * "tick" if the timeout is non-zero but the conversion results in 0
10166 ticks = (timeout + 5)/10;
10167 if (timeout && !ticks)
10170 memset(&wdog, 0, sizeof wdog);
10171 wdog.op_to_vfn = cpu_to_be32(V_FW_CMD_OP(FW_WATCHDOG_CMD) |
10174 V_FW_PARAMS_CMD_PFN(pf) |
10175 V_FW_PARAMS_CMD_VFN(vf));
10176 wdog.retval_len16 = cpu_to_be32(FW_LEN16(wdog));
10177 wdog.timeout = cpu_to_be32(ticks);
10178 wdog.action = cpu_to_be32(action);
10180 return t4_wr_mbox(adapter, mbox, &wdog, sizeof wdog, NULL);
10183 int t4_get_devlog_level(struct adapter *adapter, unsigned int *level)
10185 struct fw_devlog_cmd devlog_cmd;
10188 memset(&devlog_cmd, 0, sizeof(devlog_cmd));
10189 devlog_cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_DEVLOG_CMD) |
10190 F_FW_CMD_REQUEST | F_FW_CMD_READ);
10191 devlog_cmd.retval_len16 = cpu_to_be32(FW_LEN16(devlog_cmd));
10192 ret = t4_wr_mbox(adapter, adapter->mbox, &devlog_cmd,
10193 sizeof(devlog_cmd), &devlog_cmd);
10197 *level = devlog_cmd.level;
10201 int t4_set_devlog_level(struct adapter *adapter, unsigned int level)
10203 struct fw_devlog_cmd devlog_cmd;
10205 memset(&devlog_cmd, 0, sizeof(devlog_cmd));
10206 devlog_cmd.op_to_write = cpu_to_be32(V_FW_CMD_OP(FW_DEVLOG_CMD) |
10209 devlog_cmd.level = level;
10210 devlog_cmd.retval_len16 = cpu_to_be32(FW_LEN16(devlog_cmd));
10211 return t4_wr_mbox(adapter, adapter->mbox, &devlog_cmd,
10212 sizeof(devlog_cmd), &devlog_cmd);