1 /******************************************************************************* 2 3 Intel 10 Gigabit PCI Express Linux driver 4 Copyright(c) 1999 - 2014 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 Linux NICS <linux.nics@intel.com> 24 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 26 27 *******************************************************************************/ 28 29 #include <linux/pci.h> 30 #include <linux/delay.h> 31 #include "ixgbe.h" 32 #include "ixgbe_mbx.h" 33 34 /** 35 * ixgbe_read_mbx - Reads a message from the mailbox 36 * @hw: pointer to the HW structure 37 * @msg: The message buffer 38 * @size: Length of buffer 39 * @mbx_id: id of mailbox to read 40 * 41 * returns SUCCESS if it successfully read message from buffer 42 **/ 43 s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id) 44 { 45 struct ixgbe_mbx_info *mbx = &hw->mbx; 46 47 /* limit read to size of mailbox */ 48 if (size > mbx->size) 49 size = mbx->size; 50 51 if (!mbx->ops.read) 52 return IXGBE_ERR_MBX; 53 54 return mbx->ops.read(hw, msg, size, mbx_id); 55 } 56 57 /** 58 * ixgbe_write_mbx - Write a message to the mailbox 59 * @hw: pointer to the HW structure 60 * @msg: The message buffer 61 * @size: Length of buffer 62 * @mbx_id: id of mailbox to write 63 * 64 * returns SUCCESS if it successfully copied message into the buffer 65 **/ 66 s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id) 67 { 68 struct ixgbe_mbx_info *mbx = &hw->mbx; 69 70 if (size > mbx->size) 71 return IXGBE_ERR_MBX; 72 73 if (!mbx->ops.write) 74 return IXGBE_ERR_MBX; 75 76 return mbx->ops.write(hw, msg, size, mbx_id); 77 } 78 79 /** 80 * ixgbe_check_for_msg - checks to see if someone sent us mail 81 * @hw: pointer to the HW structure 82 * @mbx_id: id of mailbox to check 83 * 84 * returns SUCCESS if the Status bit was found or else ERR_MBX 85 **/ 86 s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id) 87 { 88 struct ixgbe_mbx_info *mbx = &hw->mbx; 89 90 if (!mbx->ops.check_for_msg) 91 return IXGBE_ERR_MBX; 92 93 return mbx->ops.check_for_msg(hw, mbx_id); 94 } 95 96 /** 97 * ixgbe_check_for_ack - checks to see if someone sent us ACK 98 * @hw: pointer to the HW structure 99 * @mbx_id: id of mailbox to check 100 * 101 * returns SUCCESS if the Status bit was found or else ERR_MBX 102 **/ 103 s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id) 104 { 105 struct ixgbe_mbx_info *mbx = &hw->mbx; 106 107 if (!mbx->ops.check_for_ack) 108 return IXGBE_ERR_MBX; 109 110 return mbx->ops.check_for_ack(hw, mbx_id); 111 } 112 113 /** 114 * ixgbe_check_for_rst - checks to see if other side has reset 115 * @hw: pointer to the HW structure 116 * @mbx_id: id of mailbox to check 117 * 118 * returns SUCCESS if the Status bit was found or else ERR_MBX 119 **/ 120 s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id) 121 { 122 struct ixgbe_mbx_info *mbx = &hw->mbx; 123 124 if (!mbx->ops.check_for_rst) 125 return IXGBE_ERR_MBX; 126 127 return mbx->ops.check_for_rst(hw, mbx_id); 128 } 129 130 /** 131 * ixgbe_poll_for_msg - Wait for message notification 132 * @hw: pointer to the HW structure 133 * @mbx_id: id of mailbox to write 134 * 135 * returns SUCCESS if it successfully received a message notification 136 **/ 137 static s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id) 138 { 139 struct ixgbe_mbx_info *mbx = &hw->mbx; 140 int countdown = mbx->timeout; 141 142 if (!countdown || !mbx->ops.check_for_msg) 143 return IXGBE_ERR_MBX; 144 145 while (mbx->ops.check_for_msg(hw, mbx_id)) { 146 countdown--; 147 if (!countdown) 148 return IXGBE_ERR_MBX; 149 udelay(mbx->usec_delay); 150 } 151 152 return 0; 153 } 154 155 /** 156 * ixgbe_poll_for_ack - Wait for message acknowledgement 157 * @hw: pointer to the HW structure 158 * @mbx_id: id of mailbox to write 159 * 160 * returns SUCCESS if it successfully received a message acknowledgement 161 **/ 162 static s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id) 163 { 164 struct ixgbe_mbx_info *mbx = &hw->mbx; 165 int countdown = mbx->timeout; 166 167 if (!countdown || !mbx->ops.check_for_ack) 168 return IXGBE_ERR_MBX; 169 170 while (mbx->ops.check_for_ack(hw, mbx_id)) { 171 countdown--; 172 if (!countdown) 173 return IXGBE_ERR_MBX; 174 udelay(mbx->usec_delay); 175 } 176 177 return 0; 178 } 179 180 /** 181 * ixgbe_read_posted_mbx - Wait for message notification and receive message 182 * @hw: pointer to the HW structure 183 * @msg: The message buffer 184 * @size: Length of buffer 185 * @mbx_id: id of mailbox to write 186 * 187 * returns SUCCESS if it successfully received a message notification and 188 * copied it into the receive buffer. 189 **/ 190 static s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, 191 u16 mbx_id) 192 { 193 struct ixgbe_mbx_info *mbx = &hw->mbx; 194 s32 ret_val; 195 196 if (!mbx->ops.read) 197 return IXGBE_ERR_MBX; 198 199 ret_val = ixgbe_poll_for_msg(hw, mbx_id); 200 if (ret_val) 201 return ret_val; 202 203 /* if ack received read message */ 204 return mbx->ops.read(hw, msg, size, mbx_id); 205 } 206 207 /** 208 * ixgbe_write_posted_mbx - Write a message to the mailbox, wait for ack 209 * @hw: pointer to the HW structure 210 * @msg: The message buffer 211 * @size: Length of buffer 212 * @mbx_id: id of mailbox to write 213 * 214 * returns SUCCESS if it successfully copied message into the buffer and 215 * received an ack to that message within delay * timeout period 216 **/ 217 static s32 ixgbe_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, 218 u16 mbx_id) 219 { 220 struct ixgbe_mbx_info *mbx = &hw->mbx; 221 s32 ret_val; 222 223 /* exit if either we can't write or there isn't a defined timeout */ 224 if (!mbx->ops.write || !mbx->timeout) 225 return IXGBE_ERR_MBX; 226 227 /* send msg */ 228 ret_val = mbx->ops.write(hw, msg, size, mbx_id); 229 if (ret_val) 230 return ret_val; 231 232 /* if msg sent wait until we receive an ack */ 233 return ixgbe_poll_for_ack(hw, mbx_id); 234 } 235 236 static s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index) 237 { 238 u32 mbvficr = IXGBE_READ_REG(hw, IXGBE_MBVFICR(index)); 239 240 if (mbvficr & mask) { 241 IXGBE_WRITE_REG(hw, IXGBE_MBVFICR(index), mask); 242 return 0; 243 } 244 245 return IXGBE_ERR_MBX; 246 } 247 248 /** 249 * ixgbe_check_for_msg_pf - checks to see if the VF has sent mail 250 * @hw: pointer to the HW structure 251 * @vf_number: the VF index 252 * 253 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 254 **/ 255 static s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_number) 256 { 257 s32 index = IXGBE_MBVFICR_INDEX(vf_number); 258 u32 vf_bit = vf_number % 16; 259 260 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFREQ_VF1 << vf_bit, 261 index)) { 262 hw->mbx.stats.reqs++; 263 return 0; 264 } 265 266 return IXGBE_ERR_MBX; 267 } 268 269 /** 270 * ixgbe_check_for_ack_pf - checks to see if the VF has ACKed 271 * @hw: pointer to the HW structure 272 * @vf_number: the VF index 273 * 274 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 275 **/ 276 static s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_number) 277 { 278 s32 index = IXGBE_MBVFICR_INDEX(vf_number); 279 u32 vf_bit = vf_number % 16; 280 281 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFACK_VF1 << vf_bit, 282 index)) { 283 hw->mbx.stats.acks++; 284 return 0; 285 } 286 287 return IXGBE_ERR_MBX; 288 } 289 290 /** 291 * ixgbe_check_for_rst_pf - checks to see if the VF has reset 292 * @hw: pointer to the HW structure 293 * @vf_number: the VF index 294 * 295 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX 296 **/ 297 static s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number) 298 { 299 u32 reg_offset = (vf_number < 32) ? 0 : 1; 300 u32 vf_shift = vf_number % 32; 301 u32 vflre = 0; 302 303 switch (hw->mac.type) { 304 case ixgbe_mac_82599EB: 305 vflre = IXGBE_READ_REG(hw, IXGBE_VFLRE(reg_offset)); 306 break; 307 case ixgbe_mac_X540: 308 case ixgbe_mac_X550: 309 case ixgbe_mac_X550EM_x: 310 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset)); 311 break; 312 default: 313 break; 314 } 315 316 if (vflre & (1 << vf_shift)) { 317 IXGBE_WRITE_REG(hw, IXGBE_VFLREC(reg_offset), (1 << vf_shift)); 318 hw->mbx.stats.rsts++; 319 return 0; 320 } 321 322 return IXGBE_ERR_MBX; 323 } 324 325 /** 326 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock 327 * @hw: pointer to the HW structure 328 * @vf_number: the VF index 329 * 330 * return SUCCESS if we obtained the mailbox lock 331 **/ 332 static s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number) 333 { 334 u32 p2v_mailbox; 335 336 /* Take ownership of the buffer */ 337 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU); 338 339 /* reserve mailbox for vf use */ 340 p2v_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_number)); 341 if (p2v_mailbox & IXGBE_PFMAILBOX_PFU) 342 return 0; 343 344 return IXGBE_ERR_MBX; 345 } 346 347 /** 348 * ixgbe_write_mbx_pf - Places a message in the mailbox 349 * @hw: pointer to the HW structure 350 * @msg: The message buffer 351 * @size: Length of buffer 352 * @vf_number: the VF index 353 * 354 * returns SUCCESS if it successfully copied message into the buffer 355 **/ 356 static s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size, 357 u16 vf_number) 358 { 359 s32 ret_val; 360 u16 i; 361 362 /* lock the mailbox to prevent pf/vf race condition */ 363 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number); 364 if (ret_val) 365 return ret_val; 366 367 /* flush msg and acks as we are overwriting the message buffer */ 368 ixgbe_check_for_msg_pf(hw, vf_number); 369 ixgbe_check_for_ack_pf(hw, vf_number); 370 371 /* copy the caller specified message to the mailbox memory buffer */ 372 for (i = 0; i < size; i++) 373 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i, msg[i]); 374 375 /* Interrupt VF to tell it a message has been sent and release buffer*/ 376 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_STS); 377 378 /* update stats */ 379 hw->mbx.stats.msgs_tx++; 380 381 return 0; 382 } 383 384 /** 385 * ixgbe_read_mbx_pf - Read a message from the mailbox 386 * @hw: pointer to the HW structure 387 * @msg: The message buffer 388 * @size: Length of buffer 389 * @vf_number: the VF index 390 * 391 * This function copies a message from the mailbox buffer to the caller's 392 * memory buffer. The presumption is that the caller knows that there was 393 * a message due to a VF request so no polling for message is needed. 394 **/ 395 static s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size, 396 u16 vf_number) 397 { 398 s32 ret_val; 399 u16 i; 400 401 /* lock the mailbox to prevent pf/vf race condition */ 402 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number); 403 if (ret_val) 404 return ret_val; 405 406 /* copy the message to the mailbox memory buffer */ 407 for (i = 0; i < size; i++) 408 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i); 409 410 /* Acknowledge the message and release buffer */ 411 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK); 412 413 /* update stats */ 414 hw->mbx.stats.msgs_rx++; 415 416 return 0; 417 } 418 419 #ifdef CONFIG_PCI_IOV 420 /** 421 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox 422 * @hw: pointer to the HW structure 423 * 424 * Initializes the hw->mbx struct to correct values for pf mailbox 425 */ 426 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw) 427 { 428 struct ixgbe_mbx_info *mbx = &hw->mbx; 429 430 if (hw->mac.type != ixgbe_mac_82599EB && 431 hw->mac.type != ixgbe_mac_X550 && 432 hw->mac.type != ixgbe_mac_X550EM_x && 433 hw->mac.type != ixgbe_mac_X540) 434 return; 435 436 mbx->timeout = 0; 437 mbx->usec_delay = 0; 438 439 mbx->stats.msgs_tx = 0; 440 mbx->stats.msgs_rx = 0; 441 mbx->stats.reqs = 0; 442 mbx->stats.acks = 0; 443 mbx->stats.rsts = 0; 444 445 mbx->size = IXGBE_VFMAILBOX_SIZE; 446 } 447 #endif /* CONFIG_PCI_IOV */ 448 449 struct ixgbe_mbx_operations mbx_ops_generic = { 450 .read = ixgbe_read_mbx_pf, 451 .write = ixgbe_write_mbx_pf, 452 .read_posted = ixgbe_read_posted_mbx, 453 .write_posted = ixgbe_write_posted_mbx, 454 .check_for_msg = ixgbe_check_for_msg_pf, 455 .check_for_ack = ixgbe_check_for_ack_pf, 456 .check_for_rst = ixgbe_check_for_rst_pf, 457 }; 458 459