core.c 85.3 KB
Newer Older
1 2
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
3 4 5 6 7 8 9 10

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/export.h>
#include <linux/err.h>
#include <linux/if_link.h>
#include <linux/netdevice.h>
11
#include <linux/completion.h>
12 13 14 15 16 17 18 19 20 21
#include <linux/skbuff.h>
#include <linux/etherdevice.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/gfp.h>
#include <linux/random.h>
#include <linux/jiffies.h>
#include <linux/mutex.h>
#include <linux/rcupdate.h>
#include <linux/slab.h>
22
#include <linux/workqueue.h>
23
#include <linux/firmware.h>
24
#include <asm/byteorder.h>
J
Jiri Pirko 已提交
25
#include <net/devlink.h>
J
Jiri Pirko 已提交
26
#include <trace/events/devlink.h>
27 28 29 30 31 32

#include "core.h"
#include "item.h"
#include "cmd.h"
#include "port.h"
#include "trap.h"
33 34
#include "emad.h"
#include "reg.h"
J
Jiri Pirko 已提交
35
#include "resources.h"
36
#include "../mlxfw/mlxfw.h"
37 38 39 40 41 42

static LIST_HEAD(mlxsw_core_driver_list);
static DEFINE_SPINLOCK(mlxsw_core_driver_list_lock);

static const char mlxsw_core_driver_name[] = "mlxsw_core";

43
static struct workqueue_struct *mlxsw_wq;
44
static struct workqueue_struct *mlxsw_owq;
45

46 47 48
struct mlxsw_core_port {
	struct devlink_port devlink_port;
	void *port_driver_priv;
49
	u8 local_port;
50 51 52 53 54 55 56 57 58 59 60 61 62
};

void *mlxsw_core_port_driver_priv(struct mlxsw_core_port *mlxsw_core_port)
{
	return mlxsw_core_port->port_driver_priv;
}
EXPORT_SYMBOL(mlxsw_core_port_driver_priv);

static bool mlxsw_core_port_check(struct mlxsw_core_port *mlxsw_core_port)
{
	return mlxsw_core_port->port_driver_priv != NULL;
}

63 64 65 66 67
struct mlxsw_core {
	struct mlxsw_driver *driver;
	const struct mlxsw_bus *bus;
	void *bus_priv;
	const struct mlxsw_bus_info *bus_info;
I
Ido Schimmel 已提交
68
	struct workqueue_struct *emad_wq;
69
	struct list_head rx_listener_list;
70 71
	struct list_head event_listener_list;
	struct {
72 73 74
		atomic64_t tid;
		struct list_head trans_list;
		spinlock_t trans_list_lock; /* protects trans_list writes */
75
		bool use_emad;
76
		bool enable_string_tlv;
77
	} emad;
78 79 80
	struct {
		u8 *mapping; /* lag_id+port_index to local_port mapping */
	} lag;
J
Jiri Pirko 已提交
81
	struct mlxsw_res res;
82
	struct mlxsw_hwmon *hwmon;
I
Ivan Vecera 已提交
83
	struct mlxsw_thermal *thermal;
84 85
	struct mlxsw_core_port *ports;
	unsigned int max_ports;
86
	bool fw_flash_in_progress;
87 88 89
	struct {
		struct devlink_health_reporter *fw_fatal;
	} health;
90
	unsigned long driver_priv[];
91 92 93
	/* driver_priv has to be always the last item */
};

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
#define MLXSW_PORT_MAX_PORTS_DEFAULT	0x40

static int mlxsw_ports_init(struct mlxsw_core *mlxsw_core)
{
	/* Switch ports are numbered from 1 to queried value */
	if (MLXSW_CORE_RES_VALID(mlxsw_core, MAX_SYSTEM_PORT))
		mlxsw_core->max_ports = MLXSW_CORE_RES_GET(mlxsw_core,
							   MAX_SYSTEM_PORT) + 1;
	else
		mlxsw_core->max_ports = MLXSW_PORT_MAX_PORTS_DEFAULT + 1;

	mlxsw_core->ports = kcalloc(mlxsw_core->max_ports,
				    sizeof(struct mlxsw_core_port), GFP_KERNEL);
	if (!mlxsw_core->ports)
		return -ENOMEM;

	return 0;
}

static void mlxsw_ports_fini(struct mlxsw_core *mlxsw_core)
{
	kfree(mlxsw_core->ports);
}

unsigned int mlxsw_core_max_ports(const struct mlxsw_core *mlxsw_core)
{
	return mlxsw_core->max_ports;
}
EXPORT_SYMBOL(mlxsw_core_max_ports);

124 125 126 127 128 129
void *mlxsw_core_driver_priv(struct mlxsw_core *mlxsw_core)
{
	return mlxsw_core->driver_priv;
}
EXPORT_SYMBOL(mlxsw_core_driver_priv);

130 131 132 133 134 135
bool mlxsw_core_res_query_enabled(const struct mlxsw_core *mlxsw_core)
{
	return mlxsw_core->driver->res_query_enabled;
}
EXPORT_SYMBOL(mlxsw_core_res_query_enabled);

136 137 138 139 140 141 142 143 144 145
bool
mlxsw_core_fw_rev_minor_subminor_validate(const struct mlxsw_fw_rev *rev,
					  const struct mlxsw_fw_rev *req_rev)
{
	return rev->minor > req_rev->minor ||
	       (rev->minor == req_rev->minor &&
		rev->subminor >= req_rev->subminor);
}
EXPORT_SYMBOL(mlxsw_core_fw_rev_minor_subminor_validate);

146 147 148 149
struct mlxsw_rx_listener_item {
	struct list_head list;
	struct mlxsw_rx_listener rxl;
	void *priv;
150
	bool enabled;
151 152
};

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
struct mlxsw_event_listener_item {
	struct list_head list;
	struct mlxsw_event_listener el;
	void *priv;
};

/******************
 * EMAD processing
 ******************/

/* emad_eth_hdr_dmac
 * Destination MAC in EMAD's Ethernet header.
 * Must be set to 01:02:c9:00:00:01
 */
MLXSW_ITEM_BUF(emad, eth_hdr, dmac, 0x00, 6);

/* emad_eth_hdr_smac
 * Source MAC in EMAD's Ethernet header.
 * Must be set to 00:02:c9:01:02:03
 */
MLXSW_ITEM_BUF(emad, eth_hdr, smac, 0x06, 6);

/* emad_eth_hdr_ethertype
 * Ethertype in EMAD's Ethernet header.
 * Must be set to 0x8932
 */
MLXSW_ITEM32(emad, eth_hdr, ethertype, 0x0C, 16, 16);

/* emad_eth_hdr_mlx_proto
 * Mellanox protocol.
 * Must be set to 0x0.
 */
MLXSW_ITEM32(emad, eth_hdr, mlx_proto, 0x0C, 8, 8);

/* emad_eth_hdr_ver
 * Mellanox protocol version.
 * Must be set to 0x0.
 */
MLXSW_ITEM32(emad, eth_hdr, ver, 0x0C, 4, 4);

/* emad_op_tlv_type
 * Type of the TLV.
 * Must be set to 0x1 (operation TLV).
 */
MLXSW_ITEM32(emad, op_tlv, type, 0x00, 27, 5);

/* emad_op_tlv_len
 * Length of the operation TLV in u32.
 * Must be set to 0x4.
 */
MLXSW_ITEM32(emad, op_tlv, len, 0x00, 16, 11);

/* emad_op_tlv_dr
 * Direct route bit. Setting to 1 indicates the EMAD is a direct route
 * EMAD. DR TLV must follow.
 *
 * Note: Currently not supported and must not be set.
 */
MLXSW_ITEM32(emad, op_tlv, dr, 0x00, 15, 1);

/* emad_op_tlv_status
 * Returned status in case of EMAD response. Must be set to 0 in case
 * of EMAD request.
 * 0x0 - success
 * 0x1 - device is busy. Requester should retry
 * 0x2 - Mellanox protocol version not supported
 * 0x3 - unknown TLV
 * 0x4 - register not supported
 * 0x5 - operation class not supported
 * 0x6 - EMAD method not supported
 * 0x7 - bad parameter (e.g. port out of range)
 * 0x8 - resource not available
 * 0x9 - message receipt acknowledgment. Requester should retry
 * 0x70 - internal error
 */
MLXSW_ITEM32(emad, op_tlv, status, 0x00, 8, 7);

/* emad_op_tlv_register_id
 * Register ID of register within register TLV.
 */
MLXSW_ITEM32(emad, op_tlv, register_id, 0x04, 16, 16);

/* emad_op_tlv_r
 * Response bit. Setting to 1 indicates Response, otherwise request.
 */
MLXSW_ITEM32(emad, op_tlv, r, 0x04, 15, 1);

/* emad_op_tlv_method
 * EMAD method type.
 * 0x1 - query
 * 0x2 - write
 * 0x3 - send (currently not supported)
 * 0x4 - event
 */
MLXSW_ITEM32(emad, op_tlv, method, 0x04, 8, 7);

/* emad_op_tlv_class
 * EMAD operation class. Must be set to 0x1 (REG_ACCESS).
 */
MLXSW_ITEM32(emad, op_tlv, class, 0x04, 0, 8);

/* emad_op_tlv_tid
 * EMAD transaction ID. Used for pairing request and response EMADs.
 */
MLXSW_ITEM64(emad, op_tlv, tid, 0x08, 0, 64);

S
Shalom Toledo 已提交
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
/* emad_string_tlv_type
 * Type of the TLV.
 * Must be set to 0x2 (string TLV).
 */
MLXSW_ITEM32(emad, string_tlv, type, 0x00, 27, 5);

/* emad_string_tlv_len
 * Length of the string TLV in u32.
 */
MLXSW_ITEM32(emad, string_tlv, len, 0x00, 16, 11);

#define MLXSW_EMAD_STRING_TLV_STRING_LEN 128

/* emad_string_tlv_string
 * String provided by the device's firmware in case of erroneous register access
 */
MLXSW_ITEM_BUF(emad, string_tlv, string, 0x04,
	       MLXSW_EMAD_STRING_TLV_STRING_LEN);

278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
/* emad_reg_tlv_type
 * Type of the TLV.
 * Must be set to 0x3 (register TLV).
 */
MLXSW_ITEM32(emad, reg_tlv, type, 0x00, 27, 5);

/* emad_reg_tlv_len
 * Length of the operation TLV in u32.
 */
MLXSW_ITEM32(emad, reg_tlv, len, 0x00, 16, 11);

/* emad_end_tlv_type
 * Type of the TLV.
 * Must be set to 0x0 (end TLV).
 */
MLXSW_ITEM32(emad, end_tlv, type, 0x00, 27, 5);

/* emad_end_tlv_len
 * Length of the end TLV in u32.
 * Must be set to 1.
 */
MLXSW_ITEM32(emad, end_tlv, len, 0x00, 16, 11);

enum mlxsw_core_reg_access_type {
	MLXSW_CORE_REG_ACCESS_TYPE_QUERY,
	MLXSW_CORE_REG_ACCESS_TYPE_WRITE,
};

static inline const char *
mlxsw_core_reg_access_type_str(enum mlxsw_core_reg_access_type type)
{
	switch (type) {
	case MLXSW_CORE_REG_ACCESS_TYPE_QUERY:
		return "query";
	case MLXSW_CORE_REG_ACCESS_TYPE_WRITE:
		return "write";
	}
	BUG();
}

static void mlxsw_emad_pack_end_tlv(char *end_tlv)
{
	mlxsw_emad_end_tlv_type_set(end_tlv, MLXSW_EMAD_TLV_TYPE_END);
	mlxsw_emad_end_tlv_len_set(end_tlv, MLXSW_EMAD_END_TLV_LEN);
}

static void mlxsw_emad_pack_reg_tlv(char *reg_tlv,
				    const struct mlxsw_reg_info *reg,
				    char *payload)
{
	mlxsw_emad_reg_tlv_type_set(reg_tlv, MLXSW_EMAD_TLV_TYPE_REG);
	mlxsw_emad_reg_tlv_len_set(reg_tlv, reg->len / sizeof(u32) + 1);
	memcpy(reg_tlv + sizeof(u32), payload, reg->len);
}

333 334 335 336 337 338
static void mlxsw_emad_pack_string_tlv(char *string_tlv)
{
	mlxsw_emad_string_tlv_type_set(string_tlv, MLXSW_EMAD_TLV_TYPE_STRING);
	mlxsw_emad_string_tlv_len_set(string_tlv, MLXSW_EMAD_STRING_TLV_LEN);
}

339 340 341
static void mlxsw_emad_pack_op_tlv(char *op_tlv,
				   const struct mlxsw_reg_info *reg,
				   enum mlxsw_core_reg_access_type type,
342
				   u64 tid)
343 344 345 346 347 348 349
{
	mlxsw_emad_op_tlv_type_set(op_tlv, MLXSW_EMAD_TLV_TYPE_OP);
	mlxsw_emad_op_tlv_len_set(op_tlv, MLXSW_EMAD_OP_TLV_LEN);
	mlxsw_emad_op_tlv_dr_set(op_tlv, 0);
	mlxsw_emad_op_tlv_status_set(op_tlv, 0);
	mlxsw_emad_op_tlv_register_id_set(op_tlv, reg->id);
	mlxsw_emad_op_tlv_r_set(op_tlv, MLXSW_EMAD_OP_TLV_REQUEST);
350
	if (type == MLXSW_CORE_REG_ACCESS_TYPE_QUERY)
351 352 353 354 355 356 357
		mlxsw_emad_op_tlv_method_set(op_tlv,
					     MLXSW_EMAD_OP_TLV_METHOD_QUERY);
	else
		mlxsw_emad_op_tlv_method_set(op_tlv,
					     MLXSW_EMAD_OP_TLV_METHOD_WRITE);
	mlxsw_emad_op_tlv_class_set(op_tlv,
				    MLXSW_EMAD_OP_TLV_CLASS_REG_ACCESS);
358
	mlxsw_emad_op_tlv_tid_set(op_tlv, tid);
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
}

static int mlxsw_emad_construct_eth_hdr(struct sk_buff *skb)
{
	char *eth_hdr = skb_push(skb, MLXSW_EMAD_ETH_HDR_LEN);

	mlxsw_emad_eth_hdr_dmac_memcpy_to(eth_hdr, MLXSW_EMAD_EH_DMAC);
	mlxsw_emad_eth_hdr_smac_memcpy_to(eth_hdr, MLXSW_EMAD_EH_SMAC);
	mlxsw_emad_eth_hdr_ethertype_set(eth_hdr, MLXSW_EMAD_EH_ETHERTYPE);
	mlxsw_emad_eth_hdr_mlx_proto_set(eth_hdr, MLXSW_EMAD_EH_MLX_PROTO);
	mlxsw_emad_eth_hdr_ver_set(eth_hdr, MLXSW_EMAD_EH_PROTO_VERSION);

	skb_reset_mac_header(skb);

	return 0;
}

static void mlxsw_emad_construct(struct sk_buff *skb,
				 const struct mlxsw_reg_info *reg,
				 char *payload,
				 enum mlxsw_core_reg_access_type type,
380
				 u64 tid, bool enable_string_tlv)
