1

/* Intel(R) Gigabit Ethernet Linux driver

     2

 * Copyright(c) 2007-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

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

    14

 * this program; if not, see <http://www.gnu.org/licenses/>.

    15

 *

    16

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

    17

 * the file called "COPYING".

    18

 *

    19

 * Contact Information:

    20

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

    21

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

    22

 */

    23

    24

#include "e1000_mbx-3.18-ethercat.h"

    25

    26

/**

    27

 *  igb_read_mbx - Reads a message from the mailbox

    28

 *  @hw: pointer to the HW structure

    29

 *  @msg: The message buffer

    30

 *  @size: Length of buffer

    31

 *  @mbx_id: id of mailbox to read

    32

 *

    33

 *  returns SUCCESS if it successfully read message from buffer

    34

 **/

    35

s32 igb_read_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)

    36

{

    37

	struct e1000_mbx_info *mbx = &hw->mbx;

    38

	s32 ret_val = -E1000_ERR_MBX;

    39

    40

	/* limit read to size of mailbox */

    41

	if (size > mbx->size)

    42

		size = mbx->size;

    43

    44

	if (mbx->ops.read)

    45

		ret_val = mbx->ops.read(hw, msg, size, mbx_id);

    46

    47

	return ret_val;

    48

}

    49

    50

/**

    51

 *  igb_write_mbx - Write a message to the mailbox

    52

 *  @hw: pointer to the HW structure

    53

 *  @msg: The message buffer

    54

 *  @size: Length of buffer

    55

 *  @mbx_id: id of mailbox to write

    56

 *

    57

 *  returns SUCCESS if it successfully copied message into the buffer

    58

 **/

    59

s32 igb_write_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)

    60

{

    61

	struct e1000_mbx_info *mbx = &hw->mbx;

    62

	s32 ret_val = 0;

    63

    64

	if (size > mbx->size)

    65

		ret_val = -E1000_ERR_MBX;

    66

    67

	else if (mbx->ops.write)

    68

		ret_val = mbx->ops.write(hw, msg, size, mbx_id);

    69

    70

	return ret_val;

    71

}

    72

    73

/**

    74

 *  igb_check_for_msg - checks to see if someone sent us mail

    75

 *  @hw: pointer to the HW structure

    76

 *  @mbx_id: id of mailbox to check

    77

 *

    78

 *  returns SUCCESS if the Status bit was found or else ERR_MBX

    79

 **/

    80

s32 igb_check_for_msg(struct e1000_hw *hw, u16 mbx_id)

    81

{

    82

	struct e1000_mbx_info *mbx = &hw->mbx;

    83

	s32 ret_val = -E1000_ERR_MBX;

    84

    85

	if (mbx->ops.check_for_msg)

    86

		ret_val = mbx->ops.check_for_msg(hw, mbx_id);

    87

    88

	return ret_val;

    89

}

    90

    91

/**

    92

 *  igb_check_for_ack - checks to see if someone sent us ACK

    93

 *  @hw: pointer to the HW structure

    94

 *  @mbx_id: id of mailbox to check

    95

 *

    96

 *  returns SUCCESS if the Status bit was found or else ERR_MBX

    97

 **/

    98

s32 igb_check_for_ack(struct e1000_hw *hw, u16 mbx_id)

    99

{

   100

	struct e1000_mbx_info *mbx = &hw->mbx;

   101

	s32 ret_val = -E1000_ERR_MBX;

   102

   103

	if (mbx->ops.check_for_ack)

   104

		ret_val = mbx->ops.check_for_ack(hw, mbx_id);

   105

   106

	return ret_val;

   107

}

   108

   109

/**

   110

 *  igb_check_for_rst - checks to see if other side has reset

   111

 *  @hw: pointer to the HW structure

   112

 *  @mbx_id: id of mailbox to check

   113

 *

   114

 *  returns SUCCESS if the Status bit was found or else ERR_MBX

   115

 **/

   116

