ixgbe: DCB, abstract out dcb_config from DCB hardware configuration
[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  * @rx_pba: method to distribute packet buffer
37  *
38  * Configure packet buffers for DCB mode.
39  */
40 static s32 ixgbe_dcb_config_packet_buffers_82599(struct ixgbe_hw *hw, u8 rx_pba)
41 {
42         s32 ret_val = 0;
43         u32 value = IXGBE_RXPBSIZE_64KB;
44         u8  i = 0;
45
46         /* Setup Rx packet buffer sizes */
47         switch (rx_pba) {
48         case pba_80_48:
49                 /* Setup the first four at 80KB */
50                 value = IXGBE_RXPBSIZE_80KB;
51                 for (; i < 4; i++)
52                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), value);
53                 /* Setup the last four at 48KB...don't re-init i */
54                 value = IXGBE_RXPBSIZE_48KB;
55                 /* Fall Through */
56         case pba_equal:
57         default:
58                 for (; i < IXGBE_MAX_PACKET_BUFFERS; i++)
59                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), value);
60
61                 /* Setup Tx packet buffer sizes */
62                 for (i = 0; i < IXGBE_MAX_PACKET_BUFFERS; i++) {
63                         IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i),
64                                         IXGBE_TXPBSIZE_20KB);
65                         IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i),
66                                         IXGBE_TXPBTHRESH_DCB);
67                 }
68                 break;
69         }
70
71         return ret_val;
72 }
73
74 /**
75  * ixgbe_dcb_config_rx_arbiter_82599 - Config Rx Data arbiter
76  * @hw: pointer to hardware structure
77  * @refill: refill credits index by traffic class
78  * @max: max credits index by traffic class
79  * @bwg_id: bandwidth grouping indexed by traffic class
80  * @prio_type: priority type indexed by traffic class
81  *
82  * Configure Rx Packet Arbiter and credits for each traffic class.
83  */
84 s32 ixgbe_dcb_config_rx_arbiter_82599(struct ixgbe_hw *hw,
85                                       u16 *refill,
86                                       u16 *max,
87                                       u8 *bwg_id,
88                                       u8 *prio_type)
89 {
90         u32    reg           = 0;
91         u32    credit_refill = 0;
92         u32    credit_max    = 0;
93         u8     i             = 0;
94
95         /*
96          * Disable the arbiter before changing parameters
97          * (always enable recycle mode; WSP)
98          */
99         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC | IXGBE_RTRPCS_ARBDIS;
100         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
101
102         /* Map all traffic classes to their UP, 1 to 1 */
103         reg = 0;
104         for (i = 0; i < MAX_TRAFFIC_CLASS; i++)
105                 reg |= (i << (i * IXGBE_RTRUP2TC_UP_SHIFT));
106         IXGBE_WRITE_REG(hw, IXGBE_RTRUP2TC, reg);
107
108         /* Configure traffic class credits and priority */
109         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
110                 credit_refill = refill[i];
111                 credit_max    = max[i];
112                 reg = credit_refill | (credit_max << IXGBE_RTRPT4C_MCL_SHIFT);
113
114                 reg |= (u32)(bwg_id[i]) << IXGBE_RTRPT4C_BWG_SHIFT;
115
116                 if (prio_type[i] == prio_link)
117                         reg |= IXGBE_RTRPT4C_LSP;
118
119                 IXGBE_WRITE_REG(hw, IXGBE_RTRPT4C(i), reg);
120         }
121
122         /*
123          * Configure Rx packet plane (recycle mode; WSP) and
124          * enable arbiter
125          */
126         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC;
127         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
128
129         return 0;
130 }
131
132 /**
133  * ixgbe_dcb_config_tx_desc_arbiter_82599 - Config Tx Desc. arbiter
134  * @hw: pointer to hardware structure
135  * @refill: refill credits index by traffic class
136  * @max: max credits index by traffic class
137  * @bwg_id: bandwidth grouping indexed by traffic class
138  * @prio_type: priority type indexed by traffic class
139  *
140  * Configure Tx Descriptor Arbiter and credits for each traffic class.
141  */
142 s32 ixgbe_dcb_config_tx_desc_arbiter_82599(struct ixgbe_hw *hw,
143                                            u16 *refill,
144                                            u16 *max,
145                                            u8 *bwg_id,
146                                            u8 *prio_type)
147 {
148         u32    reg, max_credits;
149         u8     i;
150
151         /* Clear the per-Tx queue credits; we use per-TC instead */
152         for (i = 0; i < 128; i++) {
153                 IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, i);
154                 IXGBE_WRITE_REG(hw, IXGBE_RTTDT1C, 0);
155         }
156
157         /* Configure traffic class credits and priority */
158         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
159                 max_credits = max[i];
160                 reg = max_credits << IXGBE_RTTDT2C_MCL_SHIFT;
161                 reg |= refill[i];
162                 reg |= (u32)(bwg_id[i]) << IXGBE_RTTDT2C_BWG_SHIFT;
163
164                 if (prio_type[i] == prio_group)
165                         reg |= IXGBE_RTTDT2C_GSP;
166
167                 if (prio_type[i] == prio_link)
168                         reg |= IXGBE_RTTDT2C_LSP;
169
170                 IXGBE_WRITE_REG(hw, IXGBE_RTTDT2C(i), reg);
171         }
172
173         /*
174          * Configure Tx descriptor plane (recycle mode; WSP) and
175          * enable arbiter
176          */
177         reg = IXGBE_RTTDCS_TDPAC | IXGBE_RTTDCS_TDRM;
178         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
179
180         return 0;
181 }
182
183 /**
184  * ixgbe_dcb_config_tx_data_arbiter_82599 - Config Tx Data arbiter
185  * @hw: pointer to hardware structure
186  * @refill: refill credits index by traffic class
187  * @max: max credits index by traffic class
188  * @bwg_id: bandwidth grouping indexed by traffic class
189  * @prio_type: priority type indexed by traffic class
190  *
191  * Configure Tx Packet Arbiter and credits for each traffic class.
192  */
193 s32 ixgbe_dcb_config_tx_data_arbiter_82599(struct ixgbe_hw *hw,
194                                            u16 *refill,
195                                            u16 *max,
196                                            u8 *bwg_id,
197                                            u8 *prio_type)
198 {
199         u32 reg;
200         u8 i;
201
202         /*
203          * Disable the arbiter before changing parameters
204          * (always enable recycle mode; SP; arb delay)
205          */
206         reg = IXGBE_RTTPCS_TPPAC | IXGBE_RTTPCS_TPRM |
207               (IXGBE_RTTPCS_ARBD_DCB << IXGBE_RTTPCS_ARBD_SHIFT) |
208               IXGBE_RTTPCS_ARBDIS;
209         IXGBE_WRITE_REG(hw, IXGBE_RTTPCS, reg);
210
211         /* Map all traffic classes to their UP, 1 to 1 */
212         reg = 0;
213         for (i = 0; i < MAX_TRAFFIC_CLASS; i++)
214                 reg |= (i << (i * IXGBE_RTTUP2TC_UP_SHIFT));
215         IXGBE_WRITE_REG(hw, IXGBE_RTTUP2TC, reg);
216
217         /* Configure traffic class credits and priority */
218         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
219                 reg = refill[i];
220                 reg |= (u32)(max[i]) << IXGBE_RTTPT2C_MCL_SHIFT;
221                 reg |= (u32)(bwg_id[i]) << IXGBE_RTTPT2C_BWG_SHIFT;
222
223                 if (prio_type[i] == prio_group)
224                         reg |= IXGBE_RTTPT2C_GSP;
225
226                 if (prio_type[i] == prio_link)
227                         reg |= IXGBE_RTTPT2C_LSP;
228
229                 IXGBE_WRITE_REG(hw, IXGBE_RTTPT2C(i), reg);
230         }
231
232         /*
233          * Configure Tx packet plane (recycle mode; SP; arb delay) and
234          * enable arbiter
235          */
236         reg = IXGBE_RTTPCS_TPPAC | IXGBE_RTTPCS_TPRM |
237               (IXGBE_RTTPCS_ARBD_DCB << IXGBE_RTTPCS_ARBD_SHIFT);
238         IXGBE_WRITE_REG(hw, IXGBE_RTTPCS, reg);
239
240         return 0;
241 }
242
243 /**
244  * ixgbe_dcb_config_pfc_82599 - Configure priority flow control
245  * @hw: pointer to hardware structure
246  * @pfc_en: enabled pfc bitmask
247  *
248  * Configure Priority Flow Control (PFC) for each traffic class.
249  */
250 s32 ixgbe_dcb_config_pfc_82599(struct ixgbe_hw *hw, u8 pfc_en)
251 {
252         u32 i, reg, rx_pba_size;
253
254         /* If PFC is disabled globally then fall back to LFC. */
255         if (!pfc_en) {
256                 for (i = 0; i < MAX_TRAFFIC_CLASS; i++)
257                         hw->mac.ops.fc_enable(hw, i);
258                 goto out;
259         }
260
261         /* Configure PFC Tx thresholds per TC */
262         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
263                 int enabled = pfc_en & (1 << i);
264                 rx_pba_size = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(i));
265                 rx_pba_size >>= IXGBE_RXPBSIZE_SHIFT;
266
267                 reg = (rx_pba_size - hw->fc.low_water) << 10;
268
269                 if (enabled)
270                         reg |= IXGBE_FCRTL_XONE;
271                 IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), reg);
272
273                 reg = (rx_pba_size - hw->fc.high_water) << 10;
274                 if (enabled)
275                         reg |= IXGBE_FCRTH_FCEN;
276                 IXGBE_WRITE_REG(hw, IXGBE_FCRTH_82599(i), reg);
277         }
278
279         /* Configure pause time (2 TCs per register) */
280         reg = hw->fc.pause_time | (hw->fc.pause_time << 16);
281         for (i = 0; i < (MAX_TRAFFIC_CLASS / 2); i++)
282                 IXGBE_WRITE_REG(hw, IXGBE_FCTTV(i), reg);
283
284         /* Configure flow control refresh threshold value */
285         IXGBE_WRITE_REG(hw, IXGBE_FCRTV, hw->fc.pause_time / 2);
286
287         /* Enable Transmit PFC */
288         reg = IXGBE_FCCFG_TFCE_PRIORITY;
289         IXGBE_WRITE_REG(hw, IXGBE_FCCFG, reg);
290
291         /*
292          * Enable Receive PFC
293          * We will always honor XOFF frames we receive when
294          * we are in PFC mode.
295          */
296         reg = IXGBE_READ_REG(hw, IXGBE_MFLCN);
297         reg &= ~IXGBE_MFLCN_RFCE;
298         reg |= IXGBE_MFLCN_RPFCE | IXGBE_MFLCN_DPF;
299         IXGBE_WRITE_REG(hw, IXGBE_MFLCN, reg);
300 out:
301         return 0;
302 }
303
304 /**
305  * ixgbe_dcb_config_tc_stats_82599 - Config traffic class statistics
306  * @hw: pointer to hardware structure
307  *
308  * Configure queue statistics registers, all queues belonging to same traffic
309  * class uses a single set of queue statistics counters.
310  */
311 static s32 ixgbe_dcb_config_tc_stats_82599(struct ixgbe_hw *hw)
312 {
313         u32 reg = 0;
314         u8  i   = 0;
315
316         /*
317          * Receive Queues stats setting
318          * 32 RQSMR registers, each configuring 4 queues.
319          * Set all 16 queues of each TC to the same stat
320          * with TC 'n' going to stat 'n'.
321          */
322         for (i = 0; i < 32; i++) {
323                 reg = 0x01010101 * (i / 4);
324                 IXGBE_WRITE_REG(hw, IXGBE_RQSMR(i), reg);
325         }
326         /*
327          * Transmit Queues stats setting
328          * 32 TQSM registers, each controlling 4 queues.
329          * Set all queues of each TC to the same stat
330          * with TC 'n' going to stat 'n'.
331          * Tx queues are allocated non-uniformly to TCs:
332          * 32, 32, 16, 16, 8, 8, 8, 8.
333          */
334         for (i = 0; i < 32; i++) {
335                 if (i < 8)
336                         reg = 0x00000000;
337                 else if (i < 16)
338                         reg = 0x01010101;
339                 else if (i < 20)
340                         reg = 0x02020202;
341                 else if (i < 24)
342                         reg = 0x03030303;
343                 else if (i < 26)
344                         reg = 0x04040404;
345                 else if (i < 28)
346                         reg = 0x05050505;
347                 else if (i < 30)
348                         reg = 0x06060606;
349                 else
350                         reg = 0x07070707;
351                 IXGBE_WRITE_REG(hw, IXGBE_TQSM(i), reg);
352         }
353
354         return 0;
355 }
356
357 /**
358  * ixgbe_dcb_config_82599 - Configure general DCB parameters
359  * @hw: pointer to hardware structure
360  *
361  * Configure general DCB parameters.
362  */
363 static s32 ixgbe_dcb_config_82599(struct ixgbe_hw *hw)
364 {
365         u32 reg;
366         u32 q;
367
368         /* Disable the Tx desc arbiter so that MTQC can be changed */
369         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
370         reg |= IXGBE_RTTDCS_ARBDIS;
371         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
372
373         /* Enable DCB for Rx with 8 TCs */
374         reg = IXGBE_READ_REG(hw, IXGBE_MRQC);
375         switch (reg & IXGBE_MRQC_MRQE_MASK) {
376         case 0:
377         case IXGBE_MRQC_RT4TCEN:
378                 /* RSS disabled cases */
379                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) | IXGBE_MRQC_RT8TCEN;
380                 break;
381         case IXGBE_MRQC_RSSEN:
382         case IXGBE_MRQC_RTRSS4TCEN:
383                 /* RSS enabled cases */
384                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) | IXGBE_MRQC_RTRSS8TCEN;
385                 break;
386         default:
387                 /* Unsupported value, assume stale data, overwrite no RSS */
388                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) | IXGBE_MRQC_RT8TCEN;
389         }
390         IXGBE_WRITE_REG(hw, IXGBE_MRQC, reg);
391
392         /* Enable DCB for Tx with 8 TCs */
393         reg = IXGBE_MTQC_RT_ENA | IXGBE_MTQC_8TC_8TQ;
394         IXGBE_WRITE_REG(hw, IXGBE_MTQC, reg);
395
396         /* Disable drop for all queues */
397         for (q = 0; q < 128; q++)
398                 IXGBE_WRITE_REG(hw, IXGBE_QDE, q << IXGBE_QDE_IDX_SHIFT);
399
400         /* Enable the Tx desc arbiter */
401         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
402         reg &= ~IXGBE_RTTDCS_ARBDIS;
403         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
404
405         /* Enable Security TX Buffer IFG for DCB */
406         reg = IXGBE_READ_REG(hw, IXGBE_SECTXMINIFG);
407         reg |= IXGBE_SECTX_DCB;
408         IXGBE_WRITE_REG(hw, IXGBE_SECTXMINIFG, reg);
409
410         return 0;
411 }
412
413 /**
414  * ixgbe_dcb_hw_config_82599 - Configure and enable DCB
415  * @hw: pointer to hardware structure
416  * @rx_pba: method to distribute packet buffer
417  * @refill: refill credits index by traffic class
418  * @max: max credits index by traffic class
419  * @bwg_id: bandwidth grouping indexed by traffic class
420  * @prio_type: priority type indexed by traffic class
421  * @pfc_en: enabled pfc bitmask
422  *
423  * Configure dcb settings and enable dcb mode.
424  */
425 s32 ixgbe_dcb_hw_config_82599(struct ixgbe_hw *hw,
426                               u8 rx_pba, u8 pfc_en, u16 *refill,
427                               u16 *max, u8 *bwg_id, u8 *prio_type)
428 {
429         ixgbe_dcb_config_packet_buffers_82599(hw, rx_pba);
430         ixgbe_dcb_config_82599(hw);
431         ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwg_id, prio_type);
432         ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max,
433                                                bwg_id, prio_type);
434         ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max,
435                                                bwg_id, prio_type);
436         ixgbe_dcb_config_pfc_82599(hw, pfc_en);
437         ixgbe_dcb_config_tc_stats_82599(hw);
438
439         return 0;
440 }
441