381 382 383 384 385 386 387 388 389
{
	char *buf;

	buf = skb_push(skb, MLXSW_EMAD_END_TLV_LEN * sizeof(u32));
	mlxsw_emad_pack_end_tlv(buf);

	buf = skb_push(skb, reg->len + sizeof(u32));
	mlxsw_emad_pack_reg_tlv(buf, reg, payload);

390 391 392 393 394
	if (enable_string_tlv) {
		buf = skb_push(skb, MLXSW_EMAD_STRING_TLV_LEN * sizeof(u32));
		mlxsw_emad_pack_string_tlv(buf);
	}

395
	buf = skb_push(skb, MLXSW_EMAD_OP_TLV_LEN * sizeof(u32));
396
	mlxsw_emad_pack_op_tlv(buf, reg, type, tid);
397 398 399 400

	mlxsw_emad_construct_eth_hdr(skb);
}

401 402
struct mlxsw_emad_tlv_offsets {
	u16 op_tlv;
403
	u16 string_tlv;
404 405 406
	u16 reg_tlv;
};

407 408 409 410 411 412 413
static bool mlxsw_emad_tlv_is_string_tlv(const char *tlv)
{
	u8 tlv_type = mlxsw_emad_string_tlv_type_get(tlv);

	return tlv_type == MLXSW_EMAD_TLV_TYPE_STRING;
}

414 415 416 417 418 419
static void mlxsw_emad_tlv_parse(struct sk_buff *skb)
{
	struct mlxsw_emad_tlv_offsets *offsets =
		(struct mlxsw_emad_tlv_offsets *) skb->cb;

	offsets->op_tlv = MLXSW_EMAD_ETH_HDR_LEN;
420
	offsets->string_tlv = 0;
421 422
	offsets->reg_tlv = MLXSW_EMAD_ETH_HDR_LEN +
			   MLXSW_EMAD_OP_TLV_LEN * sizeof(u32);
423 424 425 426 427 428

	/* If string TLV is present, it must come after the operation TLV. */
	if (mlxsw_emad_tlv_is_string_tlv(skb->data + offsets->reg_tlv)) {
		offsets->string_tlv = offsets->reg_tlv;
		offsets->reg_tlv += MLXSW_EMAD_STRING_TLV_LEN * sizeof(u32);
	}
429 430
}

431 432
static char *mlxsw_emad_op_tlv(const struct sk_buff *skb)
{
433 434 435 436
	struct mlxsw_emad_tlv_offsets *offsets =
		(struct mlxsw_emad_tlv_offsets *) skb->cb;

	return ((char *) (skb->data + offsets->op_tlv));
437 438
}

439 440 441 442 443 444 445 446 447 448 449
static char *mlxsw_emad_string_tlv(const struct sk_buff *skb)
{
	struct mlxsw_emad_tlv_offsets *offsets =
		(struct mlxsw_emad_tlv_offsets *) skb->cb;

	if (!offsets->string_tlv)
		return NULL;

	return ((char *) (skb->data + offsets->string_tlv));
}

450 451
static char *mlxsw_emad_reg_tlv(const struct sk_buff *skb)
{
452 453 454 455
	struct mlxsw_emad_tlv_offsets *offsets =
		(struct mlxsw_emad_tlv_offsets *) skb->cb;

	return ((char *) (skb->data + offsets->reg_tlv));
456 457
}

458
static char *mlxsw_emad_reg_payload(const char *reg_tlv)
459
{
460 461 462 463 464 465
	return ((char *) (reg_tlv + sizeof(u32)));
}

static char *mlxsw_emad_reg_payload_cmd(const char *mbox)
{
	return ((char *) (mbox + (MLXSW_EMAD_OP_TLV_LEN + 1) * sizeof(u32)));
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
}

static u64 mlxsw_emad_get_tid(const struct sk_buff *skb)
{
	char *op_tlv;

	op_tlv = mlxsw_emad_op_tlv(skb);
	return mlxsw_emad_op_tlv_tid_get(op_tlv);
}

static bool mlxsw_emad_is_resp(const struct sk_buff *skb)
{
	char *op_tlv;

	op_tlv = mlxsw_emad_op_tlv(skb);
481
	return (mlxsw_emad_op_tlv_r_get(op_tlv) == MLXSW_EMAD_OP_TLV_RESPONSE);
482 483
}

484 485
static int mlxsw_emad_process_status(char *op_tlv,
				     enum mlxsw_emad_op_tlv_status *p_status)
486
{
487
	*p_status = mlxsw_emad_op_tlv_status_get(op_tlv);
488

489
	switch (*p_status) {
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
	case MLXSW_EMAD_OP_TLV_STATUS_SUCCESS:
		return 0;
	case MLXSW_EMAD_OP_TLV_STATUS_BUSY:
	case MLXSW_EMAD_OP_TLV_STATUS_MESSAGE_RECEIPT_ACK:
		return -EAGAIN;
	case MLXSW_EMAD_OP_TLV_STATUS_VERSION_NOT_SUPPORTED:
	case MLXSW_EMAD_OP_TLV_STATUS_UNKNOWN_TLV:
	case MLXSW_EMAD_OP_TLV_STATUS_REGISTER_NOT_SUPPORTED:
	case MLXSW_EMAD_OP_TLV_STATUS_CLASS_NOT_SUPPORTED:
	case MLXSW_EMAD_OP_TLV_STATUS_METHOD_NOT_SUPPORTED:
	case MLXSW_EMAD_OP_TLV_STATUS_BAD_PARAMETER:
	case MLXSW_EMAD_OP_TLV_STATUS_RESOURCE_NOT_AVAILABLE:
	case MLXSW_EMAD_OP_TLV_STATUS_INTERNAL_ERROR:
	default:
		return -EIO;
	}
}

508 509 510
static int
mlxsw_emad_process_status_skb(struct sk_buff *skb,
			      enum mlxsw_emad_op_tlv_status *p_status)
511
{
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
	return mlxsw_emad_process_status(mlxsw_emad_op_tlv(skb), p_status);
}

struct mlxsw_reg_trans {
	struct list_head list;
	struct list_head bulk_list;
	struct mlxsw_core *core;
	struct sk_buff *tx_skb;
	struct mlxsw_tx_info tx_info;
	struct delayed_work timeout_dw;
	unsigned int retries;
	u64 tid;
	struct completion completion;
	atomic_t active;
	mlxsw_reg_trans_cb_t *cb;
	unsigned long cb_priv;
	const struct mlxsw_reg_info *reg;
	enum mlxsw_core_reg_access_type type;
	int err;
531
	char *emad_err_string;
532 533 534 535
	enum mlxsw_emad_op_tlv_status emad_status;
	struct rcu_head rcu;
};

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
static void mlxsw_emad_process_string_tlv(const struct sk_buff *skb,
					  struct mlxsw_reg_trans *trans)
{
	char *string_tlv;
	char *string;

	string_tlv = mlxsw_emad_string_tlv(skb);
	if (!string_tlv)
		return;

	trans->emad_err_string = kzalloc(MLXSW_EMAD_STRING_TLV_STRING_LEN,
					 GFP_ATOMIC);
	if (!trans->emad_err_string)
		return;

	string = mlxsw_emad_string_tlv_string_data(string_tlv);
	strlcpy(trans->emad_err_string, string,
		MLXSW_EMAD_STRING_TLV_STRING_LEN);
}

556 557
#define MLXSW_EMAD_TIMEOUT_DURING_FW_FLASH_MS	3000
#define MLXSW_EMAD_TIMEOUT_MS			200
558 559 560 561 562

static void mlxsw_emad_trans_timeout_schedule(struct mlxsw_reg_trans *trans)
{
	unsigned long timeout = msecs_to_jiffies(MLXSW_EMAD_TIMEOUT_MS);

563 564 565
	if (trans->core->fw_flash_in_progress)
		timeout = msecs_to_jiffies(MLXSW_EMAD_TIMEOUT_DURING_FW_FLASH_MS);

I
Ido Schimmel 已提交
566
	queue_delayed_work(trans->core->emad_wq, &trans->timeout_dw, timeout);
567 568 569
}

static int mlxsw_emad_transmit(struct mlxsw_core *mlxsw_core,
570
			       struct mlxsw_reg_trans *trans)
571
{
572
	struct sk_buff *skb;
573 574
	int err;

575 576 577 578
	skb = skb_copy(trans->tx_skb, GFP_KERNEL);
	if (!skb)
		return -ENOMEM;

J
Jiri Pirko 已提交
579 580 581 582
	trace_devlink_hwmsg(priv_to_devlink(mlxsw_core), false, 0,
			    skb->data + mlxsw_core->driver->txhdr_len,
			    skb->len - mlxsw_core->driver->txhdr_len);

583 584 585 586 587
	atomic_set(&trans->active, 1);
	err = mlxsw_core_skb_transmit(mlxsw_core, skb, &trans->tx_info);
	if (err) {
		dev_kfree_skb(skb);
		return err;
588
	}
589 590 591
	mlxsw_emad_trans_timeout_schedule(trans);
	return 0;
}
592

593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
static void mlxsw_emad_trans_finish(struct mlxsw_reg_trans *trans, int err)
{
	struct mlxsw_core *mlxsw_core = trans->core;

	dev_kfree_skb(trans->tx_skb);
	spin_lock_bh(&mlxsw_core->emad.trans_list_lock);
	list_del_rcu(&trans->list);
	spin_unlock_bh(&mlxsw_core->emad.trans_list_lock);
	trans->err = err;
	complete(&trans->completion);
}

static void mlxsw_emad_transmit_retry(struct mlxsw_core *mlxsw_core,
				      struct mlxsw_reg_trans *trans)
{
	int err;
609

610 611 612 613 614 615 616
	if (trans->retries < MLXSW_EMAD_MAX_RETRY) {
		trans->retries++;
		err = mlxsw_emad_transmit(trans->core, trans);
		if (err == 0)
			return;
	} else {
		err = -EIO;
617
	}
618 619
	mlxsw_emad_trans_finish(trans, err);
}
620

621 622 623 624 625 626 627 628 629 630
static void mlxsw_emad_trans_timeout_work(struct work_struct *work)
{
	struct mlxsw_reg_trans *trans = container_of(work,
						     struct mlxsw_reg_trans,
						     timeout_dw.work);

	if (!atomic_dec_and_test(&trans->active))
		return;

	mlxsw_emad_transmit_retry(trans->core, trans);
631 632
}

633 634 635 636 637 638 639 640 641 642 643 644 645 646
static void mlxsw_emad_process_response(struct mlxsw_core *mlxsw_core,
					struct mlxsw_reg_trans *trans,
					struct sk_buff *skb)
{
	int err;

	if (!atomic_dec_and_test(&trans->active))
		return;

	err = mlxsw_emad_process_status_skb(skb, &trans->emad_status);
	if (err == -EAGAIN) {
		mlxsw_emad_transmit_retry(mlxsw_core, trans);
	} else {
		if (err == 0) {
647
			char *reg_tlv = mlxsw_emad_reg_tlv(skb);
648 649 650

			if (trans->cb)
				trans->cb(mlxsw_core,
651
					  mlxsw_emad_reg_payload(reg_tlv),
652
					  trans->reg->len, trans->cb_priv);
653 654
		} else {
			mlxsw_emad_process_string_tlv(skb, trans);
655 656 657 658 659 660
		}
		mlxsw_emad_trans_finish(trans, err);
	}
}

/* called with rcu read lock held */
661 662 663 664
static void mlxsw_emad_rx_listener_func(struct sk_buff *skb, u8 local_port,
					void *priv)
{
	struct mlxsw_core *mlxsw_core = priv;
665
	struct mlxsw_reg_trans *trans;
666

J
Jiri Pirko 已提交
667 668 669
	trace_devlink_hwmsg(priv_to_devlink(mlxsw_core), true, 0,
			    skb->data, skb->len);

670 671
	mlxsw_emad_tlv_parse(skb);

672 673 674 675 676 677 678 679
	if (!mlxsw_emad_is_resp(skb))
		goto free_skb;

	list_for_each_entry_rcu(trans, &mlxsw_core->emad.trans_list, list) {
		if (mlxsw_emad_get_tid(skb) == trans->tid) {
			mlxsw_emad_process_response(mlxsw_core, trans, skb);
			break;
		}
680
	}
681 682 683

free_skb:
	dev_kfree_skb(skb);
684 685
}

686 687 688
static const struct mlxsw_listener mlxsw_emad_rx_listener =
	MLXSW_RXL(mlxsw_emad_rx_listener_func, ETHEMAD, TRAP_TO_CPU, false,
		  EMAD, DISCARD);
689 690 691

static int mlxsw_emad_init(struct mlxsw_core *mlxsw_core)
{
I
Ido Schimmel 已提交
692
	struct workqueue_struct *emad_wq;
693
	u64 tid;
694 695
	int err;

V
Vadim Pasternak 已提交
696 697 698
	if (!(mlxsw_core->bus->features & MLXSW_BUS_F_TXRX))
		return 0;

699
	emad_wq = alloc_workqueue("mlxsw_core_emad", 0, 0);
I
Ido Schimmel 已提交
700 701 702 703
	if (!emad_wq)
		return -ENOMEM;
	mlxsw_core->emad_wq = emad_wq;

704 705 706 707
	/* Set the upper 32 bits of the transaction ID field to a random
	 * number. This allows us to discard EMADs addressed to other
	 * devices.
	 */
708 709 710
	get_random_bytes(&tid, 4);
	tid <<= 32;
	atomic64_set(&mlxsw_core->emad.tid, tid);
711

712 713
	INIT_LIST_HEAD(&mlxsw_core->emad.trans_list);
	spin_lock_init(&mlxsw_core->emad.trans_list_lock);
714

715 716
	err = mlxsw_core_trap_register(mlxsw_core, &mlxsw_emad_rx_listener,
				       mlxsw_core);
717
	if (err)
718
		goto err_trap_register;
719

720
	err = mlxsw_core->driver->basic_trap_groups_set(mlxsw_core);
721 722 723 724 725 726 727
	if (err)
		goto err_emad_trap_set;
	mlxsw_core->emad.use_emad = true;

	return 0;

err_emad_trap_set:
728 729
	mlxsw_core_trap_unregister(mlxsw_core, &mlxsw_emad_rx_listener,
				   mlxsw_core);
730
err_trap_register:
I
Ido Schimmel 已提交
731
	destroy_workqueue(mlxsw_core->emad_wq);
732 733 734 735 736 737
	return err;
}

static void mlxsw_emad_fini(struct mlxsw_core *mlxsw_core)
{

V
Vadim Pasternak 已提交
738 739 740
	if (!(mlxsw_core->bus->features & MLXSW_BUS_F_TXRX))
		return;

741
	mlxsw_core->emad.use_emad = false;
742 743
	mlxsw_core_trap_unregister(mlxsw_core, &mlxsw_emad_rx_listener,
				   mlxsw_core);
I
Ido Schimmel 已提交
744
	destroy_workqueue(mlxsw_core->emad_wq);
745 746 747
}

static struct sk_buff *mlxsw_emad_alloc(const struct mlxsw_core *mlxsw_core,
748
					u16 reg_len, bool enable_string_tlv)
