GNU Linux-libre 4.9.330-gnu1
[releases.git] / drivers / net / ethernet / intel / fm10k / fm10k_vf.c
1 /* Intel(R) Ethernet Switch Host Interface Driver
2  * Copyright(c) 2013 - 2016 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  * The full GNU General Public License is included in this distribution in
14  * the file called "COPYING".
15  *
16  * Contact Information:
17  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
18  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
19  */
20
21 #include "fm10k_vf.h"
22
23 /**
24  *  fm10k_stop_hw_vf - Stop Tx/Rx units
25  *  @hw: pointer to hardware structure
26  *
27  **/
28 static s32 fm10k_stop_hw_vf(struct fm10k_hw *hw)
29 {
30         u8 *perm_addr = hw->mac.perm_addr;
31         u32 bal = 0, bah = 0, tdlen;
32         s32 err;
33         u16 i;
34
35         /* we need to disable the queues before taking further steps */
36         err = fm10k_stop_hw_generic(hw);
37         if (err && err != FM10K_ERR_REQUESTS_PENDING)
38                 return err;
39
40         /* If permanent address is set then we need to restore it */
41         if (is_valid_ether_addr(perm_addr)) {
42                 bal = (((u32)perm_addr[3]) << 24) |
43                       (((u32)perm_addr[4]) << 16) |
44                       (((u32)perm_addr[5]) << 8);
45                 bah = (((u32)0xFF)         << 24) |
46                       (((u32)perm_addr[0]) << 16) |
47                       (((u32)perm_addr[1]) << 8) |
48                        ((u32)perm_addr[2]);
49         }
50
51         /* restore default itr_scale for next VF initialization */
52         tdlen = hw->mac.itr_scale << FM10K_TDLEN_ITR_SCALE_SHIFT;
53
54         /* The queues have already been disabled so we just need to
55          * update their base address registers
56          */
57         for (i = 0; i < hw->mac.max_queues; i++) {
58                 fm10k_write_reg(hw, FM10K_TDBAL(i), bal);
59                 fm10k_write_reg(hw, FM10K_TDBAH(i), bah);
60                 fm10k_write_reg(hw, FM10K_RDBAL(i), bal);
61                 fm10k_write_reg(hw, FM10K_RDBAH(i), bah);
62                 /* Restore ITR scale in software-defined mechanism in TDLEN
63                  * for next VF initialization. See definition of
64                  * FM10K_TDLEN_ITR_SCALE_SHIFT for more details on the use of
65                  * TDLEN here.
66                  */
67                 fm10k_write_reg(hw, FM10K_TDLEN(i), tdlen);
68         }
69
70         return err;
71 }
72
73 /**
74  *  fm10k_reset_hw_vf - VF hardware reset
75  *  @hw: pointer to hardware structure
76  *
77  *  This function should return the hardware to a state similar to the
78  *  one it is in after just being initialized.
79  **/
80 static s32 fm10k_reset_hw_vf(struct fm10k_hw *hw)
81 {
82         s32 err;
83
84         /* shut down queues we own and reset DMA configuration */
85         err = fm10k_stop_hw_vf(hw);
86         if (err == FM10K_ERR_REQUESTS_PENDING)
87                 hw->mac.reset_while_pending++;
88         else if (err)
89                 return err;
90
91         /* Inititate VF reset */
92         fm10k_write_reg(hw, FM10K_VFCTRL, FM10K_VFCTRL_RST);
93
94         /* Flush write and allow 100us for reset to complete */
95         fm10k_write_flush(hw);
96         udelay(FM10K_RESET_TIMEOUT);
97
98         /* Clear reset bit and verify it was cleared */
99         fm10k_write_reg(hw, FM10K_VFCTRL, 0);
100         if (fm10k_read_reg(hw, FM10K_VFCTRL) & FM10K_VFCTRL_RST)
101                 return FM10K_ERR_RESET_FAILED;
102
103         return 0;
104 }
105
106 /**
107  *  fm10k_init_hw_vf - VF hardware initialization
108  *  @hw: pointer to hardware structure
109  *
110  **/
111 static s32 fm10k_init_hw_vf(struct fm10k_hw *hw)
112 {
113         u32 tqdloc, tqdloc0 = ~fm10k_read_reg(hw, FM10K_TQDLOC(0));
114         s32 err;
115         u16 i;
116
117         /* verify we have at least 1 queue */
118         if (!~fm10k_read_reg(hw, FM10K_TXQCTL(0)) ||
119             !~fm10k_read_reg(hw, FM10K_RXQCTL(0))) {
120                 err = FM10K_ERR_NO_RESOURCES;
121                 goto reset_max_queues;
122         }
123
124         /* determine how many queues we have */
125         for (i = 1; tqdloc0 && (i < FM10K_MAX_QUEUES_POOL); i++) {
126                 /* verify the Descriptor cache offsets are increasing */
127                 tqdloc = ~fm10k_read_reg(hw, FM10K_TQDLOC(i));
128                 if (!tqdloc || (tqdloc == tqdloc0))
129                         break;
130
131                 /* check to verify the PF doesn't own any of our queues */
132                 if (!~fm10k_read_reg(hw, FM10K_TXQCTL(i)) ||
133                     !~fm10k_read_reg(hw, FM10K_RXQCTL(i)))
134                         break;
135         }
136
137         /* shut down queues we own and reset DMA configuration */
138         err = fm10k_disable_queues_generic(hw, i);
139         if (err)
140                 goto reset_max_queues;
141
142         /* record maximum queue count */
143         hw->mac.max_queues = i;
144
145         /* fetch default VLAN and ITR scale */
146         hw->mac.default_vid = (fm10k_read_reg(hw, FM10K_TXQCTL(0)) &
147                                FM10K_TXQCTL_VID_MASK) >> FM10K_TXQCTL_VID_SHIFT;
148         /* Read the ITR scale from TDLEN. See the definition of
149          * FM10K_TDLEN_ITR_SCALE_SHIFT for more information about how TDLEN is
150          * used here.
151          */
152         hw->mac.itr_scale = (fm10k_read_reg(hw, FM10K_TDLEN(0)) &
153                              FM10K_TDLEN_ITR_SCALE_MASK) >>
154                             FM10K_TDLEN_ITR_SCALE_SHIFT;
155
156         return 0;
157
158 reset_max_queues:
159         hw->mac.max_queues = 0;
160
161         return err;
162 }
163
164 /* This structure defines the attibutes to be parsed below */
165 const struct fm10k_tlv_attr fm10k_mac_vlan_msg_attr[] = {
166         FM10K_TLV_ATTR_U32(FM10K_MAC_VLAN_MSG_VLAN),
167         FM10K_TLV_ATTR_BOOL(FM10K_MAC_VLAN_MSG_SET),
168         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MAC),
169         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_DEFAULT_MAC),
170         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MULTICAST),
171         FM10K_TLV_ATTR_LAST
172 };
173
174 /**
175  *  fm10k_update_vlan_vf - Update status of VLAN ID in VLAN filter table
176  *  @hw: pointer to hardware structure
177  *  @vid: VLAN ID to add to table
178  *  @vsi: Reserved, should always be 0
179  *  @set: Indicates if this is a set or clear operation
180  *
181  *  This function adds or removes the corresponding VLAN ID from the VLAN
182  *  filter table for this VF.
183  **/
184 static s32 fm10k_update_vlan_vf(struct fm10k_hw *hw, u32 vid, u8 vsi, bool set)
185 {
186         struct fm10k_mbx_info *mbx = &hw->mbx;
187         u32 msg[4];
188
189         /* verify the index is not set */
190         if (vsi)
191                 return FM10K_ERR_PARAM;
192
193         /* clever trick to verify reserved bits in both vid and length */
194         if ((vid << 16 | vid) >> 28)
195                 return FM10K_ERR_PARAM;
196
197         /* encode set bit into the VLAN ID */
198         if (!set)
199                 vid |= FM10K_VLAN_CLEAR;
200
201         /* generate VLAN request */
202         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
203         fm10k_tlv_attr_put_u32(msg, FM10K_MAC_VLAN_MSG_VLAN, vid);
204
205         /* load onto outgoing mailbox */
206         return mbx->ops.enqueue_tx(hw, mbx, msg);
207 }
208
209 /**
210  *  fm10k_msg_mac_vlan_vf - Read device MAC address from mailbox message
211  *  @hw: pointer to the HW structure
212  *  @results: Attributes for message
213  *  @mbx: unused mailbox data
214  *
215  *  This function should determine the MAC address for the VF
216  **/
217 s32 fm10k_msg_mac_vlan_vf(struct fm10k_hw *hw, u32 **results,
218                           struct fm10k_mbx_info *mbx)
219 {
220         u8 perm_addr[ETH_ALEN];
221         u16 vid;
222         s32 err;
223
224         /* record MAC address requested */
225         err = fm10k_tlv_attr_get_mac_vlan(
226                                         results[FM10K_MAC_VLAN_MSG_DEFAULT_MAC],
227                                         perm_addr, &vid);
228         if (err)
229                 return err;
230
231         ether_addr_copy(hw->mac.perm_addr, perm_addr);
232         hw->mac.default_vid = vid & (FM10K_VLAN_TABLE_VID_MAX - 1);
233         hw->mac.vlan_override = !!(vid & FM10K_VLAN_OVERRIDE);
234
235         return 0;
236 }
237
238 /**
239  *  fm10k_read_mac_addr_vf - Read device MAC address
240  *  @hw: pointer to the HW structure
241  *
242  *  This function should determine the MAC address for the VF
243  **/
244 static s32 fm10k_read_mac_addr_vf(struct fm10k_hw *hw)
245 {
246         u8 perm_addr[ETH_ALEN];
247         u32 base_addr;
248
249         base_addr = fm10k_read_reg(hw, FM10K_TDBAL(0));
250
251         /* last byte should be 0 */
252         if (base_addr << 24)
253                 return  FM10K_ERR_INVALID_MAC_ADDR;
254
255         perm_addr[3] = (u8)(base_addr >> 24);
256         perm_addr[4] = (u8)(base_addr >> 16);
257         perm_addr[5] = (u8)(base_addr >> 8);
258
259         base_addr = fm10k_read_reg(hw, FM10K_TDBAH(0));
260
261         /* first byte should be all 1's */
262         if ((~base_addr) >> 24)
263                 return  FM10K_ERR_INVALID_MAC_ADDR;
264
265         perm_addr[0] = (u8)(base_addr >> 16);
266         perm_addr[1] = (u8)(base_addr >> 8);
267         perm_addr[2] = (u8)(base_addr);
268
269         ether_addr_copy(hw->mac.perm_addr, perm_addr);
270         ether_addr_copy(hw->mac.addr, perm_addr);
271
272         return 0;
273 }
274
275 /**
276  *  fm10k_update_uc_addr_vf - Update device unicast addresses
277  *  @hw: pointer to the HW structure
278  *  @glort: unused
279  *  @mac: MAC address to add/remove from table
280  *  @vid: VLAN ID to add/remove from table
281  *  @add: Indicates if this is an add or remove operation
282  *  @flags: flags field to indicate add and secure - unused
283  *
284  *  This function is used to add or remove unicast MAC addresses for
285  *  the VF.
286  **/
287 static s32 fm10k_update_uc_addr_vf(struct fm10k_hw *hw, u16 glort,
288                                    const u8 *mac, u16 vid, bool add, u8 flags)
289 {
290         struct fm10k_mbx_info *mbx = &hw->mbx;
291         u32 msg[7];
292
293         /* verify VLAN ID is valid */
294         if (vid >= FM10K_VLAN_TABLE_VID_MAX)
295                 return FM10K_ERR_PARAM;
296
297         /* verify MAC address is valid */
298         if (!is_valid_ether_addr(mac))
299                 return FM10K_ERR_PARAM;
300
301         /* verify we are not locked down on the MAC address */
302         if (is_valid_ether_addr(hw->mac.perm_addr) &&
303             !ether_addr_equal(hw->mac.perm_addr, mac))
304                 return FM10K_ERR_PARAM;
305
306         /* add bit to notify us if this is a set or clear operation */
307         if (!add)
308                 vid |= FM10K_VLAN_CLEAR;
309
310         /* generate VLAN request */
311         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
312         fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MAC, mac, vid);
313
314         /* load onto outgoing mailbox */
315         return mbx->ops.enqueue_tx(hw, mbx, msg);
316 }
317
318 /**
319  *  fm10k_update_mc_addr_vf - Update device multicast addresses
320  *  @hw: pointer to the HW structure
321  *  @glort: unused
322  *  @mac: MAC address to add/remove from table
323  *  @vid: VLAN ID to add/remove from table
324  *  @add: Indicates if this is an add or remove operation
325  *
326  *  This function is used to add or remove multicast MAC addresses for
327  *  the VF.
328  **/
329 static s32 fm10k_update_mc_addr_vf(struct fm10k_hw *hw, u16 glort,
330                                    const u8 *mac, u16 vid, bool add)
331 {
332         struct fm10k_mbx_info *mbx = &hw->mbx;
333         u32 msg[7];
334
335         /* verify VLAN ID is valid */
336         if (vid >= FM10K_VLAN_TABLE_VID_MAX)
337                 return FM10K_ERR_PARAM;
338
339         /* verify multicast address is valid */
340         if (!is_multicast_ether_addr(mac))
341                 return FM10K_ERR_PARAM;
342
343         /* add bit to notify us if this is a set or clear operation */
344         if (!add)
345                 vid |= FM10K_VLAN_CLEAR;
346
347         /* generate VLAN request */
348         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
349         fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MULTICAST,
350                                     mac, vid);
351
352         /* load onto outgoing mailbox */
353         return mbx->ops.enqueue_tx(hw, mbx, msg);
354 }
355
356 /**
357  *  fm10k_update_int_moderator_vf - Request update of interrupt moderator list
358  *  @hw: pointer to hardware structure
359  *
360  *  This function will issue a request to the PF to rescan our MSI-X table
361  *  and to update the interrupt moderator linked list.
362  **/
363 static void fm10k_update_int_moderator_vf(struct fm10k_hw *hw)
364 {
365         struct fm10k_mbx_info *mbx = &hw->mbx;
366         u32 msg[1];
367
368         /* generate MSI-X request */
369         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MSIX);
370
371         /* load onto outgoing mailbox */
372         mbx->ops.enqueue_tx(hw, mbx, msg);
373 }
374
375 /* This structure defines the attibutes to be parsed below */
376 const struct fm10k_tlv_attr fm10k_lport_state_msg_attr[] = {
377         FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_DISABLE),
378         FM10K_TLV_ATTR_U8(FM10K_LPORT_STATE_MSG_XCAST_MODE),
379         FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_READY),
380         FM10K_TLV_ATTR_LAST
381 };
382
383 /**
384  *  fm10k_msg_lport_state_vf - Message handler for lport_state message from PF
385  *  @hw: Pointer to hardware structure
386  *  @results: pointer array containing parsed data
387  *  @mbx: Pointer to mailbox information structure
388  *
389  *  This handler is meant to capture the indication from the PF that we
390  *  are ready to bring up the interface.
391  **/
392 s32 fm10k_msg_lport_state_vf(struct fm10k_hw *hw, u32 **results,
393                              struct fm10k_mbx_info *mbx)
394 {
395         hw->mac.dglort_map = !results[FM10K_LPORT_STATE_MSG_READY] ?
396                              FM10K_DGLORTMAP_NONE : FM10K_DGLORTMAP_ZERO;
397
398         return 0;
399 }
400
401 /**
402  *  fm10k_update_lport_state_vf - Update device state in lower device
403  *  @hw: pointer to the HW structure
404  *  @glort: unused
405  *  @count: number of logical ports to enable - unused (always 1)
406  *  @enable: boolean value indicating if this is an enable or disable request
407  *
408  *  Notify the lower device of a state change.  If the lower device is
409  *  enabled we can add filters, if it is disabled all filters for this
410  *  logical port are flushed.
411  **/
412 static s32 fm10k_update_lport_state_vf(struct fm10k_hw *hw, u16 glort,
413                                        u16 count, bool enable)
414 {
415         struct fm10k_mbx_info *mbx = &hw->mbx;
416         u32 msg[2];
417
418         /* reset glort mask 0 as we have to wait to be enabled */
419         hw->mac.dglort_map = FM10K_DGLORTMAP_NONE;
420
421         /* generate port state request */
422         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
423         if (!enable)
424                 fm10k_tlv_attr_put_bool(msg, FM10K_LPORT_STATE_MSG_DISABLE);
425
426         /* load onto outgoing mailbox */
427         return mbx->ops.enqueue_tx(hw, mbx, msg);
428 }
429
430 /**
431  *  fm10k_update_xcast_mode_vf - Request update of multicast mode
432  *  @hw: pointer to hardware structure
433  *  @glort: unused
434  *  @mode: integer value indicating mode being requested
435  *
436  *  This function will attempt to request a higher mode for the port
437  *  so that it can enable either multicast, multicast promiscuous, or
438  *  promiscuous mode of operation.
439  **/
440 static s32 fm10k_update_xcast_mode_vf(struct fm10k_hw *hw, u16 glort, u8 mode)
441 {
442         struct fm10k_mbx_info *mbx = &hw->mbx;
443         u32 msg[3];
444
445         if (mode > FM10K_XCAST_MODE_NONE)
446                 return FM10K_ERR_PARAM;
447
448         /* generate message requesting to change xcast mode */
449         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
450         fm10k_tlv_attr_put_u8(msg, FM10K_LPORT_STATE_MSG_XCAST_MODE, mode);
451
452         /* load onto outgoing mailbox */
453         return mbx->ops.enqueue_tx(hw, mbx, msg);
454 }
455
456 /**
457  *  fm10k_update_hw_stats_vf - Updates hardware related statistics of VF
458  *  @hw: pointer to hardware structure
459  *  @stats: pointer to statistics structure
460  *
461  *  This function collects and aggregates per queue hardware statistics.
462  **/
463 static void fm10k_update_hw_stats_vf(struct fm10k_hw *hw,
464                                      struct fm10k_hw_stats *stats)
465 {
466         fm10k_update_hw_stats_q(hw, stats->q, 0, hw->mac.max_queues);
467 }
468
469 /**
470  *  fm10k_rebind_hw_stats_vf - Resets base for hardware statistics of VF
471  *  @hw: pointer to hardware structure
472  *  @stats: pointer to the stats structure to update
473  *
474  *  This function resets the base for queue hardware statistics.
475  **/
476 static void fm10k_rebind_hw_stats_vf(struct fm10k_hw *hw,
477                                      struct fm10k_hw_stats *stats)
478 {
479         /* Unbind Queue Statistics */
480         fm10k_unbind_hw_stats_q(stats->q, 0, hw->mac.max_queues);
481
482         /* Reinitialize bases for all stats */
483         fm10k_update_hw_stats_vf(hw, stats);
484 }
485
486 /**
487  *  fm10k_configure_dglort_map_vf - Configures GLORT entry and queues
488  *  @hw: pointer to hardware structure
489  *  @dglort: pointer to dglort configuration structure
490  *
491  *  Reads the configuration structure contained in dglort_cfg and uses
492  *  that information to then populate a DGLORTMAP/DEC entry and the queues
493  *  to which it has been assigned.
494  **/
495 static s32 fm10k_configure_dglort_map_vf(struct fm10k_hw *hw,
496                                          struct fm10k_dglort_cfg *dglort)
497 {
498         /* verify the dglort pointer */
499         if (!dglort)
500                 return FM10K_ERR_PARAM;
501
502         /* stub for now until we determine correct message for this */
503
504         return 0;
505 }
506
507 static const struct fm10k_msg_data fm10k_msg_data_vf[] = {
508         FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test),
509         FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_msg_mac_vlan_vf),
510         FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_msg_lport_state_vf),
511         FM10K_TLV_MSG_ERROR_HANDLER(fm10k_tlv_msg_error),
512 };
513
514 static const struct fm10k_mac_ops mac_ops_vf = {
515         .get_bus_info           = fm10k_get_bus_info_generic,
516         .reset_hw               = fm10k_reset_hw_vf,
517         .init_hw                = fm10k_init_hw_vf,
518         .start_hw               = fm10k_start_hw_generic,
519         .stop_hw                = fm10k_stop_hw_vf,
520         .update_vlan            = fm10k_update_vlan_vf,
521         .read_mac_addr          = fm10k_read_mac_addr_vf,
522         .update_uc_addr         = fm10k_update_uc_addr_vf,
523         .update_mc_addr         = fm10k_update_mc_addr_vf,
524         .update_xcast_mode      = fm10k_update_xcast_mode_vf,
525         .update_int_moderator   = fm10k_update_int_moderator_vf,
526         .update_lport_state     = fm10k_update_lport_state_vf,
527         .update_hw_stats        = fm10k_update_hw_stats_vf,
528         .rebind_hw_stats        = fm10k_rebind_hw_stats_vf,
529         .configure_dglort_map   = fm10k_configure_dglort_map_vf,
530         .get_host_state         = fm10k_get_host_state_generic,
531 };
532
533 static s32 fm10k_get_invariants_vf(struct fm10k_hw *hw)
534 {
535         fm10k_get_invariants_generic(hw);
536
537         return fm10k_pfvf_mbx_init(hw, &hw->mbx, fm10k_msg_data_vf, 0);
538 }
539
540 const struct fm10k_info fm10k_vf_info = {
541         .mac            = fm10k_mac_vf,
542         .get_invariants = fm10k_get_invariants_vf,
543         .mac_ops        = &mac_ops_vf,
544 };