ceph/src/dpdk/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
 434         DEBUGFUNC("e1000_obtain_mbx_lock_vf");
 435
 436         /* Take ownership of the buffer */
 437         E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
 438
 439         /* reserve mailbox for vf use */
 440         if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU)
 441                 ret_val = E1000_SUCCESS;
 442
 443         return ret_val;
 444 }
 445
 446 /**
 447  *  e1000_write_mbx_vf - Write a message to the mailbox
 448  *  @hw: pointer to the HW structure
 449  *  @msg: The message buffer
 450  *  @size: Length of buffer
 451  *  @mbx_id: id of mailbox to write
 452  *
 453  *  returns SUCCESS if it successfully copied message into the buffer
 454  **/
 455 STATIC s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
 456                               u16 E1000_UNUSEDARG mbx_id)
 457 {
 458         s32 ret_val;
 459         u16 i;
 460
 461         UNREFERENCED_1PARAMETER(mbx_id);
 462
 463         DEBUGFUNC("e1000_write_mbx_vf");
 464
 465         /* lock the mailbox to prevent pf/vf race condition */
 466         ret_val = e1000_obtain_mbx_lock_vf(hw);
 467         if (ret_val)
 468                 goto out_no_write;
 469
 470         /* flush msg and acks as we are overwriting the message buffer */
 471         e1000_check_for_msg_vf(hw, 0);
 472         e1000_check_for_ack_vf(hw, 0);
 473
 474         /* copy the caller specified message to the mailbox memory buffer */
 475         for (i = 0; i < size; i++)
 476                 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(0), i, msg[i]);
 477
 478         /* update stats */
 479         hw->mbx.stats.msgs_tx++;
 480
 481         /* Drop VFU and interrupt the PF to tell it a message has been sent */
 482         E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);
 483
 484 out_no_write:
 485         return ret_val;
 486 }
 487
 488 /**
 489  *  e1000_read_mbx_vf - Reads a message from the inbox intended for vf
 490  *  @hw: pointer to the HW structure
 491  *  @msg: The message buffer
 492  *  @size: Length of buffer
 493  *  @mbx_id: id of mailbox to read
 494  *
 495  *  returns SUCCESS if it successfully read message from buffer
 496  **/
 497 STATIC s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
 498                              u16 E1000_UNUSEDARG mbx_id)
 499 {
 500         s32 ret_val = E1000_SUCCESS;
 501         u16 i;
 502
 503         DEBUGFUNC("e1000_read_mbx_vf");
 504         UNREFERENCED_1PARAMETER(mbx_id);
 505
 506         /* lock the mailbox to prevent pf/vf race condition */
 507         ret_val = e1000_obtain_mbx_lock_vf(hw);
 508         if (ret_val)
 509                 goto out_no_read;
 510
 511         /* copy the message from the mailbox memory buffer */
 512         for (i = 0; i < size; i++)
 513                 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(0), i);
 514
 515         /* Acknowledge receipt and release mailbox, then we're done */
 516         E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
 517
 518         /* update stats */
 519         hw->mbx.stats.msgs_rx++;
 520
 521 out_no_read:
 522         return ret_val;
 523 }
 524
 525 /**
 526  *  e1000_init_mbx_params_vf - set initial values for vf mailbox
 527  *  @hw: pointer to the HW structure
 528  *
 529  *  Initializes the hw->mbx struct to correct values for vf mailbox
 530  */
 531 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
 532 {
 533         struct e1000_mbx_info *mbx = &hw->mbx;
 534
 535         /* start mailbox as timed out and let the reset_hw call set the timeout
 536          * value to begin communications */
 537         mbx->timeout = 0;
 538         mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
 539
 540         mbx->size = E1000_VFMAILBOX_SIZE;
 541
 542         mbx->ops.read = e1000_read_mbx_vf;
 543         mbx->ops.write = e1000_write_mbx_vf;
 544         mbx->ops.read_posted = e1000_read_posted_mbx;
 545         mbx->ops.write_posted = e1000_write_posted_mbx;
 546         mbx->ops.check_for_msg = e1000_check_for_msg_vf;
 547         mbx->ops.check_for_ack = e1000_check_for_ack_vf;
 548         mbx->ops.check_for_rst = e1000_check_for_rst_vf;
 549
 550         mbx->stats.msgs_tx = 0;
 551         mbx->stats.msgs_rx = 0;
 552         mbx->stats.reqs = 0;
 553         mbx->stats.acks = 0;
 554         mbx->stats.rsts = 0;
 555
 556         return E1000_SUCCESS;
 557 }
 558
 559 STATIC s32 e1000_check_for_bit_pf(struct e1000_hw *hw, u32 mask)
 560 {
 561         u32 mbvficr = E1000_READ_REG(hw, E1000_MBVFICR);
 562         s32 ret_val = -E1000_ERR_MBX;
 563
 564         if (mbvficr & mask) {
 565                 ret_val = E1000_SUCCESS;
 566                 E1000_WRITE_REG(hw, E1000_MBVFICR, mask);
 567         }
 568
 569         return ret_val;
 570 }
 571
 572 /**
 573  *  e1000_check_for_msg_pf - checks to see if the VF has sent mail
 574  *  @hw: pointer to the HW structure
 575  *  @vf_number: the VF index
 576  *
 577  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 578  **/
 579 STATIC s32 e1000_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)
 580 {
 581         s32 ret_val = -E1000_ERR_MBX;
 582
 583         DEBUGFUNC("e1000_check_for_msg_pf");
 584
 585         if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {
 586                 ret_val = E1000_SUCCESS;
 587                 hw->mbx.stats.reqs++;
 588         }
 589
 590         return ret_val;
 591 }
 592
 593 /**
 594  *  e1000_check_for_ack_pf - checks to see if the VF has ACKed
 595  *  @hw: pointer to the HW structure
 596  *  @vf_number: the VF index
 597  *
 598  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 599  **/
 600 STATIC s32 e1000_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)
 601 {
 602         s32 ret_val = -E1000_ERR_MBX;
 603
 604         DEBUGFUNC("e1000_check_for_ack_pf");
 605
 606         if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {
 607                 ret_val = E1000_SUCCESS;
 608                 hw->mbx.stats.acks++;
 609         }
 610
 611         return ret_val;
 612 }
 613
 614 /**
 615  *  e1000_check_for_rst_pf - checks to see if the VF has reset
 616  *  @hw: pointer to the HW structure
 617  *  @vf_number: the VF index
 618  *
 619  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 620  **/
 621 STATIC s32 e1000_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)
 622 {
 623         u32 vflre = E1000_READ_REG(hw, E1000_VFLRE);
 624         s32 ret_val = -E1000_ERR_MBX;
 625
 626         DEBUGFUNC("e1000_check_for_rst_pf");
 627
 628         if (vflre & (1 << vf_number)) {
 629                 ret_val = E1000_SUCCESS;
 630                 E1000_WRITE_REG(hw, E1000_VFLRE, (1 << vf_number));
 631                 hw->mbx.stats.rsts++;
 632         }
 633
 634         return ret_val;
 635 }
 636
 637 /**
 638  *  e1000_obtain_mbx_lock_pf - obtain mailbox lock
 639  *  @hw: pointer to the HW structure
 640  *  @vf_number: the VF index
 641  *
 642  *  return SUCCESS if we obtained the mailbox lock
 643  **/
 644 STATIC s32 e1000_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
 645 {
 646         s32 ret_val = -E1000_ERR_MBX;
 647         u32 p2v_mailbox;
 648
 649         DEBUGFUNC("e1000_obtain_mbx_lock_pf");
 650
 651         /* Take ownership of the buffer */
 652         E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_PFU);
 653
 654         /* reserve mailbox for vf use */
 655         p2v_mailbox = E1000_READ_REG(hw, E1000_P2VMAILBOX(vf_number));
 656         if (p2v_mailbox & E1000_P2VMAILBOX_PFU)
 657                 ret_val = E1000_SUCCESS;
 658
 659         return ret_val;
 660 }
 661
 662 /**
 663  *  e1000_write_mbx_pf - Places a message in the mailbox
 664  *  @hw: pointer to the HW structure
 665  *  @msg: The message buffer
 666  *  @size: Length of buffer
 667  *  @vf_number: the VF index
 668  *
 669  *  returns SUCCESS if it successfully copied message into the buffer
 670  **/
 671 STATIC s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
 672                               u16 vf_number)
 673 {
 674         s32 ret_val;
 675         u16 i;
 676
 677         DEBUGFUNC("e1000_write_mbx_pf");
 678
 679         /* lock the mailbox to prevent pf/vf race condition */
 680         ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
 681         if (ret_val)
 682                 goto out_no_write;
 683
 684         /* flush msg and acks as we are overwriting the message buffer */
 685         e1000_check_for_msg_pf(hw, vf_number);
 686         e1000_check_for_ack_pf(hw, vf_number);
 687
 688         /* copy the caller specified message to the mailbox memory buffer */
 689         for (i = 0; i < size; i++)
 690                 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i, msg[i]);
 691
 692         /* Interrupt VF to tell it a message has been sent and release buffer*/
 693         E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS);
 694
 695         /* update stats */
 696         hw->mbx.stats.msgs_tx++;
 697
 698 out_no_write:
 699         return ret_val;
 700
 701 }
 702
 703 /**
 704  *  e1000_read_mbx_pf - Read a message from the mailbox
 705  *  @hw: pointer to the HW structure
 706  *  @msg: The message buffer
 707  *  @size: Length of buffer
 708  *  @vf_number: the VF index
 709  *
 710  *  This function copies a message from the mailbox buffer to the caller's
 711  *  memory buffer.  The presumption is that the caller knows that there was
 712  *  a message due to a VF request so no polling for message is needed.
 713  **/
 714 STATIC s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
 715                              u16 vf_number)
 716 {
 717         s32 ret_val;
 718         u16 i;
 719
 720         DEBUGFUNC("e1000_read_mbx_pf");
 721
 722         /* lock the mailbox to prevent pf/vf race condition */
 723         ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
 724         if (ret_val)
 725                 goto out_no_read;
 726
 727         /* copy the message to the mailbox memory buffer */
 728         for (i = 0; i < size; i++)
 729                 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i);
 730
 731         /* Acknowledge the message and release buffer */
 732         E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);
 733
 734         /* update stats */
 735         hw->mbx.stats.msgs_rx++;
 736
 737 out_no_read:
 738         return ret_val;
 739 }
 740
 741 /**
 742  *  e1000_init_mbx_params_pf - set initial values for pf mailbox
 743  *  @hw: pointer to the HW structure
 744  *
 745  *  Initializes the hw->mbx struct to correct values for pf mailbox
 746  */
 747 s32 e1000_init_mbx_params_pf(struct e1000_hw *hw)
 748 {
 749         struct e1000_mbx_info *mbx = &hw->mbx;
 750
 751         switch (hw->mac.type) {
 752         case e1000_82576:
 753         case e1000_i350:
 754         case e1000_i354:
 755                 mbx->timeout = 0;
 756                 mbx->usec_delay = 0;
 757
 758                 mbx->size = E1000_VFMAILBOX_SIZE;
 759
 760                 mbx->ops.read = e1000_read_mbx_pf;
 761                 mbx->ops.write = e1000_write_mbx_pf;
 762                 mbx->ops.read_posted = e1000_read_posted_mbx;
 763                 mbx->ops.write_posted = e1000_write_posted_mbx;
 764                 mbx->ops.check_for_msg = e1000_check_for_msg_pf;
 765                 mbx->ops.check_for_ack = e1000_check_for_ack_pf;
 766                 mbx->ops.check_for_rst = e1000_check_for_rst_pf;
 767
 768                 mbx->stats.msgs_tx = 0;
 769                 mbx->stats.msgs_rx = 0;
 770                 mbx->stats.reqs = 0;
 771                 mbx->stats.acks = 0;
 772                 mbx->stats.rsts = 0;
 773         default:
 774                 return E1000_SUCCESS;
 775         }
 776 }
 777