drivers/net/e1000/base/e1000_mbx.c

   1 /*******************************************************************************
   2
   3 Copyright (c) 2001-2015, Intel Corporation
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9  1. Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12  2. Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in the
  14     documentation and/or other materials provided with the distribution.
  15
  16  3. Neither the name of the Intel Corporation nor the names of its
  17     contributors may be used to endorse or promote products derived from
  18     this software without specific prior written permission.
  19
  20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 ***************************************************************************/
  33
  34 #include "e1000_mbx.h"
  35
  36 /**
  37  *  e1000_null_mbx_check_for_flag - No-op function, return 0
  38  *  @hw: pointer to the HW structure
  39  **/
  40 STATIC s32 e1000_null_mbx_check_for_flag(struct e1000_hw E1000_UNUSEDARG *hw,
  41                                          u16 E1000_UNUSEDARG mbx_id)
  42 {
  43         DEBUGFUNC("e1000_null_mbx_check_flag");
  44         UNREFERENCED_2PARAMETER(hw, mbx_id);
  45
  46         return E1000_SUCCESS;
  47 }
  48
  49 /**
  50  *  e1000_null_mbx_transact - No-op function, return 0
  51  *  @hw: pointer to the HW structure
  52  **/
  53 STATIC s32 e1000_null_mbx_transact(struct e1000_hw E1000_UNUSEDARG *hw,
  54                                    u32 E1000_UNUSEDARG *msg,
  55                                    u16 E1000_UNUSEDARG size,
  56                                    u16 E1000_UNUSEDARG mbx_id)
  57 {
  58         DEBUGFUNC("e1000_null_mbx_rw_msg");
  59         UNREFERENCED_4PARAMETER(hw, msg, size, mbx_id);
  60
  61         return E1000_SUCCESS;
  62 }
  63
  64 /**
  65  *  e1000_read_mbx - Reads a message from the mailbox
  66  *  @hw: pointer to the HW structure
  67  *  @msg: The message buffer
  68  *  @size: Length of buffer
  69  *  @mbx_id: id of mailbox to read
  70  *
  71  *  returns SUCCESS if it successfully read message from buffer
  72  **/
  73 s32 e1000_read_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
  74 {
  75         struct e1000_mbx_info *mbx = &hw->mbx;
  76         s32 ret_val = -E1000_ERR_MBX;
  77
  78         DEBUGFUNC("e1000_read_mbx");
  79
  80         /* limit read to size of mailbox */
  81         if (size > mbx->size)
  82                 size = mbx->size;
  83
  84         if (mbx->ops.read)
  85                 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
  86
  87         return ret_val;
  88 }
  89
  90 /**
  91  *  e1000_write_mbx - Write a message to the mailbox
  92  *  @hw: pointer to the HW structure
  93  *  @msg: The message buffer
  94  *  @size: Length of buffer
  95  *  @mbx_id: id of mailbox to write
  96  *
  97  *  returns SUCCESS if it successfully copied message into the buffer
  98  **/
  99 s32 e1000_write_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
 100 {
 101         struct e1000_mbx_info *mbx = &hw->mbx;
 102         s32 ret_val = E1000_SUCCESS;
 103
 104         DEBUGFUNC("e1000_write_mbx");
 105
 106         if (size > mbx->size)
 107                 ret_val = -E1000_ERR_MBX;
 108
 109         else if (mbx->ops.write)
 110                 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
 111
 112         return ret_val;
 113 }
 114
 115 /**
 116  *  e1000_check_for_msg - checks to see if someone sent us mail
 117  *  @hw: pointer to the HW structure
 118  *  @mbx_id: id of mailbox to check
 119  *
 120  *  returns SUCCESS if the Status bit was found or else ERR_MBX
 121  **/
 122 s32 e1000_check_for_msg(struct e1000_hw *hw, u16 mbx_id)
 123 {
 124         struct e1000_mbx_info *mbx = &hw->mbx;
 125         s32 ret_val = -E1000_ERR_MBX;
 126
 127         DEBUGFUNC("e1000_check_for_msg");
 128
 129         if (mbx->ops.check_for_msg)
 130                 ret_val = mbx->ops.check_for_msg(hw, mbx_id);
 131
 132         return ret_val;
 133 }
 134
 135 /**
 136  *  e1000_check_for_ack - checks to see if someone sent us ACK
 137  *  @hw: pointer to the HW structure
 138  *  @mbx_id: id of mailbox to check
 139  *
 140  *  returns SUCCESS if the Status bit was found or else ERR_MBX
 141  **/
 142 s32 e1000_check_for_ack(struct e1000_hw *hw, u16 mbx_id)
 143 {
 144         struct e1000_mbx_info *mbx = &hw->mbx;
 145         s32 ret_val = -E1000_ERR_MBX;
 146
 147         DEBUGFUNC("e1000_check_for_ack");
 148
 149         if (mbx->ops.check_for_ack)
 150                 ret_val = mbx->ops.check_for_ack(hw, mbx_id);
 151
 152         return ret_val;
 153 }
 154
 155 /**
 156  *  e1000_check_for_rst - checks to see if other side has reset
 157  *  @hw: pointer to the HW structure
 158  *  @mbx_id: id of mailbox to check
 159  *
 160  *  returns SUCCESS if the Status bit was found or else ERR_MBX
 161  **/
 162 s32 e1000_check_for_rst(struct e1000_hw *hw, u16 mbx_id)
 163 {
 164         struct e1000_mbx_info *mbx = &hw->mbx;
 165         s32 ret_val = -E1000_ERR_MBX;
 166
 167         DEBUGFUNC("e1000_check_for_rst");
 168
 169         if (mbx->ops.check_for_rst)
 170                 ret_val = mbx->ops.check_for_rst(hw, mbx_id);
 171
 172         return ret_val;
 173 }
 174
 175 /**
 176  *  e1000_poll_for_msg - Wait for message notification
 177  *  @hw: pointer to the HW structure
 178  *  @mbx_id: id of mailbox to write
 179  *
 180  *  returns SUCCESS if it successfully received a message notification
 181  **/
 182 STATIC s32 e1000_poll_for_msg(struct e1000_hw *hw, u16 mbx_id)
 183 {
 184         struct e1000_mbx_info *mbx = &hw->mbx;
 185         int countdown = mbx->timeout;
 186
 187         DEBUGFUNC("e1000_poll_for_msg");
 188
 189         if (!countdown || !mbx->ops.check_for_msg)
 190                 goto out;
 191
 192         while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
 193                 countdown--;
 194                 if (!countdown)
 195                         break;
 196                 usec_delay(mbx->usec_delay);
 197         }
 198
 199         /* if we failed, all future posted messages fail until reset */
 200         if (!countdown)
 201                 mbx->timeout = 0;
 202 out:
 203         return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
 204 }
 205
 206 /**
 207  *  e1000_poll_for_ack - Wait for message acknowledgement
 208  *  @hw: pointer to the HW structure
 209  *  @mbx_id: id of mailbox to write
 210  *
 211  *  returns SUCCESS if it successfully received a message acknowledgement
 212  **/
 213 STATIC s32 e1000_poll_for_ack(struct e1000_hw *hw, u16 mbx_id)
 214 {
 215         struct e1000_mbx_info *mbx = &hw->mbx;
 216         int countdown = mbx->timeout;
 217
 218         DEBUGFUNC("e1000_poll_for_ack");
 219
 220         if (!countdown || !mbx->ops.check_for_ack)
 221                 goto out;
 222
 223         while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
 224                 countdown--;
 225                 if (!countdown)
 226                         break;
 227                 usec_delay(mbx->usec_delay);
 228         }
 229
 230         /* if we failed, all future posted messages fail until reset */
 231         if (!countdown)
 232                 mbx->timeout = 0;
 233 out:
 234         return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
 235 }
 236
 237 /**
 238  *  e1000_read_posted_mbx - Wait for message notification and receive message
 239  *  @hw: pointer to the HW structure
 240  *  @msg: The message buffer
 241  *  @size: Length of buffer
 242  *  @mbx_id: id of mailbox to write
 243  *
 244  *  returns SUCCESS if it successfully received a message notification and
 245  *  copied it into the receive buffer.
 246  **/
 247 s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
 248 {
 249         struct e1000_mbx_info *mbx = &hw->mbx;
 250         s32 ret_val = -E1000_ERR_MBX;
 251
 252         DEBUGFUNC("e1000_read_posted_mbx");
 253
 254         if (!mbx->ops.read)
 255                 goto out;
 256
 257         ret_val = e1000_poll_for_msg(hw, mbx_id);
 258
 259         /* if ack received read message, otherwise we timed out */
 260         if (!ret_val)
 261                 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
 262 out:
 263         return ret_val;
 264 }
 265
 266 /**
 267  *  e1000_write_posted_mbx - Write a message to the mailbox, wait for ack
 268  *  @hw: pointer to the HW structure
 269  *  @msg: The message buffer
 270  *  @size: Length of buffer
 271  *  @mbx_id: id of mailbox to write
 272  *
 273  *  returns SUCCESS if it successfully copied message into the buffer and
 274  *  received an ack to that message within delay * timeout period
 275  **/
 276 s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
 277 {
 278         struct e1000_mbx_info *mbx = &hw->mbx;
 279         s32 ret_val = -E1000_ERR_MBX;
 280
 281         DEBUGFUNC("e1000_write_posted_mbx");
 282
 283         /* exit if either we can't write or there isn't a defined timeout */
 284         if (!mbx->ops.write || !mbx->timeout)
 285                 goto out;
 286
 287         /* send msg */
 288         ret_val = mbx->ops.write(hw, msg, size, mbx_id);
 289
 290         /* if msg sent wait until we receive an ack */
 291         if (!ret_val)
 292                 ret_val = e1000_poll_for_ack(hw, mbx_id);
 293 out:
 294         return ret_val;
 295 }
 296
 297 /**
 298  *  e1000_init_mbx_ops_generic - Initialize mbx function pointers
 299  *  @hw: pointer to the HW structure
 300  *
 301  *  Sets the function pointers to no-op functions
 302  **/
 303 void e1000_init_mbx_ops_generic(struct e1000_hw *hw)
 304 {
 305         struct e1000_mbx_info *mbx = &hw->mbx;
 306         mbx->ops.init_params = e1000_null_ops_generic;
 307         mbx->ops.read = e1000_null_mbx_transact;
 308         mbx->ops.write = e1000_null_mbx_transact;
 309         mbx->ops.check_for_msg = e1000_null_mbx_check_for_flag;
 310         mbx->ops.check_for_ack = e1000_null_mbx_check_for_flag;
 311         mbx->ops.check_for_rst = e1000_null_mbx_check_for_flag;
 312         mbx->ops.read_posted = e1000_read_posted_mbx;
 313         mbx->ops.write_posted = e1000_write_posted_mbx;
 314 }
 315
 316 /**
 317  *  e1000_read_v2p_mailbox - read v2p mailbox
 318  *  @hw: pointer to the HW structure
 319  *
 320  *  This function is used to read the v2p mailbox without losing the read to
 321  *  clear status bits.
 322  **/
 323 STATIC u32 e1000_read_v2p_mailbox(struct e1000_hw *hw)
 324 {
 325         u32 v2p_mailbox = E1000_READ_REG(hw, E1000_V2PMAILBOX(0));
 326
 327         v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox;
 328         hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS;
 329
 330         return v2p_mailbox;
 331 }
 332
 333 /**
 334  *  e1000_check_for_bit_vf - Determine if a status bit was set
 335  *  @hw: pointer to the HW structure
 336  *  @mask: bitmask for bits to be tested and cleared
 337  *
 338  *  This function is used to check for the read to clear bits within
 339  *  the V2P mailbox.
 340  **/
 341 STATIC s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
 342 {
 343         u32 v2p_mailbox = e1000_read_v2p_mailbox(hw);
 344         s32 ret_val = -E1000_ERR_MBX;
 345
 346         if (v2p_mailbox & mask)
 347                 ret_val = E1000_SUCCESS;
 348
 349         hw->dev_spec.vf.v2p_mailbox &= ~mask;
 350
 351         return ret_val;
 352 }
 353
 354 /**
 355  *  e1000_check_for_msg_vf - checks to see if the PF has sent mail
 356  *  @hw: pointer to the HW structure
 357  *  @mbx_id: id of mailbox to check
 358  *
 359  *  returns SUCCESS if the PF has set the Status bit or else ERR_MBX
 360  **/
 361 STATIC s32 e1000_check_for_msg_vf(struct e1000_hw *hw,
 362                                   u16 E1000_UNUSEDARG mbx_id)
 363 {
 364         s32 ret_val = -E1000_ERR_MBX;
 365
 366         UNREFERENCED_1PARAMETER(mbx_id);
 367         DEBUGFUNC("e1000_check_for_msg_vf");
 368
 369         if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) {
 370                 ret_val = E1000_SUCCESS;
 371                 hw->mbx.stats.reqs++;
 372         }
 373
 374         return ret_val;
 375 }
 376
 377 /**
 378  *  e1000_check_for_ack_vf - checks to see if the PF has ACK'd
 379  *  @hw: pointer to the HW structure
 380  *  @mbx_id: id of mailbox to check
 381  *
 382  *  returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
 383  **/
 384 STATIC s32 e1000_check_for_ack_vf(struct e1000_hw *hw,
 385                                   u16 E1000_UNUSEDARG mbx_id)
 386 {
 387         s32 ret_val = -E1000_ERR_MBX;
 388
 389         UNREFERENCED_1PARAMETER(mbx_id);
 390         DEBUGFUNC("e1000_check_for_ack_vf");
 391
 392         if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) {
 393                 ret_val = E1000_SUCCESS;
 394                 hw->mbx.stats.acks++;
 395         }
 396
 397         return ret_val;
 398 }
 399
 400 /**
 401  *  e1000_check_for_rst_vf - checks to see if the PF has reset
 402  *  @hw: pointer to the HW structure
 403  *  @mbx_id: id of mailbox to check
 404  *
 405  *  returns true if the PF has set the reset done bit or else false
 406  **/
 407 STATIC s32 e1000_check_for_rst_vf(struct e1000_hw *hw,
 408                                   u16 E1000_UNUSEDARG mbx_id)
 409 {
 410         s32 ret_val = -E1000_ERR_MBX;
 411
 412         UNREFERENCED_1PARAMETER(mbx_id);
 413         DEBUGFUNC("e1000_check_for_rst_vf");
 414
 415         if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD |
 416                                          E1000_V2PMAILBOX_RSTI))) {
 417                 ret_val = E1000_SUCCESS;
 418                 hw->mbx.stats.rsts++;
 419         }
 420
 421         return ret_val;
 422 }
 423
 424 /**
 425  *  e1000_obtain_mbx_lock_vf - obtain mailbox lock
 426  *  @hw: pointer to the HW structure
 427  *
 428  *  return SUCCESS if we obtained the mailbox lock
 429  **/
 430 STATIC s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
 431 {
 432         s32 ret_val = -E1000_ERR_MBX;
 433         int count = 10;
 434
 435         DEBUGFUNC("e1000_obtain_mbx_lock_vf");
 436
 437         do {
 438                 /* Take ownership of the buffer */
 439                 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
 440
 441                 /* reserve mailbox for vf use */
 442                 if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU) {
 443                         ret_val = E1000_SUCCESS;
 444                         break;
 445                 }
 446                 usec_delay(1000);
 447         } while (count-- > 0);
 448
 449         return ret_val;
 450 }
 451
 452 /**
 453  *  e1000_write_mbx_vf - Write a message to the mailbox
 454  *  @hw: pointer to the HW structure
 455  *  @msg: The message buffer
 456  *  @size: Length of buffer
 457  *  @mbx_id: id of mailbox to write
 458  *
 459  *  returns SUCCESS if it successfully copied message into the buffer
 460  **/
 461 STATIC s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
 462                               u16 E1000_UNUSEDARG mbx_id)
 463 {
 464         s32 ret_val;
 465         u16 i;
 466
 467         UNREFERENCED_1PARAMETER(mbx_id);
 468
 469         DEBUGFUNC("e1000_write_mbx_vf");
 470
 471         /* lock the mailbox to prevent pf/vf race condition */
 472         ret_val = e1000_obtain_mbx_lock_vf(hw);
 473         if (ret_val)
 474                 goto out_no_write;
 475
 476         /* flush msg and acks as we are overwriting the message buffer */
 477         e1000_check_for_msg_vf(hw, 0);
 478         e1000_check_for_ack_vf(hw, 0);
 479
 480         /* copy the caller specified message to the mailbox memory buffer */
 481         for (i = 0; i < size; i++)
 482                 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(0), i, msg[i]);
 483
 484         /* update stats */
 485         hw->mbx.stats.msgs_tx++;
 486
 487         /* Drop VFU and interrupt the PF to tell it a message has been sent */
 488         E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);
 489
 490 out_no_write:
 491         return ret_val;
 492 }
 493
 494 /**
 495  *  e1000_read_mbx_vf - Reads a message from the inbox intended for vf
 496  *  @hw: pointer to the HW structure
 497  *  @msg: The message buffer
 498  *  @size: Length of buffer
 499  *  @mbx_id: id of mailbox to read
 500  *
 501  *  returns SUCCESS if it successfully read message from buffer
 502  **/
 503 STATIC s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
 504                              u16 E1000_UNUSEDARG mbx_id)
 505 {
 506         s32 ret_val = E1000_SUCCESS;
 507         u16 i;
 508
 509         DEBUGFUNC("e1000_read_mbx_vf");
 510         UNREFERENCED_1PARAMETER(mbx_id);
 511
 512         /* lock the mailbox to prevent pf/vf race condition */
 513         ret_val = e1000_obtain_mbx_lock_vf(hw);
 514         if (ret_val)
 515                 goto out_no_read;
 516
 517         /* copy the message from the mailbox memory buffer */
 518         for (i = 0; i < size; i++)
 519                 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(0), i);
 520
 521         /* Acknowledge receipt and release mailbox, then we're done */
 522         E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
 523
 524         /* update stats */
 525         hw->mbx.stats.msgs_rx++;
 526
 527 out_no_read:
 528         return ret_val;
 529 }
 530
 531 /**
 532  *  e1000_init_mbx_params_vf - set initial values for vf mailbox
 533  *  @hw: pointer to the HW structure
 534  *
 535  *  Initializes the hw->mbx struct to correct values for vf mailbox
 536  */
 537 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
 538 {
 539         struct e1000_mbx_info *mbx = &hw->mbx;
 540
 541         /* start mailbox as timed out and let the reset_hw call set the timeout
 542          * value to begin communications */
 543         mbx->timeout = 0;
 544         mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
 545
 546         mbx->size = E1000_VFMAILBOX_SIZE;
 547
 548         mbx->ops.read = e1000_read_mbx_vf;
 549         mbx->ops.write = e1000_write_mbx_vf;
 550         mbx->ops.read_posted = e1000_read_posted_mbx;
 551         mbx->ops.write_posted = e1000_write_posted_mbx;
 552         mbx->ops.check_for_msg = e1000_check_for_msg_vf;
 553         mbx->ops.check_for_ack = e1000_check_for_ack_vf;
 554         mbx->ops.check_for_rst = e1000_check_for_rst_vf;
 555
 556         mbx->stats.msgs_tx = 0;
 557         mbx->stats.msgs_rx = 0;
 558         mbx->stats.reqs = 0;
 559         mbx->stats.acks = 0;
 560         mbx->stats.rsts = 0;
 561
 562         return E1000_SUCCESS;
 563 }
 564
 565 STATIC s32 e1000_check_for_bit_pf(struct e1000_hw *hw, u32 mask)
 566 {
 567         u32 mbvficr = E1000_READ_REG(hw, E1000_MBVFICR);
 568         s32 ret_val = -E1000_ERR_MBX;
 569
 570         if (mbvficr & mask) {
 571                 ret_val = E1000_SUCCESS;
 572                 E1000_WRITE_REG(hw, E1000_MBVFICR, mask);
 573         }
 574
 575         return ret_val;
 576 }
 577
 578 /**
 579  *  e1000_check_for_msg_pf - checks to see if the VF has sent mail
 580  *  @hw: pointer to the HW structure
 581  *  @vf_number: the VF index
 582  *
 583  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 584  **/
 585 STATIC s32 e1000_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)
 586 {
 587         s32 ret_val = -E1000_ERR_MBX;
 588
 589         DEBUGFUNC("e1000_check_for_msg_pf");
 590
 591         if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {
 592                 ret_val = E1000_SUCCESS;
 593                 hw->mbx.stats.reqs++;
 594         }
 595
 596         return ret_val;
 597 }
 598
 599 /**
 600  *  e1000_check_for_ack_pf - checks to see if the VF has ACKed
 601  *  @hw: pointer to the HW structure
 602  *  @vf_number: the VF index
 603  *
 604  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 605  **/
 606 STATIC s32 e1000_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)
 607 {
 608         s32 ret_val = -E1000_ERR_MBX;
 609
 610         DEBUGFUNC("e1000_check_for_ack_pf");
 611
 612         if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {
 613                 ret_val = E1000_SUCCESS;
 614                 hw->mbx.stats.acks++;
 615         }
 616
 617         return ret_val;
 618 }
 619
 620 /**
 621  *  e1000_check_for_rst_pf - checks to see if the VF has reset
 622  *  @hw: pointer to the HW structure
 623  *  @vf_number: the VF index
 624  *
 625  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 626  **/
 627 STATIC s32 e1000_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)
 628 {
 629         u32 vflre = E1000_READ_REG(hw, E1000_VFLRE);
 630         s32 ret_val = -E1000_ERR_MBX;
 631
 632         DEBUGFUNC("e1000_check_for_rst_pf");
 633
 634         if (vflre & (1 << vf_number)) {
 635                 ret_val = E1000_SUCCESS;
 636                 E1000_WRITE_REG(hw, E1000_VFLRE, (1 << vf_number));
 637                 hw->mbx.stats.rsts++;
 638         }
 639
 640         return ret_val;
 641 }
 642
 643 /**
 644  *  e1000_obtain_mbx_lock_pf - obtain mailbox lock
 645  *  @hw: pointer to the HW structure
 646  *  @vf_number: the VF index
 647  *
 648  *  return SUCCESS if we obtained the mailbox lock
 649  **/
 650 STATIC s32 e1000_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
 651 {
 652         s32 ret_val = -E1000_ERR_MBX;
 653         u32 p2v_mailbox;
 654         int count = 10;
 655
 656         DEBUGFUNC("e1000_obtain_mbx_lock_pf");
 657
 658         do {
 659                 /* Take ownership of the buffer */
 660                 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number),
 661                                 E1000_P2VMAILBOX_PFU);
 662
 663                 /* reserve mailbox for pf use */
 664                 p2v_mailbox = E1000_READ_REG(hw, E1000_P2VMAILBOX(vf_number));
 665                 if (p2v_mailbox & E1000_P2VMAILBOX_PFU) {
 666                         ret_val = E1000_SUCCESS;
 667                         break;
 668                 }
 669                 usec_delay(1000);
 670         } while (count-- > 0);
 671
 672         return ret_val;
 673
 674 }
 675
 676 /**
 677  *  e1000_write_mbx_pf - Places a message in the mailbox
 678  *  @hw: pointer to the HW structure
 679  *  @msg: The message buffer
 680  *  @size: Length of buffer
 681  *  @vf_number: the VF index
 682  *
 683  *  returns SUCCESS if it successfully copied message into the buffer
 684  **/
 685 STATIC s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
 686                               u16 vf_number)
 687 {
 688         s32 ret_val;
 689         u16 i;
 690
 691         DEBUGFUNC("e1000_write_mbx_pf");
 692
 693         /* lock the mailbox to prevent pf/vf race condition */
 694         ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
 695         if (ret_val)
 696                 goto out_no_write;
 697
 698         /* flush msg and acks as we are overwriting the message buffer */
 699         e1000_check_for_msg_pf(hw, vf_number);
 700         e1000_check_for_ack_pf(hw, vf_number);
 701
 702         /* copy the caller specified message to the mailbox memory buffer */
 703         for (i = 0; i < size; i++)
 704                 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i, msg[i]);
 705
 706         /* Interrupt VF to tell it a message has been sent and release buffer*/
 707         E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS);
 708
 709         /* update stats */
 710         hw->mbx.stats.msgs_tx++;
 711
 712 out_no_write:
 713         return ret_val;
 714
 715 }
 716
 717 /**
 718  *  e1000_read_mbx_pf - Read a message from the mailbox
 719  *  @hw: pointer to the HW structure
 720  *  @msg: The message buffer
 721  *  @size: Length of buffer
 722  *  @vf_number: the VF index
 723  *
 724  *  This function copies a message from the mailbox buffer to the caller's
 725  *  memory buffer.  The presumption is that the caller knows that there was
 726  *  a message due to a VF request so no polling for message is needed.
 727  **/
 728 STATIC s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
 729                              u16 vf_number)
 730 {
 731         s32 ret_val;
 732         u16 i;
 733
 734         DEBUGFUNC("e1000_read_mbx_pf");
 735
 736         /* lock the mailbox to prevent pf/vf race condition */
 737         ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
 738         if (ret_val)
 739                 goto out_no_read;
 740
 741         /* copy the message to the mailbox memory buffer */
 742         for (i = 0; i < size; i++)
 743                 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i);
 744
 745         /* Acknowledge the message and release buffer */
 746         E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);
 747
 748         /* update stats */
 749         hw->mbx.stats.msgs_rx++;
 750
 751 out_no_read:
 752         return ret_val;
 753 }
 754
 755 /**
 756  *  e1000_init_mbx_params_pf - set initial values for pf mailbox
 757  *  @hw: pointer to the HW structure
 758  *
 759  *  Initializes the hw->mbx struct to correct values for pf mailbox
 760  */
 761 s32 e1000_init_mbx_params_pf(struct e1000_hw *hw)
 762 {
 763         struct e1000_mbx_info *mbx = &hw->mbx;
 764
 765         switch (hw->mac.type) {
 766         case e1000_82576:
 767         case e1000_i350:
 768         case e1000_i354:
 769                 mbx->timeout = 0;
 770                 mbx->usec_delay = 0;
 771
 772                 mbx->size = E1000_VFMAILBOX_SIZE;
 773
 774                 mbx->ops.read = e1000_read_mbx_pf;
 775                 mbx->ops.write = e1000_write_mbx_pf;
 776                 mbx->ops.read_posted = e1000_read_posted_mbx;
 777                 mbx->ops.write_posted = e1000_write_posted_mbx;
 778                 mbx->ops.check_for_msg = e1000_check_for_msg_pf;
 779                 mbx->ops.check_for_ack = e1000_check_for_ack_pf;
 780                 mbx->ops.check_for_rst = e1000_check_for_rst_pf;
 781
 782                 mbx->stats.msgs_tx = 0;
 783                 mbx->stats.msgs_rx = 0;
 784                 mbx->stats.reqs = 0;
 785                 mbx->stats.acks = 0;
 786                 mbx->stats.rsts = 0;
 787         default:
 788                 return E1000_SUCCESS;
 789         }
 790 }
 791