ixgbe_x540.c 26.8 KB
Newer Older
1 2 3
/*******************************************************************************

  Intel 10 Gigabit PCI Express Linux driver
4
  Copyright(c) 1999 - 2016 Intel Corporation.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
23
  Linux NICS <linux.nics@intel.com>
24 25 26 27 28 29 30 31 32 33 34
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/sched.h>

#include "ixgbe.h"
#include "ixgbe_phy.h"
35
#include "ixgbe_x540.h"
36

37 38 39 40 41 42
#define IXGBE_X540_MAX_TX_QUEUES	128
#define IXGBE_X540_MAX_RX_QUEUES	128
#define IXGBE_X540_RAR_ENTRIES		128
#define IXGBE_X540_MC_TBL_SIZE		128
#define IXGBE_X540_VFT_TBL_SIZE		128
#define IXGBE_X540_RX_PB_SIZE		384
43 44 45 46 47 48

static s32 ixgbe_update_flash_X540(struct ixgbe_hw *hw);
static s32 ixgbe_poll_flash_update_done_X540(struct ixgbe_hw *hw);
static s32 ixgbe_get_swfw_sync_semaphore(struct ixgbe_hw *hw);
static void ixgbe_release_swfw_sync_semaphore(struct ixgbe_hw *hw);

49
enum ixgbe_media_type ixgbe_get_media_type_X540(struct ixgbe_hw *hw)
50 51 52 53
{
	return ixgbe_media_type_copper;
}

54
s32 ixgbe_get_invariants_X540(struct ixgbe_hw *hw)
55 56
{
	struct ixgbe_mac_info *mac = &hw->mac;
57 58 59
	struct ixgbe_phy_info *phy = &hw->phy;

	/* set_phy_power was set by default to NULL */
60
	phy->ops.set_phy_power = ixgbe_set_copper_phy_power;
61 62 63 64

	mac->mcft_size = IXGBE_X540_MC_TBL_SIZE;
	mac->vft_size = IXGBE_X540_VFT_TBL_SIZE;
	mac->num_rar_entries = IXGBE_X540_RAR_ENTRIES;
65
	mac->rx_pb_size = IXGBE_X540_RX_PB_SIZE;
66 67 68 69 70 71 72 73 74 75 76 77 78
	mac->max_rx_queues = IXGBE_X540_MAX_RX_QUEUES;
	mac->max_tx_queues = IXGBE_X540_MAX_TX_QUEUES;
	mac->max_msix_vectors = ixgbe_get_pcie_msix_count_generic(hw);

	return 0;
}

/**
 *  ixgbe_setup_mac_link_X540 - Set the auto advertised capabilitires
 *  @hw: pointer to hardware structure
 *  @speed: new link speed
 *  @autoneg_wait_to_complete: true when waiting for completion is needed
 **/
79 80
s32 ixgbe_setup_mac_link_X540(struct ixgbe_hw *hw, ixgbe_link_speed speed,
			      bool autoneg_wait_to_complete)
81
{
82
	return hw->phy.ops.setup_link_speed(hw, speed,
83
					    autoneg_wait_to_complete);
84 85 86 87 88 89 90 91 92 93
}

/**
 *  ixgbe_reset_hw_X540 - Perform hardware reset
 *  @hw: pointer to hardware structure
 *
 *  Resets the hardware by resetting the transmit and receive units, masks
 *  and clears all interrupts, perform a PHY reset, and perform a link (MAC)
 *  reset.
 **/
94
s32 ixgbe_reset_hw_X540(struct ixgbe_hw *hw)
95
{
A
Alexander Duyck 已提交
96 97
	s32 status;
	u32 ctrl, i;
98 99

	/* Call adapter stop to disable tx/rx and clear interrupts */
100
	status = hw->mac.ops.stop_adapter(hw);
101 102
	if (status)
		return status;
103

104 105
	/* flush pending Tx transactions */
	ixgbe_clear_tx_pending(hw);
106

107
mac_reset_top:
108
	ctrl = IXGBE_CTRL_RST;
A
Alexander Duyck 已提交
109 110
	ctrl |= IXGBE_READ_REG(hw, IXGBE_CTRL);
	IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);
111
	IXGBE_WRITE_FLUSH(hw);
112
	usleep_range(1000, 1200);
113 114 115 116

	/* Poll for reset bit to self-clear indicating reset is complete */
	for (i = 0; i < 10; i++) {
		ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
A
Alexander Duyck 已提交
117
		if (!(ctrl & IXGBE_CTRL_RST_MASK))
118
			break;
119
		udelay(1);
120
	}
A
Alexander Duyck 已提交
121 122

	if (ctrl & IXGBE_CTRL_RST_MASK) {
123 124 125
		status = IXGBE_ERR_RESET_FAILED;
		hw_dbg(hw, "Reset polling failed to complete.\n");
	}
126
	msleep(100);
A
Alexander Duyck 已提交
127

