1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  Copyright (C) 2013-2014 Chelsio Communications.  All rights reserved.
4  *
5  *  Written by Anish Bhatt (anish@chelsio.com)
6  *	       Casey Leedom (leedom@chelsio.com)
7  */
8 
9 #include "cxgb4.h"
10 
11 /* DCBx version control
12  */
13 const char * const dcb_ver_array[] = {
14 	"Unknown",
15 	"DCBx-CIN",
16 	"DCBx-CEE 1.01",
17 	"DCBx-IEEE",
18 	"", "", "",
19 	"Auto Negotiated"
20 };
21 
22 static inline bool cxgb4_dcb_state_synced(enum cxgb4_dcb_state state)
23 {
24 	if (state == CXGB4_DCB_STATE_FW_ALLSYNCED ||
25 	    state == CXGB4_DCB_STATE_HOST)
26 		return true;
27 	else
28 		return false;
29 }
30 
31 /* Initialize a port's Data Center Bridging state.
32  */
33 void cxgb4_dcb_state_init(struct net_device *dev)
34 {
35 	struct port_info *pi = netdev2pinfo(dev);
36 	struct port_dcb_info *dcb = &pi->dcb;
37 	int version_temp = dcb->dcb_version;
38 
39 	memset(dcb, 0, sizeof(struct port_dcb_info));
40 	dcb->state = CXGB4_DCB_STATE_START;
41 	if (version_temp)
42 		dcb->dcb_version = version_temp;
43 
44 	netdev_dbg(dev, "%s: Initializing DCB state for port[%d]\n",
45 		    __func__, pi->port_id);
46 }
47 
48 void cxgb4_dcb_version_init(struct net_device *dev)
49 {
50 	struct port_info *pi = netdev2pinfo(dev);
51 	struct port_dcb_info *dcb = &pi->dcb;
52 
53 	/* Any writes here are only done on kernels that exlicitly need
54 	 * a specific version, say < 2.6.38 which only support CEE
55 	 */
56 	dcb->dcb_version = FW_PORT_DCB_VER_AUTO;
57 }
58 
59 static void cxgb4_dcb_cleanup_apps(struct net_device *dev)
60 {
61 	struct port_info *pi = netdev2pinfo(dev);
62 	struct adapter *adap = pi->adapter;
63 	struct port_dcb_info *dcb = &pi->dcb;
64 	struct dcb_app app;
65 	int i, err;
66 
67 	/* zero priority implies remove */
68 	app.priority = 0;
69 
70 	for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
71 		/* Check if app list is exhausted */
72 		if (!dcb->app_priority[i].protocolid)
73 			break;
74 
75 		app.protocol = dcb->app_priority[i].protocolid;
76 
77 		if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
78 			app.priority = dcb->app_priority[i].user_prio_map;
79 			app.selector = dcb->app_priority[i].sel_field + 1;
80 			err = dcb_ieee_delapp(dev, &app);
81 		} else {
82 			app.selector = !!(dcb->app_priority[i].sel_field);
83 			err = dcb_setapp(dev, &app);
84 		}
85 
86 		if (err) {
87 			dev_err(adap->pdev_dev,
88 				"Failed DCB Clear %s Application Priority: sel=%d, prot=%d, err=%d\n",
89 				dcb_ver_array[dcb->dcb_version], app.selector,
90 				app.protocol, -err);
91 			break;
92 		}
93 	}
94 }
95 
96 /* Reset a port's Data Center Bridging state.  Typically used after a
97  * Link Down event.
98  */
99 void cxgb4_dcb_reset(struct net_device *dev)
100 {
101 	cxgb4_dcb_cleanup_apps(dev);
102 	cxgb4_dcb_state_init(dev);
103 }
104 
105 /* update the dcb port support, if version is IEEE then set it to
106  * FW_PORT_DCB_VER_IEEE and if DCB_CAP_DCBX_VER_CEE is already set then
107  * clear that. and if it is set to CEE then set dcb supported to
108  * DCB_CAP_DCBX_VER_CEE & if DCB_CAP_DCBX_VER_IEEE is set, clear it
109  */
110 static inline void cxgb4_dcb_update_support(struct port_dcb_info *dcb)
111 {
112 	if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
113 		if (dcb->supported & DCB_CAP_DCBX_VER_CEE)
114 			dcb->supported &= ~DCB_CAP_DCBX_VER_CEE;
115 		dcb->supported |= DCB_CAP_DCBX_VER_IEEE;
116 	} else if (dcb->dcb_version == FW_PORT_DCB_VER_CEE1D01) {
117 		if (dcb->supported & DCB_CAP_DCBX_VER_IEEE)
118 			dcb->supported &= ~DCB_CAP_DCBX_VER_IEEE;
119 		dcb->supported |= DCB_CAP_DCBX_VER_CEE;
120 	}
121 }
122 
123 /* Finite State machine for Data Center Bridging.
124  */
125 void cxgb4_dcb_state_fsm(struct net_device *dev,
126 			 enum cxgb4_dcb_state_input transition_to)
127 {
128 	struct port_info *pi = netdev2pinfo(dev);
129 	struct port_dcb_info *dcb = &pi->dcb;
130 	struct adapter *adap = pi->adapter;
131 	enum cxgb4_dcb_state current_state = dcb->state;
132 
133 	netdev_dbg(dev, "%s: State change from %d to %d for %s\n",
134 		    __func__, dcb->state, transition_to, dev->name);
135 
136 	switch (current_state) {
137 	case CXGB4_DCB_STATE_START: {
138 		switch (transition_to) {
139 		case CXGB4_DCB_INPUT_FW_DISABLED: {
140 			/* we're going to use Host DCB */
141 			dcb->state = CXGB4_DCB_STATE_HOST;
142 			dcb->supported = CXGB4_DCBX_HOST_SUPPORT;
143 			break;
144 		}
145 
146 		case CXGB4_DCB_INPUT_FW_ENABLED: {
147 			/* we're going to use Firmware DCB */
148 			dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE;
149 			dcb->supported = DCB_CAP_DCBX_LLD_MANAGED;
150 			if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE)
151 				dcb->supported |= DCB_CAP_DCBX_VER_IEEE;
152 			else
153 				dcb->supported |= DCB_CAP_DCBX_VER_CEE;
154 			break;
155 		}
156 
157 		case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
158 			/* expected transition */
159 			break;
160 		}
161 
162 		case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
163 			dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED;
164 			break;
165 		}
166 
167 		default:
168 			goto bad_state_input;
169 		}
170 		break;
171 	}
172 
173 	case CXGB4_DCB_STATE_FW_INCOMPLETE: {
174 		if (transition_to != CXGB4_DCB_INPUT_FW_DISABLED) {
175 			/* during this CXGB4_DCB_STATE_FW_INCOMPLETE state,
176 			 * check if the dcb version is changed (there can be
177 			 * mismatch in default config & the negotiated switch
178 			 * configuration at FW, so update the dcb support
179 			 * accordingly.
180 			 */
181 			cxgb4_dcb_update_support(dcb);
182 		}
183 		switch (transition_to) {
184 		case CXGB4_DCB_INPUT_FW_ENABLED: {
185 			/* we're alreaady in firmware DCB mode */
186 			break;
187 		}
188 
189 		case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
190 			/* we're already incomplete */
191 			break;
192 		}
193 
194 		case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
195 			dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED;
196 			dcb->enabled = 1;
197 			linkwatch_fire_event(dev);
198 			break;
199 		}
200 
201 		default:
202 			goto bad_state_input;
203 		}
204 		break;
205 	}
206 
207 	case CXGB4_DCB_STATE_FW_ALLSYNCED: {
208 		switch (transition_to) {
209 		case CXGB4_DCB_INPUT_FW_ENABLED: {
210 			/* we're alreaady in firmware DCB mode */
211 			break;
212 		}
213 
214 		case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
215 			/* We were successfully running with firmware DCB but
216 			 * now it's telling us that it's in an "incomplete
217 			 * state.  We need to reset back to a ground state
218 			 * of incomplete.
219 			 */
220 			cxgb4_dcb_reset(dev);
221 			dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE;
222 			dcb->supported = CXGB4_DCBX_FW_SUPPORT;
223 			linkwatch_fire_event(dev);
224 			break;
225 		}
226 
227 		case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
228 			/* we're already all sync'ed
229 			 * this is only applicable for IEEE or
230 			 * when another VI already completed negotiaton
231 			 */
232 			dcb->enabled = 1;
233 			linkwatch_fire_event(dev);
234 			break;
235 		}
236 
237 		default:
238 			goto bad_state_input;
239 		}
240 		break;
241 	}
242 
243 	case CXGB4_DCB_STATE_HOST: {
244 		switch (transition_to) {
245 		case CXGB4_DCB_INPUT_FW_DISABLED: {
246 			/* we're alreaady in Host DCB mode */
247 			break;
248 		}
249 
250 		default:
251 			goto bad_state_input;
252 		}
253 		break;
254 	}
255 
256 	default:
257 		goto bad_state_transition;
258 	}
259 	return;
260 
261 bad_state_input:
262 	dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: illegal input symbol %d\n",
263 		transition_to);
264 	return;
265 
266 bad_state_transition:
267 	dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: bad state transition, state = %d, input = %d\n",
268 		current_state, transition_to);
269 }
270 
271 /* Handle a DCB/DCBX update message from the firmware.
272  */
273 void cxgb4_dcb_handle_fw_update(struct adapter *adap,
274 				const struct fw_port_cmd *pcmd)
275 {
276 	const union fw_port_dcb *fwdcb = &pcmd->u.dcb;
277 	int port = FW_PORT_CMD_PORTID_G(be32_to_cpu(pcmd->op_to_portid));
278 	struct net_device *dev = adap->port[adap->chan_map[port]];
279 	struct port_info *pi = netdev_priv(dev);
280 	struct port_dcb_info *dcb = &pi->dcb;
281 	int dcb_type = pcmd->u.dcb.pgid.type;
282 	int dcb_running_version;
283 
284 	/* Handle Firmware DCB Control messages separately since they drive
285 	 * our state machine.
286 	 */
287 	if (dcb_type == FW_PORT_DCB_TYPE_CONTROL) {
288 		enum cxgb4_dcb_state_input input =
289 			((pcmd->u.dcb.control.all_syncd_pkd &
290 			  FW_PORT_CMD_ALL_SYNCD_F)
291 			 ? CXGB4_DCB_INPUT_FW_ALLSYNCED
292 			 : CXGB4_DCB_INPUT_FW_INCOMPLETE);
293 
294 		if (dcb->dcb_version != FW_PORT_DCB_VER_UNKNOWN) {
295 			dcb_running_version = FW_PORT_CMD_DCB_VERSION_G(
296 				be16_to_cpu(
297 				pcmd->u.dcb.control.dcb_version_to_app_state));
298 			if (dcb_running_version == FW_PORT_DCB_VER_CEE1D01 ||
299 			    dcb_running_version == FW_PORT_DCB_VER_IEEE) {
300 				dcb->dcb_version = dcb_running_version;
301 				dev_warn(adap->pdev_dev, "Interface %s is running %s\n",
302 					 dev->name,
303 					 dcb_ver_array[dcb->dcb_version]);
304 			} else {
305 				dev_warn(adap->pdev_dev,
306 					 "Something screwed up, requested firmware for %s, but firmware returned %s instead\n",
307 					 dcb_ver_array[dcb->dcb_version],
308 					 dcb_ver_array[dcb_running_version]);
309 				dcb->dcb_version = FW_PORT_DCB_VER_UNKNOWN;
310 			}
311 		}
312 
313 		cxgb4_dcb_state_fsm(dev, input);
314 		return;
315 	}
316 
317 	/* It's weird, and almost certainly an error, to get Firmware DCB
318 	 * messages when we either haven't been told whether we're going to be
319 	 * doing Host or Firmware DCB; and even worse when we've been told
320 	 * that we're doing Host DCB!
321 	 */
322 	if (dcb->state == CXGB4_DCB_STATE_START ||
323 	    dcb->state == CXGB4_DCB_STATE_HOST) {
324 		dev_err(adap->pdev_dev, "Receiving Firmware DCB messages in State %d\n",
325 			dcb->state);
326 		return;
327 	}
328 
329 	/* Now handle the general Firmware DCB update messages ...
330 	 */
331 	switch (dcb_type) {
332 	case FW_PORT_DCB_TYPE_PGID:
333 		dcb->pgid = be32_to_cpu(fwdcb->pgid.pgid);
334 		dcb->msgs |= CXGB4_DCB_FW_PGID;
335 		break;
336 
337 	case FW_PORT_DCB_TYPE_PGRATE:
338 		dcb->pg_num_tcs_supported = fwdcb->pgrate.num_tcs_supported;
339 		memcpy(dcb->pgrate, &fwdcb->pgrate.pgrate,
340 		       sizeof(dcb->pgrate));
341 		memcpy(dcb->tsa, &fwdcb->pgrate.tsa,
342 		       sizeof(dcb->tsa));
343 		dcb->msgs |= CXGB4_DCB_FW_PGRATE;
344 		if (dcb->msgs & CXGB4_DCB_FW_PGID)
345 			IEEE_FAUX_SYNC(dev, dcb);
346 		break;
347 
348 	case FW_PORT_DCB_TYPE_PRIORATE:
349 		memcpy(dcb->priorate, &fwdcb->priorate.strict_priorate,
350 		       sizeof(dcb->priorate));
351 		dcb->msgs |= CXGB4_DCB_FW_PRIORATE;
352 		break;
353 
354 	case FW_PORT_DCB_TYPE_PFC:
355 		dcb->pfcen = fwdcb->pfc.pfcen;
356 		dcb->pfc_num_tcs_supported = fwdcb->pfc.max_pfc_tcs;
357 		dcb->msgs |= CXGB4_DCB_FW_PFC;
358 		IEEE_FAUX_SYNC(dev, dcb);
359 		break;
360 
361 	case FW_PORT_DCB_TYPE_APP_ID: {
362 		const struct fw_port_app_priority *fwap = &fwdcb->app_priority;
363 		int idx = fwap->idx;
364 		struct app_priority *ap = &dcb->app_priority[idx];
365 
366 		struct dcb_app app = {
367 			.protocol = be16_to_cpu(fwap->protocolid),
368 		};
369 		int err;
370 
371 		/* Convert from firmware format to relevant format
372 		 * when using app selector
373 		 */
374 		if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
375 			app.selector = (fwap->sel_field + 1);
376 			app.priority = ffs(fwap->user_prio_map) - 1;
377 			err = dcb_ieee_setapp(dev, &app);
378 			IEEE_FAUX_SYNC(dev, dcb);
379 		} else {
380 			/* Default is CEE */
381 			app.selector = !!(fwap->sel_field);
382 			app.priority = fwap->user_prio_map;
383 			err = dcb_setapp(dev, &app);
384 		}
385 
386 		if (err)
387 			dev_err(adap->pdev_dev,
388 				"Failed DCB Set Application Priority: sel=%d, prot=%d, prio=%d, err=%d\n",
389 				app.selector, app.protocol, app.priority, -err);
390 
391 		ap->user_prio_map = fwap->user_prio_map;
392 		ap->sel_field = fwap->sel_field;
393 		ap->protocolid = be16_to_cpu(fwap->protocolid);
394 		dcb->msgs |= CXGB4_DCB_FW_APP_ID;
395 		break;
396 	}
397 
398 	default:
399 		dev_err(adap->pdev_dev, "Unknown DCB update type received %x\n",
400 			dcb_type);
401 		break;
402 	}
403 }
404 
405 /* Data Center Bridging netlink operations.
406  */
407 
408 
409 /* Get current DCB enabled/disabled state.
410  */
411 static u8 cxgb4_getstate(struct net_device *dev)
412 {
413 	struct port_info *pi = netdev2pinfo(dev);
414 
415 	return pi->dcb.enabled;
416 }
417 
418 /* Set DCB enabled/disabled.
419  */
420 static u8 cxgb4_setstate(struct net_device *dev, u8 enabled)
421 {
422 	struct port_info *pi = netdev2pinfo(dev);
423 
424 	/* If DCBx is host-managed, dcb is enabled by outside lldp agents */
425 	if (pi->dcb.state == CXGB4_DCB_STATE_HOST) {
426 		pi->dcb.enabled = enabled;
427 		return 0;
428 	}
429 
430 	/* Firmware doesn't provide any mechanism to control the DCB state.
431 	 */
432 	if (enabled != (pi->dcb.state == CXGB4_DCB_STATE_FW_ALLSYNCED))
433 		return 1;
434 
435 	return 0;
436 }
437 
438 static void cxgb4_getpgtccfg(struct net_device *dev, int tc,
439 			     u8 *prio_type, u8 *pgid, u8 *bw_per,
440 			     u8 *up_tc_map, int local)
441 {
442 	struct fw_port_cmd pcmd;
443 	struct port_info *pi = netdev2pinfo(dev);
444 	struct adapter *adap = pi->adapter;
445 	int err;
446 
447 	*prio_type = *pgid = *bw_per = *up_tc_map = 0;
448 
449 	if (local)
450 		INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
451 	else
452 		INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
453 
454 	pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
455 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
456 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
457 		dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
458 		return;
459 	}
460 	*pgid = (be32_to_cpu(pcmd.u.dcb.pgid.pgid) >> (tc * 4)) & 0xf;
461 
462 	if (local)
463 		INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
464 	else
465 		INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
466 	pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
467 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
468 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
469 		dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
470 			-err);
471 		return;
472 	}
473 
474 	*bw_per = pcmd.u.dcb.pgrate.pgrate[*pgid];
475 	*up_tc_map = (1 << tc);
476 
477 	/* prio_type is link strict */
478 	if (*pgid != 0xF)
479 		*prio_type = 0x2;
480 }
481 
482 static void cxgb4_getpgtccfg_tx(struct net_device *dev, int tc,
483 				u8 *prio_type, u8 *pgid, u8 *bw_per,
484 				u8 *up_tc_map)
485 {
486 	/* tc 0 is written at MSB position */
487 	return cxgb4_getpgtccfg(dev, (7 - tc), prio_type, pgid, bw_per,
488 				up_tc_map, 1);
489 }
490 
491 
492 static void cxgb4_getpgtccfg_rx(struct net_device *dev, int tc,
493 				u8 *prio_type, u8 *pgid, u8 *bw_per,
494 				u8 *up_tc_map)
495 {
496 	/* tc 0 is written at MSB position */
497 	return cxgb4_getpgtccfg(dev, (7 - tc), prio_type, pgid, bw_per,
498 				up_tc_map, 0);
499 }
500 
501 static void cxgb4_setpgtccfg_tx(struct net_device *dev, int tc,
502 				u8 prio_type, u8 pgid, u8 bw_per,
503 				u8 up_tc_map)
504 {
505 	struct fw_port_cmd pcmd;
506 	struct port_info *pi = netdev2pinfo(dev);
507 	struct adapter *adap = pi->adapter;
508 	int fw_tc = 7 - tc;
509 	u32 _pgid;
510 	int err;
511 
512 	if (pgid == DCB_ATTR_VALUE_UNDEFINED)
513 		return;
514 	if (bw_per == DCB_ATTR_VALUE_UNDEFINED)
515 		return;
516 
517 	INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
518 	pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
519 
520 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
521 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
522 		dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
523 		return;
524 	}
525 
526 	_pgid = be32_to_cpu(pcmd.u.dcb.pgid.pgid);
527 	_pgid &= ~(0xF << (fw_tc * 4));
528 	_pgid |= pgid << (fw_tc * 4);
529 	pcmd.u.dcb.pgid.pgid = cpu_to_be32(_pgid);
530 
531 	INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
532 
533 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
534 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
535 		dev_err(adap->pdev_dev, "DCB write PGID failed with %d\n",
536 			-err);
537 		return;
538 	}
539 
540 	memset(&pcmd, 0, sizeof(struct fw_port_cmd));
541 
542 	INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
543 	pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
544 
545 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
546 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
547 		dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
548 			-err);
549 		return;
550 	}
551 
552 	pcmd.u.dcb.pgrate.pgrate[pgid] = bw_per;
553 
554 	INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
555 	if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
556 		pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);
557 
558 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
559 	if (err != FW_PORT_DCB_CFG_SUCCESS)
560 		dev_err(adap->pdev_dev, "DCB write PGRATE failed with %d\n",
561 			-err);
562 }
563 
564 static void cxgb4_getpgbwgcfg(struct net_device *dev, int pgid, u8 *bw_per,
565 			      int local)
566 {
567 	struct fw_port_cmd pcmd;
568 	struct port_info *pi = netdev2pinfo(dev);
569 	struct adapter *adap = pi->adapter;
570 	int err;
571 
572 	if (local)
573 		INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
574 	else
575 		INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
576 
577 	pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
578 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
579 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
580 		dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
581 			-err);
582 		return;
583 	}
584 
585 	*bw_per = pcmd.u.dcb.pgrate.pgrate[pgid];
586 }
587 
588 static void cxgb4_getpgbwgcfg_tx(struct net_device *dev, int pgid, u8 *bw_per)
589 {
590 	return cxgb4_getpgbwgcfg(dev, pgid, bw_per, 1);
591 }
592 
593 static void cxgb4_getpgbwgcfg_rx(struct net_device *dev, int pgid, u8 *bw_per)
594 {
595 	return cxgb4_getpgbwgcfg(dev, pgid, bw_per, 0);
596 }
597 
598 static void cxgb4_setpgbwgcfg_tx(struct net_device *dev, int pgid,
599 				 u8 bw_per)
600 {
601 	struct fw_port_cmd pcmd;
602 	struct port_info *pi = netdev2pinfo(dev);
603 	struct adapter *adap = pi->adapter;
604 	int err;
605 
606 	INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
607 	pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
608 
609 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
610 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
611 		dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
612 			-err);
613 		return;
614 	}
615 
616 	pcmd.u.dcb.pgrate.pgrate[pgid] = bw_per;
617 
618 	INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
619 	if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
620 		pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);
621 
622 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
623 
624 	if (err != FW_PORT_DCB_CFG_SUCCESS)
625 		dev_err(adap->pdev_dev, "DCB write PGRATE failed with %d\n",
626 			-err);
627 }
628 
629 /* Return whether the specified Traffic Class Priority has Priority Pause
630  * Frames enabled.
631  */
632 static void cxgb4_getpfccfg(struct net_device *dev, int priority, u8 *pfccfg)
633 {
634 	struct port_info *pi = netdev2pinfo(dev);
635 	struct port_dcb_info *dcb = &pi->dcb;
636 
637 	if (!cxgb4_dcb_state_synced(dcb->state) ||
638 	    priority >= CXGB4_MAX_PRIORITY)
639 		*pfccfg = 0;
640 	else
641 		*pfccfg = (pi->dcb.pfcen >> (7 - priority)) & 1;
642 }
643 
644 /* Enable/disable Priority Pause Frames for the specified Traffic Class
645  * Priority.
646  */
647 static void cxgb4_setpfccfg(struct net_device *dev, int priority, u8 pfccfg)
648 {
649 	struct fw_port_cmd pcmd;
650 	struct port_info *pi = netdev2pinfo(dev);
651 	struct adapter *adap = pi->adapter;
652 	int err;
653 
654 	if (!cxgb4_dcb_state_synced(pi->dcb.state) ||
655 	    priority >= CXGB4_MAX_PRIORITY)
656 		return;
657 
658 	INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
659 	if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
660 		pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);
661 
662 	pcmd.u.dcb.pfc.type = FW_PORT_DCB_TYPE_PFC;
663 	pcmd.u.dcb.pfc.pfcen = pi->dcb.pfcen;
664 
665 	if (pfccfg)
666 		pcmd.u.dcb.pfc.pfcen |= (1 << (7 - priority));
667 	else
668 		pcmd.u.dcb.pfc.pfcen &= (~(1 << (7 - priority)));
669 
670 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
671 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
672 		dev_err(adap->pdev_dev, "DCB PFC write failed with %d\n", -err);
673 		return;
674 	}
675 
676 	pi->dcb.pfcen = pcmd.u.dcb.pfc.pfcen;
677 }
678 
679 static u8 cxgb4_setall(struct net_device *dev)
680 {
681 	return 0;
682 }
683 
684 /* Return DCB capabilities.
685  */
686 static u8 cxgb4_getcap(struct net_device *dev, int cap_id, u8 *caps)
687 {
688 	struct port_info *pi = netdev2pinfo(dev);
689 
690 	switch (cap_id) {
691 	case DCB_CAP_ATTR_PG:
692 	case DCB_CAP_ATTR_PFC:
693 		*caps = true;
694 		break;
695 
696 	case DCB_CAP_ATTR_PG_TCS:
697 		/* 8 priorities for PG represented by bitmap */
698 		*caps = 0x80;
699 		break;
700 
701 	case DCB_CAP_ATTR_PFC_TCS:
702 		/* 8 priorities for PFC represented by bitmap */
703 		*caps = 0x80;
704 		break;
705 
706 	case DCB_CAP_ATTR_GSP:
707 		*caps = true;
708 		break;
709 
710 	case DCB_CAP_ATTR_UP2TC:
711 	case DCB_CAP_ATTR_BCN:
712 		*caps = false;
713 		break;
714 
715 	case DCB_CAP_ATTR_DCBX:
716 		*caps = pi->dcb.supported;
717 		break;
718 
719 	default:
720 		*caps = false;
721 	}
722 
723 	return 0;
724 }
725 
726 /* Return the number of Traffic Classes for the indicated Traffic Class ID.
727  */
728 static int cxgb4_getnumtcs(struct net_device *dev, int tcs_id, u8 *num)
729 {
730 	struct port_info *pi = netdev2pinfo(dev);
731 
732 	switch (tcs_id) {
733 	case DCB_NUMTCS_ATTR_PG:
734 		if (pi->dcb.msgs & CXGB4_DCB_FW_PGRATE)
735 			*num = pi->dcb.pg_num_tcs_supported;
736 		else
737 			*num = 0x8;
738 		break;
739 
740 	case DCB_NUMTCS_ATTR_PFC:
741 		*num = 0x8;
742 		break;
743 
744 	default:
745 		return -EINVAL;
746 	}
747 
748 	return 0;
749 }
750 
751 /* Set the number of Traffic Classes supported for the indicated Traffic Class
752  * ID.
753  */
754 static int cxgb4_setnumtcs(struct net_device *dev, int tcs_id, u8 num)
755 {
756 	/* Setting the number of Traffic Classes isn't supported.
757 	 */
758 	return -ENOSYS;
759 }
760 
761 /* Return whether Priority Flow Control is enabled.  */
762 static u8 cxgb4_getpfcstate(struct net_device *dev)
763 {
764 	struct port_info *pi = netdev2pinfo(dev);
765 
766 	if (!cxgb4_dcb_state_synced(pi->dcb.state))
767 		return false;
768 
769 	return pi->dcb.pfcen != 0;
770 }
771 
772 /* Enable/disable Priority Flow Control. */
773 static void cxgb4_setpfcstate(struct net_device *dev, u8 state)
774 {
775 	/* We can't enable/disable Priority Flow Control but we also can't
776 	 * return an error ...
777 	 */
778 }
779 
780 /* Return the Application User Priority Map associated with the specified
781  * Application ID.
782  */
783 static int __cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id,
784 			  int peer)
785 {
786 	struct port_info *pi = netdev2pinfo(dev);
787 	struct adapter *adap = pi->adapter;
788 	int i;
789 
790 	if (!cxgb4_dcb_state_synced(pi->dcb.state))
791 		return 0;
792 
793 	for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
794 		struct fw_port_cmd pcmd;
795 		int err;
796 
797 		if (peer)
798 			INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
799 		else
800 			INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
801 
802 		pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
803 		pcmd.u.dcb.app_priority.idx = i;
804 
805 		err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
806 		if (err != FW_PORT_DCB_CFG_SUCCESS) {
807 			dev_err(adap->pdev_dev, "DCB APP read failed with %d\n",
808 				-err);
809 			return err;
810 		}
811 		if (be16_to_cpu(pcmd.u.dcb.app_priority.protocolid) == app_id)
812 			if (pcmd.u.dcb.app_priority.sel_field == app_idtype)
813 				return pcmd.u.dcb.app_priority.user_prio_map;
814 
815 		/* exhausted app list */
816 		if (!pcmd.u.dcb.app_priority.protocolid)
817 			break;
818 	}
819 
820 	return -EEXIST;
821 }
822 
823 /* Return the Application User Priority Map associated with the specified
824  * Application ID.
825  */
826 static int cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id)
827 {
828 	/* Convert app_idtype to firmware format before querying */
829 	return __cxgb4_getapp(dev, app_idtype == DCB_APP_IDTYPE_ETHTYPE ?
830 			      app_idtype : 3, app_id, 0);
831 }
832 
833 /* Write a new Application User Priority Map for the specified Application ID
834  */
835 static int __cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
836 			  u8 app_prio)
837 {
838 	struct fw_port_cmd pcmd;
839 	struct port_info *pi = netdev2pinfo(dev);
840 	struct adapter *adap = pi->adapter;
841 	int i, err;
842 
843 
844 	if (!cxgb4_dcb_state_synced(pi->dcb.state))
845 		return -EINVAL;
846 
847 	/* DCB info gets thrown away on link up */
848 	if (!netif_carrier_ok(dev))
849 		return -ENOLINK;
850 
851 	for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
852 		INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
853 		pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
854 		pcmd.u.dcb.app_priority.idx = i;
855 		err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
856 
857 		if (err != FW_PORT_DCB_CFG_SUCCESS) {
858 			dev_err(adap->pdev_dev, "DCB app table read failed with %d\n",
859 				-err);
860 			return err;
861 		}
862 		if (be16_to_cpu(pcmd.u.dcb.app_priority.protocolid) == app_id) {
863 			/* overwrite existing app table */
864 			pcmd.u.dcb.app_priority.protocolid = 0;
865 			break;
866 		}
867 		/* find first empty slot */
868 		if (!pcmd.u.dcb.app_priority.protocolid)
869 			break;
870 	}
871 
872 	if (i == CXGB4_MAX_DCBX_APP_SUPPORTED) {
873 		/* no empty slots available */
874 		dev_err(adap->pdev_dev, "DCB app table full\n");
875 		return -EBUSY;
876 	}
877 
878 	/* write out new app table entry */
879 	INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
880 	if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
881 		pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);
882 
883 	pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
884 	pcmd.u.dcb.app_priority.protocolid = cpu_to_be16(app_id);
885 	pcmd.u.dcb.app_priority.sel_field = app_idtype;
886 	pcmd.u.dcb.app_priority.user_prio_map = app_prio;
887 	pcmd.u.dcb.app_priority.idx = i;
888 
889 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
890 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
891 		dev_err(adap->pdev_dev, "DCB app table write failed with %d\n",
892 			-err);
893 		return err;
894 	}
895 
896 	return 0;
897 }
898 
899 /* Priority for CEE inside dcb_app is bitmask, with 0 being an invalid value */
900 static int cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
901 			u8 app_prio)
902 {
903 	int ret;
904 	struct dcb_app app = {
905 		.selector = app_idtype,
906 		.protocol = app_id,
907 		.priority = app_prio,
908 	};
909 
910 	if (app_idtype != DCB_APP_IDTYPE_ETHTYPE &&
911 	    app_idtype != DCB_APP_IDTYPE_PORTNUM)
912 		return -EINVAL;
913 
914 	/* Convert app_idtype to a format that firmware understands */
915 	ret = __cxgb4_setapp(dev, app_idtype == DCB_APP_IDTYPE_ETHTYPE ?
916 			      app_idtype : 3, app_id, app_prio);
917 	if (ret)
918 		return ret;
919 
920 	return dcb_setapp(dev, &app);
921 }
922 
923 /* Return whether IEEE Data Center Bridging has been negotiated.
924  */
925 static inline int
926 cxgb4_ieee_negotiation_complete(struct net_device *dev,
927 				enum cxgb4_dcb_fw_msgs dcb_subtype)
928 {
929 	struct port_info *pi = netdev2pinfo(dev);
930 	struct port_dcb_info *dcb = &pi->dcb;
931 
932 	if (dcb->state == CXGB4_DCB_STATE_FW_ALLSYNCED)
933 		if (dcb_subtype && !(dcb->msgs & dcb_subtype))
934 			return 0;
935 
936 	return (cxgb4_dcb_state_synced(dcb->state) &&
937 		(dcb->supported & DCB_CAP_DCBX_VER_IEEE));
938 }
939 
940 static int cxgb4_ieee_read_ets(struct net_device *dev, struct ieee_ets *ets,
941 			       int local)
942 {
943 	struct port_info *pi = netdev2pinfo(dev);
944 	struct port_dcb_info *dcb = &pi->dcb;
945 	struct adapter *adap = pi->adapter;
946 	uint32_t tc_info;
947 	struct fw_port_cmd pcmd;
948 	int i, bwg, err;
949 
950 	if (!(dcb->msgs & (CXGB4_DCB_FW_PGID | CXGB4_DCB_FW_PGRATE)))
951 		return 0;
952 
953 	ets->ets_cap =  dcb->pg_num_tcs_supported;
954 
955 	if (local) {
956 		ets->willing = 1;
957 		INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
958 	} else {
959 		INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
960 	}
961 
962 	pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
963 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
964 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
965 		dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
966 		return err;
967 	}
968 
969 	tc_info = be32_to_cpu(pcmd.u.dcb.pgid.pgid);
970 
971 	if (local)
972 		INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
973 	else
974 		INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
975 
976 	pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
977 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
978 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
979 		dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
980 			-err);
981 		return err;
982 	}
983 
984 	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
985 		bwg = (tc_info >> ((7 - i) * 4)) & 0xF;
986 		ets->prio_tc[i] = bwg;
987 		ets->tc_tx_bw[i] = pcmd.u.dcb.pgrate.pgrate[i];
988 		ets->tc_rx_bw[i] = ets->tc_tx_bw[i];
989 		ets->tc_tsa[i] = pcmd.u.dcb.pgrate.tsa[i];
990 	}
991 
992 	return 0;
993 }
994 
995 static int cxgb4_ieee_get_ets(struct net_device *dev, struct ieee_ets *ets)
996 {
997 	return cxgb4_ieee_read_ets(dev, ets, 1);
998 }
999 
1000 /* We reuse this for peer PFC as well, as we can't have it enabled one way */
1001 static int cxgb4_ieee_get_pfc(struct net_device *dev, struct ieee_pfc *pfc)
1002 {
1003 	struct port_info *pi = netdev2pinfo(dev);
1004 	struct port_dcb_info *dcb = &pi->dcb;
1005 
1006 	memset(pfc, 0, sizeof(struct ieee_pfc));
1007 
1008 	if (!(dcb->msgs & CXGB4_DCB_FW_PFC))
1009 		return 0;
1010 
1011 	pfc->pfc_cap = dcb->pfc_num_tcs_supported;
1012 	pfc->pfc_en = bitswap_1(dcb->pfcen);
1013 
1014 	return 0;
1015 }
1016 
1017 static int cxgb4_ieee_peer_ets(struct net_device *dev, struct ieee_ets *ets)
1018 {
1019 	return cxgb4_ieee_read_ets(dev, ets, 0);
1020 }
1021 
1022 /* Fill in the Application User Priority Map associated with the
1023  * specified Application.
1024  * Priority for IEEE dcb_app is an integer, with 0 being a valid value
1025  */
1026 static int cxgb4_ieee_getapp(struct net_device *dev, struct dcb_app *app)
1027 {
1028 	int prio;
1029 
1030 	if (!cxgb4_ieee_negotiation_complete(dev, CXGB4_DCB_FW_APP_ID))
1031 		return -EINVAL;
1032 	if (!(app->selector && app->protocol))
1033 		return -EINVAL;
1034 
1035 	/* Try querying firmware first, use firmware format */
1036 	prio = __cxgb4_getapp(dev, app->selector - 1, app->protocol, 0);
1037 
1038 	if (prio < 0)
1039 		prio = dcb_ieee_getapp_mask(dev, app);
1040 
1041 	app->priority = ffs(prio) - 1;
1042 	return 0;
1043 }
1044 
1045 /* Write a new Application User Priority Map for the specified Application ID.
1046  * Priority for IEEE dcb_app is an integer, with 0 being a valid value
1047  */
1048 static int cxgb4_ieee_setapp(struct net_device *dev, struct dcb_app *app)
1049 {
1050 	int ret;
1051 
1052 	if (!cxgb4_ieee_negotiation_complete(dev, CXGB4_DCB_FW_APP_ID))
1053 		return -EINVAL;
1054 	if (!(app->selector && app->protocol))
1055 		return -EINVAL;
1056 
1057 	if (!(app->selector > IEEE_8021QAZ_APP_SEL_ETHERTYPE  &&
1058 	      app->selector < IEEE_8021QAZ_APP_SEL_ANY))
1059 		return -EINVAL;
1060 
1061 	/* change selector to a format that firmware understands */
1062 	ret = __cxgb4_setapp(dev, app->selector - 1, app->protocol,
1063 			     (1 << app->priority));
1064 	if (ret)
1065 		return ret;
1066 
1067 	return dcb_ieee_setapp(dev, app);
1068 }
1069 
1070 /* Return our DCBX parameters.
1071  */
1072 static u8 cxgb4_getdcbx(struct net_device *dev)
1073 {
1074 	struct port_info *pi = netdev2pinfo(dev);
1075 
1076 	/* This is already set by cxgb4_set_dcb_caps, so just return it */
1077 	return pi->dcb.supported;
1078 }
1079 
1080 /* Set our DCBX parameters.
1081  */
1082 static u8 cxgb4_setdcbx(struct net_device *dev, u8 dcb_request)
1083 {
1084 	struct port_info *pi = netdev2pinfo(dev);
1085 
1086 	/* Filter out requests which exceed our capabilities.
1087 	 */
1088 	if ((dcb_request & (CXGB4_DCBX_FW_SUPPORT | CXGB4_DCBX_HOST_SUPPORT))
1089 	    != dcb_request)
1090 		return 1;
1091 
1092 	/* Can't enable DCB if we haven't successfully negotiated it.
1093 	 */
1094 	if (!cxgb4_dcb_state_synced(pi->dcb.state))
1095 		return 1;
1096 
1097 	/* There's currently no mechanism to allow for the firmware DCBX
1098 	 * negotiation to be changed from the Host Driver.  If the caller
1099 	 * requests exactly the same parameters that we already have then
1100 	 * we'll allow them to be successfully "set" ...
1101 	 */
1102 	if (dcb_request != pi->dcb.supported)
1103 		return 1;
1104 
1105 	pi->dcb.supported = dcb_request;
1106 	return 0;
1107 }
1108 
1109 static int cxgb4_getpeer_app(struct net_device *dev,
1110 			     struct dcb_peer_app_info *info, u16 *app_count)
1111 {
1112 	struct fw_port_cmd pcmd;
1113 	struct port_info *pi = netdev2pinfo(dev);
1114 	struct adapter *adap = pi->adapter;
1115 	int i, err = 0;
1116 
1117 	if (!cxgb4_dcb_state_synced(pi->dcb.state))
1118 		return 1;
1119 
1120 	info->willing = 0;
1121 	info->error = 0;
1122 
1123 	*app_count = 0;
1124 	for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
1125 		INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
1126 		pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
1127 		pcmd.u.dcb.app_priority.idx = *app_count;
1128 		err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
1129 
1130 		if (err != FW_PORT_DCB_CFG_SUCCESS) {
1131 			dev_err(adap->pdev_dev, "DCB app table read failed with %d\n",
1132 				-err);
1133 			return err;
1134 		}
1135 
1136 		/* find first empty slot */
1137 		if (!pcmd.u.dcb.app_priority.protocolid)
1138 			break;
1139 	}
1140 	*app_count = i;
1141 	return err;
1142 }
1143 
1144 static int cxgb4_getpeerapp_tbl(struct net_device *dev, struct dcb_app *table)
1145 {
1146 	struct fw_port_cmd pcmd;
1147 	struct port_info *pi = netdev2pinfo(dev);
1148 	struct adapter *adap = pi->adapter;
1149 	int i, err = 0;
1150 
1151 	if (!cxgb4_dcb_state_synced(pi->dcb.state))
1152 		return 1;
1153 
1154 	for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
1155 		INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
1156 		pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
1157 		pcmd.u.dcb.app_priority.idx = i;
1158 		err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
1159 
1160 		if (err != FW_PORT_DCB_CFG_SUCCESS) {
1161 			dev_err(adap->pdev_dev, "DCB app table read failed with %d\n",
1162 				-err);
1163 			return err;
1164 		}
1165 
1166 		/* find first empty slot */
1167 		if (!pcmd.u.dcb.app_priority.protocolid)
1168 			break;
1169 
1170 		table[i].selector = (pcmd.u.dcb.app_priority.sel_field + 1);
1171 		table[i].protocol =
1172 			be16_to_cpu(pcmd.u.dcb.app_priority.protocolid);
1173 		table[i].priority =
1174 			ffs(pcmd.u.dcb.app_priority.user_prio_map) - 1;
1175 	}
1176 	return err;
1177 }
1178 
1179 /* Return Priority Group information.
1180  */
1181 static int cxgb4_cee_peer_getpg(struct net_device *dev, struct cee_pg *pg)
1182 {
1183 	struct fw_port_cmd pcmd;
1184 	struct port_info *pi = netdev2pinfo(dev);
1185 	struct adapter *adap = pi->adapter;
1186 	u32 pgid;
1187 	int i, err;
1188 
1189 	/* We're always "willing" -- the Switch Fabric always dictates the
1190 	 * DCBX parameters to us.
1191 	 */
1192 	pg->willing = true;
1193 
1194 	INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
1195 	pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
1196 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
1197 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
1198 		dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
1199 		return err;
1200 	}
1201 	pgid = be32_to_cpu(pcmd.u.dcb.pgid.pgid);
1202 
1203 	for (i = 0; i < CXGB4_MAX_PRIORITY; i++)
1204 		pg->prio_pg[7 - i] = (pgid >> (i * 4)) & 0xF;
1205 
1206 	INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
1207 	pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
1208 	err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
1209 	if (err != FW_PORT_DCB_CFG_SUCCESS) {
1210 		dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
1211 			-err);
1212 		return err;
1213 	}
1214 
1215 	for (i = 0; i < CXGB4_MAX_PRIORITY; i++)
1216 		pg->pg_bw[i] = pcmd.u.dcb.pgrate.pgrate[i];
1217 
1218 	pg->tcs_supported = pcmd.u.dcb.pgrate.num_tcs_supported;
1219 
1220 	return 0;
1221 }
1222 
1223 /* Return Priority Flow Control information.
1224  */
1225 static int cxgb4_cee_peer_getpfc(struct net_device *dev, struct cee_pfc *pfc)
1226 {
1227 	struct port_info *pi = netdev2pinfo(dev);
1228 
1229 	cxgb4_getnumtcs(dev, DCB_NUMTCS_ATTR_PFC, &(pfc->tcs_supported));
1230 
1231 	/* Firmware sends this to us in a formwat that is a bit flipped version
1232 	 * of spec, correct it before we send it to host. This is taken care of
1233 	 * by bit shifting in other uses of pfcen
1234 	 */
1235 	pfc->pfc_en = bitswap_1(pi->dcb.pfcen);
1236 
1237 	pfc->tcs_supported = pi->dcb.pfc_num_tcs_supported;
1238 
1239 	return 0;
1240 }
1241 
1242 const struct dcbnl_rtnl_ops cxgb4_dcb_ops = {
1243 	.ieee_getets		= cxgb4_ieee_get_ets,
1244 	.ieee_getpfc		= cxgb4_ieee_get_pfc,
1245 	.ieee_getapp		= cxgb4_ieee_getapp,
1246 	.ieee_setapp		= cxgb4_ieee_setapp,
1247 	.ieee_peer_getets	= cxgb4_ieee_peer_ets,
1248 	.ieee_peer_getpfc	= cxgb4_ieee_get_pfc,
1249 
1250 	/* CEE std */
1251 	.getstate		= cxgb4_getstate,
1252 	.setstate		= cxgb4_setstate,
1253 	.getpgtccfgtx		= cxgb4_getpgtccfg_tx,
1254 	.getpgbwgcfgtx		= cxgb4_getpgbwgcfg_tx,
1255 	.getpgtccfgrx		= cxgb4_getpgtccfg_rx,
1256 	.getpgbwgcfgrx		= cxgb4_getpgbwgcfg_rx,
1257 	.setpgtccfgtx		= cxgb4_setpgtccfg_tx,
1258 	.setpgbwgcfgtx		= cxgb4_setpgbwgcfg_tx,
1259 	.setpfccfg		= cxgb4_setpfccfg,
1260 	.getpfccfg		= cxgb4_getpfccfg,
1261 	.setall			= cxgb4_setall,
1262 	.getcap			= cxgb4_getcap,
1263 	.getnumtcs		= cxgb4_getnumtcs,
1264 	.setnumtcs		= cxgb4_setnumtcs,
1265 	.getpfcstate		= cxgb4_getpfcstate,
1266 	.setpfcstate		= cxgb4_setpfcstate,
1267 	.getapp			= cxgb4_getapp,
1268 	.setapp			= cxgb4_setapp,
1269 
1270 	/* DCBX configuration */
1271 	.getdcbx		= cxgb4_getdcbx,
1272 	.setdcbx		= cxgb4_setdcbx,
1273 
1274 	/* peer apps */
1275 	.peer_getappinfo	= cxgb4_getpeer_app,
1276 	.peer_getapptable	= cxgb4_getpeerapp_tbl,
1277 
1278 	/* CEE peer */
1279 	.cee_peer_getpg		= cxgb4_cee_peer_getpg,
1280 	.cee_peer_getpfc	= cxgb4_cee_peer_getpfc,
1281 };
1282