1/* Intel(R) Gigabit Ethernet Linux driver 2 * Copyright(c) 2007-2014 Intel Corporation. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms and conditions of the GNU General Public License, 6 * version 2, as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * You should have received a copy of the GNU General Public License along with 14 * this program; if not, see <http://www.gnu.org/licenses/>. 15 * 16 * The full GNU General Public License is included in this distribution in 17 * the file called "COPYING". 18 * 19 * Contact Information: 20 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 21 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 22 */ 23 24#include "e1000_mbx.h" 25 26/** 27 * igb_read_mbx - Reads a message from the mailbox 28 * @hw: pointer to the HW structure 29 * @msg: The message buffer 30 * @size: Length of buffer 31 * @mbx_id: id of mailbox to read 32 * 33 * returns SUCCESS if it successfully read message from buffer 34 **/ 35s32 igb_read_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id) 36{ 37 struct e1000_mbx_info *mbx = &hw->mbx; 38 s32 ret_val = -E1000_ERR_MBX; 39 40 /* limit read to size of mailbox */ 41 if (size > mbx->size) 42 size = mbx->size; 43 44 if (mbx->ops.read) 45 ret_val = mbx->ops.read(hw, msg, size, mbx_id); 46 47 return ret_val; 48} 49 50/** 51 * igb_write_mbx - Write a message to the mailbox 52 * @hw: pointer to the HW structure 53 * @msg: The message buffer 54 * @size: Length of buffer 55 * @mbx_id: id of mailbox to write 56 * 57 * returns SUCCESS if it successfully copied message into the buffer 58 **/ 59s32 igb_write_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id) 60{ 61 struct e1000_mbx_info *mbx = &hw->mbx; 62 s32 ret_val = 0; 63 64 if (size > mbx->size) 65 ret_val = -E1000_ERR_MBX; 66 67 else if (mbx->ops.write) 68 ret_val = mbx->ops.write(hw, msg, size, mbx_id); 69 70 return ret_val; 71} 72 73/** 74 * igb_check_for_msg - checks to see if someone sent us mail 75 * @hw: pointer to the HW structure 76 * @mbx_id: id of mailbox to check 77 * 78 * returns SUCCESS if the Status bit was found or else ERR_MBX 79 **/ 80s32 igb_check_for_msg(struct e1000_hw *hw, u16 mbx_id) 81{ 82 struct e1000_mbx_info *mbx = &hw->mbx; 83 s32 ret_val = -E1000_ERR_MBX; 84 85 if (mbx->ops.check_for_msg) 86 ret_val = mbx->ops.check_for_msg(hw, mbx_id); 87 88 return ret_val; 89} 90 91/** 92 * igb_check_for_ack - checks to see if someone sent us ACK 93 * @hw: pointer to the HW structure 94 * @mbx_id: id of mailbox to check 95 * 96 * returns SUCCESS if the Status bit was found or else ERR_MBX 97 **/ 98s32 igb_check_for_ack(struct e1000_hw *hw, u16 mbx_id) 99{ 100 struct e1000_mbx_info *mbx = &hw->mbx; 101 s32 ret_val = -E1000_ERR_MBX; 102 103 if (mbx->ops.check_for_ack) 104 ret_val = mbx->ops.check_for_ack(hw, mbx_id); 105 106 return ret_val; 107} 108 109/** 110 * igb_check_for_rst - checks to see if other side has reset 111 * @hw: pointer to the HW structure 112 * @mbx_id: id of mailbox to check 113 * 114 * returns SUCCESS if the Status bit was found or else ERR_MBX 115 **/ 116s32 igb_check_for_rst(struct e1000_hw *hw, u16 mbx_id) 117{ 118 struct e1000_mbx_info *mbx = &hw->mbx; 119 s32 ret_val = -E1000_ERR_MBX; 120 121 if (mbx->ops.check_for_rst) 122 ret_val = mbx->ops.check_for_rst(hw, mbx_id); 123 124 return ret_val; 125} 126 127/** 128 * igb_poll_for_msg - Wait for message notification 129 * @hw: pointer to the HW structure 130 * @mbx_id: id of mailbox to write 131 * 132 * returns SUCCESS if it successfully received a message notification 133 **/ 134static s32 igb_poll_for_msg(struct e1000_hw *hw, u16 mbx_id) 135{ 136 struct e1000_mbx_info *mbx = &hw->mbx; 137 int countdown = mbx->timeout; 138 139 if (!countdown || !mbx->ops.check_for_msg) 140 goto out; 141 142 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) { 143 countdown--; 144 if (!countdown) 145 break; 146 udelay(mbx->usec_delay); 147 } 148 149 /* if we failed, all future posted messages fail until reset */ 150 if (!countdown) 151 mbx->timeout = 0; 152out: 153 return countdown ? 0 : -E1000_ERR_MBX; 154} 155 156/** 157 * igb_poll_for_ack - Wait for message acknowledgement 158 * @hw: pointer to the HW structure 159 * @mbx_id: id of mailbox to write 160 * 161 * returns SUCCESS if it successfully received a message acknowledgement 162 **/ 163static s32 igb_poll_for_ack(struct e1000_hw *hw, u16 mbx_id) 164{ 165 struct e1000_mbx_info *mbx = &hw->mbx; 166 int countdown = mbx->timeout; 167 168 if (!countdown || !mbx->ops.check_for_ack) 169 goto out; 170 171 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) { 172 countdown--; 173 if (!countdown) 174 break; 175 udelay(mbx->usec_delay); 176 } 177 178 /* if we failed, all future posted messages fail until reset */ 179 if (!countdown) 180 mbx->timeout = 0; 181out: 182 return countdown ? 0 : -E1000_ERR_MBX; 183} 184 185/** 186 * igb_read_posted_mbx - Wait for message notification and receive message 187 * @hw: pointer to the HW structure 188 * @msg: The message buffer 189 * @size: Length of buffer 190 * @mbx_id: id of mailbox to write 191 * 192 * returns SUCCESS if it successfully received a message notification and 193 * copied it into the receive buffer. 194 **/ 195static s32 igb_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, 196 u16 mbx_id) 197{ 198 struct e1000_mbx_info *mbx = &hw->mbx; 199 s32 ret_val = -E1000_ERR_MBX; 200 201 if (!mbx->ops.read) 202 goto out; 203 204 ret_val = igb_poll_for_msg(hw, mbx_id); 205 206 if (!ret_val) 207 ret_val = mbx->ops.read(hw, msg, size, mbx_id); 208out: 209 return ret_val; 210} 211 212/** 213 * igb_write_posted_mbx - Write a message to the mailbox, wait for ack 214 * @hw: pointer to the HW structure 215 * @msg: The message buffer 216 * @size: Length of buffer 217 * @mbx_id: id of mailbox to write 218 * 219 * returns SUCCESS if it successfully copied message into the buffer and 220 * received an ack to that message within delay * timeout period 221 **/ 222static s32 igb_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, 223 u16 mbx_id) 224{ 225 struct e1000_mbx_info *mbx = &hw->mbx; 226 s32 ret_val = -E1000_ERR_MBX; 227 228 /* exit if either we can't write or there isn't a defined timeout */ 229 if (!mbx->ops.write || !mbx->timeout) 230 goto out; 231 232 /* send msg */ 233 ret_val = mbx->ops.write(hw, msg, size, mbx_id); 234 235 /* if msg sent wait until we receive an ack */ 236 if (!ret_val) 237 ret_val = igb_poll_for_ack(hw, mbx_id); 238out: 239 return ret_val; 240} 241 242static s32 igb_check_for_bit_pf(struct e1000_hw *hw, u32 mask) 243{ 244 u32 mbvficr = rd32(E1000_MBVFICR); 245 s32 ret_val = -E1000_ERR_MBX; 246 247 if (mbvficr & mask) { 248 ret_val = 0; 249 wr32(E1000_MBVFICR, mask); 250 } 251 252 return ret_val; 253} 254 255/** 256 * igb_check_for_msg_pf - checks to see if the VF has sent mail 257 * @hw: pointer to the HW structure 258 * @vf_number: the VF index 259 * 260 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 261 **/ 262static s32 igb_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number) 263{ 264 s32 ret_val = -E1000_ERR_MBX; 265 266 if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) { 267 ret_val = 0; 268 hw->mbx.stats.reqs++; 269 } 270 271 return ret_val; 272} 273 274/** 275 * igb_check_for_ack_pf - checks to see if the VF has ACKed 276 * @hw: pointer to the HW structure 277 * @vf_number: the VF index 278 * 279 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 280 **/ 281static s32 igb_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number) 282{ 283 s32 ret_val = -E1000_ERR_MBX; 284 285 if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) { 286 ret_val = 0; 287 hw->mbx.stats.acks++; 288 } 289 290 return ret_val; 291} 292 293/** 294 * igb_check_for_rst_pf - checks to see if the VF has reset 295 * @hw: pointer to the HW structure 296 * @vf_number: the VF index 297 * 298 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 299 **/ 300static s32 igb_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number) 301{ 302 u32 vflre = rd32(E1000_VFLRE); 303 s32 ret_val = -E1000_ERR_MBX; 304 305 if (vflre & (1 << vf_number)) { 306 ret_val = 0; 307 wr32(E1000_VFLRE, (1 << vf_number)); 308 hw->mbx.stats.rsts++; 309 } 310 311 return ret_val; 312} 313 314/** 315 * igb_obtain_mbx_lock_pf - obtain mailbox lock 316 * @hw: pointer to the HW structure 317 * @vf_number: the VF index 318 * 319 * return SUCCESS if we obtained the mailbox lock 320 **/ 321static s32 igb_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number) 322{ 323 s32 ret_val = -E1000_ERR_MBX; 324 u32 p2v_mailbox; 325 326 /* Take ownership of the buffer */ 327 wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_PFU); 328 329 /* reserve mailbox for vf use */ 330 p2v_mailbox = rd32(E1000_P2VMAILBOX(vf_number)); 331 if (p2v_mailbox & E1000_P2VMAILBOX_PFU) 332 ret_val = 0; 333 334 return ret_val; 335} 336 337/** 338 * igb_write_mbx_pf - Places a message in the mailbox 339 * @hw: pointer to the HW structure 340 * @msg: The message buffer 341 * @size: Length of buffer 342 * @vf_number: the VF index 343 * 344 * returns SUCCESS if it successfully copied message into the buffer 345 **/ 346static s32 igb_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size, 347 u16 vf_number) 348{ 349 s32 ret_val; 350 u16 i; 351 352 /* lock the mailbox to prevent pf/vf race condition */ 353 ret_val = igb_obtain_mbx_lock_pf(hw, vf_number); 354 if (ret_val) 355 goto out_no_write; 356 357 /* flush msg and acks as we are overwriting the message buffer */ 358 igb_check_for_msg_pf(hw, vf_number); 359 igb_check_for_ack_pf(hw, vf_number); 360 361 /* copy the caller specified message to the mailbox memory buffer */ 362 for (i = 0; i < size; i++) 363 array_wr32(E1000_VMBMEM(vf_number), i, msg[i]); 364 365 /* Interrupt VF to tell it a message has been sent and release buffer*/ 366 wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS); 367 368 /* update stats */ 369 hw->mbx.stats.msgs_tx++; 370 371out_no_write: 372 return ret_val; 373 374} 375 376/** 377 * igb_read_mbx_pf - Read a message from the mailbox 378 * @hw: pointer to the HW structure 379 * @msg: The message buffer 380 * @size: Length of buffer 381 * @vf_number: the VF index 382 * 383 * This function copies a message from the mailbox buffer to the caller's 384 * memory buffer. The presumption is that the caller knows that there was 385 * a message due to a VF request so no polling for message is needed. 386 **/ 387static s32 igb_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size, 388 u16 vf_number) 389{ 390 s32 ret_val; 391 u16 i; 392 393 /* lock the mailbox to prevent pf/vf race condition */ 394 ret_val = igb_obtain_mbx_lock_pf(hw, vf_number); 395 if (ret_val) 396 goto out_no_read; 397 398 /* copy the message to the mailbox memory buffer */ 399 for (i = 0; i < size; i++) 400 msg[i] = array_rd32(E1000_VMBMEM(vf_number), i); 401 402 /* Acknowledge the message and release buffer */ 403 wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK); 404 405 /* update stats */ 406 hw->mbx.stats.msgs_rx++; 407 408out_no_read: 409 return ret_val; 410} 411 412/** 413 * e1000_init_mbx_params_pf - set initial values for pf mailbox 414 * @hw: pointer to the HW structure 415 * 416 * Initializes the hw->mbx struct to correct values for pf mailbox 417 */ 418s32 igb_init_mbx_params_pf(struct e1000_hw *hw) 419{ 420 struct e1000_mbx_info *mbx = &hw->mbx; 421 422 mbx->timeout = 0; 423 mbx->usec_delay = 0; 424 425 mbx->size = E1000_VFMAILBOX_SIZE; 426 427 mbx->ops.read = igb_read_mbx_pf; 428 mbx->ops.write = igb_write_mbx_pf; 429 mbx->ops.read_posted = igb_read_posted_mbx; 430 mbx->ops.write_posted = igb_write_posted_mbx; 431 mbx->ops.check_for_msg = igb_check_for_msg_pf; 432 mbx->ops.check_for_ack = igb_check_for_ack_pf; 433 mbx->ops.check_for_rst = igb_check_for_rst_pf; 434 435 mbx->stats.msgs_tx = 0; 436 mbx->stats.msgs_rx = 0; 437 mbx->stats.reqs = 0; 438 mbx->stats.acks = 0; 439 mbx->stats.rsts = 0; 440 441 return 0; 442} 443 444