s32 igb_check_for_rst(struct e1000_hw *hw, u16 mbx_id)

   117

{

   118

	struct e1000_mbx_info *mbx = &hw->mbx;

   119

	s32 ret_val = -E1000_ERR_MBX;

   120

   121

	if (mbx->ops.check_for_rst)

   122

		ret_val = mbx->ops.check_for_rst(hw, mbx_id);

   123

   124

	return ret_val;

   125

}

   126

   127

/**

   128

 *  igb_poll_for_msg - Wait for message notification

   129

 *  @hw: pointer to the HW structure

   130

 *  @mbx_id: id of mailbox to write

   131

 *

   132

 *  returns SUCCESS if it successfully received a message notification

   133

 **/

   134

static s32 igb_poll_for_msg(struct e1000_hw *hw, u16 mbx_id)

   135

{

   136

	struct e1000_mbx_info *mbx = &hw->mbx;

   137

	int countdown = mbx->timeout;

   138

   139

	if (!countdown || !mbx->ops.check_for_msg)

   140

		goto out;

   141

   142

	while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {

   143

		countdown--;

   144

		if (!countdown)

   145

			break;

   146

		udelay(mbx->usec_delay);

   147

	}

   148

   149

	/* if we failed, all future posted messages fail until reset */

   150

	if (!countdown)

   151

		mbx->timeout = 0;

   152

out:

   153

	return countdown ? 0 : -E1000_ERR_MBX;

   154

}

   155

   156

/**

   157

 *  igb_poll_for_ack - Wait for message acknowledgement

   158

 *  @hw: pointer to the HW structure

   159

 *  @mbx_id: id of mailbox to write

   160

 *

   161

 *  returns SUCCESS if it successfully received a message acknowledgement

   162

 **/

   163

static s32 igb_poll_for_ack(struct e1000_hw *hw, u16 mbx_id)

   164

{

   165

	struct e1000_mbx_info *mbx = &hw->mbx;

   166

	int countdown = mbx->timeout;

   167

   168

	if (!countdown || !mbx->ops.check_for_ack)

   169

		goto out;

   170

   171

	while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {

   172

		countdown--;

   173

		if (!countdown)

   174

			break;

   175

		udelay(mbx->usec_delay);

   176

	}

   177

   178

	/* if we failed, all future posted messages fail until reset */

   179

	if (!countdown)

   180

		mbx->timeout = 0;

   181

out:

   182

	return countdown ? 0 : -E1000_ERR_MBX;

   183

}

   184

   185

/**

   186

 *  igb_read_posted_mbx - Wait for message notification and receive message

   187

 *  @hw: pointer to the HW structure

   188

 *  @msg: The message buffer

   189

 *  @size: Length of buffer

   190

 *  @mbx_id: id of mailbox to write

   191

 *

   192

 *  returns SUCCESS if it successfully received a message notification and

   193

 *  copied it into the receive buffer.

   194

 **/

   195

static s32 igb_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size,

   196

			       u16 mbx_id)

   197

{

   198

	struct e1000_mbx_info *mbx = &hw->mbx;

   199

	s32 ret_val = -E1000_ERR_MBX;

   200

   201

	if (!mbx->ops.read)

   202

		goto out;

   203

   204

	ret_val = igb_poll_for_msg(hw, mbx_id);

   205

   206

	if (!ret_val)

   207

		ret_val = mbx->ops.read(hw, msg, size, mbx_id);

   208

out:

   209

	return ret_val;

   210

}

   211

   212

/**

   213

 *  igb_write_posted_mbx - Write a message to the mailbox, wait for ack

   214

 *  @hw: pointer to the HW structure

   215

 *  @msg: The message buffer

   216

 *  @size: Length of buffer

   217

 *  @mbx_id: id of mailbox to write

   218

 *

   219

 *  returns SUCCESS if it successfully copied message into the buffer and

   220

 *  received an ack to that message within delay * timeout period

   221

 **/

   222

