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 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_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 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); 74 } 75 76 port_buffer->port_buffer_size = 77 MLX5_GET(pbmc_reg, out, port_buffer_size) * port_buff_cell_sz; 78 port_buffer->spare_buffer_size = 79 port_buffer->port_buffer_size - total_used; 80 81 mlx5e_dbg(HW, priv, "total buffer size=%d, spare buffer size=%d\n", 82 port_buffer->port_buffer_size, 83 port_buffer->spare_buffer_size); 84 out: 85 kfree(out); 86 return err; 87 } 88 89 static int port_set_buffer(struct mlx5e_priv *priv, 90 struct mlx5e_port_buffer *port_buffer) 91 { 92 u16 port_buff_cell_sz = priv->dcbx.port_buff_cell_sz; 93 struct mlx5_core_dev *mdev = priv->mdev; 94 int sz = MLX5_ST_SZ_BYTES(pbmc_reg); 95 void *in; 96 int err; 97 int i; 98 99 in = kzalloc(sz, GFP_KERNEL); 100 if (!in) 101 return -ENOMEM; 102 103 err = mlx5e_port_query_pbmc(mdev, in); 104 if (err) 105 goto out; 106 107 for (i = 0; i < MLX5E_MAX_BUFFER; i++) { 108 void *buffer = MLX5_ADDR_OF(pbmc_reg, in, buffer[i]); 109 u64 size = port_buffer->buffer[i].size; 110 u64 xoff = port_buffer->buffer[i].xoff; 111 u64 xon = port_buffer->buffer[i].xon; 112 113 do_div(size, port_buff_cell_sz); 114 do_div(xoff, port_buff_cell_sz); 115 do_div(xon, port_buff_cell_sz); 116 MLX5_SET(bufferx_reg, buffer, size, size); 117 MLX5_SET(bufferx_reg, buffer, lossy, port_buffer->buffer[i].lossy); 118 MLX5_SET(bufferx_reg, buffer, xoff_threshold, xoff); 119 MLX5_SET(bufferx_reg, buffer, xon_threshold, xon); 120 } 121 122 err = mlx5e_port_set_pbmc(mdev, in); 123 out: 124 kfree(in); 125 return err; 126 } 127 128 /* xoff = ((301+2.16 * len [m]) * speed [Gbps] + 2.72 MTU [B]) 129 * minimum speed value is 40Gbps 130 */ 131 static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu) 132 { 133 u32 speed; 134 u32 xoff; 135 int err; 136 137 err = mlx5e_port_linkspeed(priv->mdev, &speed); 138 if (err) 139 speed = SPEED_40000; 140 speed = max_t(u32, speed, SPEED_40000); 141 142 xoff = (301 + 216 * priv->dcbx.cable_len / 100) * speed / 1000 + 272 * mtu / 100; 143 144 mlx5e_dbg(HW, priv, "%s: xoff=%d\n", __func__, xoff); 145 return xoff; 146 } 147 148 static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer, 149 u32 xoff, unsigned int max_mtu, u16 port_buff_cell_sz) 150 { 151 int i; 152 153 for (i = 0; i < MLX5E_MAX_BUFFER; i++) { 154 if (port_buffer->buffer[i].lossy) { 155 port_buffer->buffer[i].xoff = 0; 156 port_buffer->buffer[i].xon = 0; 157 continue; 158 } 159 160 if (port_buffer->buffer[i].size < 161 (xoff + max_mtu + port_buff_cell_sz)) { 162 pr_err("buffer_size[%d]=%d is not enough for lossless buffer\n", 163 i, port_buffer->buffer[i].size); 164 return -ENOMEM; 165 } 166 167 port_buffer->buffer[i].xoff = port_buffer->buffer[i].size - xoff; 168 port_buffer->buffer[i].xon = 169 port_buffer->buffer[i].xoff - max_mtu; 170 } 171 172 return 0; 173 } 174 175 /** 176 * update_buffer_lossy - Update buffer configuration based on pfc 177 * @max_mtu: netdev's max_mtu 178 * @pfc_en: <input> current pfc configuration 179 * @buffer: <input> current prio to buffer mapping 180 * @xoff: <input> xoff value 181 * @port_buff_cell_sz: <input> port buffer cell_size 182 * @port_buffer: <output> port receive buffer configuration 183 * @change: <output> 184 * 185 * Update buffer configuration based on pfc configuration and 186 * priority to buffer mapping. 187 * Buffer's lossy bit is changed to: 188 * lossless if there is at least one PFC enabled priority 189 * mapped to this buffer lossy if all priorities mapped to 190 * this buffer are PFC disabled 191 * 192 * @return: 0 if no error, 193 * sets change to true if buffer configuration was modified. 194 */ 195 static int update_buffer_lossy(unsigned int max_mtu, 196 u8 pfc_en, u8 *buffer, u32 xoff, u16 port_buff_cell_sz, 197 struct mlx5e_port_buffer *port_buffer, 198 bool *change) 199 { 200 bool changed = false; 201 u8 lossy_count; 202 u8 prio_count; 203 u8 lossy; 204 int prio; 205 int err; 206 int i; 207 208 for (i = 0; i < MLX5E_MAX_BUFFER; i++) { 209 prio_count = 0; 210 lossy_count = 0; 211 212 for (prio = 0; prio < MLX5E_MAX_PRIORITY; prio++) { 213 if (buffer[prio] != i) 214 continue; 215 216 prio_count++; 217 lossy_count += !(pfc_en & (1 << prio)); 218 } 219 220 if (lossy_count == prio_count) 221 lossy = 1; 222 else /* lossy_count < prio_count */ 223 lossy = 0; 224 225 if (lossy != port_buffer->buffer[i].lossy) { 226 port_buffer->buffer[i].lossy = lossy; 227 changed = true; 228 } 229 } 230 231 if (changed) { 232 err = update_xoff_threshold(port_buffer, xoff, max_mtu, port_buff_cell_sz); 233 if (err) 234 return err; 235 236 *change = true; 237 } 238 239 return 0; 240 } 241 242 static int fill_pfc_en(struct mlx5_core_dev *mdev, u8 *pfc_en) 243 { 244 u32 g_rx_pause, g_tx_pause; 245 int err; 246 247 err = mlx5_query_port_pause(mdev, &g_rx_pause, &g_tx_pause); 248 if (err) 249 return err; 250 251 /* If global pause enabled, set all active buffers to lossless. 252 * Otherwise, check PFC setting. 253 */ 254 if (g_rx_pause || g_tx_pause) 255 *pfc_en = 0xff; 256 else 257 err = mlx5_query_port_pfc(mdev, pfc_en, NULL); 258 259 return err; 260 } 261 262 #define MINIMUM_MAX_MTU 9216 263 int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, 264 u32 change, unsigned int mtu, 265 struct ieee_pfc *pfc, 266 u32 *buffer_size, 267 u8 *prio2buffer) 268 { 269 u16 port_buff_cell_sz = priv->dcbx.port_buff_cell_sz; 270 struct mlx5e_port_buffer port_buffer; 271 u32 xoff = calculate_xoff(priv, mtu); 272 bool update_prio2buffer = false; 273 u8 buffer[MLX5E_MAX_PRIORITY]; 274 bool update_buffer = false; 275 unsigned int max_mtu; 276 u32 total_used = 0; 277 u8 curr_pfc_en; 278 int err; 279 int i; 280 281 mlx5e_dbg(HW, priv, "%s: change=%x\n", __func__, change); 282 max_mtu = max_t(unsigned int, priv->netdev->max_mtu, MINIMUM_MAX_MTU); 283 284 err = mlx5e_port_query_buffer(priv, &port_buffer); 285 if (err) 286 return err; 287 288 if (change & MLX5E_PORT_BUFFER_CABLE_LEN) { 289 update_buffer = true; 290 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz); 291 if (err) 292 return err; 293 } 294 295 if (change & MLX5E_PORT_BUFFER_PFC) { 296 err = mlx5e_port_query_priority2buffer(priv->mdev, buffer); 297 if (err) 298 return err; 299 300 err = update_buffer_lossy(max_mtu, pfc->pfc_en, buffer, xoff, port_buff_cell_sz, 301 &port_buffer, &update_buffer); 302 if (err) 303 return err; 304 } 305 306 if (change & MLX5E_PORT_BUFFER_PRIO2BUFFER) { 307 update_prio2buffer = true; 308 err = fill_pfc_en(priv->mdev, &curr_pfc_en); 309 if (err) 310 return err; 311 312 err = update_buffer_lossy(max_mtu, curr_pfc_en, prio2buffer, port_buff_cell_sz, 313 xoff, &port_buffer, &update_buffer); 314 if (err) 315 return err; 316 } 317 318 if (change & MLX5E_PORT_BUFFER_SIZE) { 319 for (i = 0; i < MLX5E_MAX_BUFFER; i++) { 320 mlx5e_dbg(HW, priv, "%s: buffer[%d]=%d\n", __func__, i, buffer_size[i]); 321 if (!port_buffer.buffer[i].lossy && !buffer_size[i]) { 322 mlx5e_dbg(HW, priv, "%s: lossless buffer[%d] size cannot be zero\n", 323 __func__, i); 324 return -EINVAL; 325 } 326 327 port_buffer.buffer[i].size = buffer_size[i]; 328 total_used += buffer_size[i]; 329 } 330 331 mlx5e_dbg(HW, priv, "%s: total buffer requested=%d\n", __func__, total_used); 332 333 if (total_used > port_buffer.port_buffer_size) 334 return -EINVAL; 335 336 update_buffer = true; 337 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz); 338 if (err) 339 return err; 340 } 341 342 /* Need to update buffer configuration if xoff value is changed */ 343 if (!update_buffer && xoff != priv->dcbx.xoff) { 344 update_buffer = true; 345 err = update_xoff_threshold(&port_buffer, xoff, max_mtu, port_buff_cell_sz); 346 if (err) 347 return err; 348 } 349 priv->dcbx.xoff = xoff; 350 351 /* Apply the settings */ 352 if (update_buffer) { 353 err = port_set_buffer(priv, &port_buffer); 354 if (err) 355 return err; 356 } 357 358 if (update_prio2buffer) 359 err = mlx5e_port_set_priority2buffer(priv->mdev, prio2buffer); 360 361 return err; 362 } 363