128 129 130
	/*
	 * Double resets are required for recovery from certain error
	 * conditions.  Between resets, it is necessary to stall to allow time
A
Alexander Duyck 已提交
131
	 * for any pending HW events to complete.
132 133 134 135 136 137
	 */
	if (hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED) {
		hw->mac.flags &= ~IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;
		goto mac_reset_top;
	}

138 139 140 141 142 143 144 145 146 147 148
	/* Set the Rx packet buffer size. */
	IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(0), 384 << IXGBE_RXPBSIZE_SHIFT);

	/* Store the permanent mac address */
	hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);

	/*
	 * Store MAC address from RAR0, clear receive address registers, and
	 * clear the multicast table.  Also reset num_rar_entries to 128,
	 * since we modify this value when programming the SAN MAC address.
	 */
G
Greg Rose 已提交
149
	hw->mac.num_rar_entries = IXGBE_X540_MAX_TX_QUEUES;
150 151 152 153 154 155
	hw->mac.ops.init_rx_addrs(hw);

	/* Store the permanent SAN mac address */
	hw->mac.ops.get_san_mac_addr(hw, hw->mac.san_addr);

	/* Add the SAN MAC address to the RAR only if it's a valid address */
J
Joe Perches 已提交
156
	if (is_valid_ether_addr(hw->mac.san_addr)) {
157 158 159
		/* Save the SAN MAC RAR index */
		hw->mac.san_mac_rar_index = hw->mac.num_rar_entries - 1;

A
Alexander Duyck 已提交
160 161 162 163 164 165 166
		hw->mac.ops.set_rar(hw, hw->mac.san_mac_rar_index,
				    hw->mac.san_addr, 0, IXGBE_RAH_AV);

		/* clear VMDq pool/queue selection for this RAR */
		hw->mac.ops.clear_vmdq(hw, hw->mac.san_mac_rar_index,
				       IXGBE_CLEAR_VMDQ_ALL);

167 168 169 170 171 172
		/* Reserve the last RAR for the SAN MAC address */
		hw->mac.num_rar_entries--;
	}

	/* Store the alternative WWNN/WWPN prefix */
	hw->mac.ops.get_wwn_prefix(hw, &hw->mac.wwnn_prefix,
173
				   &hw->mac.wwpn_prefix);
174 175 176 177

	return status;
}

178 179 180 181 182 183 184 185
/**
 *  ixgbe_start_hw_X540 - Prepare hardware for Tx/Rx
 *  @hw: pointer to hardware structure
 *
 *  Starts the hardware using the generic start_hw function
 *  and the generation start_hw function.
 *  Then performs revision-specific operations, if any.
 **/
186
s32 ixgbe_start_hw_X540(struct ixgbe_hw *hw)
187
{
188
	s32 ret_val;
189 190

	ret_val = ixgbe_start_hw_generic(hw);
191 192
	if (ret_val)
		return ret_val;
193

194
	return ixgbe_start_hw_gen2(hw);
195 196
}

197
/**
E
Emil Tantilov 已提交
198 199 200 201 202
 *  ixgbe_init_eeprom_params_X540 - Initialize EEPROM params
 *  @hw: pointer to hardware structure
 *
 *  Initializes the EEPROM parameters ixgbe_eeprom_info within the
 *  ixgbe_hw struct in order to set up EEPROM access.
203
 **/
204
s32 ixgbe_init_eeprom_params_X540(struct ixgbe_hw *hw)
205 206 207 208 209 210 211 212 213
{
	struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
	u32 eec;
	u16 eeprom_size;

	if (eeprom->type == ixgbe_eeprom_uninitialized) {
		eeprom->semaphore_delay = 10;
		eeprom->type = ixgbe_flash;

214
		eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw));
215
		eeprom_size = (u16)((eec & IXGBE_EEC_SIZE) >>
216
				    IXGBE_EEC_SIZE_SHIFT);
217
		eeprom->word_size = 1 << (eeprom_size +
218
					  IXGBE_EEPROM_WORD_SIZE_SHIFT);
219 220

		hw_dbg(hw, "Eeprom params: type = %d, size = %d\n",
E
Emil Tantilov 已提交
221
		       eeprom->type, eeprom->word_size);
222 223 224 225 226 227
	}

	return 0;
}

/**
228 229 230 231 232 233
 *  ixgbe_read_eerd_X540- Read EEPROM word using EERD
 *  @hw: pointer to hardware structure
 *  @offset: offset of  word in the EEPROM to read
 *  @data: word read from the EEPROM
 *
 *  Reads a 16 bit word from the EEPROM using the EERD register.
234
 **/
D
Don Skidmore 已提交
235
static s32 ixgbe_read_eerd_X540(struct ixgbe_hw *hw, u16 offset, u16 *data)
236
{
237 238 239 240
	s32 status;

	if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM))
		return IXGBE_ERR_SWFW_SYNC;
241

242
	status = ixgbe_read_eerd_generic(hw, offset, data);
243

244
	hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
245 246 247
	return status;
}