static s32 igb_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size,

   223

				u16 mbx_id)

   224

{

   225

	struct e1000_mbx_info *mbx = &hw->mbx;

   226

	s32 ret_val = -E1000_ERR_MBX;

   227

   228

	/* exit if either we can't write or there isn't a defined timeout */

   229

	if (!mbx->ops.write || !mbx->timeout)

   230

		goto out;

   231

   232

	/* send msg */

   233

	ret_val = mbx->ops.write(hw, msg, size, mbx_id);

   234

   235

	/* if msg sent wait until we receive an ack */

   236

	if (!ret_val)

   237

		ret_val = igb_poll_for_ack(hw, mbx_id);

   238

out:

   239

	return ret_val;

   240

}

   241

   242

static s32 igb_check_for_bit_pf(struct e1000_hw *hw, u32 mask)

   243

{

   244

	u32 mbvficr = rd32(E1000_MBVFICR);

   245

	s32 ret_val = -E1000_ERR_MBX;

   246

   247

	if (mbvficr & mask) {

   248

		ret_val = 0;

   249

		wr32(E1000_MBVFICR, mask);

   250

	}

   251

   252

	return ret_val;

   253

}

   254

   255

/**

   256

 *  igb_check_for_msg_pf - checks to see if the VF has sent mail

   257

 *  @hw: pointer to the HW structure

   258

 *  @vf_number: the VF index

   259

 *

   260

 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX

   261

 **/

   262

static s32 igb_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)

   263

{

   264

	s32 ret_val = -E1000_ERR_MBX;

   265

   266

	if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {

   267

		ret_val = 0;

   268

		hw->mbx.stats.reqs++;

   269

	}

   270

   271

	return ret_val;

   272

}

   273

   274

/**

   275

 *  igb_check_for_ack_pf - checks to see if the VF has ACKed

   276

 *  @hw: pointer to the HW structure

   277

 *  @vf_number: the VF index

   278

 *

   279

 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX

   280

 **/

   281

static s32 igb_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)

   282

{

   283

	s32 ret_val = -E1000_ERR_MBX;

   284

   285

	if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {

   286

		ret_val = 0;

   287

		hw->mbx.stats.acks++;

   288

	}

   289

   290

	return ret_val;

   291

}

   292

   293

/**

   294

 *  igb_check_for_rst_pf - checks to see if the VF has reset

   295

 *  @hw: pointer to the HW structure

   296

 *  @vf_number: the VF index

   297

 *

   298

 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX

   299

 **/

   300

static s32 igb_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)

   301

{

   302

	u32 vflre = rd32(E1000_VFLRE);

   303

	s32 ret_val = -E1000_ERR_MBX;

   304

   305

	if (vflre & (1 << vf_number)) {

   306

		ret_val = 0;

   307

		wr32(E1000_VFLRE, (1 << vf_number));

   308

		hw->mbx.stats.rsts++;

   309

	}

   310

   311

	return ret_val;

   312

}

   313

   314

/**

   315

 *  igb_obtain_mbx_lock_pf - obtain mailbox lock

   316

 *  @hw: pointer to the HW structure

   317

 *  @vf_number: the VF index

   318

 *

   319

 *  return SUCCESS if we obtained the mailbox lock

   320

 **/

   321

static s32 igb_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)

   322

{

   323

	s32 ret_val = -E1000_ERR_MBX;

   324

	u32 p2v_mailbox;

   325

   326

	/* Take ownership of the buffer */

   327

	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_PFU);

   328

   329

	/* reserve mailbox for vf use */

   330

	p2v_mailbox = rd32(E1000_P2VMAILBOX(vf_number));

   331

	if (p2v_mailbox & E1000_P2VMAILBOX_PFU)

   332

		ret_val = 0;

   333

   334

	return ret_val;

   335

}

   336

   337

