?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / net / ethernet / chelsio / cxgb4 / cxgb4_dcb.c
blob4a872f328fea7c3b3aa36e749163a8f354db6b3d
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 };
Linux with added FPC-III support