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