fm10k/base: fix max queues on VF initialization failure
[dpdk.git] / drivers / net / fm10k / base / fm10k_common.c
1 /*******************************************************************************
2
3 Copyright (c) 2013 - 2015, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9  1. Redistributions of source code must retain the above copyright notice,
10     this list of conditions and the following disclaimer.
11
12  2. Redistributions in binary form must reproduce the above copyright
13     notice, this list of conditions and the following disclaimer in the
14     documentation and/or other materials provided with the distribution.
15
16  3. Neither the name of the Intel Corporation nor the names of its
17     contributors may be used to endorse or promote products derived from
18     this software without specific prior written permission.
19
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32 ***************************************************************************/
33
34 #include "fm10k_common.h"
35
36 /**
37  *  fm10k_get_bus_info_generic - Generic set PCI bus info
38  *  @hw: pointer to hardware structure
39  *
40  *  Gets the PCI bus info (speed, width, type) then calls helper function to
41  *  store this data within the fm10k_hw structure.
42  **/
43 STATIC s32 fm10k_get_bus_info_generic(struct fm10k_hw *hw)
44 {
45         u16 link_cap, link_status, device_cap, device_control;
46
47         DEBUGFUNC("fm10k_get_bus_info_generic");
48
49         /* Get the maximum link width and speed from PCIe config space */
50         link_cap = FM10K_READ_PCI_WORD(hw, FM10K_PCIE_LINK_CAP);
51
52         switch (link_cap & FM10K_PCIE_LINK_WIDTH) {
53         case FM10K_PCIE_LINK_WIDTH_1:
54                 hw->bus_caps.width = fm10k_bus_width_pcie_x1;
55                 break;
56         case FM10K_PCIE_LINK_WIDTH_2:
57                 hw->bus_caps.width = fm10k_bus_width_pcie_x2;
58                 break;
59         case FM10K_PCIE_LINK_WIDTH_4:
60                 hw->bus_caps.width = fm10k_bus_width_pcie_x4;
61                 break;
62         case FM10K_PCIE_LINK_WIDTH_8:
63                 hw->bus_caps.width = fm10k_bus_width_pcie_x8;
64                 break;
65         default:
66                 hw->bus_caps.width = fm10k_bus_width_unknown;
67                 break;
68         }
69
70         switch (link_cap & FM10K_PCIE_LINK_SPEED) {
71         case FM10K_PCIE_LINK_SPEED_2500:
72                 hw->bus_caps.speed = fm10k_bus_speed_2500;
73                 break;
74         case FM10K_PCIE_LINK_SPEED_5000:
75                 hw->bus_caps.speed = fm10k_bus_speed_5000;
76                 break;
77         case FM10K_PCIE_LINK_SPEED_8000:
78                 hw->bus_caps.speed = fm10k_bus_speed_8000;
79                 break;
80         default:
81                 hw->bus_caps.speed = fm10k_bus_speed_unknown;
82                 break;
83         }
84
85         /* Get the PCIe maximum payload size for the PCIe function */
86         device_cap = FM10K_READ_PCI_WORD(hw, FM10K_PCIE_DEV_CAP);
87
88         switch (device_cap & FM10K_PCIE_DEV_CAP_PAYLOAD) {
89         case FM10K_PCIE_DEV_CAP_PAYLOAD_128:
90                 hw->bus_caps.payload = fm10k_bus_payload_128;
91                 break;
92         case FM10K_PCIE_DEV_CAP_PAYLOAD_256:
93                 hw->bus_caps.payload = fm10k_bus_payload_256;
94                 break;
95         case FM10K_PCIE_DEV_CAP_PAYLOAD_512:
96                 hw->bus_caps.payload = fm10k_bus_payload_512;
97                 break;
98         default:
99                 hw->bus_caps.payload = fm10k_bus_payload_unknown;
100                 break;
101         }
102
103         /* Get the negotiated link width and speed from PCIe config space */
104         link_status = FM10K_READ_PCI_WORD(hw, FM10K_PCIE_LINK_STATUS);
105
106         switch (link_status & FM10K_PCIE_LINK_WIDTH) {
107         case FM10K_PCIE_LINK_WIDTH_1:
108                 hw->bus.width = fm10k_bus_width_pcie_x1;
109                 break;
110         case FM10K_PCIE_LINK_WIDTH_2:
111                 hw->bus.width = fm10k_bus_width_pcie_x2;
112                 break;
113         case FM10K_PCIE_LINK_WIDTH_4:
114                 hw->bus.width = fm10k_bus_width_pcie_x4;
115                 break;
116         case FM10K_PCIE_LINK_WIDTH_8:
117                 hw->bus.width = fm10k_bus_width_pcie_x8;
118                 break;
119         default:
120                 hw->bus.width = fm10k_bus_width_unknown;
121                 break;
122         }
123
124         switch (link_status & FM10K_PCIE_LINK_SPEED) {
125         case FM10K_PCIE_LINK_SPEED_2500:
126                 hw->bus.speed = fm10k_bus_speed_2500;
127                 break;
128         case FM10K_PCIE_LINK_SPEED_5000:
129                 hw->bus.speed = fm10k_bus_speed_5000;
130                 break;
131         case FM10K_PCIE_LINK_SPEED_8000:
132                 hw->bus.speed = fm10k_bus_speed_8000;
133                 break;
134         default:
135                 hw->bus.speed = fm10k_bus_speed_unknown;
136                 break;
137         }
138
139         /* Get the negotiated PCIe maximum payload size for the PCIe function */
140         device_control = FM10K_READ_PCI_WORD(hw, FM10K_PCIE_DEV_CTRL);
141
142         switch (device_control & FM10K_PCIE_DEV_CTRL_PAYLOAD) {
143         case FM10K_PCIE_DEV_CTRL_PAYLOAD_128:
144                 hw->bus.payload = fm10k_bus_payload_128;
145                 break;
146         case FM10K_PCIE_DEV_CTRL_PAYLOAD_256:
147                 hw->bus.payload = fm10k_bus_payload_256;
148                 break;
149         case FM10K_PCIE_DEV_CTRL_PAYLOAD_512:
150                 hw->bus.payload = fm10k_bus_payload_512;
151                 break;
152         default:
153                 hw->bus.payload = fm10k_bus_payload_unknown;
154                 break;
155         }
156
157         return FM10K_SUCCESS;
158 }
159
160 u16 fm10k_get_pcie_msix_count_generic(struct fm10k_hw *hw)
161 {
162         u16 msix_count;
163
164         DEBUGFUNC("fm10k_get_pcie_msix_count_generic");
165
166         /* read in value from MSI-X capability register */
167         msix_count = FM10K_READ_PCI_WORD(hw, FM10K_PCI_MSIX_MSG_CTRL);
168         msix_count &= FM10K_PCI_MSIX_MSG_CTRL_TBL_SZ_MASK;
169
170         /* MSI-X count is zero-based in HW */
171         msix_count++;
172
173         if (msix_count > FM10K_MAX_MSIX_VECTORS)
174                 msix_count = FM10K_MAX_MSIX_VECTORS;
175
176         return msix_count;
177 }
178
179 /**
180  *  fm10k_init_ops_generic - Inits function ptrs
181  *  @hw: pointer to the hardware structure
182  *
183  *  Initialize the function pointers.
184  **/
185 s32 fm10k_init_ops_generic(struct fm10k_hw *hw)
186 {
187         struct fm10k_mac_info *mac = &hw->mac;
188
189         DEBUGFUNC("fm10k_init_ops_generic");
190
191         /* MAC */
192         mac->ops.get_bus_info = &fm10k_get_bus_info_generic;
193
194         /* initialize GLORT state to avoid any false hits */
195         mac->dglort_map = FM10K_DGLORTMAP_NONE;
196
197         return FM10K_SUCCESS;
198 }
199
200 /**
201  *  fm10k_start_hw_generic - Prepare hardware for Tx/Rx
202  *  @hw: pointer to hardware structure
203  *
204  *  This function sets the Tx ready flag to indicate that the Tx path has
205  *  been initialized.
206  **/
207 s32 fm10k_start_hw_generic(struct fm10k_hw *hw)
208 {
209         DEBUGFUNC("fm10k_start_hw_generic");
210
211         /* set flag indicating we are beginning Tx */
212         hw->mac.tx_ready = true;
213
214         return FM10K_SUCCESS;
215 }
216
217 /**
218  *  fm10k_disable_queues_generic - Stop Tx/Rx queues
219  *  @hw: pointer to hardware structure
220  *  @q_cnt: number of queues to be disabled
221  *
222  **/
223 s32 fm10k_disable_queues_generic(struct fm10k_hw *hw, u16 q_cnt)
224 {
225         u32 reg;
226         u16 i, time;
227
228         DEBUGFUNC("fm10k_disable_queues_generic");
229
230         /* clear tx_ready to prevent any false hits for reset */
231         hw->mac.tx_ready = false;
232
233         /* clear the enable bit for all rings */
234         for (i = 0; i < q_cnt; i++) {
235                 reg = FM10K_READ_REG(hw, FM10K_TXDCTL(i));
236                 FM10K_WRITE_REG(hw, FM10K_TXDCTL(i),
237                                 reg & ~FM10K_TXDCTL_ENABLE);
238                 reg = FM10K_READ_REG(hw, FM10K_RXQCTL(i));
239                 FM10K_WRITE_REG(hw, FM10K_RXQCTL(i),
240                                 reg & ~FM10K_RXQCTL_ENABLE);
241         }
242
243         FM10K_WRITE_FLUSH(hw);
244         usec_delay(1);
245
246         /* loop through all queues to verify that they are all disabled */
247         for (i = 0, time = FM10K_QUEUE_DISABLE_TIMEOUT; time;) {
248                 /* if we are at end of rings all rings are disabled */
249                 if (i == q_cnt)
250                         return FM10K_SUCCESS;
251
252                 /* if queue enables cleared, then move to next ring pair */
253                 reg = FM10K_READ_REG(hw, FM10K_TXDCTL(i));
254                 if (!~reg || !(reg & FM10K_TXDCTL_ENABLE)) {
255                         reg = FM10K_READ_REG(hw, FM10K_RXQCTL(i));
256                         if (!~reg || !(reg & FM10K_RXQCTL_ENABLE)) {
257                                 i++;
258                                 continue;
259                         }
260                 }
261
262                 /* decrement time and wait 1 usec */
263                 time--;
264                 if (time)
265                         usec_delay(1);
266         }
267
268         return FM10K_ERR_REQUESTS_PENDING;
269 }
270
271 /**
272  *  fm10k_stop_hw_generic - Stop Tx/Rx units
273  *  @hw: pointer to hardware structure
274  *
275  **/
276 s32 fm10k_stop_hw_generic(struct fm10k_hw *hw)
277 {
278         DEBUGFUNC("fm10k_stop_hw_generic");
279
280         return fm10k_disable_queues_generic(hw, hw->mac.max_queues);
281 }
282
283 /**
284  *  fm10k_read_hw_stats_32b - Reads value of 32-bit registers
285  *  @hw: pointer to the hardware structure
286  *  @addr: address of register containing a 32-bit value
287  *
288  *  Function reads the content of the register and returns the delta
289  *  between the base and the current value.
290  *  **/
291 u32 fm10k_read_hw_stats_32b(struct fm10k_hw *hw, u32 addr,
292                             struct fm10k_hw_stat *stat)
293 {
294         u32 delta = FM10K_READ_REG(hw, addr) - stat->base_l;
295
296         DEBUGFUNC("fm10k_read_hw_stats_32b");
297
298         if (FM10K_REMOVED(hw->hw_addr))
299                 stat->base_h = 0;
300
301         return delta;
302 }
303
304 /**
305  *  fm10k_read_hw_stats_48b - Reads value of 48-bit registers
306  *  @hw: pointer to the hardware structure
307  *  @addr: address of register containing the lower 32-bit value
308  *
309  *  Function reads the content of 2 registers, combined to represent a 48-bit
310  *  statistical value. Extra processing is required to handle overflowing.
311  *  Finally, a delta value is returned representing the difference between the
312  *  values stored in registers and values stored in the statistic counters.
313  *  **/
314 STATIC u64 fm10k_read_hw_stats_48b(struct fm10k_hw *hw, u32 addr,
315                                    struct fm10k_hw_stat *stat)
316 {
317         u32 count_l;
318         u32 count_h;
319         u32 count_tmp;
320         u64 delta;
321
322         DEBUGFUNC("fm10k_read_hw_stats_48b");
323
324         count_h = FM10K_READ_REG(hw, addr + 1);
325
326         /* Check for overflow */
327         do {
328                 count_tmp = count_h;
329                 count_l = FM10K_READ_REG(hw, addr);
330                 count_h = FM10K_READ_REG(hw, addr + 1);
331         } while (count_h != count_tmp);
332
333         delta = ((u64)(count_h - stat->base_h) << 32) + count_l;
334         delta -= stat->base_l;
335
336         return delta & FM10K_48_BIT_MASK;
337 }
338
339 /**
340  *  fm10k_update_hw_base_48b - Updates 48-bit statistic base value
341  *  @stat: pointer to the hardware statistic structure
342  *  @delta: value to be updated into the hardware statistic structure
343  *
344  *  Function receives a value and determines if an update is required based on
345  *  a delta calculation. Only the base value will be updated.
346  **/
347 STATIC void fm10k_update_hw_base_48b(struct fm10k_hw_stat *stat, u64 delta)
348 {
349         DEBUGFUNC("fm10k_update_hw_base_48b");
350
351         if (!delta)
352                 return;
353
354         /* update lower 32 bits */
355         delta += stat->base_l;
356         stat->base_l = (u32)delta;
357
358         /* update upper 32 bits */
359         stat->base_h += (u32)(delta >> 32);
360 }
361
362 /**
363  *  fm10k_update_hw_stats_tx_q - Updates TX queue statistics counters
364  *  @hw: pointer to the hardware structure
365  *  @q: pointer to the ring of hardware statistics queue
366  *  @idx: index pointing to the start of the ring iteration
367  *
368  *  Function updates the TX queue statistics counters that are related to the
369  *  hardware.
370  **/
371 STATIC void fm10k_update_hw_stats_tx_q(struct fm10k_hw *hw,
372                                        struct fm10k_hw_stats_q *q,
373                                        u32 idx)
374 {
375         u32 id_tx, id_tx_prev, tx_packets;
376         u64 tx_bytes = 0;
377
378         DEBUGFUNC("fm10k_update_hw_stats_tx_q");
379
380         /* Retrieve TX Owner Data */
381         id_tx = FM10K_READ_REG(hw, FM10K_TXQCTL(idx));
382
383         /* Process TX Ring */
384         do {
385                 tx_packets = fm10k_read_hw_stats_32b(hw, FM10K_QPTC(idx),
386                                                      &q->tx_packets);
387
388                 if (tx_packets)
389                         tx_bytes = fm10k_read_hw_stats_48b(hw,
390                                                            FM10K_QBTC_L(idx),
391                                                            &q->tx_bytes);
392
393                 /* Re-Check Owner Data */
394                 id_tx_prev = id_tx;
395                 id_tx = FM10K_READ_REG(hw, FM10K_TXQCTL(idx));
396         } while ((id_tx ^ id_tx_prev) & FM10K_TXQCTL_ID_MASK);
397
398         /* drop non-ID bits and set VALID ID bit */
399         id_tx &= FM10K_TXQCTL_ID_MASK;
400         id_tx |= FM10K_STAT_VALID;
401
402         /* update packet counts */
403         if (q->tx_stats_idx == id_tx) {
404                 q->tx_packets.count += tx_packets;
405                 q->tx_bytes.count += tx_bytes;
406         }
407
408         /* update bases and record ID */
409         fm10k_update_hw_base_32b(&q->tx_packets, tx_packets);
410         fm10k_update_hw_base_48b(&q->tx_bytes, tx_bytes);
411
412         q->tx_stats_idx = id_tx;
413 }
414
415 /**
416  *  fm10k_update_hw_stats_rx_q - Updates RX queue statistics counters
417  *  @hw: pointer to the hardware structure
418  *  @q: pointer to the ring of hardware statistics queue
419  *  @idx: index pointing to the start of the ring iteration
420  *
421  *  Function updates the RX queue statistics counters that are related to the
422  *  hardware.
423  **/
424 STATIC void fm10k_update_hw_stats_rx_q(struct fm10k_hw *hw,
425                                        struct fm10k_hw_stats_q *q,
426                                        u32 idx)
427 {
428         u32 id_rx, id_rx_prev, rx_packets, rx_drops;
429         u64 rx_bytes = 0;
430
431         DEBUGFUNC("fm10k_update_hw_stats_rx_q");
432
433         /* Retrieve RX Owner Data */
434         id_rx = FM10K_READ_REG(hw, FM10K_RXQCTL(idx));
435
436         /* Process RX Ring */
437         do {
438                 rx_drops = fm10k_read_hw_stats_32b(hw, FM10K_QPRDC(idx),
439                                                    &q->rx_drops);
440
441                 rx_packets = fm10k_read_hw_stats_32b(hw, FM10K_QPRC(idx),
442                                                      &q->rx_packets);
443
444                 if (rx_packets)
445                         rx_bytes = fm10k_read_hw_stats_48b(hw,
446                                                            FM10K_QBRC_L(idx),
447                                                            &q->rx_bytes);
448
449                 /* Re-Check Owner Data */
450                 id_rx_prev = id_rx;
451                 id_rx = FM10K_READ_REG(hw, FM10K_RXQCTL(idx));
452         } while ((id_rx ^ id_rx_prev) & FM10K_RXQCTL_ID_MASK);
453
454         /* drop non-ID bits and set VALID ID bit */
455         id_rx &= FM10K_RXQCTL_ID_MASK;
456         id_rx |= FM10K_STAT_VALID;
457
458         /* update packet counts */
459         if (q->rx_stats_idx == id_rx) {
460                 q->rx_drops.count += rx_drops;
461                 q->rx_packets.count += rx_packets;
462                 q->rx_bytes.count += rx_bytes;
463         }
464
465         /* update bases and record ID */
466         fm10k_update_hw_base_32b(&q->rx_drops, rx_drops);
467         fm10k_update_hw_base_32b(&q->rx_packets, rx_packets);
468         fm10k_update_hw_base_48b(&q->rx_bytes, rx_bytes);
469
470         q->rx_stats_idx = id_rx;
471 }
472
473 /**
474  *  fm10k_update_hw_stats_q - Updates queue statistics counters
475  *  @hw: pointer to the hardware structure
476  *  @q: pointer to the ring of hardware statistics queue
477  *  @idx: index pointing to the start of the ring iteration
478  *  @count: number of queues to iterate over
479  *
480  *  Function updates the queue statistics counters that are related to the
481  *  hardware.
482  **/
483 void fm10k_update_hw_stats_q(struct fm10k_hw *hw, struct fm10k_hw_stats_q *q,
484                              u32 idx, u32 count)
485 {
486         u32 i;
487
488         DEBUGFUNC("fm10k_update_hw_stats_q");
489
490         for (i = 0; i < count; i++, idx++, q++) {
491                 fm10k_update_hw_stats_tx_q(hw, q, idx);
492                 fm10k_update_hw_stats_rx_q(hw, q, idx);
493         }
494 }
495
496 /**
497  *  fm10k_unbind_hw_stats_q - Unbind the queue counters from their queues
498  *  @hw: pointer to the hardware structure
499  *  @q: pointer to the ring of hardware statistics queue
500  *  @idx: index pointing to the start of the ring iteration
501  *  @count: number of queues to iterate over
502  *
503  *  Function invalidates the index values for the queues so any updates that
504  *  may have happened are ignored and the base for the queue stats is reset.
505  **/
506 void fm10k_unbind_hw_stats_q(struct fm10k_hw_stats_q *q, u32 idx, u32 count)
507 {
508         u32 i;
509
510         for (i = 0; i < count; i++, idx++, q++) {
511                 q->rx_stats_idx = 0;
512                 q->tx_stats_idx = 0;
513         }
514 }
515
516 /**
517  *  fm10k_get_host_state_generic - Returns the state of the host
518  *  @hw: pointer to hardware structure
519  *  @host_ready: pointer to boolean value that will record host state
520  *
521  *  This function will check the health of the mailbox and Tx queue 0
522  *  in order to determine if we should report that the link is up or not.
523  **/
524 s32 fm10k_get_host_state_generic(struct fm10k_hw *hw, bool *host_ready)
525 {
526         struct fm10k_mbx_info *mbx = &hw->mbx;
527         struct fm10k_mac_info *mac = &hw->mac;
528         s32 ret_val = FM10K_SUCCESS;
529         u32 txdctl = FM10K_READ_REG(hw, FM10K_TXDCTL(0));
530
531         DEBUGFUNC("fm10k_get_host_state_generic");
532
533         /* process upstream mailbox in case interrupts were disabled */
534         mbx->ops.process(hw, mbx);
535
536         /* If Tx is no longer enabled link should come down */
537         if (!(~txdctl) || !(txdctl & FM10K_TXDCTL_ENABLE))
538                 mac->get_host_state = true;
539
540         /* exit if not checking for link, or link cannot be changed */
541         if (!mac->get_host_state || !(~txdctl))
542                 goto out;
543
544         /* if we somehow dropped the Tx enable we should reset */
545         if (hw->mac.tx_ready && !(txdctl & FM10K_TXDCTL_ENABLE)) {
546                 ret_val = FM10K_ERR_RESET_REQUESTED;
547                 goto out;
548         }
549
550         /* if Mailbox timed out we should request reset */
551         if (!mbx->timeout) {
552                 ret_val = FM10K_ERR_RESET_REQUESTED;
553                 goto out;
554         }
555
556         /* verify Mailbox is still valid */
557         if (!mbx->ops.tx_ready(mbx, FM10K_VFMBX_MSG_MTU))
558                 goto out;
559
560         /* interface cannot receive traffic without logical ports */
561         if (mac->dglort_map == FM10K_DGLORTMAP_NONE)
562                 goto out;
563
564         /* if we passed all the tests above then the switch is ready and we no
565          * longer need to check for link
566          */
567         mac->get_host_state = false;
568
569 out:
570         *host_ready = !mac->get_host_state;
571         return ret_val;
572 }