1// SPDX-License-Identifier: GPL-2.0
   2/* Copyright (c) 2022, Intel Corporation. */
   3
   4#include "ice_common.h"
   5#include "ice.h"
   6#include "ice_ddp.h"
   7#include "ice_sched.h"
   8
   9/* For supporting double VLAN mode, it is necessary to enable or disable certain
  10 * boost tcam entries. The metadata labels names that match the following
  11 * prefixes will be saved to allow enabling double VLAN mode.
  12 */
  13#define ICE_DVM_PRE "BOOST_MAC_VLAN_DVM" /* enable these entries */
  14#define ICE_SVM_PRE "BOOST_MAC_VLAN_SVM" /* disable these entries */
  15
  16/* To support tunneling entries by PF, the package will append the PF number to
  17 * the label; for example TNL_VXLAN_PF0, TNL_VXLAN_PF1, TNL_VXLAN_PF2, etc.
  18 */
  19#define ICE_TNL_PRE "TNL_"
  20static const struct ice_tunnel_type_scan tnls[] = {
  21	{ TNL_VXLAN, "TNL_VXLAN_PF" },
  22	{ TNL_GENEVE, "TNL_GENEVE_PF" },
  23	{ TNL_LAST, "" }
  24};
  25
  26/**
  27 * ice_verify_pkg - verify package
  28 * @pkg: pointer to the package buffer
  29 * @len: size of the package buffer
  30 *
  31 * Verifies various attributes of the package file, including length, format
  32 * version, and the requirement of at least one segment.
  33 */
  34static enum ice_ddp_state ice_verify_pkg(const struct ice_pkg_hdr *pkg, u32 len)
  35{
  36	u32 seg_count;
  37	u32 i;
  38
  39	if (len < struct_size(pkg, seg_offset, 1))
  40		return ICE_DDP_PKG_INVALID_FILE;
  41
  42	if (pkg->pkg_format_ver.major != ICE_PKG_FMT_VER_MAJ ||
  43	    pkg->pkg_format_ver.minor != ICE_PKG_FMT_VER_MNR ||
  44	    pkg->pkg_format_ver.update != ICE_PKG_FMT_VER_UPD ||
  45	    pkg->pkg_format_ver.draft != ICE_PKG_FMT_VER_DFT)
  46		return ICE_DDP_PKG_INVALID_FILE;
  47
  48	/* pkg must have at least one segment */
  49	seg_count = le32_to_cpu(pkg->seg_count);
  50	if (seg_count < 1)
  51		return ICE_DDP_PKG_INVALID_FILE;
  52
  53	/* make sure segment array fits in package length */
  54	if (len < struct_size(pkg, seg_offset, seg_count))
  55		return ICE_DDP_PKG_INVALID_FILE;
  56
  57	/* all segments must fit within length */
  58	for (i = 0; i < seg_count; i++) {
  59		u32 off = le32_to_cpu(pkg->seg_offset[i]);
  60		const struct ice_generic_seg_hdr *seg;
  61
  62		/* segment header must fit */
  63		if (len < off + sizeof(*seg))
  64			return ICE_DDP_PKG_INVALID_FILE;
  65
  66		seg = (void *)pkg + off;
  67
  68		/* segment body must fit */
  69		if (len < off + le32_to_cpu(seg->seg_size))
  70			return ICE_DDP_PKG_INVALID_FILE;
  71	}
  72
  73	return ICE_DDP_PKG_SUCCESS;
  74}
  75
  76/**
  77 * ice_free_seg - free package segment pointer
  78 * @hw: pointer to the hardware structure
  79 *
  80 * Frees the package segment pointer in the proper manner, depending on if the
  81 * segment was allocated or just the passed in pointer was stored.
  82 */
  83void ice_free_seg(struct ice_hw *hw)
  84{
  85	if (hw->pkg_copy) {
  86		devm_kfree(ice_hw_to_dev(hw), hw->pkg_copy);
  87		hw->pkg_copy = NULL;
  88		hw->pkg_size = 0;
  89	}
  90	hw->seg = NULL;
  91}
  92
  93/**
  94 * ice_chk_pkg_version - check package version for compatibility with driver
  95 * @pkg_ver: pointer to a version structure to check
  96 *
  97 * Check to make sure that the package about to be downloaded is compatible with
  98 * the driver. To be compatible, the major and minor components of the package
  99 * version must match our ICE_PKG_SUPP_VER_MAJ and ICE_PKG_SUPP_VER_MNR
 100 * definitions.
 101 */
 102static enum ice_ddp_state ice_chk_pkg_version(struct ice_pkg_ver *pkg_ver)
 103{
 104	if (pkg_ver->major > ICE_PKG_SUPP_VER_MAJ ||
 105	    (pkg_ver->major == ICE_PKG_SUPP_VER_MAJ &&
 106	     pkg_ver->minor > ICE_PKG_SUPP_VER_MNR))
 107		return ICE_DDP_PKG_FILE_VERSION_TOO_HIGH;
 108	else if (pkg_ver->major < ICE_PKG_SUPP_VER_MAJ ||
 109		 (pkg_ver->major == ICE_PKG_SUPP_VER_MAJ &&
 110		  pkg_ver->minor < ICE_PKG_SUPP_VER_MNR))
 111		return ICE_DDP_PKG_FILE_VERSION_TOO_LOW;
 112
 113	return ICE_DDP_PKG_SUCCESS;
 114}
 115
 116/**
 117 * ice_pkg_val_buf
 118 * @buf: pointer to the ice buffer
 119 *
 120 * This helper function validates a buffer's header.
 121 */
 122static const struct ice_buf_hdr *ice_pkg_val_buf(const struct ice_buf *buf)
 123{
 124	const struct ice_buf_hdr *hdr;
 125	u16 section_count;
 126	u16 data_end;
 127
 128	hdr = (const struct ice_buf_hdr *)buf->buf;
 129	/* verify data */
 130	section_count = le16_to_cpu(hdr->section_count);
 131	if (section_count < ICE_MIN_S_COUNT || section_count > ICE_MAX_S_COUNT)
 132		return NULL;
 133
 134	data_end = le16_to_cpu(hdr->data_end);
 135	if (data_end < ICE_MIN_S_DATA_END || data_end > ICE_MAX_S_DATA_END)
 136		return NULL;
 137
 138	return hdr;
 139}
 140
 141/**
 142 * ice_find_buf_table
 143 * @ice_seg: pointer to the ice segment
 144 *
 145 * Returns the address of the buffer table within the ice segment.
 146 */
 147static struct ice_buf_table *ice_find_buf_table(struct ice_seg *ice_seg)
 148{
 149	struct ice_nvm_table *nvms = (struct ice_nvm_table *)
 150		(ice_seg->device_table + le32_to_cpu(ice_seg->device_table_count));
 151
 152	return (__force struct ice_buf_table *)(nvms->vers +
 153						le32_to_cpu(nvms->table_count));
 154}
 155
 156/**
 157 * ice_pkg_enum_buf
 158 * @ice_seg: pointer to the ice segment (or NULL on subsequent calls)
 159 * @state: pointer to the enum state
 160 *
 161 * This function will enumerate all the buffers in the ice segment. The first
 162 * call is made with the ice_seg parameter non-NULL; on subsequent calls,
 163 * ice_seg is set to NULL which continues the enumeration. When the function
 164 * returns a NULL pointer, then the end of the buffers has been reached, or an
 165 * unexpected value has been detected (for example an invalid section count or
 166 * an invalid buffer end value).
 167 */
 168static const struct ice_buf_hdr *ice_pkg_enum_buf(struct ice_seg *ice_seg,
 169						  struct ice_pkg_enum *state)
 170{
 171	if (ice_seg) {
 172		state->buf_table = ice_find_buf_table(ice_seg);
 173		if (!state->buf_table)
 174			return NULL;
 175
 176		state->buf_idx = 0;
 177		return ice_pkg_val_buf(state->buf_table->buf_array);
 178	}
 179
 180	if (++state->buf_idx < le32_to_cpu(state->buf_table->buf_count))
 181		return ice_pkg_val_buf(state->buf_table->buf_array +
 182				       state->buf_idx);
 183	else
 184		return NULL;
 185}
 186
 187/**
 188 * ice_pkg_advance_sect
 189 * @ice_seg: pointer to the ice segment (or NULL on subsequent calls)
 190 * @state: pointer to the enum state
 191 *
 192 * This helper function will advance the section within the ice segment,
 193 * also advancing the buffer if needed.
 194 */
 195static bool ice_pkg_advance_sect(struct ice_seg *ice_seg,
 196				 struct ice_pkg_enum *state)
 197{
 198	if (!ice_seg && !state->buf)
 199		return false;
 200
 201	if (!ice_seg && state->buf)
 202		if (++state->sect_idx < le16_to_cpu(state->buf->section_count))
 203			return true;
 204
 205	state->buf = ice_pkg_enum_buf(ice_seg, state);
 206	if (!state->buf)
 207		return false;
 208
 209	/* start of new buffer, reset section index */
 210	state->sect_idx = 0;
 211	return true;
 212}
 213
 214/**
 215 * ice_pkg_enum_section
 216 * @ice_seg: pointer to the ice segment (or NULL on subsequent calls)
 217 * @state: pointer to the enum state
 218 * @sect_type: section type to enumerate
 219 *
 220 * This function will enumerate all the sections of a particular type in the
 221 * ice segment. The first call is made with the ice_seg parameter non-NULL;
 222 * on subsequent calls, ice_seg is set to NULL which continues the enumeration.
 223 * When the function returns a NULL pointer, then the end of the matching
 224 * sections has been reached.
 225 */
 226void *ice_pkg_enum_section(struct ice_seg *ice_seg, struct ice_pkg_enum *state,
 227			   u32 sect_type)
 228{
 229	u16 offset, size;
 230
 231	if (ice_seg)
 232		state->type = sect_type;
 233
 234	if (!ice_pkg_advance_sect(ice_seg, state))
 235		return NULL;
 236
 237	/* scan for next matching section */
 238	while (state->buf->section_entry[state->sect_idx].type !=
 239	       cpu_to_le32(state->type))
 240		if (!ice_pkg_advance_sect(NULL, state))
 241			return NULL;
 242
 243	/* validate section */
 244	offset = le16_to_cpu(state->buf->section_entry[state->sect_idx].offset);
 245	if (offset < ICE_MIN_S_OFF || offset > ICE_MAX_S_OFF)
 246		return NULL;
 247
 248	size = le16_to_cpu(state->buf->section_entry[state->sect_idx].size);
 249	if (size < ICE_MIN_S_SZ || size > ICE_MAX_S_SZ)
 250		return NULL;
 251
 252	/* make sure the section fits in the buffer */
 253	if (offset + size > ICE_PKG_BUF_SIZE)
 254		return NULL;
 255
 256	state->sect_type =
 257		le32_to_cpu(state->buf->section_entry[state->sect_idx].type);
 258
 259	/* calc pointer to this section */
 260	state->sect =
 261		((u8 *)state->buf) +
 262		le16_to_cpu(state->buf->section_entry[state->sect_idx].offset);
 263
 264	return state->sect;
 265}
 266
 267/**
 268 * ice_pkg_enum_entry
 269 * @ice_seg: pointer to the ice segment (or NULL on subsequent calls)
 270 * @state: pointer to the enum state
 271 * @sect_type: section type to enumerate
 272 * @offset: pointer to variable that receives the offset in the table (optional)
 273 * @handler: function that handles access to the entries into the section type
 274 *
 275 * This function will enumerate all the entries in particular section type in
 276 * the ice segment. The first call is made with the ice_seg parameter non-NULL;
 277 * on subsequent calls, ice_seg is set to NULL which continues the enumeration.
 278 * When the function returns a NULL pointer, then the end of the entries has
 279 * been reached.
 280 *
 281 * Since each section may have a different header and entry size, the handler
 282 * function is needed to determine the number and location entries in each
 283 * section.
 284 *
 285 * The offset parameter is optional, but should be used for sections that
 286 * contain an offset for each section table. For such cases, the section handler
 287 * function must return the appropriate offset + index to give the absolution
 288 * offset for each entry. For example, if the base for a section's header
 289 * indicates a base offset of 10, and the index for the entry is 2, then
 290 * section handler function should set the offset to 10 + 2 = 12.
 291 */
 292void *ice_pkg_enum_entry(struct ice_seg *ice_seg,
 293			 struct ice_pkg_enum *state, u32 sect_type,
 294			 u32 *offset,
 295			 void *(*handler)(u32 sect_type, void *section,
 296					  u32 index, u32 *offset))
 297{
 298	void *entry;
 299
 300	if (ice_seg) {
 301		if (!handler)
 302			return NULL;
 303
 304		if (!ice_pkg_enum_section(ice_seg, state, sect_type))
 305			return NULL;
 306
 307		state->entry_idx = 0;
 308		state->handler = handler;
 309	} else {
 310		state->entry_idx++;
 311	}
 312
 313	if (!state->handler)
 314		return NULL;
 315
 316	/* get entry */
 317	entry = state->handler(state->sect_type, state->sect, state->entry_idx,
 318			       offset);
 319	if (!entry) {
 320		/* end of a section, look for another section of this type */
 321		if (!ice_pkg_enum_section(NULL, state, 0))
 322			return NULL;
 323
 324		state->entry_idx = 0;
 325		entry = state->handler(state->sect_type, state->sect,
 326				       state->entry_idx, offset);
 327	}
 328
 329	return entry;
 330}
 331
 332/**
 333 * ice_sw_fv_handler
 334 * @sect_type: section type
 335 * @section: pointer to section
 336 * @index: index of the field vector entry to be returned
 337 * @offset: ptr to variable that receives the offset in the field vector table
 338 *
 339 * This is a callback function that can be passed to ice_pkg_enum_entry.
 340 * This function treats the given section as of type ice_sw_fv_section and
 341 * enumerates offset field. "offset" is an index into the field vector table.
 342 */
 343static void *ice_sw_fv_handler(u32 sect_type, void *section, u32 index,
 344			       u32 *offset)
 345{
 346	struct ice_sw_fv_section *fv_section = section;
 347
 348	if (!section || sect_type != ICE_SID_FLD_VEC_SW)
 349		return NULL;
 350	if (index >= le16_to_cpu(fv_section->count))
 351		return NULL;
 352	if (offset)
 353		/* "index" passed in to this function is relative to a given
 354		 * 4k block. To get to the true index into the field vector
 355		 * table need to add the relative index to the base_offset
 356		 * field of this section
 357		 */
 358		*offset = le16_to_cpu(fv_section->base_offset) + index;
 359	return fv_section->fv + index;
 360}
 361
 362/**
 363 * ice_get_prof_index_max - get the max profile index for used profile
 364 * @hw: pointer to the HW struct
 365 *
 366 * Calling this function will get the max profile index for used profile
 367 * and store the index number in struct ice_switch_info *switch_info
 368 * in HW for following use.
 369 */
 370static int ice_get_prof_index_max(struct ice_hw *hw)
 371{
 372	u16 prof_index = 0, j, max_prof_index = 0;
 373	struct ice_pkg_enum state;
 374	struct ice_seg *ice_seg;
 375	bool flag = false;
 376	struct ice_fv *fv;
 377	u32 offset;
 378
 379	memset(&state, 0, sizeof(state));
 380
 381	if (!hw->seg)
 382		return -EINVAL;
 383
 384	ice_seg = hw->seg;
 385
 386	do {
 387		fv = ice_pkg_enum_entry(ice_seg, &state, ICE_SID_FLD_VEC_SW,
 388					&offset, ice_sw_fv_handler);
 389		if (!fv)
 390			break;
 391		ice_seg = NULL;
 392
 393		/* in the profile that not be used, the prot_id is set to 0xff
 394		 * and the off is set to 0x1ff for all the field vectors.
 395		 */
 396		for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++)
 397			if (fv->ew[j].prot_id != ICE_PROT_INVALID ||
 398			    fv->ew[j].off != ICE_FV_OFFSET_INVAL)
 399				flag = true;
 400		if (flag && prof_index > max_prof_index)
 401			max_prof_index = prof_index;
 402
 403		prof_index++;
 404		flag = false;
 405	} while (fv);
 406
 407	hw->switch_info->max_used_prof_index = max_prof_index;
 408
 409	return 0;
 410}
 411
 412/**
 413 * ice_get_ddp_pkg_state - get DDP pkg state after download
 414 * @hw: pointer to the HW struct
 415 * @already_loaded: indicates if pkg was already loaded onto the device
 416 */
 417static enum ice_ddp_state ice_get_ddp_pkg_state(struct ice_hw *hw,
 418						bool already_loaded)
 419{
 420	if (hw->pkg_ver.major == hw->active_pkg_ver.major &&
 421	    hw->pkg_ver.minor == hw->active_pkg_ver.minor &&
 422	    hw->pkg_ver.update == hw->active_pkg_ver.update &&
 423	    hw->pkg_ver.draft == hw->active_pkg_ver.draft &&
 424	    !memcmp(hw->pkg_name, hw->active_pkg_name, sizeof(hw->pkg_name))) {
 425		if (already_loaded)
 426			return ICE_DDP_PKG_SAME_VERSION_ALREADY_LOADED;
 427		else
 428			return ICE_DDP_PKG_SUCCESS;
 429	} else if (hw->active_pkg_ver.major != ICE_PKG_SUPP_VER_MAJ ||
 430		   hw->active_pkg_ver.minor != ICE_PKG_SUPP_VER_MNR) {
 431		return ICE_DDP_PKG_ALREADY_LOADED_NOT_SUPPORTED;
 432	} else if (hw->active_pkg_ver.major == ICE_PKG_SUPP_VER_MAJ &&
 433		   hw->active_pkg_ver.minor == ICE_PKG_SUPP_VER_MNR) {
 434		return ICE_DDP_PKG_COMPATIBLE_ALREADY_LOADED;
 435	} else {
 436		return ICE_DDP_PKG_ERR;
 437	}
 438}
 439
 440/**
 441 * ice_init_pkg_regs - initialize additional package registers
 442 * @hw: pointer to the hardware structure
 443 */
 444static void ice_init_pkg_regs(struct ice_hw *hw)
 445{
 446#define ICE_SW_BLK_INP_MASK_L 0xFFFFFFFF
 447#define ICE_SW_BLK_INP_MASK_H 0x0000FFFF
 448#define ICE_SW_BLK_IDX 0
 449
 450	/* setup Switch block input mask, which is 48-bits in two parts */
 451	wr32(hw, GL_PREEXT_L2_PMASK0(ICE_SW_BLK_IDX), ICE_SW_BLK_INP_MASK_L);
 452	wr32(hw, GL_PREEXT_L2_PMASK1(ICE_SW_BLK_IDX), ICE_SW_BLK_INP_MASK_H);
 453}
 454
 455/**
 456 * ice_marker_ptype_tcam_handler
 457 * @sect_type: section type
 458 * @section: pointer to section
 459 * @index: index of the Marker PType TCAM entry to be returned
 460 * @offset: pointer to receive absolute offset, always 0 for ptype TCAM sections
 461 *
 462 * This is a callback function that can be passed to ice_pkg_enum_entry.
 463 * Handles enumeration of individual Marker PType TCAM entries.
 464 */
 465static void *ice_marker_ptype_tcam_handler(u32 sect_type, void *section,
 466					   u32 index, u32 *offset)
 467{
 468	struct ice_marker_ptype_tcam_section *marker_ptype;
 469
 470	if (sect_type != ICE_SID_RXPARSER_MARKER_PTYPE)
 471		return NULL;
 472
 473	if (index > ICE_MAX_MARKER_PTYPE_TCAMS_IN_BUF)
 474		return NULL;
 475
 476	if (offset)
 477		*offset = 0;
 478
 479	marker_ptype = section;
 480	if (index >= le16_to_cpu(marker_ptype->count))
 481		return NULL;
 482
 483	return marker_ptype->tcam + index;
 484}
 485
 486/**
 487 * ice_add_dvm_hint
 488 * @hw: pointer to the HW structure
 489 * @val: value of the boost entry
 490 * @enable: true if entry needs to be enabled, or false if needs to be disabled
 491 */
 492static void ice_add_dvm_hint(struct ice_hw *hw, u16 val, bool enable)
 493{
 494	if (hw->dvm_upd.count < ICE_DVM_MAX_ENTRIES) {
 495		hw->dvm_upd.tbl[hw->dvm_upd.count].boost_addr = val;
 496		hw->dvm_upd.tbl[hw->dvm_upd.count].enable = enable;
 497		hw->dvm_upd.count++;
 498	}
 499}
 500
 501/**
 502 * ice_add_tunnel_hint
 503 * @hw: pointer to the HW structure
 504 * @label_name: label text
 505 * @val: value of the tunnel port boost entry
 506 */
 507static void ice_add_tunnel_hint(struct ice_hw *hw, char *label_name, u16 val)
 508{
 509	if (hw->tnl.count < ICE_TUNNEL_MAX_ENTRIES) {
 510		u16 i;
 511
 512		for (i = 0; tnls[i].type != TNL_LAST; i++) {
 513			size_t len = strlen(tnls[i].label_prefix);
 514
 515			/* Look for matching label start, before continuing */
 516			if (strncmp(label_name, tnls[i].label_prefix, len))
 517				continue;
 518
 519			/* Make sure this label matches our PF. Note that the PF
 520			 * character ('0' - '7') will be located where our
 521			 * prefix string's null terminator is located.
 522			 */
 523			if ((label_name[len] - '0') == hw->pf_id) {
 524				hw->tnl.tbl[hw->tnl.count].type = tnls[i].type;
 525				hw->tnl.tbl[hw->tnl.count].valid = false;
 526				hw->tnl.tbl[hw->tnl.count].boost_addr = val;
 527				hw->tnl.tbl[hw->tnl.count].port = 0;
 528				hw->tnl.count++;
 529				break;
 530			}
 531		}
 532	}
 533}
 534
 535/**
 536 * ice_label_enum_handler
 537 * @sect_type: section type
 538 * @section: pointer to section
 539 * @index: index of the label entry to be returned
 540 * @offset: pointer to receive absolute offset, always zero for label sections
 541 *
 542 * This is a callback function that can be passed to ice_pkg_enum_entry.
 543 * Handles enumeration of individual label entries.
 544 */
 545static void *ice_label_enum_handler(u32 __always_unused sect_type,
 546				    void *section, u32 index, u32 *offset)
 547{
 548	struct ice_label_section *labels;
 549
 550	if (!section)
 551		return NULL;
 552
 553	if (index > ICE_MAX_LABELS_IN_BUF)
 554		return NULL;
 555
 556	if (offset)
 557		*offset = 0;
 558
 559	labels = section;
 560	if (index >= le16_to_cpu(labels->count))
 561		return NULL;
 562
 563	return labels->label + index;
 564}
 565
 566/**
 567 * ice_enum_labels
 568 * @ice_seg: pointer to the ice segment (NULL on subsequent calls)
 569 * @type: the section type that will contain the label (0 on subsequent calls)
 570 * @state: ice_pkg_enum structure that will hold the state of the enumeration
 571 * @value: pointer to a value that will return the label's value if found
 572 *
 573 * Enumerates a list of labels in the package. The caller will call
 574 * ice_enum_labels(ice_seg, type, ...) to start the enumeration, then call
 575 * ice_enum_labels(NULL, 0, ...) to continue. When the function returns a NULL
 576 * the end of the list has been reached.
 577 */
 578static char *ice_enum_labels(struct ice_seg *ice_seg, u32 type,
 579			     struct ice_pkg_enum *state, u16 *value)
 580{
 581	struct ice_label *label;
 582
 583	/* Check for valid label section on first call */
 584	if (type && !(type >= ICE_SID_LBL_FIRST && type <= ICE_SID_LBL_LAST))
 585		return NULL;
 586
 587	label = ice_pkg_enum_entry(ice_seg, state, type, NULL,
 588				   ice_label_enum_handler);
 589	if (!label)
 590		return NULL;
 591
 592	*value = le16_to_cpu(label->value);
 593	return label->name;
 594}
 595
 596/**
 597 * ice_boost_tcam_handler
 598 * @sect_type: section type
 599 * @section: pointer to section
 600 * @index: index of the boost TCAM entry to be returned
 601 * @offset: pointer to receive absolute offset, always 0 for boost TCAM sections
 602 *
 603 * This is a callback function that can be passed to ice_pkg_enum_entry.
 604 * Handles enumeration of individual boost TCAM entries.
 605 */
 606static void *ice_boost_tcam_handler(u32 sect_type, void *section, u32 index,
 607				    u32 *offset)
 608{
 609	struct ice_boost_tcam_section *boost;
 610
 611	if (!section)
 612		return NULL;
 613
 614	if (sect_type != ICE_SID_RXPARSER_BOOST_TCAM)
 615		return NULL;
 616
 617	if (index > ICE_MAX_BST_TCAMS_IN_BUF)
 618		return NULL;
 619
 620	if (offset)
 621		*offset = 0;
 622
 623	boost = section;
 624	if (index >= le16_to_cpu(boost->count))
 625		return NULL;
 626
 627	return boost->tcam + index;
 628}
 629
 630/**
 631 * ice_find_boost_entry
 632 * @ice_seg: pointer to the ice segment (non-NULL)
 633 * @addr: Boost TCAM address of entry to search for
 634 * @entry: returns pointer to the entry
 635 *
 636 * Finds a particular Boost TCAM entry and returns a pointer to that entry
 637 * if it is found. The ice_seg parameter must not be NULL since the first call
 638 * to ice_pkg_enum_entry requires a pointer to an actual ice_segment structure.
 639 */
 640static int ice_find_boost_entry(struct ice_seg *ice_seg, u16 addr,
 641				struct ice_boost_tcam_entry **entry)
 642{
 643	struct ice_boost_tcam_entry *tcam;
 644	struct ice_pkg_enum state;
 645
 646	memset(&state, 0, sizeof(state));
 647
 648	if (!ice_seg)
 649		return -EINVAL;
 650
 651	do {
 652		tcam = ice_pkg_enum_entry(ice_seg, &state,
 653					  ICE_SID_RXPARSER_BOOST_TCAM, NULL,
 654					  ice_boost_tcam_handler);
 655		if (tcam && le16_to_cpu(tcam->addr) == addr) {
 656			*entry = tcam;
 657			return 0;
 658		}
 659
 660		ice_seg = NULL;
 661	} while (tcam);
 662
 663	*entry = NULL;
 664	return -EIO;
 665}
 666
 667/**
 668 * ice_is_init_pkg_successful - check if DDP init was successful
 669 * @state: state of the DDP pkg after download
 670 */
 671bool ice_is_init_pkg_successful(enum ice_ddp_state state)
 672{
 673	switch (state) {
 674	case ICE_DDP_PKG_SUCCESS:
 675	case ICE_DDP_PKG_SAME_VERSION_ALREADY_LOADED:
 676	case ICE_DDP_PKG_COMPATIBLE_ALREADY_LOADED:
 677		return true;
 678	default:
 679		return false;
 680	}
 681}
 682
 683/**
 684 * ice_pkg_buf_alloc
 685 * @hw: pointer to the HW structure
 686 *
 687 * Allocates a package buffer and returns a pointer to the buffer header.
 688 * Note: all package contents must be in Little Endian form.
 689 */
 690struct ice_buf_build *ice_pkg_buf_alloc(struct ice_hw *hw)
 691{
 692	struct ice_buf_build *bld;
 693	struct ice_buf_hdr *buf;
 694
 695	bld = devm_kzalloc(ice_hw_to_dev(hw), sizeof(*bld), GFP_KERNEL);
 696	if (!bld)
 697		return NULL;
 698
 699	buf = (struct ice_buf_hdr *)bld;
 700	buf->data_end =
 701		cpu_to_le16(offsetof(struct ice_buf_hdr, section_entry));
 702	return bld;
 703}
 704
 705static bool ice_is_gtp_u_profile(u16 prof_idx)
 706{
 707	return (prof_idx >= ICE_PROFID_IPV6_GTPU_TEID &&
 708		prof_idx <= ICE_PROFID_IPV6_GTPU_IPV6_TCP_INNER) ||
 709	       prof_idx == ICE_PROFID_IPV4_GTPU_TEID;
 710}
 711
 712static bool ice_is_gtp_c_profile(u16 prof_idx)
 713{
 714	switch (prof_idx) {
 715	case ICE_PROFID_IPV4_GTPC_TEID:
 716	case ICE_PROFID_IPV4_GTPC_NO_TEID:
 717	case ICE_PROFID_IPV6_GTPC_TEID:
 718	case ICE_PROFID_IPV6_GTPC_NO_TEID:
 719		return true;
 720	default:
 721		return false;
 722	}
 723}
 724
 725static bool ice_is_pfcp_profile(u16 prof_idx)
 726{
 727	return prof_idx >= ICE_PROFID_IPV4_PFCP_NODE &&
 728	       prof_idx <= ICE_PROFID_IPV6_PFCP_SESSION;
 729}
 730
 731/**
 732 * ice_get_sw_prof_type - determine switch profile type
 733 * @hw: pointer to the HW structure
 734 * @fv: pointer to the switch field vector
 735 * @prof_idx: profile index to check
 736 */
 737static enum ice_prof_type ice_get_sw_prof_type(struct ice_hw *hw,
 738					       struct ice_fv *fv, u32 prof_idx)
 739{
 740	u16 i;
 741
 742	if (ice_is_gtp_c_profile(prof_idx))
 743		return ICE_PROF_TUN_GTPC;
 744
 745	if (ice_is_gtp_u_profile(prof_idx))
 746		return ICE_PROF_TUN_GTPU;
 747
 748	if (ice_is_pfcp_profile(prof_idx))
 749		return ICE_PROF_TUN_PFCP;
 750
 751	for (i = 0; i < hw->blk[ICE_BLK_SW].es.fvw; i++) {
 752		/* UDP tunnel will have UDP_OF protocol ID and VNI offset */
 753		if (fv->ew[i].prot_id == (u8)ICE_PROT_UDP_OF &&
 754		    fv->ew[i].off == ICE_VNI_OFFSET)
 755			return ICE_PROF_TUN_UDP;
 756
 757		/* GRE tunnel will have GRE protocol */
 758		if (fv->ew[i].prot_id == (u8)ICE_PROT_GRE_OF)
 759			return ICE_PROF_TUN_GRE;
 760	}
 761
 762	return ICE_PROF_NON_TUN;
 763}
 764
 765/**
 766 * ice_get_sw_fv_bitmap - Get switch field vector bitmap based on profile type
 767 * @hw: pointer to hardware structure
 768 * @req_profs: type of profiles requested
 769 * @bm: pointer to memory for returning the bitmap of field vectors
 770 */
 771void ice_get_sw_fv_bitmap(struct ice_hw *hw, enum ice_prof_type req_profs,
 772			  unsigned long *bm)
 773{
 774	struct ice_pkg_enum state;
 775	struct ice_seg *ice_seg;
 776	struct ice_fv *fv;
 777
 778	if (req_profs == ICE_PROF_ALL) {
 779		bitmap_set(bm, 0, ICE_MAX_NUM_PROFILES);
 780		return;
 781	}
 782
 783	memset(&state, 0, sizeof(state));
 784	bitmap_zero(bm, ICE_MAX_NUM_PROFILES);
 785	ice_seg = hw->seg;
 786	do {
 787		enum ice_prof_type prof_type;
 788		u32 offset;
 789
 790		fv = ice_pkg_enum_entry(ice_seg, &state, ICE_SID_FLD_VEC_SW,
 791					&offset, ice_sw_fv_handler);
 792		ice_seg = NULL;
 793
 794		if (fv) {
 795			/* Determine field vector type */
 796			prof_type = ice_get_sw_prof_type(hw, fv, offset);
 797
 798			if (req_profs & prof_type)
 799				set_bit((u16)offset, bm);
 800		}
 801	} while (fv);
 802}
 803
 804/**
 805 * ice_get_sw_fv_list
 806 * @hw: pointer to the HW structure
 807 * @lkups: list of protocol types
 808 * @bm: bitmap of field vectors to consider
 809 * @fv_list: Head of a list
 810 *
 811 * Finds all the field vector entries from switch block that contain
 812 * a given protocol ID and offset and returns a list of structures of type
 813 * "ice_sw_fv_list_entry". Every structure in the list has a field vector
 814 * definition and profile ID information
 815 * NOTE: The caller of the function is responsible for freeing the memory
 816 * allocated for every list entry.
 817 */
 818int ice_get_sw_fv_list(struct ice_hw *hw, struct ice_prot_lkup_ext *lkups,
 819		       unsigned long *bm, struct list_head *fv_list)
 820{
 821	struct ice_sw_fv_list_entry *fvl;
 822	struct ice_sw_fv_list_entry *tmp;
 823	struct ice_pkg_enum state;
 824	struct ice_seg *ice_seg;
 825	struct ice_fv *fv;
 826	u32 offset;
 827
 828	memset(&state, 0, sizeof(state));
 829
 830	if (!lkups->n_val_words || !hw->seg)
 831		return -EINVAL;
 832
 833	ice_seg = hw->seg;
 834	do {
 835		u16 i;
 836
 837		fv = ice_pkg_enum_entry(ice_seg, &state, ICE_SID_FLD_VEC_SW,
 838					&offset, ice_sw_fv_handler);
 839		if (!fv)
 840			break;
 841		ice_seg = NULL;
 842
 843		/* If field vector is not in the bitmap list, then skip this
 844		 * profile.
 845		 */
 846		if (!test_bit((u16)offset, bm))
 847			continue;
 848
 849		for (i = 0; i < lkups->n_val_words; i++) {
 850			int j;
 851
 852			for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++)
 853				if (fv->ew[j].prot_id ==
 854					    lkups->fv_words[i].prot_id &&
 855				    fv->ew[j].off == lkups->fv_words[i].off)
 856					break;
 857			if (j >= hw->blk[ICE_BLK_SW].es.fvw)
 858				break;
 859			if (i + 1 == lkups->n_val_words) {
 860				fvl = devm_kzalloc(ice_hw_to_dev(hw),
 861						   sizeof(*fvl), GFP_KERNEL);
 862				if (!fvl)
 863					goto err;
 864				fvl->fv_ptr = fv;
 865				fvl->profile_id = offset;
 866				list_add(&fvl->list_entry, fv_list);
 867				break;
 868			}
 869		}
 870	} while (fv);
 871	if (list_empty(fv_list)) {
 872		dev_warn(ice_hw_to_dev(hw),
 873			 "Required profiles not found in currently loaded DDP package");
 874		return -EIO;
 875	}
 876
 877	return 0;
 878
 879err:
 880	list_for_each_entry_safe(fvl, tmp, fv_list, list_entry) {
 881		list_del(&fvl->list_entry);
 882		devm_kfree(ice_hw_to_dev(hw), fvl);
 883	}
 884
 885	return -ENOMEM;
 886}
 887
 888/**
 889 * ice_init_prof_result_bm - Initialize the profile result index bitmap
 890 * @hw: pointer to hardware structure
 891 */
 892void ice_init_prof_result_bm(struct ice_hw *hw)
 893{
 894	struct ice_pkg_enum state;
 895	struct ice_seg *ice_seg;
 896	struct ice_fv *fv;
 897
 898	memset(&state, 0, sizeof(state));
 899
 900	if (!hw->seg)
 901		return;
 902
 903	ice_seg = hw->seg;
 904	do {
 905		u32 off;
 906		u16 i;
 907
 908		fv = ice_pkg_enum_entry(ice_seg, &state, ICE_SID_FLD_VEC_SW,
 909					&off, ice_sw_fv_handler);
 910		ice_seg = NULL;
 911		if (!fv)
 912			break;
 913
 914		bitmap_zero(hw->switch_info->prof_res_bm[off],
 915			    ICE_MAX_FV_WORDS);
 916
 917		/* Determine empty field vector indices, these can be
 918		 * used for recipe results. Skip index 0, since it is
 919		 * always used for Switch ID.
 920		 */
 921		for (i = 1; i < ICE_MAX_FV_WORDS; i++)
 922			if (fv->ew[i].prot_id == ICE_PROT_INVALID &&
 923			    fv->ew[i].off == ICE_FV_OFFSET_INVAL)
 924				set_bit(i, hw->switch_info->prof_res_bm[off]);
 925	} while (fv);
 926}
 927
 928/**
 929 * ice_pkg_buf_free
 930 * @hw: pointer to the HW structure
 931 * @bld: pointer to pkg build (allocated by ice_pkg_buf_alloc())
 932 *
 933 * Frees a package buffer
 934 */
 935void ice_pkg_buf_free(struct ice_hw *hw, struct ice_buf_build *bld)
 936{
 937	devm_kfree(ice_hw_to_dev(hw), bld);
 938}
 939
 940/**
 941 * ice_pkg_buf_reserve_section
 942 * @bld: pointer to pkg build (allocated by ice_pkg_buf_alloc())
 943 * @count: the number of sections to reserve
 944 *
 945 * Reserves one or more section table entries in a package buffer. This routine
 946 * can be called multiple times as long as they are made before calling
 947 * ice_pkg_buf_alloc_section(). Once ice_pkg_buf_alloc_section()
 948 * is called once, the number of sections that can be allocated will not be able
 949 * to be increased; not using all reserved sections is fine, but this will
 950 * result in some wasted space in the buffer.
 951 * Note: all package contents must be in Little Endian form.
 952 */
 953int ice_pkg_buf_reserve_section(struct ice_buf_build *bld, u16 count)
 954{
 955	struct ice_buf_hdr *buf;
 956	u16 section_count;
 957	u16 data_end;
 958
 959	if (!bld)
 960		return -EINVAL;
 961
 962	buf = (struct ice_buf_hdr *)&bld->buf;
 963
 964	/* already an active section, can't increase table size */
 965	section_count = le16_to_cpu(buf->section_count);
 966	if (section_count > 0)
 967		return -EIO;
 968
 969	if (bld->reserved_section_table_entries + count > ICE_MAX_S_COUNT)
 970		return -EIO;
 971	bld->reserved_section_table_entries += count;
 972
 973	data_end = le16_to_cpu(buf->data_end) +
 974		   flex_array_size(buf, section_entry, count);
 975	buf->data_end = cpu_to_le16(data_end);
 976
 977	return 0;
 978}
 979
 980/**
 981 * ice_pkg_buf_alloc_section
 982 * @bld: pointer to pkg build (allocated by ice_pkg_buf_alloc())
 983 * @type: the section type value
 984 * @size: the size of the section to reserve (in bytes)
 985 *
 986 * Reserves memory in the buffer for a section's content and updates the
 987 * buffers' status accordingly. This routine returns a pointer to the first
 988 * byte of the section start within the buffer, which is used to fill in the
 989 * section contents.
 990 * Note: all package contents must be in Little Endian form.
 991 */
 992void *ice_pkg_buf_alloc_section(struct ice_buf_build *bld, u32 type, u16 size)
 993{
 994	struct ice_buf_hdr *buf;
 995	u16 sect_count;
 996	u16 data_end;
 997
 998	if (!bld || !type || !size)
 999		return NULL;
1000
1001	buf = (struct ice_buf_hdr *)&bld->buf;
1002
1003	/* check for enough space left in buffer */
1004	data_end = le16_to_cpu(buf->data_end);
1005
1006	/* section start must align on 4 byte boundary */
1007	data_end = ALIGN(data_end, 4);
1008
1009	if ((data_end + size) > ICE_MAX_S_DATA_END)
1010		return NULL;
1011
1012	/* check for more available section table entries */
1013	sect_count = le16_to_cpu(buf->section_count);
1014	if (sect_count < bld->reserved_section_table_entries) {
1015		void *section_ptr = ((u8 *)buf) + data_end;
1016
1017		buf->section_entry[sect_count].offset = cpu_to_le16(data_end);
1018		buf->section_entry[sect_count].size = cpu_to_le16(size);
1019		buf->section_entry[sect_count].type = cpu_to_le32(type);
1020
1021		data_end += size;
1022		buf->data_end = cpu_to_le16(data_end);
1023
1024		buf->section_count = cpu_to_le16(sect_count + 1);
1025		return section_ptr;
1026	}
1027
1028	/* no free section table entries */
1029	return NULL;
1030}
1031
1032/**
1033 * ice_pkg_buf_alloc_single_section
1034 * @hw: pointer to the HW structure
1035 * @type: the section type value
1036 * @size: the size of the section to reserve (in bytes)
1037 * @section: returns pointer to the section
1038 *
1039 * Allocates a package buffer with a single section.
1040 * Note: all package contents must be in Little Endian form.
1041 */
1042struct ice_buf_build *ice_pkg_buf_alloc_single_section(struct ice_hw *hw,
1043						       u32 type, u16 size,
1044						       void **section)
1045{
1046	struct ice_buf_build *buf;
1047
1048	if (!section)
1049		return NULL;
1050
1051	buf = ice_pkg_buf_alloc(hw);
1052	if (!buf)
1053		return NULL;
1054
1055	if (ice_pkg_buf_reserve_section(buf, 1))
1056		goto ice_pkg_buf_alloc_single_section_err;
1057
1058	*section = ice_pkg_buf_alloc_section(buf, type, size);
1059	if (!*section)
1060		goto ice_pkg_buf_alloc_single_section_err;
1061
1062	return buf;
1063
1064ice_pkg_buf_alloc_single_section_err:
1065	ice_pkg_buf_free(hw, buf);
1066	return NULL;
1067}
1068
1069/**
1070 * ice_pkg_buf_get_active_sections
1071 * @bld: pointer to pkg build (allocated by ice_pkg_buf_alloc())
1072 *
1073 * Returns the number of active sections. Before using the package buffer
1074 * in an update package command, the caller should make sure that there is at
1075 * least one active section - otherwise, the buffer is not legal and should
1076 * not be used.
1077 * Note: all package contents must be in Little Endian form.
1078 */
1079u16 ice_pkg_buf_get_active_sections(struct ice_buf_build *bld)
1080{
1081	struct ice_buf_hdr *buf;
1082
1083	if (!bld)
1084		return 0;
1085
1086	buf = (struct ice_buf_hdr *)&bld->buf;
1087	return le16_to_cpu(buf->section_count);
1088}
1089
1090/**
1091 * ice_pkg_buf
1092 * @bld: pointer to pkg build (allocated by ice_pkg_buf_alloc())
1093 *
1094 * Return a pointer to the buffer's header
1095 */
1096struct ice_buf *ice_pkg_buf(struct ice_buf_build *bld)
1097{
1098	if (!bld)
1099		return NULL;
1100
1101	return &bld->buf;
1102}
1103
1104static enum ice_ddp_state ice_map_aq_err_to_ddp_state(enum ice_aq_err aq_err)
1105{
1106	switch (aq_err) {
1107	case ICE_AQ_RC_ENOSEC:
1108	case ICE_AQ_RC_EBADSIG:
1109		return ICE_DDP_PKG_FILE_SIGNATURE_INVALID;
1110	case ICE_AQ_RC_ESVN:
1111		return ICE_DDP_PKG_FILE_REVISION_TOO_LOW;
1112	case ICE_AQ_RC_EBADMAN:
1113	case ICE_AQ_RC_EBADBUF:
1114		return ICE_DDP_PKG_LOAD_ERROR;
1115	default:
1116		return ICE_DDP_PKG_ERR;
1117	}
1118}
1119
1120/**
1121 * ice_acquire_global_cfg_lock
1122 * @hw: pointer to the HW structure
1123 * @access: access type (read or write)
1124 *
1125 * This function will request ownership of the global config lock for reading
1126 * or writing of the package. When attempting to obtain write access, the
1127 * caller must check for the following two return values:
1128 *
1129 * 0         -  Means the caller has acquired the global config lock
1130 *              and can perform writing of the package.
1131 * -EALREADY - Indicates another driver has already written the
1132 *             package or has found that no update was necessary; in
1133 *             this case, the caller can just skip performing any
1134 *             update of the package.
1135 */
1136static int ice_acquire_global_cfg_lock(struct ice_hw *hw,
1137				       enum ice_aq_res_access_type access)
1138{
1139	int status;
1140
1141	status = ice_acquire_res(hw, ICE_GLOBAL_CFG_LOCK_RES_ID, access,
1142				 ICE_GLOBAL_CFG_LOCK_TIMEOUT);
1143
1144	if (!status)
1145		mutex_lock(&ice_global_cfg_lock_sw);
1146	else if (status == -EALREADY)
1147		ice_debug(hw, ICE_DBG_PKG,
1148			  "Global config lock: No work to do\n");
1149
1150	return status;
1151}
1152
1153/**
1154 * ice_release_global_cfg_lock
1155 * @hw: pointer to the HW structure
1156 *
1157 * This function will release the global config lock.
1158 */
1159static void ice_release_global_cfg_lock(struct ice_hw *hw)
1160{
1161	mutex_unlock(&ice_global_cfg_lock_sw);
1162	ice_release_res(hw, ICE_GLOBAL_CFG_LOCK_RES_ID);
1163}
1164
1165/**
1166 * ice_aq_download_pkg
1167 * @hw: pointer to the hardware structure
1168 * @pkg_buf: the package buffer to transfer
1169 * @buf_size: the size of the package buffer
1170 * @last_buf: last buffer indicator
1171 * @error_offset: returns error offset
1172 * @error_info: returns error information
1173 * @cd: pointer to command details structure or NULL
1174 *
1175 * Download Package (0x0C40)
1176 */
1177static int
1178ice_aq_download_pkg(struct ice_hw *hw, struct ice_buf_hdr *pkg_buf,
1179		    u16 buf_size, bool last_buf, u32 *error_offset,
1180		    u32 *error_info, struct ice_sq_cd *cd)
1181{
1182	struct ice_aqc_download_pkg *cmd;
1183	struct ice_aq_desc desc;
1184	int status;
1185
1186	if (error_offset)
1187		*error_offset = 0;
1188	if (error_info)
1189		*error_info = 0;
1190
1191	cmd = &desc.params.download_pkg;
1192	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_download_pkg);
1193	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
1194
1195	if (last_buf)
1196		cmd->flags |= ICE_AQC_DOWNLOAD_PKG_LAST_BUF;
1197
1198	status = ice_aq_send_cmd(hw, &desc, pkg_buf, buf_size, cd);
1199	if (status == -EIO) {
1200		/* Read error from buffer only when the FW returned an error */
1201		struct ice_aqc_download_pkg_resp *resp;
1202
1203		resp = (struct ice_aqc_download_pkg_resp *)pkg_buf;
1204		if (error_offset)
1205			*error_offset = le32_to_cpu(resp->error_offset);
1206		if (error_info)
1207			*error_info = le32_to_cpu(resp->error_info);
1208	}
1209
1210	return status;
1211}
1212
1213/**
1214 * ice_is_buffer_metadata - determine if package buffer is a metadata buffer
1215 * @buf: pointer to buffer header
1216 * Return: whether given @buf is a metadata one.
1217 */
1218static bool ice_is_buffer_metadata(struct ice_buf_hdr *buf)
1219{
1220	return le32_to_cpu(buf->section_entry[0].type) & ICE_METADATA_BUF;
1221}
1222
1223/**
1224 * struct ice_ddp_send_ctx - sending context of current DDP segment
1225 * @hw: pointer to the hardware struct
1226 *
1227 * Keeps current sending state (header, error) for the purpose of proper "last"
1228 * bit setting in ice_aq_download_pkg(). Use via calls to ice_ddp_send_hunk().
1229 */
1230struct ice_ddp_send_ctx {
1231	struct ice_hw *hw;
1232/* private: only for ice_ddp_send_hunk() */
1233	struct ice_buf_hdr *hdr;
1234	int err;
1235};
1236
1237static void ice_ddp_send_ctx_set_err(struct ice_ddp_send_ctx *ctx, int err)
1238{
1239	ctx->err = err;
1240}
1241
1242/**
1243 * ice_ddp_send_hunk - send one hunk of data to FW
1244 * @ctx: current segment sending context
1245 * @hunk: next hunk to send, size is always ICE_PKG_BUF_SIZE
1246 *
1247 * Send the next hunk of data to FW, retrying if needed.
1248 *
1249 * Notice: must be called once more with a NULL @hunk to finish up; such call
1250 * will set up the "last" bit of an AQ request. After such call @ctx.hdr is
1251 * cleared, @hw is still valid.
1252 *
1253 * Return: %ICE_DDP_PKG_SUCCESS if there were no problems; a sticky @err
1254 *         otherwise.
1255 */
1256static enum ice_ddp_state ice_ddp_send_hunk(struct ice_ddp_send_ctx *ctx,
1257					    struct ice_buf_hdr *hunk)
1258{
1259	struct ice_buf_hdr *prev_hunk = ctx->hdr;
1260	struct ice_hw *hw = ctx->hw;
1261	bool prev_was_last = !hunk;
1262	enum ice_aq_err aq_err;
1263	u32 offset, info;
1264	int attempt, err;
1265
1266	if (ctx->err)
1267		return ctx->err;
1268
1269	ctx->hdr = hunk;
1270	if (!prev_hunk)
1271		return ICE_DDP_PKG_SUCCESS; /* no problem so far */
1272
1273	for (attempt = 0; attempt < 5; attempt++) {
1274		if (attempt)
1275			msleep(20);
1276
1277		err = ice_aq_download_pkg(hw, prev_hunk, ICE_PKG_BUF_SIZE,
1278					  prev_was_last, &offset, &info, NULL);
1279
1280		aq_err = hw->adminq.sq_last_status;
1281		if (aq_err != ICE_AQ_RC_ENOSEC && aq_err != ICE_AQ_RC_EBADSIG)
1282			break;
1283	}
1284
1285	if (err) {
1286		ice_debug(hw, ICE_DBG_PKG, "Pkg download failed: err %d off %d inf %d\n",
1287			  err, offset, info);
1288		ctx->err = ice_map_aq_err_to_ddp_state(aq_err);
1289	} else if (attempt) {
1290		dev_dbg(ice_hw_to_dev(hw),
1291			"ice_aq_download_pkg number of retries: %d\n", attempt);
1292	}
1293
1294	return ctx->err;
1295}
1296
1297/**
1298 * ice_dwnld_cfg_bufs_no_lock
1299 * @ctx: context of the current buffers section to send
1300 * @bufs: pointer to an array of buffers
1301 * @start: buffer index of first buffer to download
1302 * @count: the number of buffers to download
1303 *
1304 * Downloads package configuration buffers to the firmware. Metadata buffers
1305 * are skipped, and the first metadata buffer found indicates that the rest
1306 * of the buffers are all metadata buffers.
1307 */
1308static enum ice_ddp_state
1309ice_dwnld_cfg_bufs_no_lock(struct ice_ddp_send_ctx *ctx, struct ice_buf *bufs,
1310			   u32 start, u32 count)
1311{
1312	struct ice_buf_hdr *bh;
1313	enum ice_ddp_state err;
1314
1315	if (!bufs || !count) {
1316		ice_ddp_send_ctx_set_err(ctx, ICE_DDP_PKG_ERR);
1317		return ICE_DDP_PKG_ERR;
1318	}
1319
1320	bufs += start;
1321
1322	for (int i = 0; i < count; i++, bufs++) {
1323		bh = (struct ice_buf_hdr *)bufs;
1324		/* Metadata buffers should not be sent to FW,
1325		 * their presence means "we are done here".
1326		 */
1327		if (ice_is_buffer_metadata(bh))
1328			break;
1329
1330		err = ice_ddp_send_hunk(ctx, bh);
1331		if (err)
1332			return err;
1333	}
1334
1335	return 0;
1336}
1337
1338/**
1339 * ice_get_pkg_seg_by_idx
1340 * @pkg_hdr: pointer to the package header to be searched
1341 * @idx: index of segment
1342 */
1343static struct ice_generic_seg_hdr *
1344ice_get_pkg_seg_by_idx(struct ice_pkg_hdr *pkg_hdr, u32 idx)
1345{
1346	if (idx < le32_to_cpu(pkg_hdr->seg_count))
1347		return (struct ice_generic_seg_hdr *)
1348			((u8 *)pkg_hdr +
1349			 le32_to_cpu(pkg_hdr->seg_offset[idx]));
1350
1351	return NULL;
1352}
1353
1354/**
1355 * ice_is_signing_seg_at_idx - determine if segment is a signing segment
1356 * @pkg_hdr: pointer to package header
1357 * @idx: segment index
1358 */
1359static bool ice_is_signing_seg_at_idx(struct ice_pkg_hdr *pkg_hdr, u32 idx)
1360{
1361	struct ice_generic_seg_hdr *seg;
1362
1363	seg = ice_get_pkg_seg_by_idx(pkg_hdr, idx);
1364	if (!seg)
1365		return false;
1366
1367	return le32_to_cpu(seg->seg_type) == SEGMENT_TYPE_SIGNING;
1368}
1369
1370/**
1371 * ice_is_signing_seg_type_at_idx
1372 * @pkg_hdr: pointer to package header
1373 * @idx: segment index
1374 * @seg_id: segment id that is expected
1375 * @sign_type: signing type
1376 *
1377 * Determine if a segment is a signing segment of the correct type
1378 */
1379static bool
1380ice_is_signing_seg_type_at_idx(struct ice_pkg_hdr *pkg_hdr, u32 idx,
1381			       u32 seg_id, u32 sign_type)
1382{
1383	struct ice_sign_seg *seg;
1384
1385	if (!ice_is_signing_seg_at_idx(pkg_hdr, idx))
1386		return false;
1387
1388	seg = (struct ice_sign_seg *)ice_get_pkg_seg_by_idx(pkg_hdr, idx);
1389
1390	if (seg && le32_to_cpu(seg->seg_id) == seg_id &&
1391	    le32_to_cpu(seg->sign_type) == sign_type)
1392		return true;
1393
1394	return false;
1395}
1396
1397/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1398 * ice_download_pkg_sig_seg - download a signature segment
1399 * @ctx: context of the current buffers section to send
1400 * @seg: pointer to signature segment
1401 */
1402static enum ice_ddp_state
1403ice_download_pkg_sig_seg(struct ice_ddp_send_ctx *ctx, struct ice_sign_seg *seg)
1404{
1405	return ice_dwnld_cfg_bufs_no_lock(ctx, seg->buf_tbl.buf_array, 0,
1406					  le32_to_cpu(seg->buf_tbl.buf_count));
 
1407}
1408
1409/**
1410 * ice_download_pkg_config_seg - download a config segment
1411 * @ctx: context of the current buffers section to send
1412 * @pkg_hdr: pointer to package header
1413 * @idx: segment index
1414 * @start: starting buffer
1415 * @count: buffer count
1416 *
1417 * Note: idx must reference a ICE segment
1418 */
1419static enum ice_ddp_state
1420ice_download_pkg_config_seg(struct ice_ddp_send_ctx *ctx,
1421			    struct ice_pkg_hdr *pkg_hdr, u32 idx, u32 start,
1422			    u32 count)
1423{
1424	struct ice_buf_table *bufs;
1425	struct ice_seg *seg;
1426	u32 buf_count;
1427
1428	seg = (struct ice_seg *)ice_get_pkg_seg_by_idx(pkg_hdr, idx);
1429	if (!seg)
1430		return ICE_DDP_PKG_ERR;
1431
1432	bufs = ice_find_buf_table(seg);
1433	buf_count = le32_to_cpu(bufs->buf_count);
1434
1435	if (start >= buf_count || start + count > buf_count)
1436		return ICE_DDP_PKG_ERR;
1437
1438	return ice_dwnld_cfg_bufs_no_lock(ctx, bufs->buf_array, start, count);
1439}
1440
1441static bool ice_is_last_sign_seg(u32 flags)
1442{
1443	return !(flags & ICE_SIGN_SEG_FLAGS_VALID) || /* behavior prior to valid */
1444	       (flags & ICE_SIGN_SEG_FLAGS_LAST);
1445}
1446
1447/**
1448 * ice_dwnld_sign_and_cfg_segs - download a signing segment and config segment
1449 * @ctx: context of the current buffers section to send
1450 * @pkg_hdr: pointer to package header
1451 * @idx: segment index (must be a signature segment)
1452 *
1453 * Note: idx must reference a signature segment
1454 */
1455static enum ice_ddp_state
1456ice_dwnld_sign_and_cfg_segs(struct ice_ddp_send_ctx *ctx,
1457			    struct ice_pkg_hdr *pkg_hdr, u32 idx)
1458{
1459	u32 conf_idx, start, count, flags;
1460	enum ice_ddp_state state;
1461	struct ice_sign_seg *seg;
 
 
 
1462
1463	seg = (struct ice_sign_seg *)ice_get_pkg_seg_by_idx(pkg_hdr, idx);
1464	if (!seg) {
1465		state = ICE_DDP_PKG_ERR;
1466		ice_ddp_send_ctx_set_err(ctx, state);
1467		return state;
1468	}
1469
1470	count = le32_to_cpu(seg->signed_buf_count);
1471	state = ice_download_pkg_sig_seg(ctx, seg);
1472	if (state || !count)
1473		return state;
1474
1475	conf_idx = le32_to_cpu(seg->signed_seg_idx);
1476	start = le32_to_cpu(seg->signed_buf_start);
1477
1478	state = ice_download_pkg_config_seg(ctx, pkg_hdr, conf_idx, start,
1479					    count);
1480
1481	/* finish up by sending last hunk with "last" flag set if requested by
1482	 * DDP content
1483	 */
1484	flags = le32_to_cpu(seg->flags);
1485	if (ice_is_last_sign_seg(flags))
1486		state = ice_ddp_send_hunk(ctx, NULL);
1487
1488	return state;
1489}
1490
1491/**
1492 * ice_match_signing_seg - determine if a matching signing segment exists
1493 * @pkg_hdr: pointer to package header
1494 * @seg_id: segment id that is expected
1495 * @sign_type: signing type
1496 */
1497static bool
1498ice_match_signing_seg(struct ice_pkg_hdr *pkg_hdr, u32 seg_id, u32 sign_type)
1499{
1500	u32 i;
1501
1502	for (i = 0; i < le32_to_cpu(pkg_hdr->seg_count); i++) {
1503		if (ice_is_signing_seg_type_at_idx(pkg_hdr, i, seg_id,
1504						   sign_type))
1505			return true;
1506	}
1507
1508	return false;
1509}
1510
1511/**
1512 * ice_post_dwnld_pkg_actions - perform post download package actions
1513 * @hw: pointer to the hardware structure
1514 */
1515static enum ice_ddp_state
1516ice_post_dwnld_pkg_actions(struct ice_hw *hw)
1517{
1518	int status;
1519
1520	status = ice_set_vlan_mode(hw);
1521	if (status) {
1522		ice_debug(hw, ICE_DBG_PKG, "Failed to set VLAN mode: err %d\n",
1523			  status);
1524		return ICE_DDP_PKG_ERR;
1525	}
1526
1527	return ICE_DDP_PKG_SUCCESS;
1528}
1529
1530/**
1531 * ice_download_pkg_with_sig_seg
1532 * @hw: pointer to the hardware structure
1533 * @pkg_hdr: pointer to package header
1534 *
1535 * Handles the download of a complete package.
1536 */
1537static enum ice_ddp_state
1538ice_download_pkg_with_sig_seg(struct ice_hw *hw, struct ice_pkg_hdr *pkg_hdr)
1539{
1540	enum ice_aq_err aq_err = hw->adminq.sq_last_status;
1541	enum ice_ddp_state state = ICE_DDP_PKG_ERR;
1542	struct ice_ddp_send_ctx ctx = { .hw = hw };
1543	int status;
1544	u32 i;
1545
1546	ice_debug(hw, ICE_DBG_INIT, "Segment ID %d\n", hw->pkg_seg_id);
1547	ice_debug(hw, ICE_DBG_INIT, "Signature type %d\n", hw->pkg_sign_type);
1548
1549	status = ice_acquire_global_cfg_lock(hw, ICE_RES_WRITE);
1550	if (status) {
1551		if (status == -EALREADY)
1552			state = ICE_DDP_PKG_ALREADY_LOADED;
1553		else
1554			state = ice_map_aq_err_to_ddp_state(aq_err);
1555		return state;
1556	}
1557
1558	for (i = 0; i < le32_to_cpu(pkg_hdr->seg_count); i++) {
1559		if (!ice_is_signing_seg_type_at_idx(pkg_hdr, i, hw->pkg_seg_id,
1560						    hw->pkg_sign_type))
1561			continue;
1562
1563		state = ice_dwnld_sign_and_cfg_segs(&ctx, pkg_hdr, i);
1564		if (state)
1565			break;
1566	}
1567
1568	if (!state)
1569		state = ice_post_dwnld_pkg_actions(hw);
1570
1571	ice_release_global_cfg_lock(hw);
1572
1573	return state;
1574}
1575
1576/**
1577 * ice_dwnld_cfg_bufs
1578 * @hw: pointer to the hardware structure
1579 * @bufs: pointer to an array of buffers
1580 * @count: the number of buffers in the array
1581 *
1582 * Obtains global config lock and downloads the package configuration buffers
1583 * to the firmware.
1584 */
1585static enum ice_ddp_state
1586ice_dwnld_cfg_bufs(struct ice_hw *hw, struct ice_buf *bufs, u32 count)
1587{
1588	struct ice_ddp_send_ctx ctx = { .hw = hw };
1589	enum ice_ddp_state state;
1590	struct ice_buf_hdr *bh;
1591	int status;
1592
1593	if (!bufs || !count)
1594		return ICE_DDP_PKG_ERR;
1595
1596	/* If the first buffer's first section has its metadata bit set
1597	 * then there are no buffers to be downloaded, and the operation is
1598	 * considered a success.
1599	 */
1600	bh = (struct ice_buf_hdr *)bufs;
1601	if (ice_is_buffer_metadata(bh))
1602		return ICE_DDP_PKG_SUCCESS;
1603
1604	status = ice_acquire_global_cfg_lock(hw, ICE_RES_WRITE);
1605	if (status) {
1606		if (status == -EALREADY)
1607			return ICE_DDP_PKG_ALREADY_LOADED;
1608		return ice_map_aq_err_to_ddp_state(hw->adminq.sq_last_status);
1609	}
1610
1611	ice_dwnld_cfg_bufs_no_lock(&ctx, bufs, 0, count);
1612	/* finish up by sending last hunk with "last" flag set */
1613	state = ice_ddp_send_hunk(&ctx, NULL);
1614	if (!state)
1615		state = ice_post_dwnld_pkg_actions(hw);
1616
1617	ice_release_global_cfg_lock(hw);
1618
1619	return state;
1620}
1621
1622/**
1623 * ice_download_pkg_without_sig_seg
1624 * @hw: pointer to the hardware structure
1625 * @ice_seg: pointer to the segment of the package to be downloaded
1626 *
1627 * Handles the download of a complete package without signature segment.
1628 */
1629static enum ice_ddp_state
1630ice_download_pkg_without_sig_seg(struct ice_hw *hw, struct ice_seg *ice_seg)
1631{
1632	struct ice_buf_table *ice_buf_tbl;
1633
1634	ice_debug(hw, ICE_DBG_PKG, "Segment format version: %d.%d.%d.%d\n",
1635		  ice_seg->hdr.seg_format_ver.major,
1636		  ice_seg->hdr.seg_format_ver.minor,
1637		  ice_seg->hdr.seg_format_ver.update,
1638		  ice_seg->hdr.seg_format_ver.draft);
1639
1640	ice_debug(hw, ICE_DBG_PKG, "Seg: type 0x%X, size %d, name %s\n",
1641		  le32_to_cpu(ice_seg->hdr.seg_type),
1642		  le32_to_cpu(ice_seg->hdr.seg_size), ice_seg->hdr.seg_id);
1643
1644	ice_buf_tbl = ice_find_buf_table(ice_seg);
1645
1646	ice_debug(hw, ICE_DBG_PKG, "Seg buf count: %d\n",
1647		  le32_to_cpu(ice_buf_tbl->buf_count));
1648
1649	return ice_dwnld_cfg_bufs(hw, ice_buf_tbl->buf_array,
1650				  le32_to_cpu(ice_buf_tbl->buf_count));
1651}
1652
1653/**
1654 * ice_download_pkg
1655 * @hw: pointer to the hardware structure
1656 * @pkg_hdr: pointer to package header
1657 * @ice_seg: pointer to the segment of the package to be downloaded
1658 *
1659 * Handles the download of a complete package.
1660 */
1661static enum ice_ddp_state
1662ice_download_pkg(struct ice_hw *hw, struct ice_pkg_hdr *pkg_hdr,
1663		 struct ice_seg *ice_seg)
1664{
1665	enum ice_ddp_state state;
1666
1667	if (hw->pkg_has_signing_seg)
1668		state = ice_download_pkg_with_sig_seg(hw, pkg_hdr);
1669	else
1670		state = ice_download_pkg_without_sig_seg(hw, ice_seg);
1671
1672	ice_post_pkg_dwnld_vlan_mode_cfg(hw);
1673
1674	return state;
1675}
1676
1677/**
1678 * ice_aq_get_pkg_info_list
1679 * @hw: pointer to the hardware structure
1680 * @pkg_info: the buffer which will receive the information list
1681 * @buf_size: the size of the pkg_info information buffer
1682 * @cd: pointer to command details structure or NULL
1683 *
1684 * Get Package Info List (0x0C43)
1685 */
1686static int ice_aq_get_pkg_info_list(struct ice_hw *hw,
1687				    struct ice_aqc_get_pkg_info_resp *pkg_info,
1688				    u16 buf_size, struct ice_sq_cd *cd)
1689{
1690	struct ice_aq_desc desc;
1691
1692	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_pkg_info_list);
1693
1694	return ice_aq_send_cmd(hw, &desc, pkg_info, buf_size, cd);
1695}
1696
1697/**
1698 * ice_aq_update_pkg
1699 * @hw: pointer to the hardware structure
1700 * @pkg_buf: the package cmd buffer
1701 * @buf_size: the size of the package cmd buffer
1702 * @last_buf: last buffer indicator
1703 * @error_offset: returns error offset
1704 * @error_info: returns error information
1705 * @cd: pointer to command details structure or NULL
1706 *
1707 * Update Package (0x0C42)
1708 */
1709static int ice_aq_update_pkg(struct ice_hw *hw, struct ice_buf_hdr *pkg_buf,
1710			     u16 buf_size, bool last_buf, u32 *error_offset,
1711			     u32 *error_info, struct ice_sq_cd *cd)
1712{
1713	struct ice_aqc_download_pkg *cmd;
1714	struct ice_aq_desc desc;
1715	int status;
1716
1717	if (error_offset)
1718		*error_offset = 0;
1719	if (error_info)
1720		*error_info = 0;
1721
1722	cmd = &desc.params.download_pkg;
1723	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_update_pkg);
1724	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
1725
1726	if (last_buf)
1727		cmd->flags |= ICE_AQC_DOWNLOAD_PKG_LAST_BUF;
1728
1729	status = ice_aq_send_cmd(hw, &desc, pkg_buf, buf_size, cd);
1730	if (status == -EIO) {
1731		/* Read error from buffer only when the FW returned an error */
1732		struct ice_aqc_download_pkg_resp *resp;
1733
1734		resp = (struct ice_aqc_download_pkg_resp *)pkg_buf;
1735		if (error_offset)
1736			*error_offset = le32_to_cpu(resp->error_offset);
1737		if (error_info)
1738			*error_info = le32_to_cpu(resp->error_info);
1739	}
1740
1741	return status;
1742}
1743
1744/**
1745 * ice_aq_upload_section
1746 * @hw: pointer to the hardware structure
1747 * @pkg_buf: the package buffer which will receive the section
1748 * @buf_size: the size of the package buffer
1749 * @cd: pointer to command details structure or NULL
1750 *
1751 * Upload Section (0x0C41)
1752 */
1753int ice_aq_upload_section(struct ice_hw *hw, struct ice_buf_hdr *pkg_buf,
1754			  u16 buf_size, struct ice_sq_cd *cd)
1755{
1756	struct ice_aq_desc desc;
1757
1758	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_upload_section);
1759	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
1760
1761	return ice_aq_send_cmd(hw, &desc, pkg_buf, buf_size, cd);
1762}
1763
1764/**
1765 * ice_update_pkg_no_lock
1766 * @hw: pointer to the hardware structure
1767 * @bufs: pointer to an array of buffers
1768 * @count: the number of buffers in the array
1769 */
1770int ice_update_pkg_no_lock(struct ice_hw *hw, struct ice_buf *bufs, u32 count)
1771{
1772	int status = 0;
1773	u32 i;
1774
1775	for (i = 0; i < count; i++) {
1776		struct ice_buf_hdr *bh = (struct ice_buf_hdr *)(bufs + i);
1777		bool last = ((i + 1) == count);
1778		u32 offset, info;
1779
1780		status = ice_aq_update_pkg(hw, bh, le16_to_cpu(bh->data_end),
1781					   last, &offset, &info, NULL);
1782
1783		if (status) {
1784			ice_debug(hw, ICE_DBG_PKG,
1785				  "Update pkg failed: err %d off %d inf %d\n",
1786				  status, offset, info);
1787			break;
1788		}
1789	}
1790
1791	return status;
1792}
1793
1794/**
1795 * ice_update_pkg
1796 * @hw: pointer to the hardware structure
1797 * @bufs: pointer to an array of buffers
1798 * @count: the number of buffers in the array
1799 *
1800 * Obtains change lock and updates package.
1801 */
1802int ice_update_pkg(struct ice_hw *hw, struct ice_buf *bufs, u32 count)
1803{
1804	int status;
1805
1806	status = ice_acquire_change_lock(hw, ICE_RES_WRITE);
1807	if (status)
1808		return status;
1809
1810	status = ice_update_pkg_no_lock(hw, bufs, count);
1811
1812	ice_release_change_lock(hw);
1813
1814	return status;
1815}
1816
1817/**
1818 * ice_find_seg_in_pkg
1819 * @hw: pointer to the hardware structure
1820 * @seg_type: the segment type to search for (i.e., SEGMENT_TYPE_CPK)
1821 * @pkg_hdr: pointer to the package header to be searched
1822 *
1823 * This function searches a package file for a particular segment type. On
1824 * success it returns a pointer to the segment header, otherwise it will
1825 * return NULL.
1826 */
1827static const struct ice_generic_seg_hdr *
1828ice_find_seg_in_pkg(struct ice_hw *hw, u32 seg_type,
1829		    const struct ice_pkg_hdr *pkg_hdr)
1830{
1831	u32 i;
1832
1833	ice_debug(hw, ICE_DBG_PKG, "Package format version: %d.%d.%d.%d\n",
1834		  pkg_hdr->pkg_format_ver.major, pkg_hdr->pkg_format_ver.minor,
1835		  pkg_hdr->pkg_format_ver.update,
1836		  pkg_hdr->pkg_format_ver.draft);
1837
1838	/* Search all package segments for the requested segment type */
1839	for (i = 0; i < le32_to_cpu(pkg_hdr->seg_count); i++) {
1840		const struct ice_generic_seg_hdr *seg;
1841
1842		seg = (void *)pkg_hdr + le32_to_cpu(pkg_hdr->seg_offset[i]);
 
 
1843
1844		if (le32_to_cpu(seg->seg_type) == seg_type)
1845			return seg;
1846	}
1847
1848	return NULL;
1849}
1850
1851/**
1852 * ice_has_signing_seg - determine if package has a signing segment
1853 * @hw: pointer to the hardware structure
1854 * @pkg_hdr: pointer to the driver's package hdr
1855 */
1856static bool ice_has_signing_seg(struct ice_hw *hw, struct ice_pkg_hdr *pkg_hdr)
1857{
1858	struct ice_generic_seg_hdr *seg_hdr;
1859
1860	seg_hdr = (struct ice_generic_seg_hdr *)
1861		ice_find_seg_in_pkg(hw, SEGMENT_TYPE_SIGNING, pkg_hdr);
1862
1863	return seg_hdr ? true : false;
1864}
1865
1866/**
1867 * ice_get_pkg_segment_id - get correct package segment id, based on device
1868 * @mac_type: MAC type of the device
1869 */
1870static u32 ice_get_pkg_segment_id(enum ice_mac_type mac_type)
1871{
1872	u32 seg_id;
1873
1874	switch (mac_type) {
1875	case ICE_MAC_E830:
1876		seg_id = SEGMENT_TYPE_ICE_E830;
1877		break;
1878	case ICE_MAC_GENERIC:
1879	case ICE_MAC_GENERIC_3K_E825:
1880	default:
1881		seg_id = SEGMENT_TYPE_ICE_E810;
1882		break;
1883	}
1884
1885	return seg_id;
1886}
1887
1888/**
1889 * ice_get_pkg_sign_type - get package segment sign type, based on device
1890 * @mac_type: MAC type of the device
1891 */
1892static u32 ice_get_pkg_sign_type(enum ice_mac_type mac_type)
1893{
1894	u32 sign_type;
1895
1896	switch (mac_type) {
1897	case ICE_MAC_E830:
1898		sign_type = SEGMENT_SIGN_TYPE_RSA3K_SBB;
1899		break;
1900	case ICE_MAC_GENERIC_3K_E825:
1901		sign_type = SEGMENT_SIGN_TYPE_RSA3K_E825;
1902		break;
1903	case ICE_MAC_GENERIC:
1904	default:
1905		sign_type = SEGMENT_SIGN_TYPE_RSA2K;
1906		break;
1907	}
1908
1909	return sign_type;
1910}
1911
1912/**
1913 * ice_get_signing_req - get correct package requirements, based on device
1914 * @hw: pointer to the hardware structure
1915 */
1916static void ice_get_signing_req(struct ice_hw *hw)
1917{
1918	hw->pkg_seg_id = ice_get_pkg_segment_id(hw->mac_type);
1919	hw->pkg_sign_type = ice_get_pkg_sign_type(hw->mac_type);
1920}
1921
1922/**
1923 * ice_init_pkg_info
1924 * @hw: pointer to the hardware structure
1925 * @pkg_hdr: pointer to the driver's package hdr
1926 *
1927 * Saves off the package details into the HW structure.
1928 */
1929static enum ice_ddp_state ice_init_pkg_info(struct ice_hw *hw,
1930					    struct ice_pkg_hdr *pkg_hdr)
1931{
1932	struct ice_generic_seg_hdr *seg_hdr;
1933
1934	if (!pkg_hdr)
1935		return ICE_DDP_PKG_ERR;
1936
1937	hw->pkg_has_signing_seg = ice_has_signing_seg(hw, pkg_hdr);
1938	ice_get_signing_req(hw);
1939
1940	ice_debug(hw, ICE_DBG_INIT, "Pkg using segment id: 0x%08X\n",
1941		  hw->pkg_seg_id);
1942
1943	seg_hdr = (struct ice_generic_seg_hdr *)
1944		ice_find_seg_in_pkg(hw, hw->pkg_seg_id, pkg_hdr);
1945	if (seg_hdr) {
1946		struct ice_meta_sect *meta;
1947		struct ice_pkg_enum state;
1948
1949		memset(&state, 0, sizeof(state));
1950
1951		/* Get package information from the Metadata Section */
1952		meta = ice_pkg_enum_section((struct ice_seg *)seg_hdr, &state,
1953					    ICE_SID_METADATA);
1954		if (!meta) {
1955			ice_debug(hw, ICE_DBG_INIT,
1956				  "Did not find ice metadata section in package\n");
1957			return ICE_DDP_PKG_INVALID_FILE;
1958		}
1959
1960		hw->pkg_ver = meta->ver;
1961		memcpy(hw->pkg_name, meta->name, sizeof(meta->name));
1962
1963		ice_debug(hw, ICE_DBG_PKG, "Pkg: %d.%d.%d.%d, %s\n",
1964			  meta->ver.major, meta->ver.minor, meta->ver.update,
1965			  meta->ver.draft, meta->name);
1966
1967		hw->ice_seg_fmt_ver = seg_hdr->seg_format_ver;
1968		memcpy(hw->ice_seg_id, seg_hdr->seg_id, sizeof(hw->ice_seg_id));
1969
1970		ice_debug(hw, ICE_DBG_PKG, "Ice Seg: %d.%d.%d.%d, %s\n",
1971			  seg_hdr->seg_format_ver.major,
1972			  seg_hdr->seg_format_ver.minor,
1973			  seg_hdr->seg_format_ver.update,
1974			  seg_hdr->seg_format_ver.draft, seg_hdr->seg_id);
1975	} else {
1976		ice_debug(hw, ICE_DBG_INIT,
1977			  "Did not find ice segment in driver package\n");
1978		return ICE_DDP_PKG_INVALID_FILE;
1979	}
1980
1981	return ICE_DDP_PKG_SUCCESS;
1982}
1983
1984/**
1985 * ice_get_pkg_info
1986 * @hw: pointer to the hardware structure
1987 *
1988 * Store details of the package currently loaded in HW into the HW structure.
1989 */
1990static enum ice_ddp_state ice_get_pkg_info(struct ice_hw *hw)
1991{
1992	DEFINE_RAW_FLEX(struct ice_aqc_get_pkg_info_resp, pkg_info, pkg_info,
1993			ICE_PKG_CNT);
1994	u16 size = __struct_size(pkg_info);
1995	u32 i;
1996
1997	if (ice_aq_get_pkg_info_list(hw, pkg_info, size, NULL))
1998		return ICE_DDP_PKG_ERR;
1999
2000	for (i = 0; i < le32_to_cpu(pkg_info->count); i++) {
2001#define ICE_PKG_FLAG_COUNT 4
2002		char flags[ICE_PKG_FLAG_COUNT + 1] = { 0 };
2003		u8 place = 0;
2004
2005		if (pkg_info->pkg_info[i].is_active) {
2006			flags[place++] = 'A';
2007			hw->active_pkg_ver = pkg_info->pkg_info[i].ver;
2008			hw->active_track_id =
2009				le32_to_cpu(pkg_info->pkg_info[i].track_id);
2010			memcpy(hw->active_pkg_name, pkg_info->pkg_info[i].name,
2011			       sizeof(pkg_info->pkg_info[i].name));
2012			hw->active_pkg_in_nvm = pkg_info->pkg_info[i].is_in_nvm;
2013		}
2014		if (pkg_info->pkg_info[i].is_active_at_boot)
2015			flags[place++] = 'B';
2016		if (pkg_info->pkg_info[i].is_modified)
2017			flags[place++] = 'M';
2018		if (pkg_info->pkg_info[i].is_in_nvm)
2019			flags[place++] = 'N';
2020
2021		ice_debug(hw, ICE_DBG_PKG, "Pkg[%d]: %d.%d.%d.%d,%s,%s\n", i,
2022			  pkg_info->pkg_info[i].ver.major,
2023			  pkg_info->pkg_info[i].ver.minor,
2024			  pkg_info->pkg_info[i].ver.update,
2025			  pkg_info->pkg_info[i].ver.draft,
2026			  pkg_info->pkg_info[i].name, flags);
2027	}
2028
2029	return ICE_DDP_PKG_SUCCESS;
2030}
2031
2032/**
2033 * ice_chk_pkg_compat
2034 * @hw: pointer to the hardware structure
2035 * @ospkg: pointer to the package hdr
2036 * @seg: pointer to the package segment hdr
2037 *
2038 * This function checks the package version compatibility with driver and NVM
2039 */
2040static enum ice_ddp_state ice_chk_pkg_compat(struct ice_hw *hw,
2041					     struct ice_pkg_hdr *ospkg,
2042					     struct ice_seg **seg)
2043{
2044	DEFINE_RAW_FLEX(struct ice_aqc_get_pkg_info_resp, pkg, pkg_info,
2045			ICE_PKG_CNT);
2046	u16 size = __struct_size(pkg);
2047	enum ice_ddp_state state;
2048	u32 i;
2049
2050	/* Check package version compatibility */
2051	state = ice_chk_pkg_version(&hw->pkg_ver);
2052	if (state) {
2053		ice_debug(hw, ICE_DBG_INIT, "Package version check failed.\n");
2054		return state;
2055	}
2056
2057	/* find ICE segment in given package */
2058	*seg = (struct ice_seg *)ice_find_seg_in_pkg(hw, hw->pkg_seg_id,
2059						     ospkg);
2060	if (!*seg) {
2061		ice_debug(hw, ICE_DBG_INIT, "no ice segment in package.\n");
2062		return ICE_DDP_PKG_INVALID_FILE;
2063	}
2064
2065	/* Check if FW is compatible with the OS package */
2066	if (ice_aq_get_pkg_info_list(hw, pkg, size, NULL))
2067		return ICE_DDP_PKG_LOAD_ERROR;
2068
2069	for (i = 0; i < le32_to_cpu(pkg->count); i++) {
2070		/* loop till we find the NVM package */
2071		if (!pkg->pkg_info[i].is_in_nvm)
2072			continue;
2073		if ((*seg)->hdr.seg_format_ver.major !=
2074			    pkg->pkg_info[i].ver.major ||
2075		    (*seg)->hdr.seg_format_ver.minor >
2076			    pkg->pkg_info[i].ver.minor) {
2077			state = ICE_DDP_PKG_FW_MISMATCH;
2078			ice_debug(hw, ICE_DBG_INIT,
2079				  "OS package is not compatible with NVM.\n");
2080		}
2081		/* done processing NVM package so break */
2082		break;
2083	}
2084
2085	return state;
2086}
2087
2088/**
2089 * ice_init_pkg_hints
2090 * @hw: pointer to the HW structure
2091 * @ice_seg: pointer to the segment of the package scan (non-NULL)
2092 *
2093 * This function will scan the package and save off relevant information
2094 * (hints or metadata) for driver use. The ice_seg parameter must not be NULL
2095 * since the first call to ice_enum_labels requires a pointer to an actual
2096 * ice_seg structure.
2097 */
2098static void ice_init_pkg_hints(struct ice_hw *hw, struct ice_seg *ice_seg)
2099{
2100	struct ice_pkg_enum state;
2101	char *label_name;
2102	u16 val;
2103	int i;
2104
2105	memset(&hw->tnl, 0, sizeof(hw->tnl));
2106	memset(&state, 0, sizeof(state));
2107
2108	if (!ice_seg)
2109		return;
2110
2111	label_name = ice_enum_labels(ice_seg, ICE_SID_LBL_RXPARSER_TMEM, &state,
2112				     &val);
2113
2114	while (label_name) {
2115		if (!strncmp(label_name, ICE_TNL_PRE, strlen(ICE_TNL_PRE)))
2116			/* check for a tunnel entry */
2117			ice_add_tunnel_hint(hw, label_name, val);
2118
2119		/* check for a dvm mode entry */
2120		else if (!strncmp(label_name, ICE_DVM_PRE, strlen(ICE_DVM_PRE)))
2121			ice_add_dvm_hint(hw, val, true);
2122
2123		/* check for a svm mode entry */
2124		else if (!strncmp(label_name, ICE_SVM_PRE, strlen(ICE_SVM_PRE)))
2125			ice_add_dvm_hint(hw, val, false);
2126
2127		label_name = ice_enum_labels(NULL, 0, &state, &val);
2128	}
2129
2130	/* Cache the appropriate boost TCAM entry pointers for tunnels */
2131	for (i = 0; i < hw->tnl.count; i++) {
2132		ice_find_boost_entry(ice_seg, hw->tnl.tbl[i].boost_addr,
2133				     &hw->tnl.tbl[i].boost_entry);
2134		if (hw->tnl.tbl[i].boost_entry) {
2135			hw->tnl.tbl[i].valid = true;
2136			if (hw->tnl.tbl[i].type < __TNL_TYPE_CNT)
2137				hw->tnl.valid_count[hw->tnl.tbl[i].type]++;
2138		}
2139	}
2140
2141	/* Cache the appropriate boost TCAM entry pointers for DVM and SVM */
2142	for (i = 0; i < hw->dvm_upd.count; i++)
2143		ice_find_boost_entry(ice_seg, hw->dvm_upd.tbl[i].boost_addr,
2144				     &hw->dvm_upd.tbl[i].boost_entry);
2145}
2146
2147/**
2148 * ice_fill_hw_ptype - fill the enabled PTYPE bit information
2149 * @hw: pointer to the HW structure
2150 */
2151static void ice_fill_hw_ptype(struct ice_hw *hw)
2152{
2153	struct ice_marker_ptype_tcam_entry *tcam;
2154	struct ice_seg *seg = hw->seg;
2155	struct ice_pkg_enum state;
2156
2157	bitmap_zero(hw->hw_ptype, ICE_FLOW_PTYPE_MAX);
2158	if (!seg)
2159		return;
2160
2161	memset(&state, 0, sizeof(state));
2162
2163	do {
2164		tcam = ice_pkg_enum_entry(seg, &state,
2165					  ICE_SID_RXPARSER_MARKER_PTYPE, NULL,
2166					  ice_marker_ptype_tcam_handler);
2167		if (tcam &&
2168		    le16_to_cpu(tcam->addr) < ICE_MARKER_PTYPE_TCAM_ADDR_MAX &&
2169		    le16_to_cpu(tcam->ptype) < ICE_FLOW_PTYPE_MAX)
2170			set_bit(le16_to_cpu(tcam->ptype), hw->hw_ptype);
2171
2172		seg = NULL;
2173	} while (tcam);
2174}
2175
2176/**
2177 * ice_init_pkg - initialize/download package
2178 * @hw: pointer to the hardware structure
2179 * @buf: pointer to the package buffer
2180 * @len: size of the package buffer
2181 *
2182 * This function initializes a package. The package contains HW tables
2183 * required to do packet processing. First, the function extracts package
2184 * information such as version. Then it finds the ice configuration segment
2185 * within the package; this function then saves a copy of the segment pointer
2186 * within the supplied package buffer. Next, the function will cache any hints
2187 * from the package, followed by downloading the package itself. Note, that if
2188 * a previous PF driver has already downloaded the package successfully, then
2189 * the current driver will not have to download the package again.
2190 *
2191 * The local package contents will be used to query default behavior and to
2192 * update specific sections of the HW's version of the package (e.g. to update
2193 * the parse graph to understand new protocols).
2194 *
2195 * This function stores a pointer to the package buffer memory, and it is
2196 * expected that the supplied buffer will not be freed immediately. If the
2197 * package buffer needs to be freed, such as when read from a file, use
2198 * ice_copy_and_init_pkg() instead of directly calling ice_init_pkg() in this
2199 * case.
2200 */
2201enum ice_ddp_state ice_init_pkg(struct ice_hw *hw, u8 *buf, u32 len)
2202{
2203	bool already_loaded = false;
2204	enum ice_ddp_state state;
2205	struct ice_pkg_hdr *pkg;
2206	struct ice_seg *seg;
2207
2208	if (!buf || !len)
2209		return ICE_DDP_PKG_ERR;
2210
2211	pkg = (struct ice_pkg_hdr *)buf;
2212	state = ice_verify_pkg(pkg, len);
2213	if (state) {
2214		ice_debug(hw, ICE_DBG_INIT, "failed to verify pkg (err: %d)\n",
2215			  state);
2216		return state;
2217	}
2218
2219	/* initialize package info */
2220	state = ice_init_pkg_info(hw, pkg);
2221	if (state)
2222		return state;
2223
2224	/* must be a matching segment */
2225	if (hw->pkg_has_signing_seg &&
2226	    !ice_match_signing_seg(pkg, hw->pkg_seg_id, hw->pkg_sign_type))
2227		return ICE_DDP_PKG_ERR;
2228
2229	/* before downloading the package, check package version for
2230	 * compatibility with driver
2231	 */
2232	state = ice_chk_pkg_compat(hw, pkg, &seg);
2233	if (state)
2234		return state;
2235
2236	/* initialize package hints and then download package */
2237	ice_init_pkg_hints(hw, seg);
2238	state = ice_download_pkg(hw, pkg, seg);
2239	if (state == ICE_DDP_PKG_ALREADY_LOADED) {
2240		ice_debug(hw, ICE_DBG_INIT,
2241			  "package previously loaded - no work.\n");
2242		already_loaded = true;
2243	}
2244
2245	/* Get information on the package currently loaded in HW, then make sure
2246	 * the driver is compatible with this version.
2247	 */
2248	if (!state || state == ICE_DDP_PKG_ALREADY_LOADED) {
2249		state = ice_get_pkg_info(hw);
2250		if (!state)
2251			state = ice_get_ddp_pkg_state(hw, already_loaded);
2252	}
2253
2254	if (ice_is_init_pkg_successful(state)) {
2255		hw->seg = seg;
2256		/* on successful package download update other required
2257		 * registers to support the package and fill HW tables
2258		 * with package content.
2259		 */
2260		ice_init_pkg_regs(hw);
2261		ice_fill_blk_tbls(hw);
2262		ice_fill_hw_ptype(hw);
2263		ice_get_prof_index_max(hw);
2264	} else {
2265		ice_debug(hw, ICE_DBG_INIT, "package load failed, %d\n", state);
2266	}
2267
2268	return state;
2269}
2270
2271/**
2272 * ice_copy_and_init_pkg - initialize/download a copy of the package
2273 * @hw: pointer to the hardware structure
2274 * @buf: pointer to the package buffer
2275 * @len: size of the package buffer
2276 *
2277 * This function copies the package buffer, and then calls ice_init_pkg() to
2278 * initialize the copied package contents.
2279 *
2280 * The copying is necessary if the package buffer supplied is constant, or if
2281 * the memory may disappear shortly after calling this function.
2282 *
2283 * If the package buffer resides in the data segment and can be modified, the
2284 * caller is free to use ice_init_pkg() instead of ice_copy_and_init_pkg().
2285 *
2286 * However, if the package buffer needs to be copied first, such as when being
2287 * read from a file, the caller should use ice_copy_and_init_pkg().
2288 *
2289 * This function will first copy the package buffer, before calling
2290 * ice_init_pkg(). The caller is free to immediately destroy the original
2291 * package buffer, as the new copy will be managed by this function and
2292 * related routines.
2293 */
2294enum ice_ddp_state ice_copy_and_init_pkg(struct ice_hw *hw, const u8 *buf,
2295					 u32 len)
2296{
2297	enum ice_ddp_state state;
2298	u8 *buf_copy;
2299
2300	if (!buf || !len)
2301		return ICE_DDP_PKG_ERR;
2302
2303	buf_copy = devm_kmemdup(ice_hw_to_dev(hw), buf, len, GFP_KERNEL);
2304
2305	state = ice_init_pkg(hw, buf_copy, len);
2306	if (!ice_is_init_pkg_successful(state)) {
2307		/* Free the copy, since we failed to initialize the package */
2308		devm_kfree(ice_hw_to_dev(hw), buf_copy);
2309	} else {
2310		/* Track the copied pkg so we can free it later */
2311		hw->pkg_copy = buf_copy;
2312		hw->pkg_size = len;
2313	}
2314
2315	return state;
2316}
2317
2318/**
2319 * ice_get_set_tx_topo - get or set Tx topology
2320 * @hw: pointer to the HW struct
2321 * @buf: pointer to Tx topology buffer
2322 * @buf_size: buffer size
2323 * @cd: pointer to command details structure or NULL
2324 * @flags: pointer to descriptor flags
2325 * @set: 0-get, 1-set topology
2326 *
2327 * The function will get or set Tx topology
2328 *
2329 * Return: zero when set was successful, negative values otherwise.
2330 */
2331static int
2332ice_get_set_tx_topo(struct ice_hw *hw, u8 *buf, u16 buf_size,
2333		    struct ice_sq_cd *cd, u8 *flags, bool set)
2334{
2335	struct ice_aqc_get_set_tx_topo *cmd;
2336	struct ice_aq_desc desc;
2337	int status;
2338
2339	cmd = &desc.params.get_set_tx_topo;
2340	if (set) {
2341		ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_tx_topo);
2342		cmd->set_flags = ICE_AQC_TX_TOPO_FLAGS_ISSUED;
2343		/* requested to update a new topology, not a default topology */
2344		if (buf)
2345			cmd->set_flags |= ICE_AQC_TX_TOPO_FLAGS_SRC_RAM |
2346					  ICE_AQC_TX_TOPO_FLAGS_LOAD_NEW;
2347
2348		if (ice_is_e825c(hw))
2349			desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
2350	} else {
2351		ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_tx_topo);
2352		cmd->get_flags = ICE_AQC_TX_TOPO_GET_RAM;
2353	}
2354
2355	if (!ice_is_e825c(hw))
2356		desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
2357
2358	status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
2359	if (status)
2360		return status;
2361	/* read the return flag values (first byte) for get operation */
2362	if (!set && flags)
2363		*flags = desc.params.get_set_tx_topo.set_flags;
2364
2365	return 0;
2366}
2367
2368/**
2369 * ice_cfg_tx_topo - Initialize new Tx topology if available
2370 * @hw: pointer to the HW struct
2371 * @buf: pointer to Tx topology buffer
2372 * @len: buffer size
2373 *
2374 * The function will apply the new Tx topology from the package buffer
2375 * if available.
2376 *
2377 * Return: zero when update was successful, negative values otherwise.
2378 */
2379int ice_cfg_tx_topo(struct ice_hw *hw, const void *buf, u32 len)
2380{
2381	u8 *new_topo = NULL, *topo __free(kfree) = NULL;
2382	const struct ice_run_time_cfg_seg *seg;
2383	const struct ice_buf_hdr *section;
2384	const struct ice_pkg_hdr *pkg_hdr;
2385	enum ice_ddp_state state;
2386	u16 offset, size = 0;
2387	u32 reg = 0;
2388	int status;
2389	u8 flags;
2390
2391	if (!buf || !len)
2392		return -EINVAL;
2393
2394	/* Does FW support new Tx topology mode ? */
2395	if (!hw->func_caps.common_cap.tx_sched_topo_comp_mode_en) {
2396		ice_debug(hw, ICE_DBG_INIT, "FW doesn't support compatibility mode\n");
2397		return -EOPNOTSUPP;
2398	}
2399
2400	topo = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL);
2401	if (!topo)
2402		return -ENOMEM;
2403
2404	/* Get the current Tx topology flags */
2405	status = ice_get_set_tx_topo(hw, topo, ICE_AQ_MAX_BUF_LEN, NULL, &flags,
2406				     false);
2407
2408	if (status) {
2409		ice_debug(hw, ICE_DBG_INIT, "Get current topology is failed\n");
2410		return status;
2411	}
2412
2413	/* Is default topology already applied ? */
2414	if (!(flags & ICE_AQC_TX_TOPO_FLAGS_LOAD_NEW) &&
2415	    hw->num_tx_sched_layers == ICE_SCHED_9_LAYERS) {
2416		ice_debug(hw, ICE_DBG_INIT, "Default topology already applied\n");
2417		return -EEXIST;
2418	}
2419
2420	/* Is new topology already applied ? */
2421	if ((flags & ICE_AQC_TX_TOPO_FLAGS_LOAD_NEW) &&
2422	    hw->num_tx_sched_layers == ICE_SCHED_5_LAYERS) {
2423		ice_debug(hw, ICE_DBG_INIT, "New topology already applied\n");
2424		return -EEXIST;
2425	}
2426
2427	/* Setting topology already issued? */
2428	if (flags & ICE_AQC_TX_TOPO_FLAGS_ISSUED) {
2429		ice_debug(hw, ICE_DBG_INIT, "Update Tx topology was done by another PF\n");
2430		/* Add a small delay before exiting */
2431		msleep(2000);
2432		return -EEXIST;
2433	}
2434
2435	/* Change the topology from new to default (5 to 9) */
2436	if (!(flags & ICE_AQC_TX_TOPO_FLAGS_LOAD_NEW) &&
2437	    hw->num_tx_sched_layers == ICE_SCHED_5_LAYERS) {
2438		ice_debug(hw, ICE_DBG_INIT, "Change topology from 5 to 9 layers\n");
2439		goto update_topo;
2440	}
2441
2442	pkg_hdr = (const struct ice_pkg_hdr *)buf;
2443	state = ice_verify_pkg(pkg_hdr, len);
2444	if (state) {
2445		ice_debug(hw, ICE_DBG_INIT, "Failed to verify pkg (err: %d)\n",
2446			  state);
2447		return -EIO;
2448	}
2449
2450	/* Find runtime configuration segment */
2451	seg = (const struct ice_run_time_cfg_seg *)
2452	      ice_find_seg_in_pkg(hw, SEGMENT_TYPE_ICE_RUN_TIME_CFG, pkg_hdr);
2453	if (!seg) {
2454		ice_debug(hw, ICE_DBG_INIT, "5 layer topology segment is missing\n");
2455		return -EIO;
2456	}
2457
2458	if (le32_to_cpu(seg->buf_table.buf_count) < ICE_MIN_S_COUNT) {
2459		ice_debug(hw, ICE_DBG_INIT, "5 layer topology segment count(%d) is wrong\n",
2460			  seg->buf_table.buf_count);
2461		return -EIO;
2462	}
2463
2464	section = ice_pkg_val_buf(seg->buf_table.buf_array);
2465	if (!section || le32_to_cpu(section->section_entry[0].type) !=
2466		ICE_SID_TX_5_LAYER_TOPO) {
2467		ice_debug(hw, ICE_DBG_INIT, "5 layer topology section type is wrong\n");
2468		return -EIO;
2469	}
2470
2471	size = le16_to_cpu(section->section_entry[0].size);
2472	offset = le16_to_cpu(section->section_entry[0].offset);
2473	if (size < ICE_MIN_S_SZ || size > ICE_MAX_S_SZ) {
2474		ice_debug(hw, ICE_DBG_INIT, "5 layer topology section size is wrong\n");
2475		return -EIO;
2476	}
2477
2478	/* Make sure the section fits in the buffer */
2479	if (offset + size > ICE_PKG_BUF_SIZE) {
2480		ice_debug(hw, ICE_DBG_INIT, "5 layer topology buffer > 4K\n");
2481		return -EIO;
2482	}
2483
2484	/* Get the new topology buffer, reuse current topo copy mem */
2485	static_assert(ICE_PKG_BUF_SIZE == ICE_AQ_MAX_BUF_LEN);
2486	new_topo = topo;
2487	memcpy(new_topo, (u8 *)section + offset, size);
2488
2489update_topo:
2490	/* Acquire global lock to make sure that set topology issued
2491	 * by one PF.
2492	 */
2493	status = ice_acquire_res(hw, ICE_GLOBAL_CFG_LOCK_RES_ID, ICE_RES_WRITE,
2494				 ICE_GLOBAL_CFG_LOCK_TIMEOUT);
2495	if (status) {
2496		ice_debug(hw, ICE_DBG_INIT, "Failed to acquire global lock\n");
2497		return status;
2498	}
2499
2500	/* Check if reset was triggered already. */
2501	reg = rd32(hw, GLGEN_RSTAT);
2502	if (reg & GLGEN_RSTAT_DEVSTATE_M) {
2503		/* Reset is in progress, re-init the HW again */
2504		ice_debug(hw, ICE_DBG_INIT, "Reset is in progress. Layer topology might be applied already\n");
2505		ice_check_reset(hw);
2506		return 0;
2507	}
2508
2509	/* Set new topology */
2510	status = ice_get_set_tx_topo(hw, new_topo, size, NULL, NULL, true);
2511	if (status) {
2512		ice_debug(hw, ICE_DBG_INIT, "Failed setting Tx topology\n");
2513		return status;
2514	}
2515
2516	/* New topology is updated, delay 1 second before issuing the CORER */
2517	msleep(1000);
2518	ice_reset(hw, ICE_RESET_CORER);
2519	/* CORER will clear the global lock, so no explicit call
2520	 * required for release.
2521	 */
2522
2523	return 0;
2524}