248 249 250 251 252 253 254 255 256 257 258 259
/**
 *  ixgbe_read_eerd_buffer_X540 - Read EEPROM word(s) using EERD
 *  @hw: pointer to hardware structure
 *  @offset: offset of  word in the EEPROM to read
 *  @words: number of words
 *  @data: word(s) read from the EEPROM
 *
 *  Reads a 16 bit word(s) from the EEPROM using the EERD register.
 **/
static s32 ixgbe_read_eerd_buffer_X540(struct ixgbe_hw *hw,
				       u16 offset, u16 words, u16 *data)
{
260 261 262 263
	s32 status;

	if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM))
		return IXGBE_ERR_SWFW_SYNC;
264

265
	status = ixgbe_read_eerd_buffer_generic(hw, offset, words, data);
266 267 268 269 270

	hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
	return status;
}

271
/**
272 273 274 275
 *  ixgbe_write_eewr_X540 - Write EEPROM word using EEWR
 *  @hw: pointer to hardware structure
 *  @offset: offset of  word in the EEPROM to write
 *  @data: word write to the EEPROM
276
 *
277
 *  Write a 16 bit word to the EEPROM using the EEWR register.
278
 **/
D
Don Skidmore 已提交
279
static s32 ixgbe_write_eewr_X540(struct ixgbe_hw *hw, u16 offset, u16 data)
280
{
281 282 283 284
	s32 status;

	if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM))
		return IXGBE_ERR_SWFW_SYNC;
285

286
	status = ixgbe_write_eewr_generic(hw, offset, data);
287

288
	hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
289 290 291
	return status;
}

292 293 294 295 296 297 298 299 300 301 302 303
/**
 *  ixgbe_write_eewr_buffer_X540 - Write EEPROM word(s) using EEWR
 *  @hw: pointer to hardware structure
 *  @offset: offset of  word in the EEPROM to write
 *  @words: number of words
 *  @data: word(s) write to the EEPROM
 *
 *  Write a 16 bit word(s) to the EEPROM using the EEWR register.
 **/
static s32 ixgbe_write_eewr_buffer_X540(struct ixgbe_hw *hw,
					u16 offset, u16 words, u16 *data)
{
304
	s32 status;
305

306 307 308 309
	if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM))
		return IXGBE_ERR_SWFW_SYNC;

	status = ixgbe_write_eewr_buffer_generic(hw, offset, words, data);
310 311 312 313 314

	hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
	return status;
}

315
/**
316 317 318 319 320 321
 *  ixgbe_calc_eeprom_checksum_X540 - Calculates and returns the checksum
 *
 *  This function does not use synchronization for EERD and EEWR. It can
 *  be used internally by function which utilize ixgbe_acquire_swfw_sync_X540.
 *
 *  @hw: pointer to hardware structure
322
 **/
323
static s32 ixgbe_calc_eeprom_checksum_X540(struct ixgbe_hw *hw)
324 325 326 327 328 329 330
{
	u16 i;
	u16 j;
	u16 checksum = 0;
	u16 length = 0;
	u16 pointer = 0;
	u16 word = 0;
331 332
	u16 checksum_last_word = IXGBE_EEPROM_CHECKSUM;
	u16 ptr_start = IXGBE_PCIE_ANALOG_PTR;
333

334 335 336 337 338 339
	/*
	 * Do not use hw->eeprom.ops.read because we do not want to take
	 * the synchronization semaphores here. Instead use
	 * ixgbe_read_eerd_generic
	 */

340
	/* Include 0x0-0x3F in the checksum */
341 342
	for (i = 0; i < checksum_last_word; i++) {
		if (ixgbe_read_eerd_generic(hw, i, &word)) {
343
			hw_dbg(hw, "EEPROM read failed\n");
344
			return IXGBE_ERR_EEPROM;
345 346 347 348 349 350 351 352
		}
		checksum += word;
	}

	/*
	 * Include all data from pointers 0x3, 0x6-0xE.  This excludes the
	 * FW, PHY module, and PCIe Expansion/Option ROM pointers.
	 */
353
	for (i = ptr_start; i < IXGBE_FW_PTR; i++) {
354 355 356
		if (i == IXGBE_PHY_PTR || i == IXGBE_OPTION_ROM_PTR)
			continue;

357
		if (ixgbe_read_eerd_generic(hw, i, &pointer)) {
358 359 360 361 362 363 364 365 366
			hw_dbg(hw, "EEPROM read failed\n");
			break;
		}

		/* Skip pointer section if the pointer is invalid. */
		if (pointer == 0xFFFF || pointer == 0 ||
		    pointer >= hw->eeprom.word_size)
			continue;

367
		if (ixgbe_read_eerd_generic(hw, pointer, &length)) {
368
			hw_dbg(hw, "EEPROM read failed\n");
369
			return IXGBE_ERR_EEPROM;
370 371 372 373 374 375 376 377
			break;
		}

		/* Skip pointer section if length is invalid. */
		if (length == 0xFFFF || length == 0 ||
		    (pointer + length) >= hw->eeprom.word_size)
			continue;

378 379
		for (j = pointer + 1; j <= pointer + length; j++) {
			if (ixgbe_read_eerd_generic(hw, j, &word)) {
380
				hw_dbg(hw, "EEPROM read failed\n");
381
				return IXGBE_ERR_EEPROM;
382 383 384 385 386 387 388
			}
			checksum += word;
		}
	}

	checksum = (u16)IXGBE_EEPROM_SUM - checksum;

389
	return (s32)checksum;
390 391
}

