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
 396         MLX5_SET(mcia_reg, in, l, 0);
 397         MLX5_SET(mcia_reg, in, module, module_num);
 398         MLX5_SET(mcia_reg, in, i2c_device_address, i2c_addr);
 399         MLX5_SET(mcia_reg, in, page_number, 0);
 400         MLX5_SET(mcia_reg, in, device_address, offset);
 401         MLX5_SET(mcia_reg, in, size, size);
 402
 403         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 404                                    sizeof(out), MLX5_REG_MCIA, 0, 0);
 405         if (err)
 406                 return err;
 407
 408         status = MLX5_GET(mcia_reg, out, status);
 409         if (status) {
 410                 mlx5_core_err(dev, "query_mcia_reg failed: status: 0x%x\n",
 411                               status);
 412                 return -EIO;
 413         }
 414
 415         memcpy(data, ptr, size);
 416
 417         return size;
 418 }
 419 EXPORT_SYMBOL_GPL(mlx5_query_module_eeprom);
 420
 421 static int mlx5_query_port_pvlc(struct mlx5_core_dev *dev, u32 *pvlc,
 422                                 int pvlc_size,  u8 local_port)
 423 {
 424         u32 in[MLX5_ST_SZ_DW(pvlc_reg)] = {0};
 425
 426         MLX5_SET(pvlc_reg, in, local_port, local_port);
 427         return mlx5_core_access_reg(dev, in, sizeof(in), pvlc,
 428                                     pvlc_size, MLX5_REG_PVLC, 0, 0);
 429 }
 430
 431 int mlx5_query_port_vl_hw_cap(struct mlx5_core_dev *dev,
 432                               u8 *vl_hw_cap, u8 local_port)
 433 {
 434         u32 out[MLX5_ST_SZ_DW(pvlc_reg)];
 435         int err;
 436
 437         err = mlx5_query_port_pvlc(dev, out, sizeof(out), local_port);
 438         if (err)
 439                 return err;
 440
 441         *vl_hw_cap = MLX5_GET(pvlc_reg, out, vl_hw_cap);
 442
 443         return 0;
 444 }
 445 EXPORT_SYMBOL_GPL(mlx5_query_port_vl_hw_cap);
 446
 447 int mlx5_core_query_ib_ppcnt(struct mlx5_core_dev *dev,
 448                              u8 port_num, void *out, size_t sz)
 449 {
 450         u32 *in;
 451         int err;
 452
 453         in  = kvzalloc(sz, GFP_KERNEL);
 454         if (!in) {
 455                 err = -ENOMEM;
 456                 return err;
 457         }
 458
 459         MLX5_SET(ppcnt_reg, in, local_port, port_num);
 460
 461         MLX5_SET(ppcnt_reg, in, grp, MLX5_INFINIBAND_PORT_COUNTERS_GROUP);
 462         err = mlx5_core_access_reg(dev, in, sz, out,
 463                                    sz, MLX5_REG_PPCNT, 0, 0);
 464
 465         kvfree(in);
 466         return err;
 467 }
 468 EXPORT_SYMBOL_GPL(mlx5_core_query_ib_ppcnt);
 469
 470 int mlx5_set_port_pause(struct mlx5_core_dev *dev, u32 rx_pause, u32 tx_pause)
 471 {
 472         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 473         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 474
 475         MLX5_SET(pfcc_reg, in, local_port, 1);
 476         MLX5_SET(pfcc_reg, in, pptx, tx_pause);
 477         MLX5_SET(pfcc_reg, in, pprx, rx_pause);
 478
 479         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 480                                     sizeof(out), MLX5_REG_PFCC, 0, 1);
 481 }
 482 EXPORT_SYMBOL_GPL(mlx5_set_port_pause);
 483
 484 int mlx5_query_port_pause(struct mlx5_core_dev *dev,
 485                           u32 *rx_pause, u32 *tx_pause)
 486 {
 487         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 488         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 489         int err;
 490
 491         MLX5_SET(pfcc_reg, in, local_port, 1);
 492         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 493                                    sizeof(out), MLX5_REG_PFCC, 0, 0);
 494         if (err)
 495                 return err;
 496
 497         if (rx_pause)
 498                 *rx_pause = MLX5_GET(pfcc_reg, out, pprx);
 499
 500         if (tx_pause)
 501                 *tx_pause = MLX5_GET(pfcc_reg, out, pptx);
 502
 503         return 0;
 504 }
 505 EXPORT_SYMBOL_GPL(mlx5_query_port_pause);
 506
 507 int mlx5_set_port_pfc(struct mlx5_core_dev *dev, u8 pfc_en_tx, u8 pfc_en_rx)
 508 {
 509         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 510         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 511
 512         MLX5_SET(pfcc_reg, in, local_port, 1);
 513         MLX5_SET(pfcc_reg, in, pfctx, pfc_en_tx);
 514         MLX5_SET(pfcc_reg, in, pfcrx, pfc_en_rx);
 515         MLX5_SET_TO_ONES(pfcc_reg, in, prio_mask_tx);
 516         MLX5_SET_TO_ONES(pfcc_reg, in, prio_mask_rx);
 517
 518         return mlx5_core_access_reg(dev, in, sizeof(in), out,
 519                                     sizeof(out), MLX5_REG_PFCC, 0, 1);
 520 }
 521 EXPORT_SYMBOL_GPL(mlx5_set_port_pfc);
 522
 523 int mlx5_query_port_pfc(struct mlx5_core_dev *dev, u8 *pfc_en_tx, u8 *pfc_en_rx)
 524 {
 525         u32 in[MLX5_ST_SZ_DW(pfcc_reg)] = {0};
 526         u32 out[MLX5_ST_SZ_DW(pfcc_reg)];
 527         int err;
 528
 529         MLX5_SET(pfcc_reg, in, local_port, 1);
 530         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 531                                    sizeof(out), MLX5_REG_PFCC, 0, 0);
 532         if (err)
 533                 return err;
 534
 535         if (pfc_en_tx)
 536                 *pfc_en_tx = MLX5_GET(pfcc_reg, out, pfctx);
 537
 538         if (pfc_en_rx)
 539                 *pfc_en_rx = MLX5_GET(pfcc_reg, out, pfcrx);
 540
 541         return 0;
 542 }
 543 EXPORT_SYMBOL_GPL(mlx5_query_port_pfc);
 544
 545 void mlx5_query_port_autoneg(struct mlx5_core_dev *dev, int proto_mask,
 546                              u8 *an_status,
 547                              u8 *an_disable_cap, u8 *an_disable_admin)
 548 {
 549         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
 550
 551         *an_status = 0;
 552         *an_disable_cap = 0;
 553         *an_disable_admin = 0;
 554
 555         if (mlx5_query_port_ptys(dev, out, sizeof(out), proto_mask, 1))
 556                 return;
 557
 558         *an_status = MLX5_GET(ptys_reg, out, an_status);
 559         *an_disable_cap = MLX5_GET(ptys_reg, out, an_disable_cap);
 560         *an_disable_admin = MLX5_GET(ptys_reg, out, an_disable_admin);
 561 }
 562 EXPORT_SYMBOL_GPL(mlx5_query_port_autoneg);
 563
 564 int mlx5_max_tc(struct mlx5_core_dev *mdev)
 565 {
 566         u8 num_tc = MLX5_CAP_GEN(mdev, max_tc) ? : 8;
 567
 568         return num_tc - 1;
 569 }
 570
 571 int mlx5_query_port_dcbx_param(struct mlx5_core_dev *mdev, u32 *out)
 572 {
 573         u32 in[MLX5_ST_SZ_DW(dcbx_param)] = {0};
 574
 575         MLX5_SET(dcbx_param, in, port_number, 1);
 576
 577         return  mlx5_core_access_reg(mdev, in, sizeof(in), out,
 578                                     sizeof(in), MLX5_REG_DCBX_PARAM, 0, 0);
 579 }
 580
 581 int mlx5_set_port_dcbx_param(struct mlx5_core_dev *mdev, u32 *in)
 582 {
 583         u32 out[MLX5_ST_SZ_DW(dcbx_param)];
 584
 585         MLX5_SET(dcbx_param, in, port_number, 1);
 586
 587         return mlx5_core_access_reg(mdev, in, sizeof(out), out,
 588                                     sizeof(out), MLX5_REG_DCBX_PARAM, 0, 1);
 589 }
 590
 591 int mlx5_set_port_prio_tc(struct mlx5_core_dev *mdev, u8 *prio_tc)
 592 {
 593         u32 in[MLX5_ST_SZ_DW(qtct_reg)] = {0};
 594         u32 out[MLX5_ST_SZ_DW(qtct_reg)];
 595         int err;
 596         int i;
 597
 598         for (i = 0; i < 8; i++) {
 599                 if (prio_tc[i] > mlx5_max_tc(mdev))
 600                         return -EINVAL;
 601
 602                 MLX5_SET(qtct_reg, in, prio, i);
 603                 MLX5_SET(qtct_reg, in, tclass, prio_tc[i]);
 604
 605                 err = mlx5_core_access_reg(mdev, in, sizeof(in), out,
 606                                            sizeof(out), MLX5_REG_QTCT, 0, 1);
 607                 if (err)
 608                         return err;
 609         }
 610
 611         return 0;
 612 }
 613 EXPORT_SYMBOL_GPL(mlx5_set_port_prio_tc);
 614
 615 int mlx5_query_port_prio_tc(struct mlx5_core_dev *mdev,
 616                             u8 prio, u8 *tc)
 617 {
 618         u32 in[MLX5_ST_SZ_DW(qtct_reg)];
 619         u32 out[MLX5_ST_SZ_DW(qtct_reg)];
 620         int err;
 621
 622         memset(in, 0, sizeof(in));
 623         memset(out, 0, sizeof(out));
 624
 625         MLX5_SET(qtct_reg, in, port_number, 1);
 626         MLX5_SET(qtct_reg, in, prio, prio);
 627
 628         err = mlx5_core_access_reg(mdev, in, sizeof(in), out,
 629                                    sizeof(out), MLX5_REG_QTCT, 0, 0);
 630         if (!err)
 631                 *tc = MLX5_GET(qtct_reg, out, tclass);
 632
 633         return err;
 634 }
 635 EXPORT_SYMBOL_GPL(mlx5_query_port_prio_tc);
 636
 637 static int mlx5_set_port_qetcr_reg(struct mlx5_core_dev *mdev, u32 *in,
 638                                    int inlen)
 639 {
 640         u32 out[MLX5_ST_SZ_DW(qetc_reg)];
 641
 642         if (!MLX5_CAP_GEN(mdev, ets))
 643                 return -EOPNOTSUPP;
 644
 645         return mlx5_core_access_reg(mdev, in, inlen, out, sizeof(out),
 646                                     MLX5_REG_QETCR, 0, 1);
 647 }
 648
 649 static int mlx5_query_port_qetcr_reg(struct mlx5_core_dev *mdev, u32 *out,
 650                                      int outlen)
 651 {
 652         u32 in[MLX5_ST_SZ_DW(qetc_reg)];
 653
 654         if (!MLX5_CAP_GEN(mdev, ets))
 655                 return -EOPNOTSUPP;
 656
 657         memset(in, 0, sizeof(in));
 658         return mlx5_core_access_reg(mdev, in, sizeof(in), out, outlen,
 659                                     MLX5_REG_QETCR, 0, 0);
 660 }
 661
 662 int mlx5_set_port_tc_group(struct mlx5_core_dev *mdev, u8 *tc_group)
 663 {
 664         u32 in[MLX5_ST_SZ_DW(qetc_reg)] = {0};
 665         int i;
 666
 667         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 668                 MLX5_SET(qetc_reg, in, tc_configuration[i].g, 1);
 669                 MLX5_SET(qetc_reg, in, tc_configuration[i].group, tc_group[i]);
 670         }
 671
 672         return mlx5_set_port_qetcr_reg(mdev, in, sizeof(in));
 673 }
 674 EXPORT_SYMBOL_GPL(mlx5_set_port_tc_group);
 675
 676 int mlx5_query_port_tc_group(struct mlx5_core_dev *mdev,
 677                              u8 tc, u8 *tc_group)
 678 {
 679         u32 out[MLX5_ST_SZ_DW(qetc_reg)];
 680         void *ets_tcn_conf;
 681         int err;
 682
 683         err = mlx5_query_port_qetcr_reg(mdev, out, sizeof(out));
 684         if (err)
 685                 return err;
 686
 687         ets_tcn_conf = MLX5_ADDR_OF(qetc_reg, out,
 688                                     tc_configuration[tc]);
 689
 690         *tc_group = MLX5_GET(ets_tcn_config_reg, ets_tcn_conf,
 691                              group);
 692
 693         return 0;
 694 }
 695 EXPORT_SYMBOL_GPL(mlx5_query_port_tc_group);
 696
 697 int mlx5_set_port_tc_bw_alloc(struct mlx5_core_dev *mdev, u8 *tc_bw)
 698 {
 699         u32 in[MLX5_ST_SZ_DW(qetc_reg)] = {0};
 700         int i;
 701
 702         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 703                 MLX5_SET(qetc_reg, in, tc_configuration[i].b, 1);
 704                 MLX5_SET(qetc_reg, in, tc_configuration[i].bw_allocation, tc_bw[i]);
 705         }
 706
 707         return mlx5_set_port_qetcr_reg(mdev, in, sizeof(in));
 708 }
 709 EXPORT_SYMBOL_GPL(mlx5_set_port_tc_bw_alloc);
 710
 711 int mlx5_query_port_tc_bw_alloc(struct mlx5_core_dev *mdev,
 712                                 u8 tc, u8 *bw_pct)
 713 {
 714         u32 out[MLX5_ST_SZ_DW(qetc_reg)];
 715         void *ets_tcn_conf;
 716         int err;
 717
 718         err = mlx5_query_port_qetcr_reg(mdev, out, sizeof(out));
 719         if (err)
 720                 return err;
 721
 722         ets_tcn_conf = MLX5_ADDR_OF(qetc_reg, out,
 723                                     tc_configuration[tc]);
 724
 725         *bw_pct = MLX5_GET(ets_tcn_config_reg, ets_tcn_conf,
 726                            bw_allocation);
 727
 728         return 0;
 729 }
 730 EXPORT_SYMBOL_GPL(mlx5_query_port_tc_bw_alloc);
 731
 732 int mlx5_modify_port_ets_rate_limit(struct mlx5_core_dev *mdev,
 733                                     u8 *max_bw_value,
 734                                     u8 *max_bw_units)
 735 {
 736         u32 in[MLX5_ST_SZ_DW(qetc_reg)] = {0};
 737         void *ets_tcn_conf;
 738         int i;
 739
 740         MLX5_SET(qetc_reg, in, port_number, 1);
 741
 742         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 743                 ets_tcn_conf = MLX5_ADDR_OF(qetc_reg, in, tc_configuration[i]);
 744
 745                 MLX5_SET(ets_tcn_config_reg, ets_tcn_conf, r, 1);
 746                 MLX5_SET(ets_tcn_config_reg, ets_tcn_conf, max_bw_units,
 747                          max_bw_units[i]);
 748                 MLX5_SET(ets_tcn_config_reg, ets_tcn_conf, max_bw_value,
 749                          max_bw_value[i]);
 750         }
 751
 752         return mlx5_set_port_qetcr_reg(mdev, in, sizeof(in));
 753 }
 754 EXPORT_SYMBOL_GPL(mlx5_modify_port_ets_rate_limit);
 755
 756 int mlx5_query_port_ets_rate_limit(struct mlx5_core_dev *mdev,
 757                                    u8 *max_bw_value,
 758                                    u8 *max_bw_units)
 759 {
 760         u32 out[MLX5_ST_SZ_DW(qetc_reg)];
 761         void *ets_tcn_conf;
 762         int err;
 763         int i;
 764
 765         err = mlx5_query_port_qetcr_reg(mdev, out, sizeof(out));
 766         if (err)
 767                 return err;
 768
 769         for (i = 0; i <= mlx5_max_tc(mdev); i++) {
 770                 ets_tcn_conf = MLX5_ADDR_OF(qetc_reg, out, tc_configuration[i]);
 771
 772                 max_bw_value[i] = MLX5_GET(ets_tcn_config_reg, ets_tcn_conf,
 773                                            max_bw_value);
 774                 max_bw_units[i] = MLX5_GET(ets_tcn_config_reg, ets_tcn_conf,
 775                                            max_bw_units);
 776         }
 777
 778         return 0;
 779 }
 780 EXPORT_SYMBOL_GPL(mlx5_query_port_ets_rate_limit);
 781
 782 int mlx5_set_port_wol(struct mlx5_core_dev *mdev, u8 wol_mode)
 783 {
 784         u32 in[MLX5_ST_SZ_DW(set_wol_rol_in)]   = {0};
 785         u32 out[MLX5_ST_SZ_DW(set_wol_rol_out)] = {0};
 786
 787         MLX5_SET(set_wol_rol_in, in, opcode, MLX5_CMD_OP_SET_WOL_ROL);
 788         MLX5_SET(set_wol_rol_in, in, wol_mode_valid, 1);
 789         MLX5_SET(set_wol_rol_in, in, wol_mode, wol_mode);
 790         return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 791 }
 792 EXPORT_SYMBOL_GPL(mlx5_set_port_wol);
 793
 794 int mlx5_query_port_wol(struct mlx5_core_dev *mdev, u8 *wol_mode)
 795 {
 796         u32 in[MLX5_ST_SZ_DW(query_wol_rol_in)]   = {0};
 797         u32 out[MLX5_ST_SZ_DW(query_wol_rol_out)] = {0};
 798         int err;
 799
 800         MLX5_SET(query_wol_rol_in, in, opcode, MLX5_CMD_OP_QUERY_WOL_ROL);
 801         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 802         if (!err)
 803                 *wol_mode = MLX5_GET(query_wol_rol_out, out, wol_mode);
 804
 805         return err;
 806 }
 807 EXPORT_SYMBOL_GPL(mlx5_query_port_wol);
 808
 809 static int mlx5_query_ports_check(struct mlx5_core_dev *mdev, u32 *out,
 810                                   int outlen)
 811 {
 812         u32 in[MLX5_ST_SZ_DW(pcmr_reg)] = {0};
 813
 814         MLX5_SET(pcmr_reg, in, local_port, 1);
 815         return mlx5_core_access_reg(mdev, in, sizeof(in), out,
 816                                     outlen, MLX5_REG_PCMR, 0, 0);
 817 }
 818
 819 static int mlx5_set_ports_check(struct mlx5_core_dev *mdev, u32 *in, int inlen)
 820 {
 821         u32 out[MLX5_ST_SZ_DW(pcmr_reg)];
 822
 823         return mlx5_core_access_reg(mdev, in, inlen, out,
 824                                     sizeof(out), MLX5_REG_PCMR, 0, 1);
 825 }
 826
 827 int mlx5_set_port_fcs(struct mlx5_core_dev *mdev, u8 enable)
 828 {
 829         u32 in[MLX5_ST_SZ_DW(pcmr_reg)] = {0};
 830
 831         MLX5_SET(pcmr_reg, in, local_port, 1);
 832         MLX5_SET(pcmr_reg, in, fcs_chk, enable);
 833         return mlx5_set_ports_check(mdev, in, sizeof(in));
 834 }
 835
 836 void mlx5_query_port_fcs(struct mlx5_core_dev *mdev, bool *supported,
 837                          bool *enabled)
 838 {
 839         u32 out[MLX5_ST_SZ_DW(pcmr_reg)];
 840         /* Default values for FW which do not support MLX5_REG_PCMR */
 841         *supported = false;
 842         *enabled = true;
 843
 844         if (!MLX5_CAP_GEN(mdev, ports_check))
 845                 return;
 846
 847         if (mlx5_query_ports_check(mdev, out, sizeof(out)))
 848                 return;
 849
 850         *supported = !!(MLX5_GET(pcmr_reg, out, fcs_cap));
 851         *enabled = !!(MLX5_GET(pcmr_reg, out, fcs_chk));
 852 }
 853
 854 static const char *mlx5_pme_status[MLX5_MODULE_STATUS_NUM] = {
 855         "Cable plugged",   /* MLX5_MODULE_STATUS_PLUGGED    = 0x1 */
 856         "Cable unplugged", /* MLX5_MODULE_STATUS_UNPLUGGED  = 0x2 */
 857         "Cable error",     /* MLX5_MODULE_STATUS_ERROR      = 0x3 */
 858 };
 859
 860 static const char *mlx5_pme_error[MLX5_MODULE_EVENT_ERROR_NUM] = {
 861         "Power budget exceeded",
 862         "Long Range for non MLNX cable",
 863         "Bus stuck(I2C or data shorted)",
 864         "No EEPROM/retry timeout",
 865         "Enforce part number list",
 866         "Unknown identifier",
 867         "High Temperature",
 868         "Bad or shorted cable/module",
 869         "Unknown status",
 870 };
 871
 872 void mlx5_port_module_event(struct mlx5_core_dev *dev, struct mlx5_eqe *eqe)
 873 {
 874         enum port_module_event_status_type module_status;
 875         enum port_module_event_error_type error_type;
 876         struct mlx5_eqe_port_module *module_event_eqe;
 877         struct mlx5_priv *priv = &dev->priv;
 878         u8 module_num;
 879
 880         module_event_eqe = &eqe->data.port_module;
 881         module_num = module_event_eqe->module;
 882         module_status = module_event_eqe->module_status &
 883                         PORT_MODULE_EVENT_MODULE_STATUS_MASK;
 884         error_type = module_event_eqe->error_type &
 885                      PORT_MODULE_EVENT_ERROR_TYPE_MASK;
 886
 887         if (module_status < MLX5_MODULE_STATUS_ERROR) {
 888                 priv->pme_stats.status_counters[module_status - 1]++;
 889         } else if (module_status == MLX5_MODULE_STATUS_ERROR) {
 890                 if (error_type >= MLX5_MODULE_EVENT_ERROR_UNKNOWN)
 891                         /* Unknown error type */
 892                         error_type = MLX5_MODULE_EVENT_ERROR_UNKNOWN;
 893                 priv->pme_stats.error_counters[error_type]++;
 894         }
 895
 896         if (!printk_ratelimit())
 897                 return;
 898
 899         if (module_status < MLX5_MODULE_STATUS_ERROR)
 900                 mlx5_core_info(dev,
 901                                "Port module event: module %u, %s\n",
 902                                module_num, mlx5_pme_status[module_status - 1]);
 903
 904         else if (module_status == MLX5_MODULE_STATUS_ERROR)
 905                 mlx5_core_info(dev,
 906                                "Port module event[error]: module %u, %s, %s\n",
 907                                module_num, mlx5_pme_status[module_status - 1],
 908                                mlx5_pme_error[error_type]);
 909 }
 910
 911 int mlx5_query_mtpps(struct mlx5_core_dev *mdev, u32 *mtpps, u32 mtpps_size)
 912 {
 913         u32 in[MLX5_ST_SZ_DW(mtpps_reg)] = {0};
 914
 915         return mlx5_core_access_reg(mdev, in, sizeof(in), mtpps,
 916                                     mtpps_size, MLX5_REG_MTPPS, 0, 0);
 917 }
 918
 919 int mlx5_set_mtpps(struct mlx5_core_dev *mdev, u32 *mtpps, u32 mtpps_size)
 920 {
 921         u32 out[MLX5_ST_SZ_DW(mtpps_reg)] = {0};
 922
 923         return mlx5_core_access_reg(mdev, mtpps, mtpps_size, out,
 924                                     sizeof(out), MLX5_REG_MTPPS, 0, 1);
 925 }
 926
 927 int mlx5_query_mtppse(struct mlx5_core_dev *mdev, u8 pin, u8 *arm, u8 *mode)
 928 {
 929         u32 out[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 930         u32 in[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 931         int err = 0;
 932
 933         MLX5_SET(mtppse_reg, in, pin, pin);
 934
 935         err = mlx5_core_access_reg(mdev, in, sizeof(in), out,
 936                                    sizeof(out), MLX5_REG_MTPPSE, 0, 0);
 937         if (err)
 938                 return err;
 939
 940         *arm = MLX5_GET(mtppse_reg, in, event_arm);
 941         *mode = MLX5_GET(mtppse_reg, in, event_generation_mode);
 942
 943         return err;
 944 }
 945
 946 int mlx5_set_mtppse(struct mlx5_core_dev *mdev, u8 pin, u8 arm, u8 mode)
 947 {
 948         u32 out[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 949         u32 in[MLX5_ST_SZ_DW(mtppse_reg)] = {0};
 950
 951         MLX5_SET(mtppse_reg, in, pin, pin);
 952         MLX5_SET(mtppse_reg, in, event_arm, arm);
 953         MLX5_SET(mtppse_reg, in, event_generation_mode, mode);
 954
 955         return mlx5_core_access_reg(mdev, in, sizeof(in), out,
 956                                     sizeof(out), MLX5_REG_MTPPSE, 0, 1);
 957 }