749 750 751 752 753 754 755
{
	struct sk_buff *skb;
	u16 emad_len;

	emad_len = (reg_len + sizeof(u32) + MLXSW_EMAD_ETH_HDR_LEN +
		    (MLXSW_EMAD_OP_TLV_LEN + MLXSW_EMAD_END_TLV_LEN) *
		    sizeof(u32) + mlxsw_core->driver->txhdr_len);
756 757
	if (enable_string_tlv)
		emad_len += MLXSW_EMAD_STRING_TLV_LEN * sizeof(u32);
758 759 760 761 762 763 764 765 766 767 768 769
	if (emad_len > MLXSW_EMAD_MAX_FRAME_LEN)
		return NULL;

	skb = netdev_alloc_skb(NULL, emad_len);
	if (!skb)
		return NULL;
	memset(skb->data, 0, emad_len);
	skb_reserve(skb, emad_len);

	return skb;
}

770 771 772 773 774 775 776 777 778
static int mlxsw_emad_reg_access(struct mlxsw_core *mlxsw_core,
				 const struct mlxsw_reg_info *reg,
				 char *payload,
				 enum mlxsw_core_reg_access_type type,
				 struct mlxsw_reg_trans *trans,
				 struct list_head *bulk_list,
				 mlxsw_reg_trans_cb_t *cb,
				 unsigned long cb_priv, u64 tid)
{
779
	bool enable_string_tlv;
780 781 782 783
	struct sk_buff *skb;
	int err;

	dev_dbg(mlxsw_core->bus_info->dev, "EMAD reg access (tid=%llx,reg_id=%x(%s),type=%s)\n",
784
		tid, reg->id, mlxsw_reg_id_str(reg->id),
785 786
		mlxsw_core_reg_access_type_str(type));

787 788 789 790 791 792
	/* Since this can be changed during emad_reg_access, read it once and
	 * use the value all the way.
	 */
	enable_string_tlv = mlxsw_core->emad.enable_string_tlv;

	skb = mlxsw_emad_alloc(mlxsw_core, reg->len, enable_string_tlv);
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
	if (!skb)
		return -ENOMEM;

	list_add_tail(&trans->bulk_list, bulk_list);
	trans->core = mlxsw_core;
	trans->tx_skb = skb;
	trans->tx_info.local_port = MLXSW_PORT_CPU_PORT;
	trans->tx_info.is_emad = true;
	INIT_DELAYED_WORK(&trans->timeout_dw, mlxsw_emad_trans_timeout_work);
	trans->tid = tid;
	init_completion(&trans->completion);
	trans->cb = cb;
	trans->cb_priv = cb_priv;
	trans->reg = reg;
	trans->type = type;

809 810
	mlxsw_emad_construct(skb, reg, payload, type, trans->tid,
			     enable_string_tlv);
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
	mlxsw_core->driver->txhdr_construct(skb, &trans->tx_info);

	spin_lock_bh(&mlxsw_core->emad.trans_list_lock);
	list_add_tail_rcu(&trans->list, &mlxsw_core->emad.trans_list);
	spin_unlock_bh(&mlxsw_core->emad.trans_list_lock);
	err = mlxsw_emad_transmit(mlxsw_core, trans);
	if (err)
		goto err_out;
	return 0;

err_out:
	spin_lock_bh(&mlxsw_core->emad.trans_list_lock);
	list_del_rcu(&trans->list);
	spin_unlock_bh(&mlxsw_core->emad.trans_list_lock);
	list_del(&trans->bulk_list);
	dev_kfree_skb(trans->tx_skb);
	return err;
}

830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
/*****************
 * Core functions
 *****************/

int mlxsw_core_driver_register(struct mlxsw_driver *mlxsw_driver)
{
	spin_lock(&mlxsw_core_driver_list_lock);
	list_add_tail(&mlxsw_driver->list, &mlxsw_core_driver_list);
	spin_unlock(&mlxsw_core_driver_list_lock);
	return 0;
}
EXPORT_SYMBOL(mlxsw_core_driver_register);

void mlxsw_core_driver_unregister(struct mlxsw_driver *mlxsw_driver)
{
	spin_lock(&mlxsw_core_driver_list_lock);
	list_del(&mlxsw_driver->list);
	spin_unlock(&mlxsw_core_driver_list_lock);
}
EXPORT_SYMBOL(mlxsw_core_driver_unregister);

static struct mlxsw_driver *__driver_find(const char *kind)
{
	struct mlxsw_driver *mlxsw_driver;

	list_for_each_entry(mlxsw_driver, &mlxsw_core_driver_list, list) {
		if (strcmp(mlxsw_driver->kind, kind) == 0)
			return mlxsw_driver;
	}
	return NULL;
}

static struct mlxsw_driver *mlxsw_core_driver_get(const char *kind)
{
	struct mlxsw_driver *mlxsw_driver;

	spin_lock(&mlxsw_core_driver_list_lock);
	mlxsw_driver = __driver_find(kind);
	spin_unlock(&mlxsw_core_driver_list_lock);
	return mlxsw_driver;
}

872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
struct mlxsw_core_fw_info {
	struct mlxfw_dev mlxfw_dev;
	struct mlxsw_core *mlxsw_core;
};

static int mlxsw_core_fw_component_query(struct mlxfw_dev *mlxfw_dev,
					 u16 component_index, u32 *p_max_size,
					 u8 *p_align_bits, u16 *p_max_write_size)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcqi_pl[MLXSW_REG_MCQI_LEN];
	int err;

	mlxsw_reg_mcqi_pack(mcqi_pl, component_index);
	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mcqi), mcqi_pl);
	if (err)
		return err;
	mlxsw_reg_mcqi_unpack(mcqi_pl, p_max_size, p_align_bits, p_max_write_size);

	*p_align_bits = max_t(u8, *p_align_bits, 2);
	*p_max_write_size = min_t(u16, *p_max_write_size, MLXSW_REG_MCDA_MAX_DATA_LEN);
	return 0;
}

static int mlxsw_core_fw_fsm_lock(struct mlxfw_dev *mlxfw_dev, u32 *fwhandle)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcc_pl[MLXSW_REG_MCC_LEN];
	u8 control_state;
	int err;

	mlxsw_reg_mcc_pack(mcc_pl, 0, 0, 0, 0);
	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
	if (err)
		return err;

	mlxsw_reg_mcc_unpack(mcc_pl, fwhandle, NULL, &control_state);
	if (control_state != MLXFW_FSM_STATE_IDLE)
		return -EBUSY;

	mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_LOCK_UPDATE_HANDLE, 0, *fwhandle, 0);
	return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
}

static int mlxsw_core_fw_fsm_component_update(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
					      u16 component_index, u32 component_size)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcc_pl[MLXSW_REG_MCC_LEN];

	mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_UPDATE_COMPONENT,
			   component_index, fwhandle, component_size);
	return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
}

static int mlxsw_core_fw_fsm_block_download(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
					    u8 *data, u16 size, u32 offset)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcda_pl[MLXSW_REG_MCDA_LEN];

	mlxsw_reg_mcda_pack(mcda_pl, fwhandle, offset, size, data);
	return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcda), mcda_pl);
}

static int mlxsw_core_fw_fsm_component_verify(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
					      u16 component_index)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcc_pl[MLXSW_REG_MCC_LEN];

	mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_VERIFY_COMPONENT,
			   component_index, fwhandle, 0);
	return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
}

static int mlxsw_core_fw_fsm_activate(struct mlxfw_dev *mlxfw_dev, u32 fwhandle)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcc_pl[MLXSW_REG_MCC_LEN];

	mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_ACTIVATE, 0, fwhandle, 0);
	return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
}

static int mlxsw_core_fw_fsm_query_state(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
					 enum mlxfw_fsm_state *fsm_state,
					 enum mlxfw_fsm_state_err *fsm_state_err)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcc_pl[MLXSW_REG_MCC_LEN];
	u8 control_state;
	u8 error_code;
	int err;

	mlxsw_reg_mcc_pack(mcc_pl, 0, 0, fwhandle, 0);
	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
	if (err)
		return err;

	mlxsw_reg_mcc_unpack(mcc_pl, NULL, &error_code, &control_state);
	*fsm_state = control_state;
	*fsm_state_err = min_t(enum mlxfw_fsm_state_err, error_code, MLXFW_FSM_STATE_ERR_MAX);
	return 0;
}

static void mlxsw_core_fw_fsm_cancel(struct mlxfw_dev *mlxfw_dev, u32 fwhandle)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcc_pl[MLXSW_REG_MCC_LEN];

	mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_CANCEL, 0, fwhandle, 0);
	mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
}

static void mlxsw_core_fw_fsm_release(struct mlxfw_dev *mlxfw_dev, u32 fwhandle)
{
	struct mlxsw_core_fw_info *mlxsw_core_fw_info =
		container_of(mlxfw_dev, struct mlxsw_core_fw_info, mlxfw_dev);
	struct mlxsw_core *mlxsw_core = mlxsw_core_fw_info->mlxsw_core;
	char mcc_pl[MLXSW_REG_MCC_LEN];

	mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_RELEASE_UPDATE_HANDLE, 0, fwhandle, 0);
	mlxsw_reg_write(mlxsw_core, MLXSW_REG(mcc), mcc_pl);
}

static const struct mlxfw_dev_ops mlxsw_core_fw_mlxsw_dev_ops = {
	.component_query	= mlxsw_core_fw_component_query,
	.fsm_lock		= mlxsw_core_fw_fsm_lock,
	.fsm_component_update	= mlxsw_core_fw_fsm_component_update,
	.fsm_block_download	= mlxsw_core_fw_fsm_block_download,
	.fsm_component_verify	= mlxsw_core_fw_fsm_component_verify,
	.fsm_activate		= mlxsw_core_fw_fsm_activate,
	.fsm_query_state	= mlxsw_core_fw_fsm_query_state,
	.fsm_cancel		= mlxsw_core_fw_fsm_cancel,
	.fsm_release		= mlxsw_core_fw_fsm_release,
};

static int mlxsw_core_fw_flash(struct mlxsw_core *mlxsw_core, const struct firmware *firmware,
			       struct netlink_ext_ack *extack)
{
	struct mlxsw_core_fw_info mlxsw_core_fw_info = {
		.mlxfw_dev = {
			.ops = &mlxsw_core_fw_mlxsw_dev_ops,
			.psid = mlxsw_core->bus_info->psid,
			.psid_size = strlen(mlxsw_core->bus_info->psid),
			.devlink = priv_to_devlink(mlxsw_core),
		},
		.mlxsw_core = mlxsw_core
	};
	int err;

	mlxsw_core->fw_flash_in_progress = true;
	err = mlxfw_firmware_flash(&mlxsw_core_fw_info.mlxfw_dev, firmware, extack);
	mlxsw_core->fw_flash_in_progress = false;

	return err;
}

static int mlxsw_core_fw_rev_validate(struct mlxsw_core *mlxsw_core,
				      const struct mlxsw_bus_info *mlxsw_bus_info,
				      const struct mlxsw_fw_rev *req_rev,
				      const char *filename)
{
	const struct mlxsw_fw_rev *rev = &mlxsw_bus_info->fw_rev;
	union devlink_param_value value;
	const struct firmware *firmware;
	int err;

	/* Don't check if driver does not require it */
	if (!req_rev || !filename)
		return 0;

	/* Don't check if devlink 'fw_load_policy' param is 'flash' */
	err = devlink_param_driverinit_value_get(priv_to_devlink(mlxsw_core),
						 DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY,
						 &value);
	if (err)
		return err;
	if (value.vu8 == DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_FLASH)
		return 0;

	/* Validate driver & FW are compatible */
	if (rev->major != req_rev->major) {
		WARN(1, "Mismatch in major FW version [%d:%d] is never expected; Please contact support\n",
		     rev->major, req_rev->major);
		return -EINVAL;
	}
	if (mlxsw_core_fw_rev_minor_subminor_validate(rev, req_rev))
		return 0;

	dev_err(mlxsw_bus_info->dev, "The firmware version %d.%d.%d is incompatible with the driver (required >= %d.%d.%d)\n",
		rev->major, rev->minor, rev->subminor, req_rev->major,
		req_rev->minor, req_rev->subminor);
	dev_info(mlxsw_bus_info->dev, "Flashing firmware using file %s\n", filename);

	err = request_firmware_direct(&firmware, filename, mlxsw_bus_info->dev);
	if (err) {
		dev_err(mlxsw_bus_info->dev, "Could not request firmware file %s\n", filename);
		return err;
	}

	err = mlxsw_core_fw_flash(mlxsw_core, firmware, NULL);
	release_firmware(firmware);
	if (err)
		dev_err(mlxsw_bus_info->dev, "Could not upgrade firmware\n");

	/* On FW flash success, tell the caller FW reset is needed
	 * if current FW supports it.
	 */
	if (rev->minor >= req_rev->can_reset_minor)
		return err ? err : -EAGAIN;
	else
		return 0;
}

static int mlxsw_core_fw_flash_update(struct mlxsw_core *mlxsw_core,
1105
				      struct devlink_flash_update_params *params,
1106 1107 1108 1109 1110
				      struct netlink_ext_ack *extack)
{
	const struct firmware *firmware;
	int err;

1111
	err = request_firmware_direct(&firmware, params->file_name, mlxsw_core->bus_info->dev);
1112 1113 1114 1115 1116 1117 1118 1119
	if (err)
		return err;
	err = mlxsw_core_fw_flash(mlxsw_core, firmware, extack);
	release_firmware(firmware);

	return err;
}

1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
static int mlxsw_core_devlink_param_fw_load_policy_validate(struct devlink *devlink, u32 id,
							    union devlink_param_value val,
							    struct netlink_ext_ack *extack)
{
	if (val.vu8 != DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DRIVER &&
	    val.vu8 != DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_FLASH) {
		NL_SET_ERR_MSG_MOD(extack, "'fw_load_policy' must be 'driver' or 'flash'");
		return -EINVAL;
	}

	return 0;
}

static const struct devlink_param mlxsw_core_fw_devlink_params[] = {
	DEVLINK_PARAM_GENERIC(FW_LOAD_POLICY, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT), NULL, NULL,
			      mlxsw_core_devlink_param_fw_load_policy_validate),
};

static int mlxsw_core_fw_params_register(struct mlxsw_core *mlxsw_core)
{
	struct devlink *devlink = priv_to_devlink(mlxsw_core);
	union devlink_param_value value;
	int err;

	err = devlink_params_register(devlink, mlxsw_core_fw_devlink_params,
				      ARRAY_SIZE(mlxsw_core_fw_devlink_params));
	if (err)
		return err;

	value.vu8 = DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DRIVER;
	devlink_param_driverinit_value_set(devlink, DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY, value);
	return 0;
}

static void mlxsw_core_fw_params_unregister(struct mlxsw_core *mlxsw_core)
{
	devlink_params_unregister(priv_to_devlink(mlxsw_core), mlxsw_core_fw_devlink_params,
				  ARRAY_SIZE(mlxsw_core_fw_devlink_params));
}

1160 1161
static int mlxsw_devlink_port_split(struct devlink *devlink,
				    unsigned int port_index,
1162 1163
				    unsigned int count,
				    struct netlink_ext_ack *extack)
1164 1165 1166
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);

