Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2001-2020 Intel Corporation
3 : : */
4 : :
5 : :
6 : : #include "e1000_api.h"
7 : :
8 : :
9 : : STATIC s32 e1000_init_phy_params_vf(struct e1000_hw *hw);
10 : : STATIC s32 e1000_init_nvm_params_vf(struct e1000_hw *hw);
11 : : STATIC void e1000_release_vf(struct e1000_hw *hw);
12 : : STATIC s32 e1000_acquire_vf(struct e1000_hw *hw);
13 : : STATIC s32 e1000_setup_link_vf(struct e1000_hw *hw);
14 : : STATIC s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw);
15 : : STATIC s32 e1000_init_mac_params_vf(struct e1000_hw *hw);
16 : : STATIC s32 e1000_check_for_link_vf(struct e1000_hw *hw);
17 : : STATIC s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
18 : : u16 *duplex);
19 : : STATIC s32 e1000_init_hw_vf(struct e1000_hw *hw);
20 : : STATIC s32 e1000_reset_hw_vf(struct e1000_hw *hw);
21 : : STATIC void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, u32);
22 : : STATIC int e1000_rar_set_vf(struct e1000_hw *, u8 *, u32);
23 : : STATIC s32 e1000_read_mac_addr_vf(struct e1000_hw *);
24 : :
25 : : /**
26 : : * e1000_init_phy_params_vf - Inits PHY params
27 : : * @hw: pointer to the HW structure
28 : : *
29 : : * Doesn't do much - there's no PHY available to the VF.
30 : : **/
31 : 0 : STATIC s32 e1000_init_phy_params_vf(struct e1000_hw *hw)
32 : : {
33 : 0 : DEBUGFUNC("e1000_init_phy_params_vf");
34 : 0 : hw->phy.type = e1000_phy_vf;
35 : 0 : hw->phy.ops.acquire = e1000_acquire_vf;
36 : 0 : hw->phy.ops.release = e1000_release_vf;
37 : :
38 : 0 : return E1000_SUCCESS;
39 : : }
40 : :
41 : : /**
42 : : * e1000_init_nvm_params_vf - Inits NVM params
43 : : * @hw: pointer to the HW structure
44 : : *
45 : : * Doesn't do much - there's no NVM available to the VF.
46 : : **/
47 : 0 : STATIC s32 e1000_init_nvm_params_vf(struct e1000_hw *hw)
48 : : {
49 : 0 : DEBUGFUNC("e1000_init_nvm_params_vf");
50 : 0 : hw->nvm.type = e1000_nvm_none;
51 : 0 : hw->nvm.ops.acquire = e1000_acquire_vf;
52 : 0 : hw->nvm.ops.release = e1000_release_vf;
53 : :
54 : 0 : return E1000_SUCCESS;
55 : : }
56 : :
57 : : /**
58 : : * e1000_init_mac_params_vf - Inits MAC params
59 : : * @hw: pointer to the HW structure
60 : : **/
61 : 0 : STATIC s32 e1000_init_mac_params_vf(struct e1000_hw *hw)
62 : : {
63 : : struct e1000_mac_info *mac = &hw->mac;
64 : :
65 : 0 : DEBUGFUNC("e1000_init_mac_params_vf");
66 : :
67 : : /* Set media type */
68 : : /*
69 : : * Virtual functions don't care what they're media type is as they
70 : : * have no direct access to the PHY, or the media. That is handled
71 : : * by the physical function driver.
72 : : */
73 : 0 : hw->phy.media_type = e1000_media_type_unknown;
74 : :
75 : : /* No ASF features for the VF driver */
76 : 0 : mac->asf_firmware_present = false;
77 : : /* ARC subsystem not supported */
78 : 0 : mac->arc_subsystem_valid = false;
79 : : /* Disable adaptive IFS mode so the generic funcs don't do anything */
80 : 0 : mac->adaptive_ifs = false;
81 : : /* VF's have no MTA Registers - PF feature only */
82 : 0 : mac->mta_reg_count = 128;
83 : : /* VF's have no access to RAR entries */
84 : 0 : mac->rar_entry_count = 1;
85 : :
86 : : /* Function pointers */
87 : : /* link setup */
88 : 0 : mac->ops.setup_link = e1000_setup_link_vf;
89 : : /* bus type/speed/width */
90 : 0 : mac->ops.get_bus_info = e1000_get_bus_info_pcie_vf;
91 : : /* reset */
92 : 0 : mac->ops.reset_hw = e1000_reset_hw_vf;
93 : : /* hw initialization */
94 : 0 : mac->ops.init_hw = e1000_init_hw_vf;
95 : : /* check for link */
96 : 0 : mac->ops.check_for_link = e1000_check_for_link_vf;
97 : : /* link info */
98 : 0 : mac->ops.get_link_up_info = e1000_get_link_up_info_vf;
99 : : /* multicast address update */
100 : 0 : mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_vf;
101 : : /* set mac address */
102 : 0 : mac->ops.rar_set = e1000_rar_set_vf;
103 : : /* read mac address */
104 : 0 : mac->ops.read_mac_addr = e1000_read_mac_addr_vf;
105 : :
106 : :
107 : 0 : return E1000_SUCCESS;
108 : : }
109 : :
110 : : /**
111 : : * e1000_init_function_pointers_vf - Inits function pointers
112 : : * @hw: pointer to the HW structure
113 : : **/
114 : 0 : void e1000_init_function_pointers_vf(struct e1000_hw *hw)
115 : : {
116 : 0 : DEBUGFUNC("e1000_init_function_pointers_vf");
117 : :
118 : 0 : hw->mac.ops.init_params = e1000_init_mac_params_vf;
119 : 0 : hw->nvm.ops.init_params = e1000_init_nvm_params_vf;
120 : 0 : hw->phy.ops.init_params = e1000_init_phy_params_vf;
121 : 0 : hw->mbx.ops.init_params = e1000_init_mbx_params_vf;
122 : 0 : }
123 : :
124 : : /**
125 : : * e1000_acquire_vf - Acquire rights to access PHY or NVM.
126 : : * @hw: pointer to the HW structure
127 : : *
128 : : * There is no PHY or NVM so we want all attempts to acquire these to fail.
129 : : * In addition, the MAC registers to access PHY/NVM don't exist so we don't
130 : : * even want any SW to attempt to use them.
131 : : **/
132 : 0 : STATIC s32 e1000_acquire_vf(struct e1000_hw E1000_UNUSEDARG *hw)
133 : : {
134 : : UNREFERENCED_1PARAMETER(hw);
135 : 0 : return -E1000_ERR_PHY;
136 : : }
137 : :
138 : : /**
139 : : * e1000_release_vf - Release PHY or NVM
140 : : * @hw: pointer to the HW structure
141 : : *
142 : : * There is no PHY or NVM so we want all attempts to acquire these to fail.
143 : : * In addition, the MAC registers to access PHY/NVM don't exist so we don't
144 : : * even want any SW to attempt to use them.
145 : : **/
146 : 0 : STATIC void e1000_release_vf(struct e1000_hw E1000_UNUSEDARG *hw)
147 : : {
148 : : UNREFERENCED_1PARAMETER(hw);
149 : 0 : return;
150 : : }
151 : :
152 : : /**
153 : : * e1000_setup_link_vf - Sets up link.
154 : : * @hw: pointer to the HW structure
155 : : *
156 : : * Virtual functions cannot change link.
157 : : **/
158 : 0 : STATIC s32 e1000_setup_link_vf(struct e1000_hw E1000_UNUSEDARG *hw)
159 : : {
160 : 0 : DEBUGFUNC("e1000_setup_link_vf");
161 : : UNREFERENCED_1PARAMETER(hw);
162 : :
163 : 0 : return E1000_SUCCESS;
164 : : }
165 : :
166 : : /**
167 : : * e1000_get_bus_info_pcie_vf - Gets the bus info.
168 : : * @hw: pointer to the HW structure
169 : : *
170 : : * Virtual functions are not really on their own bus.
171 : : **/
172 : 0 : STATIC s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw)
173 : : {
174 : : struct e1000_bus_info *bus = &hw->bus;
175 : :
176 : 0 : DEBUGFUNC("e1000_get_bus_info_pcie_vf");
177 : :
178 : : /* Do not set type PCI-E because we don't want disable master to run */
179 : 0 : bus->type = e1000_bus_type_reserved;
180 : 0 : bus->speed = e1000_bus_speed_2500;
181 : :
182 : 0 : return 0;
183 : : }
184 : :
185 : : /**
186 : : * e1000_get_link_up_info_vf - Gets link info.
187 : : * @hw: pointer to the HW structure
188 : : * @speed: pointer to 16 bit value to store link speed.
189 : : * @duplex: pointer to 16 bit value to store duplex.
190 : : *
191 : : * Since we cannot read the PHY and get accurate link info, we must rely upon
192 : : * the status register's data which is often stale and inaccurate.
193 : : **/
194 : 0 : STATIC s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
195 : : u16 *duplex)
196 : : {
197 : : s32 status;
198 : :
199 : 0 : DEBUGFUNC("e1000_get_link_up_info_vf");
200 : :
201 : 0 : status = E1000_READ_REG(hw, E1000_STATUS);
202 [ # # ]: 0 : if (status & E1000_STATUS_SPEED_1000) {
203 : 0 : *speed = SPEED_1000;
204 : 0 : DEBUGOUT("1000 Mbs, ");
205 [ # # ]: 0 : } else if (status & E1000_STATUS_SPEED_100) {
206 : 0 : *speed = SPEED_100;
207 : 0 : DEBUGOUT("100 Mbs, ");
208 : : } else {
209 : 0 : *speed = SPEED_10;
210 : 0 : DEBUGOUT("10 Mbs, ");
211 : : }
212 : :
213 [ # # ]: 0 : if (status & E1000_STATUS_FD) {
214 : 0 : *duplex = FULL_DUPLEX;
215 : 0 : DEBUGOUT("Full Duplex\n");
216 : : } else {
217 : 0 : *duplex = HALF_DUPLEX;
218 : 0 : DEBUGOUT("Half Duplex\n");
219 : : }
220 : :
221 : 0 : return E1000_SUCCESS;
222 : : }
223 : :
224 : : /**
225 : : * e1000_reset_hw_vf - Resets the HW
226 : : * @hw: pointer to the HW structure
227 : : *
228 : : * VF's provide a function level reset. This is done using bit 26 of ctrl_reg.
229 : : * This is all the reset we can perform on a VF.
230 : : **/
231 : 0 : STATIC s32 e1000_reset_hw_vf(struct e1000_hw *hw)
232 : : {
233 : : struct e1000_mbx_info *mbx = &hw->mbx;
234 : : u32 timeout = E1000_VF_INIT_TIMEOUT;
235 : : s32 ret_val = -E1000_ERR_MAC_INIT;
236 : : u32 ctrl, msgbuf[3];
237 : : u8 *addr = (u8 *)(&msgbuf[1]);
238 : :
239 : 0 : DEBUGFUNC("e1000_reset_hw_vf");
240 : :
241 : 0 : DEBUGOUT("Issuing a function level reset to MAC\n");
242 : 0 : ctrl = E1000_READ_REG(hw, E1000_CTRL);
243 : 0 : E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
244 : :
245 : : /* we cannot reset while the RSTI / RSTD bits are asserted */
246 [ # # # # ]: 0 : while (!mbx->ops.check_for_rst(hw, 0) && timeout) {
247 : 0 : timeout--;
248 : 0 : usec_delay(5);
249 : : }
250 : :
251 [ # # ]: 0 : if (timeout) {
252 : : /* mailbox timeout can now become active */
253 : 0 : mbx->timeout = E1000_VF_MBX_INIT_TIMEOUT;
254 : :
255 : 0 : msgbuf[0] = E1000_VF_RESET;
256 : 0 : mbx->ops.write_posted(hw, msgbuf, 1, 0);
257 : :
258 : 0 : msec_delay(10);
259 : :
260 : : /* set our "perm_addr" based on info provided by PF */
261 : 0 : ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
262 [ # # ]: 0 : if (!ret_val) {
263 [ # # ]: 0 : if (msgbuf[0] == (E1000_VF_RESET |
264 : : E1000_VT_MSGTYPE_ACK))
265 : 0 : memcpy(hw->mac.perm_addr, addr, 6);
266 : : else
267 : : ret_val = -E1000_ERR_MAC_INIT;
268 : : }
269 : : }
270 : :
271 : 0 : return ret_val;
272 : : }
273 : :
274 : : /**
275 : : * e1000_init_hw_vf - Inits the HW
276 : : * @hw: pointer to the HW structure
277 : : *
278 : : * Not much to do here except clear the PF Reset indication if there is one.
279 : : **/
280 : 0 : STATIC s32 e1000_init_hw_vf(struct e1000_hw *hw)
281 : : {
282 : 0 : DEBUGFUNC("e1000_init_hw_vf");
283 : :
284 : : /* attempt to set and restore our mac address */
285 : 0 : e1000_rar_set_vf(hw, hw->mac.addr, 0);
286 : :
287 : 0 : return E1000_SUCCESS;
288 : : }
289 : :
290 : : /**
291 : : * e1000_rar_set_vf - set device MAC address
292 : : * @hw: pointer to the HW structure
293 : : * @addr: pointer to the receive address
294 : : * @index receive address array register
295 : : **/
296 : 0 : STATIC int e1000_rar_set_vf(struct e1000_hw *hw, u8 *addr,
297 : : u32 E1000_UNUSEDARG index)
298 : : {
299 : : struct e1000_mbx_info *mbx = &hw->mbx;
300 : : u32 msgbuf[3];
301 : : u8 *msg_addr = (u8 *)(&msgbuf[1]);
302 : : s32 ret_val;
303 : :
304 : : UNREFERENCED_1PARAMETER(index);
305 : : memset(msgbuf, 0, 12);
306 : 0 : msgbuf[0] = E1000_VF_SET_MAC_ADDR;
307 : : memcpy(msg_addr, addr, 6);
308 : 0 : ret_val = mbx->ops.write_posted(hw, msgbuf, 3, 0);
309 : :
310 [ # # ]: 0 : if (!ret_val)
311 : 0 : ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
312 : :
313 : 0 : msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS;
314 : :
315 : : /* if nacked the address was rejected, use "perm_addr" */
316 [ # # # # ]: 0 : if (!ret_val &&
317 : : (msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK)))
318 : : e1000_read_mac_addr_vf(hw);
319 : :
320 : 0 : return E1000_SUCCESS;
321 : : }
322 : :
323 : : /**
324 : : * e1000_hash_mc_addr_vf - Generate a multicast hash value
325 : : * @hw: pointer to the HW structure
326 : : * @mc_addr: pointer to a multicast address
327 : : *
328 : : * Generates a multicast address hash value which is used to determine
329 : : * the multicast filter table array address and new table value.
330 : : **/
331 : 0 : STATIC u32 e1000_hash_mc_addr_vf(struct e1000_hw *hw, u8 *mc_addr)
332 : : {
333 : : u32 hash_value, hash_mask;
334 : : u8 bit_shift = 0;
335 : :
336 : 0 : DEBUGFUNC("e1000_hash_mc_addr_generic");
337 : :
338 : : /* Register count multiplied by bits per register */
339 : 0 : hash_mask = (hw->mac.mta_reg_count * 32) - 1;
340 : :
341 : : /*
342 : : * The bit_shift is the number of left-shifts
343 : : * where 0xFF would still fall within the hash mask.
344 : : */
345 [ # # ]: 0 : while (hash_mask >> bit_shift != 0xFF)
346 : 0 : bit_shift++;
347 : :
348 : 0 : hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
349 : 0 : (((u16) mc_addr[5]) << bit_shift)));
350 : :
351 : 0 : return hash_value;
352 : : }
353 : :
354 : : STATIC void e1000_write_msg_read_ack(struct e1000_hw *hw,
355 : : u32 *msg, u16 size)
356 : : {
357 : : struct e1000_mbx_info *mbx = &hw->mbx;
358 : : u32 retmsg[E1000_VFMAILBOX_SIZE];
359 : 0 : s32 retval = mbx->ops.write_posted(hw, msg, size, 0);
360 : :
361 [ # # # # : 0 : if (!retval)
# # ]
362 : 0 : mbx->ops.read_posted(hw, retmsg, E1000_VFMAILBOX_SIZE, 0);
363 : : }
364 : :
365 : : /**
366 : : * e1000_update_mc_addr_list_vf - Update Multicast addresses
367 : : * @hw: pointer to the HW structure
368 : : * @mc_addr_list: array of multicast addresses to program
369 : : * @mc_addr_count: number of multicast addresses to program
370 : : *
371 : : * Updates the Multicast Table Array.
372 : : * The caller must have a packed mc_addr_list of multicast addresses.
373 : : **/
374 : 0 : void e1000_update_mc_addr_list_vf(struct e1000_hw *hw,
375 : : u8 *mc_addr_list, u32 mc_addr_count)
376 : : {
377 : : u32 msgbuf[E1000_VFMAILBOX_SIZE];
378 : : u16 *hash_list = (u16 *)&msgbuf[1];
379 : : u32 hash_value;
380 : : u32 i;
381 : :
382 : 0 : DEBUGFUNC("e1000_update_mc_addr_list_vf");
383 : :
384 : : /* Each entry in the list uses 1 16 bit word. We have 30
385 : : * 16 bit words available in our HW msg buffer (minus 1 for the
386 : : * msg type). That's 30 hash values if we pack 'em right. If
387 : : * there are more than 30 MC addresses to add then punt the
388 : : * extras for now and then add code to handle more than 30 later.
389 : : * It would be unusual for a server to request that many multi-cast
390 : : * addresses except for in large enterprise network environments.
391 : : */
392 : :
393 : 0 : DEBUGOUT1("MC Addr Count = %d\n", mc_addr_count);
394 : :
395 : 0 : msgbuf[0] = E1000_VF_SET_MULTICAST;
396 : :
397 [ # # ]: 0 : if (mc_addr_count > 30) {
398 : 0 : msgbuf[0] |= E1000_VF_SET_MULTICAST_OVERFLOW;
399 : : mc_addr_count = 30;
400 : : }
401 : :
402 : 0 : msgbuf[0] |= mc_addr_count << E1000_VT_MSGINFO_SHIFT;
403 : :
404 [ # # ]: 0 : for (i = 0; i < mc_addr_count; i++) {
405 : 0 : hash_value = e1000_hash_mc_addr_vf(hw, mc_addr_list);
406 : 0 : DEBUGOUT1("Hash value = 0x%03X\n", hash_value);
407 : 0 : hash_list[i] = hash_value & 0x0FFF;
408 : 0 : mc_addr_list += ETH_ADDR_LEN;
409 : : }
410 : :
411 : : e1000_write_msg_read_ack(hw, msgbuf, E1000_VFMAILBOX_SIZE);
412 : 0 : }
413 : :
414 : : /**
415 : : * e1000_vfta_set_vf - Set/Unset vlan filter table address
416 : : * @hw: pointer to the HW structure
417 : : * @vid: determines the vfta register and bit to set/unset
418 : : * @set: if true then set bit, else clear bit
419 : : **/
420 : 0 : void e1000_vfta_set_vf(struct e1000_hw *hw, u16 vid, bool set)
421 : : {
422 : : u32 msgbuf[2];
423 : :
424 : 0 : msgbuf[0] = E1000_VF_SET_VLAN;
425 : 0 : msgbuf[1] = vid;
426 : : /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */
427 [ # # ]: 0 : if (set)
428 : 0 : msgbuf[0] |= E1000_VF_SET_VLAN_ADD;
429 : :
430 : : e1000_write_msg_read_ack(hw, msgbuf, 2);
431 : 0 : }
432 : :
433 : : /** e1000_rlpml_set_vf - Set the maximum receive packet length
434 : : * @hw: pointer to the HW structure
435 : : * @max_size: value to assign to max frame size
436 : : **/
437 : 0 : void e1000_rlpml_set_vf(struct e1000_hw *hw, u16 max_size)
438 : : {
439 : : u32 msgbuf[2];
440 : :
441 : 0 : msgbuf[0] = E1000_VF_SET_LPE;
442 : 0 : msgbuf[1] = max_size;
443 : :
444 : : e1000_write_msg_read_ack(hw, msgbuf, 2);
445 : 0 : }
446 : :
447 : : /**
448 : : * e1000_promisc_set_vf - Set flags for Unicast or Multicast promisc
449 : : * @hw: pointer to the HW structure
450 : : * @uni: boolean indicating unicast promisc status
451 : : * @multi: boolean indicating multicast promisc status
452 : : **/
453 : 0 : s32 e1000_promisc_set_vf(struct e1000_hw *hw, enum e1000_promisc_type type)
454 : : {
455 : : struct e1000_mbx_info *mbx = &hw->mbx;
456 : 0 : u32 msgbuf = E1000_VF_SET_PROMISC;
457 : : s32 ret_val;
458 : :
459 [ # # # # : 0 : switch (type) {
# ]
460 : 0 : case e1000_promisc_multicast:
461 : 0 : msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
462 : 0 : break;
463 : 0 : case e1000_promisc_enabled:
464 : 0 : msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
465 : : /* fall-through */
466 : 0 : case e1000_promisc_unicast:
467 : 0 : msgbuf |= E1000_VF_SET_PROMISC_UNICAST;
468 : : /* fall-through */
469 : : case e1000_promisc_disabled:
470 : : break;
471 : : default:
472 : : return -E1000_ERR_MAC_INIT;
473 : : }
474 : :
475 : 0 : ret_val = mbx->ops.write_posted(hw, &msgbuf, 1, 0);
476 : :
477 [ # # ]: 0 : if (!ret_val)
478 : 0 : ret_val = mbx->ops.read_posted(hw, &msgbuf, 1, 0);
479 : :
480 [ # # # # ]: 0 : if (!ret_val && !(msgbuf & E1000_VT_MSGTYPE_ACK))
481 : : ret_val = -E1000_ERR_MAC_INIT;
482 : :
483 : : return ret_val;
484 : : }
485 : :
486 : : /**
487 : : * e1000_read_mac_addr_vf - Read device MAC address
488 : : * @hw: pointer to the HW structure
489 : : **/
490 : 0 : STATIC s32 e1000_read_mac_addr_vf(struct e1000_hw *hw)
491 : : {
492 : : int i;
493 : :
494 [ # # # # ]: 0 : for (i = 0; i < ETH_ADDR_LEN; i++)
495 : 0 : hw->mac.addr[i] = hw->mac.perm_addr[i];
496 : :
497 : 0 : return E1000_SUCCESS;
498 : : }
499 : :
500 : : /**
501 : : * e1000_check_for_link_vf - Check for link for a virtual interface
502 : : * @hw: pointer to the HW structure
503 : : *
504 : : * Checks to see if the underlying PF is still talking to the VF and
505 : : * if it is then it reports the link state to the hardware, otherwise
506 : : * it reports link down and returns an error.
507 : : **/
508 : 0 : STATIC s32 e1000_check_for_link_vf(struct e1000_hw *hw)
509 : : {
510 : : struct e1000_mbx_info *mbx = &hw->mbx;
511 : : struct e1000_mac_info *mac = &hw->mac;
512 : : s32 ret_val = E1000_SUCCESS;
513 : 0 : u32 in_msg = 0;
514 : :
515 : 0 : DEBUGFUNC("e1000_check_for_link_vf");
516 : :
517 : : /*
518 : : * We only want to run this if there has been a rst asserted.
519 : : * in this case that could mean a link change, device reset,
520 : : * or a virtual function reset
521 : : */
522 : :
523 : : /* If we were hit with a reset or timeout drop the link */
524 [ # # # # ]: 0 : if (!mbx->ops.check_for_rst(hw, 0) || !mbx->timeout)
525 : 0 : mac->get_link_status = true;
526 : :
527 [ # # ]: 0 : if (!mac->get_link_status)
528 : 0 : goto out;
529 : :
530 : : /* if link status is down no point in checking to see if pf is up */
531 [ # # ]: 0 : if (!(E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU))
532 : 0 : goto out;
533 : :
534 : : /* if the read failed it could just be a mailbox collision, best wait
535 : : * until we are called again and don't report an error */
536 [ # # ]: 0 : if (mbx->ops.read(hw, &in_msg, 1, 0))
537 : 0 : goto out;
538 : :
539 : : /* if incoming message isn't clear to send we are waiting on response */
540 [ # # ]: 0 : if (!(in_msg & E1000_VT_MSGTYPE_CTS)) {
541 : : /* message is not CTS and is NACK we have lost CTS status */
542 [ # # ]: 0 : if (in_msg & E1000_VT_MSGTYPE_NACK)
543 : : ret_val = -E1000_ERR_MAC_INIT;
544 : 0 : goto out;
545 : : }
546 : :
547 : : /* at this point we know the PF is talking to us, check and see if
548 : : * we are still accepting timeout or if we had a timeout failure.
549 : : * if we failed then we will need to reinit */
550 [ # # ]: 0 : if (!mbx->timeout) {
551 : : ret_val = -E1000_ERR_MAC_INIT;
552 : 0 : goto out;
553 : : }
554 : :
555 : : /* if we passed all the tests above then the link is up and we no
556 : : * longer need to check for link */
557 : 0 : mac->get_link_status = false;
558 : :
559 : 0 : out:
560 : 0 : return ret_val;
561 : : }
562 : :
|
