1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2013 Intel Corporation.

     5

     6

  This program is free software; you can redistribute it and/or modify it

     7

  under the terms and conditions of the GNU General Public License,

     8

  version 2, as published by the Free Software Foundation.

     9

    10

  This program is distributed in the hope it will be useful, but WITHOUT

    11

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12

  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

    13

  more details.

    14

    15

  You should have received a copy of the GNU General Public License along with

    16

  this program; if not, write to the Free Software Foundation, Inc.,

    17

  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

    18

    19

  The full GNU General Public License is included in this distribution in

    20

  the file called "COPYING".

    21

    22

  Contact Information:

    23

  Linux NICS <linux.nics@intel.com>

    24

  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>

    25

  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

    26

    27

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

    28

    29

#include "e1000.h"

    30

    31

/**

    32

 *  e1000_calculate_checksum - Calculate checksum for buffer

    33

 *  @buffer: pointer to EEPROM

    34

 *  @length: size of EEPROM to calculate a checksum for

    35

 *

    36

 *  Calculates the checksum for some buffer on a specified length.  The

    37

 *  checksum calculated is returned.

    38

 **/

    39

static u8 e1000_calculate_checksum(u8 *buffer, u32 length)

    40

{

    41

	u32 i;

    42

	u8 sum = 0;

    43

    44

	if (!buffer)

    45

		return 0;

    46

    47

	for (i = 0; i < length; i++)

    48

		sum += buffer[i];

    49

    50

	return (u8)(0 - sum);

    51

}

    52

    53

/**

    54

 *  e1000_mng_enable_host_if - Checks host interface is enabled

    55

 *  @hw: pointer to the HW structure

    56

 *

    57

 *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND

    58

 *

    59

 *  This function checks whether the HOST IF is enabled for command operation

    60

 *  and also checks whether the previous command is completed.  It busy waits

    61

 *  in case of previous command is not completed.

    62

 **/

    63

static s32 e1000_mng_enable_host_if(struct e1000_hw *hw)

    64

{

    65

	u32 hicr;

    66

	u8 i;

    67

    68

	if (!hw->mac.arc_subsystem_valid) {

    69

		e_dbg("ARC subsystem not valid.\n");

    70

		return -E1000_ERR_HOST_INTERFACE_COMMAND;

    71

	}

    72

    73

	/* Check that the host interface is enabled. */

    74

	hicr = er32(HICR);

    75

	if (!(hicr & E1000_HICR_EN)) {

    76

		e_dbg("E1000_HOST_EN bit disabled.\n");

    77

		return -E1000_ERR_HOST_INTERFACE_COMMAND;

    78

	}

    79

	/* check the previous command is completed */

    80

	for (i = 0; i < E1000_MNG_DHCP_COMMAND_TIMEOUT; i++) {

    81

		hicr = er32(HICR);

    82

		if (!(hicr & E1000_HICR_C))

    83

			break;

    84

		mdelay(1);

    85

	}

    86

    87

	if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) {

    88

		e_dbg("Previous command timeout failed .\n");

    89

		return -E1000_ERR_HOST_INTERFACE_COMMAND;

    90

	}

    91

    92

	return 0;

    93

}

    94

    95

/**

    96

 *  e1000e_check_mng_mode_generic - Generic check management mode

    97

 *  @hw: pointer to the HW structure

    98

 *

    99

 *  Reads the firmware semaphore register and returns true (>0) if

   100

 *  manageability is enabled, else false (0).

   101

 **/

   102

bool e1000e_check_mng_mode_generic(struct e1000_hw *hw)

   103

{

   104

	u32 fwsm = er32(FWSM);

   105

   106

	return (fwsm & E1000_FWSM_MODE_MASK) ==

   107

	    (E1000_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT);

   108

}

   109

   110

/**

   111

 *  e1000e_enable_tx_pkt_filtering - Enable packet filtering on Tx

   112

 *  @hw: pointer to the HW structure

   113

 *

   114

 *  Enables packet filtering on transmit packets if manageability is enabled

   115

 *  and host interface is enabled.

   116

 **/

   117

bool e1000e_enable_tx_pkt_filtering(struct e1000_hw *hw)

   118