392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
/**
 *  ixgbe_validate_eeprom_checksum_X540 - Validate EEPROM checksum
 *  @hw: pointer to hardware structure
 *  @checksum_val: calculated checksum
 *
 *  Performs checksum calculation and validates the EEPROM checksum.  If the
 *  caller does not need checksum_val, the value can be NULL.
 **/
static s32 ixgbe_validate_eeprom_checksum_X540(struct ixgbe_hw *hw,
					       u16 *checksum_val)
{
	s32 status;
	u16 checksum;
	u16 read_checksum = 0;

407
	/* Read the first word from the EEPROM. If this times out or fails, do
408 409 410 411
	 * not continue or we could be in for a very long wait while every
	 * EEPROM read fails
	 */
	status = hw->eeprom.ops.read(hw, 0, &checksum);
412
	if (status) {
413
		hw_dbg(hw, "EEPROM read failed\n");
414
		return status;
415 416
	}

417 418 419
	if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM))
		return IXGBE_ERR_SWFW_SYNC;

420 421 422 423 424
	status = hw->eeprom.ops.calc_checksum(hw);
	if (status < 0)
		goto out;

	checksum = (u16)(status & 0xffff);
425 426 427 428 429 430

	/* Do not use hw->eeprom.ops.read because we do not want to take
	 * the synchronization semaphores twice here.
	 */
	status = ixgbe_read_eerd_generic(hw, IXGBE_EEPROM_CHECKSUM,
					 &read_checksum);
431 432
	if (status)
		goto out;
433

434 435 436 437 438 439 440
	/* Verify read checksum from EEPROM is the same as
	 * calculated checksum
	 */
	if (read_checksum != checksum) {
		hw_dbg(hw, "Invalid EEPROM checksum");
		status = IXGBE_ERR_EEPROM_CHECKSUM;
	}
441 442 443 444 445

	/* If the user cares, return the calculated checksum */
	if (checksum_val)
		*checksum_val = checksum;

446 447
out:
	hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
448

449 450 451
	return status;
}

452 453 454 455 456 457 458 459
/**
 * ixgbe_update_eeprom_checksum_X540 - Updates the EEPROM checksum and flash
 * @hw: pointer to hardware structure
 *
 * After writing EEPROM to shadow RAM using EEWR register, software calculates
 * checksum and updates the EEPROM and instructs the hardware to update
 * the flash.
 **/
D
Don Skidmore 已提交
460
static s32 ixgbe_update_eeprom_checksum_X540(struct ixgbe_hw *hw)
461 462
{
	s32 status;
463
	u16 checksum;
464

465
	/* Read the first word from the EEPROM. If this times out or fails, do
466 467 468 469
	 * not continue or we could be in for a very long wait while every
	 * EEPROM read fails
	 */
	status = hw->eeprom.ops.read(hw, 0, &checksum);
470
	if (status) {
471
		hw_dbg(hw, "EEPROM read failed\n");
472 473
		return status;
	}
474

475 476
	if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM))
		return  IXGBE_ERR_SWFW_SYNC;
477

478 479 480 481 482
	status = hw->eeprom.ops.calc_checksum(hw);
	if (status < 0)
		goto out;

	checksum = (u16)(status & 0xffff);
483

484 485 486 487
	/* Do not use hw->eeprom.ops.write because we do not want to
	 * take the synchronization semaphores twice here.
	 */
	status = ixgbe_write_eewr_generic(hw, IXGBE_EEPROM_CHECKSUM, checksum);
488 489 490 491
	if (status)
		goto out;

	status = ixgbe_update_flash_X540(hw);
492

493
out:
494
	hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
495 496 497 498 499 500 501 502 503 504 505 506 507
	return status;
}

/**
 * ixgbe_update_flash_X540 - Instruct HW to copy EEPROM to Flash device
 * @hw: pointer to hardware structure
 *
 * Set FLUP (bit 23) of the EEC register to instruct Hardware to copy
 * EEPROM from shadow RAM to the flash device.
 **/
static s32 ixgbe_update_flash_X540(struct ixgbe_hw *hw)
{
	u32 flup;
508
	s32 status;
509 510 511 512

	status = ixgbe_poll_flash_update_done_X540(hw);
	if (status == IXGBE_ERR_EEPROM) {
		hw_dbg(hw, "Flash update time out\n");
513
		return status;
514 515
	}

516 517
	flup = IXGBE_READ_REG(hw, IXGBE_EEC(hw)) | IXGBE_EEC_FLUP;
	IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), flup);
518 519

	status = ixgbe_poll_flash_update_done_X540(hw);
E
Emil Tantilov 已提交
520
	if (status == 0)
