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