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 /*$FreeBSD$*/ 34 35 #include "e1000_mbx.h" 36 37 /** 38 * e1000_null_mbx_check_for_flag - No-op function, return 0 39 * @hw: pointer to the HW structure 40 **/ 41 static s32 e1000_null_mbx_check_for_flag(struct e1000_hw E1000_UNUSEDARG *hw, 42 u16 E1000_UNUSEDARG mbx_id) 43 { 44 DEBUGFUNC("e1000_null_mbx_check_flag"); 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 60 return E1000_SUCCESS; 61 } 62 63 /** 64 * e1000_read_mbx - Reads a message from the mailbox 65 * @hw: pointer to the HW structure 66 * @msg: The message buffer 67 * @size: Length of buffer 68 * @mbx_id: id of mailbox to read 69 * 70 * returns SUCCESS if it successfully read message from buffer 71 **/ 72 s32 e1000_read_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id) 73 { 74 struct e1000_mbx_info *mbx = &hw->mbx; 75 s32 ret_val = -E1000_ERR_MBX; 76 77 DEBUGFUNC("e1000_read_mbx"); 78 79 /* limit read to size of mailbox */ 80 if (size > mbx->size) 81 size = mbx->size; 82 83 if (mbx->ops.read) 84 ret_val = mbx->ops.read(hw, msg, size, mbx_id); 85 86 return ret_val; 87 } 88 89 /** 90 * e1000_write_mbx - Write a message to the mailbox 91 * @hw: pointer to the HW structure 92 * @msg: The message buffer 93 * @size: Length of buffer 94 * @mbx_id: id of mailbox to write 95 * 96 * returns SUCCESS if it successfully copied message into the buffer 97 **/ 98 s32 e1000_write_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id) 99 { 100 struct e1000_mbx_info *mbx = &hw->mbx; 101 s32 ret_val = E1000_SUCCESS; 102 103 DEBUGFUNC("e1000_write_mbx"); 104 105 if (size > mbx->size) 106 ret_val = -E1000_ERR_MBX; 107 108 else if (mbx->ops.write) 109 ret_val = mbx->ops.write(hw, msg, size, mbx_id); 110 111 return ret_val; 112 } 113 114 /** 115 * e1000_check_for_msg - checks to see if someone sent us mail 116 * @hw: pointer to the HW structure 117 * @mbx_id: id of mailbox to check 118 * 119 * returns SUCCESS if the Status bit was found or else ERR_MBX 120 **/ 121 s32 e1000_check_for_msg(struct e1000_hw *hw, u16 mbx_id) 122 { 123 struct e1000_mbx_info *mbx = &hw->mbx; 124 s32 ret_val = -E1000_ERR_MBX; 125 126 DEBUGFUNC("e1000_check_for_msg"); 127 128 if (mbx->ops.check_for_msg) 129 ret_val = mbx->ops.check_for_msg(hw, mbx_id); 130 131 return ret_val; 132 } 133 134 /** 135 * e1000_check_for_ack - checks to see if someone sent us ACK 136 * @hw: pointer to the HW structure 137 * @mbx_id: id of mailbox to check 138 * 139 * returns SUCCESS if the Status bit was found or else ERR_MBX 140 **/ 141 s32 e1000_check_for_ack(struct e1000_hw *hw, u16 mbx_id) 142 { 143 struct e1000_mbx_info *mbx = &hw->mbx; 144 s32 ret_val = -E1000_ERR_MBX; 145 146 DEBUGFUNC("e1000_check_for_ack"); 147 148 if (mbx->ops.check_for_ack) 149 ret_val = mbx->ops.check_for_ack(hw, mbx_id); 150 151 return ret_val; 152 } 153 154 /** 155 * e1000_check_for_rst - checks to see if other side has reset 156 * @hw: pointer to the HW structure 157 * @mbx_id: id of mailbox to check 158 * 159 * returns SUCCESS if the Status bit was found or else ERR_MBX 160 **/ 161 s32 e1000_check_for_rst(struct e1000_hw *hw, u16 mbx_id) 162 { 163 struct e1000_mbx_info *mbx = &hw->mbx; 164 s32 ret_val = -E1000_ERR_MBX; 165 166 DEBUGFUNC("e1000_check_for_rst"); 167 168 if (mbx->ops.check_for_rst) 169 ret_val = mbx->ops.check_for_rst(hw, mbx_id); 170 171 return ret_val; 172 } 173 174 /** 175 * e1000_poll_for_msg - Wait for message notification 176 * @hw: pointer to the HW structure 177 * @mbx_id: id of mailbox to write 178 * 179 * returns SUCCESS if it successfully received a message notification 180 **/ 181 static s32 e1000_poll_for_msg(struct e1000_hw *hw, u16 mbx_id) 182 { 183 struct e1000_mbx_info *mbx = &hw->mbx; 184 int countdown = mbx->timeout; 185 186 DEBUGFUNC("e1000_poll_for_msg"); 187 188 if (!countdown || !mbx->ops.check_for_msg) 189 goto out; 190 191 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) { 192 countdown--; 193 if (!countdown) 194 break; 195 usec_delay(mbx->usec_delay); 196 } 197 198 /* if we failed, all future posted messages fail until reset */ 199 if (!countdown) 200 mbx->timeout = 0; 201 out: 202 return countdown ? E1000_SUCCESS : -E1000_ERR_MBX; 203 } 204 205 /** 206 * e1000_poll_for_ack - Wait for message acknowledgement 207 * @hw: pointer to the HW structure 208 * @mbx_id: id of mailbox to write 209 * 210 * returns SUCCESS if it successfully received a message acknowledgement 211 **/ 212 static s32 e1000_poll_for_ack(struct e1000_hw *hw, u16 mbx_id) 213 { 214 struct e1000_mbx_info *mbx = &hw->mbx; 215 int countdown = mbx->timeout; 216 217 DEBUGFUNC("e1000_poll_for_ack"); 218 219 if (!countdown || !mbx->ops.check_for_ack) 220 goto out; 221 222 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) { 223 countdown--; 224 if (!countdown) 225 break; 226 usec_delay(mbx->usec_delay); 227 } 228 229 /* if we failed, all future posted messages fail until reset */ 230 if (!countdown) 231 mbx->timeout = 0; 232 out: 233 return countdown ? E1000_SUCCESS : -E1000_ERR_MBX; 234 } 235 236 /** 237 * e1000_read_posted_mbx - Wait for message notification and receive message 238 * @hw: pointer to the HW structure 239 * @msg: The message buffer 240 * @size: Length of buffer 241 * @mbx_id: id of mailbox to write 242 * 243 * returns SUCCESS if it successfully received a message notification and 244 * copied it into the receive buffer. 245 **/ 246 s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id) 247 { 248 struct e1000_mbx_info *mbx = &hw->mbx; 249 s32 ret_val = -E1000_ERR_MBX; 250 251 DEBUGFUNC("e1000_read_posted_mbx"); 252 253 if (!mbx->ops.read) 254 goto out; 255 256 ret_val = e1000_poll_for_msg(hw, mbx_id); 257 258 /* if ack received read message, otherwise we timed out */ 259 if (!ret_val) 260 ret_val = mbx->ops.read(hw, msg, size, mbx_id); 261 out: 262 return ret_val; 263 } 264 265 /** 266 * e1000_write_posted_mbx - Write a message to the mailbox, wait for ack 267 * @hw: pointer to the HW structure 268 * @msg: The message buffer 269 * @size: Length of buffer 270 * @mbx_id: id of mailbox to write 271 * 272 * returns SUCCESS if it successfully copied message into the buffer and 273 * received an ack to that message within delay * timeout period 274 **/ 275 s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id) 276 { 277 struct e1000_mbx_info *mbx = &hw->mbx; 278 s32 ret_val = -E1000_ERR_MBX; 279 280 DEBUGFUNC("e1000_write_posted_mbx"); 281 282 /* exit if either we can't write or there isn't a defined timeout */ 283 if (!mbx->ops.write || !mbx->timeout) 284 goto out; 285 286 /* send msg */ 287 ret_val = mbx->ops.write(hw, msg, size, mbx_id); 288 289 /* if msg sent wait until we receive an ack */ 290 if (!ret_val) 291 ret_val = e1000_poll_for_ack(hw, mbx_id); 292 out: 293 return ret_val; 294 } 295 296 /** 297 * e1000_init_mbx_ops_generic - Initialize mbx function pointers 298 * @hw: pointer to the HW structure 299 * 300 * Sets the function pointers to no-op functions 301 **/ 302 void e1000_init_mbx_ops_generic(struct e1000_hw *hw) 303 { 304 struct e1000_mbx_info *mbx = &hw->mbx; 305 mbx->ops.init_params = e1000_null_ops_generic; 306 mbx->ops.read = e1000_null_mbx_transact; 307 mbx->ops.write = e1000_null_mbx_transact; 308 mbx->ops.check_for_msg = e1000_null_mbx_check_for_flag; 309 mbx->ops.check_for_ack = e1000_null_mbx_check_for_flag; 310 mbx->ops.check_for_rst = e1000_null_mbx_check_for_flag; 311 mbx->ops.read_posted = e1000_read_posted_mbx; 312 mbx->ops.write_posted = e1000_write_posted_mbx; 313 } 314 315 /** 316 * e1000_read_v2p_mailbox - read v2p mailbox 317 * @hw: pointer to the HW structure 318 * 319 * This function is used to read the v2p mailbox without losing the read to 320 * clear status bits. 321 **/ 322 static u32 e1000_read_v2p_mailbox(struct e1000_hw *hw) 323 { 324 u32 v2p_mailbox = E1000_READ_REG(hw, E1000_V2PMAILBOX(0)); 325 326 v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox; 327 hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS; 328 329 return v2p_mailbox; 330 } 331 332 /** 333 * e1000_check_for_bit_vf - Determine if a status bit was set 334 * @hw: pointer to the HW structure 335 * @mask: bitmask for bits to be tested and cleared 336 * 337 * This function is used to check for the read to clear bits within 338 * the V2P mailbox. 339 **/ 340 static s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask) 341 { 342 u32 v2p_mailbox = e1000_read_v2p_mailbox(hw); 343 s32 ret_val = -E1000_ERR_MBX; 344 345 if (v2p_mailbox & mask) 346 ret_val = E1000_SUCCESS; 347 348 hw->dev_spec.vf.v2p_mailbox &= ~mask; 349 350 return ret_val; 351 } 352 353 /** 354 * e1000_check_for_msg_vf - checks to see if the PF has sent mail 355 * @hw: pointer to the HW structure 356 * @mbx_id: id of mailbox to check 357 * 358 * returns SUCCESS if the PF has set the Status bit or else ERR_MBX 359 **/ 360 static s32 e1000_check_for_msg_vf(struct e1000_hw *hw, 361 u16 E1000_UNUSEDARG mbx_id) 362 { 363 s32 ret_val = -E1000_ERR_MBX; 364 365 DEBUGFUNC("e1000_check_for_msg_vf"); 366 367 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) { 368 ret_val = E1000_SUCCESS; 369 hw->mbx.stats.reqs++; 370 } 371 372 return ret_val; 373 } 374 375 /** 376 * e1000_check_for_ack_vf - checks to see if the PF has ACK'd 377 * @hw: pointer to the HW structure 378 * @mbx_id: id of mailbox to check 379 * 380 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX 381 **/ 382 static s32 e1000_check_for_ack_vf(struct e1000_hw *hw, 383 u16 E1000_UNUSEDARG mbx_id) 384 { 385 s32 ret_val = -E1000_ERR_MBX; 386 387 DEBUGFUNC("e1000_check_for_ack_vf"); 388 389 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) { 390 ret_val = E1000_SUCCESS; 391 hw->mbx.stats.acks++; 392 } 393 394 return ret_val; 395 } 396 397 /** 398 * e1000_check_for_rst_vf - checks to see if the PF has reset 399 * @hw: pointer to the HW structure 400 * @mbx_id: id of mailbox to check 401 * 402 * returns TRUE if the PF has set the reset done bit or else FALSE 403 **/ 404 static s32 e1000_check_for_rst_vf(struct e1000_hw *hw, 405 u16 E1000_UNUSEDARG mbx_id) 406 { 407 s32 ret_val = -E1000_ERR_MBX; 408 409 DEBUGFUNC("e1000_check_for_rst_vf"); 410 411 if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD | 412 E1000_V2PMAILBOX_RSTI))) { 413 ret_val = E1000_SUCCESS; 414 hw->mbx.stats.rsts++; 415 } 416 417 return ret_val; 418 } 419 420 /** 421 * e1000_obtain_mbx_lock_vf - obtain mailbox lock 422 * @hw: pointer to the HW structure 423 * 424 * return SUCCESS if we obtained the mailbox lock 425 **/ 426 static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw) 427 { 428 s32 ret_val = -E1000_ERR_MBX; 429 int count = 10; 430 431 DEBUGFUNC("e1000_obtain_mbx_lock_vf"); 432 433 do { 434 /* Take ownership of the buffer */ 435 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_VFU); 436 437 /* reserve mailbox for vf use */ 438 if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU) { 439 ret_val = E1000_SUCCESS; 440 break; 441 } 442 usec_delay(1000); 443 } while (count-- > 0); 444 445 return ret_val; 446 } 447 448 /** 449 * e1000_write_mbx_vf - Write a message to the mailbox 450 * @hw: pointer to the HW structure 451 * @msg: The message buffer 452 * @size: Length of buffer 453 * @mbx_id: id of mailbox to write 454 * 455 * returns SUCCESS if it successfully copied message into the buffer 456 **/ 457 static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size, 458 u16 E1000_UNUSEDARG mbx_id) 459 { 460 s32 ret_val; 461 u16 i; 462 463 464 DEBUGFUNC("e1000_write_mbx_vf"); 465 466 /* lock the mailbox to prevent pf/vf race condition */ 467 ret_val = e1000_obtain_mbx_lock_vf(hw); 468 if (ret_val) 469 goto out_no_write; 470 471 /* flush msg and acks as we are overwriting the message buffer */ 472 e1000_check_for_msg_vf(hw, 0); 473 e1000_check_for_ack_vf(hw, 0); 474 475 /* copy the caller specified message to the mailbox memory buffer */ 476 for (i = 0; i < size; i++) 477 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(0), i, msg[i]); 478 479 /* update stats */ 480 hw->mbx.stats.msgs_tx++; 481 482 /* Drop VFU and interrupt the PF to tell it a message has been sent */ 483 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_REQ); 484 485 out_no_write: 486 return ret_val; 487 } 488 489 /** 490 * e1000_read_mbx_vf - Reads a message from the inbox intended for vf 491 * @hw: pointer to the HW structure 492 * @msg: The message buffer 493 * @size: Length of buffer 494 * @mbx_id: id of mailbox to read 495 * 496 * returns SUCCESS if it successfully read message from buffer 497 **/ 498 static s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size, 499 u16 E1000_UNUSEDARG mbx_id) 500 { 501 s32 ret_val = E1000_SUCCESS; 502 u16 i; 503 504 DEBUGFUNC("e1000_read_mbx_vf"); 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 int count = 10; 649 650 DEBUGFUNC("e1000_obtain_mbx_lock_pf"); 651 652 do { 653 /* Take ownership of the buffer */ 654 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), 655 E1000_P2VMAILBOX_PFU); 656 657 /* reserve mailbox for pf use */ 658 p2v_mailbox = E1000_READ_REG(hw, E1000_P2VMAILBOX(vf_number)); 659 if (p2v_mailbox & E1000_P2VMAILBOX_PFU) { 660 ret_val = E1000_SUCCESS; 661 break; 662 } 663 usec_delay(1000); 664 } while (count-- > 0); 665 666 return ret_val; 667 668 } 669 670 /** 671 * e1000_write_mbx_pf - Places a message in the mailbox 672 * @hw: pointer to the HW structure 673 * @msg: The message buffer 674 * @size: Length of buffer 675 * @vf_number: the VF index 676 * 677 * returns SUCCESS if it successfully copied message into the buffer 678 **/ 679 static s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size, 680 u16 vf_number) 681 { 682 s32 ret_val; 683 u16 i; 684 685 DEBUGFUNC("e1000_write_mbx_pf"); 686 687 /* lock the mailbox to prevent pf/vf race condition */ 688 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number); 689 if (ret_val) 690 goto out_no_write; 691 692 /* flush msg and acks as we are overwriting the message buffer */ 693 e1000_check_for_msg_pf(hw, vf_number); 694 e1000_check_for_ack_pf(hw, vf_number); 695 696 /* copy the caller specified message to the mailbox memory buffer */ 697 for (i = 0; i < size; i++) 698 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i, msg[i]); 699 700 /* Interrupt VF to tell it a message has been sent and release buffer*/ 701 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS); 702 703 /* update stats */ 704 hw->mbx.stats.msgs_tx++; 705 706 out_no_write: 707 return ret_val; 708 709 } 710 711 /** 712 * e1000_read_mbx_pf - Read a message from the mailbox 713 * @hw: pointer to the HW structure 714 * @msg: The message buffer 715 * @size: Length of buffer 716 * @vf_number: the VF index 717 * 718 * This function copies a message from the mailbox buffer to the caller's 719 * memory buffer. The presumption is that the caller knows that there was 720 * a message due to a VF request so no polling for message is needed. 721 **/ 722 static s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size, 723 u16 vf_number) 724 { 725 s32 ret_val; 726 u16 i; 727 728 DEBUGFUNC("e1000_read_mbx_pf"); 729 730 /* lock the mailbox to prevent pf/vf race condition */ 731 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number); 732 if (ret_val) 733 goto out_no_read; 734 735 /* copy the message to the mailbox memory buffer */ 736 for (i = 0; i < size; i++) 737 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i); 738 739 /* Acknowledge the message and release buffer */ 740 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK); 741 742 /* update stats */ 743 hw->mbx.stats.msgs_rx++; 744 745 out_no_read: 746 return ret_val; 747 } 748 749 /** 750 * e1000_init_mbx_params_pf - set initial values for pf mailbox 751 * @hw: pointer to the HW structure 752 * 753 * Initializes the hw->mbx struct to correct values for pf mailbox 754 */ 755 s32 e1000_init_mbx_params_pf(struct e1000_hw *hw) 756 { 757 struct e1000_mbx_info *mbx = &hw->mbx; 758 759 switch (hw->mac.type) { 760 case e1000_82576: 761 case e1000_i350: 762 case e1000_i354: 763 mbx->timeout = 0; 764 mbx->usec_delay = 0; 765 766 mbx->size = E1000_VFMAILBOX_SIZE; 767 768 mbx->ops.read = e1000_read_mbx_pf; 769 mbx->ops.write = e1000_write_mbx_pf; 770 mbx->ops.read_posted = e1000_read_posted_mbx; 771 mbx->ops.write_posted = e1000_write_posted_mbx; 772 mbx->ops.check_for_msg = e1000_check_for_msg_pf; 773 mbx->ops.check_for_ack = e1000_check_for_ack_pf; 774 mbx->ops.check_for_rst = e1000_check_for_rst_pf; 775 776 mbx->stats.msgs_tx = 0; 777 mbx->stats.msgs_rx = 0; 778 mbx->stats.reqs = 0; 779 mbx->stats.acks = 0; 780 mbx->stats.rsts = 0; 781 default: 782 return E1000_SUCCESS; 783 } 784 } 785 786