1

/* Intel PRO/1000 Linux driver

     2

 * Copyright(c) 1999 - 2014 Intel Corporation.

     3

 *

     4

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

     5

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

     6

 * version 2, as published by the Free Software Foundation.

     7

 *

     8

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

     9

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10

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

    11

 * more details.

    12

 *

    13

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

    14

 * the file called "COPYING".

    15

 *

    16

 * Contact Information:

    17

 * Linux NICS <linux.nics@intel.com>

    18

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

    19

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

    20

 */

    21

    22

#include "e1000-3.16-ethercat.h"

    23

    24

/**

    25

 *  e1000_calculate_checksum - Calculate checksum for buffer

    26

 *  @buffer: pointer to EEPROM

    27

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

    28

 *

    29

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

    30

 *  checksum calculated is returned.

    31

 **/

    32

static u8 e1000_calculate_checksum(u8 *buffer, u32 length)

    33

{

    34

	u32 i;

    35

	u8 sum = 0;

    36

    37

	if (!buffer)

    38

		return 0;

    39

    40

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

    41

		sum += buffer[i];

    42

    43

	return (u8)(0 - sum);

    44

}

    45

    46

/**

    47

 *  e1000_mng_enable_host_if - Checks host interface is enabled

    48

 *  @hw: pointer to the HW structure

    49

 *

    50

 *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND

    51

 *

    52

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

    53

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

    54

 *  in case of previous command is not completed.

    55

 **/

    56

static s32 e1000_mng_enable_host_if(struct e1000_hw *hw)

    57

{

    58

	u32 hicr;

    59

	u8 i;

    60

    61

	if (!hw->mac.arc_subsystem_valid) {

    62

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

    63

		return -E1000_ERR_HOST_INTERFACE_COMMAND;

    64

	}

    65

    66

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

    67

	hicr = er32(HICR);

    68

	if (!(hicr & E1000_HICR_EN)) {

    69

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

    70

		return -E1000_ERR_HOST_INTERFACE_COMMAND;

    71

	}

    72

	/* check the previous command is completed */

    73

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

    74

		hicr = er32(HICR);

    75

		if (!(hicr & E1000_HICR_C))

    76

			break;

    77

		mdelay(1);

    78

	}

    79

    80

	if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) {

    81

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

    82

		return -E1000_ERR_HOST_INTERFACE_COMMAND;

    83

	}

    84

    85

	return 0;

    86

}

    87

    88

/**

    89

 *  e1000e_check_mng_mode_generic - Generic check management mode

    90

 *  @hw: pointer to the HW structure

    91

 *

    92

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

    93

 *  manageability is enabled, else false (0).

    94

 **/

    95

bool e1000e_check_mng_mode_generic(struct e1000_hw *hw)

    96

{

    97

	u32 fwsm = er32(FWSM);

    98

    99

	return (fwsm & E1000_FWSM_MODE_MASK) ==

   100

	    (E1000_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT);

   101

}

   102

   103

/**

   104

 *  e1000e_enable_tx_pkt_filtering - Enable packet filtering on Tx

   105

 *  @hw: pointer to the HW structure

   106

 *

   107

 *  Enables packet filtering on transmit packets if manageability is enabled

   108

 *  and host interface is enabled.

   109

 **/

   110

bool e1000e_enable_tx_pkt_filtering(struct e1000_hw *hw)

   111

{

   112

	struct e1000_host_mng_dhcp_cookie *hdr = &hw->mng_cookie;

   113

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

   114

	u32 offset;

   115

	s32 ret_val, hdr_csum, csum;

   116

	u8 i, len;

   117

   118

	hw->mac.tx_pkt_filtering = true;

   119

   120

	/* No manageability, no filtering */

   121

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

   122

		hw->mac.tx_pkt_filtering = false;

   123

		return hw->mac.tx_pkt_filtering;

   124

	}

   125

   126

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

   127

	 * reason, disable filtering.

   128

	 */

   129

	ret_val = e1000_mng_enable_host_if(hw);

   130

	if (ret_val) {

   131

		hw->mac.tx_pkt_filtering = false;

   132

		return hw->mac.tx_pkt_filtering;

   133

	}

   134

   135

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

   136

	len = E1000_MNG_DHCP_COOKIE_LENGTH >> 2;

   137

	offset = E1000_MNG_DHCP_COOKIE_OFFSET >> 2;

   138

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

   139

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

   140

						     offset + i);

   141

	hdr_csum = hdr->checksum;

   142

	hdr->checksum = 0;

   143

	csum = e1000_calculate_checksum((u8 *)hdr,

   144

					E1000_MNG_DHCP_COOKIE_LENGTH);

   145

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

   146

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

   147

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

   148

	 */

   149

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

   150

		hw->mac.tx_pkt_filtering = true;

   151

		return hw->mac.tx_pkt_filtering;

   152

	}

   153

   154

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

   155

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

   156

		hw->mac.tx_pkt_filtering = false;

   157

   158

	return hw->mac.tx_pkt_filtering;

   159

}

   160

   161

/**

   162

 *  e1000_mng_write_cmd_header - Writes manageability command header

   163

 *  @hw: pointer to the HW structure

   164

 *  @hdr: pointer to the host interface command header

   165

 *

   166

 *  Writes the command header after does the checksum calculation.

   167

 **/

   168

