drivers/net/ethernet/mellanox/mlx5/core/port.c

   1 /*
   2  * Copyright (c) 2013-2015, 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
  33 #include <linux/module.h>
  34 #include <linux/mlx5/driver.h>
  35 #include <linux/mlx5/port.h>
  36 #include <linux/mlx5/cmd.h>
  37 #include "mlx5_core.h"
  38
  39 int mlx5_core_access_reg(struct mlx5_core_dev *dev, void *data_in,
  40                          int size_in, void *data_out, int size_out,
  41                          u16 reg_id, int arg, int write)
  42 {
  43         int outlen = MLX5_ST_SZ_BYTES(access_register_out) + size_out;
  44         int inlen = MLX5_ST_SZ_BYTES(access_register_in) + size_in;
  45         int err = -ENOMEM;
  46         u32 *out = NULL;
  47         u32 *in = NULL;
  48         void *data;
  49
  50         in = kvzalloc(inlen, GFP_KERNEL);
  51         out = kvzalloc(outlen, GFP_KERNEL);
  52         if (!in || !out)
  53                 goto out;
  54
  55         data = MLX5_ADDR_OF(access_register_in, in, register_data);
  56         memcpy(data, data_in, size_in);
  57
  58         MLX5_SET(access_register_in, in, opcode, MLX5_CMD_OP_ACCESS_REG);
  59         MLX5_SET(access_register_in, in, op_mod, !write);
  60         MLX5_SET(access_register_in, in, argument, arg);
  61         MLX5_SET(access_register_in, in, register_id, reg_id);
  62
  63         err = mlx5_cmd_exec(dev, in, inlen, out, outlen);
  64         if (err)
  65                 goto out;
  66
  67         data = MLX5_ADDR_OF(access_register_out, out, register_data);
  68         memcpy(data_out, data, size_out);
  69
  70 out:
  71         kvfree(out);
  72         kvfree(in);
  73         return err;
  74 }
  75 EXPORT_SYMBOL_GPL(mlx5_core_access_reg);
  76
  77 int mlx5_query_pcam_reg(struct mlx5_core_dev *dev, u32 *pcam, u8 feature_group,
  78                         u8 access_reg_group)
  79 {
  80         u32 in[MLX5_ST_SZ_DW(pcam_reg)] = {0};
  81         int sz = MLX5_ST_SZ_BYTES(pcam_reg);
  82
  83         MLX5_SET(pcam_reg, in, feature_group, feature_group);
  84         MLX5_SET(pcam_reg, in, access_reg_group, access_reg_group);
  85
  86         return mlx5_core_access_reg(dev, in, sz, pcam, sz, MLX5_REG_PCAM, 0, 0);
  87 }
  88
  89 int mlx5_query_mcam_reg(struct mlx5_core_dev *dev, u32 *mcam, u8 feature_group,
  90                         u8 access_reg_group)
  91 {
  92         u32 in[MLX5_ST_SZ_DW(mcam_reg)] = {0};
  93         int sz = MLX5_ST_SZ_BYTES(mcam_reg);
  94
  95         MLX5_SET(mcam_reg, in, feature_group, feature_group);
  96         MLX5_SET(mcam_reg, in, access_reg_group, access_reg_group);
  97
  98         return mlx5_core_access_reg(dev, in, sz, mcam, sz, MLX5_REG_MCAM, 0, 0);
  99 }
 100
 101 struct mlx5_reg_pcap {
 102         u8                      rsvd0;
 103         u8                      port_num;
 104         u8                      rsvd1[2];
 105         __be32                  caps_127_96;
 106         __be32                  caps_95_64;
 107         __be32                  caps_63_32;
 108         __be32                  caps_31_0;
 109 };
 110
 111 int mlx5_set_port_caps(struct mlx5_core_dev *dev, u8 port_num, u32 caps)
 112 {
 113         struct mlx5_reg_pcap in;
 114         struct mlx5_reg_pcap out;
 115
 116         memset(&in, 0, sizeof(in));
 117         in.caps_127_96 = cpu_to_be32(caps);
 118         in.port_num = port_num;
 119
 120         return mlx5_core_access_reg(dev, &in, sizeof(in), &out,
 121                                     sizeof(out), MLX5_REG_PCAP, 0, 1);
 122 }
 123 EXPORT_SYMBOL_GPL(mlx5_set_port_caps);
 124
 125 int mlx5_query_port_ptys(struct mlx5_core_dev *dev, u32 *ptys,
 126                          int ptys_size, int proto_mask, u8 local_port)
 127 {
 128         u32 in[MLX5_ST_SZ_DW(ptys_reg)] = {0};
 129
 130         MLX5_SET(ptys_reg, in, local_port, local_port);
 131         MLX5_SET(ptys_reg, in, proto_mask, proto_mask);
 132         return mlx5_core_access_reg(dev, in, sizeof(in), ptys,
 133                                     ptys_size, MLX5_REG_PTYS, 0, 0);
 134 }
 135 EXPORT_SYMBOL_GPL(mlx5_query_port_ptys);
 136
 137 int mlx5_set_port_beacon(struct mlx5_core_dev *dev, u16 beacon_duration)
 138 {
 139         u32 in[MLX5_ST_SZ_DW(mlcr_reg)]  = {0};
 140         u32 out[MLX5_ST_SZ_DW(mlcr_reg)];
 141
 142         MLX5_SET(mlcr_reg, in, local_port, 1);
 143         MLX5_SET(mlcr_reg, in, beacon_duration, beacon_duration);
 144         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 145                                     sizeof(out), MLX5_REG_MLCR, 0, 1);
 146 }
 147
 148 int mlx5_query_port_proto_cap(struct mlx5_core_dev *dev,
 149                               u32 *proto_cap, int proto_mask)
 150 {
 151         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 152         int err;
 153
 154         err = mlx5_query_port_ptys(dev, out, sizeof(out), proto_mask, 1);
 155         if (err)
 156                 return err;
 157
 158         if (proto_mask == MLX5_PTYS_EN)
 159                 *proto_cap = MLX5_GET(ptys_reg, out, eth_proto_capability);
 160         else
 161                 *proto_cap = MLX5_GET(ptys_reg, out, ib_proto_capability);
 162
 163         return 0;
 164 }
 165 EXPORT_SYMBOL_GPL(mlx5_query_port_proto_cap);
 166
 167 int mlx5_query_port_proto_admin(struct mlx5_core_dev *dev,
 168                                 u32 *proto_admin, int proto_mask)
 169 {
 170         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 171         int err;
 172
 173         err = mlx5_query_port_ptys(dev, out, sizeof(out), proto_mask, 1);
 174         if (err)
 175                 return err;
 176
 177         if (proto_mask == MLX5_PTYS_EN)
 178                 *proto_admin = MLX5_GET(ptys_reg, out, eth_proto_admin);
 179         else
 180                 *proto_admin = MLX5_GET(ptys_reg, out, ib_proto_admin);
 181
 182         return 0;
 183 }
 184 EXPORT_SYMBOL_GPL(mlx5_query_port_proto_admin);
 185
 186 int mlx5_query_port_link_width_oper(struct mlx5_core_dev *dev,
 187                                     u8 *link_width_oper, u8 local_port)
 188 {
 189         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 190         int err;
 191
 192         err = mlx5_query_port_ptys(dev, out, sizeof(out), MLX5_PTYS_IB, local_port);
 193         if (err)
 194                 return err;
 195
 196         *link_width_oper = MLX5_GET(ptys_reg, out, ib_link_width_oper);
 197
 198         return 0;
 199 }
 200 EXPORT_SYMBOL_GPL(mlx5_query_port_link_width_oper);
 201
 202 int mlx5_query_port_eth_proto_oper(struct mlx5_core_dev *dev,
 203                                    u32 *proto_oper, u8 local_port)
 204 {
 205         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 206         int err;
 207
 208         err = mlx5_query_port_ptys(dev, out, sizeof(out), MLX5_PTYS_EN,
 209                                    local_port);
 210         if (err)
 211                 return err;
 212
 213         *proto_oper = MLX5_GET(ptys_reg, out, eth_proto_oper);
 214
 215         return 0;
 216 }
 217 EXPORT_SYMBOL(mlx5_query_port_eth_proto_oper);
 218
 219 int mlx5_query_port_ib_proto_oper(struct mlx5_core_dev *dev,
 220                                   u8 *proto_oper, u8 local_port)
 221 {
 222         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 223         int err;
 224
 225         err = mlx5_query_port_ptys(dev, out, sizeof(out), MLX5_PTYS_IB,
 226                                    local_port);
 227         if (err)
 228                 return err;
 229
 230         *proto_oper = MLX5_GET(ptys_reg, out, ib_proto_oper);
 231
 232         return 0;
 233 }
 234 EXPORT_SYMBOL(mlx5_query_port_ib_proto_oper);
 235
 236 int mlx5_set_port_ptys(struct mlx5_core_dev *dev, bool an_disable,
 237                        u32 proto_admin, int proto_mask)
 238 {
 239         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 240         u32 in[MLX5_ST_SZ_DW(ptys_reg)];
 241         u8 an_disable_admin;
 242         u8 an_disable_cap;
 243         u8 an_status;
 244
 245         mlx5_query_port_autoneg(dev, proto_mask, &an_status,
 246                                 &an_disable_cap, &an_disable_admin);
 247         if (!an_disable_cap && an_disable)
 248                 return -EPERM;
 249
 250         memset(in, 0, sizeof(in));
 251
 252         MLX5_SET(ptys_reg, in, local_port, 1);
 253         MLX5_SET(ptys_reg, in, an_disable_admin, an_disable);
 254         MLX5_SET(ptys_reg, in, proto_mask, proto_mask);
 255         if (proto_mask == MLX5_PTYS_EN)
 256                 MLX5_SET(ptys_reg, in, eth_proto_admin, proto_admin);
 257         else
 258                 MLX5_SET(ptys_reg, in, ib_proto_admin, proto_admin);
 259
 260         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 261                                     sizeof(out), MLX5_REG_PTYS, 0, 1);
 262 }
 263 EXPORT_SYMBOL_GPL(mlx5_set_port_ptys);
 264
 265 /* This function should be used after setting a port register only */
 266 void mlx5_toggle_port_link(struct mlx5_core_dev *dev)
 267 {
 268         enum mlx5_port_status ps;
 269
 270         mlx5_query_port_admin_status(dev, &ps);
 271         mlx5_set_port_admin_status(dev, MLX5_PORT_DOWN);
 272         if (ps == MLX5_PORT_UP)
 273                 mlx5_set_port_admin_status(dev, MLX5_PORT_UP);
 274 }
 275 EXPORT_SYMBOL_GPL(mlx5_toggle_port_link);
 276
 277 int mlx5_set_port_admin_status(struct mlx5_core_dev *dev,
 278                                enum mlx5_port_status status)
 279 {
 280         u32 in[MLX5_ST_SZ_DW(paos_reg)] = {0};
 281         u32 out[MLX5_ST_SZ_DW(paos_reg)];
 282
 283         MLX5_SET(paos_reg, in, local_port, 1);
 284         MLX5_SET(paos_reg, in, admin_status, status);
 285         MLX5_SET(paos_reg, in, ase, 1);
 286         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 287                                     sizeof(out), MLX5_REG_PAOS, 0, 1);
 288 }
 289 EXPORT_SYMBOL_GPL(mlx5_set_port_admin_status);
 290
 291 int mlx5_query_port_admin_status(struct mlx5_core_dev *dev,
 292                                  enum mlx5_port_status *status)
 293 {
 294         u32 in[MLX5_ST_SZ_DW(paos_reg)] = {0};
 295         u32 out[MLX5_ST_SZ_DW(paos_reg)];
 296         int err;
 297
 298         MLX5_SET(paos_reg, in, local_port, 1);
 299         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 300                                    sizeof(out), MLX5_REG_PAOS, 0, 0);
 301         if (err)
 302                 return err;
 303         *status = MLX5_GET(paos_reg, out, admin_status);
 304         return 0;
 305 }
 306 EXPORT_SYMBOL_GPL(mlx5_query_port_admin_status);
 307
 308 static void mlx5_query_port_mtu(struct mlx5_core_dev *dev, u16 *admin_mtu,
 309                                 u16 *max_mtu, u16 *oper_mtu, u8 port)
 310 {
 311         u32 in[MLX5_ST_SZ_DW(pmtu_reg)] = {0};
 312         u32 out[MLX5_ST_SZ_DW(pmtu_reg)];
 313
 314         MLX5_SET(pmtu_reg, in, local_port, port);
 315         mlx5_core_access_reg(dev, in, sizeof(in), out,
 316                              sizeof(out), MLX5_REG_PMTU, 0, 0);
 317
 318         if (max_mtu)
 319                 *max_mtu  = MLX5_GET(pmtu_reg, out, max_mtu);
 320         if (oper_mtu)
 321                 *oper_mtu = MLX5_GET(pmtu_reg, out, oper_mtu);
 322         if (admin_mtu)
 323                 *admin_mtu = MLX5_GET(pmtu_reg, out, admin_mtu);
 324 }
 325
 326 int mlx5_set_port_mtu(struct mlx5_core_dev *dev, u16 mtu, u8 port)
 327 {
 328         u32 in[MLX5_ST_SZ_DW(pmtu_reg)] = {0};
 329         u32 out[MLX5_ST_SZ_DW(pmtu_reg)];
 330
 331         MLX5_SET(pmtu_reg, in, admin_mtu, mtu);
 332         MLX5_SET(pmtu_reg, in, local_port, port);
 333         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 334                                    sizeof(out), MLX5_REG_PMTU, 0, 1);
 335 }
 336 EXPORT_SYMBOL_GPL(mlx5_set_port_mtu);
 337
 338 void mlx5_query_port_max_mtu(struct mlx5_core_dev *dev, u16 *max_mtu,
 339                              u8 port)
 340 {
 341         mlx5_query_port_mtu(dev, NULL, max_mtu, NULL, port);
 342 }
 343 EXPORT_SYMBOL_GPL(mlx5_query_port_max_mtu);
 344
 345 void mlx5_query_port_oper_mtu(struct mlx5_core_dev *dev, u16 *oper_mtu,
 346                               u8 port)
 347 {
 348         mlx5_query_port_mtu(dev, NULL, NULL, oper_mtu, port);
 349 }
 350 EXPORT_SYMBOL_GPL(mlx5_query_port_oper_mtu);
 351
 352 static int mlx5_query_module_num(struct mlx5_core_dev *dev, int *module_num)
 353 {
 354         u32 in[MLX5_ST_SZ_DW(pmlp_reg)] = {0};
 355         u32 out[MLX5_ST_SZ_DW(pmlp_reg)];
 356         int module_mapping;
 357         int err;
 358
 359         MLX5_SET(pmlp_reg, in, local_port, 1);
 360         err = mlx5_core_access_reg(dev, in, sizeof(in), out, sizeof(out),
 361                                    MLX5_REG_PMLP, 0, 0);
 362         if (err)
 363                 return err;
 364
 365         module_mapping = MLX5_GET(pmlp_reg, out, lane0_module_mapping);
 366         *module_num = module_mapping & MLX5_EEPROM_IDENTIFIER_BYTE_MASK;
 367
 368         return 0;
 369 }
 370
 371 int mlx5_query_module_eeprom(struct mlx5_core_dev *dev,
 372                              u16 offset, u16 size, u8 *data)
 373 {
 374         u32 out[MLX5_ST_SZ_DW(mcia_reg)];
 375         u32 in[MLX5_ST_SZ_DW(mcia_reg)];
 376         int module_num;
 377         u16 i2c_addr;
 378         int status;
 379         int err;
 380         void *ptr = MLX5_ADDR_OF(mcia_reg, out, dword_0);
 381
 382         err = mlx5_query_module_num(dev, &module_num);
 383         if (err)
 384                 return err;
 385
 386         memset(in, 0, sizeof(in));
 387         size = min_t(int, size, MLX5_EEPROM_MAX_BYTES);
 388
 389         if (offset < MLX5_EEPROM_PAGE_LENGTH &&
 390             offset + size > MLX5_EEPROM_PAGE_LENGTH)
 391                 /* Cross pages read, read until offset 256 in low page */
 392                 size -= offset + size - MLX5_EEPROM_PAGE_LENGTH;
 393
 394         i2c_addr = MLX5_I2C_ADDR_LOW;
 395         if (offset >= MLX5_EEPROM_PAGE_LENGTH) {
 396                 i2c_addr = MLX5_I2C_ADDR_HIGH;
 397                 offset -= MLX5_EEPROM_PAGE_LENGTH;
 398         }
 399
 400         MLX5_SET(mcia_reg, in, l, 0);
 401         MLX5_SET(mcia_reg, in, module, module_num);
 402         MLX5_SET(mcia_reg, in, i2c_device_address, i2c_addr);
 403         MLX5_SET(mcia_reg, in, page_number, 0);
 404         MLX5_SET(mcia_reg, in, device_address, offset);
 405         MLX5_SET(mcia_reg, in, size, size);
 406
 407         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 408                                    sizeof(out), MLX5_REG_MCIA, 0, 0);
 409         if (err)
 410                 return err;
 411
 412         status = MLX5_GET(mcia_reg, out, status);
 413         if (status) {
 414                 mlx5_core_err(dev, "query_mcia_reg failed: status: 0x%x\n",
 415                               status);
 416                 return -EIO;
 417         }
 418
 419         memcpy(data, ptr, size);
 420
 421         return size;
 422 }
 423 EXPORT_SYMBOL_GPL(mlx5_query_module_eeprom);
 424
 425 static int mlx5_query_port_pvlc(struct mlx5_core_dev *dev, u32 *pvlc,
 426                                 int pvlc_size,  u8 local_port)
 427 {
 428         u32 in[MLX5_ST_SZ_DW(pvlc_reg)] = {0};
 429
 430         MLX5_SET(pvlc_reg, in, local_port, local_port);
 431         return mlx5_core_access_reg(dev, in, sizeof(in), pvlc,
 432                                     pvlc_size, MLX5_REG_PVLC, 0, 0);
 433 }
 434
 435 int mlx5_query_port_vl_hw_cap(struct mlx5_core_dev *dev,
 436                               u8 *vl_hw_cap, u8 local_port)
 437 {
 438         u32 out[MLX5_ST_SZ_DW(pvlc_reg)];
 439         int err;
 440
 441         err = mlx5_query_port_pvlc(dev, out, sizeof(out), local_port);
 442         if (err)
 443                 return err;
 444
 445         *vl_hw_cap = MLX5_GET(pvlc_reg, out, vl_hw_cap);
 446
 447         return 0;
 448 }
 449 EXPORT_SYMBOL_GPL(mlx5_query_port_vl_hw_cap);
 450
 451 int mlx5_core_query_ib_ppcnt(struct mlx5_core_dev *dev,
 452                              u8 port_num, void *out, size_t sz)
 453 {
 454         u32 *in;
 455         int err;
 456
 457         in  = kvzalloc(sz, GFP_KERNEL);
 458         if (!in) {
 459                 err = -ENOMEM;
 460                 return err;
 461         }
 462
 463         MLX5_SET(ppcnt_reg, in, local_port, port_num);
 464
 465         MLX5_SET(ppcnt_reg, in, grp, MLX5_INFINIBAND_PORT_COUNTERS_GROUP);
 466         err = mlx5_core_access_reg(dev, in, sz, out,
 467                                    sz, MLX5_REG_PPCNT, 0, 0);
 468
 469         kvfree(in);
 470         return err;
 471 }
 472 EXPORT_SYMBOL_GPL(mlx5_core_query_ib_ppcnt);
 473
 474 int mlx5_set_port_pause(struct mlx5_core_dev *dev, u32 rx_pause, u32 tx_pause)
 475 {
 476         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 477         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 478
 479         MLX5_SET(pfcc_reg, in, local_port, 1);
 480         MLX5_SET(pfcc_reg, in, pptx, tx_pause);
 481         MLX5_SET(pfcc_reg, in, pprx, rx_pause);
 482
 483         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 484                                     sizeof(out), MLX5_REG_PFCC, 0, 1);
 485 }
 486 EXPORT_SYMBOL_GPL(mlx5_set_port_pause);
 487
 488 int mlx5_query_port_pause(struct mlx5_core_dev *dev,
 489                           u32 *rx_pause, u32 *tx_pause)
 490 {
 491         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 492         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 493         int err;
 494
 495         MLX5_SET(pfcc_reg, in, local_port, 1);
 496         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 497                                    sizeof(out), MLX5_REG_PFCC, 0, 0);
 498         if (err)
 499                 return err;
 500
 501         if (rx_pause)
 502                 *rx_pause = MLX5_GET(pfcc_reg, out, pprx);
 503
 504         if (tx_pause)
 505                 *tx_pause = MLX5_GET(pfcc_reg, out, pptx);
 506
 507         return 0;
 508 }
 509 EXPORT_SYMBOL_GPL(mlx5_query_port_pause);
 510
 511 int mlx5_set_port_pfc(struct mlx5_core_dev *dev, u8 pfc_en_tx, u8 pfc_en_rx)
 512 {
 513         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 514         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 515
 516         MLX5_SET(pfcc_reg, in, local_port, 1);
 517         MLX5_SET(pfcc_reg, in, pfctx, pfc_en_tx);
 518         MLX5_SET(pfcc_reg, in, pfcrx, pfc_en_rx);
 519         MLX5_SET_TO_ONES(pfcc_reg, in, prio_mask_tx);
 520         MLX5_SET_TO_ONES(pfcc_reg, in, prio_mask_rx);
 521
 522         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 523                                     sizeof(out), MLX5_REG_PFCC, 0, 1);
 524 }
 525 EXPORT_SYMBOL_GPL(mlx5_set_port_pfc);
 526
 527 int mlx5_query_port_pfc(struct mlx5_core_dev *dev, u8 *pfc_en_tx, u8 *pfc_en_rx)
 528 {
 529         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 530         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 531         int err;
 532
 533         MLX5_SET(pfcc_reg, in, local_port, 1);
 534         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 535                                    sizeof(out), MLX5_REG_PFCC, 0, 0);
 536         if (err)
 537                 return err;
 538
 539         if (pfc_en_tx)
 540                 *pfc_en_tx = MLX5_GET(pfcc_reg, out, pfctx);
 541
 542         if (pfc_en_rx)
 543                 *pfc_en_rx = MLX5_GET(pfcc_reg, out, pfcrx);
 544
 545         return 0;
 546 }
 547 EXPORT_SYMBOL_GPL(mlx5_query_port_pfc);
 548
 549 void mlx5_query_port_autoneg(struct mlx5_core_dev *dev, int proto_mask,
 550                              u8 *an_status,
 551                              u8 *an_disable_cap, u8 *an_disable_admin)
 552 {
 553         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 554
 555         *an_status = 0;
 556         *an_disable_cap = 0;
 557         *an_disable_admin = 0;
 558
 559         if (mlx5_query_port_ptys(dev, out, sizeof(out), proto_mask, 1))
 560                 return;
 561
 562         *an_status = MLX5_GET(ptys_reg, out, an_status);
 563         *an_disable_cap = MLX5_GET(ptys_reg, out, an_disable_cap);
 564         *an_disable_admin = MLX5_GET(ptys_reg, out, an_disable_admin);
 565 }
 566 EXPORT_SYMBOL_GPL(mlx5_query_port_autoneg);
 567
 568 int mlx5_max_tc(struct mlx5_core_dev *mdev)
 569 {
 570         u8 num_tc = MLX5_CAP_GEN(mdev, max_tc) ? : 8;
 571
 572         return num_tc - 1;
 573 }
 574
 575 int mlx5_query_port_dcbx_param(struct mlx5_core_dev *mdev, u32 *out)
 576 {
 577         u32 in[MLX5_ST_SZ_DW(dcbx_param)] = {0};
 578
 579         MLX5_SET(dcbx_param, in, port_number, 1);
 580
 581         return  mlx5_core_access_reg(mdev, in, sizeof(in), out,
 582                                     sizeof(in), MLX5_REG_DCBX_PARAM, 0, 0);
 583 }
 584
 585 int mlx5_set_port_dcbx_param(struct mlx5_core_dev *mdev, u32 *in)
 586 {
 587         u32 out[MLX5_ST_SZ_DW(dcbx_param)];
 588
 589         MLX5_SET(dcbx_param, in, port_number, 1);
 590
 591         return mlx5_core_access_reg(mdev, in, sizeof(out), out,
 592                                     sizeof(out), MLX5_REG_DCBX_PARAM, 0, 1);
 593 }
 594
 595 int mlx5_set_port_prio_tc(struct mlx5_core_dev *mdev, u8 *prio_tc)
 596 {
 597         u32 in[MLX5_ST_SZ_DW(qtct_reg)] = {0};
 598         u32 out[MLX5_ST_SZ_DW(qtct_reg)];
 599         int err;
 600         int i;
 601
 602         for (i = 0; i < 8; i++) {
 603                 if (prio_tc[i] > mlx5_max_tc(mdev))
 604                         return -EINVAL;
 605
 606                 MLX5_SET(qtct_reg, in, prio, i);
 607                 MLX5_SET(qtct_reg, in, tclass, prio_tc[i]);
 608
 609                 err = mlx5_core_access_reg(mdev, in, sizeof(in), out,
 610                                            sizeof(out), MLX5_REG_QTCT, 0, 1);
 611                 if (err)
 612                         return err;
 613         }
 614
 615         return 0;
 616 }
 617 EXPORT_SYMBOL_GPL(mlx5_set_port_prio_tc);
 618
 619 int mlx5_query_port_prio_tc(struct mlx5_core_dev *mdev,
 620                             u8 prio, u8 *tc)
 621 {
 622         u32 in[MLX5_ST_SZ_DW(qtct_reg)];
 623         u32 out[MLX5_ST_SZ_DW(qtct_reg)];
 624         int err;
 625
 626         memset(in, 0, sizeof(in));
 627         memset(out, 0, sizeof(out));
 628
 629         MLX5_SET(qtct_reg, in, port_number, 1);
 630         MLX5_SET(qtct_reg, in, prio, prio);
 631
 632         err = mlx5_core_access_reg(mdev, in, sizeof(in), out,
 633                                    sizeof(out), MLX5_REG_QTCT, 0, 0);
 634         if (!err)
 635                 *tc = MLX5_GET(qtct_reg, out, tclass);
 636
 637         return err;
 638 }
 639 EXPORT_SYMBOL_GPL(mlx5_query_port_prio_tc);
 640
 641 static int mlx5_set_port_qetcr_reg(struct mlx5_core_dev *mdev, u32 *in,
 642                                    int inlen)
 643 {
 644         u32 out[MLX5_ST_SZ_DW(qtct_reg)];
 645
 646         if (!MLX5_CAP_GEN(mdev, ets))
 647                 return -EOPNOTSUPP;
 648
 649         return mlx5_core_access_reg(mdev, in, inlen, out, sizeof(out),
 650                                     MLX5_REG_QETCR, 0, 1);
 651 }
 652
 653 static int mlx5_query_port_qetcr_reg(struct mlx5_core_dev *mdev, u32 *out,
 654                                      int outlen)
 655 {
 656         u32 in[MLX5_ST_SZ_DW(qtct_reg)];
 657
 658         if (!MLX5_CAP_GEN(mdev, ets))
 659                 return -EOPNOTSUPP;
 660
 661         memset(in, 0, sizeof(in));
 662         return mlx5_core_access_reg(mdev, in, sizeof(in), out, outlen,
 663                                     MLX5_REG_QETCR, 0, 0);
 664 }
 665
 666 int mlx5_set_port_tc_group(struct mlx5_core_dev *mdev, u8 *tc_group)
 667 {
 668         u32 in[MLX5_ST_SZ_DW(qetc_reg)] = {0};
 669         int i;
 670
 671         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 672                 MLX5_SET(qetc_reg, in, tc_configuration[i].g, 1);
 673                 MLX5_SET(qetc_reg, in, tc_configuration[i].group, tc_group[i]);
 674         }
 675
 676         return mlx5_set_port_qetcr_reg(mdev, in, sizeof(in));
 677 }
 678 EXPORT_SYMBOL_GPL(mlx5_set_port_tc_group);
 679
 680 int mlx5_set_port_tc_bw_alloc(struct mlx5_core_dev *mdev, u8 *tc_bw)
 681 {
 682         u32 in[MLX5_ST_SZ_DW(qetc_reg)] = {0};
 683         int i;
 684
 685         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 686                 MLX5_SET(qetc_reg, in, tc_configuration[i].b, 1);
 687                 MLX5_SET(qetc_reg, in, tc_configuration[i].bw_allocation, tc_bw[i]);
 688         }
 689
 690         return mlx5_set_port_qetcr_reg(mdev, in, sizeof(in));
 691 }
 692 EXPORT_SYMBOL_GPL(mlx5_set_port_tc_bw_alloc);
 693
 694 int mlx5_query_port_tc_bw_alloc(struct mlx5_core_dev *mdev,
 695                                 u8 tc, u8 *bw_pct)
 696 {
 697         u32 out[MLX5_ST_SZ_DW(qetc_reg)];
 698         void *ets_tcn_conf;
 699         int err;
 700
 701         err = mlx5_query_port_qetcr_reg(mdev, out, sizeof(out));
 702         if (err)
 703                 return err;
 704
 705         ets_tcn_conf = MLX5_ADDR_OF(qetc_reg, out,
 706                                     tc_configuration[tc]);
 707
 708         *bw_pct = MLX5_GET(ets_tcn_config_reg, ets_tcn_conf,
 709                            bw_allocation);
 710
 711         return 0;
 712 }
 713 EXPORT_SYMBOL_GPL(mlx5_query_port_tc_bw_alloc);
 714
 715 int mlx5_modify_port_ets_rate_limit(struct mlx5_core_dev *mdev,
 716                                     u8 *max_bw_value,
 717                                     u8 *max_bw_units)
 718 {
 719         u32 in[MLX5_ST_SZ_DW(qetc_reg)] = {0};
 720         void *ets_tcn_conf;
 721         int i;
 722
 723         MLX5_SET(qetc_reg, in, port_number, 1);
 724
 725         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 726                 ets_tcn_conf = MLX5_ADDR_OF(qetc_reg, in, tc_configuration[i]);
 727
 728                 MLX5_SET(ets_tcn_config_reg, ets_tcn_conf, r, 1);
 729                 MLX5_SET(ets_tcn_config_reg, ets_tcn_conf, max_bw_units,
 730                          max_bw_units[i]);
 731                 MLX5_SET(ets_tcn_config_reg, ets_tcn_conf, max_bw_value,
 732                          max_bw_value[i]);
 733         }
 734
 735         return mlx5_set_port_qetcr_reg(mdev, in, sizeof(in));
 736 }
 737 EXPORT_SYMBOL_GPL(mlx5_modify_port_ets_rate_limit);
 738
 739 int mlx5_query_port_ets_rate_limit(struct mlx5_core_dev *mdev,
 740                                    u8 *max_bw_value,
 741                                    u8 *max_bw_units)
 742 {
 743         u32 out[MLX5_ST_SZ_DW(qetc_reg)];
 744         void *ets_tcn_conf;
 745         int err;
 746         int i;
 747
 748         err = mlx5_query_port_qetcr_reg(mdev, out, sizeof(out));
 749         if (err)
 750                 return err;
 751
 752         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 753                 ets_tcn_conf = MLX5_ADDR_OF(qetc_reg, out, tc_configuration[i]);
 754
 755                 max_bw_value[i] = MLX5_GET(ets_tcn_config_reg, ets_tcn_conf,
 756                                            max_bw_value);
 757                 max_bw_units[i] = MLX5_GET(ets_tcn_config_reg, ets_tcn_conf,
 758                                            max_bw_units);
 759         }
 760
 761         return 0;
 762 }
 763 EXPORT_SYMBOL_GPL(mlx5_query_port_ets_rate_limit);
 764
 765 int mlx5_set_port_wol(struct mlx5_core_dev *mdev, u8 wol_mode)
 766 {
 767         u32 in[MLX5_ST_SZ_DW(set_wol_rol_in)]   = {0};
 768         u32 out[MLX5_ST_SZ_DW(set_wol_rol_out)] = {0};
 769
 770         MLX5_SET(set_wol_rol_in, in, opcode, MLX5_CMD_OP_SET_WOL_ROL);
 771         MLX5_SET(set_wol_rol_in, in, wol_mode_valid, 1);
 772         MLX5_SET(set_wol_rol_in, in, wol_mode, wol_mode);
 773         return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 774 }
 775 EXPORT_SYMBOL_GPL(mlx5_set_port_wol);
 776
 777 int mlx5_query_port_wol(struct mlx5_core_dev *mdev, u8 *wol_mode)
 778 {
 779         u32 in[MLX5_ST_SZ_DW(query_wol_rol_in)]   = {0};
 780         u32 out[MLX5_ST_SZ_DW(query_wol_rol_out)] = {0};
 781         int err;
 782
 783         MLX5_SET(query_wol_rol_in, in, opcode, MLX5_CMD_OP_QUERY_WOL_ROL);
 784         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 785         if (!err)
 786                 *wol_mode = MLX5_GET(query_wol_rol_out, out, wol_mode);
 787
 788         return err;
 789 }
 790 EXPORT_SYMBOL_GPL(mlx5_query_port_wol);
 791
 792 static int mlx5_query_ports_check(struct mlx5_core_dev *mdev, u32 *out,
 793                                   int outlen)
 794 {
 795         u32 in[MLX5_ST_SZ_DW(pcmr_reg)] = {0};
 796
 797         MLX5_SET(pcmr_reg, in, local_port, 1);
 798         return mlx5_core_access_reg(mdev, in, sizeof(in), out,
 799                                     outlen, MLX5_REG_PCMR, 0, 0);
 800 }
 801
 802 static int mlx5_set_ports_check(struct mlx5_core_dev *mdev, u32 *in, int inlen)
 803 {
 804         u32 out[MLX5_ST_SZ_DW(pcmr_reg)];
 805
 806         return mlx5_core_access_reg(mdev, in, inlen, out,
 807                                     sizeof(out), MLX5_REG_PCMR, 0, 1);
 808 }
 809
 810 int mlx5_set_port_fcs(struct mlx5_core_dev *mdev, u8 enable)
 811 {
 812         u32 in[MLX5_ST_SZ_DW(pcmr_reg)] = {0};
 813
 814         MLX5_SET(pcmr_reg, in, local_port, 1);
 815         MLX5_SET(pcmr_reg, in, fcs_chk, enable);
 816         return mlx5_set_ports_check(mdev, in, sizeof(in));
 817 }
 818
 819 void mlx5_query_port_fcs(struct mlx5_core_dev *mdev, bool *supported,
 820                          bool *enabled)
 821 {
 822         u32 out[MLX5_ST_SZ_DW(pcmr_reg)];
 823         /* Default values for FW which do not support MLX5_REG_PCMR */
 824         *supported = false;
 825         *enabled = true;
 826
 827         if (!MLX5_CAP_GEN(mdev, ports_check))
 828                 return;
 829
 830         if (mlx5_query_ports_check(mdev, out, sizeof(out)))
 831                 return;
 832
 833         *supported = !!(MLX5_GET(pcmr_reg, out, fcs_cap));
 834         *enabled = !!(MLX5_GET(pcmr_reg, out, fcs_chk));
 835 }
 836
 837 static const char *mlx5_pme_status[MLX5_MODULE_STATUS_NUM] = {
 838         "Cable plugged",   /* MLX5_MODULE_STATUS_PLUGGED    = 0x1 */
 839         "Cable unplugged", /* MLX5_MODULE_STATUS_UNPLUGGED  = 0x2 */
 840         "Cable error",     /* MLX5_MODULE_STATUS_ERROR      = 0x3 */
 841 };
 842
 843 static const char *mlx5_pme_error[MLX5_MODULE_EVENT_ERROR_NUM] = {
 844         "Power budget exceeded",
 845         "Long Range for non MLNX cable",
 846         "Bus stuck(I2C or data shorted)",
 847         "No EEPROM/retry timeout",
 848         "Enforce part number list",
 849         "Unknown identifier",
 850         "High Temperature",
 851         "Bad or shorted cable/module",
 852         "Unknown status",
 853 };
 854
 855 void mlx5_port_module_event(struct mlx5_core_dev *dev, struct mlx5_eqe *eqe)
 856 {
 857         enum port_module_event_status_type module_status;
 858         enum port_module_event_error_type error_type;
 859         struct mlx5_eqe_port_module *module_event_eqe;
 860         struct mlx5_priv *priv = &dev->priv;
 861         u8 module_num;
 862
 863         module_event_eqe = &eqe->data.port_module;
 864         module_num = module_event_eqe->module;
 865         module_status = module_event_eqe->module_status &
 866                         PORT_MODULE_EVENT_MODULE_STATUS_MASK;
 867         error_type = module_event_eqe->error_type &
 868                      PORT_MODULE_EVENT_ERROR_TYPE_MASK;
 869
 870         if (module_status < MLX5_MODULE_STATUS_ERROR) {
 871                 priv->pme_stats.status_counters[module_status - 1]++;
 872         } else if (module_status == MLX5_MODULE_STATUS_ERROR) {
 873                 if (error_type >= MLX5_MODULE_EVENT_ERROR_UNKNOWN)
 874                         /* Unknown error type */
 875                         error_type = MLX5_MODULE_EVENT_ERROR_UNKNOWN;
 876                 priv->pme_stats.error_counters[error_type]++;
 877         }
 878
 879         if (!printk_ratelimit())
 880                 return;
 881
 882         if (module_status < MLX5_MODULE_STATUS_ERROR)
 883                 mlx5_core_info(dev,
 884                                "Port module event: module %u, %s\n",
 885                                module_num, mlx5_pme_status[module_status - 1]);
 886
 887         else if (module_status == MLX5_MODULE_STATUS_ERROR)
 888                 mlx5_core_info(dev,
 889                                "Port module event[error]: module %u, %s, %s\n",
 890                                module_num, mlx5_pme_status[module_status - 1],
 891                                mlx5_pme_error[error_type]);
 892 }
 893
 894 int mlx5_query_mtpps(struct mlx5_core_dev *mdev, u32 *mtpps, u32 mtpps_size)
 895 {
 896         u32 in[MLX5_ST_SZ_DW(mtpps_reg)] = {0};
 897
 898         return mlx5_core_access_reg(mdev, in, sizeof(in), mtpps,
 899                                     mtpps_size, MLX5_REG_MTPPS, 0, 0);
 900 }
 901
 902 int mlx5_set_mtpps(struct mlx5_core_dev *mdev, u32 *mtpps, u32 mtpps_size)
 903 {
 904         u32 out[MLX5_ST_SZ_DW(mtpps_reg)] = {0};
 905
 906         return mlx5_core_access_reg(mdev, mtpps, mtpps_size, out,
 907                                     sizeof(out), MLX5_REG_MTPPS, 0, 1);
 908 }
 909
 910 int mlx5_query_mtppse(struct mlx5_core_dev *mdev, u8 pin, u8 *arm, u8 *mode)
 911 {
 912         u32 out[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 913         u32 in[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 914         int err = 0;
 915
 916         MLX5_SET(mtppse_reg, in, pin, pin);
 917
 918         err = mlx5_core_access_reg(mdev, in, sizeof(in), out,
 919                                    sizeof(out), MLX5_REG_MTPPSE, 0, 0);
 920         if (err)
 921                 return err;
 922
 923         *arm = MLX5_GET(mtppse_reg, in, event_arm);
 924         *mode = MLX5_GET(mtppse_reg, in, event_generation_mode);
 925
 926         return err;
 927 }
 928
 929 int mlx5_set_mtppse(struct mlx5_core_dev *mdev, u8 pin, u8 arm, u8 mode)
 930 {
 931         u32 out[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 932         u32 in[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 933
 934         MLX5_SET(mtppse_reg, in, pin, pin);
 935         MLX5_SET(mtppse_reg, in, event_arm, arm);
 936         MLX5_SET(mtppse_reg, in, event_generation_mode, mode);
 937
 938         return mlx5_core_access_reg(mdev, in, sizeof(in), out,
 939                                     sizeof(out), MLX5_REG_MTPPSE, 0, 1);
 940 }