Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2013 - 2015 Intel Corporation
3 : : */
4 : :
5 : : #include "fm10k_vf.h"
6 : :
7 : : /**
8 : : * fm10k_stop_hw_vf - Stop Tx/Rx units
9 : : * @hw: pointer to hardware structure
10 : : *
11 : : **/
12 : 0 : STATIC s32 fm10k_stop_hw_vf(struct fm10k_hw *hw)
13 : : {
14 : : u8 *perm_addr = hw->mac.perm_addr;
15 : : u32 bal = 0, bah = 0, tdlen;
16 : : s32 err;
17 : : u16 i;
18 : :
19 : 0 : DEBUGFUNC("fm10k_stop_hw_vf");
20 : :
21 : : /* we need to disable the queues before taking further steps */
22 : 0 : err = fm10k_stop_hw_generic(hw);
23 [ # # ]: 0 : if (err && err != FM10K_ERR_REQUESTS_PENDING)
24 : : return err;
25 : :
26 : : /* If permanent address is set then we need to restore it */
27 [ # # # # ]: 0 : if (IS_VALID_ETHER_ADDR(perm_addr)) {
28 : 0 : bal = (((u32)perm_addr[3]) << 24) |
29 : 0 : (((u32)perm_addr[4]) << 16) |
30 : 0 : (((u32)perm_addr[5]) << 8);
31 : 0 : bah = (((u32)0xFF) << 24) |
32 : 0 : (((u32)perm_addr[0]) << 16) |
33 : 0 : (((u32)perm_addr[1]) << 8) |
34 : 0 : ((u32)perm_addr[2]);
35 : : }
36 : :
37 : : /* restore default itr_scale for next VF initialization */
38 : 0 : tdlen = hw->mac.itr_scale << FM10K_TDLEN_ITR_SCALE_SHIFT;
39 : :
40 : : /* The queues have already been disabled so we just need to
41 : : * update their base address registers
42 : : */
43 [ # # ]: 0 : for (i = 0; i < hw->mac.max_queues; i++) {
44 : 0 : FM10K_WRITE_REG(hw, FM10K_TDBAL(i), bal);
45 : 0 : FM10K_WRITE_REG(hw, FM10K_TDBAH(i), bah);
46 : 0 : FM10K_WRITE_REG(hw, FM10K_RDBAL(i), bal);
47 : 0 : FM10K_WRITE_REG(hw, FM10K_RDBAH(i), bah);
48 : : /* Restore ITR scale in software-defined mechanism in TDLEN
49 : : * for next VF initialization. See definition of
50 : : * FM10K_TDLEN_ITR_SCALE_SHIFT for more details on the use of
51 : : * TDLEN here.
52 : : */
53 : 0 : FM10K_WRITE_REG(hw, FM10K_TDLEN(i), tdlen);
54 : : }
55 : :
56 : : return err;
57 : : }
58 : :
59 : : /**
60 : : * fm10k_reset_hw_vf - VF hardware reset
61 : : * @hw: pointer to hardware structure
62 : : *
63 : : * This function should return the hardware to a state similar to the
64 : : * one it is in after just being initialized.
65 : : **/
66 : 0 : STATIC s32 fm10k_reset_hw_vf(struct fm10k_hw *hw)
67 : : {
68 : : s32 err;
69 : :
70 : 0 : DEBUGFUNC("fm10k_reset_hw_vf");
71 : :
72 : : /* shut down queues we own and reset DMA configuration */
73 : 0 : err = fm10k_stop_hw_vf(hw);
74 [ # # ]: 0 : if (err == FM10K_ERR_REQUESTS_PENDING)
75 : 0 : hw->mac.reset_while_pending++;
76 [ # # ]: 0 : else if (err)
77 : : return err;
78 : :
79 : : /* Inititate VF reset */
80 : 0 : FM10K_WRITE_REG(hw, FM10K_VFCTRL, FM10K_VFCTRL_RST);
81 : :
82 : : /* Flush write and allow 100us for reset to complete */
83 : 0 : FM10K_WRITE_FLUSH(hw);
84 : 0 : usec_delay(FM10K_RESET_TIMEOUT);
85 : :
86 : : /* Clear reset bit and verify it was cleared */
87 : 0 : FM10K_WRITE_REG(hw, FM10K_VFCTRL, 0);
88 [ # # ]: 0 : if (FM10K_READ_REG(hw, FM10K_VFCTRL) & FM10K_VFCTRL_RST)
89 : 0 : return FM10K_ERR_RESET_FAILED;
90 : :
91 : : return FM10K_SUCCESS;
92 : : }
93 : :
94 : : /**
95 : : * fm10k_init_hw_vf - VF hardware initialization
96 : : * @hw: pointer to hardware structure
97 : : *
98 : : **/
99 : 0 : STATIC s32 fm10k_init_hw_vf(struct fm10k_hw *hw)
100 : : {
101 : 0 : u32 tqdloc, tqdloc0 = ~FM10K_READ_REG(hw, FM10K_TQDLOC(0));
102 : : s32 err;
103 : : u16 i;
104 : :
105 : 0 : DEBUGFUNC("fm10k_init_hw_vf");
106 : :
107 : : /* verify we have at least 1 queue */
108 [ # # # # ]: 0 : if (!~FM10K_READ_REG(hw, FM10K_TXQCTL(0)) ||
109 : 0 : !~FM10K_READ_REG(hw, FM10K_RXQCTL(0))) {
110 : : err = FM10K_ERR_NO_RESOURCES;
111 : 0 : goto reset_max_queues;
112 : : }
113 : :
114 : : /* determine how many queues we have */
115 [ # # ]: 0 : for (i = 1; tqdloc0 && (i < FM10K_MAX_QUEUES_POOL); i++) {
116 : : /* verify the Descriptor cache offsets are increasing */
117 : 0 : tqdloc = ~FM10K_READ_REG(hw, FM10K_TQDLOC(i));
118 [ # # ]: 0 : if (!tqdloc || (tqdloc == tqdloc0))
119 : : break;
120 : :
121 : : /* check to verify the PF doesn't own any of our queues */
122 [ # # # # ]: 0 : if (!~FM10K_READ_REG(hw, FM10K_TXQCTL(i)) ||
123 : 0 : !~FM10K_READ_REG(hw, FM10K_RXQCTL(i)))
124 : : break;
125 : : }
126 : :
127 : : /* shut down queues we own and reset DMA configuration */
128 : 0 : err = fm10k_disable_queues_generic(hw, i);
129 [ # # ]: 0 : if (err)
130 : 0 : goto reset_max_queues;
131 : :
132 : : /* record maximum queue count */
133 : 0 : hw->mac.max_queues = i;
134 : :
135 : : /* fetch default VLAN and ITR scale */
136 : 0 : hw->mac.default_vid = (FM10K_READ_REG(hw, FM10K_TXQCTL(0)) &
137 : 0 : FM10K_TXQCTL_VID_MASK) >> FM10K_TXQCTL_VID_SHIFT;
138 : : /* Read the ITR scale from TDLEN. See the definition of
139 : : * FM10K_TDLEN_ITR_SCALE_SHIFT for more information about how TDLEN is
140 : : * used here.
141 : : */
142 : 0 : hw->mac.itr_scale = (FM10K_READ_REG(hw, FM10K_TDLEN(0)) &
143 : 0 : FM10K_TDLEN_ITR_SCALE_MASK) >>
144 : : FM10K_TDLEN_ITR_SCALE_SHIFT;
145 : :
146 : 0 : return FM10K_SUCCESS;
147 : :
148 : 0 : reset_max_queues:
149 : 0 : hw->mac.max_queues = 0;
150 : :
151 : 0 : return err;
152 : : }
153 : :
154 : : #ifndef NO_IS_SLOT_APPROPRIATE_CHECK
155 : : /**
156 : : * fm10k_is_slot_appropriate_vf - Indicate appropriate slot for this SKU
157 : : * @hw: pointer to hardware structure
158 : : *
159 : : * Looks at the PCIe bus info to confirm whether or not this slot can support
160 : : * the necessary bandwidth for this device. Since the VF has no control over
161 : : * the "slot" it is in, always indicate that the slot is appropriate.
162 : : **/
163 : 0 : STATIC bool fm10k_is_slot_appropriate_vf(struct fm10k_hw *hw)
164 : : {
165 : : UNREFERENCED_1PARAMETER(hw);
166 : 0 : DEBUGFUNC("fm10k_is_slot_appropriate_vf");
167 : :
168 : 0 : return TRUE;
169 : : }
170 : :
171 : : #endif
172 : : /* This structure defines the attibutes to be parsed below */
173 : : const struct fm10k_tlv_attr fm10k_mac_vlan_msg_attr[] = {
174 : : FM10K_TLV_ATTR_U32(FM10K_MAC_VLAN_MSG_VLAN),
175 : : FM10K_TLV_ATTR_BOOL(FM10K_MAC_VLAN_MSG_SET),
176 : : FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MAC),
177 : : FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_DEFAULT_MAC),
178 : : FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MULTICAST),
179 : : FM10K_TLV_ATTR_LAST
180 : : };
181 : :
182 : : /**
183 : : * fm10k_update_vlan_vf - Update status of VLAN ID in VLAN filter table
184 : : * @hw: pointer to hardware structure
185 : : * @vid: VLAN ID to add to table
186 : : * @vsi: Reserved, should always be 0
187 : : * @set: Indicates if this is a set or clear operation
188 : : *
189 : : * This function adds or removes the corresponding VLAN ID from the VLAN
190 : : * filter table for this VF.
191 : : **/
192 : 0 : STATIC s32 fm10k_update_vlan_vf(struct fm10k_hw *hw, u32 vid, u8 vsi, bool set)
193 : : {
194 : 0 : struct fm10k_mbx_info *mbx = &hw->mbx;
195 : : u32 msg[4];
196 : :
197 : : /* verify the index is not set */
198 [ # # ]: 0 : if (vsi)
199 : : return FM10K_ERR_PARAM;
200 : :
201 : : /* clever trick to verify reserved bits in both vid and length */
202 [ # # ]: 0 : if ((vid << 16 | vid) >> 28)
203 : : return FM10K_ERR_PARAM;
204 : :
205 : : /* encode set bit into the VLAN ID */
206 [ # # ]: 0 : if (!set)
207 : 0 : vid |= FM10K_VLAN_CLEAR;
208 : :
209 : : /* generate VLAN request */
210 : 0 : fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
211 : 0 : fm10k_tlv_attr_put_u32(msg, FM10K_MAC_VLAN_MSG_VLAN, vid);
212 : :
213 : : /* load onto outgoing mailbox */
214 : 0 : return mbx->ops.enqueue_tx(hw, mbx, msg);
215 : : }
216 : :
217 : : /**
218 : : * fm10k_msg_mac_vlan_vf - Read device MAC address from mailbox message
219 : : * @hw: pointer to the HW structure
220 : : * @results: Attributes for message
221 : : * @mbx: unused mailbox data
222 : : *
223 : : * This function should determine the MAC address for the VF
224 : : **/
225 : 0 : s32 fm10k_msg_mac_vlan_vf(struct fm10k_hw *hw, u32 **results,
226 : : struct fm10k_mbx_info *mbx)
227 : : {
228 : : u8 perm_addr[ETH_ALEN];
229 : : u16 vid;
230 : : s32 err;
231 : :
232 : : UNREFERENCED_1PARAMETER(mbx);
233 : 0 : DEBUGFUNC("fm10k_msg_mac_vlan_vf");
234 : :
235 : : /* record MAC address requested */
236 : 0 : err = fm10k_tlv_attr_get_mac_vlan(
237 : : results[FM10K_MAC_VLAN_MSG_DEFAULT_MAC],
238 : : perm_addr, &vid);
239 [ # # ]: 0 : if (err)
240 : : return err;
241 : :
242 : 0 : memcpy(hw->mac.perm_addr, perm_addr, ETH_ALEN);
243 : 0 : hw->mac.default_vid = vid & (FM10K_VLAN_TABLE_VID_MAX - 1);
244 : 0 : hw->mac.vlan_override = !!(vid & FM10K_VLAN_OVERRIDE);
245 : :
246 : 0 : return FM10K_SUCCESS;
247 : : }
248 : :
249 : : /**
250 : : * fm10k_read_mac_addr_vf - Read device MAC address
251 : : * @hw: pointer to the HW structure
252 : : *
253 : : * This function should determine the MAC address for the VF
254 : : **/
255 : 0 : STATIC s32 fm10k_read_mac_addr_vf(struct fm10k_hw *hw)
256 : : {
257 : : u8 perm_addr[ETH_ALEN];
258 : : u32 base_addr;
259 : :
260 : 0 : DEBUGFUNC("fm10k_read_mac_addr_vf");
261 : :
262 : 0 : base_addr = FM10K_READ_REG(hw, FM10K_TDBAL(0));
263 : :
264 : : /* last byte should be 0 */
265 [ # # ]: 0 : if (base_addr << 24)
266 : : return FM10K_ERR_INVALID_MAC_ADDR;
267 : :
268 : 0 : perm_addr[3] = (u8)(base_addr >> 24);
269 : 0 : perm_addr[4] = (u8)(base_addr >> 16);
270 : 0 : perm_addr[5] = (u8)(base_addr >> 8);
271 : :
272 : 0 : base_addr = FM10K_READ_REG(hw, FM10K_TDBAH(0));
273 : :
274 : : /* first byte should be all 1's */
275 [ # # ]: 0 : if ((~base_addr) >> 24)
276 : : return FM10K_ERR_INVALID_MAC_ADDR;
277 : :
278 : 0 : perm_addr[0] = (u8)(base_addr >> 16);
279 : 0 : perm_addr[1] = (u8)(base_addr >> 8);
280 : 0 : perm_addr[2] = (u8)(base_addr);
281 : :
282 : 0 : memcpy(hw->mac.perm_addr, perm_addr, ETH_ALEN);
283 : 0 : memcpy(hw->mac.addr, perm_addr, ETH_ALEN);
284 : :
285 : 0 : return FM10K_SUCCESS;
286 : : }
287 : :
288 : : /**
289 : : * fm10k_update_uc_addr_vf - Update device unicast addresses
290 : : * @hw: pointer to the HW structure
291 : : * @glort: unused
292 : : * @mac: MAC address to add/remove from table
293 : : * @vid: VLAN ID to add/remove from table
294 : : * @add: Indicates if this is an add or remove operation
295 : : * @flags: flags field to indicate add and secure - unused
296 : : *
297 : : * This function is used to add or remove unicast MAC addresses for
298 : : * the VF.
299 : : **/
300 : 0 : STATIC s32 fm10k_update_uc_addr_vf(struct fm10k_hw *hw, u16 glort,
301 : : const u8 *mac, u16 vid, bool add, u8 flags)
302 : : {
303 : 0 : struct fm10k_mbx_info *mbx = &hw->mbx;
304 : : u32 msg[7];
305 : :
306 : 0 : DEBUGFUNC("fm10k_update_uc_addr_vf");
307 : :
308 : : UNREFERENCED_2PARAMETER(glort, flags);
309 : :
310 : : /* verify VLAN ID is valid */
311 [ # # ]: 0 : if (vid >= FM10K_VLAN_TABLE_VID_MAX)
312 : : return FM10K_ERR_PARAM;
313 : :
314 : : /* verify MAC address is valid */
315 [ # # # # ]: 0 : if (!IS_VALID_ETHER_ADDR(mac))
316 : : return FM10K_ERR_PARAM;
317 : :
318 : : /* verify we are not locked down on the MAC address */
319 [ # # # # ]: 0 : if (IS_VALID_ETHER_ADDR(hw->mac.perm_addr) &&
320 [ # # ]: 0 : memcmp(hw->mac.perm_addr, mac, ETH_ALEN))
321 : : return FM10K_ERR_PARAM;
322 : :
323 : : /* add bit to notify us if this is a set or clear operation */
324 [ # # ]: 0 : if (!add)
325 : 0 : vid |= FM10K_VLAN_CLEAR;
326 : :
327 : : /* generate VLAN request */
328 : 0 : fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
329 : 0 : fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MAC, mac, vid);
330 : :
331 : : /* load onto outgoing mailbox */
332 : 0 : return mbx->ops.enqueue_tx(hw, mbx, msg);
333 : : }
334 : :
335 : : /**
336 : : * fm10k_update_mc_addr_vf - Update device multicast addresses
337 : : * @hw: pointer to the HW structure
338 : : * @glort: unused
339 : : * @mac: MAC address to add/remove from table
340 : : * @vid: VLAN ID to add/remove from table
341 : : * @add: Indicates if this is an add or remove operation
342 : : *
343 : : * This function is used to add or remove multicast MAC addresses for
344 : : * the VF.
345 : : **/
346 : 0 : STATIC s32 fm10k_update_mc_addr_vf(struct fm10k_hw *hw, u16 glort,
347 : : const u8 *mac, u16 vid, bool add)
348 : : {
349 : 0 : struct fm10k_mbx_info *mbx = &hw->mbx;
350 : : u32 msg[7];
351 : :
352 : 0 : DEBUGFUNC("fm10k_update_uc_addr_vf");
353 : :
354 : : UNREFERENCED_1PARAMETER(glort);
355 : :
356 : : /* verify VLAN ID is valid */
357 [ # # ]: 0 : if (vid >= FM10K_VLAN_TABLE_VID_MAX)
358 : : return FM10K_ERR_PARAM;
359 : :
360 : : /* verify multicast address is valid */
361 [ # # ]: 0 : if (!IS_MULTICAST_ETHER_ADDR(mac))
362 : : return FM10K_ERR_PARAM;
363 : :
364 : : /* add bit to notify us if this is a set or clear operation */
365 [ # # ]: 0 : if (!add)
366 : 0 : vid |= FM10K_VLAN_CLEAR;
367 : :
368 : : /* generate VLAN request */
369 : 0 : fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
370 : 0 : fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MULTICAST,
371 : : mac, vid);
372 : :
373 : : /* load onto outgoing mailbox */
374 : 0 : return mbx->ops.enqueue_tx(hw, mbx, msg);
375 : : }
376 : :
377 : : /**
378 : : * fm10k_update_int_moderator_vf - Request update of interrupt moderator list
379 : : * @hw: pointer to hardware structure
380 : : *
381 : : * This function will issue a request to the PF to rescan our MSI-X table
382 : : * and to update the interrupt moderator linked list.
383 : : **/
384 : 0 : STATIC void fm10k_update_int_moderator_vf(struct fm10k_hw *hw)
385 : : {
386 : 0 : struct fm10k_mbx_info *mbx = &hw->mbx;
387 : : u32 msg[1];
388 : :
389 : : /* generate MSI-X request */
390 : 0 : fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MSIX);
391 : :
392 : : /* load onto outgoing mailbox */
393 : 0 : mbx->ops.enqueue_tx(hw, mbx, msg);
394 : 0 : }
395 : :
396 : : /* This structure defines the attibutes to be parsed below */
397 : : const struct fm10k_tlv_attr fm10k_lport_state_msg_attr[] = {
398 : : FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_DISABLE),
399 : : FM10K_TLV_ATTR_U8(FM10K_LPORT_STATE_MSG_XCAST_MODE),
400 : : FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_READY),
401 : : FM10K_TLV_ATTR_LAST
402 : : };
403 : :
404 : : /**
405 : : * fm10k_msg_lport_state_vf - Message handler for lport_state message from PF
406 : : * @hw: Pointer to hardware structure
407 : : * @results: pointer array containing parsed data
408 : : * @mbx: Pointer to mailbox information structure
409 : : *
410 : : * This handler is meant to capture the indication from the PF that we
411 : : * are ready to bring up the interface.
412 : : **/
413 : 0 : s32 fm10k_msg_lport_state_vf(struct fm10k_hw *hw, u32 **results,
414 : : struct fm10k_mbx_info *mbx)
415 : : {
416 : : UNREFERENCED_1PARAMETER(mbx);
417 : 0 : DEBUGFUNC("fm10k_msg_lport_state_vf");
418 : :
419 : 0 : hw->mac.dglort_map = !results[FM10K_LPORT_STATE_MSG_READY] ?
420 [ # # ]: 0 : FM10K_DGLORTMAP_NONE : FM10K_DGLORTMAP_ZERO;
421 : :
422 : 0 : return FM10K_SUCCESS;
423 : : }
424 : :
425 : : /**
426 : : * fm10k_update_lport_state_vf - Update device state in lower device
427 : : * @hw: pointer to the HW structure
428 : : * @glort: unused
429 : : * @count: number of logical ports to enable - unused (always 1)
430 : : * @enable: boolean value indicating if this is an enable or disable request
431 : : *
432 : : * Notify the lower device of a state change. If the lower device is
433 : : * enabled we can add filters, if it is disabled all filters for this
434 : : * logical port are flushed.
435 : : **/
436 : 0 : STATIC s32 fm10k_update_lport_state_vf(struct fm10k_hw *hw, u16 glort,
437 : : u16 count, bool enable)
438 : : {
439 : 0 : struct fm10k_mbx_info *mbx = &hw->mbx;
440 : : u32 msg[2];
441 : :
442 : : UNREFERENCED_2PARAMETER(glort, count);
443 : 0 : DEBUGFUNC("fm10k_update_lport_state_vf");
444 : :
445 : : /* reset glort mask 0 as we have to wait to be enabled */
446 : 0 : hw->mac.dglort_map = FM10K_DGLORTMAP_NONE;
447 : :
448 : : /* generate port state request */
449 : 0 : fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
450 [ # # ]: 0 : if (!enable)
451 : 0 : fm10k_tlv_attr_put_bool(msg, FM10K_LPORT_STATE_MSG_DISABLE);
452 : :
453 : : /* load onto outgoing mailbox */
454 : 0 : return mbx->ops.enqueue_tx(hw, mbx, msg);
455 : : }
456 : :
457 : : /**
458 : : * fm10k_update_xcast_mode_vf - Request update of multicast mode
459 : : * @hw: pointer to hardware structure
460 : : * @glort: unused
461 : : * @mode: integer value indicating mode being requested
462 : : *
463 : : * This function will attempt to request a higher mode for the port
464 : : * so that it can enable either multicast, multicast promiscuous, or
465 : : * promiscuous mode of operation.
466 : : **/
467 : 0 : STATIC s32 fm10k_update_xcast_mode_vf(struct fm10k_hw *hw, u16 glort, u8 mode)
468 : : {
469 : 0 : struct fm10k_mbx_info *mbx = &hw->mbx;
470 : : u32 msg[3];
471 : :
472 : : UNREFERENCED_1PARAMETER(glort);
473 : 0 : DEBUGFUNC("fm10k_update_xcast_mode_vf");
474 : :
475 [ # # ]: 0 : if (mode > FM10K_XCAST_MODE_NONE)
476 : : return FM10K_ERR_PARAM;
477 : :
478 : : /* generate message requesting to change xcast mode */
479 : 0 : fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
480 : 0 : fm10k_tlv_attr_put_u8(msg, FM10K_LPORT_STATE_MSG_XCAST_MODE, mode);
481 : :
482 : : /* load onto outgoing mailbox */
483 : 0 : return mbx->ops.enqueue_tx(hw, mbx, msg);
484 : : }
485 : :
486 : : const struct fm10k_tlv_attr fm10k_1588_msg_attr[] = {
487 : : FM10K_TLV_ATTR_U64(FM10K_1588_MSG_CLK_OFFSET),
488 : : FM10K_TLV_ATTR_LAST
489 : : };
490 : :
491 : : /* currently there is no shared 1588 message handler */
492 : :
493 : : /**
494 : : * fm10k_update_hw_stats_vf - Updates hardware related statistics of VF
495 : : * @hw: pointer to hardware structure
496 : : * @stats: pointer to statistics structure
497 : : *
498 : : * This function collects and aggregates per queue hardware statistics.
499 : : **/
500 : 0 : void fm10k_update_hw_stats_vf(struct fm10k_hw *hw,
501 : : struct fm10k_hw_stats *stats)
502 : : {
503 : 0 : DEBUGFUNC("fm10k_update_hw_stats_vf");
504 : :
505 : 0 : fm10k_update_hw_stats_q(hw, stats->q, 0, hw->mac.max_queues);
506 : 0 : }
507 : :
508 : : /**
509 : : * fm10k_rebind_hw_stats_vf - Resets base for hardware statistics of VF
510 : : * @hw: pointer to hardware structure
511 : : * @stats: pointer to the stats structure to update
512 : : *
513 : : * This function resets the base for queue hardware statistics.
514 : : **/
515 : 0 : void fm10k_rebind_hw_stats_vf(struct fm10k_hw *hw,
516 : : struct fm10k_hw_stats *stats)
517 : : {
518 : 0 : DEBUGFUNC("fm10k_rebind_hw_stats_vf");
519 : :
520 : : /* Unbind Queue Statistics */
521 : 0 : fm10k_unbind_hw_stats_q(stats->q, 0, hw->mac.max_queues);
522 : :
523 : : /* Reinitialize bases for all stats */
524 : 0 : fm10k_update_hw_stats_vf(hw, stats);
525 : 0 : }
526 : :
527 : : /**
528 : : * fm10k_configure_dglort_map_vf - Configures GLORT entry and queues
529 : : * @hw: pointer to hardware structure
530 : : * @dglort: pointer to dglort configuration structure
531 : : *
532 : : * Reads the configuration structure contained in dglort_cfg and uses
533 : : * that information to then populate a DGLORTMAP/DEC entry and the queues
534 : : * to which it has been assigned.
535 : : **/
536 : 0 : STATIC s32 fm10k_configure_dglort_map_vf(struct fm10k_hw *hw,
537 : : struct fm10k_dglort_cfg *dglort)
538 : : {
539 : : UNREFERENCED_1PARAMETER(hw);
540 : 0 : DEBUGFUNC("fm10k_configure_dglort_map_vf");
541 : :
542 : : /* verify the dglort pointer */
543 [ # # ]: 0 : if (!dglort)
544 : 0 : return FM10K_ERR_PARAM;
545 : :
546 : : /* stub for now until we determine correct message for this */
547 : :
548 : : return FM10K_SUCCESS;
549 : : }
550 : :
551 : : /**
552 : : * fm10k_adjust_systime_vf - Adjust systime frequency
553 : : * @hw: pointer to hardware structure
554 : : * @ppb: adjustment rate in parts per billion
555 : : *
556 : : * This function takes an adjustment rate in parts per billion and will
557 : : * verify that this value is 0 as the VF cannot support adjusting the
558 : : * systime clock.
559 : : *
560 : : * If the ppb value is non-zero the return is ERR_PARAM else success
561 : : **/
562 : 0 : STATIC s32 fm10k_adjust_systime_vf(struct fm10k_hw *hw, s32 ppb)
563 : : {
564 : : UNREFERENCED_1PARAMETER(hw);
565 : 0 : DEBUGFUNC("fm10k_adjust_systime_vf");
566 : :
567 : : /* The VF cannot adjust the clock frequency, however it should
568 : : * already have a syntonic clock with whichever host interface is
569 : : * running as the master for the host interface clock domain so
570 : : * there should be not frequency adjustment necessary.
571 : : */
572 [ # # ]: 0 : return ppb ? FM10K_ERR_PARAM : FM10K_SUCCESS;
573 : : }
574 : :
575 : : /**
576 : : * fm10k_read_systime_vf - Reads value of systime registers
577 : : * @hw: pointer to the hardware structure
578 : : *
579 : : * Function reads the content of 2 registers, combined to represent a 64 bit
580 : : * value measured in nanoseconds. In order to guarantee the value is accurate
581 : : * we check the 32 most significant bits both before and after reading the
582 : : * 32 least significant bits to verify they didn't change as we were reading
583 : : * the registers.
584 : : **/
585 : 0 : static u64 fm10k_read_systime_vf(struct fm10k_hw *hw)
586 : : {
587 : : u32 systime_l, systime_h, systime_tmp;
588 : :
589 : 0 : systime_h = fm10k_read_reg(hw, FM10K_VFSYSTIME + 1);
590 : :
591 : : do {
592 : : systime_tmp = systime_h;
593 : 0 : systime_l = fm10k_read_reg(hw, FM10K_VFSYSTIME);
594 : 0 : systime_h = fm10k_read_reg(hw, FM10K_VFSYSTIME + 1);
595 [ # # ]: 0 : } while (systime_tmp != systime_h);
596 : :
597 : 0 : return ((u64)systime_h << 32) | systime_l;
598 : : }
599 : :
600 : : static const struct fm10k_msg_data fm10k_msg_data_vf[] = {
601 : : FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test),
602 : : FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_msg_mac_vlan_vf),
603 : : FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_msg_lport_state_vf),
604 : : FM10K_TLV_MSG_ERROR_HANDLER(fm10k_tlv_msg_error),
605 : : };
606 : :
607 : : /**
608 : : * fm10k_init_ops_vf - Inits func ptrs and MAC type
609 : : * @hw: pointer to hardware structure
610 : : *
611 : : * Initialize the function pointers and assign the MAC type for VF.
612 : : * Does not touch the hardware.
613 : : **/
614 : 0 : s32 fm10k_init_ops_vf(struct fm10k_hw *hw)
615 : : {
616 : : struct fm10k_mac_info *mac = &hw->mac;
617 : :
618 : 0 : DEBUGFUNC("fm10k_init_ops_vf");
619 : :
620 : 0 : fm10k_init_ops_generic(hw);
621 : :
622 : 0 : mac->ops.reset_hw = &fm10k_reset_hw_vf;
623 : 0 : mac->ops.init_hw = &fm10k_init_hw_vf;
624 : 0 : mac->ops.start_hw = &fm10k_start_hw_generic;
625 : 0 : mac->ops.stop_hw = &fm10k_stop_hw_vf;
626 : : #ifndef NO_IS_SLOT_APPROPRIATE_CHECK
627 : 0 : mac->ops.is_slot_appropriate = &fm10k_is_slot_appropriate_vf;
628 : : #endif
629 : 0 : mac->ops.update_vlan = &fm10k_update_vlan_vf;
630 : 0 : mac->ops.read_mac_addr = &fm10k_read_mac_addr_vf;
631 : 0 : mac->ops.update_uc_addr = &fm10k_update_uc_addr_vf;
632 : 0 : mac->ops.update_mc_addr = &fm10k_update_mc_addr_vf;
633 : 0 : mac->ops.update_xcast_mode = &fm10k_update_xcast_mode_vf;
634 : 0 : mac->ops.update_int_moderator = &fm10k_update_int_moderator_vf;
635 : 0 : mac->ops.update_lport_state = &fm10k_update_lport_state_vf;
636 : 0 : mac->ops.update_hw_stats = &fm10k_update_hw_stats_vf;
637 : 0 : mac->ops.rebind_hw_stats = &fm10k_rebind_hw_stats_vf;
638 : 0 : mac->ops.configure_dglort_map = &fm10k_configure_dglort_map_vf;
639 : 0 : mac->ops.get_host_state = &fm10k_get_host_state_generic;
640 : 0 : mac->ops.adjust_systime = &fm10k_adjust_systime_vf;
641 : 0 : mac->ops.read_systime = &fm10k_read_systime_vf;
642 : :
643 : 0 : mac->max_msix_vectors = fm10k_get_pcie_msix_count_generic(hw);
644 : :
645 : 0 : return fm10k_pfvf_mbx_init(hw, &hw->mbx, fm10k_msg_data_vf, 0);
646 : : }
|