1167 1168
	if (port_index >= mlxsw_core->max_ports) {
		NL_SET_ERR_MSG_MOD(extack, "Port index exceeds maximum number of ports");
1169
		return -EINVAL;
1170
	}
1171 1172
	if (!mlxsw_core->driver->port_split)
		return -EOPNOTSUPP;
1173 1174
	return mlxsw_core->driver->port_split(mlxsw_core, port_index, count,
					      extack);
1175 1176 1177
}

static int mlxsw_devlink_port_unsplit(struct devlink *devlink,
1178 1179
				      unsigned int port_index,
				      struct netlink_ext_ack *extack)
1180 1181 1182
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);

1183 1184
	if (port_index >= mlxsw_core->max_ports) {
		NL_SET_ERR_MSG_MOD(extack, "Port index exceeds maximum number of ports");
1185
		return -EINVAL;
1186
	}
1187 1188
	if (!mlxsw_core->driver->port_unsplit)
		return -EOPNOTSUPP;
1189 1190
	return mlxsw_core->driver->port_unsplit(mlxsw_core, port_index,
						extack);
1191 1192
}

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
static int
mlxsw_devlink_sb_pool_get(struct devlink *devlink,
			  unsigned int sb_index, u16 pool_index,
			  struct devlink_sb_pool_info *pool_info)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->sb_pool_get)
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_pool_get(mlxsw_core, sb_index,
					 pool_index, pool_info);
}

static int
mlxsw_devlink_sb_pool_set(struct devlink *devlink,
			  unsigned int sb_index, u16 pool_index, u32 size,
1210 1211
			  enum devlink_sb_threshold_type threshold_type,
			  struct netlink_ext_ack *extack)
1212 1213 1214 1215 1216 1217 1218
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->sb_pool_set)
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_pool_set(mlxsw_core, sb_index,
1219 1220
					 pool_index, size, threshold_type,
					 extack);
1221 1222 1223 1224 1225 1226 1227
}

static void *__dl_port(struct devlink_port *devlink_port)
{
	return container_of(devlink_port, struct mlxsw_core_port, devlink_port);
}

1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
static int mlxsw_devlink_port_type_set(struct devlink_port *devlink_port,
				       enum devlink_port_type port_type)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink_port->devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;
	struct mlxsw_core_port *mlxsw_core_port = __dl_port(devlink_port);

	if (!mlxsw_driver->port_type_set)
		return -EOPNOTSUPP;

	return mlxsw_driver->port_type_set(mlxsw_core,
					   mlxsw_core_port->local_port,
					   port_type);
}

1243 1244 1245 1246 1247 1248 1249 1250
static int mlxsw_devlink_sb_port_pool_get(struct devlink_port *devlink_port,
					  unsigned int sb_index, u16 pool_index,
					  u32 *p_threshold)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink_port->devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;
	struct mlxsw_core_port *mlxsw_core_port = __dl_port(devlink_port);

1251 1252
	if (!mlxsw_driver->sb_port_pool_get ||
	    !mlxsw_core_port_check(mlxsw_core_port))
1253 1254 1255 1256 1257 1258 1259
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_port_pool_get(mlxsw_core_port, sb_index,
					      pool_index, p_threshold);
}

static int mlxsw_devlink_sb_port_pool_set(struct devlink_port *devlink_port,
					  unsigned int sb_index, u16 pool_index,
1260 1261
					  u32 threshold,
					  struct netlink_ext_ack *extack)
1262 1263 1264 1265 1266
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink_port->devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;
	struct mlxsw_core_port *mlxsw_core_port = __dl_port(devlink_port);

1267 1268
	if (!mlxsw_driver->sb_port_pool_set ||
	    !mlxsw_core_port_check(mlxsw_core_port))
1269 1270
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_port_pool_set(mlxsw_core_port, sb_index,
1271
					      pool_index, threshold, extack);
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
}

static int
mlxsw_devlink_sb_tc_pool_bind_get(struct devlink_port *devlink_port,
				  unsigned int sb_index, u16 tc_index,
				  enum devlink_sb_pool_type pool_type,
				  u16 *p_pool_index, u32 *p_threshold)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink_port->devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;
	struct mlxsw_core_port *mlxsw_core_port = __dl_port(devlink_port);

1284 1285
	if (!mlxsw_driver->sb_tc_pool_bind_get ||
	    !mlxsw_core_port_check(mlxsw_core_port))
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_tc_pool_bind_get(mlxsw_core_port, sb_index,
						 tc_index, pool_type,
						 p_pool_index, p_threshold);
}

static int
mlxsw_devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port,
				  unsigned int sb_index, u16 tc_index,
				  enum devlink_sb_pool_type pool_type,
1296 1297
				  u16 pool_index, u32 threshold,
				  struct netlink_ext_ack *extack)
1298 1299 1300 1301 1302
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink_port->devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;
	struct mlxsw_core_port *mlxsw_core_port = __dl_port(devlink_port);

1303 1304
	if (!mlxsw_driver->sb_tc_pool_bind_set ||
	    !mlxsw_core_port_check(mlxsw_core_port))
1305 1306 1307
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_tc_pool_bind_set(mlxsw_core_port, sb_index,
						 tc_index, pool_type,
1308
						 pool_index, threshold, extack);
1309 1310
}

1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
static int mlxsw_devlink_sb_occ_snapshot(struct devlink *devlink,
					 unsigned int sb_index)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->sb_occ_snapshot)
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_occ_snapshot(mlxsw_core, sb_index);
}

static int mlxsw_devlink_sb_occ_max_clear(struct devlink *devlink,
					  unsigned int sb_index)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->sb_occ_max_clear)
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_occ_max_clear(mlxsw_core, sb_index);
}

static int
mlxsw_devlink_sb_occ_port_pool_get(struct devlink_port *devlink_port,
				   unsigned int sb_index, u16 pool_index,
				   u32 *p_cur, u32 *p_max)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink_port->devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;
	struct mlxsw_core_port *mlxsw_core_port = __dl_port(devlink_port);

1342 1343
	if (!mlxsw_driver->sb_occ_port_pool_get ||
	    !mlxsw_core_port_check(mlxsw_core_port))
1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_occ_port_pool_get(mlxsw_core_port, sb_index,
						  pool_index, p_cur, p_max);
}

static int
mlxsw_devlink_sb_occ_tc_port_bind_get(struct devlink_port *devlink_port,
				      unsigned int sb_index, u16 tc_index,
				      enum devlink_sb_pool_type pool_type,
				      u32 *p_cur, u32 *p_max)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink_port->devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;
	struct mlxsw_core_port *mlxsw_core_port = __dl_port(devlink_port);

1359 1360
	if (!mlxsw_driver->sb_occ_tc_port_bind_get ||
	    !mlxsw_core_port_check(mlxsw_core_port))
1361 1362 1363 1364 1365 1366
		return -EOPNOTSUPP;
	return mlxsw_driver->sb_occ_tc_port_bind_get(mlxsw_core_port,
						     sb_index, tc_index,
						     pool_type, p_cur, p_max);
}

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
static int
mlxsw_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req,
		       struct netlink_ext_ack *extack)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	char fw_info_psid[MLXSW_REG_MGIR_FW_INFO_PSID_SIZE];
	u32 hw_rev, fw_major, fw_minor, fw_sub_minor;
	char mgir_pl[MLXSW_REG_MGIR_LEN];
	char buf[32];
	int err;

	err = devlink_info_driver_name_put(req,
					   mlxsw_core->bus_info->device_kind);
	if (err)
		return err;

	mlxsw_reg_mgir_pack(mgir_pl);
	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mgir), mgir_pl);
	if (err)
		return err;
	mlxsw_reg_mgir_unpack(mgir_pl, &hw_rev, fw_info_psid, &fw_major,
			      &fw_minor, &fw_sub_minor);

	sprintf(buf, "%X", hw_rev);
	err = devlink_info_version_fixed_put(req, "hw.revision", buf);
	if (err)
		return err;

	err = devlink_info_version_fixed_put(req, "fw.psid", fw_info_psid);
	if (err)
		return err;

	sprintf(buf, "%d.%d.%d", fw_major, fw_minor, fw_sub_minor);
	err = devlink_info_version_running_put(req, "fw.version", buf);
	if (err)
		return err;

	return 0;
}

1407 1408
static int
mlxsw_devlink_core_bus_device_reload_down(struct devlink *devlink,
1409
					  bool netns_change,
1410
					  struct netlink_ext_ack *extack)
1411 1412 1413
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);

1414
	if (!(mlxsw_core->bus->features & MLXSW_BUS_F_RESET))
1415 1416 1417
		return -EOPNOTSUPP;

	mlxsw_core_bus_device_unregister(mlxsw_core, true);
1418 1419 1420 1421 1422 1423 1424 1425
	return 0;
}

static int
mlxsw_devlink_core_bus_device_reload_up(struct devlink *devlink,
					struct netlink_ext_ack *extack)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
1426

1427 1428 1429
	return mlxsw_core_bus_device_register(mlxsw_core->bus_info,
					      mlxsw_core->bus,
					      mlxsw_core->bus_priv, true,
1430
					      devlink, extack);
1431 1432
}

1433
static int mlxsw_devlink_flash_update(struct devlink *devlink,
1434
				      struct devlink_flash_update_params *params,
1435 1436 1437 1438
				      struct netlink_ext_ack *extack)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);

1439
	return mlxsw_core_fw_flash_update(mlxsw_core, params, extack);
1440 1441
}

1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
static int mlxsw_devlink_trap_init(struct devlink *devlink,
				   const struct devlink_trap *trap,
				   void *trap_ctx)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_init)
		return -EOPNOTSUPP;
	return mlxsw_driver->trap_init(mlxsw_core, trap, trap_ctx);
}

static void mlxsw_devlink_trap_fini(struct devlink *devlink,
				    const struct devlink_trap *trap,
				    void *trap_ctx)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_fini)
		return;
	mlxsw_driver->trap_fini(mlxsw_core, trap, trap_ctx);
}

static int mlxsw_devlink_trap_action_set(struct devlink *devlink,
					 const struct devlink_trap *trap,
1468 1469
					 enum devlink_trap_action action,
					 struct netlink_ext_ack *extack)
1470 1471 1472 1473 1474 1475
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_action_set)
		return -EOPNOTSUPP;
1476
	return mlxsw_driver->trap_action_set(mlxsw_core, trap, action, extack);
1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
}

static int
mlxsw_devlink_trap_group_init(struct devlink *devlink,
			      const struct devlink_trap_group *group)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_group_init)
		return -EOPNOTSUPP;
	return mlxsw_driver->trap_group_init(mlxsw_core, group);
}

1491 1492 1493
static int
mlxsw_devlink_trap_group_set(struct devlink *devlink,
			     const struct devlink_trap_group *group,
1494 1495
			     const struct devlink_trap_policer *policer,
			     struct netlink_ext_ack *extack)
1496 1497 1498 1499 1500 1501
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_group_set)
		return -EOPNOTSUPP;
1502
	return mlxsw_driver->trap_group_set(mlxsw_core, group, policer, extack);
1503 1504
}

1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
static int
mlxsw_devlink_trap_policer_init(struct devlink *devlink,
				const struct devlink_trap_policer *policer)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_policer_init)
		return -EOPNOTSUPP;
	return mlxsw_driver->trap_policer_init(mlxsw_core, policer);
}

static void
mlxsw_devlink_trap_policer_fini(struct devlink *devlink,
				const struct devlink_trap_policer *policer)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_policer_fini)
		return;
	mlxsw_driver->trap_policer_fini(mlxsw_core, policer);
}

static int
mlxsw_devlink_trap_policer_set(struct devlink *devlink,
			       const struct devlink_trap_policer *policer,
			       u64 rate, u64 burst,
			       struct netlink_ext_ack *extack)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_policer_set)
		return -EOPNOTSUPP;
	return mlxsw_driver->trap_policer_set(mlxsw_core, policer, rate, burst,
					      extack);
}

static int
mlxsw_devlink_trap_policer_counter_get(struct devlink *devlink,
				       const struct devlink_trap_policer *policer,
				       u64 *p_drops)
{
	struct mlxsw_core *mlxsw_core = devlink_priv(devlink);
	struct mlxsw_driver *mlxsw_driver = mlxsw_core->driver;

	if (!mlxsw_driver->trap_policer_counter_get)
		return -EOPNOTSUPP;
	return mlxsw_driver->trap_policer_counter_get(mlxsw_core, policer,
						      p_drops);
}

1558
static const struct devlink_ops mlxsw_devlink_ops = {
1559 1560
	.reload_down		= mlxsw_devlink_core_bus_device_reload_down,
	.reload_up		= mlxsw_devlink_core_bus_device_reload_up,
1561
	.port_type_set			= mlxsw_devlink_port_type_set,
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
	.port_split			= mlxsw_devlink_port_split,
	.port_unsplit			= mlxsw_devlink_port_unsplit,
	.sb_pool_get			= mlxsw_devlink_sb_pool_get,
	.sb_pool_set			= mlxsw_devlink_sb_pool_set,
	.sb_port_pool_get		= mlxsw_devlink_sb_port_pool_get,
	.sb_port_pool_set		= mlxsw_devlink_sb_port_pool_set,
	.sb_tc_pool_bind_get		= mlxsw_devlink_sb_tc_pool_bind_get,
	.sb_tc_pool_bind_set		= mlxsw_devlink_sb_tc_pool_bind_set,
	.sb_occ_snapshot		= mlxsw_devlink_sb_occ_snapshot,
	.sb_occ_max_clear		= mlxsw_devlink_sb_occ_max_clear,
	.sb_occ_port_pool_get		= mlxsw_devlink_sb_occ_port_pool_get,
	.sb_occ_tc_port_bind_get	= mlxsw_devlink_sb_occ_tc_port_bind_get,
1574
	.info_get			= mlxsw_devlink_info_get,
1575
	.flash_update			= mlxsw_devlink_flash_update,
1576 1577 1578 1579
	.trap_init			= mlxsw_devlink_trap_init,
	.trap_fini			= mlxsw_devlink_trap_fini,
	.trap_action_set		= mlxsw_devlink_trap_action_set,
	.trap_group_init		= mlxsw_devlink_trap_group_init,
1580
	.trap_group_set			= mlxsw_devlink_trap_group_set,
1581 1582 1583 1584
	.trap_policer_init		= mlxsw_devlink_trap_policer_init,
	.trap_policer_fini		= mlxsw_devlink_trap_policer_fini,
	.trap_policer_set		= mlxsw_devlink_trap_policer_set,
	.trap_policer_counter_get	= mlxsw_devlink_trap_policer_counter_get,
1585 1586
};

1587 1588 1589 1590
static int mlxsw_core_params_register(struct mlxsw_core *mlxsw_core)
{
	int err;

1591 1592 1593 1594
	err = mlxsw_core_fw_params_register(mlxsw_core);
	if (err)
		return err;

1595 1596 1597
	if (mlxsw_core->driver->params_register) {
		err = mlxsw_core->driver->params_register(mlxsw_core);
		if (err)
1598
			goto err_params_register;
1599 1600
	}
	return 0;
1601 1602 1603 1604

err_params_register:
	mlxsw_core_fw_params_unregister(mlxsw_core);
	return err;
1605 1606 1607 1608
}