521 522 523 524 525
		hw_dbg(hw, "Flash update complete\n");
	else
		hw_dbg(hw, "Flash update time out\n");

	if (hw->revision_id == 0) {
526
		flup = IXGBE_READ_REG(hw, IXGBE_EEC(hw));
527 528 529

		if (flup & IXGBE_EEC_SEC1VAL) {
			flup |= IXGBE_EEC_FLUP;
530
			IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), flup);
531 532 533
		}

		status = ixgbe_poll_flash_update_done_X540(hw);
E
Emil Tantilov 已提交
534
		if (status == 0)
535 536 537 538
			hw_dbg(hw, "Flash update complete\n");
		else
			hw_dbg(hw, "Flash update time out\n");
	}
539

540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
	return status;
}

/**
 * ixgbe_poll_flash_update_done_X540 - Poll flash update status
 * @hw: pointer to hardware structure
 *
 * Polls the FLUDONE (bit 26) of the EEC Register to determine when the
 * flash update is done.
 **/
static s32 ixgbe_poll_flash_update_done_X540(struct ixgbe_hw *hw)
{
	u32 i;
	u32 reg;

	for (i = 0; i < IXGBE_FLUDONE_ATTEMPTS; i++) {
556
		reg = IXGBE_READ_REG(hw, IXGBE_EEC(hw));
557 558
		if (reg & IXGBE_EEC_FLUDONE)
			return 0;
559 560
		udelay(5);
	}
561
	return IXGBE_ERR_EEPROM;
562 563 564 565 566 567 568 569 570 571
}

/**
 * ixgbe_acquire_swfw_sync_X540 - Acquire SWFW semaphore
 * @hw: pointer to hardware structure
 * @mask: Mask to specify which semaphore to acquire
 *
 * Acquires the SWFW semaphore thought the SW_FW_SYNC register for
 * the specified function (CSR, PHY0, PHY1, NVM, Flash)
 **/
572
s32 ixgbe_acquire_swfw_sync_X540(struct ixgbe_hw *hw, u32 mask)
573
{
M
Mark Rustad 已提交
574 575 576
	u32 swmask = mask & IXGBE_GSSR_NVM_PHY_MASK;
	u32 swi2c_mask = mask & IXGBE_GSSR_I2C_MASK;
	u32 fwmask = swmask << 5;
577
	u32 timeout = 200;
M
Mark Rustad 已提交
578 579
	u32 hwmask = 0;
	u32 swfw_sync;
580 581
	u32 i;

M
Mark Rustad 已提交
582
	if (swmask & IXGBE_GSSR_EEP_SM)
583 584
		hwmask = IXGBE_GSSR_FLASH_SM;

M
Mark Rustad 已提交
585 586 587 588 589 590
	/* SW only mask does not have FW bit pair */
	if (mask & IXGBE_GSSR_SW_MNG_SM)
		swmask |= IXGBE_GSSR_SW_MNG_SM;

	swmask |= swi2c_mask;
	fwmask |= swi2c_mask << 2;
591
	for (i = 0; i < timeout; i++) {
M
Mark Rustad 已提交
592
		/* SW NVM semaphore bit is used for access to all
593 594 595 596 597
		 * SW_FW_SYNC bits (not just NVM)
		 */
		if (ixgbe_get_swfw_sync_semaphore(hw))
			return IXGBE_ERR_SWFW_SYNC;

598
		swfw_sync = IXGBE_READ_REG(hw, IXGBE_SWFW_SYNC(hw));
599 600
		if (!(swfw_sync & (fwmask | swmask | hwmask))) {
			swfw_sync |= swmask;
601
			IXGBE_WRITE_REG(hw, IXGBE_SWFW_SYNC(hw), swfw_sync);
602
			ixgbe_release_swfw_sync_semaphore(hw);
M
Mark Rustad 已提交
603 604
			usleep_range(5000, 6000);
			return 0;
605
		}
M
Mark Rustad 已提交
606 607 608 609 610 611
		/* Firmware currently using resource (fwmask), hardware
		 * currently using resource (hwmask), or other software
		 * thread currently using resource (swmask)
		 */
		ixgbe_release_swfw_sync_semaphore(hw);
		usleep_range(5000, 10000);
612 613
	}

M
Mark Rustad 已提交
614 615 616 617 618
	/* Failed to get SW only semaphore */
	if (swmask == IXGBE_GSSR_SW_MNG_SM) {
		hw_dbg(hw, "Failed to get SW only semaphore\n");
		return IXGBE_ERR_SWFW_SYNC;
	}
619

M
Mark Rustad 已提交
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
	/* If the resource is not released by the FW/HW the SW can assume that
	 * the FW/HW malfunctions. In that case the SW should set the SW bit(s)
	 * of the requested resource(s) while ignoring the corresponding FW/HW
	 * bits in the SW_FW_SYNC register.
	 */
	if (ixgbe_get_swfw_sync_semaphore(hw))
		return IXGBE_ERR_SWFW_SYNC;
	swfw_sync = IXGBE_READ_REG(hw, IXGBE_SWFW_SYNC(hw));
	if (swfw_sync & (fwmask | hwmask)) {
		swfw_sync |= swmask;
		IXGBE_WRITE_REG(hw, IXGBE_SWFW_SYNC(hw), swfw_sync);
		ixgbe_release_swfw_sync_semaphore(hw);
		usleep_range(5000, 6000);
		return 0;
	}
	/* If the resource is not released by other SW the SW can assume that
	 * the other SW malfunctions. In that case the SW should clear all SW
	 * flags that it does not own and then repeat the whole process once
	 * again.
	 */
	if (swfw_sync & swmask) {
		u32 rmask = IXGBE_GSSR_EEP_SM | IXGBE_GSSR_PHY0_SM |
			    IXGBE_GSSR_PHY1_SM | IXGBE_GSSR_MAC_CSR_SM;

		if (swi2c_mask)
			rmask |= IXGBE_GSSR_I2C_MASK;
		ixgbe_release_swfw_sync_X540(hw, rmask);
		ixgbe_release_swfw_sync_semaphore(hw);
		return IXGBE_ERR_SWFW_SYNC;
649
	}
M
Mark Rustad 已提交
650
	ixgbe_release_swfw_sync_semaphore(hw);
651

M
Mark Rustad 已提交
652
	return IXGBE_ERR_SWFW_SYNC;
653 654 655 656 657 658 659
}