/**

   338

 *  igb_write_mbx_pf - Places a message in the mailbox

   339

 *  @hw: pointer to the HW structure

   340

 *  @msg: The message buffer

   341

 *  @size: Length of buffer

   342

 *  @vf_number: the VF index

   343

 *

   344

 *  returns SUCCESS if it successfully copied message into the buffer

   345

 **/

   346

static s32 igb_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,

   347

			    u16 vf_number)

   348

{

   349

	s32 ret_val;

   350

	u16 i;

   351

   352

	/* lock the mailbox to prevent pf/vf race condition */

   353

	ret_val = igb_obtain_mbx_lock_pf(hw, vf_number);

   354

	if (ret_val)

   355

		goto out_no_write;

   356

   357

	/* flush msg and acks as we are overwriting the message buffer */

   358

	igb_check_for_msg_pf(hw, vf_number);

   359

	igb_check_for_ack_pf(hw, vf_number);

   360

   361

	/* copy the caller specified message to the mailbox memory buffer */

   362

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

   363

		array_wr32(E1000_VMBMEM(vf_number), i, msg[i]);

   364

   365

	/* Interrupt VF to tell it a message has been sent and release buffer*/

   366

	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS);

   367

   368

	/* update stats */

   369

	hw->mbx.stats.msgs_tx++;

   370

   371

out_no_write:

   372

	return ret_val;

   373

   374

}

   375

   376

/**

   377

 *  igb_read_mbx_pf - Read a message from the mailbox

   378

 *  @hw: pointer to the HW structure

   379

 *  @msg: The message buffer

   380

 *  @size: Length of buffer

   381

 *  @vf_number: the VF index

   382

 *

   383

 *  This function copies a message from the mailbox buffer to the caller's

   384

 *  memory buffer.  The presumption is that the caller knows that there was

   385

 *  a message due to a VF request so no polling for message is needed.

   386

 **/

   387

static s32 igb_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,

   388

			   u16 vf_number)

   389

{

   390

	s32 ret_val;

   391

	u16 i;

   392

   393

	/* lock the mailbox to prevent pf/vf race condition */

   394

	ret_val = igb_obtain_mbx_lock_pf(hw, vf_number);

   395

	if (ret_val)

   396

		goto out_no_read;

   397

   398

	/* copy the message to the mailbox memory buffer */

   399

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

   400

		msg[i] = array_rd32(E1000_VMBMEM(vf_number), i);

   401

   402

	/* Acknowledge the message and release buffer */

   403

	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);

   404

   405

	/* update stats */

   406

	hw->mbx.stats.msgs_rx++;

   407

   408

out_no_read:

   409

	return ret_val;

   410

}

   411

   412

/**

   413

 *  e1000_init_mbx_params_pf - set initial values for pf mailbox

   414

 *  @hw: pointer to the HW structure

   415

 *

   416

 *  Initializes the hw->mbx struct to correct values for pf mailbox

   417

 */

   418

s32 igb_init_mbx_params_pf(struct e1000_hw *hw)

   419

{

   420

	struct e1000_mbx_info *mbx = &hw->mbx;

   421

   422

	mbx->timeout = 0;

   423

	mbx->usec_delay = 0;

   424

   425

	mbx->size = E1000_VFMAILBOX_SIZE;

   426

   427

	mbx->ops.read = igb_read_mbx_pf;

   428

	mbx->ops.write = igb_write_mbx_pf;

   429

	mbx->ops.read_posted = igb_read_posted_mbx;

   430

	mbx->ops.write_posted = igb_write_posted_mbx;

   431

	mbx->ops.check_for_msg = igb_check_for_msg_pf;

   432

	mbx->ops.check_for_ack = igb_check_for_ack_pf;

   433

	mbx->ops.check_for_rst = igb_check_for_rst_pf;

   434

   435

	mbx->stats.msgs_tx = 0;

   436

	mbx->stats.msgs_rx = 0;

   437

	mbx->stats.reqs = 0;

   438

	mbx->stats.acks = 0;

   439

	mbx->stats.rsts = 0;

   440

   441

	return 0;

   442

}

   443