static void mlxsw_core_params_unregister(struct mlxsw_core *mlxsw_core)
{
1609
	mlxsw_core_fw_params_unregister(mlxsw_core);
1610 1611 1612 1613
	if (mlxsw_core->driver->params_register)
		mlxsw_core->driver->params_unregister(mlxsw_core);
}

1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843
struct mlxsw_core_health_event {
	struct mlxsw_core *mlxsw_core;
	char mfde_pl[MLXSW_REG_MFDE_LEN];
	struct work_struct work;
};

static void mlxsw_core_health_event_work(struct work_struct *work)
{
	struct mlxsw_core_health_event *event;
	struct mlxsw_core *mlxsw_core;

	event = container_of(work, struct mlxsw_core_health_event, work);
	mlxsw_core = event->mlxsw_core;
	devlink_health_report(mlxsw_core->health.fw_fatal, "FW fatal event occurred",
			      event->mfde_pl);
	kfree(event);
}

static void mlxsw_core_health_listener_func(const struct mlxsw_reg_info *reg,
					    char *mfde_pl, void *priv)
{
	struct mlxsw_core_health_event *event;
	struct mlxsw_core *mlxsw_core = priv;

	event = kmalloc(sizeof(*event), GFP_ATOMIC);
	if (!event)
		return;
	event->mlxsw_core = mlxsw_core;
	memcpy(event->mfde_pl, mfde_pl, sizeof(event->mfde_pl));
	INIT_WORK(&event->work, mlxsw_core_health_event_work);
	mlxsw_core_schedule_work(&event->work);
}

static const struct mlxsw_listener mlxsw_core_health_listener =
	MLXSW_EVENTL(mlxsw_core_health_listener_func, MFDE, MFDE);

static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *reporter,
					   struct devlink_fmsg *fmsg, void *priv_ctx,
					   struct netlink_ext_ack *extack)
{
	char *mfde_pl = priv_ctx;
	char *val_str;
	u8 event_id;
	u32 val;
	int err;

	if (!priv_ctx)
		/* User-triggered dumps are not possible */
		return -EOPNOTSUPP;

	val = mlxsw_reg_mfde_irisc_id_get(mfde_pl);
	err = devlink_fmsg_u8_pair_put(fmsg, "irisc_id", val);
	if (err)
		return err;
	err = devlink_fmsg_arr_pair_nest_start(fmsg, "event");
	if (err)
		return err;

	event_id = mlxsw_reg_mfde_event_id_get(mfde_pl);
	err = devlink_fmsg_u8_pair_put(fmsg, "id", event_id);
	if (err)
		return err;
	switch (event_id) {
	case MLXSW_REG_MFDE_EVENT_ID_CRSPACE_TO:
		val_str = "CR space timeout";
		break;
	case MLXSW_REG_MFDE_EVENT_ID_KVD_IM_STOP:
		val_str = "KVD insertion machine stopped";
		break;
	default:
		val_str = NULL;
	}
	if (val_str) {
		err = devlink_fmsg_string_pair_put(fmsg, "desc", val_str);
		if (err)
			return err;
	}
	err = devlink_fmsg_arr_pair_nest_end(fmsg);
	if (err)
		return err;

	val = mlxsw_reg_mfde_method_get(mfde_pl);
	switch (val) {
	case MLXSW_REG_MFDE_METHOD_QUERY:
		val_str = "query";
		break;
	case MLXSW_REG_MFDE_METHOD_WRITE:
		val_str = "write";
		break;
	default:
		val_str = NULL;
	}
	if (val_str) {
		err = devlink_fmsg_string_pair_put(fmsg, "method", val_str);
		if (err)
			return err;
	}

	val = mlxsw_reg_mfde_long_process_get(mfde_pl);
	err = devlink_fmsg_bool_pair_put(fmsg, "long_process", val);
	if (err)
		return err;

	val = mlxsw_reg_mfde_command_type_get(mfde_pl);
	switch (val) {
	case MLXSW_REG_MFDE_COMMAND_TYPE_MAD:
		val_str = "mad";
		break;
	case MLXSW_REG_MFDE_COMMAND_TYPE_EMAD:
		val_str = "emad";
		break;
	case MLXSW_REG_MFDE_COMMAND_TYPE_CMDIF:
		val_str = "cmdif";
		break;
	default:
		val_str = NULL;
	}
	if (val_str) {
		err = devlink_fmsg_string_pair_put(fmsg, "command_type", val_str);
		if (err)
			return err;
	}

	val = mlxsw_reg_mfde_reg_attr_id_get(mfde_pl);
	err = devlink_fmsg_u32_pair_put(fmsg, "reg_attr_id", val);
	if (err)
		return err;

	if (event_id == MLXSW_REG_MFDE_EVENT_ID_CRSPACE_TO) {
		val = mlxsw_reg_mfde_log_address_get(mfde_pl);
		err = devlink_fmsg_u32_pair_put(fmsg, "log_address", val);
		if (err)
			return err;
		val = mlxsw_reg_mfde_log_id_get(mfde_pl);
		err = devlink_fmsg_u8_pair_put(fmsg, "log_irisc_id", val);
		if (err)
			return err;
	} else if (event_id == MLXSW_REG_MFDE_EVENT_ID_KVD_IM_STOP) {
		val = mlxsw_reg_mfde_pipes_mask_get(mfde_pl);
		err = devlink_fmsg_u32_pair_put(fmsg, "pipes_mask", val);
		if (err)
			return err;
	}

	return 0;
}

static int
mlxsw_core_health_fw_fatal_test(struct devlink_health_reporter *reporter,
				struct netlink_ext_ack *extack)
{
	struct mlxsw_core *mlxsw_core = devlink_health_reporter_priv(reporter);
	char mfgd_pl[MLXSW_REG_MFGD_LEN];
	int err;

	/* Read the register first to make sure no other bits are changed. */
	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mfgd), mfgd_pl);
	if (err)
		return err;
	mlxsw_reg_mfgd_trigger_test_set(mfgd_pl, true);
	return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mfgd), mfgd_pl);
}

static const struct devlink_health_reporter_ops
mlxsw_core_health_fw_fatal_ops = {
	.name = "fw_fatal",
	.dump = mlxsw_core_health_fw_fatal_dump,
	.test = mlxsw_core_health_fw_fatal_test,
};

static int mlxsw_core_health_fw_fatal_config(struct mlxsw_core *mlxsw_core,
					     bool enable)
{
	char mfgd_pl[MLXSW_REG_MFGD_LEN];
	int err;

	/* Read the register first to make sure no other bits are changed. */
	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mfgd), mfgd_pl);
	if (err)
		return err;
	mlxsw_reg_mfgd_fatal_event_mode_set(mfgd_pl, enable);
	return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mfgd), mfgd_pl);
}

static int mlxsw_core_health_init(struct mlxsw_core *mlxsw_core)
{
	struct devlink *devlink = priv_to_devlink(mlxsw_core);
	struct devlink_health_reporter *fw_fatal;
	int err;

	if (!mlxsw_core->driver->fw_fatal_enabled)
		return 0;

	fw_fatal = devlink_health_reporter_create(devlink, &mlxsw_core_health_fw_fatal_ops,
						  0, mlxsw_core);
	if (IS_ERR(fw_fatal)) {
		dev_err(mlxsw_core->bus_info->dev, "Failed to create fw fatal reporter");
		return PTR_ERR(fw_fatal);
	}
	mlxsw_core->health.fw_fatal = fw_fatal;

	err = mlxsw_core_trap_register(mlxsw_core, &mlxsw_core_health_listener, mlxsw_core);
	if (err)
		goto err_trap_register;

	err = mlxsw_core_health_fw_fatal_config(mlxsw_core, true);
	if (err)
		goto err_fw_fatal_config;

	return 0;

err_fw_fatal_config:
	mlxsw_core_trap_unregister(mlxsw_core, &mlxsw_core_health_listener, mlxsw_core);
err_trap_register:
	devlink_health_reporter_destroy(mlxsw_core->health.fw_fatal);
	return err;
}

static void mlxsw_core_health_fini(struct mlxsw_core *mlxsw_core)
{
	if (!mlxsw_core->driver->fw_fatal_enabled)
		return;

	mlxsw_core_health_fw_fatal_config(mlxsw_core, false);
	mlxsw_core_trap_unregister(mlxsw_core, &mlxsw_core_health_listener, mlxsw_core);
	/* Make sure there is no more event work scheduled */
	mlxsw_core_flush_owq();
	devlink_health_reporter_destroy(mlxsw_core->health.fw_fatal);
}

1844 1845 1846 1847
static int
__mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info,
				 const struct mlxsw_bus *mlxsw_bus,
				 void *bus_priv, bool reload,
1848 1849
				 struct devlink *devlink,
				 struct netlink_ext_ack *extack)
1850 1851 1852 1853
{
	const char *device_kind = mlxsw_bus_info->device_kind;
	struct mlxsw_core *mlxsw_core;
	struct mlxsw_driver *mlxsw_driver;
1854
	struct mlxsw_res *res;
1855 1856 1857 1858 1859 1860
	size_t alloc_size;
	int err;

	mlxsw_driver = mlxsw_core_driver_get(device_kind);
	if (!mlxsw_driver)
		return -EINVAL;
1861 1862 1863 1864 1865 1866 1867 1868

	if (!reload) {
		alloc_size = sizeof(*mlxsw_core) + mlxsw_driver->priv_size;
		devlink = devlink_alloc(&mlxsw_devlink_ops, alloc_size);
		if (!devlink) {
			err = -ENOMEM;
			goto err_devlink_alloc;
		}
1869 1870
	}

J
Jiri Pirko 已提交
1871
	mlxsw_core = devlink_priv(devlink);
1872
	INIT_LIST_HEAD(&mlxsw_core->rx_listener_list);
1873
	INIT_LIST_HEAD(&mlxsw_core->event_listener_list);
1874 1875 1876 1877 1878
	mlxsw_core->driver = mlxsw_driver;
	mlxsw_core->bus = mlxsw_bus;
	mlxsw_core->bus_priv = bus_priv;
	mlxsw_core->bus_info = mlxsw_bus_info;

1879 1880
	res = mlxsw_driver->res_query_enabled ? &mlxsw_core->res : NULL;
	err = mlxsw_bus->init(bus_priv, mlxsw_core, mlxsw_driver->profile, res);
1881 1882 1883
	if (err)
		goto err_bus_init;

1884
	if (mlxsw_driver->resources_register && !reload) {
1885 1886 1887 1888 1889
		err = mlxsw_driver->resources_register(mlxsw_core);
		if (err)
			goto err_register_resources;
	}

1890 1891 1892 1893
	err = mlxsw_ports_init(mlxsw_core);
	if (err)
		goto err_ports_init;

J
Jiri Pirko 已提交
1894 1895 1896 1897 1898
	if (MLXSW_CORE_RES_VALID(mlxsw_core, MAX_LAG) &&
	    MLXSW_CORE_RES_VALID(mlxsw_core, MAX_LAG_MEMBERS)) {
		alloc_size = sizeof(u8) *
			MLXSW_CORE_RES_GET(mlxsw_core, MAX_LAG) *
			MLXSW_CORE_RES_GET(mlxsw_core, MAX_LAG_MEMBERS);
1899 1900 1901 1902 1903 1904 1905
		mlxsw_core->lag.mapping = kzalloc(alloc_size, GFP_KERNEL);
		if (!mlxsw_core->lag.mapping) {
			err = -ENOMEM;
			goto err_alloc_lag_mapping;
		}
	}

1906 1907 1908 1909
	err = mlxsw_emad_init(mlxsw_core);
	if (err)
		goto err_emad_init;

1910 1911 1912 1913 1914
	if (!reload) {
		err = devlink_register(devlink, mlxsw_bus_info->dev);
		if (err)
			goto err_devlink_register;
	}
J
Jiri Pirko 已提交
1915

1916 1917
	if (!reload) {
		err = mlxsw_core_params_register(mlxsw_core);
1918 1919 1920 1921
		if (err)
			goto err_register_params;
	}

1922 1923 1924 1925 1926
	err = mlxsw_core_fw_rev_validate(mlxsw_core, mlxsw_bus_info, mlxsw_driver->fw_req_rev,
					 mlxsw_driver->fw_filename);
	if (err)
		goto err_fw_rev_validate;

1927 1928 1929 1930
	err = mlxsw_core_health_init(mlxsw_core);
	if (err)
		goto err_health_init;

1931
	if (mlxsw_driver->init) {
1932
		err = mlxsw_driver->init(mlxsw_core, mlxsw_bus_info, extack);
1933 1934 1935 1936
		if (err)
			goto err_driver_init;
	}

J
Jiri Pirko 已提交
1937 1938 1939 1940
	err = mlxsw_hwmon_init(mlxsw_core, mlxsw_bus_info, &mlxsw_core->hwmon);
	if (err)
		goto err_hwmon_init;

I
Ivan Vecera 已提交
1941 1942 1943 1944 1945
	err = mlxsw_thermal_init(mlxsw_core, mlxsw_bus_info,
				 &mlxsw_core->thermal);
	if (err)
		goto err_thermal_init;

1946
	devlink_params_publish(devlink);
1947 1948

	if (!reload)
1949
		devlink_reload_enable(devlink);
1950

1951 1952
	return 0;

I
Ivan Vecera 已提交
1953
err_thermal_init:
1954
	mlxsw_hwmon_fini(mlxsw_core->hwmon);
J
Jiri Pirko 已提交
1955
err_hwmon_init:
1956 1957 1958
	if (mlxsw_core->driver->fini)
		mlxsw_core->driver->fini(mlxsw_core);
err_driver_init:
1959 1960
	mlxsw_core_health_fini(mlxsw_core);
err_health_init:
1961
err_fw_rev_validate:
1962 1963
	if (!reload)
		mlxsw_core_params_unregister(mlxsw_core);
1964
err_register_params:
1965 1966
	if (!reload)
		devlink_unregister(devlink);
J
Jiri Pirko 已提交
1967
err_devlink_register:
1968 1969
	mlxsw_emad_fini(mlxsw_core);
err_emad_init:
1970 1971
	kfree(mlxsw_core->lag.mapping);
err_alloc_lag_mapping:
1972 1973
	mlxsw_ports_fini(mlxsw_core);
err_ports_init:
1974 1975
	if (!reload)
		devlink_resources_unregister(devlink, NULL);
1976
err_register_resources:
1977 1978
	mlxsw_bus->fini(bus_priv);
err_bus_init:
1979 1980
	if (!reload)
		devlink_free(devlink);
J
Jiri Pirko 已提交
1981
err_devlink_alloc:
1982 1983
	return err;
}
1984 1985 1986 1987

int mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info,
				   const struct mlxsw_bus *mlxsw_bus,
				   void *bus_priv, bool reload,
1988 1989
				   struct devlink *devlink,
				   struct netlink_ext_ack *extack)
1990 1991 1992 1993 1994 1995
{
	bool called_again = false;
	int err;

again:
	err = __mlxsw_core_bus_device_register(mlxsw_bus_info, mlxsw_bus,
1996 1997
					       bus_priv, reload,
					       devlink, extack);
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
	/* -EAGAIN is returned in case the FW was updated. FW needs
	 * a reset, so lets try to call __mlxsw_core_bus_device_register()
	 * again.
	 */
	if (err == -EAGAIN && !called_again) {
		called_again = true;
		goto again;
	}

	return err;
}
2009 2010
EXPORT_SYMBOL(mlxsw_core_bus_device_register);

