drivers/net/ethernet/intel/ixgbevf/mbx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 1999 - 2018 Intel Corporation. */
   3
   4 #include "mbx.h"
   5 #include "ixgbevf.h"
   6
   7 /**
   8  *  ixgbevf_poll_for_msg - Wait for message notification
   9  *  @hw: pointer to the HW structure
  10  *
  11  *  returns 0 if it successfully received a message notification
  12  **/
  13 static s32 ixgbevf_poll_for_msg(struct ixgbe_hw *hw)
  14 {
  15         struct ixgbe_mbx_info *mbx = &hw->mbx;
  16         int countdown = mbx->timeout;
  17
  18         if (!countdown || !mbx->ops.check_for_msg)
  19                 return IXGBE_ERR_CONFIG;
  20
  21         while (countdown && mbx->ops.check_for_msg(hw)) {
  22                 countdown--;
  23                 udelay(mbx->udelay);
  24         }
  25
  26         return countdown ? 0 : IXGBE_ERR_TIMEOUT;
  27 }
  28
  29 /**
  30  *  ixgbevf_poll_for_ack - Wait for message acknowledgment
  31  *  @hw: pointer to the HW structure
  32  *
  33  *  returns 0 if it successfully received a message acknowledgment
  34  **/
  35 static s32 ixgbevf_poll_for_ack(struct ixgbe_hw *hw)
  36 {
  37         struct ixgbe_mbx_info *mbx = &hw->mbx;
  38         int countdown = mbx->timeout;
  39
  40         if (!countdown || !mbx->ops.check_for_ack)
  41                 return IXGBE_ERR_CONFIG;
  42
  43         while (countdown && mbx->ops.check_for_ack(hw)) {
  44                 countdown--;
  45                 udelay(mbx->udelay);
  46         }
  47
  48         return countdown ? 0 : IXGBE_ERR_TIMEOUT;
  49 }
  50
  51 /**
  52  * ixgbevf_read_mailbox_vf - read VF's mailbox register
  53  * @hw: pointer to the HW structure
  54  *
  55  * This function is used to read the mailbox register dedicated for VF without
  56  * losing the read to clear status bits.
  57  **/
  58 static u32 ixgbevf_read_mailbox_vf(struct ixgbe_hw *hw)
  59 {
  60         u32 vf_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
  61
  62         vf_mailbox |= hw->mbx.vf_mailbox;
  63         hw->mbx.vf_mailbox |= vf_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
  64
  65         return vf_mailbox;
  66 }
  67
  68 /**
  69  * ixgbevf_clear_msg_vf - clear PF status bit
  70  * @hw: pointer to the HW structure
  71  *
  72  * This function is used to clear PFSTS bit in the VFMAILBOX register
  73  **/
  74 static void ixgbevf_clear_msg_vf(struct ixgbe_hw *hw)
  75 {
  76         u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
  77
  78         if (vf_mailbox & IXGBE_VFMAILBOX_PFSTS) {
  79                 hw->mbx.stats.reqs++;
  80                 hw->mbx.vf_mailbox &= ~IXGBE_VFMAILBOX_PFSTS;
  81         }
  82 }
  83
  84 /**
  85  * ixgbevf_clear_ack_vf - clear PF ACK bit
  86  * @hw: pointer to the HW structure
  87  *
  88  * This function is used to clear PFACK bit in the VFMAILBOX register
  89  **/
  90 static void ixgbevf_clear_ack_vf(struct ixgbe_hw *hw)
  91 {
  92         u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
  93
  94         if (vf_mailbox & IXGBE_VFMAILBOX_PFACK) {
  95                 hw->mbx.stats.acks++;
  96                 hw->mbx.vf_mailbox &= ~IXGBE_VFMAILBOX_PFACK;
  97         }
  98 }
  99
 100 /**
 101  * ixgbevf_clear_rst_vf - clear PF reset bit
 102  * @hw: pointer to the HW structure
 103  *
 104  * This function is used to clear reset indication and reset done bit in
 105  * VFMAILBOX register after reset the shared resources and the reset sequence.
 106  **/
 107 static void ixgbevf_clear_rst_vf(struct ixgbe_hw *hw)
 108 {
 109         u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
 110
 111         if (vf_mailbox & (IXGBE_VFMAILBOX_RSTI | IXGBE_VFMAILBOX_RSTD)) {
 112                 hw->mbx.stats.rsts++;
 113                 hw->mbx.vf_mailbox &= ~(IXGBE_VFMAILBOX_RSTI |
 114                                         IXGBE_VFMAILBOX_RSTD);
 115         }
 116 }
 117
 118 /**
 119  *  ixgbevf_check_for_bit_vf - Determine if a status bit was set
 120  *  @hw: pointer to the HW structure
 121  *  @mask: bitmask for bits to be tested and cleared
 122  *
 123  *  This function is used to check for the read to clear bits within
 124  *  the V2P mailbox.
 125  **/
 126 static s32 ixgbevf_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
 127 {
 128         u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
 129         s32 ret_val = IXGBE_ERR_MBX;
 130
 131         if (vf_mailbox & mask)
 132                 ret_val = 0;
 133
 134         return ret_val;
 135 }
 136
 137 /**
 138  *  ixgbevf_check_for_msg_vf - checks to see if the PF has sent mail
 139  *  @hw: pointer to the HW structure
 140  *
 141  *  returns 0 if the PF has set the Status bit or else ERR_MBX
 142  **/
 143 static s32 ixgbevf_check_for_msg_vf(struct ixgbe_hw *hw)
 144 {
 145         s32 ret_val = IXGBE_ERR_MBX;
 146
 147         if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
 148                 ret_val = 0;
 149                 hw->mbx.stats.reqs++;
 150         }
 151
 152         return ret_val;
 153 }
 154
 155 /**
 156  *  ixgbevf_check_for_ack_vf - checks to see if the PF has ACK'd
 157  *  @hw: pointer to the HW structure
 158  *
 159  *  returns 0 if the PF has set the ACK bit or else ERR_MBX
 160  **/
 161 static s32 ixgbevf_check_for_ack_vf(struct ixgbe_hw *hw)
 162 {
 163         s32 ret_val = IXGBE_ERR_MBX;
 164
 165         if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
 166                 ret_val = 0;
 167                 ixgbevf_clear_ack_vf(hw);
 168                 hw->mbx.stats.acks++;
 169         }
 170
 171         return ret_val;
 172 }
 173
 174 /**
 175  *  ixgbevf_check_for_rst_vf - checks to see if the PF has reset
 176  *  @hw: pointer to the HW structure
 177  *
 178  *  returns true if the PF has set the reset done bit or else false
 179  **/
 180 static s32 ixgbevf_check_for_rst_vf(struct ixgbe_hw *hw)
 181 {
 182         s32 ret_val = IXGBE_ERR_MBX;
 183
 184         if (!ixgbevf_check_for_bit_vf(hw, (IXGBE_VFMAILBOX_RSTD |
 185                                            IXGBE_VFMAILBOX_RSTI))) {
 186                 ret_val = 0;
 187                 ixgbevf_clear_rst_vf(hw);
 188                 hw->mbx.stats.rsts++;
 189         }
 190
 191         return ret_val;
 192 }
 193
 194 /**
 195  *  ixgbevf_obtain_mbx_lock_vf - obtain mailbox lock
 196  *  @hw: pointer to the HW structure
 197  *
 198  *  return 0 if we obtained the mailbox lock
 199  **/
 200 static s32 ixgbevf_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
 201 {
 202         struct ixgbe_mbx_info *mbx = &hw->mbx;
 203         s32 ret_val = IXGBE_ERR_CONFIG;
 204         int countdown = mbx->timeout;
 205         u32 vf_mailbox;
 206
 207         if (!mbx->timeout)
 208                 return ret_val;
 209
 210         while (countdown--) {
 211                 /* Reserve mailbox for VF use */
 212                 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
 213                 vf_mailbox |= IXGBE_VFMAILBOX_VFU;
 214                 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
 215
 216                 /* Verify that VF is the owner of the lock */
 217                 if (ixgbevf_read_mailbox_vf(hw) & IXGBE_VFMAILBOX_VFU) {
 218                         ret_val = 0;
 219                         break;
 220                 }
 221
 222                 /* Wait a bit before trying again */
 223                 udelay(mbx->udelay);
 224         }
 225
 226         if (ret_val)
 227                 ret_val = IXGBE_ERR_TIMEOUT;
 228
 229         return ret_val;
 230 }
 231
 232 /**
 233  * ixgbevf_release_mbx_lock_vf - release mailbox lock
 234  * @hw: pointer to the HW structure
 235  **/
 236 static void ixgbevf_release_mbx_lock_vf(struct ixgbe_hw *hw)
 237 {
 238         u32 vf_mailbox;
 239
 240         /* Return ownership of the buffer */
 241         vf_mailbox = ixgbevf_read_mailbox_vf(hw);
 242         vf_mailbox &= ~IXGBE_VFMAILBOX_VFU;
 243         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
 244 }
 245
 246 /**
 247  * ixgbevf_release_mbx_lock_vf_legacy - release mailbox lock
 248  * @hw: pointer to the HW structure
 249  **/
 250 static void ixgbevf_release_mbx_lock_vf_legacy(struct ixgbe_hw *__always_unused hw)
 251 {
 252 }
 253
 254 /**
 255  *  ixgbevf_write_mbx_vf - Write a message to the mailbox
 256  *  @hw: pointer to the HW structure
 257  *  @msg: The message buffer
 258  *  @size: Length of buffer
 259  *
 260  *  returns 0 if it successfully copied message into the buffer
 261  **/
 262 static s32 ixgbevf_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
 263 {
 264         u32 vf_mailbox;
 265         s32 ret_val;
 266         u16 i;
 267
 268         /* lock the mailbox to prevent PF/VF race condition */
 269         ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
 270         if (ret_val)
 271                 goto out_no_write;
 272
 273         /* flush msg and acks as we are overwriting the message buffer */
 274         ixgbevf_clear_msg_vf(hw);
 275         ixgbevf_clear_ack_vf(hw);
 276
 277         /* copy the caller specified message to the mailbox memory buffer */
 278         for (i = 0; i < size; i++)
 279                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
 280
 281         /* update stats */
 282         hw->mbx.stats.msgs_tx++;
 283
 284         /* interrupt the PF to tell it a message has been sent */
 285         vf_mailbox = ixgbevf_read_mailbox_vf(hw);
 286         vf_mailbox |= IXGBE_VFMAILBOX_REQ;
 287         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
 288
 289         /* if msg sent wait until we receive an ack */
 290         ret_val = ixgbevf_poll_for_ack(hw);
 291
 292 out_no_write:
 293         hw->mbx.ops.release(hw);
 294
 295         return ret_val;
 296 }
 297
 298 /**
 299  *  ixgbevf_write_mbx_vf_legacy - Write a message to the mailbox
 300  *  @hw: pointer to the HW structure
 301  *  @msg: The message buffer
 302  *  @size: Length of buffer
 303  *
 304  *  returns 0 if it successfully copied message into the buffer
 305  **/
 306 static s32 ixgbevf_write_mbx_vf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size)
 307 {
 308         s32 ret_val;
 309         u16 i;
 310
 311         /* lock the mailbox to prevent PF/VF race condition */
 312         ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
 313         if (ret_val)
 314                 goto out_no_write;
 315
 316         /* flush msg and acks as we are overwriting the message buffer */
 317         ixgbevf_check_for_msg_vf(hw);
 318         ixgbevf_clear_msg_vf(hw);
 319         ixgbevf_check_for_ack_vf(hw);
 320         ixgbevf_clear_ack_vf(hw);
 321
 322         /* copy the caller specified message to the mailbox memory buffer */
 323         for (i = 0; i < size; i++)
 324                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
 325
 326         /* update stats */
 327         hw->mbx.stats.msgs_tx++;
 328
 329         /* Drop VFU and interrupt the PF to tell it a message has been sent */
 330         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
 331
 332 out_no_write:
 333         return ret_val;
 334 }
 335
 336 /**
 337  *  ixgbevf_read_mbx_vf - Reads a message from the inbox intended for VF
 338  *  @hw: pointer to the HW structure
 339  *  @msg: The message buffer
 340  *  @size: Length of buffer
 341  *
 342  *  returns 0 if it successfully read message from buffer
 343  **/
 344 static s32 ixgbevf_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
 345 {
 346         u32 vf_mailbox;
 347         s32 ret_val;
 348         u16 i;
 349
 350         /* check if there is a message from PF */
 351         ret_val = ixgbevf_check_for_msg_vf(hw);
 352         if (ret_val)
 353                 return ret_val;
 354
 355         ixgbevf_clear_msg_vf(hw);
 356
 357         /* copy the message from the mailbox memory buffer */
 358         for (i = 0; i < size; i++)
 359                 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
 360
 361         /* Acknowledge receipt */
 362         vf_mailbox = ixgbevf_read_mailbox_vf(hw);
 363         vf_mailbox |= IXGBE_VFMAILBOX_ACK;
 364         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
 365
 366         /* update stats */
 367         hw->mbx.stats.msgs_rx++;
 368
 369         return ret_val;
 370 }
 371
 372 /**
 373  *  ixgbevf_read_mbx_vf_legacy - Reads a message from the inbox intended for VF
 374  *  @hw: pointer to the HW structure
 375  *  @msg: The message buffer
 376  *  @size: Length of buffer
 377  *
 378  *  returns 0 if it successfully read message from buffer
 379  **/
 380 static s32 ixgbevf_read_mbx_vf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size)
 381 {
 382         s32 ret_val = 0;
 383         u16 i;
 384
 385         /* lock the mailbox to prevent PF/VF race condition */
 386         ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
 387         if (ret_val)
 388                 goto out_no_read;
 389
 390         /* copy the message from the mailbox memory buffer */
 391         for (i = 0; i < size; i++)
 392                 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
 393
 394         /* Acknowledge receipt and release mailbox, then we're done */
 395         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
 396
 397         /* update stats */
 398         hw->mbx.stats.msgs_rx++;
 399
 400 out_no_read:
 401         return ret_val;
 402 }
 403
 404 /**
 405  *  ixgbevf_init_mbx_params_vf - set initial values for VF mailbox
 406  *  @hw: pointer to the HW structure
 407  *
 408  *  Initializes the hw->mbx struct to correct values for VF mailbox
 409  */
 410 static s32 ixgbevf_init_mbx_params_vf(struct ixgbe_hw *hw)
 411 {
 412         struct ixgbe_mbx_info *mbx = &hw->mbx;
 413
 414         /* start mailbox as timed out and let the reset_hw call set the timeout
 415          * value to begin communications
 416          */
 417         mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
 418         mbx->udelay = IXGBE_VF_MBX_INIT_DELAY;
 419
 420         mbx->size = IXGBE_VFMAILBOX_SIZE;
 421
 422         mbx->stats.msgs_tx = 0;
 423         mbx->stats.msgs_rx = 0;
 424         mbx->stats.reqs = 0;
 425         mbx->stats.acks = 0;
 426         mbx->stats.rsts = 0;
 427
 428         return 0;
 429 }
 430
 431 /**
 432  * ixgbevf_poll_mbx - Wait for message and read it from the mailbox
 433  * @hw: pointer to the HW structure
 434  * @msg: The message buffer
 435  * @size: Length of buffer
 436  *
 437  * returns 0 if it successfully read message from buffer
 438  **/
 439 s32 ixgbevf_poll_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
 440 {
 441         struct ixgbe_mbx_info *mbx = &hw->mbx;
 442         s32 ret_val = IXGBE_ERR_CONFIG;
 443
 444         if (!mbx->ops.read || !mbx->ops.check_for_msg || !mbx->timeout)
 445                 return ret_val;
 446
 447         /* limit read to size of mailbox */
 448         if (size > mbx->size)
 449                 size = mbx->size;
 450
 451         ret_val = ixgbevf_poll_for_msg(hw);
 452         /* if ack received read message, otherwise we timed out */
 453         if (!ret_val)
 454                 ret_val = mbx->ops.read(hw, msg, size);
 455
 456         return ret_val;
 457 }
 458
 459 /**
 460  * ixgbevf_write_mbx - Write a message to the mailbox and wait for ACK
 461  * @hw: pointer to the HW structure
 462  * @msg: The message buffer
 463  * @size: Length of buffer
 464  *
 465  * returns 0 if it successfully copied message into the buffer and
 466  * received an ACK to that message within specified period
 467  **/
 468 s32 ixgbevf_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
 469 {
 470         struct ixgbe_mbx_info *mbx = &hw->mbx;
 471         s32 ret_val = IXGBE_ERR_CONFIG;
 472
 473         /**
 474          * exit if either we can't write, release
 475          * or there is no timeout defined
 476          */
 477         if (!mbx->ops.write || !mbx->ops.check_for_ack || !mbx->ops.release ||
 478             !mbx->timeout)
 479                 return ret_val;
 480
 481         if (size > mbx->size)
 482                 ret_val = IXGBE_ERR_PARAM;
 483         else
 484                 ret_val = mbx->ops.write(hw, msg, size);
 485
 486         return ret_val;
 487 }
 488
 489 const struct ixgbe_mbx_operations ixgbevf_mbx_ops = {
 490         .init_params    = ixgbevf_init_mbx_params_vf,
 491         .release        = ixgbevf_release_mbx_lock_vf,
 492         .read           = ixgbevf_read_mbx_vf,
 493         .write          = ixgbevf_write_mbx_vf,
 494         .check_for_msg  = ixgbevf_check_for_msg_vf,
 495         .check_for_ack  = ixgbevf_check_for_ack_vf,
 496         .check_for_rst  = ixgbevf_check_for_rst_vf,
 497 };
 498
 499 const struct ixgbe_mbx_operations ixgbevf_mbx_ops_legacy = {
 500         .init_params    = ixgbevf_init_mbx_params_vf,
 501         .release        = ixgbevf_release_mbx_lock_vf_legacy,
 502         .read           = ixgbevf_read_mbx_vf_legacy,
 503         .write          = ixgbevf_write_mbx_vf_legacy,
 504         .check_for_msg  = ixgbevf_check_for_msg_vf,
 505         .check_for_ack  = ixgbevf_check_for_ack_vf,
 506         .check_for_rst  = ixgbevf_check_for_rst_vf,
 507 };
 508
 509 /* Mailbox operations when running on Hyper-V.
 510  * On Hyper-V, PF/VF communication is not through the
 511  * hardware mailbox; this communication is through
 512  * a software mediated path.
 513  * Most mail box operations are noop while running on
 514  * Hyper-V.
 515  */
 516 const struct ixgbe_mbx_operations ixgbevf_hv_mbx_ops = {
 517         .init_params    = ixgbevf_init_mbx_params_vf,
 518         .check_for_rst  = ixgbevf_check_for_rst_vf,
 519 };