/**
 * ixgbe_release_swfw_sync_X540 - Release SWFW semaphore
 * @hw: pointer to hardware structure
 * @mask: Mask to specify which semaphore to release
 *
L
Lucas De Marchi 已提交
660
 * Releases the SWFW semaphore through the SW_FW_SYNC register
661 662
 * for the specified function (CSR, PHY0, PHY1, EVM, Flash)
 **/
663
void ixgbe_release_swfw_sync_X540(struct ixgbe_hw *hw, u32 mask)
664
{
M
Mark Rustad 已提交
665
	u32 swmask = mask & (IXGBE_GSSR_NVM_PHY_MASK | IXGBE_GSSR_SW_MNG_SM);
666 667
	u32 swfw_sync;

M
Mark Rustad 已提交
668 669
	if (mask & IXGBE_GSSR_I2C_MASK)
		swmask |= mask & IXGBE_GSSR_I2C_MASK;
670 671
	ixgbe_get_swfw_sync_semaphore(hw);

672
	swfw_sync = IXGBE_READ_REG(hw, IXGBE_SWFW_SYNC(hw));
673
	swfw_sync &= ~swmask;
674
	IXGBE_WRITE_REG(hw, IXGBE_SWFW_SYNC(hw), swfw_sync);
675 676

	ixgbe_release_swfw_sync_semaphore(hw);
M
Mark Rustad 已提交
677
	usleep_range(5000, 6000);
678 679 680
}

/**
681
 * ixgbe_get_swfw_sync_semaphore - Get hardware semaphore
682 683 684
 * @hw: pointer to hardware structure
 *
 * Sets the hardware semaphores so SW/FW can gain control of shared resources
685
 */
686 687 688 689 690 691 692 693
static s32 ixgbe_get_swfw_sync_semaphore(struct ixgbe_hw *hw)
{
	u32 timeout = 2000;
	u32 i;
	u32 swsm;

	/* Get SMBI software semaphore between device drivers first */
	for (i = 0; i < timeout; i++) {
694
		/* If the SMBI bit is 0 when we read it, then the bit will be
695 696
		 * set and we have the semaphore
		 */
697
		swsm = IXGBE_READ_REG(hw, IXGBE_SWSM(hw));
698
		if (!(swsm & IXGBE_SWSM_SMBI))
699
			break;
700
		usleep_range(50, 100);
701 702
	}

703 704 705 706 707 708
	if (i == timeout) {
		hw_dbg(hw,
		       "Software semaphore SMBI between device drivers not granted.\n");
		return IXGBE_ERR_EEPROM;
	}

709
	/* Now get the semaphore between SW/FW through the REGSMP bit */
710
	for (i = 0; i < timeout; i++) {
711
		swsm = IXGBE_READ_REG(hw, IXGBE_SWFW_SYNC(hw));
712 713
		if (!(swsm & IXGBE_SWFW_REGSMP))
			return 0;
714

715
		usleep_range(50, 100);
716 717
	}

718 719 720 721 722
	/* Release semaphores and return error if SW NVM semaphore
	 * was not granted because we do not have access to the EEPROM
	 */
	hw_dbg(hw, "REGSMP Software NVM semaphore not granted\n");
	ixgbe_release_swfw_sync_semaphore(hw);
723
	return IXGBE_ERR_EEPROM;
724 725 726 727 728 729 730 731 732 733 734 735 736 737
}

/**
 * ixgbe_release_nvm_semaphore - Release hardware semaphore
 * @hw: pointer to hardware structure
 *
 * This function clears hardware semaphore bits.
 **/