{

   119

	struct e1000_host_mng_dhcp_cookie *hdr = &hw->mng_cookie;

   120

	u32 *buffer = (u32 *)&hw->mng_cookie;

   121

	u32 offset;

   122

	s32 ret_val, hdr_csum, csum;

   123

	u8 i, len;

   124

   125

	hw->mac.tx_pkt_filtering = true;

   126

   127

	/* No manageability, no filtering */

   128

	if (!hw->mac.ops.check_mng_mode(hw)) {

   129

		hw->mac.tx_pkt_filtering = false;

   130

		return hw->mac.tx_pkt_filtering;

   131

	}

   132

   133

	/* If we can't read from the host interface for whatever

   134

	 * reason, disable filtering.

   135

	 */

   136

	ret_val = e1000_mng_enable_host_if(hw);

   137

	if (ret_val) {

   138

		hw->mac.tx_pkt_filtering = false;

   139

		return hw->mac.tx_pkt_filtering;

   140

	}

   141

   142

	/* Read in the header.  Length and offset are in dwords. */

   143

	len = E1000_MNG_DHCP_COOKIE_LENGTH >> 2;

   144

	offset = E1000_MNG_DHCP_COOKIE_OFFSET >> 2;

   145

	for (i = 0; i < len; i++)

   146

		*(buffer + i) = E1000_READ_REG_ARRAY(hw, E1000_HOST_IF,

   147

						     offset + i);

   148

	hdr_csum = hdr->checksum;

   149

	hdr->checksum = 0;

   150

	csum = e1000_calculate_checksum((u8 *)hdr,

   151

					E1000_MNG_DHCP_COOKIE_LENGTH);

   152

	/* If either the checksums or signature don't match, then

   153

	 * the cookie area isn't considered valid, in which case we

   154

	 * take the safe route of assuming Tx filtering is enabled.

   155

	 */

   156

	if ((hdr_csum != csum) || (hdr->signature != E1000_IAMT_SIGNATURE)) {

   157

		hw->mac.tx_pkt_filtering = true;

   158

		return hw->mac.tx_pkt_filtering;

   159

	}

   160

   161

	/* Cookie area is valid, make the final check for filtering. */

   162

	if (!(hdr->status & E1000_MNG_DHCP_COOKIE_STATUS_PARSING))

   163

		hw->mac.tx_pkt_filtering = false;

   164

   165

	return hw->mac.tx_pkt_filtering;

   166

}

   167

   168

/**

   169

 *  e1000_mng_write_cmd_header - Writes manageability command header

   170

 *  @hw: pointer to the HW structure

   171

 *  @hdr: pointer to the host interface command header

   172

 *

   173

 *  Writes the command header after does the checksum calculation.

   174

 **/

   175

static s32 e1000_mng_write_cmd_header(struct e1000_hw *hw,

   176

				      struct e1000_host_mng_command_header *hdr)

   177

{

   178

	u16 i, length = sizeof(struct e1000_host_mng_command_header);

   179

   180

	/* Write the whole command header structure with new checksum. */

   181

   182

	hdr->checksum = e1000_calculate_checksum((u8 *)hdr, length);

   183

   184

	length >>= 2;

   185

	/* Write the relevant command block into the ram area. */

   186

	for (i = 0; i < length; i++) {

   187

		E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, i, *((u32 *)hdr + i));

   188

		e1e_flush();

   189

	}

   190

   191

	return 0;

   192

}

   193

   194

/**

   195

 *  e1000_mng_host_if_write - Write to the manageability host interface

   196

 *  @hw: pointer to the HW structure

   197

 *  @buffer: pointer to the host interface buffer

   198

 *  @length: size of the buffer

   199

 *  @offset: location in the buffer to write to

   200

 *  @sum: sum of the data (not checksum)

   201

 *

   202

 *  This function writes the buffer content at the offset given on the host if.

   203

 *  It also does alignment considerations to do the writes in most efficient

   204

 *  way.  Also fills up the sum of the buffer in *buffer parameter.

   205

 **/

   206

static s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer,

   207

				   u16 length, u16 offset, u8 *sum)

   208

