[build] Avoid implicit-fallthrough warnings on GCC 7
[ipxe.git] / src / drivers / net / igbvf / igbvf_vf.c
1 /*******************************************************************************
2
3 Intel(R) 82576 Virtual Function Linux driver
4 Copyright(c) 1999 - 2008 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 FILE_LICENCE ( GPL2_ONLY );
30
31 #include "igbvf_vf.h"
32
33
34 static s32 igbvf_init_mac_params_vf(struct e1000_hw *hw);
35 static s32 igbvf_check_for_link_vf(struct e1000_hw *hw);
36 static s32 igbvf_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
37 u16 *duplex);
38 static s32 igbvf_init_hw_vf(struct e1000_hw *hw);
39 static s32 igbvf_reset_hw_vf(struct e1000_hw *hw);
40 static void igbvf_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, u32);
41 static void igbvf_rar_set_vf(struct e1000_hw *, u8 *, u32);
42 static s32 igbvf_read_mac_addr_vf(struct e1000_hw *);
43
44 /**
45 * igbvf_init_mac_params_vf - Inits MAC params
46 * @hw: pointer to the HW structure
47 **/
48 static s32 igbvf_init_mac_params_vf(struct e1000_hw *hw)
49 {
50 struct e1000_mac_info *mac = &hw->mac;
51
52 DEBUGFUNC("igbvf_init_mac_params_vf");
53
54 /* VF's have no MTA Registers - PF feature only */
55 mac->mta_reg_count = 128;
56 /* VF's have no access to RAR entries */
57 mac->rar_entry_count = 1;
58
59 /* Function pointers */
60 /* reset */
61 mac->ops.reset_hw = igbvf_reset_hw_vf;
62 /* hw initialization */
63 mac->ops.init_hw = igbvf_init_hw_vf;
64 /* check for link */
65 mac->ops.check_for_link = igbvf_check_for_link_vf;
66 /* link info */
67 mac->ops.get_link_up_info = igbvf_get_link_up_info_vf;
68 /* multicast address update */
69 mac->ops.update_mc_addr_list = igbvf_update_mc_addr_list_vf;
70 /* set mac address */
71 mac->ops.rar_set = igbvf_rar_set_vf;
72 /* read mac address */
73 mac->ops.read_mac_addr = igbvf_read_mac_addr_vf;
74
75
76 return E1000_SUCCESS;
77 }
78
79 /**
80 * igbvf_init_function_pointers_vf - Inits function pointers
81 * @hw: pointer to the HW structure
82 **/
83 void igbvf_init_function_pointers_vf(struct e1000_hw *hw)
84 {
85 DEBUGFUNC("igbvf_init_function_pointers_vf");
86
87 hw->mac.ops.init_params = igbvf_init_mac_params_vf;
88 hw->mbx.ops.init_params = igbvf_init_mbx_params_vf;
89 }
90
91 /**
92 * igbvf_get_link_up_info_vf - Gets link info.
93 * @hw: pointer to the HW structure
94 * @speed: pointer to 16 bit value to store link speed.
95 * @duplex: pointer to 16 bit value to store duplex.
96 *
97 * Since we cannot read the PHY and get accurate link info, we must rely upon
98 * the status register's data which is often stale and inaccurate.
99 **/
100 static s32 igbvf_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
101 u16 *duplex)
102 {
103 s32 status;
104
105 DEBUGFUNC("igbvf_get_link_up_info_vf");
106
107 status = E1000_READ_REG(hw, E1000_STATUS);
108 if (status & E1000_STATUS_SPEED_1000) {
109 *speed = SPEED_1000;
110 DEBUGOUT("1000 Mbs, ");
111 } else if (status & E1000_STATUS_SPEED_100) {
112 *speed = SPEED_100;
113 DEBUGOUT("100 Mbs, ");
114 } else {
115 *speed = SPEED_10;
116 DEBUGOUT("10 Mbs, ");
117 }
118
119 if (status & E1000_STATUS_FD) {
120 *duplex = FULL_DUPLEX;
121 DEBUGOUT("Full Duplex\n");
122 } else {
123 *duplex = HALF_DUPLEX;
124 DEBUGOUT("Half Duplex\n");
125 }
126
127 return E1000_SUCCESS;
128 }
129
130 /**
131 * igbvf_reset_hw_vf - Resets the HW
132 * @hw: pointer to the HW structure
133 *
134 * VF's provide a function level reset. This is done using bit 26 of ctrl_reg.
135 * This is all the reset we can perform on a VF.
136 **/
137 static s32 igbvf_reset_hw_vf(struct e1000_hw *hw)
138 {
139 struct e1000_mbx_info *mbx = &hw->mbx;
140 u32 timeout = E1000_VF_INIT_TIMEOUT;
141 s32 ret_val = -E1000_ERR_MAC_INIT;
142 u32 ctrl, msgbuf[3];
143 u8 *addr = (u8 *)(&msgbuf[1]);
144
145 DEBUGFUNC("igbvf_reset_hw_vf");
146
147 DEBUGOUT("Issuing a function level reset to MAC\n");
148 ctrl = E1000_READ_REG(hw, E1000_CTRL);
149 E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
150
151 /* we cannot reset while the RSTI / RSTD bits are asserted */
152 while (!mbx->ops.check_for_rst(hw, 0) && timeout) {
153 timeout--;
154 usec_delay(5);
155 }
156
157 if (timeout) {
158 /* mailbox timeout can now become active */
159 mbx->timeout = E1000_VF_MBX_INIT_TIMEOUT;
160
161 msgbuf[0] = E1000_VF_RESET;
162 mbx->ops.write_posted(hw, msgbuf, 1, 0);
163
164 msec_delay(10);
165
166 /* set our "perm_addr" based on info provided by PF */
167 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
168 if (!ret_val) {
169 if (msgbuf[0] == (E1000_VF_RESET |
170 E1000_VT_MSGTYPE_ACK))
171 memcpy(hw->mac.perm_addr, addr, 6);
172 else
173 ret_val = -E1000_ERR_MAC_INIT;
174 }
175 }
176
177 return ret_val;
178 }
179
180 /**
181 * igbvf_init_hw_vf - Inits the HW
182 * @hw: pointer to the HW structure
183 *
184 * Not much to do here except clear the PF Reset indication if there is one.
185 **/
186 static s32 igbvf_init_hw_vf(struct e1000_hw *hw)
187 {
188 DEBUGFUNC("igbvf_init_hw_vf");
189
190 /* attempt to set and restore our mac address */
191 igbvf_rar_set_vf(hw, hw->mac.addr, 0);
192
193 return E1000_SUCCESS;
194 }
195
196 /**
197 * igbvf_rar_set_vf - set device MAC address
198 * @hw: pointer to the HW structure
199 * @addr: pointer to the receive address
200 * @index receive address array register
201 **/
202 static void igbvf_rar_set_vf(struct e1000_hw *hw, u8 * addr, u32 index __unused)
203 {
204 struct e1000_mbx_info *mbx = &hw->mbx;
205 u32 msgbuf[3];
206 u8 *msg_addr = (u8 *)(&msgbuf[1]);
207 s32 ret_val;
208
209 memset(msgbuf, 0, 12);
210 msgbuf[0] = E1000_VF_SET_MAC_ADDR;
211 memcpy(msg_addr, addr, 6);
212 ret_val = mbx->ops.write_posted(hw, msgbuf, 3, 0);
213
214 if (!ret_val)
215 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
216
217 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS;
218
219 /* if nacked the address was rejected, use "perm_addr" */
220 if (!ret_val &&
221 (msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK)))
222 igbvf_read_mac_addr_vf(hw);
223 }
224
225 /**
226 * igbvf_hash_mc_addr_vf - Generate a multicast hash value
227 * @hw: pointer to the HW structure
228 * @mc_addr: pointer to a multicast address
229 *
230 * Generates a multicast address hash value which is used to determine
231 * the multicast filter table array address and new table value. See
232 * igbvf_mta_set_generic()
233 **/
234 static u32 igbvf_hash_mc_addr_vf(struct e1000_hw *hw, u8 *mc_addr)
235 {
236 u32 hash_value, hash_mask;
237 u8 bit_shift = 0;
238
239 DEBUGFUNC("igbvf_hash_mc_addr_generic");
240
241 /* Register count multiplied by bits per register */
242 hash_mask = (hw->mac.mta_reg_count * 32) - 1;
243
244 /*
245 * The bit_shift is the number of left-shifts
246 * where 0xFF would still fall within the hash mask.
247 */
248 while (hash_mask >> bit_shift != 0xFF)
249 bit_shift++;
250
251 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
252 (((u16) mc_addr[5]) << bit_shift)));
253
254 return hash_value;
255 }
256
257 /**
258 * igbvf_update_mc_addr_list_vf - Update Multicast addresses
259 * @hw: pointer to the HW structure
260 * @mc_addr_list: array of multicast addresses to program
261 * @mc_addr_count: number of multicast addresses to program
262 *
263 * Updates the Multicast Table Array.
264 * The caller must have a packed mc_addr_list of multicast addresses.
265 **/
266 void igbvf_update_mc_addr_list_vf(struct e1000_hw *hw,
267 u8 *mc_addr_list, u32 mc_addr_count)
268 {
269 struct e1000_mbx_info *mbx = &hw->mbx;
270 u32 msgbuf[E1000_VFMAILBOX_SIZE];
271 u16 *hash_list = (u16 *)&msgbuf[1];
272 u32 hash_value;
273 u32 i;
274
275 DEBUGFUNC("igbvf_update_mc_addr_list_vf");
276
277 /* Each entry in the list uses 1 16 bit word. We have 30
278 * 16 bit words available in our HW msg buffer (minus 1 for the
279 * msg type). That's 30 hash values if we pack 'em right. If
280 * there are more than 30 MC addresses to add then punt the
281 * extras for now and then add code to handle more than 30 later.
282 * It would be unusual for a server to request that many multi-cast
283 * addresses except for in large enterprise network environments.
284 */
285
286 DEBUGOUT1("MC Addr Count = %d\n", mc_addr_count);
287
288 msgbuf[0] = E1000_VF_SET_MULTICAST;
289
290 if (mc_addr_count > 30) {
291 msgbuf[0] |= E1000_VF_SET_MULTICAST_OVERFLOW;
292 mc_addr_count = 30;
293 }
294
295 msgbuf[0] |= mc_addr_count << E1000_VT_MSGINFO_SHIFT;
296
297 for (i = 0; i < mc_addr_count; i++) {
298 hash_value = igbvf_hash_mc_addr_vf(hw, mc_addr_list);
299 DEBUGOUT1("Hash value = 0x%03X\n", hash_value);
300 hash_list[i] = hash_value & 0x0FFF;
301 mc_addr_list += ETH_ADDR_LEN;
302 }
303
304 mbx->ops.write_posted(hw, msgbuf, E1000_VFMAILBOX_SIZE, 0);
305 }
306
307 /**
308 * igbvf_vfta_set_vf - Set/Unset vlan filter table address
309 * @hw: pointer to the HW structure
310 * @vid: determines the vfta register and bit to set/unset
311 * @set: if true then set bit, else clear bit
312 **/
313 void igbvf_vfta_set_vf(struct e1000_hw *hw, u16 vid, bool set)
314 {
315 struct e1000_mbx_info *mbx = &hw->mbx;
316 u32 msgbuf[2];
317
318 msgbuf[0] = E1000_VF_SET_VLAN;
319 msgbuf[1] = vid;
320 /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */
321 if (set)
322 msgbuf[0] |= E1000_VF_SET_VLAN_ADD;
323
324 mbx->ops.write_posted(hw, msgbuf, 2, 0);
325 }
326
327 /** igbvf_rlpml_set_vf - Set the maximum receive packet length
328 * @hw: pointer to the HW structure
329 * @max_size: value to assign to max frame size
330 **/
331 void igbvf_rlpml_set_vf(struct e1000_hw *hw, u16 max_size)
332 {
333 struct e1000_mbx_info *mbx = &hw->mbx;
334 u32 msgbuf[2];
335
336 msgbuf[0] = E1000_VF_SET_LPE;
337 msgbuf[1] = max_size;
338
339 mbx->ops.write_posted(hw, msgbuf, 2, 0);
340 }
341
342 /**
343 * igbvf_promisc_set_vf - Set flags for Unicast or Multicast promisc
344 * @hw: pointer to the HW structure
345 * @uni: boolean indicating unicast promisc status
346 * @multi: boolean indicating multicast promisc status
347 **/
348 s32 igbvf_promisc_set_vf(struct e1000_hw *hw, enum e1000_promisc_type type)
349 {
350 struct e1000_mbx_info *mbx = &hw->mbx;
351 u32 msgbuf = E1000_VF_SET_PROMISC;
352 s32 ret_val;
353
354 switch (type) {
355 case e1000_promisc_multicast:
356 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
357 break;
358 case e1000_promisc_enabled:
359 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
360 /* Fall through */
361 case e1000_promisc_unicast:
362 msgbuf |= E1000_VF_SET_PROMISC_UNICAST;
363 case e1000_promisc_disabled:
364 break;
365 default:
366 return -E1000_ERR_MAC_INIT;
367 }
368
369 ret_val = mbx->ops.write_posted(hw, &msgbuf, 1, 0);
370
371 if (!ret_val)
372 ret_val = mbx->ops.read_posted(hw, &msgbuf, 1, 0);
373
374 if (!ret_val && !(msgbuf & E1000_VT_MSGTYPE_ACK))
375 ret_val = -E1000_ERR_MAC_INIT;
376
377 return ret_val;
378 }
379
380 /**
381 * igbvf_read_mac_addr_vf - Read device MAC address
382 * @hw: pointer to the HW structure
383 **/
384 static s32 igbvf_read_mac_addr_vf(struct e1000_hw *hw)
385 {
386 int i;
387
388 for (i = 0; i < ETH_ADDR_LEN; i++)
389 hw->mac.addr[i] = hw->mac.perm_addr[i];
390
391 return E1000_SUCCESS;
392 }
393
394 /**
395 * igbvf_check_for_link_vf - Check for link for a virtual interface
396 * @hw: pointer to the HW structure
397 *
398 * Checks to see if the underlying PF is still talking to the VF and
399 * if it is then it reports the link state to the hardware, otherwise
400 * it reports link down and returns an error.
401 **/
402 static s32 igbvf_check_for_link_vf(struct e1000_hw *hw)
403 {
404 struct e1000_mbx_info *mbx = &hw->mbx;
405 struct e1000_mac_info *mac = &hw->mac;
406 s32 ret_val = E1000_SUCCESS;
407 u32 in_msg = 0;
408
409 DEBUGFUNC("igbvf_check_for_link_vf");
410
411 /*
412 * We only want to run this if there has been a rst asserted.
413 * in this case that could mean a link change, device reset,
414 * or a virtual function reset
415 */
416
417 /* If we were hit with a reset drop the link */
418 if (!mbx->ops.check_for_rst(hw, 0))
419 mac->get_link_status = true;
420
421 if (!mac->get_link_status)
422 goto out;
423
424 /* if link status is down no point in checking to see if pf is up */
425 if (!(E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU))
426 goto out;
427
428 /* if the read failed it could just be a mailbox collision, best wait
429 * until we are called again and don't report an error */
430 if (mbx->ops.read(hw, &in_msg, 1, 0))
431 goto out;
432
433 /* if incoming message isn't clear to send we are waiting on response */
434 if (!(in_msg & E1000_VT_MSGTYPE_CTS)) {
435 /* message is not CTS and is NACK we have lost CTS status */
436 if (in_msg & E1000_VT_MSGTYPE_NACK)
437 ret_val = -E1000_ERR_MAC_INIT;
438 goto out;
439 }
440
441 /* at this point we know the PF is talking to us, check and see if
442 * we are still accepting timeout or if we had a timeout failure.
443 * if we failed then we will need to reinit */
444 if (!mbx->timeout) {
445 ret_val = -E1000_ERR_MAC_INIT;
446 goto out;
447 }
448
449 /* if we passed all the tests above then the link is up and we no
450 * longer need to check for link */
451 mac->get_link_status = false;
452
453 out:
454 return ret_val;
455 }
456