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