static s32 e1000_mng_write_cmd_header(struct e1000_hw *hw,

   169

				      struct e1000_host_mng_command_header *hdr)

   170

{

   171

	u16 i, length = sizeof(struct e1000_host_mng_command_header);

   172

   173

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

   174

   175

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

   176

   177

	length >>= 2;

   178

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

   179

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

   180

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

   181

		e1e_flush();

   182

	}

   183

   184

	return 0;

   185

}

   186

   187

/**

   188

 *  e1000_mng_host_if_write - Write to the manageability host interface

   189

 *  @hw: pointer to the HW structure

   190

 *  @buffer: pointer to the host interface buffer

   191

 *  @length: size of the buffer

   192

 *  @offset: location in the buffer to write to

   193

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

   194

 *

   195

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

   196

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

   197

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

   198

 **/

   199

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

   200

				   u16 length, u16 offset, u8 *sum)

   201

{

   202

	u8 *tmp;

   203

	u8 *bufptr = buffer;

   204

	u32 data = 0;

   205

	u16 remaining, i, j, prev_bytes;

   206

   207

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

   208

   209

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

   210

		return -E1000_ERR_PARAM;

   211

   212

	tmp = (u8 *)&data;

   213

	prev_bytes = offset & 0x3;

   214

	offset >>= 2;

   215

   216

	if (prev_bytes) {

   217

		data = E1000_READ_REG_ARRAY(hw, E1000_HOST_IF, offset);

   218

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

   219

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

   220

			*sum += *(tmp + j);

   221

		}

   222

		E1000_WRITE_REG_ARRAY(hw, E1000_HOST_IF, offset, data);

   223

		length -= j - prev_bytes;

   224

		offset++;

   225

	}

   226

   227

	remaining = length & 0x3;

   228

	length -= remaining;

   229

   230

	/* Calculate length in DWORDs */

   231

	length >>= 2;

   232

   233

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

   234

	 * ram area.

   235

	 */

   236

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

   237

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

   238

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

   239

			*sum += *(tmp + j);

   240

		}

   241

   242

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

   243

	}

   244

	if (remaining) {

   245

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

   246

			if (j < remaining)

   247

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

   248

			else

   249

				*(tmp + j) = 0;

   250

   251

			*sum += *(tmp + j);

   252

		}

   253

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

   254

	}

   255

   256

	return 0;

   257

}

   258

   259

/**

   260

 *  e1000e_mng_write_dhcp_info - Writes DHCP info to host interface

   261

 *  @hw: pointer to the HW structure

   262

 *  @buffer: pointer to the host interface

   263

 *  @length: size of the buffer

   264

 *

   265

 *  Writes the DHCP information to the host interface.

   266

 **/

   267

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

   268

{

   269

	struct e1000_host_mng_command_header hdr;

   270

	s32 ret_val;

   271

	u32 hicr;

   272

   273

	hdr.command_id = E1000_MNG_DHCP_TX_PAYLOAD_CMD;

   274

	hdr.command_length = length;

   275

	hdr.reserved1 = 0;

   276

	hdr.reserved2 = 0;

   277

	hdr.checksum = 0;

   278

   279

	/* Enable the host interface */

   280

	ret_val = e1000_mng_enable_host_if(hw);

   281

	if (ret_val)

   282

		return ret_val;

   283

   284

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

   285

	ret_val = e1000_mng_host_if_write(hw, buffer, length,

   286

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

   287

	if (ret_val)

   288

		return ret_val;

   289

   290

	/* Write the manageability command header */

   291

	ret_val = e1000_mng_write_cmd_header(hw, &hdr);

   292

	if (ret_val)

   293

		return ret_val;

   294

   295

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

   296

	hicr = er32(HICR);

   297

	ew32(HICR, hicr | E1000_HICR_C);

   298

   299

	return 0;

   300

}

   301

   302

/**

   303

 *  e1000e_enable_mng_pass_thru - Check if management passthrough is needed

   304

 *  @hw: pointer to the HW structure

   305

 *

   306

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

   307

 *  be directed to and from the management interface.

   308

 **/

   309

bool e1000e_enable_mng_pass_thru(struct e1000_hw *hw)

   310

{

   311

	u32 manc;

   312

	u32 fwsm, factps;

   313

   314

	manc = er32(MANC);

   315

   316

	if (!(manc & E1000_MANC_RCV_TCO_EN))

   317

		return false;

   318

   319

	if (hw->mac.has_fwsm) {

   320

		fwsm = er32(FWSM);

   321

		factps = er32(FACTPS);

   322

   323

		if (!(factps & E1000_FACTPS_MNGCG) &&

   324

		    ((fwsm & E1000_FWSM_MODE_MASK) ==

   325

		     (e1000_mng_mode_pt << E1000_FWSM_MODE_SHIFT)))

   326

			return true;

   327

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

   328

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

   329

		u16 data;

   330

   331

		factps = er32(FACTPS);

   332

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

   333

   334

		if (!(factps & E1000_FACTPS_MNGCG) &&

   335

		    ((data & E1000_NVM_INIT_CTRL2_MNGM) ==

   336

		     (e1000_mng_mode_pt << 13)))

   337

			return true;

   338

	} else if ((manc & E1000_MANC_SMBUS_EN) &&

   339

		   !(manc & E1000_MANC_ASF_EN)) {

   340

		return true;

   341

	}

   342

   343

	return false;

   344

}