2011 2012
void mlxsw_core_bus_device_unregister(struct mlxsw_core *mlxsw_core,
				      bool reload)
2013
{
J
Jiri Pirko 已提交
2014
	struct devlink *devlink = priv_to_devlink(mlxsw_core);
2015

2016 2017
	if (!reload)
		devlink_reload_disable(devlink);
2018
	if (devlink_is_reload_failed(devlink)) {
2019 2020 2021 2022 2023 2024 2025 2026
		if (!reload)
			/* Only the parts that were not de-initialized in the
			 * failed reload attempt need to be de-initialized.
			 */
			goto reload_fail_deinit;
		else
			return;
	}
2027

2028
	devlink_params_unpublish(devlink);
I
Ivan Vecera 已提交
2029
	mlxsw_thermal_fini(mlxsw_core->thermal);
2030
	mlxsw_hwmon_fini(mlxsw_core->hwmon);
2031 2032
	if (mlxsw_core->driver->fini)
		mlxsw_core->driver->fini(mlxsw_core);
2033
	mlxsw_core_health_fini(mlxsw_core);
2034 2035
	if (!reload)
		mlxsw_core_params_unregister(mlxsw_core);
2036 2037
	if (!reload)
		devlink_unregister(devlink);
2038
	mlxsw_emad_fini(mlxsw_core);
2039
	kfree(mlxsw_core->lag.mapping);
2040
	mlxsw_ports_fini(mlxsw_core);
2041 2042
	if (!reload)
		devlink_resources_unregister(devlink, NULL);
2043
	mlxsw_core->bus->fini(mlxsw_core->bus_priv);
2044 2045 2046 2047

	return;

reload_fail_deinit:
2048
	mlxsw_core_params_unregister(mlxsw_core);
2049 2050
	devlink_unregister(devlink);
	devlink_resources_unregister(devlink, NULL);
J
Jiri Pirko 已提交
2051
	devlink_free(devlink);
2052 2053 2054
}
EXPORT_SYMBOL(mlxsw_core_bus_device_unregister);

2055
bool mlxsw_core_skb_transmit_busy(struct mlxsw_core *mlxsw_core,
2056 2057 2058 2059 2060 2061 2062
				  const struct mlxsw_tx_info *tx_info)
{
	return mlxsw_core->bus->skb_transmit_busy(mlxsw_core->bus_priv,
						  tx_info);
}
EXPORT_SYMBOL(mlxsw_core_skb_transmit_busy);

2063
int mlxsw_core_skb_transmit(struct mlxsw_core *mlxsw_core, struct sk_buff *skb,
2064 2065 2066 2067 2068 2069 2070
			    const struct mlxsw_tx_info *tx_info)
{
	return mlxsw_core->bus->skb_transmit(mlxsw_core->bus_priv, skb,
					     tx_info);
}
EXPORT_SYMBOL(mlxsw_core_skb_transmit);

2071 2072 2073 2074 2075 2076 2077 2078 2079
void mlxsw_core_ptp_transmitted(struct mlxsw_core *mlxsw_core,
				struct sk_buff *skb, u8 local_port)
{
	if (mlxsw_core->driver->ptp_transmitted)
		mlxsw_core->driver->ptp_transmitted(mlxsw_core, skb,
						    local_port);
}
EXPORT_SYMBOL(mlxsw_core_ptp_transmitted);

2080 2081 2082 2083 2084
static bool __is_rx_listener_equal(const struct mlxsw_rx_listener *rxl_a,
				   const struct mlxsw_rx_listener *rxl_b)
{
	return (rxl_a->func == rxl_b->func &&
		rxl_a->local_port == rxl_b->local_port &&
2085 2086
		rxl_a->trap_id == rxl_b->trap_id &&
		rxl_a->mirror_reason == rxl_b->mirror_reason);
2087 2088 2089 2090
}

static struct mlxsw_rx_listener_item *
__find_rx_listener_item(struct mlxsw_core *mlxsw_core,
2091
			const struct mlxsw_rx_listener *rxl)
2092 2093 2094 2095
{
	struct mlxsw_rx_listener_item *rxl_item;

	list_for_each_entry(rxl_item, &mlxsw_core->rx_listener_list, list) {
2096
		if (__is_rx_listener_equal(&rxl_item->rxl, rxl))
2097 2098 2099 2100 2101 2102 2103
			return rxl_item;
	}
	return NULL;
}

int mlxsw_core_rx_listener_register(struct mlxsw_core *mlxsw_core,
				    const struct mlxsw_rx_listener *rxl,
2104
				    void *priv, bool enabled)
2105 2106 2107
{
	struct mlxsw_rx_listener_item *rxl_item;

2108
	rxl_item = __find_rx_listener_item(mlxsw_core, rxl);
2109 2110 2111 2112 2113 2114 2115
	if (rxl_item)
		return -EEXIST;
	rxl_item = kmalloc(sizeof(*rxl_item), GFP_KERNEL);
	if (!rxl_item)
		return -ENOMEM;
	rxl_item->rxl = *rxl;
	rxl_item->priv = priv;
2116
	rxl_item->enabled = enabled;
2117 2118 2119 2120 2121 2122 2123

	list_add_rcu(&rxl_item->list, &mlxsw_core->rx_listener_list);
	return 0;
}
EXPORT_SYMBOL(mlxsw_core_rx_listener_register);

void mlxsw_core_rx_listener_unregister(struct mlxsw_core *mlxsw_core,
2124
				       const struct mlxsw_rx_listener *rxl)
2125 2126 2127
{
	struct mlxsw_rx_listener_item *rxl_item;

2128
	rxl_item = __find_rx_listener_item(mlxsw_core, rxl);
2129 2130 2131 2132 2133 2134 2135 2136
	if (!rxl_item)
		return;
	list_del_rcu(&rxl_item->list);
	synchronize_rcu();
	kfree(rxl_item);
}
EXPORT_SYMBOL(mlxsw_core_rx_listener_unregister);

2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149
static void
mlxsw_core_rx_listener_state_set(struct mlxsw_core *mlxsw_core,
				 const struct mlxsw_rx_listener *rxl,
				 bool enabled)
{
	struct mlxsw_rx_listener_item *rxl_item;

	rxl_item = __find_rx_listener_item(mlxsw_core, rxl);
	if (WARN_ON(!rxl_item))
		return;
	rxl_item->enabled = enabled;
}

2150 2151 2152 2153 2154 2155
static void mlxsw_core_event_listener_func(struct sk_buff *skb, u8 local_port,
					   void *priv)
{
	struct mlxsw_event_listener_item *event_listener_item = priv;
	struct mlxsw_reg_info reg;
	char *payload;
2156 2157 2158 2159 2160 2161
	char *reg_tlv;
	char *op_tlv;

	mlxsw_emad_tlv_parse(skb);
	op_tlv = mlxsw_emad_op_tlv(skb);
	reg_tlv = mlxsw_emad_reg_tlv(skb);
2162 2163 2164

	reg.id = mlxsw_emad_op_tlv_register_id_get(op_tlv);
	reg.len = (mlxsw_emad_reg_tlv_len_get(reg_tlv) - 1) * sizeof(u32);
2165
	payload = mlxsw_emad_reg_payload(reg_tlv);
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
	event_listener_item->el.func(&reg, payload, event_listener_item->priv);
	dev_kfree_skb(skb);
}

static bool __is_event_listener_equal(const struct mlxsw_event_listener *el_a,
				      const struct mlxsw_event_listener *el_b)
{
	return (el_a->func == el_b->func &&
		el_a->trap_id == el_b->trap_id);
}

static struct mlxsw_event_listener_item *
__find_event_listener_item(struct mlxsw_core *mlxsw_core,
2179
			   const struct mlxsw_event_listener *el)
2180 2181 2182 2183
{
	struct mlxsw_event_listener_item *el_item;

	list_for_each_entry(el_item, &mlxsw_core->event_listener_list, list) {
2184
		if (__is_event_listener_equal(&el_item->el, el))
2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
			return el_item;
	}
	return NULL;
}

int mlxsw_core_event_listener_register(struct mlxsw_core *mlxsw_core,
				       const struct mlxsw_event_listener *el,
				       void *priv)
{
	int err;
	struct mlxsw_event_listener_item *el_item;
	const struct mlxsw_rx_listener rxl = {
		.func = mlxsw_core_event_listener_func,
		.local_port = MLXSW_PORT_DONT_CARE,
		.trap_id = el->trap_id,
	};

2202
	el_item = __find_event_listener_item(mlxsw_core, el);
2203 2204 2205 2206 2207 2208 2209 2210
	if (el_item)
		return -EEXIST;
	el_item = kmalloc(sizeof(*el_item), GFP_KERNEL);
	if (!el_item)
		return -ENOMEM;
	el_item->el = *el;
	el_item->priv = priv;

2211
	err = mlxsw_core_rx_listener_register(mlxsw_core, &rxl, el_item, true);
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
	if (err)
		goto err_rx_listener_register;

	/* No reason to save item if we did not manage to register an RX
	 * listener for it.
	 */
	list_add_rcu(&el_item->list, &mlxsw_core->event_listener_list);

	return 0;

err_rx_listener_register:
	kfree(el_item);
	return err;
}
EXPORT_SYMBOL(mlxsw_core_event_listener_register);

void mlxsw_core_event_listener_unregister(struct mlxsw_core *mlxsw_core,
2229
					  const struct mlxsw_event_listener *el)
2230 2231 2232 2233 2234 2235 2236 2237
{
	struct mlxsw_event_listener_item *el_item;
	const struct mlxsw_rx_listener rxl = {
		.func = mlxsw_core_event_listener_func,
		.local_port = MLXSW_PORT_DONT_CARE,
		.trap_id = el->trap_id,
	};

2238
	el_item = __find_event_listener_item(mlxsw_core, el);
2239 2240
	if (!el_item)
		return;
2241
	mlxsw_core_rx_listener_unregister(mlxsw_core, &rxl);
2242 2243 2244 2245 2246
	list_del(&el_item->list);
	kfree(el_item);
}
EXPORT_SYMBOL(mlxsw_core_event_listener_unregister);

2247 2248
static int mlxsw_core_listener_register(struct mlxsw_core *mlxsw_core,
					const struct mlxsw_listener *listener,
2249
					void *priv, bool enabled)
2250
{
2251 2252
	if (listener->is_event) {
		WARN_ON(!enabled);
2253
		return mlxsw_core_event_listener_register(mlxsw_core,
2254
						&listener->event_listener,
2255
						priv);
2256
	} else {
2257
		return mlxsw_core_rx_listener_register(mlxsw_core,
2258
						&listener->rx_listener,
2259 2260
						priv, enabled);
	}
2261 2262 2263 2264 2265 2266 2267 2268
}

static void mlxsw_core_listener_unregister(struct mlxsw_core *mlxsw_core,
				      const struct mlxsw_listener *listener,
				      void *priv)
{
	if (listener->is_event)
		mlxsw_core_event_listener_unregister(mlxsw_core,
2269
						     &listener->event_listener);
2270 2271
	else
		mlxsw_core_rx_listener_unregister(mlxsw_core,
2272
						  &listener->rx_listener);
2273 2274 2275 2276 2277
}

int mlxsw_core_trap_register(struct mlxsw_core *mlxsw_core,
			     const struct mlxsw_listener *listener, void *priv)
{
2278
	enum mlxsw_reg_htgt_trap_group trap_group;
2279
	enum mlxsw_reg_hpkt_action action;
2280 2281 2282
	char hpkt_pl[MLXSW_REG_HPKT_LEN];
	int err;

2283 2284
	err = mlxsw_core_listener_register(mlxsw_core, listener, priv,
					   listener->enabled_on_register);
2285 2286 2287
	if (err)
		return err;

2288 2289
	action = listener->enabled_on_register ? listener->en_action :
						 listener->dis_action;
2290 2291
	trap_group = listener->enabled_on_register ? listener->en_trap_group :
						     listener->dis_trap_group;
2292
	mlxsw_reg_hpkt_pack(hpkt_pl, action, listener->trap_id,
2293
			    trap_group, listener->is_ctrl);
N
Nogah Frankel 已提交
2294
	err = mlxsw_reg_write(mlxsw_core,  MLXSW_REG(hpkt), hpkt_pl);
2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312
	if (err)
		goto err_trap_set;

	return 0;

err_trap_set:
	mlxsw_core_listener_unregister(mlxsw_core, listener, priv);
	return err;
}
EXPORT_SYMBOL(mlxsw_core_trap_register);

void mlxsw_core_trap_unregister(struct mlxsw_core *mlxsw_core,
				const struct mlxsw_listener *listener,
				void *priv)
{
	char hpkt_pl[MLXSW_REG_HPKT_LEN];

	if (!listener->is_event) {
2313
		mlxsw_reg_hpkt_pack(hpkt_pl, listener->dis_action,
2314
				    listener->trap_id, listener->dis_trap_group,
N
Nogah Frankel 已提交
2315
				    listener->is_ctrl);
2316 2317 2318 2319 2320 2321 2322
		mlxsw_reg_write(mlxsw_core, MLXSW_REG(hpkt), hpkt_pl);
	}

	mlxsw_core_listener_unregister(mlxsw_core, listener, priv);
}
EXPORT_SYMBOL(mlxsw_core_trap_unregister);

2323 2324 2325
int mlxsw_core_trap_state_set(struct mlxsw_core *mlxsw_core,
			      const struct mlxsw_listener *listener,
			      bool enabled)
2326
{
2327
	enum mlxsw_reg_htgt_trap_group trap_group;
2328
	enum mlxsw_reg_hpkt_action action;
2329
	char hpkt_pl[MLXSW_REG_HPKT_LEN];
2330 2331 2332 2333 2334
	int err;

	/* Not supported for event listener */
	if (WARN_ON(listener->is_event))
		return -EINVAL;
2335

2336
	action = enabled ? listener->en_action : listener->dis_action;
2337 2338
	trap_group = enabled ? listener->en_trap_group :
			       listener->dis_trap_group;
2339
	mlxsw_reg_hpkt_pack(hpkt_pl, action, listener->trap_id,
2340
			    trap_group, listener->is_ctrl);
2341 2342 2343 2344 2345 2346 2347
	err = mlxsw_reg_write(mlxsw_core, MLXSW_REG(hpkt), hpkt_pl);
	if (err)
		return err;

	mlxsw_core_rx_listener_state_set(mlxsw_core, &listener->rx_listener,
					 enabled);
	return 0;
2348
}
2349
EXPORT_SYMBOL(mlxsw_core_trap_state_set);
2350

2351 2352 2353 2354 2355
static u64 mlxsw_core_tid_get(struct mlxsw_core *mlxsw_core)
{
	return atomic64_inc_return(&mlxsw_core->emad.tid);
}

2356 2357 2358
static int mlxsw_core_reg_access_emad(struct mlxsw_core *mlxsw_core,
				      const struct mlxsw_reg_info *reg,
				      char *payload,
2359 2360 2361 2362
				      enum mlxsw_core_reg_access_type type,
				      struct list_head *bulk_list,
				      mlxsw_reg_trans_cb_t *cb,
				      unsigned long cb_priv)