static void ixgbe_release_swfw_sync_semaphore(struct ixgbe_hw *hw)
{
	 u32 swsm;

	/* Release both semaphores by writing 0 to the bits REGSMP and SMBI */

738
	swsm = IXGBE_READ_REG(hw, IXGBE_SWFW_SYNC(hw));
739
	swsm &= ~IXGBE_SWFW_REGSMP;
740
	IXGBE_WRITE_REG(hw, IXGBE_SWFW_SYNC(hw), swsm);
741

742
	swsm = IXGBE_READ_REG(hw, IXGBE_SWSM(hw));
743
	swsm &= ~IXGBE_SWSM_SMBI;
744
	IXGBE_WRITE_REG(hw, IXGBE_SWSM(hw), swsm);
745

746 747 748
	IXGBE_WRITE_FLUSH(hw);
}

749 750 751 752 753 754 755 756
/**
 * ixgbe_blink_led_start_X540 - Blink LED based on index.
 * @hw: pointer to hardware structure
 * @index: led number to blink
 *
 * Devices that implement the version 2 interface:
 *   X540
 **/
757
s32 ixgbe_blink_led_start_X540(struct ixgbe_hw *hw, u32 index)
758 759 760
{
	u32 macc_reg;
	u32 ledctl_reg;
761 762
	ixgbe_link_speed speed;
	bool link_up;
763 764

	/*
765 766 767
	 * Link should be up in order for the blink bit in the LED control
	 * register to work. Force link and speed in the MAC if link is down.
	 * This will be reversed when we stop the blinking.
768
	 */
769
	hw->mac.ops.check_link(hw, &speed, &link_up, false);
770
	if (!link_up) {
771 772 773 774
		macc_reg = IXGBE_READ_REG(hw, IXGBE_MACC);
		macc_reg |= IXGBE_MACC_FLU | IXGBE_MACC_FSV_10G | IXGBE_MACC_FS;
		IXGBE_WRITE_REG(hw, IXGBE_MACC, macc_reg);
	}
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
	/* Set the LED to LINK_UP + BLINK. */
	ledctl_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
	ledctl_reg &= ~IXGBE_LED_MODE_MASK(index);
	ledctl_reg |= IXGBE_LED_BLINK(index);
	IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, ledctl_reg);
	IXGBE_WRITE_FLUSH(hw);

	return 0;
}

/**
 * ixgbe_blink_led_stop_X540 - Stop blinking LED based on index.
 * @hw: pointer to hardware structure
 * @index: led number to stop blinking
 *
 * Devices that implement the version 2 interface:
 *   X540
 **/
793
s32 ixgbe_blink_led_stop_X540(struct ixgbe_hw *hw, u32 index)
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
{
	u32 macc_reg;
	u32 ledctl_reg;

	/* Restore the LED to its default value. */
	ledctl_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
	ledctl_reg &= ~IXGBE_LED_MODE_MASK(index);
	ledctl_reg |= IXGBE_LED_LINK_ACTIVE << IXGBE_LED_MODE_SHIFT(index);
	ledctl_reg &= ~IXGBE_LED_BLINK(index);
	IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, ledctl_reg);

	/* Unforce link and speed in the MAC. */
	macc_reg = IXGBE_READ_REG(hw, IXGBE_MACC);
	macc_reg &= ~(IXGBE_MACC_FLU | IXGBE_MACC_FSV_10G | IXGBE_MACC_FS);
	IXGBE_WRITE_REG(hw, IXGBE_MACC, macc_reg);
	IXGBE_WRITE_FLUSH(hw);

	return 0;
}
813
static const struct ixgbe_mac_operations mac_ops_X540 = {
814 815
	.init_hw                = &ixgbe_init_hw_generic,
	.reset_hw               = &ixgbe_reset_hw_X540,
816
	.start_hw               = &ixgbe_start_hw_X540,
817 818 819 820 821
	.clear_hw_cntrs         = &ixgbe_clear_hw_cntrs_generic,
	.get_media_type         = &ixgbe_get_media_type_X540,
	.enable_rx_dma          = &ixgbe_enable_rx_dma_generic,
	.get_mac_addr           = &ixgbe_get_mac_addr_generic,
	.get_san_mac_addr       = &ixgbe_get_san_mac_addr_generic,
822
	.get_device_caps        = &ixgbe_get_device_caps_generic,
823 824 825 826 827 828 829
	.get_wwn_prefix         = &ixgbe_get_wwn_prefix_generic,
	.stop_adapter           = &ixgbe_stop_adapter_generic,
	.get_bus_info           = &ixgbe_get_bus_info_generic,
	.set_lan_id             = &ixgbe_set_lan_id_multi_port_pcie,
	.read_analog_reg8       = NULL,
	.write_analog_reg8      = NULL,
	.setup_link             = &ixgbe_setup_mac_link_X540,
830
	.set_rxpba		= &ixgbe_set_rxpba_generic,
831 832 833 834
	.check_link             = &ixgbe_check_mac_link_generic,
	.get_link_capabilities  = &ixgbe_get_copper_link_capabilities_generic,
	.led_on                 = &ixgbe_led_on_generic,
	.led_off                = &ixgbe_led_off_generic,
835 836
	.blink_led_start        = &ixgbe_blink_led_start_X540,
	.blink_led_stop         = &ixgbe_blink_led_stop_X540,
837 838 839
	.set_rar                = &ixgbe_set_rar_generic,
	.clear_rar              = &ixgbe_clear_rar_generic,
	.set_vmdq               = &ixgbe_set_vmdq_generic,
840
	.set_vmdq_san_mac	= &ixgbe_set_vmdq_san_mac_generic,
841 842 843 844 845 846 847 848
	.clear_vmdq             = &ixgbe_clear_vmdq_generic,
	.init_rx_addrs          = &ixgbe_init_rx_addrs_generic,
	.update_mc_addr_list    = &ixgbe_update_mc_addr_list_generic,
	.enable_mc              = &ixgbe_enable_mc_generic,
	.disable_mc             = &ixgbe_disable_mc_generic,
	.clear_vfta             = &ixgbe_clear_vfta_generic,
	.set_vfta               = &ixgbe_set_vfta_generic,
	.fc_enable              = &ixgbe_fc_enable_generic,
E
Emil Tantilov 已提交
849
	.set_fw_drv_ver         = &ixgbe_set_fw_drv_ver_generic,
850 851
	.init_uta_tables        = &ixgbe_init_uta_tables_generic,
	.setup_sfp              = NULL,
852 853
	.set_mac_anti_spoofing  = &ixgbe_set_mac_anti_spoofing,
	.set_vlan_anti_spoofing = &ixgbe_set_vlan_anti_spoofing,
854 855
	.acquire_swfw_sync      = &ixgbe_acquire_swfw_sync_X540,
	.release_swfw_sync      = &ixgbe_release_swfw_sync_X540,
856 857
	.disable_rx_buff	= &ixgbe_disable_rx_buff_generic,
	.enable_rx_buff		= &ixgbe_enable_rx_buff_generic,
858 859
	.get_thermal_sensor_data = NULL,
	.init_thermal_sensor_thresh = NULL,
860 861
	.prot_autoc_read	= &prot_autoc_read_generic,
	.prot_autoc_write	= &prot_autoc_write_generic,
862 863
	.enable_rx		= &ixgbe_enable_rx_generic,
	.disable_rx		= &ixgbe_disable_rx_generic,
864 865
};