{

   209

	u8 *tmp;

   210

	u8 *bufptr = buffer;

   211

	u32 data = 0;

   212

	u16 remaining, i, j, prev_bytes;

   213

   214

	/* sum = only sum of the data and it is not checksum */

   215

   216

	if (length == 0 || offset + length > E1000_HI_MAX_MNG_DATA_LENGTH)

   217

		return -E1000_ERR_PARAM;

   218

   219

	tmp = (u8 *)&data;

   220

	prev_bytes = offset & 0x3;

   221

	offset >>= 2;

   222

   223

	if (prev_bytes) {

   224

		data = E1000_READ_REG_ARRAY(hw, E1000_HOST_IF, offset);

   225

		for (j = prev_bytes; j < sizeof(u32); j++) {

   226

			*(tmp + j) = *bufptr++;

   227

			*sum += *(tmp + j);

   228

		}

   229

		E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset, data);

   230

		length -= j - prev_bytes;

   231

		offset++;

   232

	}

   233

   234

	remaining = length & 0x3;

   235

	length -= remaining;

   236

   237

	/* Calculate length in DWORDs */

   238

	length >>= 2;

   239

   240

	/* The device driver writes the relevant command block into the

   241

	 * ram area.

   242

	 */

   243

	for (i = 0; i < length; i++) {

   244

		for (j = 0; j < sizeof(u32); j++) {

   245

			*(tmp + j) = *bufptr++;

   246

			*sum += *(tmp + j);

   247

		}

   248

   249

		E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset + i, data);

   250

	}

   251

	if (remaining) {

   252

		for (j = 0; j < sizeof(u32); j++) {

   253

			if (j < remaining)

   254

				*(tmp + j) = *bufptr++;

   255

			else

   256

				*(tmp + j) = 0;

   257

   258

			*sum += *(tmp + j);

   259

		}

   260

		E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset + i, data);

   261

	}

   262

   263

	return 0;

   264

}

   265

   266

/**

   267

 *  e1000e_mng_write_dhcp_info - Writes DHCP info to host interface

   268

 *  @hw: pointer to the HW structure

   269

 *  @buffer: pointer to the host interface

   270

 *  @length: size of the buffer

   271

 *

   272

 *  Writes the DHCP information to the host interface.

   273

 **/

   274

s32 e1000e_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length)

   275

{

   276

	struct e1000_host_mng_command_header hdr;

   277

	s32 ret_val;

   278

	u32 hicr;

   279

   280

	hdr.command_id = E1000_MNG_DHCP_TX_PAYLOAD_CMD;

   281

	hdr.command_length = length;

   282

	hdr.reserved1 = 0;

   283

	hdr.reserved2 = 0;

   284

	hdr.checksum = 0;

   285

   286

	/* Enable the host interface */

   287

	ret_val = e1000_mng_enable_host_if(hw);

   288

	if (ret_val)

   289

		return ret_val;

   290

   291

	/* Populate the host interface with the contents of "buffer". */

   292

	ret_val = e1000_mng_host_if_write(hw, buffer, length,

   293

					  sizeof(hdr), &(hdr.checksum));

   294

	if (ret_val)

   295

		return ret_val;

   296

   297

	/* Write the manageability command header */

   298

	ret_val = e1000_mng_write_cmd_header(hw, &hdr);

   299

	if (ret_val)

   300

		return ret_val;

   301

   302

	/* Tell the ARC a new command is pending. */

   303

	hicr = er32(HICR);

   304

	ew32(HICR, hicr | E1000_HICR_C);

   305

   306

	return 0;

   307

}

   308

   309

/**

   310

 *  e1000e_enable_mng_pass_thru - Check if management passthrough is needed

   311

 *  @hw: pointer to the HW structure

   312

 *

   313

 *  Verifies the hardware needs to leave interface enabled so that frames can

   314

 *  be directed to and from the management interface.

   315

 **/

   316

bool e1000e_enable_mng_pass_thru(struct e1000_hw *hw)

   317

{

   318

	u32 manc;

   319

	u32 fwsm, factps;

   320

   321

	manc = er32(MANC);

   322

   323

	if (!(manc & E1000_MANC_RCV_TCO_EN))

   324

		return false;

   325

   326

	if (hw->mac.has_fwsm) {

   327

		fwsm = er32(FWSM);

   328

		factps = er32(FACTPS);

   329

   330

		if (!(factps & E1000_FACTPS_MNGCG) &&

   331

		    ((fwsm & E1000_FWSM_MODE_MASK) ==

   332

		     (e1000_mng_mode_pt << E1000_FWSM_MODE_SHIFT)))

   333

			return true;

   334

	} else if ((hw->mac.type == e1000_82574) ||

   335

		   (hw->mac.type == e1000_82583)) {

   336

		u16 data;

   337

   338

		factps = er32(FACTPS);

   339

		e1000_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &data);

   340

   341

		if (!(factps & E1000_FACTPS_MNGCG) &&

   342

		    ((data & E1000_NVM_INIT_CTRL2_MNGM) ==

   343

		     (e1000_mng_mode_pt << 13)))

   344

			return true;

   345

	} else if ((manc & E1000_MANC_SMBUS_EN) &&

   346

		   !(manc & E1000_MANC_ASF_EN)) {

   347

		return true;

   348

	}

   349

   350

	return false;

   351

}