2363
{
2364 2365
	u64 tid = mlxsw_core_tid_get(mlxsw_core);
	struct mlxsw_reg_trans *trans;
2366 2367
	int err;

2368 2369
	trans = kzalloc(sizeof(*trans), GFP_KERNEL);
	if (!trans)
2370 2371
		return -ENOMEM;

2372 2373 2374
	err = mlxsw_emad_reg_access(mlxsw_core, reg, payload, type, trans,
				    bulk_list, cb, cb_priv, tid);
	if (err) {
2375
		kfree_rcu(trans, rcu);
2376 2377 2378 2379
		return err;
	}
	return 0;
}
2380

2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
int mlxsw_reg_trans_query(struct mlxsw_core *mlxsw_core,
			  const struct mlxsw_reg_info *reg, char *payload,
			  struct list_head *bulk_list,
			  mlxsw_reg_trans_cb_t *cb, unsigned long cb_priv)
{
	return mlxsw_core_reg_access_emad(mlxsw_core, reg, payload,
					  MLXSW_CORE_REG_ACCESS_TYPE_QUERY,
					  bulk_list, cb, cb_priv);
}
EXPORT_SYMBOL(mlxsw_reg_trans_query);
2391

2392 2393 2394 2395 2396 2397 2398 2399 2400 2401
int mlxsw_reg_trans_write(struct mlxsw_core *mlxsw_core,
			  const struct mlxsw_reg_info *reg, char *payload,
			  struct list_head *bulk_list,
			  mlxsw_reg_trans_cb_t *cb, unsigned long cb_priv)
{
	return mlxsw_core_reg_access_emad(mlxsw_core, reg, payload,
					  MLXSW_CORE_REG_ACCESS_TYPE_WRITE,
					  bulk_list, cb, cb_priv);
}
EXPORT_SYMBOL(mlxsw_reg_trans_write);
2402

2403 2404
#define MLXSW_REG_TRANS_ERR_STRING_SIZE	256

2405 2406
static int mlxsw_reg_trans_wait(struct mlxsw_reg_trans *trans)
{
2407
	char err_string[MLXSW_REG_TRANS_ERR_STRING_SIZE];
2408 2409
	struct mlxsw_core *mlxsw_core = trans->core;
	int err;
2410

2411 2412 2413
	wait_for_completion(&trans->completion);
	cancel_delayed_work_sync(&trans->timeout_dw);
	err = trans->err;
2414

2415 2416 2417
	if (trans->retries)
		dev_warn(mlxsw_core->bus_info->dev, "EMAD retries (%d/%d) (tid=%llx)\n",
			 trans->retries, MLXSW_EMAD_MAX_RETRY, trans->tid);
N
Nir Dotan 已提交
2418
	if (err) {
2419 2420 2421 2422 2423 2424
		dev_err(mlxsw_core->bus_info->dev, "EMAD reg access failed (tid=%llx,reg_id=%x(%s),type=%s,status=%x(%s))\n",
			trans->tid, trans->reg->id,
			mlxsw_reg_id_str(trans->reg->id),
			mlxsw_core_reg_access_type_str(trans->type),
			trans->emad_status,
			mlxsw_emad_op_tlv_status_str(trans->emad_status));
2425 2426

		snprintf(err_string, MLXSW_REG_TRANS_ERR_STRING_SIZE,
2427
			 "(tid=%llx,reg_id=%x(%s)) %s (%s)\n", trans->tid,
2428
			 trans->reg->id, mlxsw_reg_id_str(trans->reg->id),
2429 2430
			 mlxsw_emad_op_tlv_status_str(trans->emad_status),
			 trans->emad_err_string ? trans->emad_err_string : "");
2431

N
Nir Dotan 已提交
2432
		trace_devlink_hwerr(priv_to_devlink(mlxsw_core),
2433
				    trans->emad_status, err_string);
2434 2435

		kfree(trans->emad_err_string);
N
Nir Dotan 已提交
2436
	}
2437 2438 2439

	list_del(&trans->bulk_list);
	kfree_rcu(trans, rcu);
2440 2441 2442
	return err;
}

2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
int mlxsw_reg_trans_bulk_wait(struct list_head *bulk_list)
{
	struct mlxsw_reg_trans *trans;
	struct mlxsw_reg_trans *tmp;
	int sum_err = 0;
	int err;

	list_for_each_entry_safe(trans, tmp, bulk_list, bulk_list) {
		err = mlxsw_reg_trans_wait(trans);
		if (err && sum_err == 0)
			sum_err = err; /* first error to be returned */
	}
	return sum_err;
}
EXPORT_SYMBOL(mlxsw_reg_trans_bulk_wait);

2459 2460 2461 2462 2463
static int mlxsw_core_reg_access_cmd(struct mlxsw_core *mlxsw_core,
				     const struct mlxsw_reg_info *reg,
				     char *payload,
				     enum mlxsw_core_reg_access_type type)
{
2464
	enum mlxsw_emad_op_tlv_status status;
2465
	int err, n_retry;
2466
	bool reset_ok;
2467 2468
	char *in_mbox, *out_mbox, *tmp;

2469 2470 2471 2472
	dev_dbg(mlxsw_core->bus_info->dev, "Reg cmd access (reg_id=%x(%s),type=%s)\n",
		reg->id, mlxsw_reg_id_str(reg->id),
		mlxsw_core_reg_access_type_str(type));

2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
	in_mbox = mlxsw_cmd_mbox_alloc();
	if (!in_mbox)
		return -ENOMEM;

	out_mbox = mlxsw_cmd_mbox_alloc();
	if (!out_mbox) {
		err = -ENOMEM;
		goto free_in_mbox;
	}

2483 2484
	mlxsw_emad_pack_op_tlv(in_mbox, reg, type,
			       mlxsw_core_tid_get(mlxsw_core));
2485 2486 2487
	tmp = in_mbox + MLXSW_EMAD_OP_TLV_LEN * sizeof(u32);
	mlxsw_emad_pack_reg_tlv(tmp, reg, payload);

2488 2489 2490 2491 2492 2493 2494
	/* There is a special treatment needed for MRSR (reset) register.
	 * The command interface will return error after the command
	 * is executed, so tell the lower layer to expect it
	 * and cope accordingly.
	 */
	reset_ok = reg->id == MLXSW_REG_MRSR_ID;

2495 2496
	n_retry = 0;
retry:
2497
	err = mlxsw_cmd_access_reg(mlxsw_core, reset_ok, in_mbox, out_mbox);
2498
	if (!err) {
2499 2500 2501 2502 2503 2504 2505
		err = mlxsw_emad_process_status(out_mbox, &status);
		if (err) {
			if (err == -EAGAIN && n_retry++ < MLXSW_EMAD_MAX_RETRY)
				goto retry;
			dev_err(mlxsw_core->bus_info->dev, "Reg cmd access status failed (status=%x(%s))\n",
				status, mlxsw_emad_op_tlv_status_str(status));
		}
2506 2507 2508
	}

	if (!err)
2509
		memcpy(payload, mlxsw_emad_reg_payload_cmd(out_mbox),
2510 2511 2512 2513 2514
		       reg->len);

	mlxsw_cmd_mbox_free(out_mbox);
free_in_mbox:
	mlxsw_cmd_mbox_free(in_mbox);
2515 2516 2517 2518
	if (err)
		dev_err(mlxsw_core->bus_info->dev, "Reg cmd access failed (reg_id=%x(%s),type=%s)\n",
			reg->id, mlxsw_reg_id_str(reg->id),
			mlxsw_core_reg_access_type_str(type));
2519 2520 2521
	return err;
}

2522 2523 2524 2525 2526 2527 2528 2529 2530
static void mlxsw_core_reg_access_cb(struct mlxsw_core *mlxsw_core,
				     char *payload, size_t payload_len,
				     unsigned long cb_priv)
{
	char *orig_payload = (char *) cb_priv;

	memcpy(orig_payload, payload, payload_len);
}

2531 2532 2533 2534 2535
static int mlxsw_core_reg_access(struct mlxsw_core *mlxsw_core,
				 const struct mlxsw_reg_info *reg,
				 char *payload,
				 enum mlxsw_core_reg_access_type type)
{
2536
	LIST_HEAD(bulk_list);
2537 2538 2539 2540 2541 2542 2543
	int err;

	/* During initialization EMAD interface is not available to us,
	 * so we default to command interface. We switch to EMAD interface
	 * after setting the appropriate traps.
	 */
	if (!mlxsw_core->emad.use_emad)
2544
		return mlxsw_core_reg_access_cmd(mlxsw_core, reg,
2545 2546
						 payload, type);

2547 2548 2549 2550
	err = mlxsw_core_reg_access_emad(mlxsw_core, reg,
					 payload, type, &bulk_list,
					 mlxsw_core_reg_access_cb,
					 (unsigned long) payload);
2551
	if (err)
2552 2553
		return err;
	return mlxsw_reg_trans_bulk_wait(&bulk_list);
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571
}

int mlxsw_reg_query(struct mlxsw_core *mlxsw_core,
		    const struct mlxsw_reg_info *reg, char *payload)
{
	return mlxsw_core_reg_access(mlxsw_core, reg, payload,
				     MLXSW_CORE_REG_ACCESS_TYPE_QUERY);
}
EXPORT_SYMBOL(mlxsw_reg_query);

int mlxsw_reg_write(struct mlxsw_core *mlxsw_core,
		    const struct mlxsw_reg_info *reg, char *payload)
{
	return mlxsw_core_reg_access(mlxsw_core, reg, payload,
				     MLXSW_CORE_REG_ACCESS_TYPE_WRITE);
}
EXPORT_SYMBOL(mlxsw_reg_write);

2572 2573 2574 2575 2576
void mlxsw_core_skb_receive(struct mlxsw_core *mlxsw_core, struct sk_buff *skb,
			    struct mlxsw_rx_info *rx_info)
{
	struct mlxsw_rx_listener_item *rxl_item;
	const struct mlxsw_rx_listener *rxl;
2577
	u8 local_port;
2578 2579
	bool found = false;

2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
	if (rx_info->is_lag) {
		dev_dbg_ratelimited(mlxsw_core->bus_info->dev, "%s: lag_id = %d, lag_port_index = 0x%x\n",
				    __func__, rx_info->u.lag_id,
				    rx_info->trap_id);
		/* Upper layer does not care if the skb came from LAG or not,
		 * so just get the local_port for the lag port and push it up.
		 */
		local_port = mlxsw_core_lag_mapping_get(mlxsw_core,
							rx_info->u.lag_id,
							rx_info->lag_port_index);
	} else {
		local_port = rx_info->u.sys_port;
	}

	dev_dbg_ratelimited(mlxsw_core->bus_info->dev, "%s: local_port = %d, trap_id = 0x%x\n",
			    __func__, local_port, rx_info->trap_id);
2596 2597

	if ((rx_info->trap_id >= MLXSW_TRAP_ID_MAX) ||
2598
	    (local_port >= mlxsw_core->max_ports))
2599 2600 2601 2602 2603 2604 2605
		goto drop;

	rcu_read_lock();
	list_for_each_entry_rcu(rxl_item, &mlxsw_core->rx_listener_list, list) {
		rxl = &rxl_item->rxl;
		if ((rxl->local_port == MLXSW_PORT_DONT_CARE ||
		     rxl->local_port == local_port) &&
2606 2607
		    rxl->trap_id == rx_info->trap_id &&
		    rxl->mirror_reason == rx_info->mirror_reason) {
2608 2609
			if (rxl_item->enabled)
				found = true;
2610 2611 2612
			break;
		}
	}
2613 2614
	if (!found) {
		rcu_read_unlock();
2615
		goto drop;
2616
	}
2617 2618

	rxl->func(skb, local_port, rxl_item->priv);
2619
	rcu_read_unlock();
2620 2621 2622 2623 2624 2625 2626
	return;

drop:
	dev_kfree_skb(skb);
}
EXPORT_SYMBOL(mlxsw_core_skb_receive);

2627 2628 2629
static int mlxsw_core_lag_mapping_index(struct mlxsw_core *mlxsw_core,
					u16 lag_id, u8 port_index)
{
J
Jiri Pirko 已提交
2630
	return MLXSW_CORE_RES_GET(mlxsw_core, MAX_LAG_MEMBERS) * lag_id +
2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658
	       port_index;
}

void mlxsw_core_lag_mapping_set(struct mlxsw_core *mlxsw_core,
				u16 lag_id, u8 port_index, u8 local_port)
{
	int index = mlxsw_core_lag_mapping_index(mlxsw_core,
						 lag_id, port_index);

	mlxsw_core->lag.mapping[index] = local_port;
}
EXPORT_SYMBOL(mlxsw_core_lag_mapping_set);

u8 mlxsw_core_lag_mapping_get(struct mlxsw_core *mlxsw_core,
			      u16 lag_id, u8 port_index)
{
	int index = mlxsw_core_lag_mapping_index(mlxsw_core,
						 lag_id, port_index);

	return mlxsw_core->lag.mapping[index];
}
EXPORT_SYMBOL(mlxsw_core_lag_mapping_get);

void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core,
				  u16 lag_id, u8 local_port)
{
	int i;

J
Jiri Pirko 已提交
2659
	for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_core, MAX_LAG_MEMBERS); i++) {
2660 2661 2662 2663 2664 2665 2666 2667 2668
		int index = mlxsw_core_lag_mapping_index(mlxsw_core,
							 lag_id, i);

		if (mlxsw_core->lag.mapping[index] == local_port)
			mlxsw_core->lag.mapping[index] = 0;
	}
}
EXPORT_SYMBOL(mlxsw_core_lag_mapping_clear);

J
Jiri Pirko 已提交
2669 2670
bool mlxsw_core_res_valid(struct mlxsw_core *mlxsw_core,
			  enum mlxsw_res_id res_id)
2671
{
J
Jiri Pirko 已提交
2672
	return mlxsw_res_valid(&mlxsw_core->res, res_id);
2673
}
J
Jiri Pirko 已提交
2674 2675 2676 2677 2678 2679 2680 2681
EXPORT_SYMBOL(mlxsw_core_res_valid);

u64 mlxsw_core_res_get(struct mlxsw_core *mlxsw_core,
		       enum mlxsw_res_id res_id)
{
	return mlxsw_res_get(&mlxsw_core->res, res_id);
}
EXPORT_SYMBOL(mlxsw_core_res_get);
2682

2683 2684 2685 2686
static int __mlxsw_core_port_init(struct mlxsw_core *mlxsw_core, u8 local_port,
				  enum devlink_port_flavour flavour,
				  u32 port_number, bool split,
				  u32 split_port_subnumber,
2687
				  bool splittable, u32 lanes,
2688 2689
				  const unsigned char *switch_id,
				  unsigned char switch_id_len)