866
static const struct ixgbe_eeprom_operations eeprom_ops_X540 = {
867 868
	.init_params            = &ixgbe_init_eeprom_params_X540,
	.read                   = &ixgbe_read_eerd_X540,
869
	.read_buffer		= &ixgbe_read_eerd_buffer_X540,
870
	.write                  = &ixgbe_write_eewr_X540,
871
	.write_buffer		= &ixgbe_write_eewr_buffer_X540,
872
	.calc_checksum		= &ixgbe_calc_eeprom_checksum_X540,
873
	.validate_checksum      = &ixgbe_validate_eeprom_checksum_X540,
874 875 876
	.update_checksum        = &ixgbe_update_eeprom_checksum_X540,
};

877
static const struct ixgbe_phy_operations phy_ops_X540 = {
878 879 880
	.identify               = &ixgbe_identify_phy_generic,
	.identify_sfp           = &ixgbe_identify_sfp_module_generic,
	.init			= NULL,
881
	.reset                  = NULL,
882 883 884 885 886 887
	.read_reg               = &ixgbe_read_phy_reg_generic,
	.write_reg              = &ixgbe_write_phy_reg_generic,
	.setup_link             = &ixgbe_setup_phy_link_generic,
	.setup_link_speed       = &ixgbe_setup_phy_link_speed_generic,
	.read_i2c_byte          = &ixgbe_read_i2c_byte_generic,
	.write_i2c_byte         = &ixgbe_write_i2c_byte_generic,
888
	.read_i2c_sff8472	= &ixgbe_read_i2c_sff8472_generic,
889 890 891
	.read_i2c_eeprom        = &ixgbe_read_i2c_eeprom_generic,
	.write_i2c_eeprom       = &ixgbe_write_i2c_eeprom_generic,
	.check_overtemp         = &ixgbe_tn_check_overtemp,
892
	.set_phy_power          = &ixgbe_set_copper_phy_power,
893
	.get_firmware_version   = &ixgbe_get_phy_firmware_version_generic,
894 895
};

896 897 898 899
static const u32 ixgbe_mvals_X540[IXGBE_MVALS_IDX_LIMIT] = {
	IXGBE_MVALS_INIT(X540)
};

900
const struct ixgbe_info ixgbe_X540_info = {
901 902 903 904 905 906
	.mac                    = ixgbe_mac_X540,
	.get_invariants         = &ixgbe_get_invariants_X540,
	.mac_ops                = &mac_ops_X540,
	.eeprom_ops             = &eeprom_ops_X540,
	.phy_ops                = &phy_ops_X540,
	.mbx_ops                = &mbx_ops_generic,
907
	.mvals			= ixgbe_mvals_X540,
908
};