374e1f74d0f51c20bbfe6e245d8500f90a015dab
[linux-2.6.git] / drivers / net / ixgbe / ixgbe_dcb_82599.c
1 /*******************************************************************************
2
3   Intel 10 Gigabit PCI Express Linux driver
4   Copyright(c) 1999 - 2010 Intel Corporation.
5
6   This program is free software; you can redistribute it and/or modify it
7   under the terms and conditions of the GNU General Public License,
8   version 2, as published by the Free Software Foundation.
9
10   This program is distributed in the hope it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13   more details.
14
15   You should have received a copy of the GNU General Public License along with
16   this program; if not, write to the Free Software Foundation, Inc.,
17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18
19   The full GNU General Public License is included in this distribution in
20   the file called "COPYING".
21
22   Contact Information:
23   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
24   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
25
26 *******************************************************************************/
27
28 #include "ixgbe.h"
29 #include "ixgbe_type.h"
30 #include "ixgbe_dcb.h"
31 #include "ixgbe_dcb_82599.h"
32
33 /**
34  * ixgbe_dcb_config_packet_buffers_82599 - Configure DCB packet buffers
35  * @hw: pointer to hardware structure
36  * @dcb_config: pointer to ixgbe_dcb_config structure
37  *
38  * Configure packet buffers for DCB mode.
39  */
40 static s32 ixgbe_dcb_config_packet_buffers_82599(struct ixgbe_hw *hw,
41                                           struct ixgbe_dcb_config *dcb_config)
42 {
43         s32 ret_val = 0;
44         u32 value = IXGBE_RXPBSIZE_64KB;
45         u8  i = 0;
46
47         /* Setup Rx packet buffer sizes */
48         switch (dcb_config->rx_pba_cfg) {
49         case pba_80_48:
50                 /* Setup the first four at 80KB */
51                 value = IXGBE_RXPBSIZE_80KB;
52                 for (; i < 4; i++)
53                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), value);
54                 /* Setup the last four at 48KB...don't re-init i */
55                 value = IXGBE_RXPBSIZE_48KB;
56                 /* Fall Through */
57         case pba_equal:
58         default:
59                 for (; i < IXGBE_MAX_PACKET_BUFFERS; i++)
60                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), value);
61
62                 /* Setup Tx packet buffer sizes */
63                 for (i = 0; i < IXGBE_MAX_PACKET_BUFFERS; i++) {
64                         IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i),
65                                         IXGBE_TXPBSIZE_20KB);
66                         IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i),
67                                         IXGBE_TXPBTHRESH_DCB);
68                 }
69                 break;
70         }
71
72         return ret_val;
73 }
74
75 /**
76  * ixgbe_dcb_config_rx_arbiter_82599 - Config Rx Data arbiter
77  * @hw: pointer to hardware structure
78  * @dcb_config: pointer to ixgbe_dcb_config structure
79  *
80  * Configure Rx Packet Arbiter and credits for each traffic class.
81  */
82 static s32 ixgbe_dcb_config_rx_arbiter_82599(struct ixgbe_hw *hw,
83                                       struct ixgbe_dcb_config *dcb_config)
84 {
85         struct tc_bw_alloc    *p;
86         u32    reg           = 0;
87         u32    credit_refill = 0;
88         u32    credit_max    = 0;
89         u8     i             = 0;
90
91         /*
92          * Disable the arbiter before changing parameters
93          * (always enable recycle mode; WSP)
94          */
95         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC | IXGBE_RTRPCS_ARBDIS;
96         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
97
98         /* Map all traffic classes to their UP, 1 to 1 */
99         reg = 0;
100         for (i = 0; i < MAX_TRAFFIC_CLASS; i++)
101                 reg |= (i << (i * IXGBE_RTRUP2TC_UP_SHIFT));
102         IXGBE_WRITE_REG(hw, IXGBE_RTRUP2TC, reg);
103
104         /* Configure traffic class credits and priority */
105         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
106                 p = &dcb_config->tc_config[i].path[DCB_RX_CONFIG];
107
108                 credit_refill = p->data_credits_refill;
109                 credit_max    = p->data_credits_max;
110                 reg = credit_refill | (credit_max << IXGBE_RTRPT4C_MCL_SHIFT);
111
112                 reg |= (u32)(p->bwg_id) << IXGBE_RTRPT4C_BWG_SHIFT;
113
114                 if (p->prio_type == prio_link)
115                         reg |= IXGBE_RTRPT4C_LSP;
116
117                 IXGBE_WRITE_REG(hw, IXGBE_RTRPT4C(i), reg);
118         }
119
120         /*
121          * Configure Rx packet plane (recycle mode; WSP) and
122          * enable arbiter
123          */
124         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC;
125         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
126
127         return 0;
128 }
129
130 /**
131  * ixgbe_dcb_config_tx_desc_arbiter_82599 - Config Tx Desc. arbiter
132  * @hw: pointer to hardware structure
133  * @dcb_config: pointer to ixgbe_dcb_config structure
134  *
135  * Configure Tx Descriptor Arbiter and credits for each traffic class.
136  */
137 static s32 ixgbe_dcb_config_tx_desc_arbiter_82599(struct ixgbe_hw *hw,
138                                            struct ixgbe_dcb_config *dcb_config)
139 {
140         struct tc_bw_alloc *p;
141         u32    reg, max_credits;
142         u8     i;
143
144         /* Clear the per-Tx queue credits; we use per-TC instead */
145         for (i = 0; i < 128; i++) {
146                 IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, i);
147                 IXGBE_WRITE_REG(hw, IXGBE_RTTDT1C, 0);
148         }
149
150         /* Configure traffic class credits and priority */
151         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
152                 p = &dcb_config->tc_config[i].path[DCB_TX_CONFIG];
153                 max_credits = dcb_config->tc_config[i].desc_credits_max;
154                 reg = max_credits << IXGBE_RTTDT2C_MCL_SHIFT;
155                 reg |= p->data_credits_refill;
156                 reg |= (u32)(p->bwg_id) << IXGBE_RTTDT2C_BWG_SHIFT;
157
158                 if (p->prio_type == prio_group)
159                         reg |= IXGBE_RTTDT2C_GSP;
160
161                 if (p->prio_type == prio_link)
162                         reg |= IXGBE_RTTDT2C_LSP;
163
164                 IXGBE_WRITE_REG(hw, IXGBE_RTTDT2C(i), reg);
165         }
166
167         /*
168          * Configure Tx descriptor plane (recycle mode; WSP) and
169          * enable arbiter
170          */
171         reg = IXGBE_RTTDCS_TDPAC | IXGBE_RTTDCS_TDRM;
172         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
173
174         return 0;
175 }
176
177 /**
178  * ixgbe_dcb_config_tx_data_arbiter_82599 - Config Tx Data arbiter
179  * @hw: pointer to hardware structure
180  * @dcb_config: pointer to ixgbe_dcb_config structure
181  *
182  * Configure Tx Packet Arbiter and credits for each traffic class.
183  */
184 static s32 ixgbe_dcb_config_tx_data_arbiter_82599(struct ixgbe_hw *hw,
185                                            struct ixgbe_dcb_config *dcb_config)
186 {
187         struct tc_bw_alloc *p;
188         u32 reg;
189         u8 i;
190
191         /*
192          * Disable the arbiter before changing parameters
193          * (always enable recycle mode; SP; arb delay)
194          */
195         reg = IXGBE_RTTPCS_TPPAC | IXGBE_RTTPCS_TPRM |
196               (IXGBE_RTTPCS_ARBD_DCB << IXGBE_RTTPCS_ARBD_SHIFT) |
197               IXGBE_RTTPCS_ARBDIS;
198         IXGBE_WRITE_REG(hw, IXGBE_RTTPCS, reg);
199
200         /* Map all traffic classes to their UP, 1 to 1 */
201         reg = 0;
202         for (i = 0; i < MAX_TRAFFIC_CLASS; i++)
203                 reg |= (i << (i * IXGBE_RTTUP2TC_UP_SHIFT));
204         IXGBE_WRITE_REG(hw, IXGBE_RTTUP2TC, reg);
205
206         /* Configure traffic class credits and priority */
207         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
208                 p = &dcb_config->tc_config[i].path[DCB_TX_CONFIG];
209                 reg = p->data_credits_refill;
210                 reg |= (u32)(p->data_credits_max) << IXGBE_RTTPT2C_MCL_SHIFT;
211                 reg |= (u32)(p->bwg_id) << IXGBE_RTTPT2C_BWG_SHIFT;
212
213                 if (p->prio_type == prio_group)
214                         reg |= IXGBE_RTTPT2C_GSP;
215
216                 if (p->prio_type == prio_link)
217                         reg |= IXGBE_RTTPT2C_LSP;
218
219                 IXGBE_WRITE_REG(hw, IXGBE_RTTPT2C(i), reg);
220         }
221
222         /*
223          * Configure Tx packet plane (recycle mode; SP; arb delay) and
224          * enable arbiter
225          */
226         reg = IXGBE_RTTPCS_TPPAC | IXGBE_RTTPCS_TPRM |
227               (IXGBE_RTTPCS_ARBD_DCB << IXGBE_RTTPCS_ARBD_SHIFT);
228         IXGBE_WRITE_REG(hw, IXGBE_RTTPCS, reg);
229
230         return 0;
231 }
232
233 /**
234  * ixgbe_dcb_config_pfc_82599 - Configure priority flow control
235  * @hw: pointer to hardware structure
236  * @dcb_config: pointer to ixgbe_dcb_config structure
237  *
238  * Configure Priority Flow Control (PFC) for each traffic class.
239  */
240 s32 ixgbe_dcb_config_pfc_82599(struct ixgbe_hw *hw,
241                                struct ixgbe_dcb_config *dcb_config)
242 {
243         u32 i, reg, rx_pba_size;
244
245         /* If PFC is disabled globally then fall back to LFC. */
246         if (!dcb_config->pfc_mode_enable) {
247                 for (i = 0; i < MAX_TRAFFIC_CLASS; i++)
248                         hw->mac.ops.fc_enable(hw, i);
249                 goto out;
250         }
251
252         /* Configure PFC Tx thresholds per TC */
253         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
254                 rx_pba_size = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(i));
255                 rx_pba_size >>= IXGBE_RXPBSIZE_SHIFT;
256
257                 reg = (rx_pba_size - hw->fc.low_water) << 10;
258
259                 if (dcb_config->tc_config[i].dcb_pfc == pfc_enabled_full ||
260                     dcb_config->tc_config[i].dcb_pfc == pfc_enabled_tx)
261                         reg |= IXGBE_FCRTL_XONE;
262                 IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), reg);
263
264                 reg = (rx_pba_size - hw->fc.high_water) << 10;
265                 if (dcb_config->tc_config[i].dcb_pfc == pfc_enabled_full ||
266                     dcb_config->tc_config[i].dcb_pfc == pfc_enabled_tx)
267                         reg |= IXGBE_FCRTH_FCEN;
268                 IXGBE_WRITE_REG(hw, IXGBE_FCRTH_82599(i), reg);
269         }
270
271         /* Configure pause time (2 TCs per register) */
272         reg = hw->fc.pause_time | (hw->fc.pause_time << 16);
273         for (i = 0; i < (MAX_TRAFFIC_CLASS / 2); i++)
274                 IXGBE_WRITE_REG(hw, IXGBE_FCTTV(i), reg);
275
276         /* Configure flow control refresh threshold value */
277         IXGBE_WRITE_REG(hw, IXGBE_FCRTV, hw->fc.pause_time / 2);
278
279         /* Enable Transmit PFC */
280         reg = IXGBE_FCCFG_TFCE_PRIORITY;
281         IXGBE_WRITE_REG(hw, IXGBE_FCCFG, reg);
282
283         /*
284          * Enable Receive PFC
285          * We will always honor XOFF frames we receive when
286          * we are in PFC mode.
287          */
288         reg = IXGBE_READ_REG(hw, IXGBE_MFLCN);
289         reg &= ~IXGBE_MFLCN_RFCE;
290         reg |= IXGBE_MFLCN_RPFCE | IXGBE_MFLCN_DPF;
291         IXGBE_WRITE_REG(hw, IXGBE_MFLCN, reg);
292 out:
293         return 0;
294 }
295
296 /**
297  * ixgbe_dcb_config_tc_stats_82599 - Config traffic class statistics
298  * @hw: pointer to hardware structure
299  *
300  * Configure queue statistics registers, all queues belonging to same traffic
301  * class uses a single set of queue statistics counters.
302  */
303 static s32 ixgbe_dcb_config_tc_stats_82599(struct ixgbe_hw *hw)
304 {
305         u32 reg = 0;
306         u8  i   = 0;
307
308         /*
309          * Receive Queues stats setting
310          * 32 RQSMR registers, each configuring 4 queues.
311          * Set all 16 queues of each TC to the same stat
312          * with TC 'n' going to stat 'n'.
313          */
314         for (i = 0; i < 32; i++) {
315                 reg = 0x01010101 * (i / 4);
316                 IXGBE_WRITE_REG(hw, IXGBE_RQSMR(i), reg);
317         }
318         /*
319          * Transmit Queues stats setting
320          * 32 TQSM registers, each controlling 4 queues.
321          * Set all queues of each TC to the same stat
322          * with TC 'n' going to stat 'n'.
323          * Tx queues are allocated non-uniformly to TCs:
324          * 32, 32, 16, 16, 8, 8, 8, 8.
325          */
326         for (i = 0; i < 32; i++) {
327                 if (i < 8)
328                         reg = 0x00000000;
329                 else if (i < 16)
330                         reg = 0x01010101;
331                 else if (i < 20)
332                         reg = 0x02020202;
333                 else if (i < 24)
334                         reg = 0x03030303;
335                 else if (i < 26)
336                         reg = 0x04040404;
337                 else if (i < 28)
338                         reg = 0x05050505;
339                 else if (i < 30)
340                         reg = 0x06060606;
341                 else
342                         reg = 0x07070707;
343                 IXGBE_WRITE_REG(hw, IXGBE_TQSM(i), reg);
344         }
345
346         return 0;
347 }
348
349 /**
350  * ixgbe_dcb_config_82599 - Configure general DCB parameters
351  * @hw: pointer to hardware structure
352  * @dcb_config: pointer to ixgbe_dcb_config structure
353  *
354  * Configure general DCB parameters.
355  */
356 static s32 ixgbe_dcb_config_82599(struct ixgbe_hw *hw)
357 {
358         u32 reg;
359         u32 q;
360
361         /* Disable the Tx desc arbiter so that MTQC can be changed */
362         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
363         reg |= IXGBE_RTTDCS_ARBDIS;
364         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
365
366         /* Enable DCB for Rx with 8 TCs */
367         reg = IXGBE_READ_REG(hw, IXGBE_MRQC);
368         switch (reg & IXGBE_MRQC_MRQE_MASK) {
369         case 0:
370         case IXGBE_MRQC_RT4TCEN:
371                 /* RSS disabled cases */
372                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) | IXGBE_MRQC_RT8TCEN;
373                 break;
374         case IXGBE_MRQC_RSSEN:
375         case IXGBE_MRQC_RTRSS4TCEN:
376                 /* RSS enabled cases */
377                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) | IXGBE_MRQC_RTRSS8TCEN;
378                 break;
379         default:
380                 /* Unsupported value, assume stale data, overwrite no RSS */
381                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) | IXGBE_MRQC_RT8TCEN;
382         }
383         IXGBE_WRITE_REG(hw, IXGBE_MRQC, reg);
384
385         /* Enable DCB for Tx with 8 TCs */
386         reg = IXGBE_MTQC_RT_ENA | IXGBE_MTQC_8TC_8TQ;
387         IXGBE_WRITE_REG(hw, IXGBE_MTQC, reg);
388
389         /* Disable drop for all queues */
390         for (q = 0; q < 128; q++)
391                 IXGBE_WRITE_REG(hw, IXGBE_QDE, q << IXGBE_QDE_IDX_SHIFT);
392
393         /* Enable the Tx desc arbiter */
394         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
395         reg &= ~IXGBE_RTTDCS_ARBDIS;
396         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
397
398         /* Enable Security TX Buffer IFG for DCB */
399         reg = IXGBE_READ_REG(hw, IXGBE_SECTXMINIFG);
400         reg |= IXGBE_SECTX_DCB;
401         IXGBE_WRITE_REG(hw, IXGBE_SECTXMINIFG, reg);
402
403         return 0;
404 }
405
406 /**
407  * ixgbe_dcb_hw_config_82599 - Configure and enable DCB
408  * @hw: pointer to hardware structure
409  * @dcb_config: pointer to ixgbe_dcb_config structure
410  *
411  * Configure dcb settings and enable dcb mode.
412  */
413 s32 ixgbe_dcb_hw_config_82599(struct ixgbe_hw *hw,
414                               struct ixgbe_dcb_config *dcb_config)
415 {
416         ixgbe_dcb_config_packet_buffers_82599(hw, dcb_config);
417         ixgbe_dcb_config_82599(hw);
418         ixgbe_dcb_config_rx_arbiter_82599(hw, dcb_config);
419         ixgbe_dcb_config_tx_desc_arbiter_82599(hw, dcb_config);
420         ixgbe_dcb_config_tx_data_arbiter_82599(hw, dcb_config);
421         ixgbe_dcb_config_pfc_82599(hw, dcb_config);
422         ixgbe_dcb_config_tc_stats_82599(hw);
423
424         return 0;
425 }
426