2690 2691
{
	struct devlink *devlink = priv_to_devlink(mlxsw_core);
2692 2693
	struct mlxsw_core_port *mlxsw_core_port =
					&mlxsw_core->ports[local_port];
2694
	struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;
2695
	struct devlink_port_attrs attrs = {};
2696
	int err;
2697

2698
	attrs.split = split;
2699
	attrs.lanes = lanes;
2700
	attrs.splittable = splittable;
2701 2702 2703 2704 2705
	attrs.flavour = flavour;
	attrs.phys.port_number = port_number;
	attrs.phys.split_subport_number = split_port_subnumber;
	memcpy(attrs.switch_id.id, switch_id, switch_id_len);
	attrs.switch_id.id_len = switch_id_len;
2706
	mlxsw_core_port->local_port = local_port;
2707
	devlink_port_attrs_set(devlink_port, &attrs);
2708 2709 2710 2711
	err = devlink_port_register(devlink, devlink_port, local_port);
	if (err)
		memset(mlxsw_core_port, 0, sizeof(*mlxsw_core_port));
	return err;
2712 2713
}

2714
static void __mlxsw_core_port_fini(struct mlxsw_core *mlxsw_core, u8 local_port)
2715
{
2716 2717
	struct mlxsw_core_port *mlxsw_core_port =
					&mlxsw_core->ports[local_port];
2718 2719 2720
	struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;

	devlink_port_unregister(devlink_port);
2721
	memset(mlxsw_core_port, 0, sizeof(*mlxsw_core_port));
2722
}
2723 2724 2725 2726

int mlxsw_core_port_init(struct mlxsw_core *mlxsw_core, u8 local_port,
			 u32 port_number, bool split,
			 u32 split_port_subnumber,
2727
			 bool splittable, u32 lanes,
2728 2729 2730 2731 2732 2733
			 const unsigned char *switch_id,
			 unsigned char switch_id_len)
{
	return __mlxsw_core_port_init(mlxsw_core, local_port,
				      DEVLINK_PORT_FLAVOUR_PHYSICAL,
				      port_number, split, split_port_subnumber,
2734 2735
				      splittable, lanes,
				      switch_id, switch_id_len);
2736 2737 2738 2739 2740 2741 2742
}
EXPORT_SYMBOL(mlxsw_core_port_init);

void mlxsw_core_port_fini(struct mlxsw_core *mlxsw_core, u8 local_port)
{
	__mlxsw_core_port_fini(mlxsw_core, local_port);
}
2743 2744
EXPORT_SYMBOL(mlxsw_core_port_fini);

2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755
int mlxsw_core_cpu_port_init(struct mlxsw_core *mlxsw_core,
			     void *port_driver_priv,
			     const unsigned char *switch_id,
			     unsigned char switch_id_len)
{
	struct mlxsw_core_port *mlxsw_core_port =
				&mlxsw_core->ports[MLXSW_PORT_CPU_PORT];
	int err;

	err = __mlxsw_core_port_init(mlxsw_core, MLXSW_PORT_CPU_PORT,
				     DEVLINK_PORT_FLAVOUR_CPU,
2756
				     0, false, 0, false, 0,
2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
				     switch_id, switch_id_len);
	if (err)
		return err;

	mlxsw_core_port->port_driver_priv = port_driver_priv;
	return 0;
}
EXPORT_SYMBOL(mlxsw_core_cpu_port_init);

void mlxsw_core_cpu_port_fini(struct mlxsw_core *mlxsw_core)
{
	__mlxsw_core_port_fini(mlxsw_core, MLXSW_PORT_CPU_PORT);
}
EXPORT_SYMBOL(mlxsw_core_cpu_port_fini);

2772
void mlxsw_core_port_eth_set(struct mlxsw_core *mlxsw_core, u8 local_port,
2773
			     void *port_driver_priv, struct net_device *dev)
2774 2775 2776 2777 2778 2779 2780 2781
{
	struct mlxsw_core_port *mlxsw_core_port =
					&mlxsw_core->ports[local_port];
	struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;

	mlxsw_core_port->port_driver_priv = port_driver_priv;
	devlink_port_type_eth_set(devlink_port, dev);
}
2782
EXPORT_SYMBOL(mlxsw_core_port_eth_set);
2783

2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
void mlxsw_core_port_ib_set(struct mlxsw_core *mlxsw_core, u8 local_port,
			    void *port_driver_priv)
{
	struct mlxsw_core_port *mlxsw_core_port =
					&mlxsw_core->ports[local_port];
	struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;

	mlxsw_core_port->port_driver_priv = port_driver_priv;
	devlink_port_type_ib_set(devlink_port, NULL);
}
EXPORT_SYMBOL(mlxsw_core_port_ib_set);

2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807
void mlxsw_core_port_clear(struct mlxsw_core *mlxsw_core, u8 local_port,
			   void *port_driver_priv)
{
	struct mlxsw_core_port *mlxsw_core_port =
					&mlxsw_core->ports[local_port];
	struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;

	mlxsw_core_port->port_driver_priv = port_driver_priv;
	devlink_port_type_clear(devlink_port);
}
EXPORT_SYMBOL(mlxsw_core_port_clear);

2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818
enum devlink_port_type mlxsw_core_port_type_get(struct mlxsw_core *mlxsw_core,
						u8 local_port)
{
	struct mlxsw_core_port *mlxsw_core_port =
					&mlxsw_core->ports[local_port];
	struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;

	return devlink_port->type;
}
EXPORT_SYMBOL(mlxsw_core_port_type_get);

2819

2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831
struct devlink_port *
mlxsw_core_port_devlink_port_get(struct mlxsw_core *mlxsw_core,
				 u8 local_port)
{
	struct mlxsw_core_port *mlxsw_core_port =
					&mlxsw_core->ports[local_port];
	struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;

	return devlink_port;
}
EXPORT_SYMBOL(mlxsw_core_port_devlink_port_get);

2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846
int mlxsw_core_module_max_width(struct mlxsw_core *mlxsw_core, u8 module)
{
	enum mlxsw_reg_pmtm_module_type module_type;
	char pmtm_pl[MLXSW_REG_PMTM_LEN];
	int err;

	mlxsw_reg_pmtm_pack(pmtm_pl, module);
	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(pmtm), pmtm_pl);
	if (err)
		return err;
	mlxsw_reg_pmtm_unpack(pmtm_pl, &module_type);

	/* Here we need to get the module width according to the module type. */

	switch (module_type) {
2847 2848
	case MLXSW_REG_PMTM_MODULE_TYPE_C2C8X:
	case MLXSW_REG_PMTM_MODULE_TYPE_QSFP_DD:
2849 2850
	case MLXSW_REG_PMTM_MODULE_TYPE_OSFP:
		return 8;
2851 2852
	case MLXSW_REG_PMTM_MODULE_TYPE_C2C4X:
	case MLXSW_REG_PMTM_MODULE_TYPE_BP_4X:
2853
	case MLXSW_REG_PMTM_MODULE_TYPE_QSFP:
2854
		return 4;
2855 2856 2857
	case MLXSW_REG_PMTM_MODULE_TYPE_C2C2X:
	case MLXSW_REG_PMTM_MODULE_TYPE_BP_2X:
	case MLXSW_REG_PMTM_MODULE_TYPE_SFP_DD:
2858
	case MLXSW_REG_PMTM_MODULE_TYPE_DSFP:
2859
		return 2;
2860 2861
	case MLXSW_REG_PMTM_MODULE_TYPE_C2C1X:
	case MLXSW_REG_PMTM_MODULE_TYPE_BP_1X:
2862
	case MLXSW_REG_PMTM_MODULE_TYPE_SFP:
2863 2864 2865 2866 2867 2868 2869
		return 1;
	default:
		return -EINVAL;
	}
}
EXPORT_SYMBOL(mlxsw_core_module_max_width);

2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
static void mlxsw_core_buf_dump_dbg(struct mlxsw_core *mlxsw_core,
				    const char *buf, size_t size)
{
	__be32 *m = (__be32 *) buf;
	int i;
	int count = size / sizeof(__be32);

	for (i = count - 1; i >= 0; i--)
		if (m[i])
			break;
	i++;
	count = i ? i : 1;
	for (i = 0; i < count; i += 4)
		dev_dbg(mlxsw_core->bus_info->dev, "%04x - %08x %08x %08x %08x\n",
			i * 4, be32_to_cpu(m[i]), be32_to_cpu(m[i + 1]),
			be32_to_cpu(m[i + 2]), be32_to_cpu(m[i + 3]));
}

2888
int mlxsw_cmd_exec(struct mlxsw_core *mlxsw_core, u16 opcode, u8 opcode_mod,
2889
		   u32 in_mod, bool out_mbox_direct, bool reset_ok,
2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
		   char *in_mbox, size_t in_mbox_size,
		   char *out_mbox, size_t out_mbox_size)
{
	u8 status;
	int err;

	BUG_ON(in_mbox_size % sizeof(u32) || out_mbox_size % sizeof(u32));
	if (!mlxsw_core->bus->cmd_exec)
		return -EOPNOTSUPP;

	dev_dbg(mlxsw_core->bus_info->dev, "Cmd exec (opcode=%x(%s),opcode_mod=%x,in_mod=%x)\n",
		opcode, mlxsw_cmd_opcode_str(opcode), opcode_mod, in_mod);
	if (in_mbox) {
		dev_dbg(mlxsw_core->bus_info->dev, "Input mailbox:\n");
		mlxsw_core_buf_dump_dbg(mlxsw_core, in_mbox, in_mbox_size);
	}

	err = mlxsw_core->bus->cmd_exec(mlxsw_core->bus_priv, opcode,
					opcode_mod, in_mod, out_mbox_direct,
					in_mbox, in_mbox_size,
					out_mbox, out_mbox_size, &status);

2912 2913 2914 2915 2916 2917 2918 2919 2920
	if (!err && out_mbox) {
		dev_dbg(mlxsw_core->bus_info->dev, "Output mailbox:\n");
		mlxsw_core_buf_dump_dbg(mlxsw_core, out_mbox, out_mbox_size);
	}

	if (reset_ok && err == -EIO &&
	    status == MLXSW_CMD_STATUS_RUNNING_RESET) {
		err = 0;
	} else if (err == -EIO && status != MLXSW_CMD_STATUS_OK) {
2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
		dev_err(mlxsw_core->bus_info->dev, "Cmd exec failed (opcode=%x(%s),opcode_mod=%x,in_mod=%x,status=%x(%s))\n",
			opcode, mlxsw_cmd_opcode_str(opcode), opcode_mod,
			in_mod, status, mlxsw_cmd_status_str(status));
	} else if (err == -ETIMEDOUT) {
		dev_err(mlxsw_core->bus_info->dev, "Cmd exec timed-out (opcode=%x(%s),opcode_mod=%x,in_mod=%x)\n",
			opcode, mlxsw_cmd_opcode_str(opcode), opcode_mod,
			in_mod);
	}

	return err;
}
EXPORT_SYMBOL(mlxsw_cmd_exec);

2934 2935 2936 2937 2938 2939
int mlxsw_core_schedule_dw(struct delayed_work *dwork, unsigned long delay)
{
	return queue_delayed_work(mlxsw_wq, dwork, delay);
}
EXPORT_SYMBOL(mlxsw_core_schedule_dw);

2940
bool mlxsw_core_schedule_work(struct work_struct *work)
2941
{
2942
	return queue_work(mlxsw_owq, work);
2943
}
2944
EXPORT_SYMBOL(mlxsw_core_schedule_work);
2945 2946 2947 2948 2949 2950 2951

void mlxsw_core_flush_owq(void)
{
	flush_workqueue(mlxsw_owq);
}
EXPORT_SYMBOL(mlxsw_core_flush_owq);

2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
int mlxsw_core_kvd_sizes_get(struct mlxsw_core *mlxsw_core,
			     const struct mlxsw_config_profile *profile,
			     u64 *p_single_size, u64 *p_double_size,
			     u64 *p_linear_size)
{
	struct mlxsw_driver *driver = mlxsw_core->driver;

	if (!driver->kvd_sizes_get)
		return -EINVAL;

	return driver->kvd_sizes_get(mlxsw_core, profile,
				     p_single_size, p_double_size,
				     p_linear_size);
}
EXPORT_SYMBOL(mlxsw_core_kvd_sizes_get);

2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004
int mlxsw_core_resources_query(struct mlxsw_core *mlxsw_core, char *mbox,
			       struct mlxsw_res *res)
{
	int index, i;
	u64 data;
	u16 id;
	int err;

	if (!res)
		return 0;

	mlxsw_cmd_mbox_zero(mbox);

	for (index = 0; index < MLXSW_CMD_QUERY_RESOURCES_MAX_QUERIES;
	     index++) {
		err = mlxsw_cmd_query_resources(mlxsw_core, mbox, index);
		if (err)
			return err;

		for (i = 0; i < MLXSW_CMD_QUERY_RESOURCES_PER_QUERY; i++) {
			id = mlxsw_cmd_mbox_query_resource_id_get(mbox, i);
			data = mlxsw_cmd_mbox_query_resource_data_get(mbox, i);

			if (id == MLXSW_CMD_QUERY_RESOURCES_TABLE_END_ID)
				return 0;

			mlxsw_res_parse(res, id, data);
		}
	}

	/* If after MLXSW_RESOURCES_QUERY_MAX_QUERIES we still didn't get
	 * MLXSW_RESOURCES_TABLE_END_ID, something went bad in the FW.
	 */
	return -EIO;
}
EXPORT_SYMBOL(mlxsw_core_resources_query);

3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016
u32 mlxsw_core_read_frc_h(struct mlxsw_core *mlxsw_core)
{
	return mlxsw_core->bus->read_frc_h(mlxsw_core->bus_priv);
}
EXPORT_SYMBOL(mlxsw_core_read_frc_h);

u32 mlxsw_core_read_frc_l(struct mlxsw_core *mlxsw_core)
{
	return mlxsw_core->bus->read_frc_l(mlxsw_core->bus_priv);
}
EXPORT_SYMBOL(mlxsw_core_read_frc_l);

3017 3018 3019 3020 3021 3022
void mlxsw_core_emad_string_tlv_enable(struct mlxsw_core *mlxsw_core)
{
	mlxsw_core->emad.enable_string_tlv = true;
}
EXPORT_SYMBOL(mlxsw_core_emad_string_tlv_enable);

3023 3024
static int __init mlxsw_core_module_init(void)
{
3025 3026
	int err;

3027
	mlxsw_wq = alloc_workqueue(mlxsw_core_driver_name, 0, 0);
3028
	if (!mlxsw_wq)
3029
		return -ENOMEM;
3030
	mlxsw_owq = alloc_ordered_workqueue("%s_ordered", 0,
3031 3032 3033 3034 3035
					    mlxsw_core_driver_name);
	if (!mlxsw_owq) {
		err = -ENOMEM;
		goto err_alloc_ordered_workqueue;
	}
3036
	return 0;
3037

3038
err_alloc_ordered_workqueue:
3039 3040
	destroy_workqueue(mlxsw_wq);
	return err;
3041 3042 3043 3044
}

static void __exit mlxsw_core_module_exit(void)
{
3045
	destroy_workqueue(mlxsw_owq);
3046
	destroy_workqueue(mlxsw_wq);
3047 3048 3049 3050 3051 3052 3053 3054
}

module_init(mlxsw_core_module_init);
module_exit(mlxsw_core_module_exit);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
MODULE_DESCRIPTION("Mellanox switch device core driver");