1 /****************************************************************************** 2 SPDX-License-Identifier: BSD-3-Clause 3 4 Copyright (c) 2001-2020, Intel Corporation 5 All rights reserved. 6 7 Redistribution and use in source and binary forms, with or without 8 modification, are permitted provided that the following conditions are met: 9 10 1. Redistributions of source code must retain the above copyright notice, 11 this list of conditions and the following disclaimer. 12 13 2. Redistributions in binary form must reproduce the above copyright 14 notice, this list of conditions and the following disclaimer in the 15 documentation and/or other materials provided with the distribution. 16 17 3. Neither the name of the Intel Corporation nor the names of its 18 contributors may be used to endorse or promote products derived from 19 this software without specific prior written permission. 20 21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 25 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 POSSIBILITY OF SUCH DAMAGE. 32 33 ******************************************************************************/ 34 /*$FreeBSD$*/ 35 36 #include "e1000_mbx.h" 37 38 /** 39 * e1000_null_mbx_check_for_flag - No-op function, return 0 40 * @hw: pointer to the HW structure 41 **/ 42 static s32 e1000_null_mbx_check_for_flag(struct e1000_hw E1000_UNUSEDARG *hw, 43 u16 E1000_UNUSEDARG mbx_id) 44 { 45 DEBUGFUNC("e1000_null_mbx_check_flag"); 46 47 return E1000_SUCCESS; 48 } 49 50 /** 51 * e1000_null_mbx_transact - No-op function, return 0 52 * @hw: pointer to the HW structure 53 **/ 54 static s32 e1000_null_mbx_transact(struct e1000_hw E1000_UNUSEDARG *hw, 55 u32 E1000_UNUSEDARG *msg, 56 u16 E1000_UNUSEDARG size, 57 u16 E1000_UNUSEDARG mbx_id) 58 { 59 DEBUGFUNC("e1000_null_mbx_rw_msg"); 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 DEBUGFUNC("e1000_check_for_msg_vf"); 367 368 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) { 369 ret_val = E1000_SUCCESS; 370 hw->mbx.stats.reqs++; 371 } 372 373 return ret_val; 374 } 375 376 /** 377 * e1000_check_for_ack_vf - checks to see if the PF has ACK'd 378 * @hw: pointer to the HW structure 379 * @mbx_id: id of mailbox to check 380 * 381 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX 382 **/ 383 static s32 e1000_check_for_ack_vf(struct e1000_hw *hw, 384 u16 E1000_UNUSEDARG mbx_id) 385 { 386 s32 ret_val = -E1000_ERR_MBX; 387 388 DEBUGFUNC("e1000_check_for_ack_vf"); 389 390 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) { 391 ret_val = E1000_SUCCESS; 392 hw->mbx.stats.acks++; 393 } 394 395 return ret_val; 396 } 397 398 /** 399 * e1000_check_for_rst_vf - checks to see if the PF has reset 400 * @hw: pointer to the HW structure 401 * @mbx_id: id of mailbox to check 402 * 403 * returns TRUE if the PF has set the reset done bit or else FALSE 404 **/ 405 static s32 e1000_check_for_rst_vf(struct e1000_hw *hw, 406 u16 E1000_UNUSEDARG mbx_id) 407 { 408 s32 ret_val = -E1000_ERR_MBX; 409 410 DEBUGFUNC("e1000_check_for_rst_vf"); 411 412 if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD | 413 E1000_V2PMAILBOX_RSTI))) { 414 ret_val = E1000_SUCCESS; 415 hw->mbx.stats.rsts++; 416 } 417 418 return ret_val; 419 } 420 421 /** 422 * e1000_obtain_mbx_lock_vf - obtain mailbox lock 423 * @hw: pointer to the HW structure 424 * 425 * return SUCCESS if we obtained the mailbox lock 426 **/ 427 static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw) 428 { 429 s32 ret_val = -E1000_ERR_MBX; 430 int count = 10; 431 432 DEBUGFUNC("e1000_obtain_mbx_lock_vf"); 433 434 do { 435 /* Take ownership of the buffer */ 436 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_VFU); 437 438 /* reserve mailbox for vf use */ 439 if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU) { 440 ret_val = E1000_SUCCESS; 441 break; 442 } 443 usec_delay(1000); 444 } while (count-- > 0); 445 446 return ret_val; 447 } 448 449 /** 450 * e1000_write_mbx_vf - Write a message to the mailbox 451 * @hw: pointer to the HW structure 452 * @msg: The message buffer 453 * @size: Length of buffer 454 * @mbx_id: id of mailbox to write 455 * 456 * returns SUCCESS if it successfully copied message into the buffer 457 **/ 458 static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size, 459 u16 E1000_UNUSEDARG mbx_id) 460 { 461 s32 ret_val; 462 u16 i; 463 464 465 DEBUGFUNC("e1000_write_mbx_vf"); 466 467 /* lock the mailbox to prevent pf/vf race condition */ 468 ret_val = e1000_obtain_mbx_lock_vf(hw); 469 if (ret_val) 470 goto out_no_write; 471 472 /* flush msg and acks as we are overwriting the message buffer */ 473 e1000_check_for_msg_vf(hw, 0); 474 e1000_check_for_ack_vf(hw, 0); 475 476 /* copy the caller specified message to the mailbox memory buffer */ 477 for (i = 0; i < size; i++) 478 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(0), i, msg[i]); 479 480 /* update stats */ 481 hw->mbx.stats.msgs_tx++; 482 483 /* Drop VFU and interrupt the PF to tell it a message has been sent */ 484 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_REQ); 485 486 out_no_write: 487 return ret_val; 488 } 489 490 /** 491 * e1000_read_mbx_vf - Reads a message from the inbox intended for vf 492 * @hw: pointer to the HW structure 493 * @msg: The message buffer 494 * @size: Length of buffer 495 * @mbx_id: id of mailbox to read 496 * 497 * returns SUCCESS if it successfully read message from buffer 498 **/ 499 static s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size, 500 u16 E1000_UNUSEDARG mbx_id) 501 { 502 s32 ret_val = E1000_SUCCESS; 503 u16 i; 504 505 DEBUGFUNC("e1000_read_mbx_vf"); 506 507 /* lock the mailbox to prevent pf/vf race condition */ 508 ret_val = e1000_obtain_mbx_lock_vf(hw); 509 if (ret_val) 510 goto out_no_read; 511 512 /* copy the message from the mailbox memory buffer */ 513 for (i = 0; i < size; i++) 514 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(0), i); 515 516 /* Acknowledge receipt and release mailbox, then we're done */ 517 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_ACK); 518 519 /* update stats */ 520 hw->mbx.stats.msgs_rx++; 521 522 out_no_read: 523 return ret_val; 524 } 525 526 /** 527 * e1000_init_mbx_params_vf - set initial values for vf mailbox 528 * @hw: pointer to the HW structure 529 * 530 * Initializes the hw->mbx struct to correct values for vf mailbox 531 */ 532 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw) 533 { 534 struct e1000_mbx_info *mbx = &hw->mbx; 535 536 /* start mailbox as timed out and let the reset_hw call set the timeout 537 * value to begin communications */ 538 mbx->timeout = 0; 539 mbx->usec_delay = E1000_VF_MBX_INIT_DELAY; 540 541 mbx->size = E1000_VFMAILBOX_SIZE; 542 543 mbx->ops.read = e1000_read_mbx_vf; 544 mbx->ops.write = e1000_write_mbx_vf; 545 mbx->ops.read_posted = e1000_read_posted_mbx; 546 mbx->ops.write_posted = e1000_write_posted_mbx; 547 mbx->ops.check_for_msg = e1000_check_for_msg_vf; 548 mbx->ops.check_for_ack = e1000_check_for_ack_vf; 549 mbx->ops.check_for_rst = e1000_check_for_rst_vf; 550 551 mbx->stats.msgs_tx = 0; 552 mbx->stats.msgs_rx = 0; 553 mbx->stats.reqs = 0; 554 mbx->stats.acks = 0; 555 mbx->stats.rsts = 0; 556 557 return E1000_SUCCESS; 558 } 559 560 static s32 e1000_check_for_bit_pf(struct e1000_hw *hw, u32 mask) 561 { 562 u32 mbvficr = E1000_READ_REG(hw, E1000_MBVFICR); 563 s32 ret_val = -E1000_ERR_MBX; 564 565 if (mbvficr & mask) { 566 ret_val = E1000_SUCCESS; 567 E1000_WRITE_REG(hw, E1000_MBVFICR, mask); 568 } 569 570 return ret_val; 571 } 572 573 /** 574 * e1000_check_for_msg_pf - checks to see if the VF has sent mail 575 * @hw: pointer to the HW structure 576 * @vf_number: the VF index 577 * 578 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 579 **/ 580 static s32 e1000_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number) 581 { 582 s32 ret_val = -E1000_ERR_MBX; 583 584 DEBUGFUNC("e1000_check_for_msg_pf"); 585 586 if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) { 587 ret_val = E1000_SUCCESS; 588 hw->mbx.stats.reqs++; 589 } 590 591 return ret_val; 592 } 593 594 /** 595 * e1000_check_for_ack_pf - checks to see if the VF has ACKed 596 * @hw: pointer to the HW structure 597 * @vf_number: the VF index 598 * 599 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 600 **/ 601 static s32 e1000_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number) 602 { 603 s32 ret_val = -E1000_ERR_MBX; 604 605 DEBUGFUNC("e1000_check_for_ack_pf"); 606 607 if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) { 608 ret_val = E1000_SUCCESS; 609 hw->mbx.stats.acks++; 610 } 611 612 return ret_val; 613 } 614 615 /** 616 * e1000_check_for_rst_pf - checks to see if the VF has reset 617 * @hw: pointer to the HW structure 618 * @vf_number: the VF index 619 * 620 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 621 **/ 622 static s32 e1000_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number) 623 { 624 u32 vflre = E1000_READ_REG(hw, E1000_VFLRE); 625 s32 ret_val = -E1000_ERR_MBX; 626 627 DEBUGFUNC("e1000_check_for_rst_pf"); 628 629 if (vflre & (1 << vf_number)) { 630 ret_val = E1000_SUCCESS; 631 E1000_WRITE_REG(hw, E1000_VFLRE, (1 << vf_number)); 632 hw->mbx.stats.rsts++; 633 } 634 635 return ret_val; 636 } 637 638 /** 639 * e1000_obtain_mbx_lock_pf - obtain mailbox lock 640 * @hw: pointer to the HW structure 641 * @vf_number: the VF index 642 * 643 * return SUCCESS if we obtained the mailbox lock 644 **/ 645 static s32 e1000_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number) 646 { 647 s32 ret_val = -E1000_ERR_MBX; 648 u32 p2v_mailbox; 649 int count = 10; 650 651 DEBUGFUNC("e1000_obtain_mbx_lock_pf"); 652 653 do { 654 /* Take ownership of the buffer */ 655 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), 656 E1000_P2VMAILBOX_PFU); 657 658 /* reserve mailbox for pf use */ 659 p2v_mailbox = E1000_READ_REG(hw, E1000_P2VMAILBOX(vf_number)); 660 if (p2v_mailbox & E1000_P2VMAILBOX_PFU) { 661 ret_val = E1000_SUCCESS; 662 break; 663 } 664 usec_delay(1000); 665 } while (count-- > 0); 666 667 return ret_val; 668 669 } 670 671 /** 672 * e1000_write_mbx_pf - Places a message in the mailbox 673 * @hw: pointer to the HW structure 674 * @msg: The message buffer 675 * @size: Length of buffer 676 * @vf_number: the VF index 677 * 678 * returns SUCCESS if it successfully copied message into the buffer 679 **/ 680 static s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size, 681 u16 vf_number) 682 { 683 s32 ret_val; 684 u16 i; 685 686 DEBUGFUNC("e1000_write_mbx_pf"); 687 688 /* lock the mailbox to prevent pf/vf race condition */ 689 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number); 690 if (ret_val) 691 goto out_no_write; 692 693 /* flush msg and acks as we are overwriting the message buffer */ 694 e1000_check_for_msg_pf(hw, vf_number); 695 e1000_check_for_ack_pf(hw, vf_number); 696 697 /* copy the caller specified message to the mailbox memory buffer */ 698 for (i = 0; i < size; i++) 699 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i, msg[i]); 700 701 /* Interrupt VF to tell it a message has been sent and release buffer*/ 702 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS); 703 704 /* update stats */ 705 hw->mbx.stats.msgs_tx++; 706 707 out_no_write: 708 return ret_val; 709 710 } 711 712 /** 713 * e1000_read_mbx_pf - Read a message from the mailbox 714 * @hw: pointer to the HW structure 715 * @msg: The message buffer 716 * @size: Length of buffer 717 * @vf_number: the VF index 718 * 719 * This function copies a message from the mailbox buffer to the caller's 720 * memory buffer. The presumption is that the caller knows that there was 721 * a message due to a VF request so no polling for message is needed. 722 **/ 723 static s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size, 724 u16 vf_number) 725 { 726 s32 ret_val; 727 u16 i; 728 729 DEBUGFUNC("e1000_read_mbx_pf"); 730 731 /* lock the mailbox to prevent pf/vf race condition */ 732 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number); 733 if (ret_val) 734 goto out_no_read; 735 736 /* copy the message to the mailbox memory buffer */ 737 for (i = 0; i < size; i++) 738 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i); 739 740 /* Acknowledge the message and release buffer */ 741 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK); 742 743 /* update stats */ 744 hw->mbx.stats.msgs_rx++; 745 746 out_no_read: 747 return ret_val; 748 } 749 750 /** 751 * e1000_init_mbx_params_pf - set initial values for pf mailbox 752 * @hw: pointer to the HW structure 753 * 754 * Initializes the hw->mbx struct to correct values for pf mailbox 755 */ 756 s32 e1000_init_mbx_params_pf(struct e1000_hw *hw) 757 { 758 struct e1000_mbx_info *mbx = &hw->mbx; 759 760 switch (hw->mac.type) { 761 case e1000_82576: 762 case e1000_i350: 763 case e1000_i354: 764 mbx->timeout = 0; 765 mbx->usec_delay = 0; 766 767 mbx->size = E1000_VFMAILBOX_SIZE; 768 769 mbx->ops.read = e1000_read_mbx_pf; 770 mbx->ops.write = e1000_write_mbx_pf; 771 mbx->ops.read_posted = e1000_read_posted_mbx; 772 mbx->ops.write_posted = e1000_write_posted_mbx; 773 mbx->ops.check_for_msg = e1000_check_for_msg_pf; 774 mbx->ops.check_for_ack = e1000_check_for_ack_pf; 775 mbx->ops.check_for_rst = e1000_check_for_rst_pf; 776 777 mbx->stats.msgs_tx = 0; 778 mbx->stats.msgs_rx = 0; 779 mbx->stats.reqs = 0; 780 mbx->stats.acks = 0; 781 mbx->stats.rsts = 0; 782 /* FALLTHROUGH */ 783 default: 784 return E1000_SUCCESS; 785 } 786 } 787 788