2 * Copyright (c) 2018, Mellanox Technologies. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 #include "port_buffer.h"
34 int mlx5e_port_query_buffer(struct mlx5e_priv *priv,
35 struct mlx5e_port_buffer *port_buffer)
37 u16 port_buff_cell_sz = priv->dcbx.port_buff_cell_sz;
38 struct mlx5_core_dev *mdev = priv->mdev;
39 int sz = MLX5_ST_SZ_BYTES(pbmc_reg);
46 out = kzalloc(sz, GFP_KERNEL);
50 err = mlx5e_port_query_pbmc(mdev, out);
54 for (i = 0; i < MLX5E_MAX_BUFFER; i++) {
55 buffer = MLX5_ADDR_OF(pbmc_reg, out, buffer[i]);
56 port_buffer->buffer[i].lossy =
57 MLX5_GET(bufferx_reg, buffer, lossy);
58 port_buffer->buffer[i].epsb =
59 MLX5_GET(bufferx_reg, buffer, epsb);
60 port_buffer->buffer[i].size =
61 MLX5_GET(bufferx_reg, buffer, size) * port_buff_cell_sz;
62 port_buffer->buffer[i].xon =
63 MLX5_GET(bufferx_reg, buffer, xon_threshold) * port_buff_cell_sz;
64 port_buffer->buffer[i].xoff =
65 MLX5_GET(bufferx_reg, buffer, xoff_threshold) * port_buff_cell_sz;
66 total_used += port_buffer->buffer[i].size;
68 mlx5e_dbg(HW, priv, "buffer %d: size=%d, xon=%d, xoff=%d, epsb=%d, lossy=%d\n", i,
69 port_buffer->buffer[i].size,
70 port_buffer->buffer[i].xon,
71 port_buffer->buffer[i].xoff,
72 port_buffer->buffer[i].epsb,
73 port_buffer->buffer[i].lossy);
76 port_buffer->headroom_size = total_used;
77 port_buffer->port_buffer_size =
78 MLX5_GET(pbmc_reg, out, port_buffer_size) * port_buff_cell_sz;
79 port_buffer->spare_buffer_size =
80 port_buffer->port_buffer_size - total_used;
82 mlx5e_dbg(HW, priv, "total buffer size=%d, spare buffer size=%d\n",
83 port_buffer->port_buffer_size,
84 port_buffer->spare_buffer_size);
90 struct mlx5e_buffer_pool {
96 static int mlx5e_port_query_pool(struct mlx5_core_dev *mdev,
97 struct mlx5e_buffer_pool *buffer_pool,
98 u32 desc, u8 dir, u8 pool_idx)
100 u32 out[MLX5_ST_SZ_DW(sbpr_reg)] = {};
103 err = mlx5e_port_query_sbpr(mdev, desc, dir, pool_idx, out,
108 buffer_pool->size = MLX5_GET(sbpr_reg, out, size);
109 buffer_pool->infi_size = MLX5_GET(sbpr_reg, out, infi_size);
110 buffer_pool->buff_occupancy = MLX5_GET(sbpr_reg, out, buff_occupancy);
116 MLX5_INGRESS_DIR = 0,
122 MLX5_LOSSLESS_POOL = 1,
125 /* No limit on usage of shared buffer pool (max_buff=0) */
126 #define MLX5_SB_POOL_NO_THRESHOLD 0
127 /* Shared buffer pool usage threshold when calculated
128 * dynamically in alpha units. alpha=13 is equivalent to
129 * HW_alpha of [(1/128) * 2 ^ (alpha-1)] = 32, where HW_alpha
130 * equates to the following portion of the shared buffer pool:
131 * [32 / (1 + n * 32)] While *n* is the number of buffers
132 * that are using the shared buffer pool.
134 #define MLX5_SB_POOL_THRESHOLD 13
136 /* Shared buffer class management parameters */
137 struct mlx5_sbcm_params {
143 static const struct mlx5_sbcm_params sbcm_default = {
144 .pool_idx = MLX5_LOSSY_POOL,
145 .max_buff = MLX5_SB_POOL_NO_THRESHOLD,
149 static const struct mlx5_sbcm_params sbcm_lossy = {
150 .pool_idx = MLX5_LOSSY_POOL,
151 .max_buff = MLX5_SB_POOL_NO_THRESHOLD,
155 static const struct mlx5_sbcm_params sbcm_lossless = {
156 .pool_idx = MLX5_LOSSLESS_POOL,
157 .max_buff = MLX5_SB_POOL_THRESHOLD,
161 static const struct mlx5_sbcm_params sbcm_lossless_no_threshold = {
162 .pool_idx = MLX5_LOSSLESS_POOL,
163 .max_buff = MLX5_SB_POOL_NO_THRESHOLD,
168 * select_sbcm_params() - selects the shared buffer pool configuration
170 * @buffer: <input> port buffer to retrieve params of
171 * @lossless_buff_count: <input> number of lossless buffers in total
173 * The selection is based on the following rules:
174 * 1. If buffer size is 0, no shared buffer pool is used.
175 * 2. If buffer is lossy, use lossy shared buffer pool.
176 * 3. If there are more than 1 lossless buffers, use lossless shared buffer pool
178 * 4. If there is only 1 lossless buffer, use lossless shared buffer pool
181 * @return const struct mlx5_sbcm_params* selected values
183 static const struct mlx5_sbcm_params *
184 select_sbcm_params(struct mlx5e_bufferx_reg *buffer, u8 lossless_buff_count)
186 if (buffer->size == 0)
187 return &sbcm_default;
192 if (lossless_buff_count > 1)
193 return &sbcm_lossless;
195 return &sbcm_lossless_no_threshold;
198 static int port_update_pool_cfg(struct mlx5_core_dev *mdev,
199 struct mlx5e_port_buffer *port_buffer)
201 const struct mlx5_sbcm_params *p;
202 u8 lossless_buff_count = 0;
206 if (!MLX5_CAP_GEN(mdev, sbcam_reg))
209 for (i = 0; i < MLX5E_MAX_BUFFER; i++)
210 lossless_buff_count += ((port_buffer->buffer[i].size) &&
211 (!(port_buffer->buffer[i].lossy)));
213 for (i = 0; i < MLX5E_MAX_BUFFER; i++) {
214 p = select_sbcm_params(&port_buffer->buffer[i], lossless_buff_count);
215 err = mlx5e_port_set_sbcm(mdev, 0, i,
227 static int port_update_shared_buffer(struct mlx5_core_dev *mdev,
228 u32 current_headroom_size,
229 u32 new_headroom_size)
231 struct mlx5e_buffer_pool lossless_ipool;
232 struct mlx5e_buffer_pool lossy_epool;
233 u32 lossless_ipool_size;
234 u32 shared_buffer_size;
235 u32 total_buffer_size;
236 u32 lossy_epool_size;
239 if (!MLX5_CAP_GEN(mdev, sbcam_reg))
242 err = mlx5e_port_query_pool(mdev, &lossy_epool, 0, MLX5_EGRESS_DIR,
247 err = mlx5e_port_query_pool(mdev, &lossless_ipool, 0, MLX5_INGRESS_DIR,
252 total_buffer_size = current_headroom_size + lossy_epool.size +
254 shared_buffer_size = total_buffer_size - new_headroom_size;
256 if (shared_buffer_size < 4) {
257 pr_err("Requested port buffer is too large, not enough space left for shared buffer\n");
261 /* Total shared buffer size is split in a ratio of 3:1 between
262 * lossy and lossless pools respectively.
264 lossy_epool_size = (shared_buffer_size / 4) * 3;
265 lossless_ipool_size = shared_buffer_size / 4;
267 mlx5e_port_set_sbpr(mdev, 0, MLX5_EGRESS_DIR, MLX5_LOSSY_POOL, 0,
269 mlx5e_port_set_sbpr(mdev, 0, MLX5_INGRESS_DIR, MLX5_LOSSLESS_POOL, 0,
270 lossless_ipool_size);
274 static int port_set_buffer(struct mlx5e_priv *priv,
275 struct mlx5e_port_buffer *port_buffer)
277 u16 port_buff_cell_sz = priv->dcbx.port_buff_cell_sz;
278 struct mlx5_core_dev *mdev = priv->mdev;
279 int sz = MLX5_ST_SZ_BYTES(pbmc_reg);
280 u32 new_headroom_size = 0;
281 u32 current_headroom_size;
286 current_headroom_size = port_buffer->headroom_size;
288 in = kzalloc(sz, GFP_KERNEL);
292 err = mlx5e_port_query_pbmc(mdev, in);
296 for (i = 0; i < MLX5E_MAX_BUFFER; i++) {
297 void *buffer = MLX5_ADDR_OF(pbmc_reg, in, buffer[i]);
298 u64 size = port_buffer->buffer[i].size;
299 u64 xoff = port_buffer->buffer[i].xoff;
300 u64 xon = port_buffer->buffer[i].xon;
302 new_headroom_size += size;
303 do_div(size, port_buff_cell_sz);
304 do_div(xoff, port_buff_cell_sz);
305 do_div(xon, port_buff_cell_sz);
306 MLX5_SET(bufferx_reg, buffer, size, size);
307 MLX5_SET(bufferx_reg, buffer, lossy, port_buffer->buffer[i].lossy);
308 MLX5_SET(bufferx_reg, buffer, xoff_threshold, xoff);
309 MLX5_SET(bufferx_reg, buffer, xon_threshold, xon);
312 new_headroom_size /= port_buff_cell_sz;
313 current_headroom_size /= port_buff_cell_sz;
314 err = port_update_shared_buffer(priv->mdev, current_headroom_size,
319 err = port_update_pool_cfg(priv->mdev, port_buffer);
323 err = mlx5e_port_set_pbmc(mdev, in);
329 /* xoff = ((301+2.16 * len [m]) * speed [Gbps] + 2.72 MTU [B])
330 * minimum speed value is 40Gbps
332 static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu)
338 err = mlx5e_port_linkspeed(priv->mdev, &speed);
341 speed = max_t(u32, speed, SPEED_40000);
343 xoff = (301 + 216 * priv->dcbx.cable_len / 100) * speed / 1000 + 272 * mtu / 100;
345 mlx5e_dbg(HW, priv, "%s: xoff=%d\n", __func__, xoff);
349 static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer,
350 u32 xoff, unsigned int max_mtu, u16 port_buff_cell_sz)
354 for (i = 0; i < MLX5E_MAX_BUFFER; i++) {
355 if (port_buffer->buffer[i].lossy) {
356 port_buffer->buffer[i].xoff = 0;
357 port_buffer->buffer[i].xon = 0;
361 if (port_buffer->buffer[i].size <
362 (xoff + max_mtu + port_buff_cell_sz)) {
363 pr_err("buffer_size[%d]=%d is not enough for lossless buffer\n",
364 i, port_buffer->buffer[i].size);
368 port_buffer->buffer[i].xoff = port_buffer->buffer[i].size - xoff;
369 port_buffer->buffer[i].xon =
370 port_buffer->buffer[i].xoff - max_mtu;
377 * update_buffer_lossy - Update buffer configuration based on pfc
378 * @mdev: port function core device
379 * @max_mtu: netdev's max_mtu
380 * @pfc_en: <input> current pfc configuration
381 * @buffer: <input> current prio to buffer mapping
382 * @xoff: <input> xoff value
383 * @port_buff_cell_sz: <input> port buffer cell_size
384 * @port_buffer: <output> port receive buffer configuration
387 * Update buffer configuration based on pfc configuration and
388 * priority to buffer mapping.
389 * Buffer's lossy bit is changed to:
390 * lossless if there is at least one PFC enabled priority
391 * mapped to this buffer lossy if all priorities mapped to
392 * this buffer are PFC disabled
394 * @return: 0 if no error,
395 * sets change to true if buffer configuration was modified.
397 static int update_buffer_lossy(struct mlx5_core_dev *mdev,
398 unsigned int max_mtu,
399 u8 pfc_en, u8 *buffer, u32 xoff, u16 port_buff_cell_sz,
400 struct mlx5e_port_buffer *port_buffer,
403 bool changed = false;
411 for (i = 0; i < MLX5E_MAX_BUFFER; i++) {
415 for (prio = 0; prio < MLX5E_MAX_PRIORITY; prio++) {
416 if (buffer[prio] != i)
420 lossy_count += !(pfc_en & (1 << prio));
423 if (lossy_count == prio_count)
425 else /* lossy_count < prio_count */
428 if (lossy != port_buffer->buffer[i].lossy) {
429 port_buffer->buffer[i].lossy = lossy;
435 err = port_update_pool_cfg(mdev, port_buffer);
439 err = update_xoff_threshold(port_buffer, xoff, max_mtu, port_buff_cell_sz);
449 static int fill_pfc_en(struct mlx5_core_dev *mdev, u8 *pfc_en)
451 u32 g_rx_pause, g_tx_pause;
454 err = mlx5_query_port_pause(mdev, &g_rx_pause, &g_tx_pause);
458 /* If global pause enabled, set all active buffers to lossless.
459 * Otherwise, check PFC setting.
461 if (g_rx_pause || g_tx_pause)
464 err = mlx5_query_port_pfc(mdev, pfc_en, NULL);
469 #define MINIMUM_MAX_MTU 9216
470 int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv,
471 u32 change, unsigned int mtu,
472 struct ieee_pfc *pfc,
476 u16 port_buff_cell_sz = priv->dcbx.port_buff_cell_sz;
477 struct mlx5e_port_buffer port_buffer;
478 u32 xoff = calculate_xoff(priv, mtu);
479 bool update_prio2buffer = false;
480 u8 buffer[MLX5E_MAX_PRIORITY];
481 bool update_buffer = false;
482 unsigned int max_mtu;
488 mlx5e_dbg(HW, priv, "%s: change=%x\n", __func__, change);
489 max_mtu = max_t(unsigned int, priv->netdev->max_mtu, MINIMUM_MAX_MTU);
491 err = mlx5e_port_query_buffer(priv, &port_buffer);
495 if (change & MLX5E_PORT_BUFFER_CABLE_LEN) {
496 update_buffer = true;
497 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz);
502 if (change & MLX5E_PORT_BUFFER_PFC) {
503 mlx5e_dbg(HW, priv, "%s: requested PFC per priority bitmask: 0x%x\n",
504 __func__, pfc->pfc_en);
505 err = mlx5e_port_query_priority2buffer(priv->mdev, buffer);
509 err = update_buffer_lossy(priv->mdev, max_mtu, pfc->pfc_en, buffer, xoff,
510 port_buff_cell_sz, &port_buffer,
516 if (change & MLX5E_PORT_BUFFER_PRIO2BUFFER) {
517 update_prio2buffer = true;
518 for (i = 0; i < MLX5E_MAX_BUFFER; i++)
519 mlx5e_dbg(HW, priv, "%s: requested to map prio[%d] to buffer %d\n",
520 __func__, i, prio2buffer[i]);
522 err = fill_pfc_en(priv->mdev, &curr_pfc_en);
526 err = update_buffer_lossy(priv->mdev, max_mtu, curr_pfc_en, prio2buffer, xoff,
527 port_buff_cell_sz, &port_buffer, &update_buffer);
532 if (change & MLX5E_PORT_BUFFER_SIZE) {
533 for (i = 0; i < MLX5E_MAX_BUFFER; i++) {
534 mlx5e_dbg(HW, priv, "%s: buffer[%d]=%d\n", __func__, i, buffer_size[i]);
535 if (!port_buffer.buffer[i].lossy && !buffer_size[i]) {
536 mlx5e_dbg(HW, priv, "%s: lossless buffer[%d] size cannot be zero\n",
541 port_buffer.buffer[i].size = buffer_size[i];
542 total_used += buffer_size[i];
545 mlx5e_dbg(HW, priv, "%s: total buffer requested=%d\n", __func__, total_used);
547 if (total_used > port_buffer.port_buffer_size)
550 update_buffer = true;
551 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz);
556 /* Need to update buffer configuration if xoff value is changed */
557 if (!update_buffer && xoff != priv->dcbx.xoff) {
558 update_buffer = true;
559 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz);
563 priv->dcbx.xoff = xoff;
565 /* Apply the settings */
567 err = port_set_buffer(priv, &port_buffer);
572 if (update_prio2buffer)
573 err = mlx5e_port_set_priority2buffer(priv->mdev, prio2buffer);