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