1 /*
2 * Copyright (c) 2018, Mellanox Technologies. All rights reserved.
3 *
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:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
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.
22 *
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
30 * SOFTWARE.
31 */
32 #include "port_buffer.h"
33
mlx5e_port_query_buffer(struct mlx5e_priv * priv,struct mlx5e_port_buffer * port_buffer)34 int mlx5e_port_query_buffer(struct mlx5e_priv *priv,
35 struct mlx5e_port_buffer *port_buffer)
36 {
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);
40 u32 total_used = 0;
41 void *buffer;
42 void *out;
43 int err;
44 int i;
45
46 out = kzalloc(sz, GFP_KERNEL);
47 if (!out)
48 return -ENOMEM;
49
50 err = mlx5e_port_query_pbmc(mdev, out);
51 if (err)
52 goto out;
53
54 for (i = 0; i < MLX5E_MAX_NETWORK_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;
67
68 netdev_dbg(priv->netdev, "buffer %d: size=%d, xon=%d, xoff=%d, epsb=%d, lossy=%d\n",
69 i,
70 port_buffer->buffer[i].size,
71 port_buffer->buffer[i].xon,
72 port_buffer->buffer[i].xoff,
73 port_buffer->buffer[i].epsb,
74 port_buffer->buffer[i].lossy);
75 }
76
77 port_buffer->internal_buffers_size = 0;
78 for (i = MLX5E_MAX_NETWORK_BUFFER; i < MLX5E_TOTAL_BUFFERS; i++) {
79 buffer = MLX5_ADDR_OF(pbmc_reg, out, buffer[i]);
80 port_buffer->internal_buffers_size +=
81 MLX5_GET(bufferx_reg, buffer, size) * port_buff_cell_sz;
82 }
83
84 port_buffer->port_buffer_size =
85 MLX5_GET(pbmc_reg, out, port_buffer_size) * port_buff_cell_sz;
86 port_buffer->headroom_size = total_used;
87 port_buffer->spare_buffer_size = port_buffer->port_buffer_size -
88 port_buffer->internal_buffers_size -
89 port_buffer->headroom_size;
90
91 netdev_dbg(priv->netdev,
92 "total buffer size=%u, headroom buffer size=%u, internal buffers size=%u, spare buffer size=%u\n",
93 port_buffer->port_buffer_size, port_buffer->headroom_size,
94 port_buffer->internal_buffers_size,
95 port_buffer->spare_buffer_size);
96 out:
97 kfree(out);
98 return err;
99 }
100
101 struct mlx5e_buffer_pool {
102 u32 infi_size;
103 u32 size;
104 u32 buff_occupancy;
105 };
106
mlx5e_port_query_pool(struct mlx5_core_dev * mdev,struct mlx5e_buffer_pool * buffer_pool,u32 desc,u8 dir,u8 pool_idx)107 static int mlx5e_port_query_pool(struct mlx5_core_dev *mdev,
108 struct mlx5e_buffer_pool *buffer_pool,
109 u32 desc, u8 dir, u8 pool_idx)
110 {
111 u32 out[MLX5_ST_SZ_DW(sbpr_reg)] = {};
112 int err;
113
114 err = mlx5e_port_query_sbpr(mdev, desc, dir, pool_idx, out,
115 sizeof(out));
116 if (err)
117 return err;
118
119 buffer_pool->size = MLX5_GET(sbpr_reg, out, size);
120 buffer_pool->infi_size = MLX5_GET(sbpr_reg, out, infi_size);
121 buffer_pool->buff_occupancy = MLX5_GET(sbpr_reg, out, buff_occupancy);
122
123 return err;
124 }
125
126 enum {
127 MLX5_INGRESS_DIR = 0,
128 MLX5_EGRESS_DIR = 1,
129 };
130
131 enum {
132 MLX5_LOSSY_POOL = 0,
133 MLX5_LOSSLESS_POOL = 1,
134 };
135
136 /* No limit on usage of shared buffer pool (max_buff=0) */
137 #define MLX5_SB_POOL_NO_THRESHOLD 0
138 /* Shared buffer pool usage threshold when calculated
139 * dynamically in alpha units. alpha=13 is equivalent to
140 * HW_alpha of [(1/128) * 2 ^ (alpha-1)] = 32, where HW_alpha
141 * equates to the following portion of the shared buffer pool:
142 * [32 / (1 + n * 32)] While *n* is the number of buffers
143 * that are using the shared buffer pool.
144 */
145 #define MLX5_SB_POOL_THRESHOLD 13
146
147 /* Shared buffer class management parameters */
148 struct mlx5_sbcm_params {
149 u8 pool_idx;
150 u8 max_buff;
151 u8 infi_size;
152 };
153
154 static const struct mlx5_sbcm_params sbcm_default = {
155 .pool_idx = MLX5_LOSSY_POOL,
156 .max_buff = MLX5_SB_POOL_NO_THRESHOLD,
157 .infi_size = 0,
158 };
159
160 static const struct mlx5_sbcm_params sbcm_lossy = {
161 .pool_idx = MLX5_LOSSY_POOL,
162 .max_buff = MLX5_SB_POOL_NO_THRESHOLD,
163 .infi_size = 1,
164 };
165
166 static const struct mlx5_sbcm_params sbcm_lossless = {
167 .pool_idx = MLX5_LOSSLESS_POOL,
168 .max_buff = MLX5_SB_POOL_THRESHOLD,
169 .infi_size = 0,
170 };
171
172 static const struct mlx5_sbcm_params sbcm_lossless_no_threshold = {
173 .pool_idx = MLX5_LOSSLESS_POOL,
174 .max_buff = MLX5_SB_POOL_NO_THRESHOLD,
175 .infi_size = 1,
176 };
177
178 /**
179 * select_sbcm_params() - selects the shared buffer pool configuration
180 *
181 * @buffer: <input> port buffer to retrieve params of
182 * @lossless_buff_count: <input> number of lossless buffers in total
183 *
184 * The selection is based on the following rules:
185 * 1. If buffer size is 0, no shared buffer pool is used.
186 * 2. If buffer is lossy, use lossy shared buffer pool.
187 * 3. If there are more than 1 lossless buffers, use lossless shared buffer pool
188 * with threshold.
189 * 4. If there is only 1 lossless buffer, use lossless shared buffer pool
190 * without threshold.
191 *
192 * @return const struct mlx5_sbcm_params* selected values
193 */
194 static const struct mlx5_sbcm_params *
select_sbcm_params(struct mlx5e_bufferx_reg * buffer,u8 lossless_buff_count)195 select_sbcm_params(struct mlx5e_bufferx_reg *buffer, u8 lossless_buff_count)
196 {
197 if (buffer->size == 0)
198 return &sbcm_default;
199
200 if (buffer->lossy)
201 return &sbcm_lossy;
202
203 if (lossless_buff_count > 1)
204 return &sbcm_lossless;
205
206 return &sbcm_lossless_no_threshold;
207 }
208
port_update_pool_cfg(struct mlx5_core_dev * mdev,struct mlx5e_port_buffer * port_buffer)209 static int port_update_pool_cfg(struct mlx5_core_dev *mdev,
210 struct mlx5e_port_buffer *port_buffer)
211 {
212 const struct mlx5_sbcm_params *p;
213 u8 lossless_buff_count = 0;
214 int err;
215 int i;
216
217 if (!MLX5_CAP_GEN(mdev, sbcam_reg))
218 return 0;
219
220 for (i = 0; i < MLX5E_MAX_NETWORK_BUFFER; i++)
221 lossless_buff_count += ((port_buffer->buffer[i].size) &&
222 (!(port_buffer->buffer[i].lossy)));
223
224 for (i = 0; i < MLX5E_MAX_NETWORK_BUFFER; i++) {
225 p = select_sbcm_params(&port_buffer->buffer[i], lossless_buff_count);
226 err = mlx5e_port_set_sbcm(mdev, 0, i,
227 MLX5_INGRESS_DIR,
228 p->infi_size,
229 p->max_buff,
230 p->pool_idx);
231 if (err)
232 return err;
233 }
234
235 return 0;
236 }
237
port_update_shared_buffer(struct mlx5_core_dev * mdev,u32 current_headroom_size,u32 new_headroom_size)238 static int port_update_shared_buffer(struct mlx5_core_dev *mdev,
239 u32 current_headroom_size,
240 u32 new_headroom_size)
241 {
242 struct mlx5e_buffer_pool lossless_ipool;
243 struct mlx5e_buffer_pool lossy_epool;
244 u32 lossless_ipool_size;
245 u32 shared_buffer_size;
246 u32 total_buffer_size;
247 u32 lossy_epool_size;
248 int err;
249
250 if (!MLX5_CAP_GEN(mdev, sbcam_reg))
251 return 0;
252
253 err = mlx5e_port_query_pool(mdev, &lossy_epool, 0, MLX5_EGRESS_DIR,
254 MLX5_LOSSY_POOL);
255 if (err)
256 return err;
257
258 err = mlx5e_port_query_pool(mdev, &lossless_ipool, 0, MLX5_INGRESS_DIR,
259 MLX5_LOSSLESS_POOL);
260 if (err)
261 return err;
262
263 total_buffer_size = current_headroom_size + lossy_epool.size +
264 lossless_ipool.size;
265 shared_buffer_size = total_buffer_size - new_headroom_size;
266
267 if (shared_buffer_size < 4) {
268 pr_err("Requested port buffer is too large, not enough space left for shared buffer\n");
269 return -EINVAL;
270 }
271
272 /* Total shared buffer size is split in a ratio of 3:1 between
273 * lossy and lossless pools respectively.
274 */
275 lossy_epool_size = (shared_buffer_size / 4) * 3;
276 lossless_ipool_size = shared_buffer_size / 4;
277
278 mlx5e_port_set_sbpr(mdev, 0, MLX5_EGRESS_DIR, MLX5_LOSSY_POOL, 0,
279 lossy_epool_size);
280 mlx5e_port_set_sbpr(mdev, 0, MLX5_INGRESS_DIR, MLX5_LOSSLESS_POOL, 0,
281 lossless_ipool_size);
282 return 0;
283 }
284
port_set_buffer(struct mlx5e_priv * priv,struct mlx5e_port_buffer * port_buffer)285 static int port_set_buffer(struct mlx5e_priv *priv,
286 struct mlx5e_port_buffer *port_buffer)
287 {
288 u16 port_buff_cell_sz = priv->dcbx.port_buff_cell_sz;
289 struct mlx5_core_dev *mdev = priv->mdev;
290 int sz = MLX5_ST_SZ_BYTES(pbmc_reg);
291 u32 new_headroom_size = 0;
292 u32 current_headroom_size;
293 void *in;
294 int err;
295 int i;
296
297 current_headroom_size = port_buffer->headroom_size;
298
299 in = kzalloc(sz, GFP_KERNEL);
300 if (!in)
301 return -ENOMEM;
302
303 err = mlx5e_port_query_pbmc(mdev, in);
304 if (err)
305 goto out;
306
307 for (i = 0; i < MLX5E_MAX_NETWORK_BUFFER; i++) {
308 void *buffer = MLX5_ADDR_OF(pbmc_reg, in, buffer[i]);
309 u64 size = port_buffer->buffer[i].size;
310 u64 xoff = port_buffer->buffer[i].xoff;
311 u64 xon = port_buffer->buffer[i].xon;
312
313 new_headroom_size += size;
314 do_div(size, port_buff_cell_sz);
315 do_div(xoff, port_buff_cell_sz);
316 do_div(xon, port_buff_cell_sz);
317 MLX5_SET(bufferx_reg, buffer, size, size);
318 MLX5_SET(bufferx_reg, buffer, lossy, port_buffer->buffer[i].lossy);
319 MLX5_SET(bufferx_reg, buffer, xoff_threshold, xoff);
320 MLX5_SET(bufferx_reg, buffer, xon_threshold, xon);
321 }
322
323 new_headroom_size /= port_buff_cell_sz;
324 current_headroom_size /= port_buff_cell_sz;
325 err = port_update_shared_buffer(priv->mdev, current_headroom_size,
326 new_headroom_size);
327 if (err)
328 goto out;
329
330 err = port_update_pool_cfg(priv->mdev, port_buffer);
331 if (err)
332 goto out;
333
334 /* RO bits should be set to 0 on write */
335 MLX5_SET(pbmc_reg, in, port_buffer_size, 0);
336
337 err = mlx5e_port_set_pbmc(mdev, in);
338 out:
339 kfree(in);
340 return err;
341 }
342
343 /* xoff = ((301+2.16 * len [m]) * speed [Gbps] + 2.72 MTU [B])
344 * minimum speed value is 40Gbps
345 */
calculate_xoff(struct mlx5e_priv * priv,unsigned int mtu)346 static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu)
347 {
348 u32 speed;
349 u32 xoff;
350 int err;
351
352 err = mlx5e_port_linkspeed(priv->mdev, &speed);
353 if (err)
354 speed = SPEED_40000;
355 speed = max_t(u32, speed, SPEED_40000);
356
357 xoff = (301 + 216 * priv->dcbx.cable_len / 100) * speed / 1000 + 272 * mtu / 100;
358
359 netdev_dbg(priv->netdev, "%s: xoff=%d\n", __func__, xoff);
360 return xoff;
361 }
362
update_xoff_threshold(struct mlx5e_port_buffer * port_buffer,u32 xoff,unsigned int max_mtu,u16 port_buff_cell_sz)363 static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer,
364 u32 xoff, unsigned int max_mtu, u16 port_buff_cell_sz)
365 {
366 int i;
367
368 for (i = 0; i < MLX5E_MAX_NETWORK_BUFFER; i++) {
369 if (port_buffer->buffer[i].lossy) {
370 port_buffer->buffer[i].xoff = 0;
371 port_buffer->buffer[i].xon = 0;
372 continue;
373 }
374
375 if (port_buffer->buffer[i].size <
376 (xoff + max_mtu + port_buff_cell_sz)) {
377 pr_err("buffer_size[%d]=%d is not enough for lossless buffer\n",
378 i, port_buffer->buffer[i].size);
379 return -ENOMEM;
380 }
381
382 port_buffer->buffer[i].xoff = port_buffer->buffer[i].size - xoff;
383 port_buffer->buffer[i].xon =
384 port_buffer->buffer[i].xoff - max_mtu;
385 }
386
387 return 0;
388 }
389
390 /**
391 * update_buffer_lossy - Update buffer configuration based on pfc
392 * @mdev: port function core device
393 * @max_mtu: netdev's max_mtu
394 * @pfc_en: <input> current pfc configuration
395 * @buffer: <input> current prio to buffer mapping
396 * @xoff: <input> xoff value
397 * @port_buff_cell_sz: <input> port buffer cell_size
398 * @port_buffer: <output> port receive buffer configuration
399 * @change: <output>
400 *
401 * Update buffer configuration based on pfc configuration and
402 * priority to buffer mapping.
403 * Buffer's lossy bit is changed to:
404 * lossless if there is at least one PFC enabled priority
405 * mapped to this buffer lossy if all priorities mapped to
406 * this buffer are PFC disabled
407 *
408 * @return: 0 if no error,
409 * sets change to true if buffer configuration was modified.
410 */
update_buffer_lossy(struct mlx5_core_dev * mdev,unsigned int max_mtu,u8 pfc_en,u8 * buffer,u32 xoff,u16 port_buff_cell_sz,struct mlx5e_port_buffer * port_buffer,bool * change)411 static int update_buffer_lossy(struct mlx5_core_dev *mdev,
412 unsigned int max_mtu,
413 u8 pfc_en, u8 *buffer, u32 xoff, u16 port_buff_cell_sz,
414 struct mlx5e_port_buffer *port_buffer,
415 bool *change)
416 {
417 bool changed = false;
418 u8 lossy_count;
419 u8 prio_count;
420 u8 lossy;
421 int prio;
422 int err;
423 int i;
424
425 for (i = 0; i < MLX5E_MAX_NETWORK_BUFFER; i++) {
426 prio_count = 0;
427 lossy_count = 0;
428
429 for (prio = 0; prio < MLX5E_MAX_PRIORITY; prio++) {
430 if (buffer[prio] != i)
431 continue;
432
433 prio_count++;
434 lossy_count += !(pfc_en & (1 << prio));
435 }
436
437 if (lossy_count == prio_count)
438 lossy = 1;
439 else /* lossy_count < prio_count */
440 lossy = 0;
441
442 if (lossy != port_buffer->buffer[i].lossy) {
443 port_buffer->buffer[i].lossy = lossy;
444 changed = true;
445 }
446 }
447
448 if (changed) {
449 err = update_xoff_threshold(port_buffer, xoff, max_mtu, port_buff_cell_sz);
450 if (err)
451 return err;
452
453 err = port_update_pool_cfg(mdev, port_buffer);
454 if (err)
455 return err;
456
457 *change = true;
458 }
459
460 return 0;
461 }
462
fill_pfc_en(struct mlx5_core_dev * mdev,u8 * pfc_en)463 static int fill_pfc_en(struct mlx5_core_dev *mdev, u8 *pfc_en)
464 {
465 u32 g_rx_pause, g_tx_pause;
466 int err;
467
468 err = mlx5_query_port_pause(mdev, &g_rx_pause, &g_tx_pause);
469 if (err)
470 return err;
471
472 /* If global pause enabled, set all active buffers to lossless.
473 * Otherwise, check PFC setting.
474 */
475 if (g_rx_pause || g_tx_pause)
476 *pfc_en = 0xff;
477 else
478 err = mlx5_query_port_pfc(mdev, pfc_en, NULL);
479
480 return err;
481 }
482
483 #define MINIMUM_MAX_MTU 9216
mlx5e_port_manual_buffer_config(struct mlx5e_priv * priv,u32 change,unsigned int mtu,struct ieee_pfc * pfc,u32 * buffer_size,u8 * prio2buffer)484 int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv,
485 u32 change, unsigned int mtu,
486 struct ieee_pfc *pfc,
487 u32 *buffer_size,
488 u8 *prio2buffer)
489 {
490 u16 port_buff_cell_sz = priv->dcbx.port_buff_cell_sz;
491 struct net_device *netdev = priv->netdev;
492 struct mlx5e_port_buffer port_buffer;
493 u32 xoff = calculate_xoff(priv, mtu);
494 bool update_prio2buffer = false;
495 u8 buffer[MLX5E_MAX_PRIORITY];
496 bool update_buffer = false;
497 unsigned int max_mtu;
498 u32 total_used = 0;
499 u8 curr_pfc_en;
500 int err;
501 int i;
502
503 netdev_dbg(netdev, "%s: change=%x\n", __func__, change);
504 max_mtu = max_t(unsigned int, priv->netdev->max_mtu, MINIMUM_MAX_MTU);
505
506 err = mlx5e_port_query_buffer(priv, &port_buffer);
507 if (err)
508 return err;
509
510 if (change & MLX5E_PORT_BUFFER_CABLE_LEN) {
511 update_buffer = true;
512 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz);
513 if (err)
514 return err;
515 }
516
517 if (change & MLX5E_PORT_BUFFER_PFC) {
518 netdev_dbg(netdev, "%s: requested PFC per priority bitmask: 0x%x\n",
519 __func__, pfc->pfc_en);
520 err = mlx5e_port_query_priority2buffer(priv->mdev, buffer);
521 if (err)
522 return err;
523
524 err = update_buffer_lossy(priv->mdev, max_mtu, pfc->pfc_en, buffer, xoff,
525 port_buff_cell_sz, &port_buffer,
526 &update_buffer);
527 if (err)
528 return err;
529 }
530
531 if (change & MLX5E_PORT_BUFFER_PRIO2BUFFER) {
532 update_prio2buffer = true;
533 for (i = 0; i < MLX5E_MAX_NETWORK_BUFFER; i++)
534 netdev_dbg(priv->netdev, "%s: requested to map prio[%d] to buffer %d\n",
535 __func__, i, prio2buffer[i]);
536
537 err = fill_pfc_en(priv->mdev, &curr_pfc_en);
538 if (err)
539 return err;
540
541 err = update_buffer_lossy(priv->mdev, max_mtu, curr_pfc_en, prio2buffer, xoff,
542 port_buff_cell_sz, &port_buffer, &update_buffer);
543 if (err)
544 return err;
545 }
546
547 if (change & MLX5E_PORT_BUFFER_SIZE) {
548 for (i = 0; i < MLX5E_MAX_NETWORK_BUFFER; i++) {
549 netdev_dbg(priv->netdev, "%s: buffer[%d]=%d\n", __func__, i, buffer_size[i]);
550 if (!port_buffer.buffer[i].lossy && !buffer_size[i]) {
551 netdev_dbg(priv->netdev, "%s: lossless buffer[%d] size cannot be zero\n",
552 __func__, i);
553 return -EINVAL;
554 }
555
556 port_buffer.buffer[i].size = buffer_size[i];
557 total_used += buffer_size[i];
558 }
559
560 netdev_dbg(priv->netdev, "%s: total buffer requested=%d\n", __func__, total_used);
561
562 if (total_used > port_buffer.headroom_size &&
563 (total_used - port_buffer.headroom_size) >
564 port_buffer.spare_buffer_size)
565 return -EINVAL;
566
567 update_buffer = true;
568 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz);
569 if (err)
570 return err;
571 }
572
573 /* Need to update buffer configuration if xoff value is changed */
574 if (!update_buffer && xoff != priv->dcbx.xoff) {
575 update_buffer = true;
576 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz);
577 if (err)
578 return err;
579 }
580 priv->dcbx.xoff = xoff;
581
582 /* Apply the settings */
583 if (update_buffer) {
584 err = port_set_buffer(priv, &port_buffer);
585 if (err)
586 return err;
587 }
588
589 if (update_prio2buffer)
590 err = mlx5e_port_set_priority2buffer(priv->mdev, prio2buffer);
591
592 return err;
593 }
594