aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net
diff options
context:
space:
mode:
authorCasey Leedom <leedom@chelsio.com>2010-06-25 08:12:54 -0400
committerDavid S. Miller <davem@davemloft.net>2010-06-29 02:59:35 -0400
commit16f8bd4be7541215fe9dd772ed8bccee9a864d9c (patch)
tree2b3fbf40b79967a9bd820571867feca4ed7a1237 /drivers/net
parent7ee9ff94857dd27144521118173786a03d490efb (diff)
cxgb4vf: Add core T4 PCI-E SR-IOV Virtual Function hardware definitions and device communication code
Add core T4 PCI-E SR-IOV Virtual Function hardware definitions and device communication code. Signed-off-by: Casey Leedom Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers/net')
-rw-r--r--drivers/net/cxgb4vf/t4vf_common.h273
-rw-r--r--drivers/net/cxgb4vf/t4vf_defs.h121
-rw-r--r--drivers/net/cxgb4vf/t4vf_hw.c1333
3 files changed, 1727 insertions, 0 deletions
diff --git a/drivers/net/cxgb4vf/t4vf_common.h b/drivers/net/cxgb4vf/t4vf_common.h
new file mode 100644
index 00000000000..5c7bde7f9ba
--- /dev/null
+++ b/drivers/net/cxgb4vf/t4vf_common.h
@@ -0,0 +1,273 @@
1/*
2 * This file is part of the Chelsio T4 PCI-E SR-IOV Virtual Function Ethernet
3 * driver for Linux.
4 *
5 * Copyright (c) 2009-2010 Chelsio Communications, Inc. All rights reserved.
6 *
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
12 *
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
16 *
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer.
20 *
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * SOFTWARE.
34 */
35
36#ifndef __T4VF_COMMON_H__
37#define __T4VF_COMMON_H__
38
39#include "../cxgb4/t4fw_api.h"
40
41/*
42 * The "len16" field of a Firmware Command Structure ...
43 */
44#define FW_LEN16(fw_struct) FW_CMD_LEN16(sizeof(fw_struct) / 16)
45
46/*
47 * Per-VF statistics.
48 */
49struct t4vf_port_stats {
50 /*
51 * TX statistics.
52 */
53 u64 tx_bcast_bytes; /* broadcast */
54 u64 tx_bcast_frames;
55 u64 tx_mcast_bytes; /* multicast */
56 u64 tx_mcast_frames;
57 u64 tx_ucast_bytes; /* unicast */
58 u64 tx_ucast_frames;
59 u64 tx_drop_frames; /* TX dropped frames */
60 u64 tx_offload_bytes; /* offload */
61 u64 tx_offload_frames;
62
63 /*
64 * RX statistics.
65 */
66 u64 rx_bcast_bytes; /* broadcast */
67 u64 rx_bcast_frames;
68 u64 rx_mcast_bytes; /* multicast */
69 u64 rx_mcast_frames;
70 u64 rx_ucast_bytes;
71 u64 rx_ucast_frames; /* unicast */
72
73 u64 rx_err_frames; /* RX error frames */
74};
75
76/*
77 * Per-"port" (Virtual Interface) link configuration ...
78 */
79struct link_config {
80 unsigned int supported; /* link capabilities */
81 unsigned int advertising; /* advertised capabilities */
82 unsigned short requested_speed; /* speed user has requested */
83 unsigned short speed; /* actual link speed */
84 unsigned char requested_fc; /* flow control user has requested */
85 unsigned char fc; /* actual link flow control */
86 unsigned char autoneg; /* autonegotiating? */
87 unsigned char link_ok; /* link up? */
88};
89
90enum {
91 PAUSE_RX = 1 << 0,
92 PAUSE_TX = 1 << 1,
93 PAUSE_AUTONEG = 1 << 2
94};
95
96/*
97 * General device parameters ...
98 */
99struct dev_params {
100 u32 fwrev; /* firmware version */
101 u32 tprev; /* TP Microcode Version */
102};
103
104/*
105 * Scatter Gather Engine parameters. These are almost all determined by the
106 * Physical Function Driver. We just need to grab them to see within which
107 * environment we're playing ...
108 */
109struct sge_params {
110 u32 sge_control; /* padding, boundaries, lengths, etc. */
111 u32 sge_host_page_size; /* RDMA page sizes */
112 u32 sge_queues_per_page; /* RDMA queues/page */
113 u32 sge_user_mode_limits; /* limits for BAR2 user mode accesses */
114 u32 sge_fl_buffer_size[16]; /* free list buffer sizes */
115 u32 sge_ingress_rx_threshold; /* RX counter interrupt threshold[4] */
116 u32 sge_timer_value_0_and_1; /* interrupt coalescing timer values */
117 u32 sge_timer_value_2_and_3;
118 u32 sge_timer_value_4_and_5;
119};
120
121/*
122 * Vital Product Data parameters.
123 */
124struct vpd_params {
125 u32 cclk; /* Core Clock (KHz) */
126};
127
128/*
129 * Global Receive Side Scaling (RSS) parameters in host-native format.
130 */
131struct rss_params {
132 unsigned int mode; /* RSS mode */
133 union {
134 struct {
135 int synmapen:1; /* SYN Map Enable */
136 int syn4tupenipv6:1; /* enable hashing 4-tuple IPv6 SYNs */
137 int syn2tupenipv6:1; /* enable hashing 2-tuple IPv6 SYNs */
138 int syn4tupenipv4:1; /* enable hashing 4-tuple IPv4 SYNs */
139 int syn2tupenipv4:1; /* enable hashing 2-tuple IPv4 SYNs */
140 int ofdmapen:1; /* Offload Map Enable */
141 int tnlmapen:1; /* Tunnel Map Enable */
142 int tnlalllookup:1; /* Tunnel All Lookup */
143 int hashtoeplitz:1; /* use Toeplitz hash */
144 } basicvirtual;
145 } u;
146};
147
148/*
149 * Virtual Interface RSS Configuration in host-native format.
150 */
151union rss_vi_config {
152 struct {
153 u16 defaultq; /* Ingress Queue ID for !tnlalllookup */
154 int ip6fourtupen:1; /* hash 4-tuple IPv6 ingress packets */
155 int ip6twotupen:1; /* hash 2-tuple IPv6 ingress packets */
156 int ip4fourtupen:1; /* hash 4-tuple IPv4 ingress packets */
157 int ip4twotupen:1; /* hash 2-tuple IPv4 ingress packets */
158 int udpen; /* hash 4-tuple UDP ingress packets */
159 } basicvirtual;
160};
161
162/*
163 * Maximum resources provisioned for a PCI VF.
164 */
165struct vf_resources {
166 unsigned int nvi; /* N virtual interfaces */
167 unsigned int neq; /* N egress Qs */
168 unsigned int nethctrl; /* N egress ETH or CTRL Qs */
169 unsigned int niqflint; /* N ingress Qs/w free list(s) & intr */
170 unsigned int niq; /* N ingress Qs */
171 unsigned int tc; /* PCI-E traffic class */
172 unsigned int pmask; /* port access rights mask */
173 unsigned int nexactf; /* N exact MPS filters */
174 unsigned int r_caps; /* read capabilities */
175 unsigned int wx_caps; /* write/execute capabilities */
176};
177
178/*
179 * Per-"adapter" (Virtual Function) parameters.
180 */
181struct adapter_params {
182 struct dev_params dev; /* general device parameters */
183 struct sge_params sge; /* Scatter Gather Engine */
184 struct vpd_params vpd; /* Vital Product Data */
185 struct rss_params rss; /* Receive Side Scaling */
186 struct vf_resources vfres; /* Virtual Function Resource limits */
187 u8 nports; /* # of Ethernet "ports" */
188};
189
190#include "adapter.h"
191
192#ifndef PCI_VENDOR_ID_CHELSIO
193# define PCI_VENDOR_ID_CHELSIO 0x1425
194#endif
195
196#define for_each_port(adapter, iter) \
197 for (iter = 0; iter < (adapter)->params.nports; iter++)
198
199static inline bool is_10g_port(const struct link_config *lc)
200{
201 return (lc->supported & SUPPORTED_10000baseT_Full) != 0;
202}
203
204static inline unsigned int core_ticks_per_usec(const struct adapter *adapter)
205{
206 return adapter->params.vpd.cclk / 1000;
207}
208
209static inline unsigned int us_to_core_ticks(const struct adapter *adapter,
210 unsigned int us)
211{
212 return (us * adapter->params.vpd.cclk) / 1000;
213}
214
215static inline unsigned int core_ticks_to_us(const struct adapter *adapter,
216 unsigned int ticks)
217{
218 return (ticks * 1000) / adapter->params.vpd.cclk;
219}
220
221int t4vf_wr_mbox_core(struct adapter *, const void *, int, void *, bool);
222
223static inline int t4vf_wr_mbox(struct adapter *adapter, const void *cmd,
224 int size, void *rpl)
225{
226 return t4vf_wr_mbox_core(adapter, cmd, size, rpl, true);
227}
228
229static inline int t4vf_wr_mbox_ns(struct adapter *adapter, const void *cmd,
230 int size, void *rpl)
231{
232 return t4vf_wr_mbox_core(adapter, cmd, size, rpl, false);
233}
234
235int __devinit t4vf_wait_dev_ready(struct adapter *);
236int __devinit t4vf_port_init(struct adapter *, int);
237
238int t4vf_query_params(struct adapter *, unsigned int, const u32 *, u32 *);
239int t4vf_set_params(struct adapter *, unsigned int, const u32 *, const u32 *);
240
241int t4vf_get_sge_params(struct adapter *);
242int t4vf_get_vpd_params(struct adapter *);
243int t4vf_get_dev_params(struct adapter *);
244int t4vf_get_rss_glb_config(struct adapter *);
245int t4vf_get_vfres(struct adapter *);
246
247int t4vf_read_rss_vi_config(struct adapter *, unsigned int,
248 union rss_vi_config *);
249int t4vf_write_rss_vi_config(struct adapter *, unsigned int,
250 union rss_vi_config *);
251int t4vf_config_rss_range(struct adapter *, unsigned int, int, int,
252 const u16 *, int);
253
254int t4vf_alloc_vi(struct adapter *, int);
255int t4vf_free_vi(struct adapter *, int);
256int t4vf_enable_vi(struct adapter *, unsigned int, bool, bool);
257int t4vf_identify_port(struct adapter *, unsigned int, unsigned int);
258
259int t4vf_set_rxmode(struct adapter *, unsigned int, int, int, int, int, int,
260 bool);
261int t4vf_alloc_mac_filt(struct adapter *, unsigned int, bool, unsigned int,
262 const u8 **, u16 *, u64 *, bool);
263int t4vf_change_mac(struct adapter *, unsigned int, int, const u8 *, bool);
264int t4vf_set_addr_hash(struct adapter *, unsigned int, bool, u64, bool);
265int t4vf_get_port_stats(struct adapter *, int, struct t4vf_port_stats *);
266
267int t4vf_iq_free(struct adapter *, unsigned int, unsigned int, unsigned int,
268 unsigned int);
269int t4vf_eth_eq_free(struct adapter *, unsigned int);
270
271int t4vf_handle_fw_rpl(struct adapter *, const __be64 *);
272
273#endif /* __T4VF_COMMON_H__ */
diff --git a/drivers/net/cxgb4vf/t4vf_defs.h b/drivers/net/cxgb4vf/t4vf_defs.h
new file mode 100644
index 00000000000..c7b127d9376
--- /dev/null
+++ b/drivers/net/cxgb4vf/t4vf_defs.h
@@ -0,0 +1,121 @@
1/*
2 * This file is part of the Chelsio T4 PCI-E SR-IOV Virtual Function Ethernet
3 * driver for Linux.
4 *
5 * Copyright (c) 2009-2010 Chelsio Communications, Inc. All rights reserved.
6 *
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
12 *
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
16 *
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer.
20 *
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * SOFTWARE.
34 */
35
36#ifndef __T4VF_DEFS_H__
37#define __T4VF_DEFS_H__
38
39#include "../cxgb4/t4_regs.h"
40
41/*
42 * The VF Register Map.
43 *
44 * The Scatter Gather Engine (SGE), Multiport Support module (MPS), PIO Local
45 * bus module (PL) and CPU Interface Module (CIM) components are mapped via
46 * the Slice to Module Map Table (see below) in the Physical Function Register
47 * Map. The Mail Box Data (MBDATA) range is mapped via the PCI-E Mailbox Base
48 * and Offset registers in the PF Register Map. The MBDATA base address is
49 * quite constrained as it determines the Mailbox Data addresses for both PFs
50 * and VFs, and therefore must fit in both the VF and PF Register Maps without
51 * overlapping other registers.
52 */
53#define T4VF_SGE_BASE_ADDR 0x0000
54#define T4VF_MPS_BASE_ADDR 0x0100
55#define T4VF_PL_BASE_ADDR 0x0200
56#define T4VF_MBDATA_BASE_ADDR 0x0240
57#define T4VF_CIM_BASE_ADDR 0x0300
58
59#define T4VF_REGMAP_START 0x0000
60#define T4VF_REGMAP_SIZE 0x0400
61
62/*
63 * There's no hardware limitation which requires that the addresses of the
64 * Mailbox Data in the fixed CIM PF map and the programmable VF map must
65 * match. However, it's a useful convention ...
66 */
67#if T4VF_MBDATA_BASE_ADDR != CIM_PF_MAILBOX_DATA
68#error T4VF_MBDATA_BASE_ADDR must match CIM_PF_MAILBOX_DATA!
69#endif
70
71/*
72 * Virtual Function "Slice to Module Map Table" definitions.
73 *
74 * This table allows us to map subsets of the various module register sets
75 * into the T4VF Register Map. Each table entry identifies the index of the
76 * module whose registers are being mapped, the offset within the module's
77 * register set that the mapping should start at, the limit of the mapping,
78 * and the offset within the T4VF Register Map to which the module's registers
79 * are being mapped. All addresses and qualtities are in terms of 32-bit
80 * words. The "limit" value is also in terms of 32-bit words and is equal to
81 * the last address mapped in the T4VF Register Map 1 (i.e. it's a "<="
82 * relation rather than a "<").
83 */
84#define T4VF_MOD_MAP(module, index, first, last) \
85 T4VF_MOD_MAP_##module##_INDEX = (index), \
86 T4VF_MOD_MAP_##module##_FIRST = (first), \
87 T4VF_MOD_MAP_##module##_LAST = (last), \
88 T4VF_MOD_MAP_##module##_OFFSET = ((first)/4), \
89 T4VF_MOD_MAP_##module##_BASE = \
90 (T4VF_##module##_BASE_ADDR/4 + (first)/4), \
91 T4VF_MOD_MAP_##module##_LIMIT = \
92 (T4VF_##module##_BASE_ADDR/4 + (last)/4),
93
94#define SGE_VF_KDOORBELL 0x0
95#define SGE_VF_GTS 0x4
96#define MPS_VF_CTL 0x0
97#define MPS_VF_STAT_RX_VF_ERR_FRAMES_H 0xfc
98#define PL_VF_WHOAMI 0x0
99#define CIM_VF_EXT_MAILBOX_CTRL 0x0
100#define CIM_VF_EXT_MAILBOX_STATUS 0x4
101
102enum {
103 T4VF_MOD_MAP(SGE, 2, SGE_VF_KDOORBELL, SGE_VF_GTS)
104 T4VF_MOD_MAP(MPS, 0, MPS_VF_CTL, MPS_VF_STAT_RX_VF_ERR_FRAMES_H)
105 T4VF_MOD_MAP(PL, 3, PL_VF_WHOAMI, PL_VF_WHOAMI)
106 T4VF_MOD_MAP(CIM, 1, CIM_VF_EXT_MAILBOX_CTRL, CIM_VF_EXT_MAILBOX_STATUS)
107};
108
109/*
110 * There isn't a Slice to Module Map Table entry for the Mailbox Data
111 * registers, but it's convenient to use similar names as above. There are 8
112 * little-endian 64-bit Mailbox Data registers. Note that the "instances"
113 * value below is in terms of 32-bit words which matches the "word" addressing
114 * space we use above for the Slice to Module Map Space.
115 */
116#define NUM_CIM_VF_MAILBOX_DATA_INSTANCES 16
117
118#define T4VF_MBDATA_FIRST 0
119#define T4VF_MBDATA_LAST ((NUM_CIM_VF_MAILBOX_DATA_INSTANCES-1)*4)
120
121#endif /* __T4T4VF_DEFS_H__ */
diff --git a/drivers/net/cxgb4vf/t4vf_hw.c b/drivers/net/cxgb4vf/t4vf_hw.c
new file mode 100644
index 00000000000..1ef252864b9
--- /dev/null
+++ b/drivers/net/cxgb4vf/t4vf_hw.c
@@ -0,0 +1,1333 @@
1/*
2 * This file is part of the Chelsio T4 PCI-E SR-IOV Virtual Function Ethernet
3 * driver for Linux.
4 *
5 * Copyright (c) 2009-2010 Chelsio Communications, Inc. All rights reserved.
6 *
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
12 *
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
16 *
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer.
20 *
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * SOFTWARE.
34 */
35
36#include <linux/version.h>
37#include <linux/pci.h>
38
39#include "t4vf_common.h"
40#include "t4vf_defs.h"
41
42#include "../cxgb4/t4_regs.h"
43#include "../cxgb4/t4fw_api.h"
44
45/*
46 * Wait for the device to become ready (signified by our "who am I" register
47 * returning a value other than all 1's). Return an error if it doesn't
48 * become ready ...
49 */
50int __devinit t4vf_wait_dev_ready(struct adapter *adapter)
51{
52 const u32 whoami = T4VF_PL_BASE_ADDR + PL_VF_WHOAMI;
53 const u32 notready1 = 0xffffffff;
54 const u32 notready2 = 0xeeeeeeee;
55 u32 val;
56
57 val = t4_read_reg(adapter, whoami);
58 if (val != notready1 && val != notready2)
59 return 0;
60 msleep(500);
61 val = t4_read_reg(adapter, whoami);
62 if (val != notready1 && val != notready2)
63 return 0;
64 else
65 return -EIO;
66}
67
68/*
69 * Get the reply to a mailbox command and store it in @rpl in big-endian order
70 * (since the firmware data structures are specified in a big-endian layout).
71 */
72static void get_mbox_rpl(struct adapter *adapter, __be64 *rpl, int size,
73 u32 mbox_data)
74{
75 for ( ; size; size -= 8, mbox_data += 8)
76 *rpl++ = cpu_to_be64(t4_read_reg64(adapter, mbox_data));
77}
78
79/*
80 * Dump contents of mailbox with a leading tag.
81 */
82static void dump_mbox(struct adapter *adapter, const char *tag, u32 mbox_data)
83{
84 dev_err(adapter->pdev_dev,
85 "mbox %s: %llx %llx %llx %llx %llx %llx %llx %llx\n", tag,
86 (unsigned long long)t4_read_reg64(adapter, mbox_data + 0),
87 (unsigned long long)t4_read_reg64(adapter, mbox_data + 8),
88 (unsigned long long)t4_read_reg64(adapter, mbox_data + 16),
89 (unsigned long long)t4_read_reg64(adapter, mbox_data + 24),
90 (unsigned long long)t4_read_reg64(adapter, mbox_data + 32),
91 (unsigned long long)t4_read_reg64(adapter, mbox_data + 40),
92 (unsigned long long)t4_read_reg64(adapter, mbox_data + 48),
93 (unsigned long long)t4_read_reg64(adapter, mbox_data + 56));
94}
95
96/**
97 * t4vf_wr_mbox_core - send a command to FW through the mailbox
98 * @adapter: the adapter
99 * @cmd: the command to write
100 * @size: command length in bytes
101 * @rpl: where to optionally store the reply
102 * @sleep_ok: if true we may sleep while awaiting command completion
103 *
104 * Sends the given command to FW through the mailbox and waits for the
105 * FW to execute the command. If @rpl is not %NULL it is used to store
106 * the FW's reply to the command. The command and its optional reply
107 * are of the same length. FW can take up to 500 ms to respond.
108 * @sleep_ok determines whether we may sleep while awaiting the response.
109 * If sleeping is allowed we use progressive backoff otherwise we spin.
110 *
111 * The return value is 0 on success or a negative errno on failure. A
112 * failure can happen either because we are not able to execute the
113 * command or FW executes it but signals an error. In the latter case
114 * the return value is the error code indicated by FW (negated).
115 */
116int t4vf_wr_mbox_core(struct adapter *adapter, const void *cmd, int size,
117 void *rpl, bool sleep_ok)
118{
119 static int delay[] = {
120 1, 1, 3, 5, 10, 10, 20, 50, 100
121 };
122
123 u32 v;
124 int i, ms, delay_idx;
125 const __be64 *p;
126 u32 mbox_data = T4VF_MBDATA_BASE_ADDR;
127 u32 mbox_ctl = T4VF_CIM_BASE_ADDR + CIM_VF_EXT_MAILBOX_CTRL;
128
129 /*
130 * Commands must be multiples of 16 bytes in length and may not be
131 * larger than the size of the Mailbox Data register array.
132 */
133 if ((size % 16) != 0 ||
134 size > NUM_CIM_VF_MAILBOX_DATA_INSTANCES * 4)
135 return -EINVAL;
136
137 /*
138 * Loop trying to get ownership of the mailbox. Return an error
139 * if we can't gain ownership.
140 */
141 v = MBOWNER_GET(t4_read_reg(adapter, mbox_ctl));
142 for (i = 0; v == MBOX_OWNER_NONE && i < 3; i++)
143 v = MBOWNER_GET(t4_read_reg(adapter, mbox_ctl));
144 if (v != MBOX_OWNER_DRV)
145 return v == MBOX_OWNER_FW ? -EBUSY : -ETIMEDOUT;
146
147 /*
148 * Write the command array into the Mailbox Data register array and
149 * transfer ownership of the mailbox to the firmware.
150 */
151 for (i = 0, p = cmd; i < size; i += 8)
152 t4_write_reg64(adapter, mbox_data + i, be64_to_cpu(*p++));
153 t4_write_reg(adapter, mbox_ctl,
154 MBMSGVALID | MBOWNER(MBOX_OWNER_FW));
155 t4_read_reg(adapter, mbox_ctl); /* flush write */
156
157 /*
158 * Spin waiting for firmware to acknowledge processing our command.
159 */
160 delay_idx = 0;
161 ms = delay[0];
162
163 for (i = 0; i < 500; i += ms) {
164 if (sleep_ok) {
165 ms = delay[delay_idx];
166 if (delay_idx < ARRAY_SIZE(delay))
167 delay_idx++;
168 msleep(ms);
169 } else
170 mdelay(ms);
171
172 /*
173 * If we're the owner, see if this is the reply we wanted.
174 */
175 v = t4_read_reg(adapter, mbox_ctl);
176 if (MBOWNER_GET(v) == MBOX_OWNER_DRV) {
177 /*
178 * If the Message Valid bit isn't on, revoke ownership
179 * of the mailbox and continue waiting for our reply.
180 */
181 if ((v & MBMSGVALID) == 0) {
182 t4_write_reg(adapter, mbox_ctl,
183 MBOWNER(MBOX_OWNER_NONE));
184 continue;
185 }
186
187 /*
188 * We now have our reply. Extract the command return
189 * value, copy the reply back to our caller's buffer
190 * (if specified) and revoke ownership of the mailbox.
191 * We return the (negated) firmware command return
192 * code (this depends on FW_SUCCESS == 0).
193 */
194
195 /* return value in low-order little-endian word */
196 v = t4_read_reg(adapter, mbox_data);
197 if (FW_CMD_RETVAL_GET(v))
198 dump_mbox(adapter, "FW Error", mbox_data);
199
200 if (rpl) {
201 /* request bit in high-order BE word */
202 WARN_ON((be32_to_cpu(*(const u32 *)cmd)
203 & FW_CMD_REQUEST) == 0);
204 get_mbox_rpl(adapter, rpl, size, mbox_data);
205 WARN_ON((be32_to_cpu(*(u32 *)rpl)
206 & FW_CMD_REQUEST) != 0);
207 }
208 t4_write_reg(adapter, mbox_ctl,
209 MBOWNER(MBOX_OWNER_NONE));
210 return -FW_CMD_RETVAL_GET(v);
211 }
212 }
213
214 /*
215 * We timed out. Return the error ...
216 */
217 dump_mbox(adapter, "FW Timeout", mbox_data);
218 return -ETIMEDOUT;
219}
220
221/**
222 * hash_mac_addr - return the hash value of a MAC address
223 * @addr: the 48-bit Ethernet MAC address
224 *
225 * Hashes a MAC address according to the hash function used by hardware
226 * inexact (hash) address matching.
227 */
228static int hash_mac_addr(const u8 *addr)
229{
230 u32 a = ((u32)addr[0] << 16) | ((u32)addr[1] << 8) | addr[2];
231 u32 b = ((u32)addr[3] << 16) | ((u32)addr[4] << 8) | addr[5];
232 a ^= b;
233 a ^= (a >> 12);
234 a ^= (a >> 6);
235 return a & 0x3f;
236}
237
238/**
239 * init_link_config - initialize a link's SW state
240 * @lc: structure holding the link state
241 * @caps: link capabilities
242 *
243 * Initializes the SW state maintained for each link, including the link's
244 * capabilities and default speed/flow-control/autonegotiation settings.
245 */
246static void __devinit init_link_config(struct link_config *lc,
247 unsigned int caps)
248{
249 lc->supported = caps;
250 lc->requested_speed = 0;
251 lc->speed = 0;
252 lc->requested_fc = lc->fc = PAUSE_RX | PAUSE_TX;
253 if (lc->supported & SUPPORTED_Autoneg) {
254 lc->advertising = lc->supported;
255 lc->autoneg = AUTONEG_ENABLE;
256 lc->requested_fc |= PAUSE_AUTONEG;
257 } else {
258 lc->advertising = 0;
259 lc->autoneg = AUTONEG_DISABLE;
260 }
261}
262
263/**
264 * t4vf_port_init - initialize port hardware/software state
265 * @adapter: the adapter
266 * @pidx: the adapter port index
267 */
268int __devinit t4vf_port_init(struct adapter *adapter, int pidx)
269{
270 struct port_info *pi = adap2pinfo(adapter, pidx);
271 struct fw_vi_cmd vi_cmd, vi_rpl;
272 struct fw_port_cmd port_cmd, port_rpl;
273 int v;
274 u32 word;
275
276 /*
277 * Execute a VI Read command to get our Virtual Interface information
278 * like MAC address, etc.
279 */
280 memset(&vi_cmd, 0, sizeof(vi_cmd));
281 vi_cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_VI_CMD) |
282 FW_CMD_REQUEST |
283 FW_CMD_READ);
284 vi_cmd.alloc_to_len16 = cpu_to_be32(FW_LEN16(vi_cmd));
285 vi_cmd.type_viid = cpu_to_be16(FW_VI_CMD_VIID(pi->viid));
286 v = t4vf_wr_mbox(adapter, &vi_cmd, sizeof(vi_cmd), &vi_rpl);
287 if (v)
288 return v;
289
290 BUG_ON(pi->port_id != FW_VI_CMD_PORTID_GET(vi_rpl.portid_pkd));
291 pi->rss_size = FW_VI_CMD_RSSSIZE_GET(be16_to_cpu(vi_rpl.rsssize_pkd));
292 t4_os_set_hw_addr(adapter, pidx, vi_rpl.mac);
293
294 /*
295 * If we don't have read access to our port information, we're done
296 * now. Otherwise, execute a PORT Read command to get it ...
297 */
298 if (!(adapter->params.vfres.r_caps & FW_CMD_CAP_PORT))
299 return 0;
300
301 memset(&port_cmd, 0, sizeof(port_cmd));
302 port_cmd.op_to_portid = cpu_to_be32(FW_CMD_OP(FW_PORT_CMD) |
303 FW_CMD_REQUEST |
304 FW_CMD_READ |
305 FW_PORT_CMD_PORTID(pi->port_id));
306 port_cmd.action_to_len16 =
307 cpu_to_be32(FW_PORT_CMD_ACTION(FW_PORT_ACTION_GET_PORT_INFO) |
308 FW_LEN16(port_cmd));
309 v = t4vf_wr_mbox(adapter, &port_cmd, sizeof(port_cmd), &port_rpl);
310 if (v)
311 return v;
312
313 v = 0;
314 word = be16_to_cpu(port_rpl.u.info.pcap);
315 if (word & FW_PORT_CAP_SPEED_100M)
316 v |= SUPPORTED_100baseT_Full;
317 if (word & FW_PORT_CAP_SPEED_1G)
318 v |= SUPPORTED_1000baseT_Full;
319 if (word & FW_PORT_CAP_SPEED_10G)
320 v |= SUPPORTED_10000baseT_Full;
321 if (word & FW_PORT_CAP_ANEG)
322 v |= SUPPORTED_Autoneg;
323 init_link_config(&pi->link_cfg, v);
324
325 return 0;
326}
327
328/**
329 * t4vf_query_params - query FW or device parameters
330 * @adapter: the adapter
331 * @nparams: the number of parameters
332 * @params: the parameter names
333 * @vals: the parameter values
334 *
335 * Reads the values of firmware or device parameters. Up to 7 parameters
336 * can be queried at once.
337 */
338int t4vf_query_params(struct adapter *adapter, unsigned int nparams,
339 const u32 *params, u32 *vals)
340{
341 int i, ret;
342 struct fw_params_cmd cmd, rpl;
343 struct fw_params_param *p;
344 size_t len16;
345
346 if (nparams > 7)
347 return -EINVAL;
348
349 memset(&cmd, 0, sizeof(cmd));
350 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_PARAMS_CMD) |
351 FW_CMD_REQUEST |
352 FW_CMD_READ);
353 len16 = DIV_ROUND_UP(offsetof(struct fw_params_cmd,
354 param[nparams].mnem), 16);
355 cmd.retval_len16 = cpu_to_be32(FW_CMD_LEN16(len16));
356 for (i = 0, p = &cmd.param[0]; i < nparams; i++, p++)
357 p->mnem = htonl(*params++);
358
359 ret = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &rpl);
360 if (ret == 0)
361 for (i = 0, p = &rpl.param[0]; i < nparams; i++, p++)
362 *vals++ = be32_to_cpu(p->val);
363 return ret;
364}
365
366/**
367 * t4vf_set_params - sets FW or device parameters
368 * @adapter: the adapter
369 * @nparams: the number of parameters
370 * @params: the parameter names
371 * @vals: the parameter values
372 *
373 * Sets the values of firmware or device parameters. Up to 7 parameters
374 * can be specified at once.
375 */
376int t4vf_set_params(struct adapter *adapter, unsigned int nparams,
377 const u32 *params, const u32 *vals)
378{
379 int i;
380 struct fw_params_cmd cmd;
381 struct fw_params_param *p;
382 size_t len16;
383
384 if (nparams > 7)
385 return -EINVAL;
386
387 memset(&cmd, 0, sizeof(cmd));
388 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_PARAMS_CMD) |
389 FW_CMD_REQUEST |
390 FW_CMD_WRITE);
391 len16 = DIV_ROUND_UP(offsetof(struct fw_params_cmd,
392 param[nparams]), 16);
393 cmd.retval_len16 = cpu_to_be32(FW_CMD_LEN16(len16));
394 for (i = 0, p = &cmd.param[0]; i < nparams; i++, p++) {
395 p->mnem = cpu_to_be32(*params++);
396 p->val = cpu_to_be32(*vals++);
397 }
398
399 return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);
400}
401
402/**
403 * t4vf_get_sge_params - retrieve adapter Scatter gather Engine parameters
404 * @adapter: the adapter
405 *
406 * Retrieves various core SGE parameters in the form of hardware SGE
407 * register values. The caller is responsible for decoding these as
408 * needed. The SGE parameters are stored in @adapter->params.sge.
409 */
410int t4vf_get_sge_params(struct adapter *adapter)
411{
412 struct sge_params *sge_params = &adapter->params.sge;
413 u32 params[7], vals[7];
414 int v;
415
416 params[0] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
417 FW_PARAMS_PARAM_XYZ(SGE_CONTROL));
418 params[1] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
419 FW_PARAMS_PARAM_XYZ(SGE_HOST_PAGE_SIZE));
420 params[2] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
421 FW_PARAMS_PARAM_XYZ(SGE_FL_BUFFER_SIZE0));
422 params[3] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
423 FW_PARAMS_PARAM_XYZ(SGE_FL_BUFFER_SIZE1));
424 params[4] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
425 FW_PARAMS_PARAM_XYZ(SGE_TIMER_VALUE_0_AND_1));
426 params[5] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
427 FW_PARAMS_PARAM_XYZ(SGE_TIMER_VALUE_2_AND_3));
428 params[6] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
429 FW_PARAMS_PARAM_XYZ(SGE_TIMER_VALUE_4_AND_5));
430 v = t4vf_query_params(adapter, 7, params, vals);
431 if (v)
432 return v;
433 sge_params->sge_control = vals[0];
434 sge_params->sge_host_page_size = vals[1];
435 sge_params->sge_fl_buffer_size[0] = vals[2];
436 sge_params->sge_fl_buffer_size[1] = vals[3];
437 sge_params->sge_timer_value_0_and_1 = vals[4];
438 sge_params->sge_timer_value_2_and_3 = vals[5];
439 sge_params->sge_timer_value_4_and_5 = vals[6];
440
441 params[0] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_REG) |
442 FW_PARAMS_PARAM_XYZ(SGE_INGRESS_RX_THRESHOLD));
443 v = t4vf_query_params(adapter, 1, params, vals);
444 if (v)
445 return v;
446 sge_params->sge_ingress_rx_threshold = vals[0];
447
448 return 0;
449}
450
451/**
452 * t4vf_get_vpd_params - retrieve device VPD paremeters
453 * @adapter: the adapter
454 *
455 * Retrives various device Vital Product Data parameters. The parameters
456 * are stored in @adapter->params.vpd.
457 */
458int t4vf_get_vpd_params(struct adapter *adapter)
459{
460 struct vpd_params *vpd_params = &adapter->params.vpd;
461 u32 params[7], vals[7];
462 int v;
463
464 params[0] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
465 FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_CCLK));
466 v = t4vf_query_params(adapter, 1, params, vals);
467 if (v)
468 return v;
469 vpd_params->cclk = vals[0];
470
471 return 0;
472}
473
474/**
475 * t4vf_get_dev_params - retrieve device paremeters
476 * @adapter: the adapter
477 *
478 * Retrives various device parameters. The parameters are stored in
479 * @adapter->params.dev.
480 */
481int t4vf_get_dev_params(struct adapter *adapter)
482{
483 struct dev_params *dev_params = &adapter->params.dev;
484 u32 params[7], vals[7];
485 int v;
486
487 params[0] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
488 FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_FWREV));
489 params[1] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
490 FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_TPREV));
491 v = t4vf_query_params(adapter, 2, params, vals);
492 if (v)
493 return v;
494 dev_params->fwrev = vals[0];
495 dev_params->tprev = vals[1];
496
497 return 0;
498}
499
500/**
501 * t4vf_get_rss_glb_config - retrieve adapter RSS Global Configuration
502 * @adapter: the adapter
503 *
504 * Retrieves global RSS mode and parameters with which we have to live
505 * and stores them in the @adapter's RSS parameters.
506 */
507int t4vf_get_rss_glb_config(struct adapter *adapter)
508{
509 struct rss_params *rss = &adapter->params.rss;
510 struct fw_rss_glb_config_cmd cmd, rpl;
511 int v;
512
513 /*
514 * Execute an RSS Global Configuration read command to retrieve
515 * our RSS configuration.
516 */
517 memset(&cmd, 0, sizeof(cmd));
518 cmd.op_to_write = cpu_to_be32(FW_CMD_OP(FW_RSS_GLB_CONFIG_CMD) |
519 FW_CMD_REQUEST |
520 FW_CMD_READ);
521 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
522 v = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &rpl);
523 if (v)
524 return v;
525
526 /*
527 * Transate the big-endian RSS Global Configuration into our
528 * cpu-endian format based on the RSS mode. We also do first level
529 * filtering at this point to weed out modes which don't support
530 * VF Drivers ...
531 */
532 rss->mode = FW_RSS_GLB_CONFIG_CMD_MODE_GET(
533 be32_to_cpu(rpl.u.manual.mode_pkd));
534 switch (rss->mode) {
535 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL: {
536 u32 word = be32_to_cpu(
537 rpl.u.basicvirtual.synmapen_to_hashtoeplitz);
538
539 rss->u.basicvirtual.synmapen =
540 ((word & FW_RSS_GLB_CONFIG_CMD_SYNMAPEN) != 0);
541 rss->u.basicvirtual.syn4tupenipv6 =
542 ((word & FW_RSS_GLB_CONFIG_CMD_SYN4TUPENIPV6) != 0);
543 rss->u.basicvirtual.syn2tupenipv6 =
544 ((word & FW_RSS_GLB_CONFIG_CMD_SYN2TUPENIPV6) != 0);
545 rss->u.basicvirtual.syn4tupenipv4 =
546 ((word & FW_RSS_GLB_CONFIG_CMD_SYN4TUPENIPV4) != 0);
547 rss->u.basicvirtual.syn2tupenipv4 =
548 ((word & FW_RSS_GLB_CONFIG_CMD_SYN2TUPENIPV4) != 0);
549
550 rss->u.basicvirtual.ofdmapen =
551 ((word & FW_RSS_GLB_CONFIG_CMD_OFDMAPEN) != 0);
552
553 rss->u.basicvirtual.tnlmapen =
554 ((word & FW_RSS_GLB_CONFIG_CMD_TNLMAPEN) != 0);
555 rss->u.basicvirtual.tnlalllookup =
556 ((word & FW_RSS_GLB_CONFIG_CMD_TNLALLLKP) != 0);
557
558 rss->u.basicvirtual.hashtoeplitz =
559 ((word & FW_RSS_GLB_CONFIG_CMD_HASHTOEPLITZ) != 0);
560
561 /* we need at least Tunnel Map Enable to be set */
562 if (!rss->u.basicvirtual.tnlmapen)
563 return -EINVAL;
564 break;
565 }
566
567 default:
568 /* all unknown/unsupported RSS modes result in an error */
569 return -EINVAL;
570 }
571
572 return 0;
573}
574
575/**
576 * t4vf_get_vfres - retrieve VF resource limits
577 * @adapter: the adapter
578 *
579 * Retrieves configured resource limits and capabilities for a virtual
580 * function. The results are stored in @adapter->vfres.
581 */
582int t4vf_get_vfres(struct adapter *adapter)
583{
584 struct vf_resources *vfres = &adapter->params.vfres;
585 struct fw_pfvf_cmd cmd, rpl;
586 int v;
587 u32 word;
588
589 /*
590 * Execute PFVF Read command to get VF resource limits; bail out early
591 * with error on command failure.
592 */
593 memset(&cmd, 0, sizeof(cmd));
594 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_PFVF_CMD) |
595 FW_CMD_REQUEST |
596 FW_CMD_READ);
597 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
598 v = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &rpl);
599 if (v)
600 return v;
601
602 /*
603 * Extract VF resource limits and return success.
604 */
605 word = be32_to_cpu(rpl.niqflint_niq);
606 vfres->niqflint = FW_PFVF_CMD_NIQFLINT_GET(word);
607 vfres->niq = FW_PFVF_CMD_NIQ_GET(word);
608
609 word = be32_to_cpu(rpl.type_to_neq);
610 vfres->neq = FW_PFVF_CMD_NEQ_GET(word);
611 vfres->pmask = FW_PFVF_CMD_PMASK_GET(word);
612
613 word = be32_to_cpu(rpl.tc_to_nexactf);
614 vfres->tc = FW_PFVF_CMD_TC_GET(word);
615 vfres->nvi = FW_PFVF_CMD_NVI_GET(word);
616 vfres->nexactf = FW_PFVF_CMD_NEXACTF_GET(word);
617
618 word = be32_to_cpu(rpl.r_caps_to_nethctrl);
619 vfres->r_caps = FW_PFVF_CMD_R_CAPS_GET(word);
620 vfres->wx_caps = FW_PFVF_CMD_WX_CAPS_GET(word);
621 vfres->nethctrl = FW_PFVF_CMD_NETHCTRL_GET(word);
622
623 return 0;
624}
625
626/**
627 * t4vf_read_rss_vi_config - read a VI's RSS configuration
628 * @adapter: the adapter
629 * @viid: Virtual Interface ID
630 * @config: pointer to host-native VI RSS Configuration buffer
631 *
632 * Reads the Virtual Interface's RSS configuration information and
633 * translates it into CPU-native format.
634 */
635int t4vf_read_rss_vi_config(struct adapter *adapter, unsigned int viid,
636 union rss_vi_config *config)
637{
638 struct fw_rss_vi_config_cmd cmd, rpl;
639 int v;
640
641 memset(&cmd, 0, sizeof(cmd));
642 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_RSS_VI_CONFIG_CMD) |
643 FW_CMD_REQUEST |
644 FW_CMD_READ |
645 FW_RSS_VI_CONFIG_CMD_VIID(viid));
646 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
647 v = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &rpl);
648 if (v)
649 return v;
650
651 switch (adapter->params.rss.mode) {
652 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL: {
653 u32 word = be32_to_cpu(rpl.u.basicvirtual.defaultq_to_udpen);
654
655 config->basicvirtual.ip6fourtupen =
656 ((word & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN) != 0);
657 config->basicvirtual.ip6twotupen =
658 ((word & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN) != 0);
659 config->basicvirtual.ip4fourtupen =
660 ((word & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN) != 0);
661 config->basicvirtual.ip4twotupen =
662 ((word & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN) != 0);
663 config->basicvirtual.udpen =
664 ((word & FW_RSS_VI_CONFIG_CMD_UDPEN) != 0);
665 config->basicvirtual.defaultq =
666 FW_RSS_VI_CONFIG_CMD_DEFAULTQ_GET(word);
667 break;
668 }
669
670 default:
671 return -EINVAL;
672 }
673
674 return 0;
675}
676
677/**
678 * t4vf_write_rss_vi_config - write a VI's RSS configuration
679 * @adapter: the adapter
680 * @viid: Virtual Interface ID
681 * @config: pointer to host-native VI RSS Configuration buffer
682 *
683 * Write the Virtual Interface's RSS configuration information
684 * (translating it into firmware-native format before writing).
685 */
686int t4vf_write_rss_vi_config(struct adapter *adapter, unsigned int viid,
687 union rss_vi_config *config)
688{
689 struct fw_rss_vi_config_cmd cmd, rpl;
690
691 memset(&cmd, 0, sizeof(cmd));
692 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_RSS_VI_CONFIG_CMD) |
693 FW_CMD_REQUEST |
694 FW_CMD_WRITE |
695 FW_RSS_VI_CONFIG_CMD_VIID(viid));
696 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
697 switch (adapter->params.rss.mode) {
698 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL: {
699 u32 word = 0;
700
701 if (config->basicvirtual.ip6fourtupen)
702 word |= FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN;
703 if (config->basicvirtual.ip6twotupen)
704 word |= FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN;
705 if (config->basicvirtual.ip4fourtupen)
706 word |= FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN;
707 if (config->basicvirtual.ip4twotupen)
708 word |= FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN;
709 if (config->basicvirtual.udpen)
710 word |= FW_RSS_VI_CONFIG_CMD_UDPEN;
711 word |= FW_RSS_VI_CONFIG_CMD_DEFAULTQ(
712 config->basicvirtual.defaultq);
713 cmd.u.basicvirtual.defaultq_to_udpen = cpu_to_be32(word);
714 break;
715 }
716
717 default:
718 return -EINVAL;
719 }
720
721 return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &rpl);
722}
723
724/**
725 * t4vf_config_rss_range - configure a portion of the RSS mapping table
726 * @adapter: the adapter
727 * @viid: Virtual Interface of RSS Table Slice
728 * @start: starting entry in the table to write
729 * @n: how many table entries to write
730 * @rspq: values for the "Response Queue" (Ingress Queue) lookup table
731 * @nrspq: number of values in @rspq
732 *
733 * Programs the selected part of the VI's RSS mapping table with the
734 * provided values. If @nrspq < @n the supplied values are used repeatedly
735 * until the full table range is populated.
736 *
737 * The caller must ensure the values in @rspq are in the range 0..1023.
738 */
739int t4vf_config_rss_range(struct adapter *adapter, unsigned int viid,
740 int start, int n, const u16 *rspq, int nrspq)
741{
742 const u16 *rsp = rspq;
743 const u16 *rsp_end = rspq+nrspq;
744 struct fw_rss_ind_tbl_cmd cmd;
745
746 /*
747 * Initialize firmware command template to write the RSS table.
748 */
749 memset(&cmd, 0, sizeof(cmd));
750 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_RSS_IND_TBL_CMD) |
751 FW_CMD_REQUEST |
752 FW_CMD_WRITE |
753 FW_RSS_IND_TBL_CMD_VIID(viid));
754 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
755
756 /*
757 * Each firmware RSS command can accommodate up to 32 RSS Ingress
758 * Queue Identifiers. These Ingress Queue IDs are packed three to
759 * a 32-bit word as 10-bit values with the upper remaining 2 bits
760 * reserved.
761 */
762 while (n > 0) {
763 __be32 *qp = &cmd.iq0_to_iq2;
764 int nq = min(n, 32);
765 int ret;
766
767 /*
768 * Set up the firmware RSS command header to send the next
769 * "nq" Ingress Queue IDs to the firmware.
770 */
771 cmd.niqid = cpu_to_be16(nq);
772 cmd.startidx = cpu_to_be16(start);
773
774 /*
775 * "nq" more done for the start of the next loop.
776 */
777 start += nq;
778 n -= nq;
779
780 /*
781 * While there are still Ingress Queue IDs to stuff into the
782 * current firmware RSS command, retrieve them from the
783 * Ingress Queue ID array and insert them into the command.
784 */
785 while (nq > 0) {
786 /*
787 * Grab up to the next 3 Ingress Queue IDs (wrapping
788 * around the Ingress Queue ID array if necessary) and
789 * insert them into the firmware RSS command at the
790 * current 3-tuple position within the commad.
791 */
792 u16 qbuf[3];
793 u16 *qbp = qbuf;
794 int nqbuf = min(3, nq);
795
796 nq -= nqbuf;
797 qbuf[0] = qbuf[1] = qbuf[2] = 0;
798 while (nqbuf) {
799 nqbuf--;
800 *qbp++ = *rsp++;
801 if (rsp >= rsp_end)
802 rsp = rspq;
803 }
804 *qp++ = cpu_to_be32(FW_RSS_IND_TBL_CMD_IQ0(qbuf[0]) |
805 FW_RSS_IND_TBL_CMD_IQ1(qbuf[1]) |
806 FW_RSS_IND_TBL_CMD_IQ2(qbuf[2]));
807 }
808
809 /*
810 * Send this portion of the RRS table update to the firmware;
811 * bail out on any errors.
812 */
813 ret = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);
814 if (ret)
815 return ret;
816 }
817 return 0;
818}
819
820/**
821 * t4vf_alloc_vi - allocate a virtual interface on a port
822 * @adapter: the adapter
823 * @port_id: physical port associated with the VI
824 *
825 * Allocate a new Virtual Interface and bind it to the indicated
826 * physical port. Return the new Virtual Interface Identifier on
827 * success, or a [negative] error number on failure.
828 */
829int t4vf_alloc_vi(struct adapter *adapter, int port_id)
830{
831 struct fw_vi_cmd cmd, rpl;
832 int v;
833
834 /*
835 * Execute a VI command to allocate Virtual Interface and return its
836 * VIID.
837 */
838 memset(&cmd, 0, sizeof(cmd));
839 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_VI_CMD) |
840 FW_CMD_REQUEST |
841 FW_CMD_WRITE |
842 FW_CMD_EXEC);
843 cmd.alloc_to_len16 = cpu_to_be32(FW_LEN16(cmd) |
844 FW_VI_CMD_ALLOC);
845 cmd.portid_pkd = FW_VI_CMD_PORTID(port_id);
846 v = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &rpl);
847 if (v)
848 return v;
849
850 return FW_VI_CMD_VIID_GET(be16_to_cpu(rpl.type_viid));
851}
852
853/**
854 * t4vf_free_vi -- free a virtual interface
855 * @adapter: the adapter
856 * @viid: the virtual interface identifier
857 *
858 * Free a previously allocated Virtual Interface. Return an error on
859 * failure.
860 */
861int t4vf_free_vi(struct adapter *adapter, int viid)
862{
863 struct fw_vi_cmd cmd;
864
865 /*
866 * Execute a VI command to free the Virtual Interface.
867 */
868 memset(&cmd, 0, sizeof(cmd));
869 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_VI_CMD) |
870 FW_CMD_REQUEST |
871 FW_CMD_EXEC);
872 cmd.alloc_to_len16 = cpu_to_be32(FW_LEN16(cmd) |
873 FW_VI_CMD_FREE);
874 cmd.type_viid = cpu_to_be16(FW_VI_CMD_VIID(viid));
875 return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);
876}
877
878/**
879 * t4vf_enable_vi - enable/disable a virtual interface
880 * @adapter: the adapter
881 * @viid: the Virtual Interface ID
882 * @rx_en: 1=enable Rx, 0=disable Rx
883 * @tx_en: 1=enable Tx, 0=disable Tx
884 *
885 * Enables/disables a virtual interface.
886 */
887int t4vf_enable_vi(struct adapter *adapter, unsigned int viid,
888 bool rx_en, bool tx_en)
889{
890 struct fw_vi_enable_cmd cmd;
891
892 memset(&cmd, 0, sizeof(cmd));
893 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_VI_ENABLE_CMD) |
894 FW_CMD_REQUEST |
895 FW_CMD_EXEC |
896 FW_VI_ENABLE_CMD_VIID(viid));
897 cmd.ien_to_len16 = cpu_to_be32(FW_VI_ENABLE_CMD_IEN(rx_en) |
898 FW_VI_ENABLE_CMD_EEN(tx_en) |
899 FW_LEN16(cmd));
900 return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);
901}
902
903/**
904 * t4vf_identify_port - identify a VI's port by blinking its LED
905 * @adapter: the adapter
906 * @viid: the Virtual Interface ID
907 * @nblinks: how many times to blink LED at 2.5 Hz
908 *
909 * Identifies a VI's port by blinking its LED.
910 */
911int t4vf_identify_port(struct adapter *adapter, unsigned int viid,
912 unsigned int nblinks)
913{
914 struct fw_vi_enable_cmd cmd;
915
916 memset(&cmd, 0, sizeof(cmd));
917 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_VI_ENABLE_CMD) |
918 FW_CMD_REQUEST |
919 FW_CMD_EXEC |
920 FW_VI_ENABLE_CMD_VIID(viid));
921 cmd.ien_to_len16 = cpu_to_be32(FW_VI_ENABLE_CMD_LED |
922 FW_LEN16(cmd));
923 cmd.blinkdur = cpu_to_be16(nblinks);
924 return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);
925}
926
927/**
928 * t4vf_set_rxmode - set Rx properties of a virtual interface
929 * @adapter: the adapter
930 * @viid: the VI id
931 * @mtu: the new MTU or -1 for no change
932 * @promisc: 1 to enable promiscuous mode, 0 to disable it, -1 no change
933 * @all_multi: 1 to enable all-multi mode, 0 to disable it, -1 no change
934 * @bcast: 1 to enable broadcast Rx, 0 to disable it, -1 no change
935 * @vlanex: 1 to enable hardware VLAN Tag extraction, 0 to disable it,
936 * -1 no change
937 *
938 * Sets Rx properties of a virtual interface.
939 */
940int t4vf_set_rxmode(struct adapter *adapter, unsigned int viid,
941 int mtu, int promisc, int all_multi, int bcast, int vlanex,
942 bool sleep_ok)
943{
944 struct fw_vi_rxmode_cmd cmd;
945
946 /* convert to FW values */
947 if (mtu < 0)
948 mtu = FW_VI_RXMODE_CMD_MTU_MASK;
949 if (promisc < 0)
950 promisc = FW_VI_RXMODE_CMD_PROMISCEN_MASK;
951 if (all_multi < 0)
952 all_multi = FW_VI_RXMODE_CMD_ALLMULTIEN_MASK;
953 if (bcast < 0)
954 bcast = FW_VI_RXMODE_CMD_BROADCASTEN_MASK;
955 if (vlanex < 0)
956 vlanex = FW_VI_RXMODE_CMD_VLANEXEN_MASK;
957
958 memset(&cmd, 0, sizeof(cmd));
959 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_VI_RXMODE_CMD) |
960 FW_CMD_REQUEST |
961 FW_CMD_WRITE |
962 FW_VI_RXMODE_CMD_VIID(viid));
963 cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
964 cmd.mtu_to_vlanexen =
965 cpu_to_be32(FW_VI_RXMODE_CMD_MTU(mtu) |
966 FW_VI_RXMODE_CMD_PROMISCEN(promisc) |
967 FW_VI_RXMODE_CMD_ALLMULTIEN(all_multi) |
968 FW_VI_RXMODE_CMD_BROADCASTEN(bcast) |
969 FW_VI_RXMODE_CMD_VLANEXEN(vlanex));
970 return t4vf_wr_mbox_core(adapter, &cmd, sizeof(cmd), NULL, sleep_ok);
971}
972
973/**
974 * t4vf_alloc_mac_filt - allocates exact-match filters for MAC addresses
975 * @adapter: the adapter
976 * @viid: the Virtual Interface Identifier
977 * @free: if true any existing filters for this VI id are first removed
978 * @naddr: the number of MAC addresses to allocate filters for (up to 7)
979 * @addr: the MAC address(es)
980 * @idx: where to store the index of each allocated filter
981 * @hash: pointer to hash address filter bitmap
982 * @sleep_ok: call is allowed to sleep
983 *
984 * Allocates an exact-match filter for each of the supplied addresses and
985 * sets it to the corresponding address. If @idx is not %NULL it should
986 * have at least @naddr entries, each of which will be set to the index of
987 * the filter allocated for the corresponding MAC address. If a filter
988 * could not be allocated for an address its index is set to 0xffff.
989 * If @hash is not %NULL addresses that fail to allocate an exact filter
990 * are hashed and update the hash filter bitmap pointed at by @hash.
991 *
992 * Returns a negative error number or the number of filters allocated.
993 */
994int t4vf_alloc_mac_filt(struct adapter *adapter, unsigned int viid, bool free,
995 unsigned int naddr, const u8 **addr, u16 *idx,
996 u64 *hash, bool sleep_ok)
997{
998 int i, ret;
999 struct fw_vi_mac_cmd cmd, rpl;
1000 struct fw_vi_mac_exact *p;
1001 size_t len16;
1002
1003 if (naddr > ARRAY_SIZE(cmd.u.exact))
1004 return -EINVAL;
1005 len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,
1006 u.exact[naddr]), 16);
1007
1008 memset(&cmd, 0, sizeof(cmd));
1009 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_VI_MAC_CMD) |
1010 FW_CMD_REQUEST |
1011 FW_CMD_WRITE |
1012 (free ? FW_CMD_EXEC : 0) |
1013 FW_VI_MAC_CMD_VIID(viid));
1014 cmd.freemacs_to_len16 = cpu_to_be32(FW_VI_MAC_CMD_FREEMACS(free) |
1015 FW_CMD_LEN16(len16));
1016
1017 for (i = 0, p = cmd.u.exact; i < naddr; i++, p++) {
1018 p->valid_to_idx =
1019 cpu_to_be16(FW_VI_MAC_CMD_VALID |
1020 FW_VI_MAC_CMD_IDX(FW_VI_MAC_ADD_MAC));
1021 memcpy(p->macaddr, addr[i], sizeof(p->macaddr));
1022 }
1023
1024 ret = t4vf_wr_mbox_core(adapter, &cmd, sizeof(cmd), &rpl, sleep_ok);
1025 if (ret)
1026 return ret;
1027
1028 for (i = 0, p = rpl.u.exact; i < naddr; i++, p++) {
1029 u16 index = FW_VI_MAC_CMD_IDX_GET(be16_to_cpu(p->valid_to_idx));
1030
1031 if (idx)
1032 idx[i] = (index >= FW_CLS_TCAM_NUM_ENTRIES
1033 ? 0xffff
1034 : index);
1035 if (index < FW_CLS_TCAM_NUM_ENTRIES)
1036 ret++;
1037 else if (hash)
1038 *hash |= (1 << hash_mac_addr(addr[i]));
1039 }
1040 return ret;
1041}
1042
1043/**
1044 * t4vf_change_mac - modifies the exact-match filter for a MAC address
1045 * @adapter: the adapter
1046 * @viid: the Virtual Interface ID
1047 * @idx: index of existing filter for old value of MAC address, or -1
1048 * @addr: the new MAC address value
1049 * @persist: if idx < 0, the new MAC allocation should be persistent
1050 *
1051 * Modifies an exact-match filter and sets it to the new MAC address.
1052 * Note that in general it is not possible to modify the value of a given
1053 * filter so the generic way to modify an address filter is to free the
1054 * one being used by the old address value and allocate a new filter for
1055 * the new address value. @idx can be -1 if the address is a new
1056 * addition.
1057 *
1058 * Returns a negative error number or the index of the filter with the new
1059 * MAC value.
1060 */
1061int t4vf_change_mac(struct adapter *adapter, unsigned int viid,
1062 int idx, const u8 *addr, bool persist)
1063{
1064 int ret;
1065 struct fw_vi_mac_cmd cmd, rpl;
1066 struct fw_vi_mac_exact *p = &cmd.u.exact[0];
1067 size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,
1068 u.exact[1]), 16);
1069
1070 /*
1071 * If this is a new allocation, determine whether it should be
1072 * persistent (across a "freemacs" operation) or not.
1073 */
1074 if (idx < 0)
1075 idx = persist ? FW_VI_MAC_ADD_PERSIST_MAC : FW_VI_MAC_ADD_MAC;
1076
1077 memset(&cmd, 0, sizeof(cmd));
1078 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_VI_MAC_CMD) |
1079 FW_CMD_REQUEST |
1080 FW_CMD_WRITE |
1081 FW_VI_MAC_CMD_VIID(viid));
1082 cmd.freemacs_to_len16 = cpu_to_be32(FW_CMD_LEN16(len16));
1083 p->valid_to_idx = cpu_to_be16(FW_VI_MAC_CMD_VALID |
1084 FW_VI_MAC_CMD_IDX(idx));
1085 memcpy(p->macaddr, addr, sizeof(p->macaddr));
1086
1087 ret = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &rpl);
1088 if (ret == 0) {
1089 p = &rpl.u.exact[0];
1090 ret = FW_VI_MAC_CMD_IDX_GET(be16_to_cpu(p->valid_to_idx));
1091 if (ret >= FW_CLS_TCAM_NUM_ENTRIES)
1092 ret = -ENOMEM;
1093 }
1094 return ret;
1095}
1096
1097/**
1098 * t4vf_set_addr_hash - program the MAC inexact-match hash filter
1099 * @adapter: the adapter
1100 * @viid: the Virtual Interface Identifier
1101 * @ucast: whether the hash filter should also match unicast addresses
1102 * @vec: the value to be written to the hash filter
1103 * @sleep_ok: call is allowed to sleep
1104 *
1105 * Sets the 64-bit inexact-match hash filter for a virtual interface.
1106 */
1107int t4vf_set_addr_hash(struct adapter *adapter, unsigned int viid,
1108 bool ucast, u64 vec, bool sleep_ok)
1109{
1110 struct fw_vi_mac_cmd cmd;
1111 size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,
1112 u.exact[0]), 16);
1113
1114 memset(&cmd, 0, sizeof(cmd));
1115 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_VI_MAC_CMD) |
1116 FW_CMD_REQUEST |
1117 FW_CMD_WRITE |
1118 FW_VI_ENABLE_CMD_VIID(viid));
1119 cmd.freemacs_to_len16 = cpu_to_be32(FW_VI_MAC_CMD_HASHVECEN |
1120 FW_VI_MAC_CMD_HASHUNIEN(ucast) |
1121 FW_CMD_LEN16(len16));
1122 cmd.u.hash.hashvec = cpu_to_be64(vec);
1123 return t4vf_wr_mbox_core(adapter, &cmd, sizeof(cmd), NULL, sleep_ok);
1124}
1125
1126/**
1127 * t4vf_get_port_stats - collect "port" statistics
1128 * @adapter: the adapter
1129 * @pidx: the port index
1130 * @s: the stats structure to fill
1131 *
1132 * Collect statistics for the "port"'s Virtual Interface.
1133 */
1134int t4vf_get_port_stats(struct adapter *adapter, int pidx,
1135 struct t4vf_port_stats *s)
1136{
1137 struct port_info *pi = adap2pinfo(adapter, pidx);
1138 struct fw_vi_stats_vf fwstats;
1139 unsigned int rem = VI_VF_NUM_STATS;
1140 __be64 *fwsp = (__be64 *)&fwstats;
1141
1142 /*
1143 * Grab the Virtual Interface statistics a chunk at a time via mailbox
1144 * commands. We could use a Work Request and get all of them at once
1145 * but that's an asynchronous interface which is awkward to use.
1146 */
1147 while (rem) {
1148 unsigned int ix = VI_VF_NUM_STATS - rem;
1149 unsigned int nstats = min(6U, rem);
1150 struct fw_vi_stats_cmd cmd, rpl;
1151 size_t len = (offsetof(struct fw_vi_stats_cmd, u) +
1152 sizeof(struct fw_vi_stats_ctl));
1153 size_t len16 = DIV_ROUND_UP(len, 16);
1154 int ret;
1155
1156 memset(&cmd, 0, sizeof(cmd));
1157 cmd.op_to_viid = cpu_to_be32(FW_CMD_OP(FW_VI_STATS_CMD) |
1158 FW_VI_STATS_CMD_VIID(pi->viid) |
1159 FW_CMD_REQUEST |
1160 FW_CMD_READ);
1161 cmd.retval_len16 = cpu_to_be32(FW_CMD_LEN16(len16));
1162 cmd.u.ctl.nstats_ix =
1163 cpu_to_be16(FW_VI_STATS_CMD_IX(ix) |
1164 FW_VI_STATS_CMD_NSTATS(nstats));
1165 ret = t4vf_wr_mbox_ns(adapter, &cmd, len, &rpl);
1166 if (ret)
1167 return ret;
1168
1169 memcpy(fwsp, &rpl.u.ctl.stat0, sizeof(__be64) * nstats);
1170
1171 rem -= nstats;
1172 fwsp += nstats;
1173 }
1174
1175 /*
1176 * Translate firmware statistics into host native statistics.
1177 */
1178 s->tx_bcast_bytes = be64_to_cpu(fwstats.tx_bcast_bytes);
1179 s->tx_bcast_frames = be64_to_cpu(fwstats.tx_bcast_frames);
1180 s->tx_mcast_bytes = be64_to_cpu(fwstats.tx_mcast_bytes);
1181 s->tx_mcast_frames = be64_to_cpu(fwstats.tx_mcast_frames);
1182 s->tx_ucast_bytes = be64_to_cpu(fwstats.tx_ucast_bytes);
1183 s->tx_ucast_frames = be64_to_cpu(fwstats.tx_ucast_frames);
1184 s->tx_drop_frames = be64_to_cpu(fwstats.tx_drop_frames);
1185 s->tx_offload_bytes = be64_to_cpu(fwstats.tx_offload_bytes);
1186 s->tx_offload_frames = be64_to_cpu(fwstats.tx_offload_frames);
1187
1188 s->rx_bcast_bytes = be64_to_cpu(fwstats.rx_bcast_bytes);
1189 s->rx_bcast_frames = be64_to_cpu(fwstats.rx_bcast_frames);
1190 s->rx_mcast_bytes = be64_to_cpu(fwstats.rx_mcast_bytes);
1191 s->rx_mcast_frames = be64_to_cpu(fwstats.rx_mcast_frames);
1192 s->rx_ucast_bytes = be64_to_cpu(fwstats.rx_ucast_bytes);
1193 s->rx_ucast_frames = be64_to_cpu(fwstats.rx_ucast_frames);
1194
1195 s->rx_err_frames = be64_to_cpu(fwstats.rx_err_frames);
1196
1197 return 0;
1198}
1199
1200/**
1201 * t4vf_iq_free - free an ingress queue and its free lists
1202 * @adapter: the adapter
1203 * @iqtype: the ingress queue type (FW_IQ_TYPE_FL_INT_CAP, etc.)
1204 * @iqid: ingress queue ID
1205 * @fl0id: FL0 queue ID or 0xffff if no attached FL0
1206 * @fl1id: FL1 queue ID or 0xffff if no attached FL1
1207 *
1208 * Frees an ingress queue and its associated free lists, if any.
1209 */
1210int t4vf_iq_free(struct adapter *adapter, unsigned int iqtype,
1211 unsigned int iqid, unsigned int fl0id, unsigned int fl1id)
1212{
1213 struct fw_iq_cmd cmd;
1214
1215 memset(&cmd, 0, sizeof(cmd));
1216 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_IQ_CMD) |
1217 FW_CMD_REQUEST |
1218 FW_CMD_EXEC);
1219 cmd.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_FREE |
1220 FW_LEN16(cmd));
1221 cmd.type_to_iqandstindex =
1222 cpu_to_be32(FW_IQ_CMD_TYPE(iqtype));
1223
1224 cmd.iqid = cpu_to_be16(iqid);
1225 cmd.fl0id = cpu_to_be16(fl0id);
1226 cmd.fl1id = cpu_to_be16(fl1id);
1227 return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);
1228}
1229
1230/**
1231 * t4vf_eth_eq_free - free an Ethernet egress queue
1232 * @adapter: the adapter
1233 * @eqid: egress queue ID
1234 *
1235 * Frees an Ethernet egress queue.
1236 */
1237int t4vf_eth_eq_free(struct adapter *adapter, unsigned int eqid)
1238{
1239 struct fw_eq_eth_cmd cmd;
1240
1241 memset(&cmd, 0, sizeof(cmd));
1242 cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP(FW_EQ_ETH_CMD) |
1243 FW_CMD_REQUEST |
1244 FW_CMD_EXEC);
1245 cmd.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_FREE |
1246 FW_LEN16(cmd));
1247 cmd.eqid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_EQID(eqid));
1248 return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);
1249}
1250
1251/**
1252 * t4vf_handle_fw_rpl - process a firmware reply message
1253 * @adapter: the adapter
1254 * @rpl: start of the firmware message
1255 *
1256 * Processes a firmware message, such as link state change messages.
1257 */
1258int t4vf_handle_fw_rpl(struct adapter *adapter, const __be64 *rpl)
1259{
1260 struct fw_cmd_hdr *cmd_hdr = (struct fw_cmd_hdr *)rpl;
1261 u8 opcode = FW_CMD_OP_GET(be32_to_cpu(cmd_hdr->hi));
1262
1263 switch (opcode) {
1264 case FW_PORT_CMD: {
1265 /*
1266 * Link/module state change message.
1267 */
1268 const struct fw_port_cmd *port_cmd = (void *)rpl;
1269 u32 word;
1270 int action, port_id, link_ok, speed, fc, pidx;
1271
1272 /*
1273 * Extract various fields from port status change message.
1274 */
1275 action = FW_PORT_CMD_ACTION_GET(
1276 be32_to_cpu(port_cmd->action_to_len16));
1277 if (action != FW_PORT_ACTION_GET_PORT_INFO) {
1278 dev_err(adapter->pdev_dev,
1279 "Unknown firmware PORT reply action %x\n",
1280 action);
1281 break;
1282 }
1283
1284 port_id = FW_PORT_CMD_PORTID_GET(
1285 be32_to_cpu(port_cmd->op_to_portid));
1286
1287 word = be32_to_cpu(port_cmd->u.info.lstatus_to_modtype);
1288 link_ok = (word & FW_PORT_CMD_LSTATUS) != 0;
1289 speed = 0;
1290 fc = 0;
1291 if (word & FW_PORT_CMD_RXPAUSE)
1292 fc |= PAUSE_RX;
1293 if (word & FW_PORT_CMD_TXPAUSE)
1294 fc |= PAUSE_TX;
1295 if (word & FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_100M))
1296 speed = SPEED_100;
1297 else if (word & FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_1G))
1298 speed = SPEED_1000;
1299 else if (word & FW_PORT_CMD_LSPEED(FW_PORT_CAP_SPEED_10G))
1300 speed = SPEED_10000;
1301
1302 /*
1303 * Scan all of our "ports" (Virtual Interfaces) looking for
1304 * those bound to the physical port which has changed. If
1305 * our recorded state doesn't match the current state,
1306 * signal that change to the OS code.
1307 */
1308 for_each_port(adapter, pidx) {
1309 struct port_info *pi = adap2pinfo(adapter, pidx);
1310 struct link_config *lc;
1311
1312 if (pi->port_id != port_id)
1313 continue;
1314
1315 lc = &pi->link_cfg;
1316 if (link_ok != lc->link_ok || speed != lc->speed ||
1317 fc != lc->fc) {
1318 /* something changed */
1319 lc->link_ok = link_ok;
1320 lc->speed = speed;
1321 lc->fc = fc;
1322 t4vf_os_link_changed(adapter, pidx, link_ok);
1323 }
1324 }
1325 break;
1326 }
1327
1328 default:
1329 dev_err(adapter->pdev_dev, "Unknown firmware reply %X\n",
1330 opcode);
1331 }
1332 return 0;
1333}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-26 01:10:36 -0500