1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2009 - 2018 Intel Corporation. */ 3 4 #include <linux/bitfield.h> 5 #include "mbx.h" 6 7 /** 8 * e1000_poll_for_msg - Wait for message notification 9 * @hw: pointer to the HW structure 10 * 11 * returns SUCCESS if it successfully received a message notification 12 **/ 13 static s32 e1000_poll_for_msg(struct e1000_hw *hw) 14 { 15 struct e1000_mbx_info *mbx = &hw->mbx; 16 int countdown = mbx->timeout; 17 18 if (!mbx->ops.check_for_msg) 19 goto out; 20 21 while (countdown && mbx->ops.check_for_msg(hw)) { 22 countdown--; 23 udelay(mbx->usec_delay); 24 } 25 26 /* if we failed, all future posted messages fail until reset */ 27 if (!countdown) 28 mbx->timeout = 0; 29 out: 30 return countdown ? E1000_SUCCESS : -E1000_ERR_MBX; 31 } 32 33 /** 34 * e1000_poll_for_ack - Wait for message acknowledgment 35 * @hw: pointer to the HW structure 36 * 37 * returns SUCCESS if it successfully received a message acknowledgment 38 **/ 39 static s32 e1000_poll_for_ack(struct e1000_hw *hw) 40 { 41 struct e1000_mbx_info *mbx = &hw->mbx; 42 int countdown = mbx->timeout; 43 44 if (!mbx->ops.check_for_ack) 45 goto out; 46 47 while (countdown && mbx->ops.check_for_ack(hw)) { 48 countdown--; 49 udelay(mbx->usec_delay); 50 } 51 52 /* if we failed, all future posted messages fail until reset */ 53 if (!countdown) 54 mbx->timeout = 0; 55 out: 56 return countdown ? E1000_SUCCESS : -E1000_ERR_MBX; 57 } 58 59 /** 60 * e1000_read_posted_mbx - Wait for message notification and receive message 61 * @hw: pointer to the HW structure 62 * @msg: The message buffer 63 * @size: Length of buffer 64 * 65 * returns SUCCESS if it successfully received a message notification and 66 * copied it into the receive buffer. 67 **/ 68 static s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size) 69 { 70 struct e1000_mbx_info *mbx = &hw->mbx; 71 s32 ret_val = -E1000_ERR_MBX; 72 73 if (!mbx->ops.read) 74 goto out; 75 76 ret_val = e1000_poll_for_msg(hw); 77 78 /* if ack received read message, otherwise we timed out */ 79 if (!ret_val) 80 ret_val = mbx->ops.read(hw, msg, size); 81 out: 82 return ret_val; 83 } 84 85 /** 86 * e1000_write_posted_mbx - Write a message to the mailbox, wait for ack 87 * @hw: pointer to the HW structure 88 * @msg: The message buffer 89 * @size: Length of buffer 90 * 91 * returns SUCCESS if it successfully copied message into the buffer and 92 * received an ack to that message within delay * timeout period 93 **/ 94 static s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size) 95 { 96 struct e1000_mbx_info *mbx = &hw->mbx; 97 s32 ret_val = -E1000_ERR_MBX; 98 99 /* exit if we either can't write or there isn't a defined timeout */ 100 if (!mbx->ops.write || !mbx->timeout) 101 goto out; 102 103 /* send msg*/ 104 ret_val = mbx->ops.write(hw, msg, size); 105 106 /* if msg sent wait until we receive an ack */ 107 if (!ret_val) 108 ret_val = e1000_poll_for_ack(hw); 109 out: 110 return ret_val; 111 } 112 113 /** 114 * e1000_read_v2p_mailbox - read v2p mailbox 115 * @hw: pointer to the HW structure 116 * 117 * This function is used to read the v2p mailbox without losing the read to 118 * clear status bits. 119 **/ 120 static u32 e1000_read_v2p_mailbox(struct e1000_hw *hw) 121 { 122 u32 v2p_mailbox = er32(V2PMAILBOX(0)); 123 124 v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox; 125 hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS; 126 127 return v2p_mailbox; 128 } 129 130 /** 131 * e1000_check_for_bit_vf - Determine if a status bit was set 132 * @hw: pointer to the HW structure 133 * @mask: bitmask for bits to be tested and cleared 134 * 135 * This function is used to check for the read to clear bits within 136 * the V2P mailbox. 137 **/ 138 static s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask) 139 { 140 u32 v2p_mailbox = e1000_read_v2p_mailbox(hw); 141 s32 ret_val = -E1000_ERR_MBX; 142 143 if (v2p_mailbox & mask) 144 ret_val = E1000_SUCCESS; 145 146 hw->dev_spec.vf.v2p_mailbox &= ~mask; 147 148 return ret_val; 149 } 150 151 /** 152 * e1000_check_for_msg_vf - checks to see if the PF has sent mail 153 * @hw: pointer to the HW structure 154 * 155 * returns SUCCESS if the PF has set the Status bit or else ERR_MBX 156 **/ 157 static s32 e1000_check_for_msg_vf(struct e1000_hw *hw) 158 { 159 s32 ret_val = -E1000_ERR_MBX; 160 161 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) { 162 ret_val = E1000_SUCCESS; 163 hw->mbx.stats.reqs++; 164 } 165 166 return ret_val; 167 } 168 169 /** 170 * e1000_check_for_ack_vf - checks to see if the PF has ACK'd 171 * @hw: pointer to the HW structure 172 * 173 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX 174 **/ 175 static s32 e1000_check_for_ack_vf(struct e1000_hw *hw) 176 { 177 s32 ret_val = -E1000_ERR_MBX; 178 179 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) { 180 ret_val = E1000_SUCCESS; 181 hw->mbx.stats.acks++; 182 } 183 184 return ret_val; 185 } 186 187 /** 188 * e1000_check_for_rst_vf - checks to see if the PF has reset 189 * @hw: pointer to the HW structure 190 * 191 * returns true if the PF has set the reset done bit or else false 192 **/ 193 static s32 e1000_check_for_rst_vf(struct e1000_hw *hw) 194 { 195 s32 ret_val = -E1000_ERR_MBX; 196 197 if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD | 198 E1000_V2PMAILBOX_RSTI))) { 199 ret_val = E1000_SUCCESS; 200 hw->mbx.stats.rsts++; 201 } 202 203 return ret_val; 204 } 205 206 /** 207 * e1000_obtain_mbx_lock_vf - obtain mailbox lock 208 * @hw: pointer to the HW structure 209 * 210 * return SUCCESS if we obtained the mailbox lock 211 **/ 212 static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw) 213 { 214 s32 ret_val = -E1000_ERR_MBX; 215 int count = 10; 216 217 do { 218 /* Take ownership of the buffer */ 219 ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_VFU); 220 221 /* reserve mailbox for VF use */ 222 if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU) { 223 ret_val = 0; 224 break; 225 } 226 udelay(1000); 227 } while (count-- > 0); 228 229 return ret_val; 230 } 231 232 /** 233 * e1000_write_mbx_vf - Write a message to the mailbox 234 * @hw: pointer to the HW structure 235 * @msg: The message buffer 236 * @size: Length of buffer 237 * 238 * returns SUCCESS if it successfully copied message into the buffer 239 **/ 240 static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size) 241 { 242 s32 err; 243 u16 i; 244 245 lockdep_assert_held(&hw->mbx_lock); 246 247 /* lock the mailbox to prevent pf/vf race condition */ 248 err = e1000_obtain_mbx_lock_vf(hw); 249 if (err) 250 goto out_no_write; 251 252 /* flush any ack or msg as we are going to overwrite mailbox */ 253 e1000_check_for_ack_vf(hw); 254 e1000_check_for_msg_vf(hw); 255 256 /* copy the caller specified message to the mailbox memory buffer */ 257 for (i = 0; i < size; i++) 258 array_ew32(VMBMEM(0), i, msg[i]); 259 260 /* update stats */ 261 hw->mbx.stats.msgs_tx++; 262 263 /* Drop VFU and interrupt the PF to tell it a message has been sent */ 264 ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_REQ); 265 266 out_no_write: 267 return err; 268 } 269 270 /** 271 * e1000_read_mbx_vf - Reads a message from the inbox intended for VF 272 * @hw: pointer to the HW structure 273 * @msg: The message buffer 274 * @size: Length of buffer 275 * 276 * returns SUCCESS if it successfully read message from buffer 277 **/ 278 static s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size) 279 { 280 s32 err; 281 u16 i; 282 283 lockdep_assert_held(&hw->mbx_lock); 284 285 /* lock the mailbox to prevent pf/vf race condition */ 286 err = e1000_obtain_mbx_lock_vf(hw); 287 if (err) 288 goto out_no_read; 289 290 /* copy the message from the mailbox memory buffer */ 291 for (i = 0; i < size; i++) 292 msg[i] = array_er32(VMBMEM(0), i); 293 294 /* Acknowledge receipt and release mailbox, then we're done */ 295 ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_ACK); 296 297 /* update stats */ 298 hw->mbx.stats.msgs_rx++; 299 300 out_no_read: 301 return err; 302 } 303 304 /** 305 * e1000_init_mbx_params_vf - set initial values for VF mailbox 306 * @hw: pointer to the HW structure 307 * 308 * Initializes the hw->mbx struct to correct values for VF mailbox 309 */ 310 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw) 311 { 312 struct e1000_mbx_info *mbx = &hw->mbx; 313 314 /* start mailbox as timed out and let the reset_hw call set the timeout 315 * value to being communications 316 */ 317 mbx->timeout = 0; 318 mbx->usec_delay = E1000_VF_MBX_INIT_DELAY; 319 320 mbx->size = E1000_VFMAILBOX_SIZE; 321 322 mbx->ops.read = e1000_read_mbx_vf; 323 mbx->ops.write = e1000_write_mbx_vf; 324 mbx->ops.read_posted = e1000_read_posted_mbx; 325 mbx->ops.write_posted = e1000_write_posted_mbx; 326 mbx->ops.check_for_msg = e1000_check_for_msg_vf; 327 mbx->ops.check_for_ack = e1000_check_for_ack_vf; 328 mbx->ops.check_for_rst = e1000_check_for_rst_vf; 329 330 mbx->stats.msgs_tx = 0; 331 mbx->stats.msgs_rx = 0; 332 mbx->stats.reqs = 0; 333 mbx->stats.acks = 0; 334 mbx->stats.rsts = 0; 335 336 return E1000_SUCCESS; 337 } 338