Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 845f876d0819e2b941b1dbe92e0d219df8010035 / . / drivers / staging / rdma / hfi1 / chip.c
blob: 81b48d600cf82049220b9c2c98210a31cbc1f48d [file] [log] [blame]
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1/*
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
8 * Copyright(c) 2015 Intel Corporation.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * BSD LICENSE
20 *
21 * Copyright(c) 2015 Intel Corporation.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 *
27 * - Redistributions of source code must retain the above copyright
28 * notice, this list of conditions and the following disclaimer.
29 * - Redistributions in binary form must reproduce the above copyright
30 * notice, this list of conditions and the following disclaimer in
31 * the documentation and/or other materials provided with the
32 * distribution.
33 * - Neither the name of Intel Corporation nor the names of its
34 * contributors may be used to endorse or promote products derived
35 * from this software without specific prior written permission.
36 *
37 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
38 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
39 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
40 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
41 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
44 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
45 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
46 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
47 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48 *
49 */
50
51/*
52 * This file contains all of the code that is specific to the HFI chip
53 */
54
55#include <linux/pci.h>
56#include <linux/delay.h>
57#include <linux/interrupt.h>
58#include <linux/module.h>
59
60#include "hfi.h"
61#include "trace.h"
62#include "mad.h"
63#include "pio.h"
64#include "sdma.h"
65#include "eprom.h"
Dean Luick5d9157a2015-11-16 21:59:34 -0500[diff] [blame]66#include "efivar.h"
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]67#include "platform.h"
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]68
69#define NUM_IB_PORTS 1
70
71uint kdeth_qp;
72module_param_named(kdeth_qp, kdeth_qp, uint, S_IRUGO);
73MODULE_PARM_DESC(kdeth_qp, "Set the KDETH queue pair prefix");
74
75uint num_vls = HFI1_MAX_VLS_SUPPORTED;
76module_param(num_vls, uint, S_IRUGO);
77MODULE_PARM_DESC(num_vls, "Set number of Virtual Lanes to use (1-8)");
78
79/*
80 * Default time to aggregate two 10K packets from the idle state
81 * (timer not running). The timer starts at the end of the first packet,
82 * so only the time for one 10K packet and header plus a bit extra is needed.
83 * 10 * 1024 + 64 header byte = 10304 byte
84 * 10304 byte / 12.5 GB/s = 824.32ns
85 */
86uint rcv_intr_timeout = (824 + 16); /* 16 is for coalescing interrupt */
87module_param(rcv_intr_timeout, uint, S_IRUGO);
88MODULE_PARM_DESC(rcv_intr_timeout, "Receive interrupt mitigation timeout in ns");
89
90uint rcv_intr_count = 16; /* same as qib */
91module_param(rcv_intr_count, uint, S_IRUGO);
92MODULE_PARM_DESC(rcv_intr_count, "Receive interrupt mitigation count");
93
94ushort link_crc_mask = SUPPORTED_CRCS;
95module_param(link_crc_mask, ushort, S_IRUGO);
96MODULE_PARM_DESC(link_crc_mask, "CRCs to use on the link");
97
98uint loopback;
99module_param_named(loopback, loopback, uint, S_IRUGO);
100MODULE_PARM_DESC(loopback, "Put into loopback mode (1 = serdes, 3 = external cable");
101
102/* Other driver tunables */
103uint rcv_intr_dynamic = 1; /* enable dynamic mode for rcv int mitigation*/
104static ushort crc_14b_sideband = 1;
105static uint use_flr = 1;
106uint quick_linkup; /* skip LNI */
107
108struct flag_table {
109 u64 flag; /* the flag */
110 char *str; /* description string */
111 u16 extra; /* extra information */
112 u16 unused0;
113 u32 unused1;
114};
115
116/* str must be a string constant */
117#define FLAG_ENTRY(str, extra, flag) {flag, str, extra}
118#define FLAG_ENTRY0(str, flag) {flag, str, 0}
119
120/* Send Error Consequences */
121#define SEC_WRITE_DROPPED 0x1
122#define SEC_PACKET_DROPPED 0x2
123#define SEC_SC_HALTED 0x4 /* per-context only */
124#define SEC_SPC_FREEZE 0x8 /* per-HFI only */
125
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]126#define MIN_KERNEL_KCTXTS 2
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]127#define FIRST_KERNEL_KCTXT 1
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]128#define NUM_MAP_REGS 32
129
130/* Bit offset into the GUID which carries HFI id information */
131#define GUID_HFI_INDEX_SHIFT 39
132
133/* extract the emulation revision */
134#define emulator_rev(dd) ((dd)->irev >> 8)
135/* parallel and serial emulation versions are 3 and 4 respectively */
136#define is_emulator_p(dd) ((((dd)->irev) & 0xf) == 3)
137#define is_emulator_s(dd) ((((dd)->irev) & 0xf) == 4)
138
139/* RSM fields */
140
141/* packet type */
142#define IB_PACKET_TYPE 2ull
143#define QW_SHIFT 6ull
144/* QPN[7..1] */
145#define QPN_WIDTH 7ull
146
147/* LRH.BTH: QW 0, OFFSET 48 - for match */
148#define LRH_BTH_QW 0ull
149#define LRH_BTH_BIT_OFFSET 48ull
150#define LRH_BTH_OFFSET(off) ((LRH_BTH_QW << QW_SHIFT) | (off))
151#define LRH_BTH_MATCH_OFFSET LRH_BTH_OFFSET(LRH_BTH_BIT_OFFSET)
152#define LRH_BTH_SELECT
153#define LRH_BTH_MASK 3ull
154#define LRH_BTH_VALUE 2ull
155
156/* LRH.SC[3..0] QW 0, OFFSET 56 - for match */
157#define LRH_SC_QW 0ull
158#define LRH_SC_BIT_OFFSET 56ull
159#define LRH_SC_OFFSET(off) ((LRH_SC_QW << QW_SHIFT) | (off))
160#define LRH_SC_MATCH_OFFSET LRH_SC_OFFSET(LRH_SC_BIT_OFFSET)
161#define LRH_SC_MASK 128ull
162#define LRH_SC_VALUE 0ull
163
164/* SC[n..0] QW 0, OFFSET 60 - for select */
165#define LRH_SC_SELECT_OFFSET ((LRH_SC_QW << QW_SHIFT) | (60ull))
166
167/* QPN[m+n:1] QW 1, OFFSET 1 */
168#define QPN_SELECT_OFFSET ((1ull << QW_SHIFT) | (1ull))
169
170/* defines to build power on SC2VL table */
171#define SC2VL_VAL( \
172 num, \
173 sc0, sc0val, \
174 sc1, sc1val, \
175 sc2, sc2val, \
176 sc3, sc3val, \
177 sc4, sc4val, \
178 sc5, sc5val, \
179 sc6, sc6val, \
180 sc7, sc7val) \
181( \
182 ((u64)(sc0val) << SEND_SC2VLT##num##_SC##sc0##_SHIFT) | \
183 ((u64)(sc1val) << SEND_SC2VLT##num##_SC##sc1##_SHIFT) | \
184 ((u64)(sc2val) << SEND_SC2VLT##num##_SC##sc2##_SHIFT) | \
185 ((u64)(sc3val) << SEND_SC2VLT##num##_SC##sc3##_SHIFT) | \
186 ((u64)(sc4val) << SEND_SC2VLT##num##_SC##sc4##_SHIFT) | \
187 ((u64)(sc5val) << SEND_SC2VLT##num##_SC##sc5##_SHIFT) | \
188 ((u64)(sc6val) << SEND_SC2VLT##num##_SC##sc6##_SHIFT) | \
189 ((u64)(sc7val) << SEND_SC2VLT##num##_SC##sc7##_SHIFT) \
190)
191
192#define DC_SC_VL_VAL( \
193 range, \
194 e0, e0val, \
195 e1, e1val, \
196 e2, e2val, \
197 e3, e3val, \
198 e4, e4val, \
199 e5, e5val, \
200 e6, e6val, \
201 e7, e7val, \
202 e8, e8val, \
203 e9, e9val, \
204 e10, e10val, \
205 e11, e11val, \
206 e12, e12val, \
207 e13, e13val, \
208 e14, e14val, \
209 e15, e15val) \
210( \
211 ((u64)(e0val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e0##_SHIFT) | \
212 ((u64)(e1val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e1##_SHIFT) | \
213 ((u64)(e2val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e2##_SHIFT) | \
214 ((u64)(e3val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e3##_SHIFT) | \
215 ((u64)(e4val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e4##_SHIFT) | \
216 ((u64)(e5val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e5##_SHIFT) | \
217 ((u64)(e6val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e6##_SHIFT) | \
218 ((u64)(e7val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e7##_SHIFT) | \
219 ((u64)(e8val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e8##_SHIFT) | \
220 ((u64)(e9val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e9##_SHIFT) | \
221 ((u64)(e10val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e10##_SHIFT) | \
222 ((u64)(e11val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e11##_SHIFT) | \
223 ((u64)(e12val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e12##_SHIFT) | \
224 ((u64)(e13val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e13##_SHIFT) | \
225 ((u64)(e14val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e14##_SHIFT) | \
226 ((u64)(e15val) << DCC_CFG_SC_VL_TABLE_##range##_ENTRY##e15##_SHIFT) \
227)
228
229/* all CceStatus sub-block freeze bits */
230#define ALL_FROZE (CCE_STATUS_SDMA_FROZE_SMASK \
231 | CCE_STATUS_RXE_FROZE_SMASK \
232 | CCE_STATUS_TXE_FROZE_SMASK \
233 | CCE_STATUS_TXE_PIO_FROZE_SMASK)
234/* all CceStatus sub-block TXE pause bits */
235#define ALL_TXE_PAUSE (CCE_STATUS_TXE_PIO_PAUSED_SMASK \
236 | CCE_STATUS_TXE_PAUSED_SMASK \
237 | CCE_STATUS_SDMA_PAUSED_SMASK)
238/* all CceStatus sub-block RXE pause bits */
239#define ALL_RXE_PAUSE CCE_STATUS_RXE_PAUSED_SMASK
240
241/*
242 * CCE Error flags.
243 */
244static struct flag_table cce_err_status_flags[] = {
245/* 0*/ FLAG_ENTRY0("CceCsrParityErr",
246 CCE_ERR_STATUS_CCE_CSR_PARITY_ERR_SMASK),
247/* 1*/ FLAG_ENTRY0("CceCsrReadBadAddrErr",
248 CCE_ERR_STATUS_CCE_CSR_READ_BAD_ADDR_ERR_SMASK),
249/* 2*/ FLAG_ENTRY0("CceCsrWriteBadAddrErr",
250 CCE_ERR_STATUS_CCE_CSR_WRITE_BAD_ADDR_ERR_SMASK),
251/* 3*/ FLAG_ENTRY0("CceTrgtAsyncFifoParityErr",
252 CCE_ERR_STATUS_CCE_TRGT_ASYNC_FIFO_PARITY_ERR_SMASK),
253/* 4*/ FLAG_ENTRY0("CceTrgtAccessErr",
254 CCE_ERR_STATUS_CCE_TRGT_ACCESS_ERR_SMASK),
255/* 5*/ FLAG_ENTRY0("CceRspdDataParityErr",
256 CCE_ERR_STATUS_CCE_RSPD_DATA_PARITY_ERR_SMASK),
257/* 6*/ FLAG_ENTRY0("CceCli0AsyncFifoParityErr",
258 CCE_ERR_STATUS_CCE_CLI0_ASYNC_FIFO_PARITY_ERR_SMASK),
259/* 7*/ FLAG_ENTRY0("CceCsrCfgBusParityErr",
260 CCE_ERR_STATUS_CCE_CSR_CFG_BUS_PARITY_ERR_SMASK),
261/* 8*/ FLAG_ENTRY0("CceCli2AsyncFifoParityErr",
262 CCE_ERR_STATUS_CCE_CLI2_ASYNC_FIFO_PARITY_ERR_SMASK),
263/* 9*/ FLAG_ENTRY0("CceCli1AsyncFifoPioCrdtParityErr",
264 CCE_ERR_STATUS_CCE_CLI1_ASYNC_FIFO_PIO_CRDT_PARITY_ERR_SMASK),
265/*10*/ FLAG_ENTRY0("CceCli1AsyncFifoPioCrdtParityErr",
266 CCE_ERR_STATUS_CCE_CLI1_ASYNC_FIFO_SDMA_HD_PARITY_ERR_SMASK),
267/*11*/ FLAG_ENTRY0("CceCli1AsyncFifoRxdmaParityError",
268 CCE_ERR_STATUS_CCE_CLI1_ASYNC_FIFO_RXDMA_PARITY_ERROR_SMASK),
269/*12*/ FLAG_ENTRY0("CceCli1AsyncFifoDbgParityError",
270 CCE_ERR_STATUS_CCE_CLI1_ASYNC_FIFO_DBG_PARITY_ERROR_SMASK),
271/*13*/ FLAG_ENTRY0("PcicRetryMemCorErr",
272 CCE_ERR_STATUS_PCIC_RETRY_MEM_COR_ERR_SMASK),
273/*14*/ FLAG_ENTRY0("PcicRetryMemCorErr",
274 CCE_ERR_STATUS_PCIC_RETRY_SOT_MEM_COR_ERR_SMASK),
275/*15*/ FLAG_ENTRY0("PcicPostHdQCorErr",
276 CCE_ERR_STATUS_PCIC_POST_HD_QCOR_ERR_SMASK),
277/*16*/ FLAG_ENTRY0("PcicPostHdQCorErr",
278 CCE_ERR_STATUS_PCIC_POST_DAT_QCOR_ERR_SMASK),
279/*17*/ FLAG_ENTRY0("PcicPostHdQCorErr",
280 CCE_ERR_STATUS_PCIC_CPL_HD_QCOR_ERR_SMASK),
281/*18*/ FLAG_ENTRY0("PcicCplDatQCorErr",
282 CCE_ERR_STATUS_PCIC_CPL_DAT_QCOR_ERR_SMASK),
283/*19*/ FLAG_ENTRY0("PcicNPostHQParityErr",
284 CCE_ERR_STATUS_PCIC_NPOST_HQ_PARITY_ERR_SMASK),
285/*20*/ FLAG_ENTRY0("PcicNPostDatQParityErr",
286 CCE_ERR_STATUS_PCIC_NPOST_DAT_QPARITY_ERR_SMASK),
287/*21*/ FLAG_ENTRY0("PcicRetryMemUncErr",
288 CCE_ERR_STATUS_PCIC_RETRY_MEM_UNC_ERR_SMASK),
289/*22*/ FLAG_ENTRY0("PcicRetrySotMemUncErr",
290 CCE_ERR_STATUS_PCIC_RETRY_SOT_MEM_UNC_ERR_SMASK),
291/*23*/ FLAG_ENTRY0("PcicPostHdQUncErr",
292 CCE_ERR_STATUS_PCIC_POST_HD_QUNC_ERR_SMASK),
293/*24*/ FLAG_ENTRY0("PcicPostDatQUncErr",
294 CCE_ERR_STATUS_PCIC_POST_DAT_QUNC_ERR_SMASK),
295/*25*/ FLAG_ENTRY0("PcicCplHdQUncErr",
296 CCE_ERR_STATUS_PCIC_CPL_HD_QUNC_ERR_SMASK),
297/*26*/ FLAG_ENTRY0("PcicCplDatQUncErr",
298 CCE_ERR_STATUS_PCIC_CPL_DAT_QUNC_ERR_SMASK),
299/*27*/ FLAG_ENTRY0("PcicTransmitFrontParityErr",
300 CCE_ERR_STATUS_PCIC_TRANSMIT_FRONT_PARITY_ERR_SMASK),
301/*28*/ FLAG_ENTRY0("PcicTransmitBackParityErr",
302 CCE_ERR_STATUS_PCIC_TRANSMIT_BACK_PARITY_ERR_SMASK),
303/*29*/ FLAG_ENTRY0("PcicReceiveParityErr",
304 CCE_ERR_STATUS_PCIC_RECEIVE_PARITY_ERR_SMASK),
305/*30*/ FLAG_ENTRY0("CceTrgtCplTimeoutErr",
306 CCE_ERR_STATUS_CCE_TRGT_CPL_TIMEOUT_ERR_SMASK),
307/*31*/ FLAG_ENTRY0("LATriggered",
308 CCE_ERR_STATUS_LA_TRIGGERED_SMASK),
309/*32*/ FLAG_ENTRY0("CceSegReadBadAddrErr",
310 CCE_ERR_STATUS_CCE_SEG_READ_BAD_ADDR_ERR_SMASK),
311/*33*/ FLAG_ENTRY0("CceSegWriteBadAddrErr",
312 CCE_ERR_STATUS_CCE_SEG_WRITE_BAD_ADDR_ERR_SMASK),
313/*34*/ FLAG_ENTRY0("CceRcplAsyncFifoParityErr",
314 CCE_ERR_STATUS_CCE_RCPL_ASYNC_FIFO_PARITY_ERR_SMASK),
315/*35*/ FLAG_ENTRY0("CceRxdmaConvFifoParityErr",
316 CCE_ERR_STATUS_CCE_RXDMA_CONV_FIFO_PARITY_ERR_SMASK),
317/*36*/ FLAG_ENTRY0("CceMsixTableCorErr",
318 CCE_ERR_STATUS_CCE_MSIX_TABLE_COR_ERR_SMASK),
319/*37*/ FLAG_ENTRY0("CceMsixTableUncErr",
320 CCE_ERR_STATUS_CCE_MSIX_TABLE_UNC_ERR_SMASK),
321/*38*/ FLAG_ENTRY0("CceIntMapCorErr",
322 CCE_ERR_STATUS_CCE_INT_MAP_COR_ERR_SMASK),
323/*39*/ FLAG_ENTRY0("CceIntMapUncErr",
324 CCE_ERR_STATUS_CCE_INT_MAP_UNC_ERR_SMASK),
325/*40*/ FLAG_ENTRY0("CceMsixCsrParityErr",
326 CCE_ERR_STATUS_CCE_MSIX_CSR_PARITY_ERR_SMASK),
327/*41-63 reserved*/
328};
329
330/*
331 * Misc Error flags
332 */
333#define MES(text) MISC_ERR_STATUS_MISC_##text##_ERR_SMASK
334static struct flag_table misc_err_status_flags[] = {
335/* 0*/ FLAG_ENTRY0("CSR_PARITY", MES(CSR_PARITY)),
336/* 1*/ FLAG_ENTRY0("CSR_READ_BAD_ADDR", MES(CSR_READ_BAD_ADDR)),
337/* 2*/ FLAG_ENTRY0("CSR_WRITE_BAD_ADDR", MES(CSR_WRITE_BAD_ADDR)),
338/* 3*/ FLAG_ENTRY0("SBUS_WRITE_FAILED", MES(SBUS_WRITE_FAILED)),
339/* 4*/ FLAG_ENTRY0("KEY_MISMATCH", MES(KEY_MISMATCH)),
340/* 5*/ FLAG_ENTRY0("FW_AUTH_FAILED", MES(FW_AUTH_FAILED)),
341/* 6*/ FLAG_ENTRY0("EFUSE_CSR_PARITY", MES(EFUSE_CSR_PARITY)),
342/* 7*/ FLAG_ENTRY0("EFUSE_READ_BAD_ADDR", MES(EFUSE_READ_BAD_ADDR)),
343/* 8*/ FLAG_ENTRY0("EFUSE_WRITE", MES(EFUSE_WRITE)),
344/* 9*/ FLAG_ENTRY0("EFUSE_DONE_PARITY", MES(EFUSE_DONE_PARITY)),
345/*10*/ FLAG_ENTRY0("INVALID_EEP_CMD", MES(INVALID_EEP_CMD)),
346/*11*/ FLAG_ENTRY0("MBIST_FAIL", MES(MBIST_FAIL)),
347/*12*/ FLAG_ENTRY0("PLL_LOCK_FAIL", MES(PLL_LOCK_FAIL))
348};
349
350/*
351 * TXE PIO Error flags and consequences
352 */
353static struct flag_table pio_err_status_flags[] = {
354/* 0*/ FLAG_ENTRY("PioWriteBadCtxt",
355 SEC_WRITE_DROPPED,
356 SEND_PIO_ERR_STATUS_PIO_WRITE_BAD_CTXT_ERR_SMASK),
357/* 1*/ FLAG_ENTRY("PioWriteAddrParity",
358 SEC_SPC_FREEZE,
359 SEND_PIO_ERR_STATUS_PIO_WRITE_ADDR_PARITY_ERR_SMASK),
360/* 2*/ FLAG_ENTRY("PioCsrParity",
361 SEC_SPC_FREEZE,
362 SEND_PIO_ERR_STATUS_PIO_CSR_PARITY_ERR_SMASK),
363/* 3*/ FLAG_ENTRY("PioSbMemFifo0",
364 SEC_SPC_FREEZE,
365 SEND_PIO_ERR_STATUS_PIO_SB_MEM_FIFO0_ERR_SMASK),
366/* 4*/ FLAG_ENTRY("PioSbMemFifo1",
367 SEC_SPC_FREEZE,
368 SEND_PIO_ERR_STATUS_PIO_SB_MEM_FIFO1_ERR_SMASK),
369/* 5*/ FLAG_ENTRY("PioPccFifoParity",
370 SEC_SPC_FREEZE,
371 SEND_PIO_ERR_STATUS_PIO_PCC_FIFO_PARITY_ERR_SMASK),
372/* 6*/ FLAG_ENTRY("PioPecFifoParity",
373 SEC_SPC_FREEZE,
374 SEND_PIO_ERR_STATUS_PIO_PEC_FIFO_PARITY_ERR_SMASK),
375/* 7*/ FLAG_ENTRY("PioSbrdctlCrrelParity",
376 SEC_SPC_FREEZE,
377 SEND_PIO_ERR_STATUS_PIO_SBRDCTL_CRREL_PARITY_ERR_SMASK),
378/* 8*/ FLAG_ENTRY("PioSbrdctrlCrrelFifoParity",
379 SEC_SPC_FREEZE,
380 SEND_PIO_ERR_STATUS_PIO_SBRDCTRL_CRREL_FIFO_PARITY_ERR_SMASK),
381/* 9*/ FLAG_ENTRY("PioPktEvictFifoParityErr",
382 SEC_SPC_FREEZE,
383 SEND_PIO_ERR_STATUS_PIO_PKT_EVICT_FIFO_PARITY_ERR_SMASK),
384/*10*/ FLAG_ENTRY("PioSmPktResetParity",
385 SEC_SPC_FREEZE,
386 SEND_PIO_ERR_STATUS_PIO_SM_PKT_RESET_PARITY_ERR_SMASK),
387/*11*/ FLAG_ENTRY("PioVlLenMemBank0Unc",
388 SEC_SPC_FREEZE,
389 SEND_PIO_ERR_STATUS_PIO_VL_LEN_MEM_BANK0_UNC_ERR_SMASK),
390/*12*/ FLAG_ENTRY("PioVlLenMemBank1Unc",
391 SEC_SPC_FREEZE,
392 SEND_PIO_ERR_STATUS_PIO_VL_LEN_MEM_BANK1_UNC_ERR_SMASK),
393/*13*/ FLAG_ENTRY("PioVlLenMemBank0Cor",
394 0,
395 SEND_PIO_ERR_STATUS_PIO_VL_LEN_MEM_BANK0_COR_ERR_SMASK),
396/*14*/ FLAG_ENTRY("PioVlLenMemBank1Cor",
397 0,
398 SEND_PIO_ERR_STATUS_PIO_VL_LEN_MEM_BANK1_COR_ERR_SMASK),
399/*15*/ FLAG_ENTRY("PioCreditRetFifoParity",
400 SEC_SPC_FREEZE,
401 SEND_PIO_ERR_STATUS_PIO_CREDIT_RET_FIFO_PARITY_ERR_SMASK),
402/*16*/ FLAG_ENTRY("PioPpmcPblFifo",
403 SEC_SPC_FREEZE,
404 SEND_PIO_ERR_STATUS_PIO_PPMC_PBL_FIFO_ERR_SMASK),
405/*17*/ FLAG_ENTRY("PioInitSmIn",
406 0,
407 SEND_PIO_ERR_STATUS_PIO_INIT_SM_IN_ERR_SMASK),
408/*18*/ FLAG_ENTRY("PioPktEvictSmOrArbSm",
409 SEC_SPC_FREEZE,
410 SEND_PIO_ERR_STATUS_PIO_PKT_EVICT_SM_OR_ARB_SM_ERR_SMASK),
411/*19*/ FLAG_ENTRY("PioHostAddrMemUnc",
412 SEC_SPC_FREEZE,
413 SEND_PIO_ERR_STATUS_PIO_HOST_ADDR_MEM_UNC_ERR_SMASK),
414/*20*/ FLAG_ENTRY("PioHostAddrMemCor",
415 0,
416 SEND_PIO_ERR_STATUS_PIO_HOST_ADDR_MEM_COR_ERR_SMASK),
417/*21*/ FLAG_ENTRY("PioWriteDataParity",
418 SEC_SPC_FREEZE,
419 SEND_PIO_ERR_STATUS_PIO_WRITE_DATA_PARITY_ERR_SMASK),
420/*22*/ FLAG_ENTRY("PioStateMachine",
421 SEC_SPC_FREEZE,
422 SEND_PIO_ERR_STATUS_PIO_STATE_MACHINE_ERR_SMASK),
423/*23*/ FLAG_ENTRY("PioWriteQwValidParity",
424 SEC_WRITE_DROPPED|SEC_SPC_FREEZE,
425 SEND_PIO_ERR_STATUS_PIO_WRITE_QW_VALID_PARITY_ERR_SMASK),
426/*24*/ FLAG_ENTRY("PioBlockQwCountParity",
427 SEC_WRITE_DROPPED|SEC_SPC_FREEZE,
428 SEND_PIO_ERR_STATUS_PIO_BLOCK_QW_COUNT_PARITY_ERR_SMASK),
429/*25*/ FLAG_ENTRY("PioVlfVlLenParity",
430 SEC_SPC_FREEZE,
431 SEND_PIO_ERR_STATUS_PIO_VLF_VL_LEN_PARITY_ERR_SMASK),
432/*26*/ FLAG_ENTRY("PioVlfSopParity",
433 SEC_SPC_FREEZE,
434 SEND_PIO_ERR_STATUS_PIO_VLF_SOP_PARITY_ERR_SMASK),
435/*27*/ FLAG_ENTRY("PioVlFifoParity",
436 SEC_SPC_FREEZE,
437 SEND_PIO_ERR_STATUS_PIO_VL_FIFO_PARITY_ERR_SMASK),
438/*28*/ FLAG_ENTRY("PioPpmcBqcMemParity",
439 SEC_SPC_FREEZE,
440 SEND_PIO_ERR_STATUS_PIO_PPMC_BQC_MEM_PARITY_ERR_SMASK),
441/*29*/ FLAG_ENTRY("PioPpmcSopLen",
442 SEC_SPC_FREEZE,
443 SEND_PIO_ERR_STATUS_PIO_PPMC_SOP_LEN_ERR_SMASK),
444/*30-31 reserved*/
445/*32*/ FLAG_ENTRY("PioCurrentFreeCntParity",
446 SEC_SPC_FREEZE,
447 SEND_PIO_ERR_STATUS_PIO_CURRENT_FREE_CNT_PARITY_ERR_SMASK),
448/*33*/ FLAG_ENTRY("PioLastReturnedCntParity",
449 SEC_SPC_FREEZE,
450 SEND_PIO_ERR_STATUS_PIO_LAST_RETURNED_CNT_PARITY_ERR_SMASK),
451/*34*/ FLAG_ENTRY("PioPccSopHeadParity",
452 SEC_SPC_FREEZE,
453 SEND_PIO_ERR_STATUS_PIO_PCC_SOP_HEAD_PARITY_ERR_SMASK),
454/*35*/ FLAG_ENTRY("PioPecSopHeadParityErr",
455 SEC_SPC_FREEZE,
456 SEND_PIO_ERR_STATUS_PIO_PEC_SOP_HEAD_PARITY_ERR_SMASK),
457/*36-63 reserved*/
458};
459
460/* TXE PIO errors that cause an SPC freeze */
461#define ALL_PIO_FREEZE_ERR \
462 (SEND_PIO_ERR_STATUS_PIO_WRITE_ADDR_PARITY_ERR_SMASK \
463 | SEND_PIO_ERR_STATUS_PIO_CSR_PARITY_ERR_SMASK \
464 | SEND_PIO_ERR_STATUS_PIO_SB_MEM_FIFO0_ERR_SMASK \
465 | SEND_PIO_ERR_STATUS_PIO_SB_MEM_FIFO1_ERR_SMASK \
466 | SEND_PIO_ERR_STATUS_PIO_PCC_FIFO_PARITY_ERR_SMASK \
467 | SEND_PIO_ERR_STATUS_PIO_PEC_FIFO_PARITY_ERR_SMASK \
468 | SEND_PIO_ERR_STATUS_PIO_SBRDCTL_CRREL_PARITY_ERR_SMASK \
469 | SEND_PIO_ERR_STATUS_PIO_SBRDCTRL_CRREL_FIFO_PARITY_ERR_SMASK \
470 | SEND_PIO_ERR_STATUS_PIO_PKT_EVICT_FIFO_PARITY_ERR_SMASK \
471 | SEND_PIO_ERR_STATUS_PIO_SM_PKT_RESET_PARITY_ERR_SMASK \
472 | SEND_PIO_ERR_STATUS_PIO_VL_LEN_MEM_BANK0_UNC_ERR_SMASK \
473 | SEND_PIO_ERR_STATUS_PIO_VL_LEN_MEM_BANK1_UNC_ERR_SMASK \
474 | SEND_PIO_ERR_STATUS_PIO_CREDIT_RET_FIFO_PARITY_ERR_SMASK \
475 | SEND_PIO_ERR_STATUS_PIO_PPMC_PBL_FIFO_ERR_SMASK \
476 | SEND_PIO_ERR_STATUS_PIO_PKT_EVICT_SM_OR_ARB_SM_ERR_SMASK \
477 | SEND_PIO_ERR_STATUS_PIO_HOST_ADDR_MEM_UNC_ERR_SMASK \
478 | SEND_PIO_ERR_STATUS_PIO_WRITE_DATA_PARITY_ERR_SMASK \
479 | SEND_PIO_ERR_STATUS_PIO_STATE_MACHINE_ERR_SMASK \
480 | SEND_PIO_ERR_STATUS_PIO_WRITE_QW_VALID_PARITY_ERR_SMASK \
481 | SEND_PIO_ERR_STATUS_PIO_BLOCK_QW_COUNT_PARITY_ERR_SMASK \
482 | SEND_PIO_ERR_STATUS_PIO_VLF_VL_LEN_PARITY_ERR_SMASK \
483 | SEND_PIO_ERR_STATUS_PIO_VLF_SOP_PARITY_ERR_SMASK \
484 | SEND_PIO_ERR_STATUS_PIO_VL_FIFO_PARITY_ERR_SMASK \
485 | SEND_PIO_ERR_STATUS_PIO_PPMC_BQC_MEM_PARITY_ERR_SMASK \
486 | SEND_PIO_ERR_STATUS_PIO_PPMC_SOP_LEN_ERR_SMASK \
487 | SEND_PIO_ERR_STATUS_PIO_CURRENT_FREE_CNT_PARITY_ERR_SMASK \
488 | SEND_PIO_ERR_STATUS_PIO_LAST_RETURNED_CNT_PARITY_ERR_SMASK \
489 | SEND_PIO_ERR_STATUS_PIO_PCC_SOP_HEAD_PARITY_ERR_SMASK \
490 | SEND_PIO_ERR_STATUS_PIO_PEC_SOP_HEAD_PARITY_ERR_SMASK)
491
492/*
493 * TXE SDMA Error flags
494 */
495static struct flag_table sdma_err_status_flags[] = {
496/* 0*/ FLAG_ENTRY0("SDmaRpyTagErr",
497 SEND_DMA_ERR_STATUS_SDMA_RPY_TAG_ERR_SMASK),
498/* 1*/ FLAG_ENTRY0("SDmaCsrParityErr",
499 SEND_DMA_ERR_STATUS_SDMA_CSR_PARITY_ERR_SMASK),
500/* 2*/ FLAG_ENTRY0("SDmaPcieReqTrackingUncErr",
501 SEND_DMA_ERR_STATUS_SDMA_PCIE_REQ_TRACKING_UNC_ERR_SMASK),
502/* 3*/ FLAG_ENTRY0("SDmaPcieReqTrackingCorErr",
503 SEND_DMA_ERR_STATUS_SDMA_PCIE_REQ_TRACKING_COR_ERR_SMASK),
504/*04-63 reserved*/
505};
506
507/* TXE SDMA errors that cause an SPC freeze */
508#define ALL_SDMA_FREEZE_ERR \
509 (SEND_DMA_ERR_STATUS_SDMA_RPY_TAG_ERR_SMASK \
510 | SEND_DMA_ERR_STATUS_SDMA_CSR_PARITY_ERR_SMASK \
511 | SEND_DMA_ERR_STATUS_SDMA_PCIE_REQ_TRACKING_UNC_ERR_SMASK)
512
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]513/* SendEgressErrInfo bits that correspond to a PortXmitDiscard counter */
514#define PORT_DISCARD_EGRESS_ERRS \
515 (SEND_EGRESS_ERR_INFO_TOO_LONG_IB_PACKET_ERR_SMASK \
516 | SEND_EGRESS_ERR_INFO_VL_MAPPING_ERR_SMASK \
517 | SEND_EGRESS_ERR_INFO_VL_ERR_SMASK)
518
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]519/*
520 * TXE Egress Error flags
521 */
522#define SEES(text) SEND_EGRESS_ERR_STATUS_##text##_ERR_SMASK
523static struct flag_table egress_err_status_flags[] = {
524/* 0*/ FLAG_ENTRY0("TxPktIntegrityMemCorErr", SEES(TX_PKT_INTEGRITY_MEM_COR)),
525/* 1*/ FLAG_ENTRY0("TxPktIntegrityMemUncErr", SEES(TX_PKT_INTEGRITY_MEM_UNC)),
526/* 2 reserved */
527/* 3*/ FLAG_ENTRY0("TxEgressFifoUnderrunOrParityErr",
528 SEES(TX_EGRESS_FIFO_UNDERRUN_OR_PARITY)),
529/* 4*/ FLAG_ENTRY0("TxLinkdownErr", SEES(TX_LINKDOWN)),
530/* 5*/ FLAG_ENTRY0("TxIncorrectLinkStateErr", SEES(TX_INCORRECT_LINK_STATE)),
531/* 6 reserved */
532/* 7*/ FLAG_ENTRY0("TxPioLaunchIntfParityErr",
533 SEES(TX_PIO_LAUNCH_INTF_PARITY)),
534/* 8*/ FLAG_ENTRY0("TxSdmaLaunchIntfParityErr",
535 SEES(TX_SDMA_LAUNCH_INTF_PARITY)),
536/* 9-10 reserved */
537/*11*/ FLAG_ENTRY0("TxSbrdCtlStateMachineParityErr",
538 SEES(TX_SBRD_CTL_STATE_MACHINE_PARITY)),
539/*12*/ FLAG_ENTRY0("TxIllegalVLErr", SEES(TX_ILLEGAL_VL)),
540/*13*/ FLAG_ENTRY0("TxLaunchCsrParityErr", SEES(TX_LAUNCH_CSR_PARITY)),
541/*14*/ FLAG_ENTRY0("TxSbrdCtlCsrParityErr", SEES(TX_SBRD_CTL_CSR_PARITY)),
542/*15*/ FLAG_ENTRY0("TxConfigParityErr", SEES(TX_CONFIG_PARITY)),
543/*16*/ FLAG_ENTRY0("TxSdma0DisallowedPacketErr",
544 SEES(TX_SDMA0_DISALLOWED_PACKET)),
545/*17*/ FLAG_ENTRY0("TxSdma1DisallowedPacketErr",
546 SEES(TX_SDMA1_DISALLOWED_PACKET)),
547/*18*/ FLAG_ENTRY0("TxSdma2DisallowedPacketErr",
548 SEES(TX_SDMA2_DISALLOWED_PACKET)),
549/*19*/ FLAG_ENTRY0("TxSdma3DisallowedPacketErr",
550 SEES(TX_SDMA3_DISALLOWED_PACKET)),
551/*20*/ FLAG_ENTRY0("TxSdma4DisallowedPacketErr",
552 SEES(TX_SDMA4_DISALLOWED_PACKET)),
553/*21*/ FLAG_ENTRY0("TxSdma5DisallowedPacketErr",
554 SEES(TX_SDMA5_DISALLOWED_PACKET)),
555/*22*/ FLAG_ENTRY0("TxSdma6DisallowedPacketErr",
556 SEES(TX_SDMA6_DISALLOWED_PACKET)),
557/*23*/ FLAG_ENTRY0("TxSdma7DisallowedPacketErr",
558 SEES(TX_SDMA7_DISALLOWED_PACKET)),
559/*24*/ FLAG_ENTRY0("TxSdma8DisallowedPacketErr",
560 SEES(TX_SDMA8_DISALLOWED_PACKET)),
561/*25*/ FLAG_ENTRY0("TxSdma9DisallowedPacketErr",
562 SEES(TX_SDMA9_DISALLOWED_PACKET)),
563/*26*/ FLAG_ENTRY0("TxSdma10DisallowedPacketErr",
564 SEES(TX_SDMA10_DISALLOWED_PACKET)),
565/*27*/ FLAG_ENTRY0("TxSdma11DisallowedPacketErr",
566 SEES(TX_SDMA11_DISALLOWED_PACKET)),
567/*28*/ FLAG_ENTRY0("TxSdma12DisallowedPacketErr",
568 SEES(TX_SDMA12_DISALLOWED_PACKET)),
569/*29*/ FLAG_ENTRY0("TxSdma13DisallowedPacketErr",
570 SEES(TX_SDMA13_DISALLOWED_PACKET)),
571/*30*/ FLAG_ENTRY0("TxSdma14DisallowedPacketErr",
572 SEES(TX_SDMA14_DISALLOWED_PACKET)),
573/*31*/ FLAG_ENTRY0("TxSdma15DisallowedPacketErr",
574 SEES(TX_SDMA15_DISALLOWED_PACKET)),
575/*32*/ FLAG_ENTRY0("TxLaunchFifo0UncOrParityErr",
576 SEES(TX_LAUNCH_FIFO0_UNC_OR_PARITY)),
577/*33*/ FLAG_ENTRY0("TxLaunchFifo1UncOrParityErr",
578 SEES(TX_LAUNCH_FIFO1_UNC_OR_PARITY)),
579/*34*/ FLAG_ENTRY0("TxLaunchFifo2UncOrParityErr",
580 SEES(TX_LAUNCH_FIFO2_UNC_OR_PARITY)),
581/*35*/ FLAG_ENTRY0("TxLaunchFifo3UncOrParityErr",
582 SEES(TX_LAUNCH_FIFO3_UNC_OR_PARITY)),
583/*36*/ FLAG_ENTRY0("TxLaunchFifo4UncOrParityErr",
584 SEES(TX_LAUNCH_FIFO4_UNC_OR_PARITY)),
585/*37*/ FLAG_ENTRY0("TxLaunchFifo5UncOrParityErr",
586 SEES(TX_LAUNCH_FIFO5_UNC_OR_PARITY)),
587/*38*/ FLAG_ENTRY0("TxLaunchFifo6UncOrParityErr",
588 SEES(TX_LAUNCH_FIFO6_UNC_OR_PARITY)),
589/*39*/ FLAG_ENTRY0("TxLaunchFifo7UncOrParityErr",
590 SEES(TX_LAUNCH_FIFO7_UNC_OR_PARITY)),
591/*40*/ FLAG_ENTRY0("TxLaunchFifo8UncOrParityErr",
592 SEES(TX_LAUNCH_FIFO8_UNC_OR_PARITY)),
593/*41*/ FLAG_ENTRY0("TxCreditReturnParityErr", SEES(TX_CREDIT_RETURN_PARITY)),
594/*42*/ FLAG_ENTRY0("TxSbHdrUncErr", SEES(TX_SB_HDR_UNC)),
595/*43*/ FLAG_ENTRY0("TxReadSdmaMemoryUncErr", SEES(TX_READ_SDMA_MEMORY_UNC)),
596/*44*/ FLAG_ENTRY0("TxReadPioMemoryUncErr", SEES(TX_READ_PIO_MEMORY_UNC)),
597/*45*/ FLAG_ENTRY0("TxEgressFifoUncErr", SEES(TX_EGRESS_FIFO_UNC)),
598/*46*/ FLAG_ENTRY0("TxHcrcInsertionErr", SEES(TX_HCRC_INSERTION)),
599/*47*/ FLAG_ENTRY0("TxCreditReturnVLErr", SEES(TX_CREDIT_RETURN_VL)),
600/*48*/ FLAG_ENTRY0("TxLaunchFifo0CorErr", SEES(TX_LAUNCH_FIFO0_COR)),
601/*49*/ FLAG_ENTRY0("TxLaunchFifo1CorErr", SEES(TX_LAUNCH_FIFO1_COR)),
602/*50*/ FLAG_ENTRY0("TxLaunchFifo2CorErr", SEES(TX_LAUNCH_FIFO2_COR)),
603/*51*/ FLAG_ENTRY0("TxLaunchFifo3CorErr", SEES(TX_LAUNCH_FIFO3_COR)),
604/*52*/ FLAG_ENTRY0("TxLaunchFifo4CorErr", SEES(TX_LAUNCH_FIFO4_COR)),
605/*53*/ FLAG_ENTRY0("TxLaunchFifo5CorErr", SEES(TX_LAUNCH_FIFO5_COR)),
606/*54*/ FLAG_ENTRY0("TxLaunchFifo6CorErr", SEES(TX_LAUNCH_FIFO6_COR)),
607/*55*/ FLAG_ENTRY0("TxLaunchFifo7CorErr", SEES(TX_LAUNCH_FIFO7_COR)),
608/*56*/ FLAG_ENTRY0("TxLaunchFifo8CorErr", SEES(TX_LAUNCH_FIFO8_COR)),
609/*57*/ FLAG_ENTRY0("TxCreditOverrunErr", SEES(TX_CREDIT_OVERRUN)),
610/*58*/ FLAG_ENTRY0("TxSbHdrCorErr", SEES(TX_SB_HDR_COR)),
611/*59*/ FLAG_ENTRY0("TxReadSdmaMemoryCorErr", SEES(TX_READ_SDMA_MEMORY_COR)),
612/*60*/ FLAG_ENTRY0("TxReadPioMemoryCorErr", SEES(TX_READ_PIO_MEMORY_COR)),
613/*61*/ FLAG_ENTRY0("TxEgressFifoCorErr", SEES(TX_EGRESS_FIFO_COR)),
614/*62*/ FLAG_ENTRY0("TxReadSdmaMemoryCsrUncErr",
615 SEES(TX_READ_SDMA_MEMORY_CSR_UNC)),
616/*63*/ FLAG_ENTRY0("TxReadPioMemoryCsrUncErr",
617 SEES(TX_READ_PIO_MEMORY_CSR_UNC)),
618};
619
620/*
621 * TXE Egress Error Info flags
622 */
623#define SEEI(text) SEND_EGRESS_ERR_INFO_##text##_ERR_SMASK
624static struct flag_table egress_err_info_flags[] = {
625/* 0*/ FLAG_ENTRY0("Reserved", 0ull),
626/* 1*/ FLAG_ENTRY0("VLErr", SEEI(VL)),
627/* 2*/ FLAG_ENTRY0("JobKeyErr", SEEI(JOB_KEY)),
628/* 3*/ FLAG_ENTRY0("JobKeyErr", SEEI(JOB_KEY)),
629/* 4*/ FLAG_ENTRY0("PartitionKeyErr", SEEI(PARTITION_KEY)),
630/* 5*/ FLAG_ENTRY0("SLIDErr", SEEI(SLID)),
631/* 6*/ FLAG_ENTRY0("OpcodeErr", SEEI(OPCODE)),
632/* 7*/ FLAG_ENTRY0("VLMappingErr", SEEI(VL_MAPPING)),
633/* 8*/ FLAG_ENTRY0("RawErr", SEEI(RAW)),
634/* 9*/ FLAG_ENTRY0("RawIPv6Err", SEEI(RAW_IPV6)),
635/*10*/ FLAG_ENTRY0("GRHErr", SEEI(GRH)),
636/*11*/ FLAG_ENTRY0("BypassErr", SEEI(BYPASS)),
637/*12*/ FLAG_ENTRY0("KDETHPacketsErr", SEEI(KDETH_PACKETS)),
638/*13*/ FLAG_ENTRY0("NonKDETHPacketsErr", SEEI(NON_KDETH_PACKETS)),
639/*14*/ FLAG_ENTRY0("TooSmallIBPacketsErr", SEEI(TOO_SMALL_IB_PACKETS)),
640/*15*/ FLAG_ENTRY0("TooSmallBypassPacketsErr", SEEI(TOO_SMALL_BYPASS_PACKETS)),
641/*16*/ FLAG_ENTRY0("PbcTestErr", SEEI(PBC_TEST)),
642/*17*/ FLAG_ENTRY0("BadPktLenErr", SEEI(BAD_PKT_LEN)),
643/*18*/ FLAG_ENTRY0("TooLongIBPacketErr", SEEI(TOO_LONG_IB_PACKET)),
644/*19*/ FLAG_ENTRY0("TooLongBypassPacketsErr", SEEI(TOO_LONG_BYPASS_PACKETS)),
645/*20*/ FLAG_ENTRY0("PbcStaticRateControlErr", SEEI(PBC_STATIC_RATE_CONTROL)),
646/*21*/ FLAG_ENTRY0("BypassBadPktLenErr", SEEI(BAD_PKT_LEN)),
647};
648
649/* TXE Egress errors that cause an SPC freeze */
650#define ALL_TXE_EGRESS_FREEZE_ERR \
651 (SEES(TX_EGRESS_FIFO_UNDERRUN_OR_PARITY) \
652 | SEES(TX_PIO_LAUNCH_INTF_PARITY) \
653 | SEES(TX_SDMA_LAUNCH_INTF_PARITY) \
654 | SEES(TX_SBRD_CTL_STATE_MACHINE_PARITY) \
655 | SEES(TX_LAUNCH_CSR_PARITY) \
656 | SEES(TX_SBRD_CTL_CSR_PARITY) \
657 | SEES(TX_CONFIG_PARITY) \
658 | SEES(TX_LAUNCH_FIFO0_UNC_OR_PARITY) \
659 | SEES(TX_LAUNCH_FIFO1_UNC_OR_PARITY) \
660 | SEES(TX_LAUNCH_FIFO2_UNC_OR_PARITY) \
661 | SEES(TX_LAUNCH_FIFO3_UNC_OR_PARITY) \
662 | SEES(TX_LAUNCH_FIFO4_UNC_OR_PARITY) \
663 | SEES(TX_LAUNCH_FIFO5_UNC_OR_PARITY) \
664 | SEES(TX_LAUNCH_FIFO6_UNC_OR_PARITY) \
665 | SEES(TX_LAUNCH_FIFO7_UNC_OR_PARITY) \
666 | SEES(TX_LAUNCH_FIFO8_UNC_OR_PARITY) \
667 | SEES(TX_CREDIT_RETURN_PARITY))
668
669/*
670 * TXE Send error flags
671 */
672#define SES(name) SEND_ERR_STATUS_SEND_##name##_ERR_SMASK
673static struct flag_table send_err_status_flags[] = {
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]674/* 0*/ FLAG_ENTRY0("SendCsrParityErr", SES(CSR_PARITY)),
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]675/* 1*/ FLAG_ENTRY0("SendCsrReadBadAddrErr", SES(CSR_READ_BAD_ADDR)),
676/* 2*/ FLAG_ENTRY0("SendCsrWriteBadAddrErr", SES(CSR_WRITE_BAD_ADDR))
677};
678
679/*
680 * TXE Send Context Error flags and consequences
681 */
682static struct flag_table sc_err_status_flags[] = {
683/* 0*/ FLAG_ENTRY("InconsistentSop",
684 SEC_PACKET_DROPPED | SEC_SC_HALTED,
685 SEND_CTXT_ERR_STATUS_PIO_INCONSISTENT_SOP_ERR_SMASK),
686/* 1*/ FLAG_ENTRY("DisallowedPacket",
687 SEC_PACKET_DROPPED | SEC_SC_HALTED,
688 SEND_CTXT_ERR_STATUS_PIO_DISALLOWED_PACKET_ERR_SMASK),
689/* 2*/ FLAG_ENTRY("WriteCrossesBoundary",
690 SEC_WRITE_DROPPED | SEC_SC_HALTED,
691 SEND_CTXT_ERR_STATUS_PIO_WRITE_CROSSES_BOUNDARY_ERR_SMASK),
692/* 3*/ FLAG_ENTRY("WriteOverflow",
693 SEC_WRITE_DROPPED | SEC_SC_HALTED,
694 SEND_CTXT_ERR_STATUS_PIO_WRITE_OVERFLOW_ERR_SMASK),
695/* 4*/ FLAG_ENTRY("WriteOutOfBounds",
696 SEC_WRITE_DROPPED | SEC_SC_HALTED,
697 SEND_CTXT_ERR_STATUS_PIO_WRITE_OUT_OF_BOUNDS_ERR_SMASK),
698/* 5-63 reserved*/
699};
700
701/*
702 * RXE Receive Error flags
703 */
704#define RXES(name) RCV_ERR_STATUS_RX_##name##_ERR_SMASK
705static struct flag_table rxe_err_status_flags[] = {
706/* 0*/ FLAG_ENTRY0("RxDmaCsrCorErr", RXES(DMA_CSR_COR)),
707/* 1*/ FLAG_ENTRY0("RxDcIntfParityErr", RXES(DC_INTF_PARITY)),
708/* 2*/ FLAG_ENTRY0("RxRcvHdrUncErr", RXES(RCV_HDR_UNC)),
709/* 3*/ FLAG_ENTRY0("RxRcvHdrCorErr", RXES(RCV_HDR_COR)),
710/* 4*/ FLAG_ENTRY0("RxRcvDataUncErr", RXES(RCV_DATA_UNC)),
711/* 5*/ FLAG_ENTRY0("RxRcvDataCorErr", RXES(RCV_DATA_COR)),
712/* 6*/ FLAG_ENTRY0("RxRcvQpMapTableUncErr", RXES(RCV_QP_MAP_TABLE_UNC)),
713/* 7*/ FLAG_ENTRY0("RxRcvQpMapTableCorErr", RXES(RCV_QP_MAP_TABLE_COR)),
714/* 8*/ FLAG_ENTRY0("RxRcvCsrParityErr", RXES(RCV_CSR_PARITY)),
715/* 9*/ FLAG_ENTRY0("RxDcSopEopParityErr", RXES(DC_SOP_EOP_PARITY)),
716/*10*/ FLAG_ENTRY0("RxDmaFlagUncErr", RXES(DMA_FLAG_UNC)),
717/*11*/ FLAG_ENTRY0("RxDmaFlagCorErr", RXES(DMA_FLAG_COR)),
718/*12*/ FLAG_ENTRY0("RxRcvFsmEncodingErr", RXES(RCV_FSM_ENCODING)),
719/*13*/ FLAG_ENTRY0("RxRbufFreeListUncErr", RXES(RBUF_FREE_LIST_UNC)),
720/*14*/ FLAG_ENTRY0("RxRbufFreeListCorErr", RXES(RBUF_FREE_LIST_COR)),
721/*15*/ FLAG_ENTRY0("RxRbufLookupDesRegUncErr", RXES(RBUF_LOOKUP_DES_REG_UNC)),
722/*16*/ FLAG_ENTRY0("RxRbufLookupDesRegUncCorErr",
723 RXES(RBUF_LOOKUP_DES_REG_UNC_COR)),
724/*17*/ FLAG_ENTRY0("RxRbufLookupDesUncErr", RXES(RBUF_LOOKUP_DES_UNC)),
725/*18*/ FLAG_ENTRY0("RxRbufLookupDesCorErr", RXES(RBUF_LOOKUP_DES_COR)),
726/*19*/ FLAG_ENTRY0("RxRbufBlockListReadUncErr",
727 RXES(RBUF_BLOCK_LIST_READ_UNC)),
728/*20*/ FLAG_ENTRY0("RxRbufBlockListReadCorErr",
729 RXES(RBUF_BLOCK_LIST_READ_COR)),
730/*21*/ FLAG_ENTRY0("RxRbufCsrQHeadBufNumParityErr",
731 RXES(RBUF_CSR_QHEAD_BUF_NUM_PARITY)),
732/*22*/ FLAG_ENTRY0("RxRbufCsrQEntCntParityErr",
733 RXES(RBUF_CSR_QENT_CNT_PARITY)),
734/*23*/ FLAG_ENTRY0("RxRbufCsrQNextBufParityErr",
735 RXES(RBUF_CSR_QNEXT_BUF_PARITY)),
736/*24*/ FLAG_ENTRY0("RxRbufCsrQVldBitParityErr",
737 RXES(RBUF_CSR_QVLD_BIT_PARITY)),
738/*25*/ FLAG_ENTRY0("RxRbufCsrQHdPtrParityErr", RXES(RBUF_CSR_QHD_PTR_PARITY)),
739/*26*/ FLAG_ENTRY0("RxRbufCsrQTlPtrParityErr", RXES(RBUF_CSR_QTL_PTR_PARITY)),
740/*27*/ FLAG_ENTRY0("RxRbufCsrQNumOfPktParityErr",
741 RXES(RBUF_CSR_QNUM_OF_PKT_PARITY)),
742/*28*/ FLAG_ENTRY0("RxRbufCsrQEOPDWParityErr", RXES(RBUF_CSR_QEOPDW_PARITY)),
743/*29*/ FLAG_ENTRY0("RxRbufCtxIdParityErr", RXES(RBUF_CTX_ID_PARITY)),
744/*30*/ FLAG_ENTRY0("RxRBufBadLookupErr", RXES(RBUF_BAD_LOOKUP)),
745/*31*/ FLAG_ENTRY0("RxRbufFullErr", RXES(RBUF_FULL)),
746/*32*/ FLAG_ENTRY0("RxRbufEmptyErr", RXES(RBUF_EMPTY)),
747/*33*/ FLAG_ENTRY0("RxRbufFlRdAddrParityErr", RXES(RBUF_FL_RD_ADDR_PARITY)),
748/*34*/ FLAG_ENTRY0("RxRbufFlWrAddrParityErr", RXES(RBUF_FL_WR_ADDR_PARITY)),
749/*35*/ FLAG_ENTRY0("RxRbufFlInitdoneParityErr",
750 RXES(RBUF_FL_INITDONE_PARITY)),
751/*36*/ FLAG_ENTRY0("RxRbufFlInitWrAddrParityErr",
752 RXES(RBUF_FL_INIT_WR_ADDR_PARITY)),
753/*37*/ FLAG_ENTRY0("RxRbufNextFreeBufUncErr", RXES(RBUF_NEXT_FREE_BUF_UNC)),
754/*38*/ FLAG_ENTRY0("RxRbufNextFreeBufCorErr", RXES(RBUF_NEXT_FREE_BUF_COR)),
755/*39*/ FLAG_ENTRY0("RxLookupDesPart1UncErr", RXES(LOOKUP_DES_PART1_UNC)),
756/*40*/ FLAG_ENTRY0("RxLookupDesPart1UncCorErr",
757 RXES(LOOKUP_DES_PART1_UNC_COR)),
758/*41*/ FLAG_ENTRY0("RxLookupDesPart2ParityErr",
759 RXES(LOOKUP_DES_PART2_PARITY)),
760/*42*/ FLAG_ENTRY0("RxLookupRcvArrayUncErr", RXES(LOOKUP_RCV_ARRAY_UNC)),
761/*43*/ FLAG_ENTRY0("RxLookupRcvArrayCorErr", RXES(LOOKUP_RCV_ARRAY_COR)),
762/*44*/ FLAG_ENTRY0("RxLookupCsrParityErr", RXES(LOOKUP_CSR_PARITY)),
763/*45*/ FLAG_ENTRY0("RxHqIntrCsrParityErr", RXES(HQ_INTR_CSR_PARITY)),
764/*46*/ FLAG_ENTRY0("RxHqIntrFsmErr", RXES(HQ_INTR_FSM)),
765/*47*/ FLAG_ENTRY0("RxRbufDescPart1UncErr", RXES(RBUF_DESC_PART1_UNC)),
766/*48*/ FLAG_ENTRY0("RxRbufDescPart1CorErr", RXES(RBUF_DESC_PART1_COR)),
767/*49*/ FLAG_ENTRY0("RxRbufDescPart2UncErr", RXES(RBUF_DESC_PART2_UNC)),
768/*50*/ FLAG_ENTRY0("RxRbufDescPart2CorErr", RXES(RBUF_DESC_PART2_COR)),
769/*51*/ FLAG_ENTRY0("RxDmaHdrFifoRdUncErr", RXES(DMA_HDR_FIFO_RD_UNC)),
770/*52*/ FLAG_ENTRY0("RxDmaHdrFifoRdCorErr", RXES(DMA_HDR_FIFO_RD_COR)),
771/*53*/ FLAG_ENTRY0("RxDmaDataFifoRdUncErr", RXES(DMA_DATA_FIFO_RD_UNC)),
772/*54*/ FLAG_ENTRY0("RxDmaDataFifoRdCorErr", RXES(DMA_DATA_FIFO_RD_COR)),
773/*55*/ FLAG_ENTRY0("RxRbufDataUncErr", RXES(RBUF_DATA_UNC)),
774/*56*/ FLAG_ENTRY0("RxRbufDataCorErr", RXES(RBUF_DATA_COR)),
775/*57*/ FLAG_ENTRY0("RxDmaCsrParityErr", RXES(DMA_CSR_PARITY)),
776/*58*/ FLAG_ENTRY0("RxDmaEqFsmEncodingErr", RXES(DMA_EQ_FSM_ENCODING)),
777/*59*/ FLAG_ENTRY0("RxDmaDqFsmEncodingErr", RXES(DMA_DQ_FSM_ENCODING)),
778/*60*/ FLAG_ENTRY0("RxDmaCsrUncErr", RXES(DMA_CSR_UNC)),
779/*61*/ FLAG_ENTRY0("RxCsrReadBadAddrErr", RXES(CSR_READ_BAD_ADDR)),
780/*62*/ FLAG_ENTRY0("RxCsrWriteBadAddrErr", RXES(CSR_WRITE_BAD_ADDR)),
781/*63*/ FLAG_ENTRY0("RxCsrParityErr", RXES(CSR_PARITY))
782};
783
784/* RXE errors that will trigger an SPC freeze */
785#define ALL_RXE_FREEZE_ERR \
786 (RCV_ERR_STATUS_RX_RCV_QP_MAP_TABLE_UNC_ERR_SMASK \
787 | RCV_ERR_STATUS_RX_RCV_CSR_PARITY_ERR_SMASK \
788 | RCV_ERR_STATUS_RX_DMA_FLAG_UNC_ERR_SMASK \
789 | RCV_ERR_STATUS_RX_RCV_FSM_ENCODING_ERR_SMASK \
790 | RCV_ERR_STATUS_RX_RBUF_FREE_LIST_UNC_ERR_SMASK \
791 | RCV_ERR_STATUS_RX_RBUF_LOOKUP_DES_REG_UNC_ERR_SMASK \
792 | RCV_ERR_STATUS_RX_RBUF_LOOKUP_DES_REG_UNC_COR_ERR_SMASK \
793 | RCV_ERR_STATUS_RX_RBUF_LOOKUP_DES_UNC_ERR_SMASK \
794 | RCV_ERR_STATUS_RX_RBUF_BLOCK_LIST_READ_UNC_ERR_SMASK \
795 | RCV_ERR_STATUS_RX_RBUF_CSR_QHEAD_BUF_NUM_PARITY_ERR_SMASK \
796 | RCV_ERR_STATUS_RX_RBUF_CSR_QENT_CNT_PARITY_ERR_SMASK \
797 | RCV_ERR_STATUS_RX_RBUF_CSR_QNEXT_BUF_PARITY_ERR_SMASK \
798 | RCV_ERR_STATUS_RX_RBUF_CSR_QVLD_BIT_PARITY_ERR_SMASK \
799 | RCV_ERR_STATUS_RX_RBUF_CSR_QHD_PTR_PARITY_ERR_SMASK \
800 | RCV_ERR_STATUS_RX_RBUF_CSR_QTL_PTR_PARITY_ERR_SMASK \
801 | RCV_ERR_STATUS_RX_RBUF_CSR_QNUM_OF_PKT_PARITY_ERR_SMASK \
802 | RCV_ERR_STATUS_RX_RBUF_CSR_QEOPDW_PARITY_ERR_SMASK \
803 | RCV_ERR_STATUS_RX_RBUF_CTX_ID_PARITY_ERR_SMASK \
804 | RCV_ERR_STATUS_RX_RBUF_BAD_LOOKUP_ERR_SMASK \
805 | RCV_ERR_STATUS_RX_RBUF_FULL_ERR_SMASK \
806 | RCV_ERR_STATUS_RX_RBUF_EMPTY_ERR_SMASK \
807 | RCV_ERR_STATUS_RX_RBUF_FL_RD_ADDR_PARITY_ERR_SMASK \
808 | RCV_ERR_STATUS_RX_RBUF_FL_WR_ADDR_PARITY_ERR_SMASK \
809 | RCV_ERR_STATUS_RX_RBUF_FL_INITDONE_PARITY_ERR_SMASK \
810 | RCV_ERR_STATUS_RX_RBUF_FL_INIT_WR_ADDR_PARITY_ERR_SMASK \
811 | RCV_ERR_STATUS_RX_RBUF_NEXT_FREE_BUF_UNC_ERR_SMASK \
812 | RCV_ERR_STATUS_RX_LOOKUP_DES_PART1_UNC_ERR_SMASK \
813 | RCV_ERR_STATUS_RX_LOOKUP_DES_PART1_UNC_COR_ERR_SMASK \
814 | RCV_ERR_STATUS_RX_LOOKUP_DES_PART2_PARITY_ERR_SMASK \
815 | RCV_ERR_STATUS_RX_LOOKUP_RCV_ARRAY_UNC_ERR_SMASK \
816 | RCV_ERR_STATUS_RX_LOOKUP_CSR_PARITY_ERR_SMASK \
817 | RCV_ERR_STATUS_RX_HQ_INTR_CSR_PARITY_ERR_SMASK \
818 | RCV_ERR_STATUS_RX_HQ_INTR_FSM_ERR_SMASK \
819 | RCV_ERR_STATUS_RX_RBUF_DESC_PART1_UNC_ERR_SMASK \
820 | RCV_ERR_STATUS_RX_RBUF_DESC_PART1_COR_ERR_SMASK \
821 | RCV_ERR_STATUS_RX_RBUF_DESC_PART2_UNC_ERR_SMASK \
822 | RCV_ERR_STATUS_RX_DMA_HDR_FIFO_RD_UNC_ERR_SMASK \
823 | RCV_ERR_STATUS_RX_DMA_DATA_FIFO_RD_UNC_ERR_SMASK \
824 | RCV_ERR_STATUS_RX_RBUF_DATA_UNC_ERR_SMASK \
825 | RCV_ERR_STATUS_RX_DMA_CSR_PARITY_ERR_SMASK \
826 | RCV_ERR_STATUS_RX_DMA_EQ_FSM_ENCODING_ERR_SMASK \
827 | RCV_ERR_STATUS_RX_DMA_DQ_FSM_ENCODING_ERR_SMASK \
828 | RCV_ERR_STATUS_RX_DMA_CSR_UNC_ERR_SMASK \
829 | RCV_ERR_STATUS_RX_CSR_PARITY_ERR_SMASK)
830
831#define RXE_FREEZE_ABORT_MASK \
832 (RCV_ERR_STATUS_RX_DMA_CSR_UNC_ERR_SMASK | \
833 RCV_ERR_STATUS_RX_DMA_HDR_FIFO_RD_UNC_ERR_SMASK | \
834 RCV_ERR_STATUS_RX_DMA_DATA_FIFO_RD_UNC_ERR_SMASK)
835
836/*
837 * DCC Error Flags
838 */
839#define DCCE(name) DCC_ERR_FLG_##name##_SMASK
840static struct flag_table dcc_err_flags[] = {
841 FLAG_ENTRY0("bad_l2_err", DCCE(BAD_L2_ERR)),
842 FLAG_ENTRY0("bad_sc_err", DCCE(BAD_SC_ERR)),
843 FLAG_ENTRY0("bad_mid_tail_err", DCCE(BAD_MID_TAIL_ERR)),
844 FLAG_ENTRY0("bad_preemption_err", DCCE(BAD_PREEMPTION_ERR)),
845 FLAG_ENTRY0("preemption_err", DCCE(PREEMPTION_ERR)),
846 FLAG_ENTRY0("preemptionvl15_err", DCCE(PREEMPTIONVL15_ERR)),
847 FLAG_ENTRY0("bad_vl_marker_err", DCCE(BAD_VL_MARKER_ERR)),
848 FLAG_ENTRY0("bad_dlid_target_err", DCCE(BAD_DLID_TARGET_ERR)),
849 FLAG_ENTRY0("bad_lver_err", DCCE(BAD_LVER_ERR)),
850 FLAG_ENTRY0("uncorrectable_err", DCCE(UNCORRECTABLE_ERR)),
851 FLAG_ENTRY0("bad_crdt_ack_err", DCCE(BAD_CRDT_ACK_ERR)),
852 FLAG_ENTRY0("unsup_pkt_type", DCCE(UNSUP_PKT_TYPE)),
853 FLAG_ENTRY0("bad_ctrl_flit_err", DCCE(BAD_CTRL_FLIT_ERR)),
854 FLAG_ENTRY0("event_cntr_parity_err", DCCE(EVENT_CNTR_PARITY_ERR)),
855 FLAG_ENTRY0("event_cntr_rollover_err", DCCE(EVENT_CNTR_ROLLOVER_ERR)),
856 FLAG_ENTRY0("link_err", DCCE(LINK_ERR)),
857 FLAG_ENTRY0("misc_cntr_rollover_err", DCCE(MISC_CNTR_ROLLOVER_ERR)),
858 FLAG_ENTRY0("bad_ctrl_dist_err", DCCE(BAD_CTRL_DIST_ERR)),
859 FLAG_ENTRY0("bad_tail_dist_err", DCCE(BAD_TAIL_DIST_ERR)),
860 FLAG_ENTRY0("bad_head_dist_err", DCCE(BAD_HEAD_DIST_ERR)),
861 FLAG_ENTRY0("nonvl15_state_err", DCCE(NONVL15_STATE_ERR)),
862 FLAG_ENTRY0("vl15_multi_err", DCCE(VL15_MULTI_ERR)),
863 FLAG_ENTRY0("bad_pkt_length_err", DCCE(BAD_PKT_LENGTH_ERR)),
864 FLAG_ENTRY0("unsup_vl_err", DCCE(UNSUP_VL_ERR)),
865 FLAG_ENTRY0("perm_nvl15_err", DCCE(PERM_NVL15_ERR)),
866 FLAG_ENTRY0("slid_zero_err", DCCE(SLID_ZERO_ERR)),
867 FLAG_ENTRY0("dlid_zero_err", DCCE(DLID_ZERO_ERR)),
868 FLAG_ENTRY0("length_mtu_err", DCCE(LENGTH_MTU_ERR)),
869 FLAG_ENTRY0("rx_early_drop_err", DCCE(RX_EARLY_DROP_ERR)),
870 FLAG_ENTRY0("late_short_err", DCCE(LATE_SHORT_ERR)),
871 FLAG_ENTRY0("late_long_err", DCCE(LATE_LONG_ERR)),
872 FLAG_ENTRY0("late_ebp_err", DCCE(LATE_EBP_ERR)),
873 FLAG_ENTRY0("fpe_tx_fifo_ovflw_err", DCCE(FPE_TX_FIFO_OVFLW_ERR)),
874 FLAG_ENTRY0("fpe_tx_fifo_unflw_err", DCCE(FPE_TX_FIFO_UNFLW_ERR)),
875 FLAG_ENTRY0("csr_access_blocked_host", DCCE(CSR_ACCESS_BLOCKED_HOST)),
876 FLAG_ENTRY0("csr_access_blocked_uc", DCCE(CSR_ACCESS_BLOCKED_UC)),
877 FLAG_ENTRY0("tx_ctrl_parity_err", DCCE(TX_CTRL_PARITY_ERR)),
878 FLAG_ENTRY0("tx_ctrl_parity_mbe_err", DCCE(TX_CTRL_PARITY_MBE_ERR)),
879 FLAG_ENTRY0("tx_sc_parity_err", DCCE(TX_SC_PARITY_ERR)),
880 FLAG_ENTRY0("rx_ctrl_parity_mbe_err", DCCE(RX_CTRL_PARITY_MBE_ERR)),
881 FLAG_ENTRY0("csr_parity_err", DCCE(CSR_PARITY_ERR)),
882 FLAG_ENTRY0("csr_inval_addr", DCCE(CSR_INVAL_ADDR)),
883 FLAG_ENTRY0("tx_byte_shft_parity_err", DCCE(TX_BYTE_SHFT_PARITY_ERR)),
884 FLAG_ENTRY0("rx_byte_shft_parity_err", DCCE(RX_BYTE_SHFT_PARITY_ERR)),
885 FLAG_ENTRY0("fmconfig_err", DCCE(FMCONFIG_ERR)),
886 FLAG_ENTRY0("rcvport_err", DCCE(RCVPORT_ERR)),
887};
888
889/*
890 * LCB error flags
891 */
892#define LCBE(name) DC_LCB_ERR_FLG_##name##_SMASK
893static struct flag_table lcb_err_flags[] = {
894/* 0*/ FLAG_ENTRY0("CSR_PARITY_ERR", LCBE(CSR_PARITY_ERR)),
895/* 1*/ FLAG_ENTRY0("INVALID_CSR_ADDR", LCBE(INVALID_CSR_ADDR)),
896/* 2*/ FLAG_ENTRY0("RST_FOR_FAILED_DESKEW", LCBE(RST_FOR_FAILED_DESKEW)),
897/* 3*/ FLAG_ENTRY0("ALL_LNS_FAILED_REINIT_TEST",
898 LCBE(ALL_LNS_FAILED_REINIT_TEST)),
899/* 4*/ FLAG_ENTRY0("LOST_REINIT_STALL_OR_TOS", LCBE(LOST_REINIT_STALL_OR_TOS)),
900/* 5*/ FLAG_ENTRY0("TX_LESS_THAN_FOUR_LNS", LCBE(TX_LESS_THAN_FOUR_LNS)),
901/* 6*/ FLAG_ENTRY0("RX_LESS_THAN_FOUR_LNS", LCBE(RX_LESS_THAN_FOUR_LNS)),
902/* 7*/ FLAG_ENTRY0("SEQ_CRC_ERR", LCBE(SEQ_CRC_ERR)),
903/* 8*/ FLAG_ENTRY0("REINIT_FROM_PEER", LCBE(REINIT_FROM_PEER)),
904/* 9*/ FLAG_ENTRY0("REINIT_FOR_LN_DEGRADE", LCBE(REINIT_FOR_LN_DEGRADE)),
905/*10*/ FLAG_ENTRY0("CRC_ERR_CNT_HIT_LIMIT", LCBE(CRC_ERR_CNT_HIT_LIMIT)),
906/*11*/ FLAG_ENTRY0("RCLK_STOPPED", LCBE(RCLK_STOPPED)),
907/*12*/ FLAG_ENTRY0("UNEXPECTED_REPLAY_MARKER", LCBE(UNEXPECTED_REPLAY_MARKER)),
908/*13*/ FLAG_ENTRY0("UNEXPECTED_ROUND_TRIP_MARKER",
909 LCBE(UNEXPECTED_ROUND_TRIP_MARKER)),
910/*14*/ FLAG_ENTRY0("ILLEGAL_NULL_LTP", LCBE(ILLEGAL_NULL_LTP)),
911/*15*/ FLAG_ENTRY0("ILLEGAL_FLIT_ENCODING", LCBE(ILLEGAL_FLIT_ENCODING)),
912/*16*/ FLAG_ENTRY0("FLIT_INPUT_BUF_OFLW", LCBE(FLIT_INPUT_BUF_OFLW)),
913/*17*/ FLAG_ENTRY0("VL_ACK_INPUT_BUF_OFLW", LCBE(VL_ACK_INPUT_BUF_OFLW)),
914/*18*/ FLAG_ENTRY0("VL_ACK_INPUT_PARITY_ERR", LCBE(VL_ACK_INPUT_PARITY_ERR)),
915/*19*/ FLAG_ENTRY0("VL_ACK_INPUT_WRONG_CRC_MODE",
916 LCBE(VL_ACK_INPUT_WRONG_CRC_MODE)),
917/*20*/ FLAG_ENTRY0("FLIT_INPUT_BUF_MBE", LCBE(FLIT_INPUT_BUF_MBE)),
918/*21*/ FLAG_ENTRY0("FLIT_INPUT_BUF_SBE", LCBE(FLIT_INPUT_BUF_SBE)),
919/*22*/ FLAG_ENTRY0("REPLAY_BUF_MBE", LCBE(REPLAY_BUF_MBE)),
920/*23*/ FLAG_ENTRY0("REPLAY_BUF_SBE", LCBE(REPLAY_BUF_SBE)),
921/*24*/ FLAG_ENTRY0("CREDIT_RETURN_FLIT_MBE", LCBE(CREDIT_RETURN_FLIT_MBE)),
922/*25*/ FLAG_ENTRY0("RST_FOR_LINK_TIMEOUT", LCBE(RST_FOR_LINK_TIMEOUT)),
923/*26*/ FLAG_ENTRY0("RST_FOR_INCOMPLT_RND_TRIP",
924 LCBE(RST_FOR_INCOMPLT_RND_TRIP)),
925/*27*/ FLAG_ENTRY0("HOLD_REINIT", LCBE(HOLD_REINIT)),
926/*28*/ FLAG_ENTRY0("NEG_EDGE_LINK_TRANSFER_ACTIVE",
927 LCBE(NEG_EDGE_LINK_TRANSFER_ACTIVE)),
928/*29*/ FLAG_ENTRY0("REDUNDANT_FLIT_PARITY_ERR",
929 LCBE(REDUNDANT_FLIT_PARITY_ERR))
930};
931
932/*
933 * DC8051 Error Flags
934 */
935#define D8E(name) DC_DC8051_ERR_FLG_##name##_SMASK
936static struct flag_table dc8051_err_flags[] = {
937 FLAG_ENTRY0("SET_BY_8051", D8E(SET_BY_8051)),
938 FLAG_ENTRY0("LOST_8051_HEART_BEAT", D8E(LOST_8051_HEART_BEAT)),
939 FLAG_ENTRY0("CRAM_MBE", D8E(CRAM_MBE)),
940 FLAG_ENTRY0("CRAM_SBE", D8E(CRAM_SBE)),
941 FLAG_ENTRY0("DRAM_MBE", D8E(DRAM_MBE)),
942 FLAG_ENTRY0("DRAM_SBE", D8E(DRAM_SBE)),
943 FLAG_ENTRY0("IRAM_MBE", D8E(IRAM_MBE)),
944 FLAG_ENTRY0("IRAM_SBE", D8E(IRAM_SBE)),
945 FLAG_ENTRY0("UNMATCHED_SECURE_MSG_ACROSS_BCC_LANES",
946 D8E(UNMATCHED_SECURE_MSG_ACROSS_BCC_LANES)),
947 FLAG_ENTRY0("INVALID_CSR_ADDR", D8E(INVALID_CSR_ADDR)),
948};
949
950/*
951 * DC8051 Information Error flags
952 *
953 * Flags in DC8051_DBG_ERR_INFO_SET_BY_8051.ERROR field.
954 */
955static struct flag_table dc8051_info_err_flags[] = {
956 FLAG_ENTRY0("Spico ROM check failed", SPICO_ROM_FAILED),
957 FLAG_ENTRY0("Unknown frame received", UNKNOWN_FRAME),
958 FLAG_ENTRY0("Target BER not met", TARGET_BER_NOT_MET),
959 FLAG_ENTRY0("Serdes internal loopback failure",
960 FAILED_SERDES_INTERNAL_LOOPBACK),
961 FLAG_ENTRY0("Failed SerDes init", FAILED_SERDES_INIT),
962 FLAG_ENTRY0("Failed LNI(Polling)", FAILED_LNI_POLLING),
963 FLAG_ENTRY0("Failed LNI(Debounce)", FAILED_LNI_DEBOUNCE),
964 FLAG_ENTRY0("Failed LNI(EstbComm)", FAILED_LNI_ESTBCOMM),
965 FLAG_ENTRY0("Failed LNI(OptEq)", FAILED_LNI_OPTEQ),
966 FLAG_ENTRY0("Failed LNI(VerifyCap_1)", FAILED_LNI_VERIFY_CAP1),
967 FLAG_ENTRY0("Failed LNI(VerifyCap_2)", FAILED_LNI_VERIFY_CAP2),
968 FLAG_ENTRY0("Failed LNI(ConfigLT)", FAILED_LNI_CONFIGLT)
969};
970
971/*
972 * DC8051 Information Host Information flags
973 *
974 * Flags in DC8051_DBG_ERR_INFO_SET_BY_8051.HOST_MSG field.
975 */
976static struct flag_table dc8051_info_host_msg_flags[] = {
977 FLAG_ENTRY0("Host request done", 0x0001),
978 FLAG_ENTRY0("BC SMA message", 0x0002),
979 FLAG_ENTRY0("BC PWR_MGM message", 0x0004),
980 FLAG_ENTRY0("BC Unknown message (BCC)", 0x0008),
981 FLAG_ENTRY0("BC Unknown message (LCB)", 0x0010),
982 FLAG_ENTRY0("External device config request", 0x0020),
983 FLAG_ENTRY0("VerifyCap all frames received", 0x0040),
984 FLAG_ENTRY0("LinkUp achieved", 0x0080),
985 FLAG_ENTRY0("Link going down", 0x0100),
986};
987
988
989static u32 encoded_size(u32 size);
990static u32 chip_to_opa_lstate(struct hfi1_devdata *dd, u32 chip_lstate);
991static int set_physical_link_state(struct hfi1_devdata *dd, u64 state);
992static void read_vc_remote_phy(struct hfi1_devdata *dd, u8 *power_management,
993 u8 *continuous);
994static void read_vc_remote_fabric(struct hfi1_devdata *dd, u8 *vau, u8 *z,
995 u8 *vcu, u16 *vl15buf, u8 *crc_sizes);
996static void read_vc_remote_link_width(struct hfi1_devdata *dd,
997 u8 *remote_tx_rate, u16 *link_widths);
998static void read_vc_local_link_width(struct hfi1_devdata *dd, u8 *misc_bits,
999 u8 *flag_bits, u16 *link_widths);
1000static void read_remote_device_id(struct hfi1_devdata *dd, u16 *device_id,
1001 u8 *device_rev);
1002static void read_mgmt_allowed(struct hfi1_devdata *dd, u8 *mgmt_allowed);
1003static void read_local_lni(struct hfi1_devdata *dd, u8 *enable_lane_rx);
1004static int read_tx_settings(struct hfi1_devdata *dd, u8 *enable_lane_tx,
1005 u8 *tx_polarity_inversion,
1006 u8 *rx_polarity_inversion, u8 *max_rate);
1007static void handle_sdma_eng_err(struct hfi1_devdata *dd,
1008 unsigned int context, u64 err_status);
1009static void handle_qsfp_int(struct hfi1_devdata *dd, u32 source, u64 reg);
1010static void handle_dcc_err(struct hfi1_devdata *dd,
1011 unsigned int context, u64 err_status);
1012static void handle_lcb_err(struct hfi1_devdata *dd,
1013 unsigned int context, u64 err_status);
1014static void handle_8051_interrupt(struct hfi1_devdata *dd, u32 unused, u64 reg);
1015static void handle_cce_err(struct hfi1_devdata *dd, u32 unused, u64 reg);
1016static void handle_rxe_err(struct hfi1_devdata *dd, u32 unused, u64 reg);
1017static void handle_misc_err(struct hfi1_devdata *dd, u32 unused, u64 reg);
1018static void handle_pio_err(struct hfi1_devdata *dd, u32 unused, u64 reg);
1019static void handle_sdma_err(struct hfi1_devdata *dd, u32 unused, u64 reg);
1020static void handle_egress_err(struct hfi1_devdata *dd, u32 unused, u64 reg);
1021static void handle_txe_err(struct hfi1_devdata *dd, u32 unused, u64 reg);
1022static void set_partition_keys(struct hfi1_pportdata *);
1023static const char *link_state_name(u32 state);
1024static const char *link_state_reason_name(struct hfi1_pportdata *ppd,
1025 u32 state);
1026static int do_8051_command(struct hfi1_devdata *dd, u32 type, u64 in_data,
1027 u64 *out_data);
1028static int read_idle_sma(struct hfi1_devdata *dd, u64 *data);
1029static int thermal_init(struct hfi1_devdata *dd);
1030
1031static int wait_logical_linkstate(struct hfi1_pportdata *ppd, u32 state,
1032 int msecs);
1033static void read_planned_down_reason_code(struct hfi1_devdata *dd, u8 *pdrrc);
1034static void handle_temp_err(struct hfi1_devdata *);
1035static void dc_shutdown(struct hfi1_devdata *);
1036static void dc_start(struct hfi1_devdata *);
1037
1038/*
1039 * Error interrupt table entry. This is used as input to the interrupt
1040 * "clear down" routine used for all second tier error interrupt register.
1041 * Second tier interrupt registers have a single bit representing them
1042 * in the top-level CceIntStatus.
1043 */
1044struct err_reg_info {
1045 u32 status; /* status CSR offset */
1046 u32 clear; /* clear CSR offset */
1047 u32 mask; /* mask CSR offset */
1048 void (*handler)(struct hfi1_devdata *dd, u32 source, u64 reg);
1049 const char *desc;
1050};
1051
1052#define NUM_MISC_ERRS (IS_GENERAL_ERR_END - IS_GENERAL_ERR_START)
1053#define NUM_DC_ERRS (IS_DC_END - IS_DC_START)
1054#define NUM_VARIOUS (IS_VARIOUS_END - IS_VARIOUS_START)
1055
1056/*
1057 * Helpers for building HFI and DC error interrupt table entries. Different
1058 * helpers are needed because of inconsistent register names.
1059 */
1060#define EE(reg, handler, desc) \
1061 { reg##_STATUS, reg##_CLEAR, reg##_MASK, \
1062 handler, desc }
1063#define DC_EE1(reg, handler, desc) \
1064 { reg##_FLG, reg##_FLG_CLR, reg##_FLG_EN, handler, desc }
1065#define DC_EE2(reg, handler, desc) \
1066 { reg##_FLG, reg##_CLR, reg##_EN, handler, desc }
1067
1068/*
1069 * Table of the "misc" grouping of error interrupts. Each entry refers to
1070 * another register containing more information.
1071 */
1072static const struct err_reg_info misc_errs[NUM_MISC_ERRS] = {
1073/* 0*/ EE(CCE_ERR, handle_cce_err, "CceErr"),
1074/* 1*/ EE(RCV_ERR, handle_rxe_err, "RxeErr"),
1075/* 2*/ EE(MISC_ERR, handle_misc_err, "MiscErr"),
1076/* 3*/ { 0, 0, 0, NULL }, /* reserved */
1077/* 4*/ EE(SEND_PIO_ERR, handle_pio_err, "PioErr"),
1078/* 5*/ EE(SEND_DMA_ERR, handle_sdma_err, "SDmaErr"),
1079/* 6*/ EE(SEND_EGRESS_ERR, handle_egress_err, "EgressErr"),
1080/* 7*/ EE(SEND_ERR, handle_txe_err, "TxeErr")
1081 /* the rest are reserved */
1082};
1083
1084/*
1085 * Index into the Various section of the interrupt sources
1086 * corresponding to the Critical Temperature interrupt.
1087 */
1088#define TCRIT_INT_SOURCE 4
1089
1090/*
1091 * SDMA error interrupt entry - refers to another register containing more
1092 * information.
1093 */
1094static const struct err_reg_info sdma_eng_err =
1095 EE(SEND_DMA_ENG_ERR, handle_sdma_eng_err, "SDmaEngErr");
1096
1097static const struct err_reg_info various_err[NUM_VARIOUS] = {
1098/* 0*/ { 0, 0, 0, NULL }, /* PbcInt */
1099/* 1*/ { 0, 0, 0, NULL }, /* GpioAssertInt */
1100/* 2*/ EE(ASIC_QSFP1, handle_qsfp_int, "QSFP1"),
1101/* 3*/ EE(ASIC_QSFP2, handle_qsfp_int, "QSFP2"),
1102/* 4*/ { 0, 0, 0, NULL }, /* TCritInt */
1103 /* rest are reserved */
1104};
1105
1106/*
1107 * The DC encoding of mtu_cap for 10K MTU in the DCC_CFG_PORT_CONFIG
1108 * register can not be derived from the MTU value because 10K is not
1109 * a power of 2. Therefore, we need a constant. Everything else can
1110 * be calculated.
1111 */
1112#define DCC_CFG_PORT_MTU_CAP_10240 7
1113
1114/*
1115 * Table of the DC grouping of error interrupts. Each entry refers to
1116 * another register containing more information.
1117 */
1118static const struct err_reg_info dc_errs[NUM_DC_ERRS] = {
1119/* 0*/ DC_EE1(DCC_ERR, handle_dcc_err, "DCC Err"),
1120/* 1*/ DC_EE2(DC_LCB_ERR, handle_lcb_err, "LCB Err"),
1121/* 2*/ DC_EE2(DC_DC8051_ERR, handle_8051_interrupt, "DC8051 Interrupt"),
1122/* 3*/ /* dc_lbm_int - special, see is_dc_int() */
1123 /* the rest are reserved */
1124};
1125
1126struct cntr_entry {
1127 /*
1128 * counter name
1129 */
1130 char *name;
1131
1132 /*
1133 * csr to read for name (if applicable)
1134 */
1135 u64 csr;
1136
1137 /*
1138 * offset into dd or ppd to store the counter's value
1139 */
1140 int offset;
1141
1142 /*
1143 * flags
1144 */
1145 u8 flags;
1146
1147 /*
1148 * accessor for stat element, context either dd or ppd
1149 */
1150 u64 (*rw_cntr)(const struct cntr_entry *,
1151 void *context,
1152 int vl,
1153 int mode,
1154 u64 data);
1155};
1156
1157#define C_RCV_HDR_OVF_FIRST C_RCV_HDR_OVF_0
1158#define C_RCV_HDR_OVF_LAST C_RCV_HDR_OVF_159
1159
1160#define CNTR_ELEM(name, csr, offset, flags, accessor) \
1161{ \
1162 name, \
1163 csr, \
1164 offset, \
1165 flags, \
1166 accessor \
1167}
1168
1169/* 32bit RXE */
1170#define RXE32_PORT_CNTR_ELEM(name, counter, flags) \
1171CNTR_ELEM(#name, \
1172 (counter * 8 + RCV_COUNTER_ARRAY32), \
1173 0, flags | CNTR_32BIT, \
1174 port_access_u32_csr)
1175
1176#define RXE32_DEV_CNTR_ELEM(name, counter, flags) \
1177CNTR_ELEM(#name, \
1178 (counter * 8 + RCV_COUNTER_ARRAY32), \
1179 0, flags | CNTR_32BIT, \
1180 dev_access_u32_csr)
1181
1182/* 64bit RXE */
1183#define RXE64_PORT_CNTR_ELEM(name, counter, flags) \
1184CNTR_ELEM(#name, \
1185 (counter * 8 + RCV_COUNTER_ARRAY64), \
1186 0, flags, \
1187 port_access_u64_csr)
1188
1189#define RXE64_DEV_CNTR_ELEM(name, counter, flags) \
1190CNTR_ELEM(#name, \
1191 (counter * 8 + RCV_COUNTER_ARRAY64), \
1192 0, flags, \
1193 dev_access_u64_csr)
1194
1195#define OVR_LBL(ctx) C_RCV_HDR_OVF_ ## ctx
1196#define OVR_ELM(ctx) \
1197CNTR_ELEM("RcvHdrOvr" #ctx, \
1198 (RCV_HDR_OVFL_CNT + ctx*0x100), \
1199 0, CNTR_NORMAL, port_access_u64_csr)
1200
1201/* 32bit TXE */
1202#define TXE32_PORT_CNTR_ELEM(name, counter, flags) \
1203CNTR_ELEM(#name, \
1204 (counter * 8 + SEND_COUNTER_ARRAY32), \
1205 0, flags | CNTR_32BIT, \
1206 port_access_u32_csr)
1207
1208/* 64bit TXE */
1209#define TXE64_PORT_CNTR_ELEM(name, counter, flags) \
1210CNTR_ELEM(#name, \
1211 (counter * 8 + SEND_COUNTER_ARRAY64), \
1212 0, flags, \
1213 port_access_u64_csr)
1214
1215# define TX64_DEV_CNTR_ELEM(name, counter, flags) \
1216CNTR_ELEM(#name,\
1217 counter * 8 + SEND_COUNTER_ARRAY64, \
1218 0, \
1219 flags, \
1220 dev_access_u64_csr)
1221
1222/* CCE */
1223#define CCE_PERF_DEV_CNTR_ELEM(name, counter, flags) \
1224CNTR_ELEM(#name, \
1225 (counter * 8 + CCE_COUNTER_ARRAY32), \
1226 0, flags | CNTR_32BIT, \
1227 dev_access_u32_csr)
1228
1229#define CCE_INT_DEV_CNTR_ELEM(name, counter, flags) \
1230CNTR_ELEM(#name, \
1231 (counter * 8 + CCE_INT_COUNTER_ARRAY32), \
1232 0, flags | CNTR_32BIT, \
1233 dev_access_u32_csr)
1234
1235/* DC */
1236#define DC_PERF_CNTR(name, counter, flags) \
1237CNTR_ELEM(#name, \
1238 counter, \
1239 0, \
1240 flags, \
1241 dev_access_u64_csr)
1242
1243#define DC_PERF_CNTR_LCB(name, counter, flags) \
1244CNTR_ELEM(#name, \
1245 counter, \
1246 0, \
1247 flags, \
1248 dc_access_lcb_cntr)
1249
1250/* ibp counters */
1251#define SW_IBP_CNTR(name, cntr) \
1252CNTR_ELEM(#name, \
1253 0, \
1254 0, \
1255 CNTR_SYNTH, \
1256 access_ibp_##cntr)
1257
1258u64 read_csr(const struct hfi1_devdata *dd, u32 offset)
1259{
1260 u64 val;
1261
1262 if (dd->flags & HFI1_PRESENT) {
1263 val = readq((void __iomem *)dd->kregbase + offset);
1264 return val;
1265 }
1266 return -1;
1267}
1268
1269void write_csr(const struct hfi1_devdata *dd, u32 offset, u64 value)
1270{
1271 if (dd->flags & HFI1_PRESENT)
1272 writeq(value, (void __iomem *)dd->kregbase + offset);
1273}
1274
1275void __iomem *get_csr_addr(
1276 struct hfi1_devdata *dd,
1277 u32 offset)
1278{
1279 return (void __iomem *)dd->kregbase + offset;
1280}
1281
1282static inline u64 read_write_csr(const struct hfi1_devdata *dd, u32 csr,
1283 int mode, u64 value)
1284{
1285 u64 ret;
1286
1287
1288 if (mode == CNTR_MODE_R) {
1289 ret = read_csr(dd, csr);
1290 } else if (mode == CNTR_MODE_W) {
1291 write_csr(dd, csr, value);
1292 ret = value;
1293 } else {
1294 dd_dev_err(dd, "Invalid cntr register access mode");
1295 return 0;
1296 }
1297
1298 hfi1_cdbg(CNTR, "csr 0x%x val 0x%llx mode %d", csr, ret, mode);
1299 return ret;
1300}
1301
1302/* Dev Access */
1303static u64 dev_access_u32_csr(const struct cntr_entry *entry,
1304 void *context, int vl, int mode, u64 data)
1305{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1306 struct hfi1_devdata *dd = context;
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]1307 u64 csr = entry->csr;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1308
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]1309 if (entry->flags & CNTR_SDMA) {
1310 if (vl == CNTR_INVALID_VL)
1311 return 0;
1312 csr += 0x100 * vl;
1313 } else {
1314 if (vl != CNTR_INVALID_VL)
1315 return 0;
1316 }
1317 return read_write_csr(dd, csr, mode, data);
1318}
1319
1320static u64 access_sde_err_cnt(const struct cntr_entry *entry,
1321 void *context, int idx, int mode, u64 data)
1322{
1323 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1324
1325 if (dd->per_sdma && idx < dd->num_sdma)
1326 return dd->per_sdma[idx].err_cnt;
1327 return 0;
1328}
1329
1330static u64 access_sde_int_cnt(const struct cntr_entry *entry,
1331 void *context, int idx, int mode, u64 data)
1332{
1333 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1334
1335 if (dd->per_sdma && idx < dd->num_sdma)
1336 return dd->per_sdma[idx].sdma_int_cnt;
1337 return 0;
1338}
1339
1340static u64 access_sde_idle_int_cnt(const struct cntr_entry *entry,
1341 void *context, int idx, int mode, u64 data)
1342{
1343 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1344
1345 if (dd->per_sdma && idx < dd->num_sdma)
1346 return dd->per_sdma[idx].idle_int_cnt;
1347 return 0;
1348}
1349
1350static u64 access_sde_progress_int_cnt(const struct cntr_entry *entry,
1351 void *context, int idx, int mode,
1352 u64 data)
1353{
1354 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1355
1356 if (dd->per_sdma && idx < dd->num_sdma)
1357 return dd->per_sdma[idx].progress_int_cnt;
1358 return 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1359}
1360
1361static u64 dev_access_u64_csr(const struct cntr_entry *entry, void *context,
1362 int vl, int mode, u64 data)
1363{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1364 struct hfi1_devdata *dd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1365
1366 u64 val = 0;
1367 u64 csr = entry->csr;
1368
1369 if (entry->flags & CNTR_VL) {
1370 if (vl == CNTR_INVALID_VL)
1371 return 0;
1372 csr += 8 * vl;
1373 } else {
1374 if (vl != CNTR_INVALID_VL)
1375 return 0;
1376 }
1377
1378 val = read_write_csr(dd, csr, mode, data);
1379 return val;
1380}
1381
1382static u64 dc_access_lcb_cntr(const struct cntr_entry *entry, void *context,
1383 int vl, int mode, u64 data)
1384{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1385 struct hfi1_devdata *dd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1386 u32 csr = entry->csr;
1387 int ret = 0;
1388
1389 if (vl != CNTR_INVALID_VL)
1390 return 0;
1391 if (mode == CNTR_MODE_R)
1392 ret = read_lcb_csr(dd, csr, &data);
1393 else if (mode == CNTR_MODE_W)
1394 ret = write_lcb_csr(dd, csr, data);
1395
1396 if (ret) {
1397 dd_dev_err(dd, "Could not acquire LCB for counter 0x%x", csr);
1398 return 0;
1399 }
1400
1401 hfi1_cdbg(CNTR, "csr 0x%x val 0x%llx mode %d", csr, data, mode);
1402 return data;
1403}
1404
1405/* Port Access */
1406static u64 port_access_u32_csr(const struct cntr_entry *entry, void *context,
1407 int vl, int mode, u64 data)
1408{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1409 struct hfi1_pportdata *ppd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1410
1411 if (vl != CNTR_INVALID_VL)
1412 return 0;
1413 return read_write_csr(ppd->dd, entry->csr, mode, data);
1414}
1415
1416static u64 port_access_u64_csr(const struct cntr_entry *entry,
1417 void *context, int vl, int mode, u64 data)
1418{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1419 struct hfi1_pportdata *ppd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1420 u64 val;
1421 u64 csr = entry->csr;
1422
1423 if (entry->flags & CNTR_VL) {
1424 if (vl == CNTR_INVALID_VL)
1425 return 0;
1426 csr += 8 * vl;
1427 } else {
1428 if (vl != CNTR_INVALID_VL)
1429 return 0;
1430 }
1431 val = read_write_csr(ppd->dd, csr, mode, data);
1432 return val;
1433}
1434
1435/* Software defined */
1436static inline u64 read_write_sw(struct hfi1_devdata *dd, u64 *cntr, int mode,
1437 u64 data)
1438{
1439 u64 ret;
1440
1441 if (mode == CNTR_MODE_R) {
1442 ret = *cntr;
1443 } else if (mode == CNTR_MODE_W) {
1444 *cntr = data;
1445 ret = data;
1446 } else {
1447 dd_dev_err(dd, "Invalid cntr sw access mode");
1448 return 0;
1449 }
1450
1451 hfi1_cdbg(CNTR, "val 0x%llx mode %d", ret, mode);
1452
1453 return ret;
1454}
1455
1456static u64 access_sw_link_dn_cnt(const struct cntr_entry *entry, void *context,
1457 int vl, int mode, u64 data)
1458{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1459 struct hfi1_pportdata *ppd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1460
1461 if (vl != CNTR_INVALID_VL)
1462 return 0;
1463 return read_write_sw(ppd->dd, &ppd->link_downed, mode, data);
1464}
1465
1466static u64 access_sw_link_up_cnt(const struct cntr_entry *entry, void *context,
1467 int vl, int mode, u64 data)
1468{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1469 struct hfi1_pportdata *ppd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1470
1471 if (vl != CNTR_INVALID_VL)
1472 return 0;
1473 return read_write_sw(ppd->dd, &ppd->link_up, mode, data);
1474}
1475
Dean Luick6d014532015-12-01 15:38:23 -0500[diff] [blame]1476static u64 access_sw_unknown_frame_cnt(const struct cntr_entry *entry,
1477 void *context, int vl, int mode,
1478 u64 data)
1479{
1480 struct hfi1_pportdata *ppd = (struct hfi1_pportdata *)context;
1481
1482 if (vl != CNTR_INVALID_VL)
1483 return 0;
1484 return read_write_sw(ppd->dd, &ppd->unknown_frame_count, mode, data);
1485}
1486
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1487static u64 access_sw_xmit_discards(const struct cntr_entry *entry,
1488 void *context, int vl, int mode, u64 data)
1489{
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]1490 struct hfi1_pportdata *ppd = (struct hfi1_pportdata *)context;
1491 u64 zero = 0;
1492 u64 *counter;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1493
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]1494 if (vl == CNTR_INVALID_VL)
1495 counter = &ppd->port_xmit_discards;
1496 else if (vl >= 0 && vl < C_VL_COUNT)
1497 counter = &ppd->port_xmit_discards_vl[vl];
1498 else
1499 counter = &zero;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1500
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]1501 return read_write_sw(ppd->dd, counter, mode, data);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1502}
1503
1504static u64 access_xmit_constraint_errs(const struct cntr_entry *entry,
1505 void *context, int vl, int mode, u64 data)
1506{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1507 struct hfi1_pportdata *ppd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1508
1509 if (vl != CNTR_INVALID_VL)
1510 return 0;
1511
1512 return read_write_sw(ppd->dd, &ppd->port_xmit_constraint_errors,
1513 mode, data);
1514}
1515
1516static u64 access_rcv_constraint_errs(const struct cntr_entry *entry,
1517 void *context, int vl, int mode, u64 data)
1518{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1519 struct hfi1_pportdata *ppd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1520
1521 if (vl != CNTR_INVALID_VL)
1522 return 0;
1523
1524 return read_write_sw(ppd->dd, &ppd->port_rcv_constraint_errors,
1525 mode, data);
1526}
1527
1528u64 get_all_cpu_total(u64 __percpu *cntr)
1529{
1530 int cpu;
1531 u64 counter = 0;
1532
1533 for_each_possible_cpu(cpu)
1534 counter += *per_cpu_ptr(cntr, cpu);
1535 return counter;
1536}
1537
1538static u64 read_write_cpu(struct hfi1_devdata *dd, u64 *z_val,
1539 u64 __percpu *cntr,
1540 int vl, int mode, u64 data)
1541{
1542
1543 u64 ret = 0;
1544
1545 if (vl != CNTR_INVALID_VL)
1546 return 0;
1547
1548 if (mode == CNTR_MODE_R) {
1549 ret = get_all_cpu_total(cntr) - *z_val;
1550 } else if (mode == CNTR_MODE_W) {
1551 /* A write can only zero the counter */
1552 if (data == 0)
1553 *z_val = get_all_cpu_total(cntr);
1554 else
1555 dd_dev_err(dd, "Per CPU cntrs can only be zeroed");
1556 } else {
1557 dd_dev_err(dd, "Invalid cntr sw cpu access mode");
1558 return 0;
1559 }
1560
1561 return ret;
1562}
1563
1564static u64 access_sw_cpu_intr(const struct cntr_entry *entry,
1565 void *context, int vl, int mode, u64 data)
1566{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1567 struct hfi1_devdata *dd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1568
1569 return read_write_cpu(dd, &dd->z_int_counter, dd->int_counter, vl,
1570 mode, data);
1571}
1572
1573static u64 access_sw_cpu_rcv_limit(const struct cntr_entry *entry,
1574 void *context, int vl, int mode, u64 data)
1575{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1576 struct hfi1_devdata *dd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1577
1578 return read_write_cpu(dd, &dd->z_rcv_limit, dd->rcv_limit, vl,
1579 mode, data);
1580}
1581
1582static u64 access_sw_pio_wait(const struct cntr_entry *entry,
1583 void *context, int vl, int mode, u64 data)
1584{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1585 struct hfi1_devdata *dd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1586
1587 return dd->verbs_dev.n_piowait;
1588}
1589
1590static u64 access_sw_vtx_wait(const struct cntr_entry *entry,
1591 void *context, int vl, int mode, u64 data)
1592{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1593 struct hfi1_devdata *dd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1594
1595 return dd->verbs_dev.n_txwait;
1596}
1597
1598static u64 access_sw_kmem_wait(const struct cntr_entry *entry,
1599 void *context, int vl, int mode, u64 data)
1600{
Shraddha Barkea787bde2015-10-15 00:58:29 +0530[diff] [blame]1601 struct hfi1_devdata *dd = context;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]1602
1603 return dd->verbs_dev.n_kmem_wait;
1604}
1605
Dean Luickb4219222015-10-26 10:28:35 -0400[diff] [blame]1606static u64 access_sw_send_schedule(const struct cntr_entry *entry,
1607 void *context, int vl, int mode, u64 data)
1608{
1609 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1610
1611 return dd->verbs_dev.n_send_schedule;
1612}
1613
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]1614/* Software counters for the error status bits within MISC_ERR_STATUS */
1615static u64 access_misc_pll_lock_fail_err_cnt(const struct cntr_entry *entry,
1616 void *context, int vl, int mode,
1617 u64 data)
1618{
1619 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1620
1621 return dd->misc_err_status_cnt[12];
1622}
1623
1624static u64 access_misc_mbist_fail_err_cnt(const struct cntr_entry *entry,
1625 void *context, int vl, int mode,
1626 u64 data)
1627{
1628 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1629
1630 return dd->misc_err_status_cnt[11];
1631}
1632
1633static u64 access_misc_invalid_eep_cmd_err_cnt(const struct cntr_entry *entry,
1634 void *context, int vl, int mode,
1635 u64 data)
1636{
1637 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1638
1639 return dd->misc_err_status_cnt[10];
1640}
1641
1642static u64 access_misc_efuse_done_parity_err_cnt(const struct cntr_entry *entry,
1643 void *context, int vl,
1644 int mode, u64 data)
1645{
1646 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1647
1648 return dd->misc_err_status_cnt[9];
1649}
1650
1651static u64 access_misc_efuse_write_err_cnt(const struct cntr_entry *entry,
1652 void *context, int vl, int mode,
1653 u64 data)
1654{
1655 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1656
1657 return dd->misc_err_status_cnt[8];
1658}
1659
1660static u64 access_misc_efuse_read_bad_addr_err_cnt(
1661 const struct cntr_entry *entry,
1662 void *context, int vl, int mode, u64 data)
1663{
1664 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1665
1666 return dd->misc_err_status_cnt[7];
1667}
1668
1669static u64 access_misc_efuse_csr_parity_err_cnt(const struct cntr_entry *entry,
1670 void *context, int vl,
1671 int mode, u64 data)
1672{
1673 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1674
1675 return dd->misc_err_status_cnt[6];
1676}
1677
1678static u64 access_misc_fw_auth_failed_err_cnt(const struct cntr_entry *entry,
1679 void *context, int vl, int mode,
1680 u64 data)
1681{
1682 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1683
1684 return dd->misc_err_status_cnt[5];
1685}
1686
1687static u64 access_misc_key_mismatch_err_cnt(const struct cntr_entry *entry,
1688 void *context, int vl, int mode,
1689 u64 data)
1690{
1691 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1692
1693 return dd->misc_err_status_cnt[4];
1694}
1695
1696static u64 access_misc_sbus_write_failed_err_cnt(const struct cntr_entry *entry,
1697 void *context, int vl,
1698 int mode, u64 data)
1699{
1700 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1701
1702 return dd->misc_err_status_cnt[3];
1703}
1704
1705static u64 access_misc_csr_write_bad_addr_err_cnt(
1706 const struct cntr_entry *entry,
1707 void *context, int vl, int mode, u64 data)
1708{
1709 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1710
1711 return dd->misc_err_status_cnt[2];
1712}
1713
1714static u64 access_misc_csr_read_bad_addr_err_cnt(const struct cntr_entry *entry,
1715 void *context, int vl,
1716 int mode, u64 data)
1717{
1718 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1719
1720 return dd->misc_err_status_cnt[1];
1721}
1722
1723static u64 access_misc_csr_parity_err_cnt(const struct cntr_entry *entry,
1724 void *context, int vl, int mode,
1725 u64 data)
1726{
1727 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1728
1729 return dd->misc_err_status_cnt[0];
1730}
1731
1732/*
1733 * Software counter for the aggregate of
1734 * individual CceErrStatus counters
1735 */
1736static u64 access_sw_cce_err_status_aggregated_cnt(
1737 const struct cntr_entry *entry,
1738 void *context, int vl, int mode, u64 data)
1739{
1740 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1741
1742 return dd->sw_cce_err_status_aggregate;
1743}
1744
1745/*
1746 * Software counters corresponding to each of the
1747 * error status bits within CceErrStatus
1748 */
1749static u64 access_cce_msix_csr_parity_err_cnt(const struct cntr_entry *entry,
1750 void *context, int vl, int mode,
1751 u64 data)
1752{
1753 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1754
1755 return dd->cce_err_status_cnt[40];
1756}
1757
1758static u64 access_cce_int_map_unc_err_cnt(const struct cntr_entry *entry,
1759 void *context, int vl, int mode,
1760 u64 data)
1761{
1762 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1763
1764 return dd->cce_err_status_cnt[39];
1765}
1766
1767static u64 access_cce_int_map_cor_err_cnt(const struct cntr_entry *entry,
1768 void *context, int vl, int mode,
1769 u64 data)
1770{
1771 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1772
1773 return dd->cce_err_status_cnt[38];
1774}
1775
1776static u64 access_cce_msix_table_unc_err_cnt(const struct cntr_entry *entry,
1777 void *context, int vl, int mode,
1778 u64 data)
1779{
1780 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1781
1782 return dd->cce_err_status_cnt[37];
1783}
1784
1785static u64 access_cce_msix_table_cor_err_cnt(const struct cntr_entry *entry,
1786 void *context, int vl, int mode,
1787 u64 data)
1788{
1789 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1790
1791 return dd->cce_err_status_cnt[36];
1792}
1793
1794static u64 access_cce_rxdma_conv_fifo_parity_err_cnt(
1795 const struct cntr_entry *entry,
1796 void *context, int vl, int mode, u64 data)
1797{
1798 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1799
1800 return dd->cce_err_status_cnt[35];
1801}
1802
1803static u64 access_cce_rcpl_async_fifo_parity_err_cnt(
1804 const struct cntr_entry *entry,
1805 void *context, int vl, int mode, u64 data)
1806{
1807 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1808
1809 return dd->cce_err_status_cnt[34];
1810}
1811
1812static u64 access_cce_seg_write_bad_addr_err_cnt(const struct cntr_entry *entry,
1813 void *context, int vl,
1814 int mode, u64 data)
1815{
1816 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1817
1818 return dd->cce_err_status_cnt[33];
1819}
1820
1821static u64 access_cce_seg_read_bad_addr_err_cnt(const struct cntr_entry *entry,
1822 void *context, int vl, int mode,
1823 u64 data)
1824{
1825 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1826
1827 return dd->cce_err_status_cnt[32];
1828}
1829
1830static u64 access_la_triggered_cnt(const struct cntr_entry *entry,
1831 void *context, int vl, int mode, u64 data)
1832{
1833 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1834
1835 return dd->cce_err_status_cnt[31];
1836}
1837
1838static u64 access_cce_trgt_cpl_timeout_err_cnt(const struct cntr_entry *entry,
1839 void *context, int vl, int mode,
1840 u64 data)
1841{
1842 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1843
1844 return dd->cce_err_status_cnt[30];
1845}
1846
1847static u64 access_pcic_receive_parity_err_cnt(const struct cntr_entry *entry,
1848 void *context, int vl, int mode,
1849 u64 data)
1850{
1851 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1852
1853 return dd->cce_err_status_cnt[29];
1854}
1855
1856static u64 access_pcic_transmit_back_parity_err_cnt(
1857 const struct cntr_entry *entry,
1858 void *context, int vl, int mode, u64 data)
1859{
1860 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1861
1862 return dd->cce_err_status_cnt[28];
1863}
1864
1865static u64 access_pcic_transmit_front_parity_err_cnt(
1866 const struct cntr_entry *entry,
1867 void *context, int vl, int mode, u64 data)
1868{
1869 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1870
1871 return dd->cce_err_status_cnt[27];
1872}
1873
1874static u64 access_pcic_cpl_dat_q_unc_err_cnt(const struct cntr_entry *entry,
1875 void *context, int vl, int mode,
1876 u64 data)
1877{
1878 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1879
1880 return dd->cce_err_status_cnt[26];
1881}
1882
1883static u64 access_pcic_cpl_hd_q_unc_err_cnt(const struct cntr_entry *entry,
1884 void *context, int vl, int mode,
1885 u64 data)
1886{
1887 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1888
1889 return dd->cce_err_status_cnt[25];
1890}
1891
1892static u64 access_pcic_post_dat_q_unc_err_cnt(const struct cntr_entry *entry,
1893 void *context, int vl, int mode,
1894 u64 data)
1895{
1896 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1897
1898 return dd->cce_err_status_cnt[24];
1899}
1900
1901static u64 access_pcic_post_hd_q_unc_err_cnt(const struct cntr_entry *entry,
1902 void *context, int vl, int mode,
1903 u64 data)
1904{
1905 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1906
1907 return dd->cce_err_status_cnt[23];
1908}
1909
1910static u64 access_pcic_retry_sot_mem_unc_err_cnt(const struct cntr_entry *entry,
1911 void *context, int vl,
1912 int mode, u64 data)
1913{
1914 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1915
1916 return dd->cce_err_status_cnt[22];
1917}
1918
1919static u64 access_pcic_retry_mem_unc_err(const struct cntr_entry *entry,
1920 void *context, int vl, int mode,
1921 u64 data)
1922{
1923 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1924
1925 return dd->cce_err_status_cnt[21];
1926}
1927
1928static u64 access_pcic_n_post_dat_q_parity_err_cnt(
1929 const struct cntr_entry *entry,
1930 void *context, int vl, int mode, u64 data)
1931{
1932 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1933
1934 return dd->cce_err_status_cnt[20];
1935}
1936
1937static u64 access_pcic_n_post_h_q_parity_err_cnt(const struct cntr_entry *entry,
1938 void *context, int vl,
1939 int mode, u64 data)
1940{
1941 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1942
1943 return dd->cce_err_status_cnt[19];
1944}
1945
1946static u64 access_pcic_cpl_dat_q_cor_err_cnt(const struct cntr_entry *entry,
1947 void *context, int vl, int mode,
1948 u64 data)
1949{
1950 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1951
1952 return dd->cce_err_status_cnt[18];
1953}
1954
1955static u64 access_pcic_cpl_hd_q_cor_err_cnt(const struct cntr_entry *entry,
1956 void *context, int vl, int mode,
1957 u64 data)
1958{
1959 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1960
1961 return dd->cce_err_status_cnt[17];
1962}
1963
1964static u64 access_pcic_post_dat_q_cor_err_cnt(const struct cntr_entry *entry,
1965 void *context, int vl, int mode,
1966 u64 data)
1967{
1968 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1969
1970 return dd->cce_err_status_cnt[16];
1971}
1972
1973static u64 access_pcic_post_hd_q_cor_err_cnt(const struct cntr_entry *entry,
1974 void *context, int vl, int mode,
1975 u64 data)
1976{
1977 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1978
1979 return dd->cce_err_status_cnt[15];
1980}
1981
1982static u64 access_pcic_retry_sot_mem_cor_err_cnt(const struct cntr_entry *entry,
1983 void *context, int vl,
1984 int mode, u64 data)
1985{
1986 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1987
1988 return dd->cce_err_status_cnt[14];
1989}
1990
1991static u64 access_pcic_retry_mem_cor_err_cnt(const struct cntr_entry *entry,
1992 void *context, int vl, int mode,
1993 u64 data)
1994{
1995 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
1996
1997 return dd->cce_err_status_cnt[13];
1998}
1999
2000static u64 access_cce_cli1_async_fifo_dbg_parity_err_cnt(
2001 const struct cntr_entry *entry,
2002 void *context, int vl, int mode, u64 data)
2003{
2004 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2005
2006 return dd->cce_err_status_cnt[12];
2007}
2008
2009static u64 access_cce_cli1_async_fifo_rxdma_parity_err_cnt(
2010 const struct cntr_entry *entry,
2011 void *context, int vl, int mode, u64 data)
2012{
2013 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2014
2015 return dd->cce_err_status_cnt[11];
2016}
2017
2018static u64 access_cce_cli1_async_fifo_sdma_hd_parity_err_cnt(
2019 const struct cntr_entry *entry,
2020 void *context, int vl, int mode, u64 data)
2021{
2022 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2023
2024 return dd->cce_err_status_cnt[10];
2025}
2026
2027static u64 access_cce_cl1_async_fifo_pio_crdt_parity_err_cnt(
2028 const struct cntr_entry *entry,
2029 void *context, int vl, int mode, u64 data)
2030{
2031 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2032
2033 return dd->cce_err_status_cnt[9];
2034}
2035
2036static u64 access_cce_cli2_async_fifo_parity_err_cnt(
2037 const struct cntr_entry *entry,
2038 void *context, int vl, int mode, u64 data)
2039{
2040 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2041
2042 return dd->cce_err_status_cnt[8];
2043}
2044
2045static u64 access_cce_csr_cfg_bus_parity_err_cnt(const struct cntr_entry *entry,
2046 void *context, int vl,
2047 int mode, u64 data)
2048{
2049 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2050
2051 return dd->cce_err_status_cnt[7];
2052}
2053
2054static u64 access_cce_cli0_async_fifo_parity_err_cnt(
2055 const struct cntr_entry *entry,
2056 void *context, int vl, int mode, u64 data)
2057{
2058 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2059
2060 return dd->cce_err_status_cnt[6];
2061}
2062
2063static u64 access_cce_rspd_data_parity_err_cnt(const struct cntr_entry *entry,
2064 void *context, int vl, int mode,
2065 u64 data)
2066{
2067 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2068
2069 return dd->cce_err_status_cnt[5];
2070}
2071
2072static u64 access_cce_trgt_access_err_cnt(const struct cntr_entry *entry,
2073 void *context, int vl, int mode,
2074 u64 data)
2075{
2076 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2077
2078 return dd->cce_err_status_cnt[4];
2079}
2080
2081static u64 access_cce_trgt_async_fifo_parity_err_cnt(
2082 const struct cntr_entry *entry,
2083 void *context, int vl, int mode, u64 data)
2084{
2085 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2086
2087 return dd->cce_err_status_cnt[3];
2088}
2089
2090static u64 access_cce_csr_write_bad_addr_err_cnt(const struct cntr_entry *entry,
2091 void *context, int vl,
2092 int mode, u64 data)
2093{
2094 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2095
2096 return dd->cce_err_status_cnt[2];
2097}
2098
2099static u64 access_cce_csr_read_bad_addr_err_cnt(const struct cntr_entry *entry,
2100 void *context, int vl,
2101 int mode, u64 data)
2102{
2103 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2104
2105 return dd->cce_err_status_cnt[1];
2106}
2107
2108static u64 access_ccs_csr_parity_err_cnt(const struct cntr_entry *entry,
2109 void *context, int vl, int mode,
2110 u64 data)
2111{
2112 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2113
2114 return dd->cce_err_status_cnt[0];
2115}
2116
2117/*
2118 * Software counters corresponding to each of the
2119 * error status bits within RcvErrStatus
2120 */
2121static u64 access_rx_csr_parity_err_cnt(const struct cntr_entry *entry,
2122 void *context, int vl, int mode,
2123 u64 data)
2124{
2125 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2126
2127 return dd->rcv_err_status_cnt[63];
2128}
2129
2130static u64 access_rx_csr_write_bad_addr_err_cnt(const struct cntr_entry *entry,
2131 void *context, int vl,
2132 int mode, u64 data)
2133{
2134 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2135
2136 return dd->rcv_err_status_cnt[62];
2137}
2138
2139static u64 access_rx_csr_read_bad_addr_err_cnt(const struct cntr_entry *entry,
2140 void *context, int vl, int mode,
2141 u64 data)
2142{
2143 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2144
2145 return dd->rcv_err_status_cnt[61];
2146}
2147
2148static u64 access_rx_dma_csr_unc_err_cnt(const struct cntr_entry *entry,
2149 void *context, int vl, int mode,
2150 u64 data)
2151{
2152 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2153
2154 return dd->rcv_err_status_cnt[60];
2155}
2156
2157static u64 access_rx_dma_dq_fsm_encoding_err_cnt(const struct cntr_entry *entry,
2158 void *context, int vl,
2159 int mode, u64 data)
2160{
2161 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2162
2163 return dd->rcv_err_status_cnt[59];
2164}
2165
2166static u64 access_rx_dma_eq_fsm_encoding_err_cnt(const struct cntr_entry *entry,
2167 void *context, int vl,
2168 int mode, u64 data)
2169{
2170 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2171
2172 return dd->rcv_err_status_cnt[58];
2173}
2174
2175static u64 access_rx_dma_csr_parity_err_cnt(const struct cntr_entry *entry,
2176 void *context, int vl, int mode,
2177 u64 data)
2178{
2179 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2180
2181 return dd->rcv_err_status_cnt[57];
2182}
2183
2184static u64 access_rx_rbuf_data_cor_err_cnt(const struct cntr_entry *entry,
2185 void *context, int vl, int mode,
2186 u64 data)
2187{
2188 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2189
2190 return dd->rcv_err_status_cnt[56];
2191}
2192
2193static u64 access_rx_rbuf_data_unc_err_cnt(const struct cntr_entry *entry,
2194 void *context, int vl, int mode,
2195 u64 data)
2196{
2197 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2198
2199 return dd->rcv_err_status_cnt[55];
2200}
2201
2202static u64 access_rx_dma_data_fifo_rd_cor_err_cnt(
2203 const struct cntr_entry *entry,
2204 void *context, int vl, int mode, u64 data)
2205{
2206 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2207
2208 return dd->rcv_err_status_cnt[54];
2209}
2210
2211static u64 access_rx_dma_data_fifo_rd_unc_err_cnt(
2212 const struct cntr_entry *entry,
2213 void *context, int vl, int mode, u64 data)
2214{
2215 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2216
2217 return dd->rcv_err_status_cnt[53];
2218}
2219
2220static u64 access_rx_dma_hdr_fifo_rd_cor_err_cnt(const struct cntr_entry *entry,
2221 void *context, int vl,
2222 int mode, u64 data)
2223{
2224 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2225
2226 return dd->rcv_err_status_cnt[52];
2227}
2228
2229static u64 access_rx_dma_hdr_fifo_rd_unc_err_cnt(const struct cntr_entry *entry,
2230 void *context, int vl,
2231 int mode, u64 data)
2232{
2233 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2234
2235 return dd->rcv_err_status_cnt[51];
2236}
2237
2238static u64 access_rx_rbuf_desc_part2_cor_err_cnt(const struct cntr_entry *entry,
2239 void *context, int vl,
2240 int mode, u64 data)
2241{
2242 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2243
2244 return dd->rcv_err_status_cnt[50];
2245}
2246
2247static u64 access_rx_rbuf_desc_part2_unc_err_cnt(const struct cntr_entry *entry,
2248 void *context, int vl,
2249 int mode, u64 data)
2250{
2251 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2252
2253 return dd->rcv_err_status_cnt[49];
2254}
2255
2256static u64 access_rx_rbuf_desc_part1_cor_err_cnt(const struct cntr_entry *entry,
2257 void *context, int vl,
2258 int mode, u64 data)
2259{
2260 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2261
2262 return dd->rcv_err_status_cnt[48];
2263}
2264
2265static u64 access_rx_rbuf_desc_part1_unc_err_cnt(const struct cntr_entry *entry,
2266 void *context, int vl,
2267 int mode, u64 data)
2268{
2269 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2270
2271 return dd->rcv_err_status_cnt[47];
2272}
2273
2274static u64 access_rx_hq_intr_fsm_err_cnt(const struct cntr_entry *entry,
2275 void *context, int vl, int mode,
2276 u64 data)
2277{
2278 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2279
2280 return dd->rcv_err_status_cnt[46];
2281}
2282
2283static u64 access_rx_hq_intr_csr_parity_err_cnt(
2284 const struct cntr_entry *entry,
2285 void *context, int vl, int mode, u64 data)
2286{
2287 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2288
2289 return dd->rcv_err_status_cnt[45];
2290}
2291
2292static u64 access_rx_lookup_csr_parity_err_cnt(
2293 const struct cntr_entry *entry,
2294 void *context, int vl, int mode, u64 data)
2295{
2296 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2297
2298 return dd->rcv_err_status_cnt[44];
2299}
2300
2301static u64 access_rx_lookup_rcv_array_cor_err_cnt(
2302 const struct cntr_entry *entry,
2303 void *context, int vl, int mode, u64 data)
2304{
2305 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2306
2307 return dd->rcv_err_status_cnt[43];
2308}
2309
2310static u64 access_rx_lookup_rcv_array_unc_err_cnt(
2311 const struct cntr_entry *entry,
2312 void *context, int vl, int mode, u64 data)
2313{
2314 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2315
2316 return dd->rcv_err_status_cnt[42];
2317}
2318
2319static u64 access_rx_lookup_des_part2_parity_err_cnt(
2320 const struct cntr_entry *entry,
2321 void *context, int vl, int mode, u64 data)
2322{
2323 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2324
2325 return dd->rcv_err_status_cnt[41];
2326}
2327
2328static u64 access_rx_lookup_des_part1_unc_cor_err_cnt(
2329 const struct cntr_entry *entry,
2330 void *context, int vl, int mode, u64 data)
2331{
2332 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2333
2334 return dd->rcv_err_status_cnt[40];
2335}
2336
2337static u64 access_rx_lookup_des_part1_unc_err_cnt(
2338 const struct cntr_entry *entry,
2339 void *context, int vl, int mode, u64 data)
2340{
2341 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2342
2343 return dd->rcv_err_status_cnt[39];
2344}
2345
2346static u64 access_rx_rbuf_next_free_buf_cor_err_cnt(
2347 const struct cntr_entry *entry,
2348 void *context, int vl, int mode, u64 data)
2349{
2350 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2351
2352 return dd->rcv_err_status_cnt[38];
2353}
2354
2355static u64 access_rx_rbuf_next_free_buf_unc_err_cnt(
2356 const struct cntr_entry *entry,
2357 void *context, int vl, int mode, u64 data)
2358{
2359 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2360
2361 return dd->rcv_err_status_cnt[37];
2362}
2363
2364static u64 access_rbuf_fl_init_wr_addr_parity_err_cnt(
2365 const struct cntr_entry *entry,
2366 void *context, int vl, int mode, u64 data)
2367{
2368 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2369
2370 return dd->rcv_err_status_cnt[36];
2371}
2372
2373static u64 access_rx_rbuf_fl_initdone_parity_err_cnt(
2374 const struct cntr_entry *entry,
2375 void *context, int vl, int mode, u64 data)
2376{
2377 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2378
2379 return dd->rcv_err_status_cnt[35];
2380}
2381
2382static u64 access_rx_rbuf_fl_write_addr_parity_err_cnt(
2383 const struct cntr_entry *entry,
2384 void *context, int vl, int mode, u64 data)
2385{
2386 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2387
2388 return dd->rcv_err_status_cnt[34];
2389}
2390
2391static u64 access_rx_rbuf_fl_rd_addr_parity_err_cnt(
2392 const struct cntr_entry *entry,
2393 void *context, int vl, int mode, u64 data)
2394{
2395 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2396
2397 return dd->rcv_err_status_cnt[33];
2398}
2399
2400static u64 access_rx_rbuf_empty_err_cnt(const struct cntr_entry *entry,
2401 void *context, int vl, int mode,
2402 u64 data)
2403{
2404 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2405
2406 return dd->rcv_err_status_cnt[32];
2407}
2408
2409static u64 access_rx_rbuf_full_err_cnt(const struct cntr_entry *entry,
2410 void *context, int vl, int mode,
2411 u64 data)
2412{
2413 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2414
2415 return dd->rcv_err_status_cnt[31];
2416}
2417
2418static u64 access_rbuf_bad_lookup_err_cnt(const struct cntr_entry *entry,
2419 void *context, int vl, int mode,
2420 u64 data)
2421{
2422 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2423
2424 return dd->rcv_err_status_cnt[30];
2425}
2426
2427static u64 access_rbuf_ctx_id_parity_err_cnt(const struct cntr_entry *entry,
2428 void *context, int vl, int mode,
2429 u64 data)
2430{
2431 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2432
2433 return dd->rcv_err_status_cnt[29];
2434}
2435
2436static u64 access_rbuf_csr_qeopdw_parity_err_cnt(const struct cntr_entry *entry,
2437 void *context, int vl,
2438 int mode, u64 data)
2439{
2440 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2441
2442 return dd->rcv_err_status_cnt[28];
2443}
2444
2445static u64 access_rx_rbuf_csr_q_num_of_pkt_parity_err_cnt(
2446 const struct cntr_entry *entry,
2447 void *context, int vl, int mode, u64 data)
2448{
2449 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2450
2451 return dd->rcv_err_status_cnt[27];
2452}
2453
2454static u64 access_rx_rbuf_csr_q_t1_ptr_parity_err_cnt(
2455 const struct cntr_entry *entry,
2456 void *context, int vl, int mode, u64 data)
2457{
2458 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2459
2460 return dd->rcv_err_status_cnt[26];
2461}
2462
2463static u64 access_rx_rbuf_csr_q_hd_ptr_parity_err_cnt(
2464 const struct cntr_entry *entry,
2465 void *context, int vl, int mode, u64 data)
2466{
2467 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2468
2469 return dd->rcv_err_status_cnt[25];
2470}
2471
2472static u64 access_rx_rbuf_csr_q_vld_bit_parity_err_cnt(
2473 const struct cntr_entry *entry,
2474 void *context, int vl, int mode, u64 data)
2475{
2476 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2477
2478 return dd->rcv_err_status_cnt[24];
2479}
2480
2481static u64 access_rx_rbuf_csr_q_next_buf_parity_err_cnt(
2482 const struct cntr_entry *entry,
2483 void *context, int vl, int mode, u64 data)
2484{
2485 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2486
2487 return dd->rcv_err_status_cnt[23];
2488}
2489
2490static u64 access_rx_rbuf_csr_q_ent_cnt_parity_err_cnt(
2491 const struct cntr_entry *entry,
2492 void *context, int vl, int mode, u64 data)
2493{
2494 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2495
2496 return dd->rcv_err_status_cnt[22];
2497}
2498
2499static u64 access_rx_rbuf_csr_q_head_buf_num_parity_err_cnt(
2500 const struct cntr_entry *entry,
2501 void *context, int vl, int mode, u64 data)
2502{
2503 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2504
2505 return dd->rcv_err_status_cnt[21];
2506}
2507
2508static u64 access_rx_rbuf_block_list_read_cor_err_cnt(
2509 const struct cntr_entry *entry,
2510 void *context, int vl, int mode, u64 data)
2511{
2512 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2513
2514 return dd->rcv_err_status_cnt[20];
2515}
2516
2517static u64 access_rx_rbuf_block_list_read_unc_err_cnt(
2518 const struct cntr_entry *entry,
2519 void *context, int vl, int mode, u64 data)
2520{
2521 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2522
2523 return dd->rcv_err_status_cnt[19];
2524}
2525
2526static u64 access_rx_rbuf_lookup_des_cor_err_cnt(const struct cntr_entry *entry,
2527 void *context, int vl,
2528 int mode, u64 data)
2529{
2530 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2531
2532 return dd->rcv_err_status_cnt[18];
2533}
2534
2535static u64 access_rx_rbuf_lookup_des_unc_err_cnt(const struct cntr_entry *entry,
2536 void *context, int vl,
2537 int mode, u64 data)
2538{
2539 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2540
2541 return dd->rcv_err_status_cnt[17];
2542}
2543
2544static u64 access_rx_rbuf_lookup_des_reg_unc_cor_err_cnt(
2545 const struct cntr_entry *entry,
2546 void *context, int vl, int mode, u64 data)
2547{
2548 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2549
2550 return dd->rcv_err_status_cnt[16];
2551}
2552
2553static u64 access_rx_rbuf_lookup_des_reg_unc_err_cnt(
2554 const struct cntr_entry *entry,
2555 void *context, int vl, int mode, u64 data)
2556{
2557 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2558
2559 return dd->rcv_err_status_cnt[15];
2560}
2561
2562static u64 access_rx_rbuf_free_list_cor_err_cnt(const struct cntr_entry *entry,
2563 void *context, int vl,
2564 int mode, u64 data)
2565{
2566 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2567
2568 return dd->rcv_err_status_cnt[14];
2569}
2570
2571static u64 access_rx_rbuf_free_list_unc_err_cnt(const struct cntr_entry *entry,
2572 void *context, int vl,
2573 int mode, u64 data)
2574{
2575 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2576
2577 return dd->rcv_err_status_cnt[13];
2578}
2579
2580static u64 access_rx_rcv_fsm_encoding_err_cnt(const struct cntr_entry *entry,
2581 void *context, int vl, int mode,
2582 u64 data)
2583{
2584 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2585
2586 return dd->rcv_err_status_cnt[12];
2587}
2588
2589static u64 access_rx_dma_flag_cor_err_cnt(const struct cntr_entry *entry,
2590 void *context, int vl, int mode,
2591 u64 data)
2592{
2593 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2594
2595 return dd->rcv_err_status_cnt[11];
2596}
2597
2598static u64 access_rx_dma_flag_unc_err_cnt(const struct cntr_entry *entry,
2599 void *context, int vl, int mode,
2600 u64 data)
2601{
2602 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2603
2604 return dd->rcv_err_status_cnt[10];
2605}
2606
2607static u64 access_rx_dc_sop_eop_parity_err_cnt(const struct cntr_entry *entry,
2608 void *context, int vl, int mode,
2609 u64 data)
2610{
2611 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2612
2613 return dd->rcv_err_status_cnt[9];
2614}
2615
2616static u64 access_rx_rcv_csr_parity_err_cnt(const struct cntr_entry *entry,
2617 void *context, int vl, int mode,
2618 u64 data)
2619{
2620 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2621
2622 return dd->rcv_err_status_cnt[8];
2623}
2624
2625static u64 access_rx_rcv_qp_map_table_cor_err_cnt(
2626 const struct cntr_entry *entry,
2627 void *context, int vl, int mode, u64 data)
2628{
2629 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2630
2631 return dd->rcv_err_status_cnt[7];
2632}
2633
2634static u64 access_rx_rcv_qp_map_table_unc_err_cnt(
2635 const struct cntr_entry *entry,
2636 void *context, int vl, int mode, u64 data)
2637{
2638 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2639
2640 return dd->rcv_err_status_cnt[6];
2641}
2642
2643static u64 access_rx_rcv_data_cor_err_cnt(const struct cntr_entry *entry,
2644 void *context, int vl, int mode,
2645 u64 data)
2646{
2647 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2648
2649 return dd->rcv_err_status_cnt[5];
2650}
2651
2652static u64 access_rx_rcv_data_unc_err_cnt(const struct cntr_entry *entry,
2653 void *context, int vl, int mode,
2654 u64 data)
2655{
2656 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2657
2658 return dd->rcv_err_status_cnt[4];
2659}
2660
2661static u64 access_rx_rcv_hdr_cor_err_cnt(const struct cntr_entry *entry,
2662 void *context, int vl, int mode,
2663 u64 data)
2664{
2665 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2666
2667 return dd->rcv_err_status_cnt[3];
2668}
2669
2670static u64 access_rx_rcv_hdr_unc_err_cnt(const struct cntr_entry *entry,
2671 void *context, int vl, int mode,
2672 u64 data)
2673{
2674 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2675
2676 return dd->rcv_err_status_cnt[2];
2677}
2678
2679static u64 access_rx_dc_intf_parity_err_cnt(const struct cntr_entry *entry,
2680 void *context, int vl, int mode,
2681 u64 data)
2682{
2683 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2684
2685 return dd->rcv_err_status_cnt[1];
2686}
2687
2688static u64 access_rx_dma_csr_cor_err_cnt(const struct cntr_entry *entry,
2689 void *context, int vl, int mode,
2690 u64 data)
2691{
2692 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2693
2694 return dd->rcv_err_status_cnt[0];
2695}
2696
2697/*
2698 * Software counters corresponding to each of the
2699 * error status bits within SendPioErrStatus
2700 */
2701static u64 access_pio_pec_sop_head_parity_err_cnt(
2702 const struct cntr_entry *entry,
2703 void *context, int vl, int mode, u64 data)
2704{
2705 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2706
2707 return dd->send_pio_err_status_cnt[35];
2708}
2709
2710static u64 access_pio_pcc_sop_head_parity_err_cnt(
2711 const struct cntr_entry *entry,
2712 void *context, int vl, int mode, u64 data)
2713{
2714 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2715
2716 return dd->send_pio_err_status_cnt[34];
2717}
2718
2719static u64 access_pio_last_returned_cnt_parity_err_cnt(
2720 const struct cntr_entry *entry,
2721 void *context, int vl, int mode, u64 data)
2722{
2723 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2724
2725 return dd->send_pio_err_status_cnt[33];
2726}
2727
2728static u64 access_pio_current_free_cnt_parity_err_cnt(
2729 const struct cntr_entry *entry,
2730 void *context, int vl, int mode, u64 data)
2731{
2732 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2733
2734 return dd->send_pio_err_status_cnt[32];
2735}
2736
2737static u64 access_pio_reserved_31_err_cnt(const struct cntr_entry *entry,
2738 void *context, int vl, int mode,
2739 u64 data)
2740{
2741 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2742
2743 return dd->send_pio_err_status_cnt[31];
2744}
2745
2746static u64 access_pio_reserved_30_err_cnt(const struct cntr_entry *entry,
2747 void *context, int vl, int mode,
2748 u64 data)
2749{
2750 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2751
2752 return dd->send_pio_err_status_cnt[30];
2753}
2754
2755static u64 access_pio_ppmc_sop_len_err_cnt(const struct cntr_entry *entry,
2756 void *context, int vl, int mode,
2757 u64 data)
2758{
2759 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2760
2761 return dd->send_pio_err_status_cnt[29];
2762}
2763
2764static u64 access_pio_ppmc_bqc_mem_parity_err_cnt(
2765 const struct cntr_entry *entry,
2766 void *context, int vl, int mode, u64 data)
2767{
2768 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2769
2770 return dd->send_pio_err_status_cnt[28];
2771}
2772
2773static u64 access_pio_vl_fifo_parity_err_cnt(const struct cntr_entry *entry,
2774 void *context, int vl, int mode,
2775 u64 data)
2776{
2777 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2778
2779 return dd->send_pio_err_status_cnt[27];
2780}
2781
2782static u64 access_pio_vlf_sop_parity_err_cnt(const struct cntr_entry *entry,
2783 void *context, int vl, int mode,
2784 u64 data)
2785{
2786 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2787
2788 return dd->send_pio_err_status_cnt[26];
2789}
2790
2791static u64 access_pio_vlf_v1_len_parity_err_cnt(const struct cntr_entry *entry,
2792 void *context, int vl,
2793 int mode, u64 data)
2794{
2795 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2796
2797 return dd->send_pio_err_status_cnt[25];
2798}
2799
2800static u64 access_pio_block_qw_count_parity_err_cnt(
2801 const struct cntr_entry *entry,
2802 void *context, int vl, int mode, u64 data)
2803{
2804 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2805
2806 return dd->send_pio_err_status_cnt[24];
2807}
2808
2809static u64 access_pio_write_qw_valid_parity_err_cnt(
2810 const struct cntr_entry *entry,
2811 void *context, int vl, int mode, u64 data)
2812{
2813 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2814
2815 return dd->send_pio_err_status_cnt[23];
2816}
2817
2818static u64 access_pio_state_machine_err_cnt(const struct cntr_entry *entry,
2819 void *context, int vl, int mode,
2820 u64 data)
2821{
2822 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2823
2824 return dd->send_pio_err_status_cnt[22];
2825}
2826
2827static u64 access_pio_write_data_parity_err_cnt(const struct cntr_entry *entry,
2828 void *context, int vl,
2829 int mode, u64 data)
2830{
2831 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2832
2833 return dd->send_pio_err_status_cnt[21];
2834}
2835
2836static u64 access_pio_host_addr_mem_cor_err_cnt(const struct cntr_entry *entry,
2837 void *context, int vl,
2838 int mode, u64 data)
2839{
2840 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2841
2842 return dd->send_pio_err_status_cnt[20];
2843}
2844
2845static u64 access_pio_host_addr_mem_unc_err_cnt(const struct cntr_entry *entry,
2846 void *context, int vl,
2847 int mode, u64 data)
2848{
2849 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2850
2851 return dd->send_pio_err_status_cnt[19];
2852}
2853
2854static u64 access_pio_pkt_evict_sm_or_arb_sm_err_cnt(
2855 const struct cntr_entry *entry,
2856 void *context, int vl, int mode, u64 data)
2857{
2858 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2859
2860 return dd->send_pio_err_status_cnt[18];
2861}
2862
2863static u64 access_pio_init_sm_in_err_cnt(const struct cntr_entry *entry,
2864 void *context, int vl, int mode,
2865 u64 data)
2866{
2867 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2868
2869 return dd->send_pio_err_status_cnt[17];
2870}
2871
2872static u64 access_pio_ppmc_pbl_fifo_err_cnt(const struct cntr_entry *entry,
2873 void *context, int vl, int mode,
2874 u64 data)
2875{
2876 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2877
2878 return dd->send_pio_err_status_cnt[16];
2879}
2880
2881static u64 access_pio_credit_ret_fifo_parity_err_cnt(
2882 const struct cntr_entry *entry,
2883 void *context, int vl, int mode, u64 data)
2884{
2885 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2886
2887 return dd->send_pio_err_status_cnt[15];
2888}
2889
2890static u64 access_pio_v1_len_mem_bank1_cor_err_cnt(
2891 const struct cntr_entry *entry,
2892 void *context, int vl, int mode, u64 data)
2893{
2894 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2895
2896 return dd->send_pio_err_status_cnt[14];
2897}
2898
2899static u64 access_pio_v1_len_mem_bank0_cor_err_cnt(
2900 const struct cntr_entry *entry,
2901 void *context, int vl, int mode, u64 data)
2902{
2903 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2904
2905 return dd->send_pio_err_status_cnt[13];
2906}
2907
2908static u64 access_pio_v1_len_mem_bank1_unc_err_cnt(
2909 const struct cntr_entry *entry,
2910 void *context, int vl, int mode, u64 data)
2911{
2912 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2913
2914 return dd->send_pio_err_status_cnt[12];
2915}
2916
2917static u64 access_pio_v1_len_mem_bank0_unc_err_cnt(
2918 const struct cntr_entry *entry,
2919 void *context, int vl, int mode, u64 data)
2920{
2921 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2922
2923 return dd->send_pio_err_status_cnt[11];
2924}
2925
2926static u64 access_pio_sm_pkt_reset_parity_err_cnt(
2927 const struct cntr_entry *entry,
2928 void *context, int vl, int mode, u64 data)
2929{
2930 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2931
2932 return dd->send_pio_err_status_cnt[10];
2933}
2934
2935static u64 access_pio_pkt_evict_fifo_parity_err_cnt(
2936 const struct cntr_entry *entry,
2937 void *context, int vl, int mode, u64 data)
2938{
2939 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2940
2941 return dd->send_pio_err_status_cnt[9];
2942}
2943
2944static u64 access_pio_sbrdctrl_crrel_fifo_parity_err_cnt(
2945 const struct cntr_entry *entry,
2946 void *context, int vl, int mode, u64 data)
2947{
2948 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2949
2950 return dd->send_pio_err_status_cnt[8];
2951}
2952
2953static u64 access_pio_sbrdctl_crrel_parity_err_cnt(
2954 const struct cntr_entry *entry,
2955 void *context, int vl, int mode, u64 data)
2956{
2957 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2958
2959 return dd->send_pio_err_status_cnt[7];
2960}
2961
2962static u64 access_pio_pec_fifo_parity_err_cnt(const struct cntr_entry *entry,
2963 void *context, int vl, int mode,
2964 u64 data)
2965{
2966 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2967
2968 return dd->send_pio_err_status_cnt[6];
2969}
2970
2971static u64 access_pio_pcc_fifo_parity_err_cnt(const struct cntr_entry *entry,
2972 void *context, int vl, int mode,
2973 u64 data)
2974{
2975 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2976
2977 return dd->send_pio_err_status_cnt[5];
2978}
2979
2980static u64 access_pio_sb_mem_fifo1_err_cnt(const struct cntr_entry *entry,
2981 void *context, int vl, int mode,
2982 u64 data)
2983{
2984 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2985
2986 return dd->send_pio_err_status_cnt[4];
2987}
2988
2989static u64 access_pio_sb_mem_fifo0_err_cnt(const struct cntr_entry *entry,
2990 void *context, int vl, int mode,
2991 u64 data)
2992{
2993 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
2994
2995 return dd->send_pio_err_status_cnt[3];
2996}
2997
2998static u64 access_pio_csr_parity_err_cnt(const struct cntr_entry *entry,
2999 void *context, int vl, int mode,
3000 u64 data)
3001{
3002 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3003
3004 return dd->send_pio_err_status_cnt[2];
3005}
3006
3007static u64 access_pio_write_addr_parity_err_cnt(const struct cntr_entry *entry,
3008 void *context, int vl,
3009 int mode, u64 data)
3010{
3011 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3012
3013 return dd->send_pio_err_status_cnt[1];
3014}
3015
3016static u64 access_pio_write_bad_ctxt_err_cnt(const struct cntr_entry *entry,
3017 void *context, int vl, int mode,
3018 u64 data)
3019{
3020 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3021
3022 return dd->send_pio_err_status_cnt[0];
3023}
3024
3025/*
3026 * Software counters corresponding to each of the
3027 * error status bits within SendDmaErrStatus
3028 */
3029static u64 access_sdma_pcie_req_tracking_cor_err_cnt(
3030 const struct cntr_entry *entry,
3031 void *context, int vl, int mode, u64 data)
3032{
3033 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3034
3035 return dd->send_dma_err_status_cnt[3];
3036}
3037
3038static u64 access_sdma_pcie_req_tracking_unc_err_cnt(
3039 const struct cntr_entry *entry,
3040 void *context, int vl, int mode, u64 data)
3041{
3042 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3043
3044 return dd->send_dma_err_status_cnt[2];
3045}
3046
3047static u64 access_sdma_csr_parity_err_cnt(const struct cntr_entry *entry,
3048 void *context, int vl, int mode,
3049 u64 data)
3050{
3051 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3052
3053 return dd->send_dma_err_status_cnt[1];
3054}
3055
3056static u64 access_sdma_rpy_tag_err_cnt(const struct cntr_entry *entry,
3057 void *context, int vl, int mode,
3058 u64 data)
3059{
3060 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3061
3062 return dd->send_dma_err_status_cnt[0];
3063}
3064
3065/*
3066 * Software counters corresponding to each of the
3067 * error status bits within SendEgressErrStatus
3068 */
3069static u64 access_tx_read_pio_memory_csr_unc_err_cnt(
3070 const struct cntr_entry *entry,
3071 void *context, int vl, int mode, u64 data)
3072{
3073 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3074
3075 return dd->send_egress_err_status_cnt[63];
3076}
3077
3078static u64 access_tx_read_sdma_memory_csr_err_cnt(
3079 const struct cntr_entry *entry,
3080 void *context, int vl, int mode, u64 data)
3081{
3082 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3083
3084 return dd->send_egress_err_status_cnt[62];
3085}
3086
3087static u64 access_tx_egress_fifo_cor_err_cnt(const struct cntr_entry *entry,
3088 void *context, int vl, int mode,
3089 u64 data)
3090{
3091 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3092
3093 return dd->send_egress_err_status_cnt[61];
3094}
3095
3096static u64 access_tx_read_pio_memory_cor_err_cnt(const struct cntr_entry *entry,
3097 void *context, int vl,
3098 int mode, u64 data)
3099{
3100 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3101
3102 return dd->send_egress_err_status_cnt[60];
3103}
3104
3105static u64 access_tx_read_sdma_memory_cor_err_cnt(
3106 const struct cntr_entry *entry,
3107 void *context, int vl, int mode, u64 data)
3108{
3109 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3110
3111 return dd->send_egress_err_status_cnt[59];
3112}
3113
3114static u64 access_tx_sb_hdr_cor_err_cnt(const struct cntr_entry *entry,
3115 void *context, int vl, int mode,
3116 u64 data)
3117{
3118 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3119
3120 return dd->send_egress_err_status_cnt[58];
3121}
3122
3123static u64 access_tx_credit_overrun_err_cnt(const struct cntr_entry *entry,
3124 void *context, int vl, int mode,
3125 u64 data)
3126{
3127 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3128
3129 return dd->send_egress_err_status_cnt[57];
3130}
3131
3132static u64 access_tx_launch_fifo8_cor_err_cnt(const struct cntr_entry *entry,
3133 void *context, int vl, int mode,
3134 u64 data)
3135{
3136 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3137
3138 return dd->send_egress_err_status_cnt[56];
3139}
3140
3141static u64 access_tx_launch_fifo7_cor_err_cnt(const struct cntr_entry *entry,
3142 void *context, int vl, int mode,
3143 u64 data)
3144{
3145 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3146
3147 return dd->send_egress_err_status_cnt[55];
3148}
3149
3150static u64 access_tx_launch_fifo6_cor_err_cnt(const struct cntr_entry *entry,
3151 void *context, int vl, int mode,
3152 u64 data)
3153{
3154 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3155
3156 return dd->send_egress_err_status_cnt[54];
3157}
3158
3159static u64 access_tx_launch_fifo5_cor_err_cnt(const struct cntr_entry *entry,
3160 void *context, int vl, int mode,
3161 u64 data)
3162{
3163 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3164
3165 return dd->send_egress_err_status_cnt[53];
3166}
3167
3168static u64 access_tx_launch_fifo4_cor_err_cnt(const struct cntr_entry *entry,
3169 void *context, int vl, int mode,
3170 u64 data)
3171{
3172 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3173
3174 return dd->send_egress_err_status_cnt[52];
3175}
3176
3177static u64 access_tx_launch_fifo3_cor_err_cnt(const struct cntr_entry *entry,
3178 void *context, int vl, int mode,
3179 u64 data)
3180{
3181 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3182
3183 return dd->send_egress_err_status_cnt[51];
3184}
3185
3186static u64 access_tx_launch_fifo2_cor_err_cnt(const struct cntr_entry *entry,
3187 void *context, int vl, int mode,
3188 u64 data)
3189{
3190 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3191
3192 return dd->send_egress_err_status_cnt[50];
3193}
3194
3195static u64 access_tx_launch_fifo1_cor_err_cnt(const struct cntr_entry *entry,
3196 void *context, int vl, int mode,
3197 u64 data)
3198{
3199 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3200
3201 return dd->send_egress_err_status_cnt[49];
3202}
3203
3204static u64 access_tx_launch_fifo0_cor_err_cnt(const struct cntr_entry *entry,
3205 void *context, int vl, int mode,
3206 u64 data)
3207{
3208 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3209
3210 return dd->send_egress_err_status_cnt[48];
3211}
3212
3213static u64 access_tx_credit_return_vl_err_cnt(const struct cntr_entry *entry,
3214 void *context, int vl, int mode,
3215 u64 data)
3216{
3217 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3218
3219 return dd->send_egress_err_status_cnt[47];
3220}
3221
3222static u64 access_tx_hcrc_insertion_err_cnt(const struct cntr_entry *entry,
3223 void *context, int vl, int mode,
3224 u64 data)
3225{
3226 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3227
3228 return dd->send_egress_err_status_cnt[46];
3229}
3230
3231static u64 access_tx_egress_fifo_unc_err_cnt(const struct cntr_entry *entry,
3232 void *context, int vl, int mode,
3233 u64 data)
3234{
3235 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3236
3237 return dd->send_egress_err_status_cnt[45];
3238}
3239
3240static u64 access_tx_read_pio_memory_unc_err_cnt(const struct cntr_entry *entry,
3241 void *context, int vl,
3242 int mode, u64 data)
3243{
3244 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3245
3246 return dd->send_egress_err_status_cnt[44];
3247}
3248
3249static u64 access_tx_read_sdma_memory_unc_err_cnt(
3250 const struct cntr_entry *entry,
3251 void *context, int vl, int mode, u64 data)
3252{
3253 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3254
3255 return dd->send_egress_err_status_cnt[43];
3256}
3257
3258static u64 access_tx_sb_hdr_unc_err_cnt(const struct cntr_entry *entry,
3259 void *context, int vl, int mode,
3260 u64 data)
3261{
3262 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3263
3264 return dd->send_egress_err_status_cnt[42];
3265}
3266
3267static u64 access_tx_credit_return_partiy_err_cnt(
3268 const struct cntr_entry *entry,
3269 void *context, int vl, int mode, u64 data)
3270{
3271 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3272
3273 return dd->send_egress_err_status_cnt[41];
3274}
3275
3276static u64 access_tx_launch_fifo8_unc_or_parity_err_cnt(
3277 const struct cntr_entry *entry,
3278 void *context, int vl, int mode, u64 data)
3279{
3280 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3281
3282 return dd->send_egress_err_status_cnt[40];
3283}
3284
3285static u64 access_tx_launch_fifo7_unc_or_parity_err_cnt(
3286 const struct cntr_entry *entry,
3287 void *context, int vl, int mode, u64 data)
3288{
3289 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3290
3291 return dd->send_egress_err_status_cnt[39];
3292}
3293
3294static u64 access_tx_launch_fifo6_unc_or_parity_err_cnt(
3295 const struct cntr_entry *entry,
3296 void *context, int vl, int mode, u64 data)
3297{
3298 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3299
3300 return dd->send_egress_err_status_cnt[38];
3301}
3302
3303static u64 access_tx_launch_fifo5_unc_or_parity_err_cnt(
3304 const struct cntr_entry *entry,
3305 void *context, int vl, int mode, u64 data)
3306{
3307 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3308
3309 return dd->send_egress_err_status_cnt[37];
3310}
3311
3312static u64 access_tx_launch_fifo4_unc_or_parity_err_cnt(
3313 const struct cntr_entry *entry,
3314 void *context, int vl, int mode, u64 data)
3315{
3316 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3317
3318 return dd->send_egress_err_status_cnt[36];
3319}
3320
3321static u64 access_tx_launch_fifo3_unc_or_parity_err_cnt(
3322 const struct cntr_entry *entry,
3323 void *context, int vl, int mode, u64 data)
3324{
3325 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3326
3327 return dd->send_egress_err_status_cnt[35];
3328}
3329
3330static u64 access_tx_launch_fifo2_unc_or_parity_err_cnt(
3331 const struct cntr_entry *entry,
3332 void *context, int vl, int mode, u64 data)
3333{
3334 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3335
3336 return dd->send_egress_err_status_cnt[34];
3337}
3338
3339static u64 access_tx_launch_fifo1_unc_or_parity_err_cnt(
3340 const struct cntr_entry *entry,
3341 void *context, int vl, int mode, u64 data)
3342{
3343 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3344
3345 return dd->send_egress_err_status_cnt[33];
3346}
3347
3348static u64 access_tx_launch_fifo0_unc_or_parity_err_cnt(
3349 const struct cntr_entry *entry,
3350 void *context, int vl, int mode, u64 data)
3351{
3352 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3353
3354 return dd->send_egress_err_status_cnt[32];
3355}
3356
3357static u64 access_tx_sdma15_disallowed_packet_err_cnt(
3358 const struct cntr_entry *entry,
3359 void *context, int vl, int mode, u64 data)
3360{
3361 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3362
3363 return dd->send_egress_err_status_cnt[31];
3364}
3365
3366static u64 access_tx_sdma14_disallowed_packet_err_cnt(
3367 const struct cntr_entry *entry,
3368 void *context, int vl, int mode, u64 data)
3369{
3370 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3371
3372 return dd->send_egress_err_status_cnt[30];
3373}
3374
3375static u64 access_tx_sdma13_disallowed_packet_err_cnt(
3376 const struct cntr_entry *entry,
3377 void *context, int vl, int mode, u64 data)
3378{
3379 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3380
3381 return dd->send_egress_err_status_cnt[29];
3382}
3383
3384static u64 access_tx_sdma12_disallowed_packet_err_cnt(
3385 const struct cntr_entry *entry,
3386 void *context, int vl, int mode, u64 data)
3387{
3388 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3389
3390 return dd->send_egress_err_status_cnt[28];
3391}
3392
3393static u64 access_tx_sdma11_disallowed_packet_err_cnt(
3394 const struct cntr_entry *entry,
3395 void *context, int vl, int mode, u64 data)
3396{
3397 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3398
3399 return dd->send_egress_err_status_cnt[27];
3400}
3401
3402static u64 access_tx_sdma10_disallowed_packet_err_cnt(
3403 const struct cntr_entry *entry,
3404 void *context, int vl, int mode, u64 data)
3405{
3406 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3407
3408 return dd->send_egress_err_status_cnt[26];
3409}
3410
3411static u64 access_tx_sdma9_disallowed_packet_err_cnt(
3412 const struct cntr_entry *entry,
3413 void *context, int vl, int mode, u64 data)
3414{
3415 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3416
3417 return dd->send_egress_err_status_cnt[25];
3418}
3419
3420static u64 access_tx_sdma8_disallowed_packet_err_cnt(
3421 const struct cntr_entry *entry,
3422 void *context, int vl, int mode, u64 data)
3423{
3424 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3425
3426 return dd->send_egress_err_status_cnt[24];
3427}
3428
3429static u64 access_tx_sdma7_disallowed_packet_err_cnt(
3430 const struct cntr_entry *entry,
3431 void *context, int vl, int mode, u64 data)
3432{
3433 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3434
3435 return dd->send_egress_err_status_cnt[23];
3436}
3437
3438static u64 access_tx_sdma6_disallowed_packet_err_cnt(
3439 const struct cntr_entry *entry,
3440 void *context, int vl, int mode, u64 data)
3441{
3442 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3443
3444 return dd->send_egress_err_status_cnt[22];
3445}
3446
3447static u64 access_tx_sdma5_disallowed_packet_err_cnt(
3448 const struct cntr_entry *entry,
3449 void *context, int vl, int mode, u64 data)
3450{
3451 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3452
3453 return dd->send_egress_err_status_cnt[21];
3454}
3455
3456static u64 access_tx_sdma4_disallowed_packet_err_cnt(
3457 const struct cntr_entry *entry,
3458 void *context, int vl, int mode, u64 data)
3459{
3460 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3461
3462 return dd->send_egress_err_status_cnt[20];
3463}
3464
3465static u64 access_tx_sdma3_disallowed_packet_err_cnt(
3466 const struct cntr_entry *entry,
3467 void *context, int vl, int mode, u64 data)
3468{
3469 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3470
3471 return dd->send_egress_err_status_cnt[19];
3472}
3473
3474static u64 access_tx_sdma2_disallowed_packet_err_cnt(
3475 const struct cntr_entry *entry,
3476 void *context, int vl, int mode, u64 data)
3477{
3478 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3479
3480 return dd->send_egress_err_status_cnt[18];
3481}
3482
3483static u64 access_tx_sdma1_disallowed_packet_err_cnt(
3484 const struct cntr_entry *entry,
3485 void *context, int vl, int mode, u64 data)
3486{
3487 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3488
3489 return dd->send_egress_err_status_cnt[17];
3490}
3491
3492static u64 access_tx_sdma0_disallowed_packet_err_cnt(
3493 const struct cntr_entry *entry,
3494 void *context, int vl, int mode, u64 data)
3495{
3496 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3497
3498 return dd->send_egress_err_status_cnt[16];
3499}
3500
3501static u64 access_tx_config_parity_err_cnt(const struct cntr_entry *entry,
3502 void *context, int vl, int mode,
3503 u64 data)
3504{
3505 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3506
3507 return dd->send_egress_err_status_cnt[15];
3508}
3509
3510static u64 access_tx_sbrd_ctl_csr_parity_err_cnt(const struct cntr_entry *entry,
3511 void *context, int vl,
3512 int mode, u64 data)
3513{
3514 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3515
3516 return dd->send_egress_err_status_cnt[14];
3517}
3518
3519static u64 access_tx_launch_csr_parity_err_cnt(const struct cntr_entry *entry,
3520 void *context, int vl, int mode,
3521 u64 data)
3522{
3523 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3524
3525 return dd->send_egress_err_status_cnt[13];
3526}
3527
3528static u64 access_tx_illegal_vl_err_cnt(const struct cntr_entry *entry,
3529 void *context, int vl, int mode,
3530 u64 data)
3531{
3532 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3533
3534 return dd->send_egress_err_status_cnt[12];
3535}
3536
3537static u64 access_tx_sbrd_ctl_state_machine_parity_err_cnt(
3538 const struct cntr_entry *entry,
3539 void *context, int vl, int mode, u64 data)
3540{
3541 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3542
3543 return dd->send_egress_err_status_cnt[11];
3544}
3545
3546static u64 access_egress_reserved_10_err_cnt(const struct cntr_entry *entry,
3547 void *context, int vl, int mode,
3548 u64 data)
3549{
3550 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3551
3552 return dd->send_egress_err_status_cnt[10];
3553}
3554
3555static u64 access_egress_reserved_9_err_cnt(const struct cntr_entry *entry,
3556 void *context, int vl, int mode,
3557 u64 data)
3558{
3559 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3560
3561 return dd->send_egress_err_status_cnt[9];
3562}
3563
3564static u64 access_tx_sdma_launch_intf_parity_err_cnt(
3565 const struct cntr_entry *entry,
3566 void *context, int vl, int mode, u64 data)
3567{
3568 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3569
3570 return dd->send_egress_err_status_cnt[8];
3571}
3572
3573static u64 access_tx_pio_launch_intf_parity_err_cnt(
3574 const struct cntr_entry *entry,
3575 void *context, int vl, int mode, u64 data)
3576{
3577 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3578
3579 return dd->send_egress_err_status_cnt[7];
3580}
3581
3582static u64 access_egress_reserved_6_err_cnt(const struct cntr_entry *entry,
3583 void *context, int vl, int mode,
3584 u64 data)
3585{
3586 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3587
3588 return dd->send_egress_err_status_cnt[6];
3589}
3590
3591static u64 access_tx_incorrect_link_state_err_cnt(
3592 const struct cntr_entry *entry,
3593 void *context, int vl, int mode, u64 data)
3594{
3595 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3596
3597 return dd->send_egress_err_status_cnt[5];
3598}
3599
3600static u64 access_tx_linkdown_err_cnt(const struct cntr_entry *entry,
3601 void *context, int vl, int mode,
3602 u64 data)
3603{
3604 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3605
3606 return dd->send_egress_err_status_cnt[4];
3607}
3608
3609static u64 access_tx_egress_fifi_underrun_or_parity_err_cnt(
3610 const struct cntr_entry *entry,
3611 void *context, int vl, int mode, u64 data)
3612{
3613 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3614
3615 return dd->send_egress_err_status_cnt[3];
3616}
3617
3618static u64 access_egress_reserved_2_err_cnt(const struct cntr_entry *entry,
3619 void *context, int vl, int mode,
3620 u64 data)
3621{
3622 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3623
3624 return dd->send_egress_err_status_cnt[2];
3625}
3626
3627static u64 access_tx_pkt_integrity_mem_unc_err_cnt(
3628 const struct cntr_entry *entry,
3629 void *context, int vl, int mode, u64 data)
3630{
3631 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3632
3633 return dd->send_egress_err_status_cnt[1];
3634}
3635
3636static u64 access_tx_pkt_integrity_mem_cor_err_cnt(
3637 const struct cntr_entry *entry,
3638 void *context, int vl, int mode, u64 data)
3639{
3640 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3641
3642 return dd->send_egress_err_status_cnt[0];
3643}
3644
3645/*
3646 * Software counters corresponding to each of the
3647 * error status bits within SendErrStatus
3648 */
3649static u64 access_send_csr_write_bad_addr_err_cnt(
3650 const struct cntr_entry *entry,
3651 void *context, int vl, int mode, u64 data)
3652{
3653 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3654
3655 return dd->send_err_status_cnt[2];
3656}
3657
3658static u64 access_send_csr_read_bad_addr_err_cnt(const struct cntr_entry *entry,
3659 void *context, int vl,
3660 int mode, u64 data)
3661{
3662 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3663
3664 return dd->send_err_status_cnt[1];
3665}
3666
3667static u64 access_send_csr_parity_cnt(const struct cntr_entry *entry,
3668 void *context, int vl, int mode,
3669 u64 data)
3670{
3671 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3672
3673 return dd->send_err_status_cnt[0];
3674}
3675
3676/*
3677 * Software counters corresponding to each of the
3678 * error status bits within SendCtxtErrStatus
3679 */
3680static u64 access_pio_write_out_of_bounds_err_cnt(
3681 const struct cntr_entry *entry,
3682 void *context, int vl, int mode, u64 data)
3683{
3684 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3685
3686 return dd->sw_ctxt_err_status_cnt[4];
3687}
3688
3689static u64 access_pio_write_overflow_err_cnt(const struct cntr_entry *entry,
3690 void *context, int vl, int mode,
3691 u64 data)
3692{
3693 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3694
3695 return dd->sw_ctxt_err_status_cnt[3];
3696}
3697
3698static u64 access_pio_write_crosses_boundary_err_cnt(
3699 const struct cntr_entry *entry,
3700 void *context, int vl, int mode, u64 data)
3701{
3702 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3703
3704 return dd->sw_ctxt_err_status_cnt[2];
3705}
3706
3707static u64 access_pio_disallowed_packet_err_cnt(const struct cntr_entry *entry,
3708 void *context, int vl,
3709 int mode, u64 data)
3710{
3711 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3712
3713 return dd->sw_ctxt_err_status_cnt[1];
3714}
3715
3716static u64 access_pio_inconsistent_sop_err_cnt(const struct cntr_entry *entry,
3717 void *context, int vl, int mode,
3718 u64 data)
3719{
3720 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3721
3722 return dd->sw_ctxt_err_status_cnt[0];
3723}
3724
3725/*
3726 * Software counters corresponding to each of the
3727 * error status bits within SendDmaEngErrStatus
3728 */
3729static u64 access_sdma_header_request_fifo_cor_err_cnt(
3730 const struct cntr_entry *entry,
3731 void *context, int vl, int mode, u64 data)
3732{
3733 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3734
3735 return dd->sw_send_dma_eng_err_status_cnt[23];
3736}
3737
3738static u64 access_sdma_header_storage_cor_err_cnt(
3739 const struct cntr_entry *entry,
3740 void *context, int vl, int mode, u64 data)
3741{
3742 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3743
3744 return dd->sw_send_dma_eng_err_status_cnt[22];
3745}
3746
3747static u64 access_sdma_packet_tracking_cor_err_cnt(
3748 const struct cntr_entry *entry,
3749 void *context, int vl, int mode, u64 data)
3750{
3751 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3752
3753 return dd->sw_send_dma_eng_err_status_cnt[21];
3754}
3755
3756static u64 access_sdma_assembly_cor_err_cnt(const struct cntr_entry *entry,
3757 void *context, int vl, int mode,
3758 u64 data)
3759{
3760 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3761
3762 return dd->sw_send_dma_eng_err_status_cnt[20];
3763}
3764
3765static u64 access_sdma_desc_table_cor_err_cnt(const struct cntr_entry *entry,
3766 void *context, int vl, int mode,
3767 u64 data)
3768{
3769 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3770
3771 return dd->sw_send_dma_eng_err_status_cnt[19];
3772}
3773
3774static u64 access_sdma_header_request_fifo_unc_err_cnt(
3775 const struct cntr_entry *entry,
3776 void *context, int vl, int mode, u64 data)
3777{
3778 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3779
3780 return dd->sw_send_dma_eng_err_status_cnt[18];
3781}
3782
3783static u64 access_sdma_header_storage_unc_err_cnt(
3784 const struct cntr_entry *entry,
3785 void *context, int vl, int mode, u64 data)
3786{
3787 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3788
3789 return dd->sw_send_dma_eng_err_status_cnt[17];
3790}
3791
3792static u64 access_sdma_packet_tracking_unc_err_cnt(
3793 const struct cntr_entry *entry,
3794 void *context, int vl, int mode, u64 data)
3795{
3796 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3797
3798 return dd->sw_send_dma_eng_err_status_cnt[16];
3799}
3800
3801static u64 access_sdma_assembly_unc_err_cnt(const struct cntr_entry *entry,
3802 void *context, int vl, int mode,
3803 u64 data)
3804{
3805 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3806
3807 return dd->sw_send_dma_eng_err_status_cnt[15];
3808}
3809
3810static u64 access_sdma_desc_table_unc_err_cnt(const struct cntr_entry *entry,
3811 void *context, int vl, int mode,
3812 u64 data)
3813{
3814 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3815
3816 return dd->sw_send_dma_eng_err_status_cnt[14];
3817}
3818
3819static u64 access_sdma_timeout_err_cnt(const struct cntr_entry *entry,
3820 void *context, int vl, int mode,
3821 u64 data)
3822{
3823 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3824
3825 return dd->sw_send_dma_eng_err_status_cnt[13];
3826}
3827
3828static u64 access_sdma_header_length_err_cnt(const struct cntr_entry *entry,
3829 void *context, int vl, int mode,
3830 u64 data)
3831{
3832 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3833
3834 return dd->sw_send_dma_eng_err_status_cnt[12];
3835}
3836
3837static u64 access_sdma_header_address_err_cnt(const struct cntr_entry *entry,
3838 void *context, int vl, int mode,
3839 u64 data)
3840{
3841 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3842
3843 return dd->sw_send_dma_eng_err_status_cnt[11];
3844}
3845
3846static u64 access_sdma_header_select_err_cnt(const struct cntr_entry *entry,
3847 void *context, int vl, int mode,
3848 u64 data)
3849{
3850 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3851
3852 return dd->sw_send_dma_eng_err_status_cnt[10];
3853}
3854
3855static u64 access_sdma_reserved_9_err_cnt(const struct cntr_entry *entry,
3856 void *context, int vl, int mode,
3857 u64 data)
3858{
3859 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3860
3861 return dd->sw_send_dma_eng_err_status_cnt[9];
3862}
3863
3864static u64 access_sdma_packet_desc_overflow_err_cnt(
3865 const struct cntr_entry *entry,
3866 void *context, int vl, int mode, u64 data)
3867{
3868 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3869
3870 return dd->sw_send_dma_eng_err_status_cnt[8];
3871}
3872
3873static u64 access_sdma_length_mismatch_err_cnt(const struct cntr_entry *entry,
3874 void *context, int vl,
3875 int mode, u64 data)
3876{
3877 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3878
3879 return dd->sw_send_dma_eng_err_status_cnt[7];
3880}
3881
3882static u64 access_sdma_halt_err_cnt(const struct cntr_entry *entry,
3883 void *context, int vl, int mode, u64 data)
3884{
3885 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3886
3887 return dd->sw_send_dma_eng_err_status_cnt[6];
3888}
3889
3890static u64 access_sdma_mem_read_err_cnt(const struct cntr_entry *entry,
3891 void *context, int vl, int mode,
3892 u64 data)
3893{
3894 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3895
3896 return dd->sw_send_dma_eng_err_status_cnt[5];
3897}
3898
3899static u64 access_sdma_first_desc_err_cnt(const struct cntr_entry *entry,
3900 void *context, int vl, int mode,
3901 u64 data)
3902{
3903 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3904
3905 return dd->sw_send_dma_eng_err_status_cnt[4];
3906}
3907
3908static u64 access_sdma_tail_out_of_bounds_err_cnt(
3909 const struct cntr_entry *entry,
3910 void *context, int vl, int mode, u64 data)
3911{
3912 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3913
3914 return dd->sw_send_dma_eng_err_status_cnt[3];
3915}
3916
3917static u64 access_sdma_too_long_err_cnt(const struct cntr_entry *entry,
3918 void *context, int vl, int mode,
3919 u64 data)
3920{
3921 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3922
3923 return dd->sw_send_dma_eng_err_status_cnt[2];
3924}
3925
3926static u64 access_sdma_gen_mismatch_err_cnt(const struct cntr_entry *entry,
3927 void *context, int vl, int mode,
3928 u64 data)
3929{
3930 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3931
3932 return dd->sw_send_dma_eng_err_status_cnt[1];
3933}
3934
3935static u64 access_sdma_wrong_dw_err_cnt(const struct cntr_entry *entry,
3936 void *context, int vl, int mode,
3937 u64 data)
3938{
3939 struct hfi1_devdata *dd = (struct hfi1_devdata *)context;
3940
3941 return dd->sw_send_dma_eng_err_status_cnt[0];
3942}
3943
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]3944#define def_access_sw_cpu(cntr) \
3945static u64 access_sw_cpu_##cntr(const struct cntr_entry *entry, \
3946 void *context, int vl, int mode, u64 data) \
3947{ \
3948 struct hfi1_pportdata *ppd = (struct hfi1_pportdata *)context; \
Dennis Dalessandro4eb06882016-01-19 14:42:39 -0800[diff] [blame]3949 return read_write_cpu(ppd->dd, &ppd->ibport_data.rvp.z_ ##cntr, \
3950 ppd->ibport_data.rvp.cntr, vl, \
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]3951 mode, data); \
3952}
3953
3954def_access_sw_cpu(rc_acks);
3955def_access_sw_cpu(rc_qacks);
3956def_access_sw_cpu(rc_delayed_comp);
3957
3958#define def_access_ibp_counter(cntr) \
3959static u64 access_ibp_##cntr(const struct cntr_entry *entry, \
3960 void *context, int vl, int mode, u64 data) \
3961{ \
3962 struct hfi1_pportdata *ppd = (struct hfi1_pportdata *)context; \
3963 \
3964 if (vl != CNTR_INVALID_VL) \
3965 return 0; \
3966 \
Dennis Dalessandro4eb06882016-01-19 14:42:39 -0800[diff] [blame]3967 return read_write_sw(ppd->dd, &ppd->ibport_data.rvp.n_ ##cntr, \
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]3968 mode, data); \
3969}
3970
3971def_access_ibp_counter(loop_pkts);
3972def_access_ibp_counter(rc_resends);
3973def_access_ibp_counter(rnr_naks);
3974def_access_ibp_counter(other_naks);
3975def_access_ibp_counter(rc_timeouts);
3976def_access_ibp_counter(pkt_drops);
3977def_access_ibp_counter(dmawait);
3978def_access_ibp_counter(rc_seqnak);
3979def_access_ibp_counter(rc_dupreq);
3980def_access_ibp_counter(rdma_seq);
3981def_access_ibp_counter(unaligned);
3982def_access_ibp_counter(seq_naks);
3983
3984static struct cntr_entry dev_cntrs[DEV_CNTR_LAST] = {
3985[C_RCV_OVF] = RXE32_DEV_CNTR_ELEM(RcvOverflow, RCV_BUF_OVFL_CNT, CNTR_SYNTH),
3986[C_RX_TID_FULL] = RXE32_DEV_CNTR_ELEM(RxTIDFullEr, RCV_TID_FULL_ERR_CNT,
3987 CNTR_NORMAL),
3988[C_RX_TID_INVALID] = RXE32_DEV_CNTR_ELEM(RxTIDInvalid, RCV_TID_VALID_ERR_CNT,
3989 CNTR_NORMAL),
3990[C_RX_TID_FLGMS] = RXE32_DEV_CNTR_ELEM(RxTidFLGMs,
3991 RCV_TID_FLOW_GEN_MISMATCH_CNT,
3992 CNTR_NORMAL),
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]3993[C_RX_CTX_EGRS] = RXE32_DEV_CNTR_ELEM(RxCtxEgrS, RCV_CONTEXT_EGR_STALL,
3994 CNTR_NORMAL),
3995[C_RCV_TID_FLSMS] = RXE32_DEV_CNTR_ELEM(RxTidFLSMs,
3996 RCV_TID_FLOW_SEQ_MISMATCH_CNT, CNTR_NORMAL),
3997[C_CCE_PCI_CR_ST] = CCE_PERF_DEV_CNTR_ELEM(CcePciCrSt,
3998 CCE_PCIE_POSTED_CRDT_STALL_CNT, CNTR_NORMAL),
3999[C_CCE_PCI_TR_ST] = CCE_PERF_DEV_CNTR_ELEM(CcePciTrSt, CCE_PCIE_TRGT_STALL_CNT,
4000 CNTR_NORMAL),
4001[C_CCE_PIO_WR_ST] = CCE_PERF_DEV_CNTR_ELEM(CcePioWrSt, CCE_PIO_WR_STALL_CNT,
4002 CNTR_NORMAL),
4003[C_CCE_ERR_INT] = CCE_INT_DEV_CNTR_ELEM(CceErrInt, CCE_ERR_INT_CNT,
4004 CNTR_NORMAL),
4005[C_CCE_SDMA_INT] = CCE_INT_DEV_CNTR_ELEM(CceSdmaInt, CCE_SDMA_INT_CNT,
4006 CNTR_NORMAL),
4007[C_CCE_MISC_INT] = CCE_INT_DEV_CNTR_ELEM(CceMiscInt, CCE_MISC_INT_CNT,
4008 CNTR_NORMAL),
4009[C_CCE_RCV_AV_INT] = CCE_INT_DEV_CNTR_ELEM(CceRcvAvInt, CCE_RCV_AVAIL_INT_CNT,
4010 CNTR_NORMAL),
4011[C_CCE_RCV_URG_INT] = CCE_INT_DEV_CNTR_ELEM(CceRcvUrgInt,
4012 CCE_RCV_URGENT_INT_CNT, CNTR_NORMAL),
4013[C_CCE_SEND_CR_INT] = CCE_INT_DEV_CNTR_ELEM(CceSndCrInt,
4014 CCE_SEND_CREDIT_INT_CNT, CNTR_NORMAL),
4015[C_DC_UNC_ERR] = DC_PERF_CNTR(DcUnctblErr, DCC_ERR_UNCORRECTABLE_CNT,
4016 CNTR_SYNTH),
4017[C_DC_RCV_ERR] = DC_PERF_CNTR(DcRecvErr, DCC_ERR_PORTRCV_ERR_CNT, CNTR_SYNTH),
4018[C_DC_FM_CFG_ERR] = DC_PERF_CNTR(DcFmCfgErr, DCC_ERR_FMCONFIG_ERR_CNT,
4019 CNTR_SYNTH),
4020[C_DC_RMT_PHY_ERR] = DC_PERF_CNTR(DcRmtPhyErr, DCC_ERR_RCVREMOTE_PHY_ERR_CNT,
4021 CNTR_SYNTH),
4022[C_DC_DROPPED_PKT] = DC_PERF_CNTR(DcDroppedPkt, DCC_ERR_DROPPED_PKT_CNT,
4023 CNTR_SYNTH),
4024[C_DC_MC_XMIT_PKTS] = DC_PERF_CNTR(DcMcXmitPkts,
4025 DCC_PRF_PORT_XMIT_MULTICAST_CNT, CNTR_SYNTH),
4026[C_DC_MC_RCV_PKTS] = DC_PERF_CNTR(DcMcRcvPkts,
4027 DCC_PRF_PORT_RCV_MULTICAST_PKT_CNT,
4028 CNTR_SYNTH),
4029[C_DC_XMIT_CERR] = DC_PERF_CNTR(DcXmitCorr,
4030 DCC_PRF_PORT_XMIT_CORRECTABLE_CNT, CNTR_SYNTH),
4031[C_DC_RCV_CERR] = DC_PERF_CNTR(DcRcvCorrCnt, DCC_PRF_PORT_RCV_CORRECTABLE_CNT,
4032 CNTR_SYNTH),
4033[C_DC_RCV_FCC] = DC_PERF_CNTR(DcRxFCntl, DCC_PRF_RX_FLOW_CRTL_CNT,
4034 CNTR_SYNTH),
4035[C_DC_XMIT_FCC] = DC_PERF_CNTR(DcXmitFCntl, DCC_PRF_TX_FLOW_CRTL_CNT,
4036 CNTR_SYNTH),
4037[C_DC_XMIT_FLITS] = DC_PERF_CNTR(DcXmitFlits, DCC_PRF_PORT_XMIT_DATA_CNT,
4038 CNTR_SYNTH),
4039[C_DC_RCV_FLITS] = DC_PERF_CNTR(DcRcvFlits, DCC_PRF_PORT_RCV_DATA_CNT,
4040 CNTR_SYNTH),
4041[C_DC_XMIT_PKTS] = DC_PERF_CNTR(DcXmitPkts, DCC_PRF_PORT_XMIT_PKTS_CNT,
4042 CNTR_SYNTH),
4043[C_DC_RCV_PKTS] = DC_PERF_CNTR(DcRcvPkts, DCC_PRF_PORT_RCV_PKTS_CNT,
4044 CNTR_SYNTH),
4045[C_DC_RX_FLIT_VL] = DC_PERF_CNTR(DcRxFlitVl, DCC_PRF_PORT_VL_RCV_DATA_CNT,
4046 CNTR_SYNTH | CNTR_VL),
4047[C_DC_RX_PKT_VL] = DC_PERF_CNTR(DcRxPktVl, DCC_PRF_PORT_VL_RCV_PKTS_CNT,
4048 CNTR_SYNTH | CNTR_VL),
4049[C_DC_RCV_FCN] = DC_PERF_CNTR(DcRcvFcn, DCC_PRF_PORT_RCV_FECN_CNT, CNTR_SYNTH),
4050[C_DC_RCV_FCN_VL] = DC_PERF_CNTR(DcRcvFcnVl, DCC_PRF_PORT_VL_RCV_FECN_CNT,
4051 CNTR_SYNTH | CNTR_VL),
4052[C_DC_RCV_BCN] = DC_PERF_CNTR(DcRcvBcn, DCC_PRF_PORT_RCV_BECN_CNT, CNTR_SYNTH),
4053[C_DC_RCV_BCN_VL] = DC_PERF_CNTR(DcRcvBcnVl, DCC_PRF_PORT_VL_RCV_BECN_CNT,
4054 CNTR_SYNTH | CNTR_VL),
4055[C_DC_RCV_BBL] = DC_PERF_CNTR(DcRcvBbl, DCC_PRF_PORT_RCV_BUBBLE_CNT,
4056 CNTR_SYNTH),
4057[C_DC_RCV_BBL_VL] = DC_PERF_CNTR(DcRcvBblVl, DCC_PRF_PORT_VL_RCV_BUBBLE_CNT,
4058 CNTR_SYNTH | CNTR_VL),
4059[C_DC_MARK_FECN] = DC_PERF_CNTR(DcMarkFcn, DCC_PRF_PORT_MARK_FECN_CNT,
4060 CNTR_SYNTH),
4061[C_DC_MARK_FECN_VL] = DC_PERF_CNTR(DcMarkFcnVl, DCC_PRF_PORT_VL_MARK_FECN_CNT,
4062 CNTR_SYNTH | CNTR_VL),
4063[C_DC_TOTAL_CRC] =
4064 DC_PERF_CNTR_LCB(DcTotCrc, DC_LCB_ERR_INFO_TOTAL_CRC_ERR,
4065 CNTR_SYNTH),
4066[C_DC_CRC_LN0] = DC_PERF_CNTR_LCB(DcCrcLn0, DC_LCB_ERR_INFO_CRC_ERR_LN0,
4067 CNTR_SYNTH),
4068[C_DC_CRC_LN1] = DC_PERF_CNTR_LCB(DcCrcLn1, DC_LCB_ERR_INFO_CRC_ERR_LN1,
4069 CNTR_SYNTH),
4070[C_DC_CRC_LN2] = DC_PERF_CNTR_LCB(DcCrcLn2, DC_LCB_ERR_INFO_CRC_ERR_LN2,
4071 CNTR_SYNTH),
4072[C_DC_CRC_LN3] = DC_PERF_CNTR_LCB(DcCrcLn3, DC_LCB_ERR_INFO_CRC_ERR_LN3,
4073 CNTR_SYNTH),
4074[C_DC_CRC_MULT_LN] =
4075 DC_PERF_CNTR_LCB(DcMultLn, DC_LCB_ERR_INFO_CRC_ERR_MULTI_LN,
4076 CNTR_SYNTH),
4077[C_DC_TX_REPLAY] = DC_PERF_CNTR_LCB(DcTxReplay, DC_LCB_ERR_INFO_TX_REPLAY_CNT,
4078 CNTR_SYNTH),
4079[C_DC_RX_REPLAY] = DC_PERF_CNTR_LCB(DcRxReplay, DC_LCB_ERR_INFO_RX_REPLAY_CNT,
4080 CNTR_SYNTH),
4081[C_DC_SEQ_CRC_CNT] =
4082 DC_PERF_CNTR_LCB(DcLinkSeqCrc, DC_LCB_ERR_INFO_SEQ_CRC_CNT,
4083 CNTR_SYNTH),
4084[C_DC_ESC0_ONLY_CNT] =
4085 DC_PERF_CNTR_LCB(DcEsc0, DC_LCB_ERR_INFO_ESCAPE_0_ONLY_CNT,
4086 CNTR_SYNTH),
4087[C_DC_ESC0_PLUS1_CNT] =
4088 DC_PERF_CNTR_LCB(DcEsc1, DC_LCB_ERR_INFO_ESCAPE_0_PLUS1_CNT,
4089 CNTR_SYNTH),
4090[C_DC_ESC0_PLUS2_CNT] =
4091 DC_PERF_CNTR_LCB(DcEsc0Plus2, DC_LCB_ERR_INFO_ESCAPE_0_PLUS2_CNT,
4092 CNTR_SYNTH),
4093[C_DC_REINIT_FROM_PEER_CNT] =
4094 DC_PERF_CNTR_LCB(DcReinitPeer, DC_LCB_ERR_INFO_REINIT_FROM_PEER_CNT,
4095 CNTR_SYNTH),
4096[C_DC_SBE_CNT] = DC_PERF_CNTR_LCB(DcSbe, DC_LCB_ERR_INFO_SBE_CNT,
4097 CNTR_SYNTH),
4098[C_DC_MISC_FLG_CNT] =
4099 DC_PERF_CNTR_LCB(DcMiscFlg, DC_LCB_ERR_INFO_MISC_FLG_CNT,
4100 CNTR_SYNTH),
4101[C_DC_PRF_GOOD_LTP_CNT] =
4102 DC_PERF_CNTR_LCB(DcGoodLTP, DC_LCB_PRF_GOOD_LTP_CNT, CNTR_SYNTH),
4103[C_DC_PRF_ACCEPTED_LTP_CNT] =
4104 DC_PERF_CNTR_LCB(DcAccLTP, DC_LCB_PRF_ACCEPTED_LTP_CNT,
4105 CNTR_SYNTH),
4106[C_DC_PRF_RX_FLIT_CNT] =
4107 DC_PERF_CNTR_LCB(DcPrfRxFlit, DC_LCB_PRF_RX_FLIT_CNT, CNTR_SYNTH),
4108[C_DC_PRF_TX_FLIT_CNT] =
4109 DC_PERF_CNTR_LCB(DcPrfTxFlit, DC_LCB_PRF_TX_FLIT_CNT, CNTR_SYNTH),
4110[C_DC_PRF_CLK_CNTR] =
4111 DC_PERF_CNTR_LCB(DcPrfClk, DC_LCB_PRF_CLK_CNTR, CNTR_SYNTH),
4112[C_DC_PG_DBG_FLIT_CRDTS_CNT] =
4113 DC_PERF_CNTR_LCB(DcFltCrdts, DC_LCB_PG_DBG_FLIT_CRDTS_CNT, CNTR_SYNTH),
4114[C_DC_PG_STS_PAUSE_COMPLETE_CNT] =
4115 DC_PERF_CNTR_LCB(DcPauseComp, DC_LCB_PG_STS_PAUSE_COMPLETE_CNT,
4116 CNTR_SYNTH),
4117[C_DC_PG_STS_TX_SBE_CNT] =
4118 DC_PERF_CNTR_LCB(DcStsTxSbe, DC_LCB_PG_STS_TX_SBE_CNT, CNTR_SYNTH),
4119[C_DC_PG_STS_TX_MBE_CNT] =
4120 DC_PERF_CNTR_LCB(DcStsTxMbe, DC_LCB_PG_STS_TX_MBE_CNT,
4121 CNTR_SYNTH),
4122[C_SW_CPU_INTR] = CNTR_ELEM("Intr", 0, 0, CNTR_NORMAL,
4123 access_sw_cpu_intr),
4124[C_SW_CPU_RCV_LIM] = CNTR_ELEM("RcvLimit", 0, 0, CNTR_NORMAL,
4125 access_sw_cpu_rcv_limit),
4126[C_SW_VTX_WAIT] = CNTR_ELEM("vTxWait", 0, 0, CNTR_NORMAL,
4127 access_sw_vtx_wait),
4128[C_SW_PIO_WAIT] = CNTR_ELEM("PioWait", 0, 0, CNTR_NORMAL,
4129 access_sw_pio_wait),
4130[C_SW_KMEM_WAIT] = CNTR_ELEM("KmemWait", 0, 0, CNTR_NORMAL,
4131 access_sw_kmem_wait),
Dean Luickb4219222015-10-26 10:28:35 -0400[diff] [blame]4132[C_SW_SEND_SCHED] = CNTR_ELEM("SendSched", 0, 0, CNTR_NORMAL,
4133 access_sw_send_schedule),
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]4134[C_SDMA_DESC_FETCHED_CNT] = CNTR_ELEM("SDEDscFdCn",
4135 SEND_DMA_DESC_FETCHED_CNT, 0,
4136 CNTR_NORMAL | CNTR_32BIT | CNTR_SDMA,
4137 dev_access_u32_csr),
4138[C_SDMA_INT_CNT] = CNTR_ELEM("SDMAInt", 0, 0,
4139 CNTR_NORMAL | CNTR_32BIT | CNTR_SDMA,
4140 access_sde_int_cnt),
4141[C_SDMA_ERR_CNT] = CNTR_ELEM("SDMAErrCt", 0, 0,
4142 CNTR_NORMAL | CNTR_32BIT | CNTR_SDMA,
4143 access_sde_err_cnt),
4144[C_SDMA_IDLE_INT_CNT] = CNTR_ELEM("SDMAIdInt", 0, 0,
4145 CNTR_NORMAL | CNTR_32BIT | CNTR_SDMA,
4146 access_sde_idle_int_cnt),
4147[C_SDMA_PROGRESS_INT_CNT] = CNTR_ELEM("SDMAPrIntCn", 0, 0,
4148 CNTR_NORMAL | CNTR_32BIT | CNTR_SDMA,
4149 access_sde_progress_int_cnt),
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]4150/* MISC_ERR_STATUS */
4151[C_MISC_PLL_LOCK_FAIL_ERR] = CNTR_ELEM("MISC_PLL_LOCK_FAIL_ERR", 0, 0,
4152 CNTR_NORMAL,
4153 access_misc_pll_lock_fail_err_cnt),
4154[C_MISC_MBIST_FAIL_ERR] = CNTR_ELEM("MISC_MBIST_FAIL_ERR", 0, 0,
4155 CNTR_NORMAL,
4156 access_misc_mbist_fail_err_cnt),
4157[C_MISC_INVALID_EEP_CMD_ERR] = CNTR_ELEM("MISC_INVALID_EEP_CMD_ERR", 0, 0,
4158 CNTR_NORMAL,
4159 access_misc_invalid_eep_cmd_err_cnt),
4160[C_MISC_EFUSE_DONE_PARITY_ERR] = CNTR_ELEM("MISC_EFUSE_DONE_PARITY_ERR", 0, 0,
4161 CNTR_NORMAL,
4162 access_misc_efuse_done_parity_err_cnt),
4163[C_MISC_EFUSE_WRITE_ERR] = CNTR_ELEM("MISC_EFUSE_WRITE_ERR", 0, 0,
4164 CNTR_NORMAL,
4165 access_misc_efuse_write_err_cnt),
4166[C_MISC_EFUSE_READ_BAD_ADDR_ERR] = CNTR_ELEM("MISC_EFUSE_READ_BAD_ADDR_ERR", 0,
4167 0, CNTR_NORMAL,
4168 access_misc_efuse_read_bad_addr_err_cnt),
4169[C_MISC_EFUSE_CSR_PARITY_ERR] = CNTR_ELEM("MISC_EFUSE_CSR_PARITY_ERR", 0, 0,
4170 CNTR_NORMAL,
4171 access_misc_efuse_csr_parity_err_cnt),
4172[C_MISC_FW_AUTH_FAILED_ERR] = CNTR_ELEM("MISC_FW_AUTH_FAILED_ERR", 0, 0,
4173 CNTR_NORMAL,
4174 access_misc_fw_auth_failed_err_cnt),
4175[C_MISC_KEY_MISMATCH_ERR] = CNTR_ELEM("MISC_KEY_MISMATCH_ERR", 0, 0,
4176 CNTR_NORMAL,
4177 access_misc_key_mismatch_err_cnt),
4178[C_MISC_SBUS_WRITE_FAILED_ERR] = CNTR_ELEM("MISC_SBUS_WRITE_FAILED_ERR", 0, 0,
4179 CNTR_NORMAL,
4180 access_misc_sbus_write_failed_err_cnt),
4181[C_MISC_CSR_WRITE_BAD_ADDR_ERR] = CNTR_ELEM("MISC_CSR_WRITE_BAD_ADDR_ERR", 0, 0,
4182 CNTR_NORMAL,
4183 access_misc_csr_write_bad_addr_err_cnt),
4184[C_MISC_CSR_READ_BAD_ADDR_ERR] = CNTR_ELEM("MISC_CSR_READ_BAD_ADDR_ERR", 0, 0,
4185 CNTR_NORMAL,
4186 access_misc_csr_read_bad_addr_err_cnt),
4187[C_MISC_CSR_PARITY_ERR] = CNTR_ELEM("MISC_CSR_PARITY_ERR", 0, 0,
4188 CNTR_NORMAL,
4189 access_misc_csr_parity_err_cnt),
4190/* CceErrStatus */
4191[C_CCE_ERR_STATUS_AGGREGATED_CNT] = CNTR_ELEM("CceErrStatusAggregatedCnt", 0, 0,
4192 CNTR_NORMAL,
4193 access_sw_cce_err_status_aggregated_cnt),
4194[C_CCE_MSIX_CSR_PARITY_ERR] = CNTR_ELEM("CceMsixCsrParityErr", 0, 0,
4195 CNTR_NORMAL,
4196 access_cce_msix_csr_parity_err_cnt),
4197[C_CCE_INT_MAP_UNC_ERR] = CNTR_ELEM("CceIntMapUncErr", 0, 0,
4198 CNTR_NORMAL,
4199 access_cce_int_map_unc_err_cnt),
4200[C_CCE_INT_MAP_COR_ERR] = CNTR_ELEM("CceIntMapCorErr", 0, 0,
4201 CNTR_NORMAL,
4202 access_cce_int_map_cor_err_cnt),
4203[C_CCE_MSIX_TABLE_UNC_ERR] = CNTR_ELEM("CceMsixTableUncErr", 0, 0,
4204 CNTR_NORMAL,
4205 access_cce_msix_table_unc_err_cnt),
4206[C_CCE_MSIX_TABLE_COR_ERR] = CNTR_ELEM("CceMsixTableCorErr", 0, 0,
4207 CNTR_NORMAL,
4208 access_cce_msix_table_cor_err_cnt),
4209[C_CCE_RXDMA_CONV_FIFO_PARITY_ERR] = CNTR_ELEM("CceRxdmaConvFifoParityErr", 0,
4210 0, CNTR_NORMAL,
4211 access_cce_rxdma_conv_fifo_parity_err_cnt),
4212[C_CCE_RCPL_ASYNC_FIFO_PARITY_ERR] = CNTR_ELEM("CceRcplAsyncFifoParityErr", 0,
4213 0, CNTR_NORMAL,
4214 access_cce_rcpl_async_fifo_parity_err_cnt),
4215[C_CCE_SEG_WRITE_BAD_ADDR_ERR] = CNTR_ELEM("CceSegWriteBadAddrErr", 0, 0,
4216 CNTR_NORMAL,
4217 access_cce_seg_write_bad_addr_err_cnt),
4218[C_CCE_SEG_READ_BAD_ADDR_ERR] = CNTR_ELEM("CceSegReadBadAddrErr", 0, 0,
4219 CNTR_NORMAL,
4220 access_cce_seg_read_bad_addr_err_cnt),
4221[C_LA_TRIGGERED] = CNTR_ELEM("Cce LATriggered", 0, 0,
4222 CNTR_NORMAL,
4223 access_la_triggered_cnt),
4224[C_CCE_TRGT_CPL_TIMEOUT_ERR] = CNTR_ELEM("CceTrgtCplTimeoutErr", 0, 0,
4225 CNTR_NORMAL,
4226 access_cce_trgt_cpl_timeout_err_cnt),
4227[C_PCIC_RECEIVE_PARITY_ERR] = CNTR_ELEM("PcicReceiveParityErr", 0, 0,
4228 CNTR_NORMAL,
4229 access_pcic_receive_parity_err_cnt),
4230[C_PCIC_TRANSMIT_BACK_PARITY_ERR] = CNTR_ELEM("PcicTransmitBackParityErr", 0, 0,
4231 CNTR_NORMAL,
4232 access_pcic_transmit_back_parity_err_cnt),
4233[C_PCIC_TRANSMIT_FRONT_PARITY_ERR] = CNTR_ELEM("PcicTransmitFrontParityErr", 0,
4234 0, CNTR_NORMAL,
4235 access_pcic_transmit_front_parity_err_cnt),
4236[C_PCIC_CPL_DAT_Q_UNC_ERR] = CNTR_ELEM("PcicCplDatQUncErr", 0, 0,
4237 CNTR_NORMAL,
4238 access_pcic_cpl_dat_q_unc_err_cnt),
4239[C_PCIC_CPL_HD_Q_UNC_ERR] = CNTR_ELEM("PcicCplHdQUncErr", 0, 0,
4240 CNTR_NORMAL,
4241 access_pcic_cpl_hd_q_unc_err_cnt),
4242[C_PCIC_POST_DAT_Q_UNC_ERR] = CNTR_ELEM("PcicPostDatQUncErr", 0, 0,
4243 CNTR_NORMAL,
4244 access_pcic_post_dat_q_unc_err_cnt),
4245[C_PCIC_POST_HD_Q_UNC_ERR] = CNTR_ELEM("PcicPostHdQUncErr", 0, 0,
4246 CNTR_NORMAL,
4247 access_pcic_post_hd_q_unc_err_cnt),
4248[C_PCIC_RETRY_SOT_MEM_UNC_ERR] = CNTR_ELEM("PcicRetrySotMemUncErr", 0, 0,
4249 CNTR_NORMAL,
4250 access_pcic_retry_sot_mem_unc_err_cnt),
4251[C_PCIC_RETRY_MEM_UNC_ERR] = CNTR_ELEM("PcicRetryMemUncErr", 0, 0,
4252 CNTR_NORMAL,
4253 access_pcic_retry_mem_unc_err),
4254[C_PCIC_N_POST_DAT_Q_PARITY_ERR] = CNTR_ELEM("PcicNPostDatQParityErr", 0, 0,
4255 CNTR_NORMAL,
4256 access_pcic_n_post_dat_q_parity_err_cnt),
4257[C_PCIC_N_POST_H_Q_PARITY_ERR] = CNTR_ELEM("PcicNPostHQParityErr", 0, 0,
4258 CNTR_NORMAL,
4259 access_pcic_n_post_h_q_parity_err_cnt),
4260[C_PCIC_CPL_DAT_Q_COR_ERR] = CNTR_ELEM("PcicCplDatQCorErr", 0, 0,
4261 CNTR_NORMAL,
4262 access_pcic_cpl_dat_q_cor_err_cnt),
4263[C_PCIC_CPL_HD_Q_COR_ERR] = CNTR_ELEM("PcicCplHdQCorErr", 0, 0,
4264 CNTR_NORMAL,
4265 access_pcic_cpl_hd_q_cor_err_cnt),
4266[C_PCIC_POST_DAT_Q_COR_ERR] = CNTR_ELEM("PcicPostDatQCorErr", 0, 0,
4267 CNTR_NORMAL,
4268 access_pcic_post_dat_q_cor_err_cnt),
4269[C_PCIC_POST_HD_Q_COR_ERR] = CNTR_ELEM("PcicPostHdQCorErr", 0, 0,
4270 CNTR_NORMAL,
4271 access_pcic_post_hd_q_cor_err_cnt),
4272[C_PCIC_RETRY_SOT_MEM_COR_ERR] = CNTR_ELEM("PcicRetrySotMemCorErr", 0, 0,
4273 CNTR_NORMAL,
4274 access_pcic_retry_sot_mem_cor_err_cnt),
4275[C_PCIC_RETRY_MEM_COR_ERR] = CNTR_ELEM("PcicRetryMemCorErr", 0, 0,
4276 CNTR_NORMAL,
4277 access_pcic_retry_mem_cor_err_cnt),
4278[C_CCE_CLI1_ASYNC_FIFO_DBG_PARITY_ERR] = CNTR_ELEM(
4279 "CceCli1AsyncFifoDbgParityError", 0, 0,
4280 CNTR_NORMAL,
4281 access_cce_cli1_async_fifo_dbg_parity_err_cnt),
4282[C_CCE_CLI1_ASYNC_FIFO_RXDMA_PARITY_ERR] = CNTR_ELEM(
4283 "CceCli1AsyncFifoRxdmaParityError", 0, 0,
4284 CNTR_NORMAL,
4285 access_cce_cli1_async_fifo_rxdma_parity_err_cnt
4286 ),
4287[C_CCE_CLI1_ASYNC_FIFO_SDMA_HD_PARITY_ERR] = CNTR_ELEM(
4288 "CceCli1AsyncFifoSdmaHdParityErr", 0, 0,
4289 CNTR_NORMAL,
4290 access_cce_cli1_async_fifo_sdma_hd_parity_err_cnt),
4291[C_CCE_CLI1_ASYNC_FIFO_PIO_CRDT_PARITY_ERR] = CNTR_ELEM(
4292 "CceCli1AsyncFifoPioCrdtParityErr", 0, 0,
4293 CNTR_NORMAL,
4294 access_cce_cl1_async_fifo_pio_crdt_parity_err_cnt),
4295[C_CCE_CLI2_ASYNC_FIFO_PARITY_ERR] = CNTR_ELEM("CceCli2AsyncFifoParityErr", 0,
4296 0, CNTR_NORMAL,
4297 access_cce_cli2_async_fifo_parity_err_cnt),
4298[C_CCE_CSR_CFG_BUS_PARITY_ERR] = CNTR_ELEM("CceCsrCfgBusParityErr", 0, 0,
4299 CNTR_NORMAL,
4300 access_cce_csr_cfg_bus_parity_err_cnt),
4301[C_CCE_CLI0_ASYNC_FIFO_PARTIY_ERR] = CNTR_ELEM("CceCli0AsyncFifoParityErr", 0,
4302 0, CNTR_NORMAL,
4303 access_cce_cli0_async_fifo_parity_err_cnt),
4304[C_CCE_RSPD_DATA_PARITY_ERR] = CNTR_ELEM("CceRspdDataParityErr", 0, 0,
4305 CNTR_NORMAL,
4306 access_cce_rspd_data_parity_err_cnt),
4307[C_CCE_TRGT_ACCESS_ERR] = CNTR_ELEM("CceTrgtAccessErr", 0, 0,
4308 CNTR_NORMAL,
4309 access_cce_trgt_access_err_cnt),
4310[C_CCE_TRGT_ASYNC_FIFO_PARITY_ERR] = CNTR_ELEM("CceTrgtAsyncFifoParityErr", 0,
4311 0, CNTR_NORMAL,
4312 access_cce_trgt_async_fifo_parity_err_cnt),
4313[C_CCE_CSR_WRITE_BAD_ADDR_ERR] = CNTR_ELEM("CceCsrWriteBadAddrErr", 0, 0,
4314 CNTR_NORMAL,
4315 access_cce_csr_write_bad_addr_err_cnt),
4316[C_CCE_CSR_READ_BAD_ADDR_ERR] = CNTR_ELEM("CceCsrReadBadAddrErr", 0, 0,
4317 CNTR_NORMAL,
4318 access_cce_csr_read_bad_addr_err_cnt),
4319[C_CCE_CSR_PARITY_ERR] = CNTR_ELEM("CceCsrParityErr", 0, 0,
4320 CNTR_NORMAL,
4321 access_ccs_csr_parity_err_cnt),
4322
4323/* RcvErrStatus */
4324[C_RX_CSR_PARITY_ERR] = CNTR_ELEM("RxCsrParityErr", 0, 0,
4325 CNTR_NORMAL,
4326 access_rx_csr_parity_err_cnt),
4327[C_RX_CSR_WRITE_BAD_ADDR_ERR] = CNTR_ELEM("RxCsrWriteBadAddrErr", 0, 0,
4328 CNTR_NORMAL,
4329 access_rx_csr_write_bad_addr_err_cnt),
4330[C_RX_CSR_READ_BAD_ADDR_ERR] = CNTR_ELEM("RxCsrReadBadAddrErr", 0, 0,
4331 CNTR_NORMAL,
4332 access_rx_csr_read_bad_addr_err_cnt),
4333[C_RX_DMA_CSR_UNC_ERR] = CNTR_ELEM("RxDmaCsrUncErr", 0, 0,
4334 CNTR_NORMAL,
4335 access_rx_dma_csr_unc_err_cnt),
4336[C_RX_DMA_DQ_FSM_ENCODING_ERR] = CNTR_ELEM("RxDmaDqFsmEncodingErr", 0, 0,
4337 CNTR_NORMAL,
4338 access_rx_dma_dq_fsm_encoding_err_cnt),
4339[C_RX_DMA_EQ_FSM_ENCODING_ERR] = CNTR_ELEM("RxDmaEqFsmEncodingErr", 0, 0,
4340 CNTR_NORMAL,
4341 access_rx_dma_eq_fsm_encoding_err_cnt),
4342[C_RX_DMA_CSR_PARITY_ERR] = CNTR_ELEM("RxDmaCsrParityErr", 0, 0,
4343 CNTR_NORMAL,
4344 access_rx_dma_csr_parity_err_cnt),
4345[C_RX_RBUF_DATA_COR_ERR] = CNTR_ELEM("RxRbufDataCorErr", 0, 0,
4346 CNTR_NORMAL,
4347 access_rx_rbuf_data_cor_err_cnt),
4348[C_RX_RBUF_DATA_UNC_ERR] = CNTR_ELEM("RxRbufDataUncErr", 0, 0,
4349 CNTR_NORMAL,
4350 access_rx_rbuf_data_unc_err_cnt),
4351[C_RX_DMA_DATA_FIFO_RD_COR_ERR] = CNTR_ELEM("RxDmaDataFifoRdCorErr", 0, 0,
4352 CNTR_NORMAL,
4353 access_rx_dma_data_fifo_rd_cor_err_cnt),
4354[C_RX_DMA_DATA_FIFO_RD_UNC_ERR] = CNTR_ELEM("RxDmaDataFifoRdUncErr", 0, 0,
4355 CNTR_NORMAL,
4356 access_rx_dma_data_fifo_rd_unc_err_cnt),
4357[C_RX_DMA_HDR_FIFO_RD_COR_ERR] = CNTR_ELEM("RxDmaHdrFifoRdCorErr", 0, 0,
4358 CNTR_NORMAL,
4359 access_rx_dma_hdr_fifo_rd_cor_err_cnt),
4360[C_RX_DMA_HDR_FIFO_RD_UNC_ERR] = CNTR_ELEM("RxDmaHdrFifoRdUncErr", 0, 0,
4361 CNTR_NORMAL,
4362 access_rx_dma_hdr_fifo_rd_unc_err_cnt),
4363[C_RX_RBUF_DESC_PART2_COR_ERR] = CNTR_ELEM("RxRbufDescPart2CorErr", 0, 0,
4364 CNTR_NORMAL,
4365 access_rx_rbuf_desc_part2_cor_err_cnt),
4366[C_RX_RBUF_DESC_PART2_UNC_ERR] = CNTR_ELEM("RxRbufDescPart2UncErr", 0, 0,
4367 CNTR_NORMAL,
4368 access_rx_rbuf_desc_part2_unc_err_cnt),
4369[C_RX_RBUF_DESC_PART1_COR_ERR] = CNTR_ELEM("RxRbufDescPart1CorErr", 0, 0,
4370 CNTR_NORMAL,
4371 access_rx_rbuf_desc_part1_cor_err_cnt),
4372[C_RX_RBUF_DESC_PART1_UNC_ERR] = CNTR_ELEM("RxRbufDescPart1UncErr", 0, 0,
4373 CNTR_NORMAL,
4374 access_rx_rbuf_desc_part1_unc_err_cnt),
4375[C_RX_HQ_INTR_FSM_ERR] = CNTR_ELEM("RxHqIntrFsmErr", 0, 0,
4376 CNTR_NORMAL,
4377 access_rx_hq_intr_fsm_err_cnt),
4378[C_RX_HQ_INTR_CSR_PARITY_ERR] = CNTR_ELEM("RxHqIntrCsrParityErr", 0, 0,
4379 CNTR_NORMAL,
4380 access_rx_hq_intr_csr_parity_err_cnt),
4381[C_RX_LOOKUP_CSR_PARITY_ERR] = CNTR_ELEM("RxLookupCsrParityErr", 0, 0,
4382 CNTR_NORMAL,
4383 access_rx_lookup_csr_parity_err_cnt),
4384[C_RX_LOOKUP_RCV_ARRAY_COR_ERR] = CNTR_ELEM("RxLookupRcvArrayCorErr", 0, 0,
4385 CNTR_NORMAL,
4386 access_rx_lookup_rcv_array_cor_err_cnt),
4387[C_RX_LOOKUP_RCV_ARRAY_UNC_ERR] = CNTR_ELEM("RxLookupRcvArrayUncErr", 0, 0,
4388 CNTR_NORMAL,
4389 access_rx_lookup_rcv_array_unc_err_cnt),
4390[C_RX_LOOKUP_DES_PART2_PARITY_ERR] = CNTR_ELEM("RxLookupDesPart2ParityErr", 0,
4391 0, CNTR_NORMAL,
4392 access_rx_lookup_des_part2_parity_err_cnt),
4393[C_RX_LOOKUP_DES_PART1_UNC_COR_ERR] = CNTR_ELEM("RxLookupDesPart1UncCorErr", 0,
4394 0, CNTR_NORMAL,
4395 access_rx_lookup_des_part1_unc_cor_err_cnt),
4396[C_RX_LOOKUP_DES_PART1_UNC_ERR] = CNTR_ELEM("RxLookupDesPart1UncErr", 0, 0,
4397 CNTR_NORMAL,
4398 access_rx_lookup_des_part1_unc_err_cnt),
4399[C_RX_RBUF_NEXT_FREE_BUF_COR_ERR] = CNTR_ELEM("RxRbufNextFreeBufCorErr", 0, 0,
4400 CNTR_NORMAL,
4401 access_rx_rbuf_next_free_buf_cor_err_cnt),
4402[C_RX_RBUF_NEXT_FREE_BUF_UNC_ERR] = CNTR_ELEM("RxRbufNextFreeBufUncErr", 0, 0,
4403 CNTR_NORMAL,
4404 access_rx_rbuf_next_free_buf_unc_err_cnt),
4405[C_RX_RBUF_FL_INIT_WR_ADDR_PARITY_ERR] = CNTR_ELEM(
4406 "RxRbufFlInitWrAddrParityErr", 0, 0,
4407 CNTR_NORMAL,
4408 access_rbuf_fl_init_wr_addr_parity_err_cnt),
4409[C_RX_RBUF_FL_INITDONE_PARITY_ERR] = CNTR_ELEM("RxRbufFlInitdoneParityErr", 0,
4410 0, CNTR_NORMAL,
4411 access_rx_rbuf_fl_initdone_parity_err_cnt),
4412[C_RX_RBUF_FL_WRITE_ADDR_PARITY_ERR] = CNTR_ELEM("RxRbufFlWrAddrParityErr", 0,
4413 0, CNTR_NORMAL,
4414 access_rx_rbuf_fl_write_addr_parity_err_cnt),
4415[C_RX_RBUF_FL_RD_ADDR_PARITY_ERR] = CNTR_ELEM("RxRbufFlRdAddrParityErr", 0, 0,
4416 CNTR_NORMAL,
4417 access_rx_rbuf_fl_rd_addr_parity_err_cnt),
4418[C_RX_RBUF_EMPTY_ERR] = CNTR_ELEM("RxRbufEmptyErr", 0, 0,
4419 CNTR_NORMAL,
4420 access_rx_rbuf_empty_err_cnt),
4421[C_RX_RBUF_FULL_ERR] = CNTR_ELEM("RxRbufFullErr", 0, 0,
4422 CNTR_NORMAL,
4423 access_rx_rbuf_full_err_cnt),
4424[C_RX_RBUF_BAD_LOOKUP_ERR] = CNTR_ELEM("RxRBufBadLookupErr", 0, 0,
4425 CNTR_NORMAL,
4426 access_rbuf_bad_lookup_err_cnt),
4427[C_RX_RBUF_CTX_ID_PARITY_ERR] = CNTR_ELEM("RxRbufCtxIdParityErr", 0, 0,
4428 CNTR_NORMAL,
4429 access_rbuf_ctx_id_parity_err_cnt),
4430[C_RX_RBUF_CSR_QEOPDW_PARITY_ERR] = CNTR_ELEM("RxRbufCsrQEOPDWParityErr", 0, 0,
4431 CNTR_NORMAL,
4432 access_rbuf_csr_qeopdw_parity_err_cnt),
4433[C_RX_RBUF_CSR_Q_NUM_OF_PKT_PARITY_ERR] = CNTR_ELEM(
4434 "RxRbufCsrQNumOfPktParityErr", 0, 0,
4435 CNTR_NORMAL,
4436 access_rx_rbuf_csr_q_num_of_pkt_parity_err_cnt),
4437[C_RX_RBUF_CSR_Q_T1_PTR_PARITY_ERR] = CNTR_ELEM(
4438 "RxRbufCsrQTlPtrParityErr", 0, 0,
4439 CNTR_NORMAL,
4440 access_rx_rbuf_csr_q_t1_ptr_parity_err_cnt),
4441[C_RX_RBUF_CSR_Q_HD_PTR_PARITY_ERR] = CNTR_ELEM("RxRbufCsrQHdPtrParityErr", 0,
4442 0, CNTR_NORMAL,
4443 access_rx_rbuf_csr_q_hd_ptr_parity_err_cnt),
4444[C_RX_RBUF_CSR_Q_VLD_BIT_PARITY_ERR] = CNTR_ELEM("RxRbufCsrQVldBitParityErr", 0,
4445 0, CNTR_NORMAL,
4446 access_rx_rbuf_csr_q_vld_bit_parity_err_cnt),
4447[C_RX_RBUF_CSR_Q_NEXT_BUF_PARITY_ERR] = CNTR_ELEM("RxRbufCsrQNextBufParityErr",
4448 0, 0, CNTR_NORMAL,
4449 access_rx_rbuf_csr_q_next_buf_parity_err_cnt),
4450[C_RX_RBUF_CSR_Q_ENT_CNT_PARITY_ERR] = CNTR_ELEM("RxRbufCsrQEntCntParityErr", 0,
4451 0, CNTR_NORMAL,
4452 access_rx_rbuf_csr_q_ent_cnt_parity_err_cnt),
4453[C_RX_RBUF_CSR_Q_HEAD_BUF_NUM_PARITY_ERR] = CNTR_ELEM(
4454 "RxRbufCsrQHeadBufNumParityErr", 0, 0,
4455 CNTR_NORMAL,
4456 access_rx_rbuf_csr_q_head_buf_num_parity_err_cnt),
4457[C_RX_RBUF_BLOCK_LIST_READ_COR_ERR] = CNTR_ELEM("RxRbufBlockListReadCorErr", 0,
4458 0, CNTR_NORMAL,
4459 access_rx_rbuf_block_list_read_cor_err_cnt),
4460[C_RX_RBUF_BLOCK_LIST_READ_UNC_ERR] = CNTR_ELEM("RxRbufBlockListReadUncErr", 0,
4461 0, CNTR_NORMAL,
4462 access_rx_rbuf_block_list_read_unc_err_cnt),
4463[C_RX_RBUF_LOOKUP_DES_COR_ERR] = CNTR_ELEM("RxRbufLookupDesCorErr", 0, 0,
4464 CNTR_NORMAL,
4465 access_rx_rbuf_lookup_des_cor_err_cnt),
4466[C_RX_RBUF_LOOKUP_DES_UNC_ERR] = CNTR_ELEM("RxRbufLookupDesUncErr", 0, 0,
4467 CNTR_NORMAL,
4468 access_rx_rbuf_lookup_des_unc_err_cnt),
4469[C_RX_RBUF_LOOKUP_DES_REG_UNC_COR_ERR] = CNTR_ELEM(
4470 "RxRbufLookupDesRegUncCorErr", 0, 0,
4471 CNTR_NORMAL,
4472 access_rx_rbuf_lookup_des_reg_unc_cor_err_cnt),
4473[C_RX_RBUF_LOOKUP_DES_REG_UNC_ERR] = CNTR_ELEM("RxRbufLookupDesRegUncErr", 0, 0,
4474 CNTR_NORMAL,
4475 access_rx_rbuf_lookup_des_reg_unc_err_cnt),
4476[C_RX_RBUF_FREE_LIST_COR_ERR] = CNTR_ELEM("RxRbufFreeListCorErr", 0, 0,
4477 CNTR_NORMAL,
4478 access_rx_rbuf_free_list_cor_err_cnt),
4479[C_RX_RBUF_FREE_LIST_UNC_ERR] = CNTR_ELEM("RxRbufFreeListUncErr", 0, 0,
4480 CNTR_NORMAL,
4481 access_rx_rbuf_free_list_unc_err_cnt),
4482[C_RX_RCV_FSM_ENCODING_ERR] = CNTR_ELEM("RxRcvFsmEncodingErr", 0, 0,
4483 CNTR_NORMAL,
4484 access_rx_rcv_fsm_encoding_err_cnt),
4485[C_RX_DMA_FLAG_COR_ERR] = CNTR_ELEM("RxDmaFlagCorErr", 0, 0,
4486 CNTR_NORMAL,
4487 access_rx_dma_flag_cor_err_cnt),
4488[C_RX_DMA_FLAG_UNC_ERR] = CNTR_ELEM("RxDmaFlagUncErr", 0, 0,
4489 CNTR_NORMAL,
4490 access_rx_dma_flag_unc_err_cnt),
4491[C_RX_DC_SOP_EOP_PARITY_ERR] = CNTR_ELEM("RxDcSopEopParityErr", 0, 0,
4492 CNTR_NORMAL,
4493 access_rx_dc_sop_eop_parity_err_cnt),
4494[C_RX_RCV_CSR_PARITY_ERR] = CNTR_ELEM("RxRcvCsrParityErr", 0, 0,
4495 CNTR_NORMAL,
4496 access_rx_rcv_csr_parity_err_cnt),
4497[C_RX_RCV_QP_MAP_TABLE_COR_ERR] = CNTR_ELEM("RxRcvQpMapTableCorErr", 0, 0,
4498 CNTR_NORMAL,
4499 access_rx_rcv_qp_map_table_cor_err_cnt),
4500[C_RX_RCV_QP_MAP_TABLE_UNC_ERR] = CNTR_ELEM("RxRcvQpMapTableUncErr", 0, 0,
4501 CNTR_NORMAL,
4502 access_rx_rcv_qp_map_table_unc_err_cnt),
4503[C_RX_RCV_DATA_COR_ERR] = CNTR_ELEM("RxRcvDataCorErr", 0, 0,
4504 CNTR_NORMAL,
4505 access_rx_rcv_data_cor_err_cnt),
4506[C_RX_RCV_DATA_UNC_ERR] = CNTR_ELEM("RxRcvDataUncErr", 0, 0,
4507 CNTR_NORMAL,
4508 access_rx_rcv_data_unc_err_cnt),
4509[C_RX_RCV_HDR_COR_ERR] = CNTR_ELEM("RxRcvHdrCorErr", 0, 0,
4510 CNTR_NORMAL,
4511 access_rx_rcv_hdr_cor_err_cnt),
4512[C_RX_RCV_HDR_UNC_ERR] = CNTR_ELEM("RxRcvHdrUncErr", 0, 0,
4513 CNTR_NORMAL,
4514 access_rx_rcv_hdr_unc_err_cnt),
4515[C_RX_DC_INTF_PARITY_ERR] = CNTR_ELEM("RxDcIntfParityErr", 0, 0,
4516 CNTR_NORMAL,
4517 access_rx_dc_intf_parity_err_cnt),
4518[C_RX_DMA_CSR_COR_ERR] = CNTR_ELEM("RxDmaCsrCorErr", 0, 0,
4519 CNTR_NORMAL,
4520 access_rx_dma_csr_cor_err_cnt),
4521/* SendPioErrStatus */
4522[C_PIO_PEC_SOP_HEAD_PARITY_ERR] = CNTR_ELEM("PioPecSopHeadParityErr", 0, 0,
4523 CNTR_NORMAL,
4524 access_pio_pec_sop_head_parity_err_cnt),
4525[C_PIO_PCC_SOP_HEAD_PARITY_ERR] = CNTR_ELEM("PioPccSopHeadParityErr", 0, 0,
4526 CNTR_NORMAL,
4527 access_pio_pcc_sop_head_parity_err_cnt),
4528[C_PIO_LAST_RETURNED_CNT_PARITY_ERR] = CNTR_ELEM("PioLastReturnedCntParityErr",
4529 0, 0, CNTR_NORMAL,
4530 access_pio_last_returned_cnt_parity_err_cnt),
4531[C_PIO_CURRENT_FREE_CNT_PARITY_ERR] = CNTR_ELEM("PioCurrentFreeCntParityErr", 0,
4532 0, CNTR_NORMAL,
4533 access_pio_current_free_cnt_parity_err_cnt),
4534[C_PIO_RSVD_31_ERR] = CNTR_ELEM("Pio Reserved 31", 0, 0,
4535 CNTR_NORMAL,
4536 access_pio_reserved_31_err_cnt),
4537[C_PIO_RSVD_30_ERR] = CNTR_ELEM("Pio Reserved 30", 0, 0,
4538 CNTR_NORMAL,
4539 access_pio_reserved_30_err_cnt),
4540[C_PIO_PPMC_SOP_LEN_ERR] = CNTR_ELEM("PioPpmcSopLenErr", 0, 0,
4541 CNTR_NORMAL,
4542 access_pio_ppmc_sop_len_err_cnt),
4543[C_PIO_PPMC_BQC_MEM_PARITY_ERR] = CNTR_ELEM("PioPpmcBqcMemParityErr", 0, 0,
4544 CNTR_NORMAL,
4545 access_pio_ppmc_bqc_mem_parity_err_cnt),
4546[C_PIO_VL_FIFO_PARITY_ERR] = CNTR_ELEM("PioVlFifoParityErr", 0, 0,
4547 CNTR_NORMAL,
4548 access_pio_vl_fifo_parity_err_cnt),
4549[C_PIO_VLF_SOP_PARITY_ERR] = CNTR_ELEM("PioVlfSopParityErr", 0, 0,
4550 CNTR_NORMAL,
4551 access_pio_vlf_sop_parity_err_cnt),
4552[C_PIO_VLF_V1_LEN_PARITY_ERR] = CNTR_ELEM("PioVlfVlLenParityErr", 0, 0,
4553 CNTR_NORMAL,
4554 access_pio_vlf_v1_len_parity_err_cnt),
4555[C_PIO_BLOCK_QW_COUNT_PARITY_ERR] = CNTR_ELEM("PioBlockQwCountParityErr", 0, 0,
4556 CNTR_NORMAL,
4557 access_pio_block_qw_count_parity_err_cnt),
4558[C_PIO_WRITE_QW_VALID_PARITY_ERR] = CNTR_ELEM("PioWriteQwValidParityErr", 0, 0,
4559 CNTR_NORMAL,
4560 access_pio_write_qw_valid_parity_err_cnt),
4561[C_PIO_STATE_MACHINE_ERR] = CNTR_ELEM("PioStateMachineErr", 0, 0,
4562 CNTR_NORMAL,
4563 access_pio_state_machine_err_cnt),
4564[C_PIO_WRITE_DATA_PARITY_ERR] = CNTR_ELEM("PioWriteDataParityErr", 0, 0,
4565 CNTR_NORMAL,
4566 access_pio_write_data_parity_err_cnt),
4567[C_PIO_HOST_ADDR_MEM_COR_ERR] = CNTR_ELEM("PioHostAddrMemCorErr", 0, 0,
4568 CNTR_NORMAL,
4569 access_pio_host_addr_mem_cor_err_cnt),
4570[C_PIO_HOST_ADDR_MEM_UNC_ERR] = CNTR_ELEM("PioHostAddrMemUncErr", 0, 0,
4571 CNTR_NORMAL,
4572 access_pio_host_addr_mem_unc_err_cnt),
4573[C_PIO_PKT_EVICT_SM_OR_ARM_SM_ERR] = CNTR_ELEM("PioPktEvictSmOrArbSmErr", 0, 0,
4574 CNTR_NORMAL,
4575 access_pio_pkt_evict_sm_or_arb_sm_err_cnt),
4576[C_PIO_INIT_SM_IN_ERR] = CNTR_ELEM("PioInitSmInErr", 0, 0,
4577 CNTR_NORMAL,
4578 access_pio_init_sm_in_err_cnt),
4579[C_PIO_PPMC_PBL_FIFO_ERR] = CNTR_ELEM("PioPpmcPblFifoErr", 0, 0,
4580 CNTR_NORMAL,
4581 access_pio_ppmc_pbl_fifo_err_cnt),
4582[C_PIO_CREDIT_RET_FIFO_PARITY_ERR] = CNTR_ELEM("PioCreditRetFifoParityErr", 0,
4583 0, CNTR_NORMAL,
4584 access_pio_credit_ret_fifo_parity_err_cnt),
4585[C_PIO_V1_LEN_MEM_BANK1_COR_ERR] = CNTR_ELEM("PioVlLenMemBank1CorErr", 0, 0,
4586 CNTR_NORMAL,
4587 access_pio_v1_len_mem_bank1_cor_err_cnt),
4588[C_PIO_V1_LEN_MEM_BANK0_COR_ERR] = CNTR_ELEM("PioVlLenMemBank0CorErr", 0, 0,
4589 CNTR_NORMAL,
4590 access_pio_v1_len_mem_bank0_cor_err_cnt),
4591[C_PIO_V1_LEN_MEM_BANK1_UNC_ERR] = CNTR_ELEM("PioVlLenMemBank1UncErr", 0, 0,
4592 CNTR_NORMAL,
4593 access_pio_v1_len_mem_bank1_unc_err_cnt),
4594[C_PIO_V1_LEN_MEM_BANK0_UNC_ERR] = CNTR_ELEM("PioVlLenMemBank0UncErr", 0, 0,
4595 CNTR_NORMAL,
4596 access_pio_v1_len_mem_bank0_unc_err_cnt),
4597[C_PIO_SM_PKT_RESET_PARITY_ERR] = CNTR_ELEM("PioSmPktResetParityErr", 0, 0,
4598 CNTR_NORMAL,
4599 access_pio_sm_pkt_reset_parity_err_cnt),
4600[C_PIO_PKT_EVICT_FIFO_PARITY_ERR] = CNTR_ELEM("PioPktEvictFifoParityErr", 0, 0,
4601 CNTR_NORMAL,
4602 access_pio_pkt_evict_fifo_parity_err_cnt),
4603[C_PIO_SBRDCTRL_CRREL_FIFO_PARITY_ERR] = CNTR_ELEM(
4604 "PioSbrdctrlCrrelFifoParityErr", 0, 0,
4605 CNTR_NORMAL,
4606 access_pio_sbrdctrl_crrel_fifo_parity_err_cnt),
4607[C_PIO_SBRDCTL_CRREL_PARITY_ERR] = CNTR_ELEM("PioSbrdctlCrrelParityErr", 0, 0,
4608 CNTR_NORMAL,
4609 access_pio_sbrdctl_crrel_parity_err_cnt),
4610[C_PIO_PEC_FIFO_PARITY_ERR] = CNTR_ELEM("PioPecFifoParityErr", 0, 0,
4611 CNTR_NORMAL,
4612 access_pio_pec_fifo_parity_err_cnt),
4613[C_PIO_PCC_FIFO_PARITY_ERR] = CNTR_ELEM("PioPccFifoParityErr", 0, 0,
4614 CNTR_NORMAL,
4615 access_pio_pcc_fifo_parity_err_cnt),
4616[C_PIO_SB_MEM_FIFO1_ERR] = CNTR_ELEM("PioSbMemFifo1Err", 0, 0,
4617 CNTR_NORMAL,
4618 access_pio_sb_mem_fifo1_err_cnt),
4619[C_PIO_SB_MEM_FIFO0_ERR] = CNTR_ELEM("PioSbMemFifo0Err", 0, 0,
4620 CNTR_NORMAL,
4621 access_pio_sb_mem_fifo0_err_cnt),
4622[C_PIO_CSR_PARITY_ERR] = CNTR_ELEM("PioCsrParityErr", 0, 0,
4623 CNTR_NORMAL,
4624 access_pio_csr_parity_err_cnt),
4625[C_PIO_WRITE_ADDR_PARITY_ERR] = CNTR_ELEM("PioWriteAddrParityErr", 0, 0,
4626 CNTR_NORMAL,
4627 access_pio_write_addr_parity_err_cnt),
4628[C_PIO_WRITE_BAD_CTXT_ERR] = CNTR_ELEM("PioWriteBadCtxtErr", 0, 0,
4629 CNTR_NORMAL,
4630 access_pio_write_bad_ctxt_err_cnt),
4631/* SendDmaErrStatus */
4632[C_SDMA_PCIE_REQ_TRACKING_COR_ERR] = CNTR_ELEM("SDmaPcieReqTrackingCorErr", 0,
4633 0, CNTR_NORMAL,
4634 access_sdma_pcie_req_tracking_cor_err_cnt),
4635[C_SDMA_PCIE_REQ_TRACKING_UNC_ERR] = CNTR_ELEM("SDmaPcieReqTrackingUncErr", 0,
4636 0, CNTR_NORMAL,
4637 access_sdma_pcie_req_tracking_unc_err_cnt),
4638[C_SDMA_CSR_PARITY_ERR] = CNTR_ELEM("SDmaCsrParityErr", 0, 0,
4639 CNTR_NORMAL,
4640 access_sdma_csr_parity_err_cnt),
4641[C_SDMA_RPY_TAG_ERR] = CNTR_ELEM("SDmaRpyTagErr", 0, 0,
4642 CNTR_NORMAL,
4643 access_sdma_rpy_tag_err_cnt),
4644/* SendEgressErrStatus */
4645[C_TX_READ_PIO_MEMORY_CSR_UNC_ERR] = CNTR_ELEM("TxReadPioMemoryCsrUncErr", 0, 0,
4646 CNTR_NORMAL,
4647 access_tx_read_pio_memory_csr_unc_err_cnt),
4648[C_TX_READ_SDMA_MEMORY_CSR_UNC_ERR] = CNTR_ELEM("TxReadSdmaMemoryCsrUncErr", 0,
4649 0, CNTR_NORMAL,
4650 access_tx_read_sdma_memory_csr_err_cnt),
4651[C_TX_EGRESS_FIFO_COR_ERR] = CNTR_ELEM("TxEgressFifoCorErr", 0, 0,
4652 CNTR_NORMAL,
4653 access_tx_egress_fifo_cor_err_cnt),
4654[C_TX_READ_PIO_MEMORY_COR_ERR] = CNTR_ELEM("TxReadPioMemoryCorErr", 0, 0,
4655 CNTR_NORMAL,
4656 access_tx_read_pio_memory_cor_err_cnt),
4657[C_TX_READ_SDMA_MEMORY_COR_ERR] = CNTR_ELEM("TxReadSdmaMemoryCorErr", 0, 0,
4658 CNTR_NORMAL,
4659 access_tx_read_sdma_memory_cor_err_cnt),
4660[C_TX_SB_HDR_COR_ERR] = CNTR_ELEM("TxSbHdrCorErr", 0, 0,
4661 CNTR_NORMAL,
4662 access_tx_sb_hdr_cor_err_cnt),
4663[C_TX_CREDIT_OVERRUN_ERR] = CNTR_ELEM("TxCreditOverrunErr", 0, 0,
4664 CNTR_NORMAL,
4665 access_tx_credit_overrun_err_cnt),
4666[C_TX_LAUNCH_FIFO8_COR_ERR] = CNTR_ELEM("TxLaunchFifo8CorErr", 0, 0,
4667 CNTR_NORMAL,
4668 access_tx_launch_fifo8_cor_err_cnt),
4669[C_TX_LAUNCH_FIFO7_COR_ERR] = CNTR_ELEM("TxLaunchFifo7CorErr", 0, 0,
4670 CNTR_NORMAL,
4671 access_tx_launch_fifo7_cor_err_cnt),
4672[C_TX_LAUNCH_FIFO6_COR_ERR] = CNTR_ELEM("TxLaunchFifo6CorErr", 0, 0,
4673 CNTR_NORMAL,
4674 access_tx_launch_fifo6_cor_err_cnt),
4675[C_TX_LAUNCH_FIFO5_COR_ERR] = CNTR_ELEM("TxLaunchFifo5CorErr", 0, 0,
4676 CNTR_NORMAL,
4677 access_tx_launch_fifo5_cor_err_cnt),
4678[C_TX_LAUNCH_FIFO4_COR_ERR] = CNTR_ELEM("TxLaunchFifo4CorErr", 0, 0,
4679 CNTR_NORMAL,
4680 access_tx_launch_fifo4_cor_err_cnt),
4681[C_TX_LAUNCH_FIFO3_COR_ERR] = CNTR_ELEM("TxLaunchFifo3CorErr", 0, 0,
4682 CNTR_NORMAL,
4683 access_tx_launch_fifo3_cor_err_cnt),
4684[C_TX_LAUNCH_FIFO2_COR_ERR] = CNTR_ELEM("TxLaunchFifo2CorErr", 0, 0,
4685 CNTR_NORMAL,
4686 access_tx_launch_fifo2_cor_err_cnt),
4687[C_TX_LAUNCH_FIFO1_COR_ERR] = CNTR_ELEM("TxLaunchFifo1CorErr", 0, 0,
4688 CNTR_NORMAL,
4689 access_tx_launch_fifo1_cor_err_cnt),
4690[C_TX_LAUNCH_FIFO0_COR_ERR] = CNTR_ELEM("TxLaunchFifo0CorErr", 0, 0,
4691 CNTR_NORMAL,
4692 access_tx_launch_fifo0_cor_err_cnt),
4693[C_TX_CREDIT_RETURN_VL_ERR] = CNTR_ELEM("TxCreditReturnVLErr", 0, 0,
4694 CNTR_NORMAL,
4695 access_tx_credit_return_vl_err_cnt),
4696[C_TX_HCRC_INSERTION_ERR] = CNTR_ELEM("TxHcrcInsertionErr", 0, 0,
4697 CNTR_NORMAL,
4698 access_tx_hcrc_insertion_err_cnt),
4699[C_TX_EGRESS_FIFI_UNC_ERR] = CNTR_ELEM("TxEgressFifoUncErr", 0, 0,
4700 CNTR_NORMAL,
4701 access_tx_egress_fifo_unc_err_cnt),
4702[C_TX_READ_PIO_MEMORY_UNC_ERR] = CNTR_ELEM("TxReadPioMemoryUncErr", 0, 0,
4703 CNTR_NORMAL,
4704 access_tx_read_pio_memory_unc_err_cnt),
4705[C_TX_READ_SDMA_MEMORY_UNC_ERR] = CNTR_ELEM("TxReadSdmaMemoryUncErr", 0, 0,
4706 CNTR_NORMAL,
4707 access_tx_read_sdma_memory_unc_err_cnt),
4708[C_TX_SB_HDR_UNC_ERR] = CNTR_ELEM("TxSbHdrUncErr", 0, 0,
4709 CNTR_NORMAL,
4710 access_tx_sb_hdr_unc_err_cnt),
4711[C_TX_CREDIT_RETURN_PARITY_ERR] = CNTR_ELEM("TxCreditReturnParityErr", 0, 0,
4712 CNTR_NORMAL,
4713 access_tx_credit_return_partiy_err_cnt),
4714[C_TX_LAUNCH_FIFO8_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo8UncOrParityErr",
4715 0, 0, CNTR_NORMAL,
4716 access_tx_launch_fifo8_unc_or_parity_err_cnt),
4717[C_TX_LAUNCH_FIFO7_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo7UncOrParityErr",
4718 0, 0, CNTR_NORMAL,
4719 access_tx_launch_fifo7_unc_or_parity_err_cnt),
4720[C_TX_LAUNCH_FIFO6_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo6UncOrParityErr",
4721 0, 0, CNTR_NORMAL,
4722 access_tx_launch_fifo6_unc_or_parity_err_cnt),
4723[C_TX_LAUNCH_FIFO5_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo5UncOrParityErr",
4724 0, 0, CNTR_NORMAL,
4725 access_tx_launch_fifo5_unc_or_parity_err_cnt),
4726[C_TX_LAUNCH_FIFO4_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo4UncOrParityErr",
4727 0, 0, CNTR_NORMAL,
4728 access_tx_launch_fifo4_unc_or_parity_err_cnt),
4729[C_TX_LAUNCH_FIFO3_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo3UncOrParityErr",
4730 0, 0, CNTR_NORMAL,
4731 access_tx_launch_fifo3_unc_or_parity_err_cnt),
4732[C_TX_LAUNCH_FIFO2_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo2UncOrParityErr",
4733 0, 0, CNTR_NORMAL,
4734 access_tx_launch_fifo2_unc_or_parity_err_cnt),
4735[C_TX_LAUNCH_FIFO1_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo1UncOrParityErr",
4736 0, 0, CNTR_NORMAL,
4737 access_tx_launch_fifo1_unc_or_parity_err_cnt),
4738[C_TX_LAUNCH_FIFO0_UNC_OR_PARITY_ERR] = CNTR_ELEM("TxLaunchFifo0UncOrParityErr",
4739 0, 0, CNTR_NORMAL,
4740 access_tx_launch_fifo0_unc_or_parity_err_cnt),
4741[C_TX_SDMA15_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma15DisallowedPacketErr",
4742 0, 0, CNTR_NORMAL,
4743 access_tx_sdma15_disallowed_packet_err_cnt),
4744[C_TX_SDMA14_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma14DisallowedPacketErr",
4745 0, 0, CNTR_NORMAL,
4746 access_tx_sdma14_disallowed_packet_err_cnt),
4747[C_TX_SDMA13_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma13DisallowedPacketErr",
4748 0, 0, CNTR_NORMAL,
4749 access_tx_sdma13_disallowed_packet_err_cnt),
4750[C_TX_SDMA12_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma12DisallowedPacketErr",
4751 0, 0, CNTR_NORMAL,
4752 access_tx_sdma12_disallowed_packet_err_cnt),
4753[C_TX_SDMA11_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma11DisallowedPacketErr",
4754 0, 0, CNTR_NORMAL,
4755 access_tx_sdma11_disallowed_packet_err_cnt),
4756[C_TX_SDMA10_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma10DisallowedPacketErr",
4757 0, 0, CNTR_NORMAL,
4758 access_tx_sdma10_disallowed_packet_err_cnt),
4759[C_TX_SDMA9_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma9DisallowedPacketErr",
4760 0, 0, CNTR_NORMAL,
4761 access_tx_sdma9_disallowed_packet_err_cnt),
4762[C_TX_SDMA8_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma8DisallowedPacketErr",
4763 0, 0, CNTR_NORMAL,
4764 access_tx_sdma8_disallowed_packet_err_cnt),
4765[C_TX_SDMA7_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma7DisallowedPacketErr",
4766 0, 0, CNTR_NORMAL,
4767 access_tx_sdma7_disallowed_packet_err_cnt),
4768[C_TX_SDMA6_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma6DisallowedPacketErr",
4769 0, 0, CNTR_NORMAL,
4770 access_tx_sdma6_disallowed_packet_err_cnt),
4771[C_TX_SDMA5_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma5DisallowedPacketErr",
4772 0, 0, CNTR_NORMAL,
4773 access_tx_sdma5_disallowed_packet_err_cnt),
4774[C_TX_SDMA4_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma4DisallowedPacketErr",
4775 0, 0, CNTR_NORMAL,
4776 access_tx_sdma4_disallowed_packet_err_cnt),
4777[C_TX_SDMA3_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma3DisallowedPacketErr",
4778 0, 0, CNTR_NORMAL,
4779 access_tx_sdma3_disallowed_packet_err_cnt),
4780[C_TX_SDMA2_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma2DisallowedPacketErr",
4781 0, 0, CNTR_NORMAL,
4782 access_tx_sdma2_disallowed_packet_err_cnt),
4783[C_TX_SDMA1_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma1DisallowedPacketErr",
4784 0, 0, CNTR_NORMAL,
4785 access_tx_sdma1_disallowed_packet_err_cnt),
4786[C_TX_SDMA0_DISALLOWED_PACKET_ERR] = CNTR_ELEM("TxSdma0DisallowedPacketErr",
4787 0, 0, CNTR_NORMAL,
4788 access_tx_sdma0_disallowed_packet_err_cnt),
4789[C_TX_CONFIG_PARITY_ERR] = CNTR_ELEM("TxConfigParityErr", 0, 0,
4790 CNTR_NORMAL,
4791 access_tx_config_parity_err_cnt),
4792[C_TX_SBRD_CTL_CSR_PARITY_ERR] = CNTR_ELEM("TxSbrdCtlCsrParityErr", 0, 0,
4793 CNTR_NORMAL,
4794 access_tx_sbrd_ctl_csr_parity_err_cnt),
4795[C_TX_LAUNCH_CSR_PARITY_ERR] = CNTR_ELEM("TxLaunchCsrParityErr", 0, 0,
4796 CNTR_NORMAL,
4797 access_tx_launch_csr_parity_err_cnt),
4798[C_TX_ILLEGAL_CL_ERR] = CNTR_ELEM("TxIllegalVLErr", 0, 0,
4799 CNTR_NORMAL,
4800 access_tx_illegal_vl_err_cnt),
4801[C_TX_SBRD_CTL_STATE_MACHINE_PARITY_ERR] = CNTR_ELEM(
4802 "TxSbrdCtlStateMachineParityErr", 0, 0,
4803 CNTR_NORMAL,
4804 access_tx_sbrd_ctl_state_machine_parity_err_cnt),
4805[C_TX_RESERVED_10] = CNTR_ELEM("Tx Egress Reserved 10", 0, 0,
4806 CNTR_NORMAL,
4807 access_egress_reserved_10_err_cnt),
4808[C_TX_RESERVED_9] = CNTR_ELEM("Tx Egress Reserved 9", 0, 0,
4809 CNTR_NORMAL,
4810 access_egress_reserved_9_err_cnt),
4811[C_TX_SDMA_LAUNCH_INTF_PARITY_ERR] = CNTR_ELEM("TxSdmaLaunchIntfParityErr",
4812 0, 0, CNTR_NORMAL,
4813 access_tx_sdma_launch_intf_parity_err_cnt),
4814[C_TX_PIO_LAUNCH_INTF_PARITY_ERR] = CNTR_ELEM("TxPioLaunchIntfParityErr", 0, 0,
4815 CNTR_NORMAL,
4816 access_tx_pio_launch_intf_parity_err_cnt),
4817[C_TX_RESERVED_6] = CNTR_ELEM("Tx Egress Reserved 6", 0, 0,
4818 CNTR_NORMAL,
4819 access_egress_reserved_6_err_cnt),
4820[C_TX_INCORRECT_LINK_STATE_ERR] = CNTR_ELEM("TxIncorrectLinkStateErr", 0, 0,
4821 CNTR_NORMAL,
4822 access_tx_incorrect_link_state_err_cnt),
4823[C_TX_LINK_DOWN_ERR] = CNTR_ELEM("TxLinkdownErr", 0, 0,
4824 CNTR_NORMAL,
4825 access_tx_linkdown_err_cnt),
4826[C_TX_EGRESS_FIFO_UNDERRUN_OR_PARITY_ERR] = CNTR_ELEM(
4827 "EgressFifoUnderrunOrParityErr", 0, 0,
4828 CNTR_NORMAL,
4829 access_tx_egress_fifi_underrun_or_parity_err_cnt),
4830[C_TX_RESERVED_2] = CNTR_ELEM("Tx Egress Reserved 2", 0, 0,
4831 CNTR_NORMAL,
4832 access_egress_reserved_2_err_cnt),
4833[C_TX_PKT_INTEGRITY_MEM_UNC_ERR] = CNTR_ELEM("TxPktIntegrityMemUncErr", 0, 0,
4834 CNTR_NORMAL,
4835 access_tx_pkt_integrity_mem_unc_err_cnt),
4836[C_TX_PKT_INTEGRITY_MEM_COR_ERR] = CNTR_ELEM("TxPktIntegrityMemCorErr", 0, 0,
4837 CNTR_NORMAL,
4838 access_tx_pkt_integrity_mem_cor_err_cnt),
4839/* SendErrStatus */
4840[C_SEND_CSR_WRITE_BAD_ADDR_ERR] = CNTR_ELEM("SendCsrWriteBadAddrErr", 0, 0,
4841 CNTR_NORMAL,
4842 access_send_csr_write_bad_addr_err_cnt),
4843[C_SEND_CSR_READ_BAD_ADD_ERR] = CNTR_ELEM("SendCsrReadBadAddrErr", 0, 0,
4844 CNTR_NORMAL,
4845 access_send_csr_read_bad_addr_err_cnt),
4846[C_SEND_CSR_PARITY_ERR] = CNTR_ELEM("SendCsrParityErr", 0, 0,
4847 CNTR_NORMAL,
4848 access_send_csr_parity_cnt),
4849/* SendCtxtErrStatus */
4850[C_PIO_WRITE_OUT_OF_BOUNDS_ERR] = CNTR_ELEM("PioWriteOutOfBoundsErr", 0, 0,
4851 CNTR_NORMAL,
4852 access_pio_write_out_of_bounds_err_cnt),
4853[C_PIO_WRITE_OVERFLOW_ERR] = CNTR_ELEM("PioWriteOverflowErr", 0, 0,
4854 CNTR_NORMAL,
4855 access_pio_write_overflow_err_cnt),
4856[C_PIO_WRITE_CROSSES_BOUNDARY_ERR] = CNTR_ELEM("PioWriteCrossesBoundaryErr",
4857 0, 0, CNTR_NORMAL,
4858 access_pio_write_crosses_boundary_err_cnt),
4859[C_PIO_DISALLOWED_PACKET_ERR] = CNTR_ELEM("PioDisallowedPacketErr", 0, 0,
4860 CNTR_NORMAL,
4861 access_pio_disallowed_packet_err_cnt),
4862[C_PIO_INCONSISTENT_SOP_ERR] = CNTR_ELEM("PioInconsistentSopErr", 0, 0,
4863 CNTR_NORMAL,
4864 access_pio_inconsistent_sop_err_cnt),
4865/* SendDmaEngErrStatus */
4866[C_SDMA_HEADER_REQUEST_FIFO_COR_ERR] = CNTR_ELEM("SDmaHeaderRequestFifoCorErr",
4867 0, 0, CNTR_NORMAL,
4868 access_sdma_header_request_fifo_cor_err_cnt),
4869[C_SDMA_HEADER_STORAGE_COR_ERR] = CNTR_ELEM("SDmaHeaderStorageCorErr", 0, 0,
4870 CNTR_NORMAL,
4871 access_sdma_header_storage_cor_err_cnt),
4872[C_SDMA_PACKET_TRACKING_COR_ERR] = CNTR_ELEM("SDmaPacketTrackingCorErr", 0, 0,
4873 CNTR_NORMAL,
4874 access_sdma_packet_tracking_cor_err_cnt),
4875[C_SDMA_ASSEMBLY_COR_ERR] = CNTR_ELEM("SDmaAssemblyCorErr", 0, 0,
4876 CNTR_NORMAL,
4877 access_sdma_assembly_cor_err_cnt),
4878[C_SDMA_DESC_TABLE_COR_ERR] = CNTR_ELEM("SDmaDescTableCorErr", 0, 0,
4879 CNTR_NORMAL,
4880 access_sdma_desc_table_cor_err_cnt),
4881[C_SDMA_HEADER_REQUEST_FIFO_UNC_ERR] = CNTR_ELEM("SDmaHeaderRequestFifoUncErr",
4882 0, 0, CNTR_NORMAL,
4883 access_sdma_header_request_fifo_unc_err_cnt),
4884[C_SDMA_HEADER_STORAGE_UNC_ERR] = CNTR_ELEM("SDmaHeaderStorageUncErr", 0, 0,
4885 CNTR_NORMAL,
4886 access_sdma_header_storage_unc_err_cnt),
4887[C_SDMA_PACKET_TRACKING_UNC_ERR] = CNTR_ELEM("SDmaPacketTrackingUncErr", 0, 0,
4888 CNTR_NORMAL,
4889 access_sdma_packet_tracking_unc_err_cnt),
4890[C_SDMA_ASSEMBLY_UNC_ERR] = CNTR_ELEM("SDmaAssemblyUncErr", 0, 0,
4891 CNTR_NORMAL,
4892 access_sdma_assembly_unc_err_cnt),
4893[C_SDMA_DESC_TABLE_UNC_ERR] = CNTR_ELEM("SDmaDescTableUncErr", 0, 0,
4894 CNTR_NORMAL,
4895 access_sdma_desc_table_unc_err_cnt),
4896[C_SDMA_TIMEOUT_ERR] = CNTR_ELEM("SDmaTimeoutErr", 0, 0,
4897 CNTR_NORMAL,
4898 access_sdma_timeout_err_cnt),
4899[C_SDMA_HEADER_LENGTH_ERR] = CNTR_ELEM("SDmaHeaderLengthErr", 0, 0,
4900 CNTR_NORMAL,
4901 access_sdma_header_length_err_cnt),
4902[C_SDMA_HEADER_ADDRESS_ERR] = CNTR_ELEM("SDmaHeaderAddressErr", 0, 0,
4903 CNTR_NORMAL,
4904 access_sdma_header_address_err_cnt),
4905[C_SDMA_HEADER_SELECT_ERR] = CNTR_ELEM("SDmaHeaderSelectErr", 0, 0,
4906 CNTR_NORMAL,
4907 access_sdma_header_select_err_cnt),
4908[C_SMDA_RESERVED_9] = CNTR_ELEM("SDma Reserved 9", 0, 0,
4909 CNTR_NORMAL,
4910 access_sdma_reserved_9_err_cnt),
4911[C_SDMA_PACKET_DESC_OVERFLOW_ERR] = CNTR_ELEM("SDmaPacketDescOverflowErr", 0, 0,
4912 CNTR_NORMAL,
4913 access_sdma_packet_desc_overflow_err_cnt),
4914[C_SDMA_LENGTH_MISMATCH_ERR] = CNTR_ELEM("SDmaLengthMismatchErr", 0, 0,
4915 CNTR_NORMAL,
4916 access_sdma_length_mismatch_err_cnt),
4917[C_SDMA_HALT_ERR] = CNTR_ELEM("SDmaHaltErr", 0, 0,
4918 CNTR_NORMAL,
4919 access_sdma_halt_err_cnt),
4920[C_SDMA_MEM_READ_ERR] = CNTR_ELEM("SDmaMemReadErr", 0, 0,
4921 CNTR_NORMAL,
4922 access_sdma_mem_read_err_cnt),
4923[C_SDMA_FIRST_DESC_ERR] = CNTR_ELEM("SDmaFirstDescErr", 0, 0,
4924 CNTR_NORMAL,
4925 access_sdma_first_desc_err_cnt),
4926[C_SDMA_TAIL_OUT_OF_BOUNDS_ERR] = CNTR_ELEM("SDmaTailOutOfBoundsErr", 0, 0,
4927 CNTR_NORMAL,
4928 access_sdma_tail_out_of_bounds_err_cnt),
4929[C_SDMA_TOO_LONG_ERR] = CNTR_ELEM("SDmaTooLongErr", 0, 0,
4930 CNTR_NORMAL,
4931 access_sdma_too_long_err_cnt),
4932[C_SDMA_GEN_MISMATCH_ERR] = CNTR_ELEM("SDmaGenMismatchErr", 0, 0,
4933 CNTR_NORMAL,
4934 access_sdma_gen_mismatch_err_cnt),
4935[C_SDMA_WRONG_DW_ERR] = CNTR_ELEM("SDmaWrongDwErr", 0, 0,
4936 CNTR_NORMAL,
4937 access_sdma_wrong_dw_err_cnt),
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]4938};
4939
4940static struct cntr_entry port_cntrs[PORT_CNTR_LAST] = {
4941[C_TX_UNSUP_VL] = TXE32_PORT_CNTR_ELEM(TxUnVLErr, SEND_UNSUP_VL_ERR_CNT,
4942 CNTR_NORMAL),
4943[C_TX_INVAL_LEN] = TXE32_PORT_CNTR_ELEM(TxInvalLen, SEND_LEN_ERR_CNT,
4944 CNTR_NORMAL),
4945[C_TX_MM_LEN_ERR] = TXE32_PORT_CNTR_ELEM(TxMMLenErr, SEND_MAX_MIN_LEN_ERR_CNT,
4946 CNTR_NORMAL),
4947[C_TX_UNDERRUN] = TXE32_PORT_CNTR_ELEM(TxUnderrun, SEND_UNDERRUN_CNT,
4948 CNTR_NORMAL),
4949[C_TX_FLOW_STALL] = TXE32_PORT_CNTR_ELEM(TxFlowStall, SEND_FLOW_STALL_CNT,
4950 CNTR_NORMAL),
4951[C_TX_DROPPED] = TXE32_PORT_CNTR_ELEM(TxDropped, SEND_DROPPED_PKT_CNT,
4952 CNTR_NORMAL),
4953[C_TX_HDR_ERR] = TXE32_PORT_CNTR_ELEM(TxHdrErr, SEND_HEADERS_ERR_CNT,
4954 CNTR_NORMAL),
4955[C_TX_PKT] = TXE64_PORT_CNTR_ELEM(TxPkt, SEND_DATA_PKT_CNT, CNTR_NORMAL),
4956[C_TX_WORDS] = TXE64_PORT_CNTR_ELEM(TxWords, SEND_DWORD_CNT, CNTR_NORMAL),
4957[C_TX_WAIT] = TXE64_PORT_CNTR_ELEM(TxWait, SEND_WAIT_CNT, CNTR_SYNTH),
4958[C_TX_FLIT_VL] = TXE64_PORT_CNTR_ELEM(TxFlitVL, SEND_DATA_VL0_CNT,
4959 CNTR_SYNTH | CNTR_VL),
4960[C_TX_PKT_VL] = TXE64_PORT_CNTR_ELEM(TxPktVL, SEND_DATA_PKT_VL0_CNT,
4961 CNTR_SYNTH | CNTR_VL),
4962[C_TX_WAIT_VL] = TXE64_PORT_CNTR_ELEM(TxWaitVL, SEND_WAIT_VL0_CNT,
4963 CNTR_SYNTH | CNTR_VL),
4964[C_RX_PKT] = RXE64_PORT_CNTR_ELEM(RxPkt, RCV_DATA_PKT_CNT, CNTR_NORMAL),
4965[C_RX_WORDS] = RXE64_PORT_CNTR_ELEM(RxWords, RCV_DWORD_CNT, CNTR_NORMAL),
4966[C_SW_LINK_DOWN] = CNTR_ELEM("SwLinkDown", 0, 0, CNTR_SYNTH | CNTR_32BIT,
4967 access_sw_link_dn_cnt),
4968[C_SW_LINK_UP] = CNTR_ELEM("SwLinkUp", 0, 0, CNTR_SYNTH | CNTR_32BIT,
4969 access_sw_link_up_cnt),
Dean Luick6d014532015-12-01 15:38:23 -0500[diff] [blame]4970[C_SW_UNKNOWN_FRAME] = CNTR_ELEM("UnknownFrame", 0, 0, CNTR_NORMAL,
4971 access_sw_unknown_frame_cnt),
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]4972[C_SW_XMIT_DSCD] = CNTR_ELEM("XmitDscd", 0, 0, CNTR_SYNTH | CNTR_32BIT,
4973 access_sw_xmit_discards),
4974[C_SW_XMIT_DSCD_VL] = CNTR_ELEM("XmitDscdVl", 0, 0,
4975 CNTR_SYNTH | CNTR_32BIT | CNTR_VL,
4976 access_sw_xmit_discards),
4977[C_SW_XMIT_CSTR_ERR] = CNTR_ELEM("XmitCstrErr", 0, 0, CNTR_SYNTH,
4978 access_xmit_constraint_errs),
4979[C_SW_RCV_CSTR_ERR] = CNTR_ELEM("RcvCstrErr", 0, 0, CNTR_SYNTH,
4980 access_rcv_constraint_errs),
4981[C_SW_IBP_LOOP_PKTS] = SW_IBP_CNTR(LoopPkts, loop_pkts),
4982[C_SW_IBP_RC_RESENDS] = SW_IBP_CNTR(RcResend, rc_resends),
4983[C_SW_IBP_RNR_NAKS] = SW_IBP_CNTR(RnrNak, rnr_naks),
4984[C_SW_IBP_OTHER_NAKS] = SW_IBP_CNTR(OtherNak, other_naks),
4985[C_SW_IBP_RC_TIMEOUTS] = SW_IBP_CNTR(RcTimeOut, rc_timeouts),
4986[C_SW_IBP_PKT_DROPS] = SW_IBP_CNTR(PktDrop, pkt_drops),
4987[C_SW_IBP_DMA_WAIT] = SW_IBP_CNTR(DmaWait, dmawait),
4988[C_SW_IBP_RC_SEQNAK] = SW_IBP_CNTR(RcSeqNak, rc_seqnak),
4989[C_SW_IBP_RC_DUPREQ] = SW_IBP_CNTR(RcDupRew, rc_dupreq),
4990[C_SW_IBP_RDMA_SEQ] = SW_IBP_CNTR(RdmaSeq, rdma_seq),
4991[C_SW_IBP_UNALIGNED] = SW_IBP_CNTR(Unaligned, unaligned),
4992[C_SW_IBP_SEQ_NAK] = SW_IBP_CNTR(SeqNak, seq_naks),
4993[C_SW_CPU_RC_ACKS] = CNTR_ELEM("RcAcks", 0, 0, CNTR_NORMAL,
4994 access_sw_cpu_rc_acks),
4995[C_SW_CPU_RC_QACKS] = CNTR_ELEM("RcQacks", 0, 0, CNTR_NORMAL,
4996 access_sw_cpu_rc_qacks),
4997[C_SW_CPU_RC_DELAYED_COMP] = CNTR_ELEM("RcDelayComp", 0, 0, CNTR_NORMAL,
4998 access_sw_cpu_rc_delayed_comp),
4999[OVR_LBL(0)] = OVR_ELM(0), [OVR_LBL(1)] = OVR_ELM(1),
5000[OVR_LBL(2)] = OVR_ELM(2), [OVR_LBL(3)] = OVR_ELM(3),
5001[OVR_LBL(4)] = OVR_ELM(4), [OVR_LBL(5)] = OVR_ELM(5),
5002[OVR_LBL(6)] = OVR_ELM(6), [OVR_LBL(7)] = OVR_ELM(7),
5003[OVR_LBL(8)] = OVR_ELM(8), [OVR_LBL(9)] = OVR_ELM(9),
5004[OVR_LBL(10)] = OVR_ELM(10), [OVR_LBL(11)] = OVR_ELM(11),
5005[OVR_LBL(12)] = OVR_ELM(12), [OVR_LBL(13)] = OVR_ELM(13),
5006[OVR_LBL(14)] = OVR_ELM(14), [OVR_LBL(15)] = OVR_ELM(15),
5007[OVR_LBL(16)] = OVR_ELM(16), [OVR_LBL(17)] = OVR_ELM(17),
5008[OVR_LBL(18)] = OVR_ELM(18), [OVR_LBL(19)] = OVR_ELM(19),
5009[OVR_LBL(20)] = OVR_ELM(20), [OVR_LBL(21)] = OVR_ELM(21),
5010[OVR_LBL(22)] = OVR_ELM(22), [OVR_LBL(23)] = OVR_ELM(23),
5011[OVR_LBL(24)] = OVR_ELM(24), [OVR_LBL(25)] = OVR_ELM(25),
5012[OVR_LBL(26)] = OVR_ELM(26), [OVR_LBL(27)] = OVR_ELM(27),
5013[OVR_LBL(28)] = OVR_ELM(28), [OVR_LBL(29)] = OVR_ELM(29),
5014[OVR_LBL(30)] = OVR_ELM(30), [OVR_LBL(31)] = OVR_ELM(31),
5015[OVR_LBL(32)] = OVR_ELM(32), [OVR_LBL(33)] = OVR_ELM(33),
5016[OVR_LBL(34)] = OVR_ELM(34), [OVR_LBL(35)] = OVR_ELM(35),
5017[OVR_LBL(36)] = OVR_ELM(36), [OVR_LBL(37)] = OVR_ELM(37),
5018[OVR_LBL(38)] = OVR_ELM(38), [OVR_LBL(39)] = OVR_ELM(39),
5019[OVR_LBL(40)] = OVR_ELM(40), [OVR_LBL(41)] = OVR_ELM(41),
5020[OVR_LBL(42)] = OVR_ELM(42), [OVR_LBL(43)] = OVR_ELM(43),
5021[OVR_LBL(44)] = OVR_ELM(44), [OVR_LBL(45)] = OVR_ELM(45),
5022[OVR_LBL(46)] = OVR_ELM(46), [OVR_LBL(47)] = OVR_ELM(47),
5023[OVR_LBL(48)] = OVR_ELM(48), [OVR_LBL(49)] = OVR_ELM(49),
5024[OVR_LBL(50)] = OVR_ELM(50), [OVR_LBL(51)] = OVR_ELM(51),
5025[OVR_LBL(52)] = OVR_ELM(52), [OVR_LBL(53)] = OVR_ELM(53),
5026[OVR_LBL(54)] = OVR_ELM(54), [OVR_LBL(55)] = OVR_ELM(55),
5027[OVR_LBL(56)] = OVR_ELM(56), [OVR_LBL(57)] = OVR_ELM(57),
5028[OVR_LBL(58)] = OVR_ELM(58), [OVR_LBL(59)] = OVR_ELM(59),
5029[OVR_LBL(60)] = OVR_ELM(60), [OVR_LBL(61)] = OVR_ELM(61),
5030[OVR_LBL(62)] = OVR_ELM(62), [OVR_LBL(63)] = OVR_ELM(63),
5031[OVR_LBL(64)] = OVR_ELM(64), [OVR_LBL(65)] = OVR_ELM(65),
5032[OVR_LBL(66)] = OVR_ELM(66), [OVR_LBL(67)] = OVR_ELM(67),
5033[OVR_LBL(68)] = OVR_ELM(68), [OVR_LBL(69)] = OVR_ELM(69),
5034[OVR_LBL(70)] = OVR_ELM(70), [OVR_LBL(71)] = OVR_ELM(71),
5035[OVR_LBL(72)] = OVR_ELM(72), [OVR_LBL(73)] = OVR_ELM(73),
5036[OVR_LBL(74)] = OVR_ELM(74), [OVR_LBL(75)] = OVR_ELM(75),
5037[OVR_LBL(76)] = OVR_ELM(76), [OVR_LBL(77)] = OVR_ELM(77),
5038[OVR_LBL(78)] = OVR_ELM(78), [OVR_LBL(79)] = OVR_ELM(79),
5039[OVR_LBL(80)] = OVR_ELM(80), [OVR_LBL(81)] = OVR_ELM(81),
5040[OVR_LBL(82)] = OVR_ELM(82), [OVR_LBL(83)] = OVR_ELM(83),
5041[OVR_LBL(84)] = OVR_ELM(84), [OVR_LBL(85)] = OVR_ELM(85),
5042[OVR_LBL(86)] = OVR_ELM(86), [OVR_LBL(87)] = OVR_ELM(87),
5043[OVR_LBL(88)] = OVR_ELM(88), [OVR_LBL(89)] = OVR_ELM(89),
5044[OVR_LBL(90)] = OVR_ELM(90), [OVR_LBL(91)] = OVR_ELM(91),
5045[OVR_LBL(92)] = OVR_ELM(92), [OVR_LBL(93)] = OVR_ELM(93),
5046[OVR_LBL(94)] = OVR_ELM(94), [OVR_LBL(95)] = OVR_ELM(95),
5047[OVR_LBL(96)] = OVR_ELM(96), [OVR_LBL(97)] = OVR_ELM(97),
5048[OVR_LBL(98)] = OVR_ELM(98), [OVR_LBL(99)] = OVR_ELM(99),
5049[OVR_LBL(100)] = OVR_ELM(100), [OVR_LBL(101)] = OVR_ELM(101),
5050[OVR_LBL(102)] = OVR_ELM(102), [OVR_LBL(103)] = OVR_ELM(103),
5051[OVR_LBL(104)] = OVR_ELM(104), [OVR_LBL(105)] = OVR_ELM(105),
5052[OVR_LBL(106)] = OVR_ELM(106), [OVR_LBL(107)] = OVR_ELM(107),
5053[OVR_LBL(108)] = OVR_ELM(108), [OVR_LBL(109)] = OVR_ELM(109),
5054[OVR_LBL(110)] = OVR_ELM(110), [OVR_LBL(111)] = OVR_ELM(111),
5055[OVR_LBL(112)] = OVR_ELM(112), [OVR_LBL(113)] = OVR_ELM(113),
5056[OVR_LBL(114)] = OVR_ELM(114), [OVR_LBL(115)] = OVR_ELM(115),
5057[OVR_LBL(116)] = OVR_ELM(116), [OVR_LBL(117)] = OVR_ELM(117),
5058[OVR_LBL(118)] = OVR_ELM(118), [OVR_LBL(119)] = OVR_ELM(119),
5059[OVR_LBL(120)] = OVR_ELM(120), [OVR_LBL(121)] = OVR_ELM(121),
5060[OVR_LBL(122)] = OVR_ELM(122), [OVR_LBL(123)] = OVR_ELM(123),
5061[OVR_LBL(124)] = OVR_ELM(124), [OVR_LBL(125)] = OVR_ELM(125),
5062[OVR_LBL(126)] = OVR_ELM(126), [OVR_LBL(127)] = OVR_ELM(127),
5063[OVR_LBL(128)] = OVR_ELM(128), [OVR_LBL(129)] = OVR_ELM(129),
5064[OVR_LBL(130)] = OVR_ELM(130), [OVR_LBL(131)] = OVR_ELM(131),
5065[OVR_LBL(132)] = OVR_ELM(132), [OVR_LBL(133)] = OVR_ELM(133),
5066[OVR_LBL(134)] = OVR_ELM(134), [OVR_LBL(135)] = OVR_ELM(135),
5067[OVR_LBL(136)] = OVR_ELM(136), [OVR_LBL(137)] = OVR_ELM(137),
5068[OVR_LBL(138)] = OVR_ELM(138), [OVR_LBL(139)] = OVR_ELM(139),
5069[OVR_LBL(140)] = OVR_ELM(140), [OVR_LBL(141)] = OVR_ELM(141),
5070[OVR_LBL(142)] = OVR_ELM(142), [OVR_LBL(143)] = OVR_ELM(143),
5071[OVR_LBL(144)] = OVR_ELM(144), [OVR_LBL(145)] = OVR_ELM(145),
5072[OVR_LBL(146)] = OVR_ELM(146), [OVR_LBL(147)] = OVR_ELM(147),
5073[OVR_LBL(148)] = OVR_ELM(148), [OVR_LBL(149)] = OVR_ELM(149),
5074[OVR_LBL(150)] = OVR_ELM(150), [OVR_LBL(151)] = OVR_ELM(151),
5075[OVR_LBL(152)] = OVR_ELM(152), [OVR_LBL(153)] = OVR_ELM(153),
5076[OVR_LBL(154)] = OVR_ELM(154), [OVR_LBL(155)] = OVR_ELM(155),
5077[OVR_LBL(156)] = OVR_ELM(156), [OVR_LBL(157)] = OVR_ELM(157),
5078[OVR_LBL(158)] = OVR_ELM(158), [OVR_LBL(159)] = OVR_ELM(159),
5079};
5080
5081/* ======================================================================== */
5082
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5083/* return true if this is chip revision revision a */
5084int is_ax(struct hfi1_devdata *dd)
5085{
5086 u8 chip_rev_minor =
5087 dd->revision >> CCE_REVISION_CHIP_REV_MINOR_SHIFT
5088 & CCE_REVISION_CHIP_REV_MINOR_MASK;
5089 return (chip_rev_minor & 0xf0) == 0;
5090}
5091
5092/* return true if this is chip revision revision b */
5093int is_bx(struct hfi1_devdata *dd)
5094{
5095 u8 chip_rev_minor =
5096 dd->revision >> CCE_REVISION_CHIP_REV_MINOR_SHIFT
5097 & CCE_REVISION_CHIP_REV_MINOR_MASK;
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]5098 return (chip_rev_minor & 0xF0) == 0x10;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5099}
5100
5101/*
5102 * Append string s to buffer buf. Arguments curp and len are the current
5103 * position and remaining length, respectively.
5104 *
5105 * return 0 on success, 1 on out of room
5106 */
5107static int append_str(char *buf, char **curp, int *lenp, const char *s)
5108{
5109 char *p = *curp;
5110 int len = *lenp;
5111 int result = 0; /* success */
5112 char c;
5113
5114 /* add a comma, if first in the buffer */
5115 if (p != buf) {
5116 if (len == 0) {
5117 result = 1; /* out of room */
5118 goto done;
5119 }
5120 *p++ = ',';
5121 len--;
5122 }
5123
5124 /* copy the string */
5125 while ((c = *s++) != 0) {
5126 if (len == 0) {
5127 result = 1; /* out of room */
5128 goto done;
5129 }
5130 *p++ = c;
5131 len--;
5132 }
5133
5134done:
5135 /* write return values */
5136 *curp = p;
5137 *lenp = len;
5138
5139 return result;
5140}
5141
5142/*
5143 * Using the given flag table, print a comma separated string into
5144 * the buffer. End in '*' if the buffer is too short.
5145 */
5146static char *flag_string(char *buf, int buf_len, u64 flags,
5147 struct flag_table *table, int table_size)
5148{
5149 char extra[32];
5150 char *p = buf;
5151 int len = buf_len;
5152 int no_room = 0;
5153 int i;
5154
5155 /* make sure there is at least 2 so we can form "*" */
5156 if (len < 2)
5157 return "";
5158
5159 len--; /* leave room for a nul */
5160 for (i = 0; i < table_size; i++) {
5161 if (flags & table[i].flag) {
5162 no_room = append_str(buf, &p, &len, table[i].str);
5163 if (no_room)
5164 break;
5165 flags &= ~table[i].flag;
5166 }
5167 }
5168
5169 /* any undocumented bits left? */
5170 if (!no_room && flags) {
5171 snprintf(extra, sizeof(extra), "bits 0x%llx", flags);
5172 no_room = append_str(buf, &p, &len, extra);
5173 }
5174
5175 /* add * if ran out of room */
5176 if (no_room) {
5177 /* may need to back up to add space for a '*' */
5178 if (len == 0)
5179 --p;
5180 *p++ = '*';
5181 }
5182
5183 /* add final nul - space already allocated above */
5184 *p = 0;
5185 return buf;
5186}
5187
5188/* first 8 CCE error interrupt source names */
5189static const char * const cce_misc_names[] = {
5190 "CceErrInt", /* 0 */
5191 "RxeErrInt", /* 1 */
5192 "MiscErrInt", /* 2 */
5193 "Reserved3", /* 3 */
5194 "PioErrInt", /* 4 */
5195 "SDmaErrInt", /* 5 */
5196 "EgressErrInt", /* 6 */
5197 "TxeErrInt" /* 7 */
5198};
5199
5200/*
5201 * Return the miscellaneous error interrupt name.
5202 */
5203static char *is_misc_err_name(char *buf, size_t bsize, unsigned int source)
5204{
5205 if (source < ARRAY_SIZE(cce_misc_names))
5206 strncpy(buf, cce_misc_names[source], bsize);
5207 else
5208 snprintf(buf,
5209 bsize,
5210 "Reserved%u",
5211 source + IS_GENERAL_ERR_START);
5212
5213 return buf;
5214}
5215
5216/*
5217 * Return the SDMA engine error interrupt name.
5218 */
5219static char *is_sdma_eng_err_name(char *buf, size_t bsize, unsigned int source)
5220{
5221 snprintf(buf, bsize, "SDmaEngErrInt%u", source);
5222 return buf;
5223}
5224
5225/*
5226 * Return the send context error interrupt name.
5227 */
5228static char *is_sendctxt_err_name(char *buf, size_t bsize, unsigned int source)
5229{
5230 snprintf(buf, bsize, "SendCtxtErrInt%u", source);
5231 return buf;
5232}
5233
5234static const char * const various_names[] = {
5235 "PbcInt",
5236 "GpioAssertInt",
5237 "Qsfp1Int",
5238 "Qsfp2Int",
5239 "TCritInt"
5240};
5241
5242/*
5243 * Return the various interrupt name.
5244 */
5245static char *is_various_name(char *buf, size_t bsize, unsigned int source)
5246{
5247 if (source < ARRAY_SIZE(various_names))
5248 strncpy(buf, various_names[source], bsize);
5249 else
5250 snprintf(buf, bsize, "Reserved%u", source+IS_VARIOUS_START);
5251 return buf;
5252}
5253
5254/*
5255 * Return the DC interrupt name.
5256 */
5257static char *is_dc_name(char *buf, size_t bsize, unsigned int source)
5258{
5259 static const char * const dc_int_names[] = {
5260 "common",
5261 "lcb",
5262 "8051",
5263 "lbm" /* local block merge */
5264 };
5265
5266 if (source < ARRAY_SIZE(dc_int_names))
5267 snprintf(buf, bsize, "dc_%s_int", dc_int_names[source]);
5268 else
5269 snprintf(buf, bsize, "DCInt%u", source);
5270 return buf;
5271}
5272
5273static const char * const sdma_int_names[] = {
5274 "SDmaInt",
5275 "SdmaIdleInt",
5276 "SdmaProgressInt",
5277};
5278
5279/*
5280 * Return the SDMA engine interrupt name.
5281 */
5282static char *is_sdma_eng_name(char *buf, size_t bsize, unsigned int source)
5283{
5284 /* what interrupt */
5285 unsigned int what = source / TXE_NUM_SDMA_ENGINES;
5286 /* which engine */
5287 unsigned int which = source % TXE_NUM_SDMA_ENGINES;
5288
5289 if (likely(what < 3))
5290 snprintf(buf, bsize, "%s%u", sdma_int_names[what], which);
5291 else
5292 snprintf(buf, bsize, "Invalid SDMA interrupt %u", source);
5293 return buf;
5294}
5295
5296/*
5297 * Return the receive available interrupt name.
5298 */
5299static char *is_rcv_avail_name(char *buf, size_t bsize, unsigned int source)
5300{
5301 snprintf(buf, bsize, "RcvAvailInt%u", source);
5302 return buf;
5303}
5304
5305/*
5306 * Return the receive urgent interrupt name.
5307 */
5308static char *is_rcv_urgent_name(char *buf, size_t bsize, unsigned int source)
5309{
5310 snprintf(buf, bsize, "RcvUrgentInt%u", source);
5311 return buf;
5312}
5313
5314/*
5315 * Return the send credit interrupt name.
5316 */
5317static char *is_send_credit_name(char *buf, size_t bsize, unsigned int source)
5318{
5319 snprintf(buf, bsize, "SendCreditInt%u", source);
5320 return buf;
5321}
5322
5323/*
5324 * Return the reserved interrupt name.
5325 */
5326static char *is_reserved_name(char *buf, size_t bsize, unsigned int source)
5327{
5328 snprintf(buf, bsize, "Reserved%u", source + IS_RESERVED_START);
5329 return buf;
5330}
5331
5332static char *cce_err_status_string(char *buf, int buf_len, u64 flags)
5333{
5334 return flag_string(buf, buf_len, flags,
5335 cce_err_status_flags, ARRAY_SIZE(cce_err_status_flags));
5336}
5337
5338static char *rxe_err_status_string(char *buf, int buf_len, u64 flags)
5339{
5340 return flag_string(buf, buf_len, flags,
5341 rxe_err_status_flags, ARRAY_SIZE(rxe_err_status_flags));
5342}
5343
5344static char *misc_err_status_string(char *buf, int buf_len, u64 flags)
5345{
5346 return flag_string(buf, buf_len, flags, misc_err_status_flags,
5347 ARRAY_SIZE(misc_err_status_flags));
5348}
5349
5350static char *pio_err_status_string(char *buf, int buf_len, u64 flags)
5351{
5352 return flag_string(buf, buf_len, flags,
5353 pio_err_status_flags, ARRAY_SIZE(pio_err_status_flags));
5354}
5355
5356static char *sdma_err_status_string(char *buf, int buf_len, u64 flags)
5357{
5358 return flag_string(buf, buf_len, flags,
5359 sdma_err_status_flags,
5360 ARRAY_SIZE(sdma_err_status_flags));
5361}
5362
5363static char *egress_err_status_string(char *buf, int buf_len, u64 flags)
5364{
5365 return flag_string(buf, buf_len, flags,
5366 egress_err_status_flags, ARRAY_SIZE(egress_err_status_flags));
5367}
5368
5369static char *egress_err_info_string(char *buf, int buf_len, u64 flags)
5370{
5371 return flag_string(buf, buf_len, flags,
5372 egress_err_info_flags, ARRAY_SIZE(egress_err_info_flags));
5373}
5374
5375static char *send_err_status_string(char *buf, int buf_len, u64 flags)
5376{
5377 return flag_string(buf, buf_len, flags,
5378 send_err_status_flags,
5379 ARRAY_SIZE(send_err_status_flags));
5380}
5381
5382static void handle_cce_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
5383{
5384 char buf[96];
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5385 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5386
5387 /*
5388 * For most these errors, there is nothing that can be done except
5389 * report or record it.
5390 */
5391 dd_dev_info(dd, "CCE Error: %s\n",
5392 cce_err_status_string(buf, sizeof(buf), reg));
5393
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]5394 if ((reg & CCE_ERR_STATUS_CCE_CLI2_ASYNC_FIFO_PARITY_ERR_SMASK) &&
5395 is_ax(dd) && (dd->icode != ICODE_FUNCTIONAL_SIMULATOR)) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5396 /* this error requires a manual drop into SPC freeze mode */
5397 /* then a fix up */
5398 start_freeze_handling(dd->pport, FREEZE_SELF);
5399 }
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5400
5401 for (i = 0; i < NUM_CCE_ERR_STATUS_COUNTERS; i++) {
5402 if (reg & (1ull << i)) {
5403 incr_cntr64(&dd->cce_err_status_cnt[i]);
5404 /* maintain a counter over all cce_err_status errors */
5405 incr_cntr64(&dd->sw_cce_err_status_aggregate);
5406 }
5407 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5408}
5409
5410/*
5411 * Check counters for receive errors that do not have an interrupt
5412 * associated with them.
5413 */
5414#define RCVERR_CHECK_TIME 10
5415static void update_rcverr_timer(unsigned long opaque)
5416{
5417 struct hfi1_devdata *dd = (struct hfi1_devdata *)opaque;
5418 struct hfi1_pportdata *ppd = dd->pport;
5419 u32 cur_ovfl_cnt = read_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL);
5420
5421 if (dd->rcv_ovfl_cnt < cur_ovfl_cnt &&
5422 ppd->port_error_action & OPA_PI_MASK_EX_BUFFER_OVERRUN) {
5423 dd_dev_info(dd, "%s: PortErrorAction bounce\n", __func__);
5424 set_link_down_reason(ppd,
5425 OPA_LINKDOWN_REASON_EXCESSIVE_BUFFER_OVERRUN, 0,
5426 OPA_LINKDOWN_REASON_EXCESSIVE_BUFFER_OVERRUN);
5427 queue_work(ppd->hfi1_wq, &ppd->link_bounce_work);
5428 }
5429 dd->rcv_ovfl_cnt = (u32) cur_ovfl_cnt;
5430
5431 mod_timer(&dd->rcverr_timer, jiffies + HZ * RCVERR_CHECK_TIME);
5432}
5433
5434static int init_rcverr(struct hfi1_devdata *dd)
5435{
Muhammad Falak R Wani24523a92015-10-25 16:13:23 +0530[diff] [blame]5436 setup_timer(&dd->rcverr_timer, update_rcverr_timer, (unsigned long)dd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5437 /* Assume the hardware counter has been reset */
5438 dd->rcv_ovfl_cnt = 0;
5439 return mod_timer(&dd->rcverr_timer, jiffies + HZ * RCVERR_CHECK_TIME);
5440}
5441
5442static void free_rcverr(struct hfi1_devdata *dd)
5443{
5444 if (dd->rcverr_timer.data)
5445 del_timer_sync(&dd->rcverr_timer);
5446 dd->rcverr_timer.data = 0;
5447}
5448
5449static void handle_rxe_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
5450{
5451 char buf[96];
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5452 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5453
5454 dd_dev_info(dd, "Receive Error: %s\n",
5455 rxe_err_status_string(buf, sizeof(buf), reg));
5456
5457 if (reg & ALL_RXE_FREEZE_ERR) {
5458 int flags = 0;
5459
5460 /*
5461 * Freeze mode recovery is disabled for the errors
5462 * in RXE_FREEZE_ABORT_MASK
5463 */
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]5464 if (is_ax(dd) && (reg & RXE_FREEZE_ABORT_MASK))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5465 flags = FREEZE_ABORT;
5466
5467 start_freeze_handling(dd->pport, flags);
5468 }
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5469
5470 for (i = 0; i < NUM_RCV_ERR_STATUS_COUNTERS; i++) {
5471 if (reg & (1ull << i))
5472 incr_cntr64(&dd->rcv_err_status_cnt[i]);
5473 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5474}
5475
5476static void handle_misc_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
5477{
5478 char buf[96];
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5479 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5480
5481 dd_dev_info(dd, "Misc Error: %s",
5482 misc_err_status_string(buf, sizeof(buf), reg));
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5483 for (i = 0; i < NUM_MISC_ERR_STATUS_COUNTERS; i++) {
5484 if (reg & (1ull << i))
5485 incr_cntr64(&dd->misc_err_status_cnt[i]);
5486 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5487}
5488
5489static void handle_pio_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
5490{
5491 char buf[96];
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5492 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5493
5494 dd_dev_info(dd, "PIO Error: %s\n",
5495 pio_err_status_string(buf, sizeof(buf), reg));
5496
5497 if (reg & ALL_PIO_FREEZE_ERR)
5498 start_freeze_handling(dd->pport, 0);
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5499
5500 for (i = 0; i < NUM_SEND_PIO_ERR_STATUS_COUNTERS; i++) {
5501 if (reg & (1ull << i))
5502 incr_cntr64(&dd->send_pio_err_status_cnt[i]);
5503 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5504}
5505
5506static void handle_sdma_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
5507{
5508 char buf[96];
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5509 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5510
5511 dd_dev_info(dd, "SDMA Error: %s\n",
5512 sdma_err_status_string(buf, sizeof(buf), reg));
5513
5514 if (reg & ALL_SDMA_FREEZE_ERR)
5515 start_freeze_handling(dd->pport, 0);
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5516
5517 for (i = 0; i < NUM_SEND_DMA_ERR_STATUS_COUNTERS; i++) {
5518 if (reg & (1ull << i))
5519 incr_cntr64(&dd->send_dma_err_status_cnt[i]);
5520 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5521}
5522
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5523static inline void __count_port_discards(struct hfi1_pportdata *ppd)
5524{
5525 incr_cntr64(&ppd->port_xmit_discards);
5526}
5527
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5528static void count_port_inactive(struct hfi1_devdata *dd)
5529{
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5530 __count_port_discards(dd->pport);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5531}
5532
5533/*
5534 * We have had a "disallowed packet" error during egress. Determine the
5535 * integrity check which failed, and update relevant error counter, etc.
5536 *
5537 * Note that the SEND_EGRESS_ERR_INFO register has only a single
5538 * bit of state per integrity check, and so we can miss the reason for an
5539 * egress error if more than one packet fails the same integrity check
5540 * since we cleared the corresponding bit in SEND_EGRESS_ERR_INFO.
5541 */
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5542static void handle_send_egress_err_info(struct hfi1_devdata *dd,
5543 int vl)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5544{
5545 struct hfi1_pportdata *ppd = dd->pport;
5546 u64 src = read_csr(dd, SEND_EGRESS_ERR_SOURCE); /* read first */
5547 u64 info = read_csr(dd, SEND_EGRESS_ERR_INFO);
5548 char buf[96];
5549
5550 /* clear down all observed info as quickly as possible after read */
5551 write_csr(dd, SEND_EGRESS_ERR_INFO, info);
5552
5553 dd_dev_info(dd,
5554 "Egress Error Info: 0x%llx, %s Egress Error Src 0x%llx\n",
5555 info, egress_err_info_string(buf, sizeof(buf), info), src);
5556
5557 /* Eventually add other counters for each bit */
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5558 if (info & PORT_DISCARD_EGRESS_ERRS) {
5559 int weight, i;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5560
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5561 /*
5562 * Count all, in case multiple bits are set. Reminder:
5563 * since there is only one info register for many sources,
5564 * these may be attributed to the wrong VL if they occur
5565 * too close together.
5566 */
5567 weight = hweight64(info);
5568 for (i = 0; i < weight; i++) {
5569 __count_port_discards(ppd);
5570 if (vl >= 0 && vl < TXE_NUM_DATA_VL)
5571 incr_cntr64(&ppd->port_xmit_discards_vl[vl]);
5572 else if (vl == 15)
5573 incr_cntr64(&ppd->port_xmit_discards_vl
5574 [C_VL_15]);
5575 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5576 }
5577}
5578
5579/*
5580 * Input value is a bit position within the SEND_EGRESS_ERR_STATUS
5581 * register. Does it represent a 'port inactive' error?
5582 */
5583static inline int port_inactive_err(u64 posn)
5584{
5585 return (posn >= SEES(TX_LINKDOWN) &&
5586 posn <= SEES(TX_INCORRECT_LINK_STATE));
5587}
5588
5589/*
5590 * Input value is a bit position within the SEND_EGRESS_ERR_STATUS
5591 * register. Does it represent a 'disallowed packet' error?
5592 */
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5593static inline int disallowed_pkt_err(int posn)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5594{
5595 return (posn >= SEES(TX_SDMA0_DISALLOWED_PACKET) &&
5596 posn <= SEES(TX_SDMA15_DISALLOWED_PACKET));
5597}
5598
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5599/*
5600 * Input value is a bit position of one of the SDMA engine disallowed
5601 * packet errors. Return which engine. Use of this must be guarded by
5602 * disallowed_pkt_err().
5603 */
5604static inline int disallowed_pkt_engine(int posn)
5605{
5606 return posn - SEES(TX_SDMA0_DISALLOWED_PACKET);
5607}
5608
5609/*
5610 * Translate an SDMA engine to a VL. Return -1 if the tranlation cannot
5611 * be done.
5612 */
5613static int engine_to_vl(struct hfi1_devdata *dd, int engine)
5614{
5615 struct sdma_vl_map *m;
5616 int vl;
5617
5618 /* range check */
5619 if (engine < 0 || engine >= TXE_NUM_SDMA_ENGINES)
5620 return -1;
5621
5622 rcu_read_lock();
5623 m = rcu_dereference(dd->sdma_map);
5624 vl = m->engine_to_vl[engine];
5625 rcu_read_unlock();
5626
5627 return vl;
5628}
5629
5630/*
5631 * Translate the send context (sofware index) into a VL. Return -1 if the
5632 * translation cannot be done.
5633 */
5634static int sc_to_vl(struct hfi1_devdata *dd, int sw_index)
5635{
5636 struct send_context_info *sci;
5637 struct send_context *sc;
5638 int i;
5639
5640 sci = &dd->send_contexts[sw_index];
5641
5642 /* there is no information for user (PSM) and ack contexts */
5643 if (sci->type != SC_KERNEL)
5644 return -1;
5645
5646 sc = sci->sc;
5647 if (!sc)
5648 return -1;
5649 if (dd->vld[15].sc == sc)
5650 return 15;
5651 for (i = 0; i < num_vls; i++)
5652 if (dd->vld[i].sc == sc)
5653 return i;
5654
5655 return -1;
5656}
5657
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5658static void handle_egress_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
5659{
5660 u64 reg_copy = reg, handled = 0;
5661 char buf[96];
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5662 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5663
5664 if (reg & ALL_TXE_EGRESS_FREEZE_ERR)
5665 start_freeze_handling(dd->pport, 0);
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5666 else if (is_ax(dd) &&
5667 (reg & SEND_EGRESS_ERR_STATUS_TX_CREDIT_RETURN_VL_ERR_SMASK) &&
5668 (dd->icode != ICODE_FUNCTIONAL_SIMULATOR))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5669 start_freeze_handling(dd->pport, 0);
5670
5671 while (reg_copy) {
5672 int posn = fls64(reg_copy);
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5673 /* fls64() returns a 1-based offset, we want it zero based */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5674 int shift = posn - 1;
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5675 u64 mask = 1ULL << shift;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5676
5677 if (port_inactive_err(shift)) {
5678 count_port_inactive(dd);
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5679 handled |= mask;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5680 } else if (disallowed_pkt_err(shift)) {
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5681 int vl = engine_to_vl(dd, disallowed_pkt_engine(shift));
5682
5683 handle_send_egress_err_info(dd, vl);
5684 handled |= mask;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5685 }
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5686 reg_copy &= ~mask;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5687 }
5688
5689 reg &= ~handled;
5690
5691 if (reg)
5692 dd_dev_info(dd, "Egress Error: %s\n",
5693 egress_err_status_string(buf, sizeof(buf), reg));
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5694
5695 for (i = 0; i < NUM_SEND_EGRESS_ERR_STATUS_COUNTERS; i++) {
5696 if (reg & (1ull << i))
5697 incr_cntr64(&dd->send_egress_err_status_cnt[i]);
5698 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5699}
5700
5701static void handle_txe_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
5702{
5703 char buf[96];
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5704 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5705
5706 dd_dev_info(dd, "Send Error: %s\n",
5707 send_err_status_string(buf, sizeof(buf), reg));
5708
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5709 for (i = 0; i < NUM_SEND_ERR_STATUS_COUNTERS; i++) {
5710 if (reg & (1ull << i))
5711 incr_cntr64(&dd->send_err_status_cnt[i]);
5712 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5713}
5714
5715/*
5716 * The maximum number of times the error clear down will loop before
5717 * blocking a repeating error. This value is arbitrary.
5718 */
5719#define MAX_CLEAR_COUNT 20
5720
5721/*
5722 * Clear and handle an error register. All error interrupts are funneled
5723 * through here to have a central location to correctly handle single-
5724 * or multi-shot errors.
5725 *
5726 * For non per-context registers, call this routine with a context value
5727 * of 0 so the per-context offset is zero.
5728 *
5729 * If the handler loops too many times, assume that something is wrong
5730 * and can't be fixed, so mask the error bits.
5731 */
5732static void interrupt_clear_down(struct hfi1_devdata *dd,
5733 u32 context,
5734 const struct err_reg_info *eri)
5735{
5736 u64 reg;
5737 u32 count;
5738
5739 /* read in a loop until no more errors are seen */
5740 count = 0;
5741 while (1) {
5742 reg = read_kctxt_csr(dd, context, eri->status);
5743 if (reg == 0)
5744 break;
5745 write_kctxt_csr(dd, context, eri->clear, reg);
5746 if (likely(eri->handler))
5747 eri->handler(dd, context, reg);
5748 count++;
5749 if (count > MAX_CLEAR_COUNT) {
5750 u64 mask;
5751
5752 dd_dev_err(dd, "Repeating %s bits 0x%llx - masking\n",
5753 eri->desc, reg);
5754 /*
5755 * Read-modify-write so any other masked bits
5756 * remain masked.
5757 */
5758 mask = read_kctxt_csr(dd, context, eri->mask);
5759 mask &= ~reg;
5760 write_kctxt_csr(dd, context, eri->mask, mask);
5761 break;
5762 }
5763 }
5764}
5765
5766/*
5767 * CCE block "misc" interrupt. Source is < 16.
5768 */
5769static void is_misc_err_int(struct hfi1_devdata *dd, unsigned int source)
5770{
5771 const struct err_reg_info *eri = &misc_errs[source];
5772
5773 if (eri->handler) {
5774 interrupt_clear_down(dd, 0, eri);
5775 } else {
5776 dd_dev_err(dd, "Unexpected misc interrupt (%u) - reserved\n",
5777 source);
5778 }
5779}
5780
5781static char *send_context_err_status_string(char *buf, int buf_len, u64 flags)
5782{
5783 return flag_string(buf, buf_len, flags,
5784 sc_err_status_flags, ARRAY_SIZE(sc_err_status_flags));
5785}
5786
5787/*
5788 * Send context error interrupt. Source (hw_context) is < 160.
5789 *
5790 * All send context errors cause the send context to halt. The normal
5791 * clear-down mechanism cannot be used because we cannot clear the
5792 * error bits until several other long-running items are done first.
5793 * This is OK because with the context halted, nothing else is going
5794 * to happen on it anyway.
5795 */
5796static void is_sendctxt_err_int(struct hfi1_devdata *dd,
5797 unsigned int hw_context)
5798{
5799 struct send_context_info *sci;
5800 struct send_context *sc;
5801 char flags[96];
5802 u64 status;
5803 u32 sw_index;
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5804 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5805
5806 sw_index = dd->hw_to_sw[hw_context];
5807 if (sw_index >= dd->num_send_contexts) {
5808 dd_dev_err(dd,
5809 "out of range sw index %u for send context %u\n",
5810 sw_index, hw_context);
5811 return;
5812 }
5813 sci = &dd->send_contexts[sw_index];
5814 sc = sci->sc;
5815 if (!sc) {
5816 dd_dev_err(dd, "%s: context %u(%u): no sc?\n", __func__,
5817 sw_index, hw_context);
5818 return;
5819 }
5820
5821 /* tell the software that a halt has begun */
5822 sc_stop(sc, SCF_HALTED);
5823
5824 status = read_kctxt_csr(dd, hw_context, SEND_CTXT_ERR_STATUS);
5825
5826 dd_dev_info(dd, "Send Context %u(%u) Error: %s\n", sw_index, hw_context,
5827 send_context_err_status_string(flags, sizeof(flags), status));
5828
5829 if (status & SEND_CTXT_ERR_STATUS_PIO_DISALLOWED_PACKET_ERR_SMASK)
Mike Marciniszyn69a00b82016-02-03 14:31:49 -0800[diff] [blame]5830 handle_send_egress_err_info(dd, sc_to_vl(dd, sw_index));
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5831
5832 /*
5833 * Automatically restart halted kernel contexts out of interrupt
5834 * context. User contexts must ask the driver to restart the context.
5835 */
5836 if (sc->type != SC_USER)
5837 queue_work(dd->pport->hfi1_wq, &sc->halt_work);
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5838
5839 /*
5840 * Update the counters for the corresponding status bits.
5841 * Note that these particular counters are aggregated over all
5842 * 160 contexts.
5843 */
5844 for (i = 0; i < NUM_SEND_CTXT_ERR_STATUS_COUNTERS; i++) {
5845 if (status & (1ull << i))
5846 incr_cntr64(&dd->sw_ctxt_err_status_cnt[i]);
5847 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5848}
5849
5850static void handle_sdma_eng_err(struct hfi1_devdata *dd,
5851 unsigned int source, u64 status)
5852{
5853 struct sdma_engine *sde;
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5854 int i = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5855
5856 sde = &dd->per_sdma[source];
5857#ifdef CONFIG_SDMA_VERBOSITY
5858 dd_dev_err(sde->dd, "CONFIG SDMA(%u) %s:%d %s()\n", sde->this_idx,
5859 slashstrip(__FILE__), __LINE__, __func__);
5860 dd_dev_err(sde->dd, "CONFIG SDMA(%u) source: %u status 0x%llx\n",
5861 sde->this_idx, source, (unsigned long long)status);
5862#endif
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]5863 sde->err_cnt++;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5864 sdma_engine_error(sde, status);
Joel Rosenzweig2c5b5212015-12-01 15:38:19 -0500[diff] [blame]5865
5866 /*
5867 * Update the counters for the corresponding status bits.
5868 * Note that these particular counters are aggregated over
5869 * all 16 DMA engines.
5870 */
5871 for (i = 0; i < NUM_SEND_DMA_ENG_ERR_STATUS_COUNTERS; i++) {
5872 if (status & (1ull << i))
5873 incr_cntr64(&dd->sw_send_dma_eng_err_status_cnt[i]);
5874 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5875}
5876
5877/*
5878 * CCE block SDMA error interrupt. Source is < 16.
5879 */
5880static void is_sdma_eng_err_int(struct hfi1_devdata *dd, unsigned int source)
5881{
5882#ifdef CONFIG_SDMA_VERBOSITY
5883 struct sdma_engine *sde = &dd->per_sdma[source];
5884
5885 dd_dev_err(dd, "CONFIG SDMA(%u) %s:%d %s()\n", sde->this_idx,
5886 slashstrip(__FILE__), __LINE__, __func__);
5887 dd_dev_err(dd, "CONFIG SDMA(%u) source: %u\n", sde->this_idx,
5888 source);
5889 sdma_dumpstate(sde);
5890#endif
5891 interrupt_clear_down(dd, source, &sdma_eng_err);
5892}
5893
5894/*
5895 * CCE block "various" interrupt. Source is < 8.
5896 */
5897static void is_various_int(struct hfi1_devdata *dd, unsigned int source)
5898{
5899 const struct err_reg_info *eri = &various_err[source];
5900
5901 /*
5902 * TCritInt cannot go through interrupt_clear_down()
5903 * because it is not a second tier interrupt. The handler
5904 * should be called directly.
5905 */
5906 if (source == TCRIT_INT_SOURCE)
5907 handle_temp_err(dd);
5908 else if (eri->handler)
5909 interrupt_clear_down(dd, 0, eri);
5910 else
5911 dd_dev_info(dd,
5912 "%s: Unimplemented/reserved interrupt %d\n",
5913 __func__, source);
5914}
5915
5916static void handle_qsfp_int(struct hfi1_devdata *dd, u32 src_ctx, u64 reg)
5917{
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]5918 /* src_ctx is always zero */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5919 struct hfi1_pportdata *ppd = dd->pport;
5920 unsigned long flags;
5921 u64 qsfp_int_mgmt = (u64)(QSFP_HFI0_INT_N | QSFP_HFI0_MODPRST_N);
5922
5923 if (reg & QSFP_HFI0_MODPRST_N) {
5924
5925 dd_dev_info(dd, "%s: ModPresent triggered QSFP interrupt\n",
5926 __func__);
5927
5928 if (!qsfp_mod_present(ppd)) {
5929 ppd->driver_link_ready = 0;
5930 /*
5931 * Cable removed, reset all our information about the
5932 * cache and cable capabilities
5933 */
5934
5935 spin_lock_irqsave(&ppd->qsfp_info.qsfp_lock, flags);
5936 /*
5937 * We don't set cache_refresh_required here as we expect
5938 * an interrupt when a cable is inserted
5939 */
5940 ppd->qsfp_info.cache_valid = 0;
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]5941 ppd->qsfp_info.reset_needed = 0;
5942 ppd->qsfp_info.limiting_active = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5943 spin_unlock_irqrestore(&ppd->qsfp_info.qsfp_lock,
5944 flags);
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]5945 /* Invert the ModPresent pin now to detect plug-in */
5946 write_csr(dd, dd->hfi1_id ? ASIC_QSFP2_INVERT :
5947 ASIC_QSFP1_INVERT, qsfp_int_mgmt);
Bryan Morgana9c05e32016-02-03 14:30:49 -0800[diff] [blame]5948
5949 if ((ppd->offline_disabled_reason >
5950 HFI1_ODR_MASK(
5951 OPA_LINKDOWN_REASONLOCAL_MEDIA_NOT_INSTALLED)) ||
5952 (ppd->offline_disabled_reason ==
5953 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_NONE)))
5954 ppd->offline_disabled_reason =
5955 HFI1_ODR_MASK(
5956 OPA_LINKDOWN_REASONLOCAL_MEDIA_NOT_INSTALLED);
5957
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5958 if (ppd->host_link_state == HLS_DN_POLL) {
5959 /*
5960 * The link is still in POLL. This means
5961 * that the normal link down processing
5962 * will not happen. We have to do it here
5963 * before turning the DC off.
5964 */
5965 queue_work(ppd->hfi1_wq, &ppd->link_down_work);
5966 }
5967 } else {
5968 spin_lock_irqsave(&ppd->qsfp_info.qsfp_lock, flags);
5969 ppd->qsfp_info.cache_valid = 0;
5970 ppd->qsfp_info.cache_refresh_required = 1;
5971 spin_unlock_irqrestore(&ppd->qsfp_info.qsfp_lock,
5972 flags);
5973
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]5974 /*
5975 * Stop inversion of ModPresent pin to detect
5976 * removal of the cable
5977 */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5978 qsfp_int_mgmt &= ~(u64)QSFP_HFI0_MODPRST_N;
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]5979 write_csr(dd, dd->hfi1_id ? ASIC_QSFP2_INVERT :
5980 ASIC_QSFP1_INVERT, qsfp_int_mgmt);
5981
5982 ppd->offline_disabled_reason =
5983 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_TRANSIENT);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5984 }
5985 }
5986
5987 if (reg & QSFP_HFI0_INT_N) {
5988
5989 dd_dev_info(dd, "%s: IntN triggered QSFP interrupt\n",
5990 __func__);
5991 spin_lock_irqsave(&ppd->qsfp_info.qsfp_lock, flags);
5992 ppd->qsfp_info.check_interrupt_flags = 1;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]5993 spin_unlock_irqrestore(&ppd->qsfp_info.qsfp_lock, flags);
5994 }
5995
5996 /* Schedule the QSFP work only if there is a cable attached. */
5997 if (qsfp_mod_present(ppd))
5998 queue_work(ppd->hfi1_wq, &ppd->qsfp_info.qsfp_work);
5999}
6000
6001static int request_host_lcb_access(struct hfi1_devdata *dd)
6002{
6003 int ret;
6004
6005 ret = do_8051_command(dd, HCMD_MISC,
6006 (u64)HCMD_MISC_REQUEST_LCB_ACCESS << LOAD_DATA_FIELD_ID_SHIFT,
6007 NULL);
6008 if (ret != HCMD_SUCCESS) {
6009 dd_dev_err(dd, "%s: command failed with error %d\n",
6010 __func__, ret);
6011 }
6012 return ret == HCMD_SUCCESS ? 0 : -EBUSY;
6013}
6014
6015static int request_8051_lcb_access(struct hfi1_devdata *dd)
6016{
6017 int ret;
6018
6019 ret = do_8051_command(dd, HCMD_MISC,
6020 (u64)HCMD_MISC_GRANT_LCB_ACCESS << LOAD_DATA_FIELD_ID_SHIFT,
6021 NULL);
6022 if (ret != HCMD_SUCCESS) {
6023 dd_dev_err(dd, "%s: command failed with error %d\n",
6024 __func__, ret);
6025 }
6026 return ret == HCMD_SUCCESS ? 0 : -EBUSY;
6027}
6028
6029/*
6030 * Set the LCB selector - allow host access. The DCC selector always
6031 * points to the host.
6032 */
6033static inline void set_host_lcb_access(struct hfi1_devdata *dd)
6034{
6035 write_csr(dd, DC_DC8051_CFG_CSR_ACCESS_SEL,
6036 DC_DC8051_CFG_CSR_ACCESS_SEL_DCC_SMASK
6037 | DC_DC8051_CFG_CSR_ACCESS_SEL_LCB_SMASK);
6038}
6039
6040/*
6041 * Clear the LCB selector - allow 8051 access. The DCC selector always
6042 * points to the host.
6043 */
6044static inline void set_8051_lcb_access(struct hfi1_devdata *dd)
6045{
6046 write_csr(dd, DC_DC8051_CFG_CSR_ACCESS_SEL,
6047 DC_DC8051_CFG_CSR_ACCESS_SEL_DCC_SMASK);
6048}
6049
6050/*
6051 * Acquire LCB access from the 8051. If the host already has access,
6052 * just increment a counter. Otherwise, inform the 8051 that the
6053 * host is taking access.
6054 *
6055 * Returns:
6056 * 0 on success
6057 * -EBUSY if the 8051 has control and cannot be disturbed
6058 * -errno if unable to acquire access from the 8051
6059 */
6060int acquire_lcb_access(struct hfi1_devdata *dd, int sleep_ok)
6061{
6062 struct hfi1_pportdata *ppd = dd->pport;
6063 int ret = 0;
6064
6065 /*
6066 * Use the host link state lock so the operation of this routine
6067 * { link state check, selector change, count increment } can occur
6068 * as a unit against a link state change. Otherwise there is a
6069 * race between the state change and the count increment.
6070 */
6071 if (sleep_ok) {
6072 mutex_lock(&ppd->hls_lock);
6073 } else {
Dan Carpenter951842b2015-09-16 09:22:51 +0300[diff] [blame]6074 while (!mutex_trylock(&ppd->hls_lock))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6075 udelay(1);
6076 }
6077
6078 /* this access is valid only when the link is up */
6079 if ((ppd->host_link_state & HLS_UP) == 0) {
6080 dd_dev_info(dd, "%s: link state %s not up\n",
6081 __func__, link_state_name(ppd->host_link_state));
6082 ret = -EBUSY;
6083 goto done;
6084 }
6085
6086 if (dd->lcb_access_count == 0) {
6087 ret = request_host_lcb_access(dd);
6088 if (ret) {
6089 dd_dev_err(dd,
6090 "%s: unable to acquire LCB access, err %d\n",
6091 __func__, ret);
6092 goto done;
6093 }
6094 set_host_lcb_access(dd);
6095 }
6096 dd->lcb_access_count++;
6097done:
6098 mutex_unlock(&ppd->hls_lock);
6099 return ret;
6100}
6101
6102/*
6103 * Release LCB access by decrementing the use count. If the count is moving
6104 * from 1 to 0, inform 8051 that it has control back.
6105 *
6106 * Returns:
6107 * 0 on success
6108 * -errno if unable to release access to the 8051
6109 */
6110int release_lcb_access(struct hfi1_devdata *dd, int sleep_ok)
6111{
6112 int ret = 0;
6113
6114 /*
6115 * Use the host link state lock because the acquire needed it.
6116 * Here, we only need to keep { selector change, count decrement }
6117 * as a unit.
6118 */
6119 if (sleep_ok) {
6120 mutex_lock(&dd->pport->hls_lock);
6121 } else {
Dan Carpenter951842b2015-09-16 09:22:51 +0300[diff] [blame]6122 while (!mutex_trylock(&dd->pport->hls_lock))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6123 udelay(1);
6124 }
6125
6126 if (dd->lcb_access_count == 0) {
6127 dd_dev_err(dd, "%s: LCB access count is zero. Skipping.\n",
6128 __func__);
6129 goto done;
6130 }
6131
6132 if (dd->lcb_access_count == 1) {
6133 set_8051_lcb_access(dd);
6134 ret = request_8051_lcb_access(dd);
6135 if (ret) {
6136 dd_dev_err(dd,
6137 "%s: unable to release LCB access, err %d\n",
6138 __func__, ret);
6139 /* restore host access if the grant didn't work */
6140 set_host_lcb_access(dd);
6141 goto done;
6142 }
6143 }
6144 dd->lcb_access_count--;
6145done:
6146 mutex_unlock(&dd->pport->hls_lock);
6147 return ret;
6148}
6149
6150/*
6151 * Initialize LCB access variables and state. Called during driver load,
6152 * after most of the initialization is finished.
6153 *
6154 * The DC default is LCB access on for the host. The driver defaults to
6155 * leaving access to the 8051. Assign access now - this constrains the call
6156 * to this routine to be after all LCB set-up is done. In particular, after
6157 * hf1_init_dd() -> set_up_interrupts() -> clear_all_interrupts()
6158 */
6159static void init_lcb_access(struct hfi1_devdata *dd)
6160{
6161 dd->lcb_access_count = 0;
6162}
6163
6164/*
6165 * Write a response back to a 8051 request.
6166 */
6167static void hreq_response(struct hfi1_devdata *dd, u8 return_code, u16 rsp_data)
6168{
6169 write_csr(dd, DC_DC8051_CFG_EXT_DEV_0,
6170 DC_DC8051_CFG_EXT_DEV_0_COMPLETED_SMASK
6171 | (u64)return_code << DC_DC8051_CFG_EXT_DEV_0_RETURN_CODE_SHIFT
6172 | (u64)rsp_data << DC_DC8051_CFG_EXT_DEV_0_RSP_DATA_SHIFT);
6173}
6174
6175/*
Easwar Hariharancbac3862016-02-03 14:31:31 -0800[diff] [blame]6176 * Handle host requests from the 8051.
6177 *
6178 * This is a work-queue function outside of the interrupt.
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6179 */
Easwar Hariharancbac3862016-02-03 14:31:31 -0800[diff] [blame]6180void handle_8051_request(struct work_struct *work)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6181{
Easwar Hariharancbac3862016-02-03 14:31:31 -0800[diff] [blame]6182 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
6183 dc_host_req_work);
6184 struct hfi1_devdata *dd = ppd->dd;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6185 u64 reg;
Easwar Hariharancbac3862016-02-03 14:31:31 -0800[diff] [blame]6186 u16 data = 0;
6187 u8 type, i, lanes, *cache = ppd->qsfp_info.cache;
6188 u8 cdr_ctrl_byte = cache[QSFP_CDR_CTRL_BYTE_OFFS];
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6189
6190 reg = read_csr(dd, DC_DC8051_CFG_EXT_DEV_1);
6191 if ((reg & DC_DC8051_CFG_EXT_DEV_1_REQ_NEW_SMASK) == 0)
6192 return; /* no request */
6193
6194 /* zero out COMPLETED so the response is seen */
6195 write_csr(dd, DC_DC8051_CFG_EXT_DEV_0, 0);
6196
6197 /* extract request details */
6198 type = (reg >> DC_DC8051_CFG_EXT_DEV_1_REQ_TYPE_SHIFT)
6199 & DC_DC8051_CFG_EXT_DEV_1_REQ_TYPE_MASK;
6200 data = (reg >> DC_DC8051_CFG_EXT_DEV_1_REQ_DATA_SHIFT)
6201 & DC_DC8051_CFG_EXT_DEV_1_REQ_DATA_MASK;
6202
6203 switch (type) {
6204 case HREQ_LOAD_CONFIG:
6205 case HREQ_SAVE_CONFIG:
6206 case HREQ_READ_CONFIG:
6207 case HREQ_SET_TX_EQ_ABS:
6208 case HREQ_SET_TX_EQ_REL:
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6209 dd_dev_info(dd, "8051 request: request 0x%x not supported\n",
6210 type);
6211 hreq_response(dd, HREQ_NOT_SUPPORTED, 0);
6212 break;
6213
Easwar Hariharancbac3862016-02-03 14:31:31 -0800[diff] [blame]6214 case HREQ_ENABLE:
6215 lanes = data & 0xF;
6216 for (i = 0; lanes; lanes >>= 1, i++) {
6217 if (!(lanes & 1))
6218 continue;
6219 if (data & 0x200) {
6220 /* enable TX CDR */
6221 if (cache[QSFP_MOD_PWR_OFFS] & 0x8 &&
6222 cache[QSFP_CDR_INFO_OFFS] & 0x80)
6223 cdr_ctrl_byte |= (1 << (i + 4));
6224 } else {
6225 /* disable TX CDR */
6226 if (cache[QSFP_MOD_PWR_OFFS] & 0x8 &&
6227 cache[QSFP_CDR_INFO_OFFS] & 0x80)
6228 cdr_ctrl_byte &= ~(1 << (i + 4));
6229 }
6230
6231 if (data & 0x800) {
6232 /* enable RX CDR */
6233 if (cache[QSFP_MOD_PWR_OFFS] & 0x4 &&
6234 cache[QSFP_CDR_INFO_OFFS] & 0x40)
6235 cdr_ctrl_byte |= (1 << i);
6236 } else {
6237 /* disable RX CDR */
6238 if (cache[QSFP_MOD_PWR_OFFS] & 0x4 &&
6239 cache[QSFP_CDR_INFO_OFFS] & 0x40)
6240 cdr_ctrl_byte &= ~(1 << i);
6241 }
6242 }
6243 qsfp_write(ppd, ppd->dd->hfi1_id, QSFP_CDR_CTRL_BYTE_OFFS,
6244 &cdr_ctrl_byte, 1);
6245 hreq_response(dd, HREQ_SUCCESS, data);
6246 refresh_qsfp_cache(ppd, &ppd->qsfp_info);
6247 break;
6248
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6249 case HREQ_CONFIG_DONE:
6250 hreq_response(dd, HREQ_SUCCESS, 0);
6251 break;
6252
6253 case HREQ_INTERFACE_TEST:
6254 hreq_response(dd, HREQ_SUCCESS, data);
6255 break;
6256
6257 default:
6258 dd_dev_err(dd, "8051 request: unknown request 0x%x\n", type);
6259 hreq_response(dd, HREQ_NOT_SUPPORTED, 0);
6260 break;
6261 }
6262}
6263
6264static void write_global_credit(struct hfi1_devdata *dd,
6265 u8 vau, u16 total, u16 shared)
6266{
6267 write_csr(dd, SEND_CM_GLOBAL_CREDIT,
6268 ((u64)total
6269 << SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT)
6270 | ((u64)shared
6271 << SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT)
6272 | ((u64)vau << SEND_CM_GLOBAL_CREDIT_AU_SHIFT));
6273}
6274
6275/*
6276 * Set up initial VL15 credits of the remote. Assumes the rest of
6277 * the CM credit registers are zero from a previous global or credit reset .
6278 */
6279void set_up_vl15(struct hfi1_devdata *dd, u8 vau, u16 vl15buf)
6280{
6281 /* leave shared count at zero for both global and VL15 */
6282 write_global_credit(dd, vau, vl15buf, 0);
6283
6284 /* We may need some credits for another VL when sending packets
6285 * with the snoop interface. Dividing it down the middle for VL15
6286 * and VL0 should suffice.
6287 */
6288 if (unlikely(dd->hfi1_snoop.mode_flag == HFI1_PORT_SNOOP_MODE)) {
6289 write_csr(dd, SEND_CM_CREDIT_VL15, (u64)(vl15buf >> 1)
6290 << SEND_CM_CREDIT_VL15_DEDICATED_LIMIT_VL_SHIFT);
6291 write_csr(dd, SEND_CM_CREDIT_VL, (u64)(vl15buf >> 1)
6292 << SEND_CM_CREDIT_VL_DEDICATED_LIMIT_VL_SHIFT);
6293 } else {
6294 write_csr(dd, SEND_CM_CREDIT_VL15, (u64)vl15buf
6295 << SEND_CM_CREDIT_VL15_DEDICATED_LIMIT_VL_SHIFT);
6296 }
6297}
6298
6299/*
6300 * Zero all credit details from the previous connection and
6301 * reset the CM manager's internal counters.
6302 */
6303void reset_link_credits(struct hfi1_devdata *dd)
6304{
6305 int i;
6306
6307 /* remove all previous VL credit limits */
6308 for (i = 0; i < TXE_NUM_DATA_VL; i++)
6309 write_csr(dd, SEND_CM_CREDIT_VL + (8*i), 0);
6310 write_csr(dd, SEND_CM_CREDIT_VL15, 0);
6311 write_global_credit(dd, 0, 0, 0);
6312 /* reset the CM block */
6313 pio_send_control(dd, PSC_CM_RESET);
6314}
6315
6316/* convert a vCU to a CU */
6317static u32 vcu_to_cu(u8 vcu)
6318{
6319 return 1 << vcu;
6320}
6321
6322/* convert a CU to a vCU */
6323static u8 cu_to_vcu(u32 cu)
6324{
6325 return ilog2(cu);
6326}
6327
6328/* convert a vAU to an AU */
6329static u32 vau_to_au(u8 vau)
6330{
6331 return 8 * (1 << vau);
6332}
6333
6334static void set_linkup_defaults(struct hfi1_pportdata *ppd)
6335{
6336 ppd->sm_trap_qp = 0x0;
6337 ppd->sa_qp = 0x1;
6338}
6339
6340/*
6341 * Graceful LCB shutdown. This leaves the LCB FIFOs in reset.
6342 */
6343static void lcb_shutdown(struct hfi1_devdata *dd, int abort)
6344{
6345 u64 reg;
6346
6347 /* clear lcb run: LCB_CFG_RUN.EN = 0 */
6348 write_csr(dd, DC_LCB_CFG_RUN, 0);
6349 /* set tx fifo reset: LCB_CFG_TX_FIFOS_RESET.VAL = 1 */
6350 write_csr(dd, DC_LCB_CFG_TX_FIFOS_RESET,
6351 1ull << DC_LCB_CFG_TX_FIFOS_RESET_VAL_SHIFT);
6352 /* set dcc reset csr: DCC_CFG_RESET.{reset_lcb,reset_rx_fpe} = 1 */
6353 dd->lcb_err_en = read_csr(dd, DC_LCB_ERR_EN);
6354 reg = read_csr(dd, DCC_CFG_RESET);
6355 write_csr(dd, DCC_CFG_RESET,
6356 reg
6357 | (1ull << DCC_CFG_RESET_RESET_LCB_SHIFT)
6358 | (1ull << DCC_CFG_RESET_RESET_RX_FPE_SHIFT));
6359 (void) read_csr(dd, DCC_CFG_RESET); /* make sure the write completed */
6360 if (!abort) {
6361 udelay(1); /* must hold for the longer of 16cclks or 20ns */
6362 write_csr(dd, DCC_CFG_RESET, reg);
6363 write_csr(dd, DC_LCB_ERR_EN, dd->lcb_err_en);
6364 }
6365}
6366
6367/*
6368 * This routine should be called after the link has been transitioned to
6369 * OFFLINE (OFFLINE state has the side effect of putting the SerDes into
6370 * reset).
6371 *
6372 * The expectation is that the caller of this routine would have taken
6373 * care of properly transitioning the link into the correct state.
6374 */
6375static void dc_shutdown(struct hfi1_devdata *dd)
6376{
6377 unsigned long flags;
6378
6379 spin_lock_irqsave(&dd->dc8051_lock, flags);
6380 if (dd->dc_shutdown) {
6381 spin_unlock_irqrestore(&dd->dc8051_lock, flags);
6382 return;
6383 }
6384 dd->dc_shutdown = 1;
6385 spin_unlock_irqrestore(&dd->dc8051_lock, flags);
6386 /* Shutdown the LCB */
6387 lcb_shutdown(dd, 1);
6388 /* Going to OFFLINE would have causes the 8051 to put the
6389 * SerDes into reset already. Just need to shut down the 8051,
6390 * itself. */
6391 write_csr(dd, DC_DC8051_CFG_RST, 0x1);
6392}
6393
6394/* Calling this after the DC has been brought out of reset should not
6395 * do any damage. */
6396static void dc_start(struct hfi1_devdata *dd)
6397{
6398 unsigned long flags;
6399 int ret;
6400
6401 spin_lock_irqsave(&dd->dc8051_lock, flags);
6402 if (!dd->dc_shutdown)
6403 goto done;
6404 spin_unlock_irqrestore(&dd->dc8051_lock, flags);
6405 /* Take the 8051 out of reset */
6406 write_csr(dd, DC_DC8051_CFG_RST, 0ull);
6407 /* Wait until 8051 is ready */
6408 ret = wait_fm_ready(dd, TIMEOUT_8051_START);
6409 if (ret) {
6410 dd_dev_err(dd, "%s: timeout starting 8051 firmware\n",
6411 __func__);
6412 }
6413 /* Take away reset for LCB and RX FPE (set in lcb_shutdown). */
6414 write_csr(dd, DCC_CFG_RESET, 0x10);
6415 /* lcb_shutdown() with abort=1 does not restore these */
6416 write_csr(dd, DC_LCB_ERR_EN, dd->lcb_err_en);
6417 spin_lock_irqsave(&dd->dc8051_lock, flags);
6418 dd->dc_shutdown = 0;
6419done:
6420 spin_unlock_irqrestore(&dd->dc8051_lock, flags);
6421}
6422
6423/*
6424 * These LCB adjustments are for the Aurora SerDes core in the FPGA.
6425 */
6426static void adjust_lcb_for_fpga_serdes(struct hfi1_devdata *dd)
6427{
6428 u64 rx_radr, tx_radr;
6429 u32 version;
6430
6431 if (dd->icode != ICODE_FPGA_EMULATION)
6432 return;
6433
6434 /*
6435 * These LCB defaults on emulator _s are good, nothing to do here:
6436 * LCB_CFG_TX_FIFOS_RADR
6437 * LCB_CFG_RX_FIFOS_RADR
6438 * LCB_CFG_LN_DCLK
6439 * LCB_CFG_IGNORE_LOST_RCLK
6440 */
6441 if (is_emulator_s(dd))
6442 return;
6443 /* else this is _p */
6444
6445 version = emulator_rev(dd);
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]6446 if (!is_ax(dd))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6447 version = 0x2d; /* all B0 use 0x2d or higher settings */
6448
6449 if (version <= 0x12) {
6450 /* release 0x12 and below */
6451
6452 /*
6453 * LCB_CFG_RX_FIFOS_RADR.RST_VAL = 0x9
6454 * LCB_CFG_RX_FIFOS_RADR.OK_TO_JUMP_VAL = 0x9
6455 * LCB_CFG_RX_FIFOS_RADR.DO_NOT_JUMP_VAL = 0xa
6456 */
6457 rx_radr =
6458 0xaull << DC_LCB_CFG_RX_FIFOS_RADR_DO_NOT_JUMP_VAL_SHIFT
6459 | 0x9ull << DC_LCB_CFG_RX_FIFOS_RADR_OK_TO_JUMP_VAL_SHIFT
6460 | 0x9ull << DC_LCB_CFG_RX_FIFOS_RADR_RST_VAL_SHIFT;
6461 /*
6462 * LCB_CFG_TX_FIFOS_RADR.ON_REINIT = 0 (default)
6463 * LCB_CFG_TX_FIFOS_RADR.RST_VAL = 6
6464 */
6465 tx_radr = 6ull << DC_LCB_CFG_TX_FIFOS_RADR_RST_VAL_SHIFT;
6466 } else if (version <= 0x18) {
6467 /* release 0x13 up to 0x18 */
6468 /* LCB_CFG_RX_FIFOS_RADR = 0x988 */
6469 rx_radr =
6470 0x9ull << DC_LCB_CFG_RX_FIFOS_RADR_DO_NOT_JUMP_VAL_SHIFT
6471 | 0x8ull << DC_LCB_CFG_RX_FIFOS_RADR_OK_TO_JUMP_VAL_SHIFT
6472 | 0x8ull << DC_LCB_CFG_RX_FIFOS_RADR_RST_VAL_SHIFT;
6473 tx_radr = 7ull << DC_LCB_CFG_TX_FIFOS_RADR_RST_VAL_SHIFT;
6474 } else if (version == 0x19) {
6475 /* release 0x19 */
6476 /* LCB_CFG_RX_FIFOS_RADR = 0xa99 */
6477 rx_radr =
6478 0xAull << DC_LCB_CFG_RX_FIFOS_RADR_DO_NOT_JUMP_VAL_SHIFT
6479 | 0x9ull << DC_LCB_CFG_RX_FIFOS_RADR_OK_TO_JUMP_VAL_SHIFT
6480 | 0x9ull << DC_LCB_CFG_RX_FIFOS_RADR_RST_VAL_SHIFT;
6481 tx_radr = 3ull << DC_LCB_CFG_TX_FIFOS_RADR_RST_VAL_SHIFT;
6482 } else if (version == 0x1a) {
6483 /* release 0x1a */
6484 /* LCB_CFG_RX_FIFOS_RADR = 0x988 */
6485 rx_radr =
6486 0x9ull << DC_LCB_CFG_RX_FIFOS_RADR_DO_NOT_JUMP_VAL_SHIFT
6487 | 0x8ull << DC_LCB_CFG_RX_FIFOS_RADR_OK_TO_JUMP_VAL_SHIFT
6488 | 0x8ull << DC_LCB_CFG_RX_FIFOS_RADR_RST_VAL_SHIFT;
6489 tx_radr = 7ull << DC_LCB_CFG_TX_FIFOS_RADR_RST_VAL_SHIFT;
6490 write_csr(dd, DC_LCB_CFG_LN_DCLK, 1ull);
6491 } else {
6492 /* release 0x1b and higher */
6493 /* LCB_CFG_RX_FIFOS_RADR = 0x877 */
6494 rx_radr =
6495 0x8ull << DC_LCB_CFG_RX_FIFOS_RADR_DO_NOT_JUMP_VAL_SHIFT
6496 | 0x7ull << DC_LCB_CFG_RX_FIFOS_RADR_OK_TO_JUMP_VAL_SHIFT
6497 | 0x7ull << DC_LCB_CFG_RX_FIFOS_RADR_RST_VAL_SHIFT;
6498 tx_radr = 3ull << DC_LCB_CFG_TX_FIFOS_RADR_RST_VAL_SHIFT;
6499 }
6500
6501 write_csr(dd, DC_LCB_CFG_RX_FIFOS_RADR, rx_radr);
6502 /* LCB_CFG_IGNORE_LOST_RCLK.EN = 1 */
6503 write_csr(dd, DC_LCB_CFG_IGNORE_LOST_RCLK,
6504 DC_LCB_CFG_IGNORE_LOST_RCLK_EN_SMASK);
6505 write_csr(dd, DC_LCB_CFG_TX_FIFOS_RADR, tx_radr);
6506}
6507
6508/*
6509 * Handle a SMA idle message
6510 *
6511 * This is a work-queue function outside of the interrupt.
6512 */
6513void handle_sma_message(struct work_struct *work)
6514{
6515 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
6516 sma_message_work);
6517 struct hfi1_devdata *dd = ppd->dd;
6518 u64 msg;
6519 int ret;
6520
6521 /* msg is bytes 1-4 of the 40-bit idle message - the command code
6522 is stripped off */
6523 ret = read_idle_sma(dd, &msg);
6524 if (ret)
6525 return;
6526 dd_dev_info(dd, "%s: SMA message 0x%llx\n", __func__, msg);
6527 /*
6528 * React to the SMA message. Byte[1] (0 for us) is the command.
6529 */
6530 switch (msg & 0xff) {
6531 case SMA_IDLE_ARM:
6532 /*
6533 * See OPAv1 table 9-14 - HFI and External Switch Ports Key
6534 * State Transitions
6535 *
6536 * Only expected in INIT or ARMED, discard otherwise.
6537 */
6538 if (ppd->host_link_state & (HLS_UP_INIT | HLS_UP_ARMED))
6539 ppd->neighbor_normal = 1;
6540 break;
6541 case SMA_IDLE_ACTIVE:
6542 /*
6543 * See OPAv1 table 9-14 - HFI and External Switch Ports Key
6544 * State Transitions
6545 *
6546 * Can activate the node. Discard otherwise.
6547 */
6548 if (ppd->host_link_state == HLS_UP_ARMED
6549 && ppd->is_active_optimize_enabled) {
6550 ppd->neighbor_normal = 1;
6551 ret = set_link_state(ppd, HLS_UP_ACTIVE);
6552 if (ret)
6553 dd_dev_err(
6554 dd,
6555 "%s: received Active SMA idle message, couldn't set link to Active\n",
6556 __func__);
6557 }
6558 break;
6559 default:
6560 dd_dev_err(dd,
6561 "%s: received unexpected SMA idle message 0x%llx\n",
6562 __func__, msg);
6563 break;
6564 }
6565}
6566
6567static void adjust_rcvctrl(struct hfi1_devdata *dd, u64 add, u64 clear)
6568{
6569 u64 rcvctrl;
6570 unsigned long flags;
6571
6572 spin_lock_irqsave(&dd->rcvctrl_lock, flags);
6573 rcvctrl = read_csr(dd, RCV_CTRL);
6574 rcvctrl |= add;
6575 rcvctrl &= ~clear;
6576 write_csr(dd, RCV_CTRL, rcvctrl);
6577 spin_unlock_irqrestore(&dd->rcvctrl_lock, flags);
6578}
6579
6580static inline void add_rcvctrl(struct hfi1_devdata *dd, u64 add)
6581{
6582 adjust_rcvctrl(dd, add, 0);
6583}
6584
6585static inline void clear_rcvctrl(struct hfi1_devdata *dd, u64 clear)
6586{
6587 adjust_rcvctrl(dd, 0, clear);
6588}
6589
6590/*
6591 * Called from all interrupt handlers to start handling an SPC freeze.
6592 */
6593void start_freeze_handling(struct hfi1_pportdata *ppd, int flags)
6594{
6595 struct hfi1_devdata *dd = ppd->dd;
6596 struct send_context *sc;
6597 int i;
6598
6599 if (flags & FREEZE_SELF)
6600 write_csr(dd, CCE_CTRL, CCE_CTRL_SPC_FREEZE_SMASK);
6601
6602 /* enter frozen mode */
6603 dd->flags |= HFI1_FROZEN;
6604
6605 /* notify all SDMA engines that they are going into a freeze */
6606 sdma_freeze_notify(dd, !!(flags & FREEZE_LINK_DOWN));
6607
6608 /* do halt pre-handling on all enabled send contexts */
6609 for (i = 0; i < dd->num_send_contexts; i++) {
6610 sc = dd->send_contexts[i].sc;
6611 if (sc && (sc->flags & SCF_ENABLED))
6612 sc_stop(sc, SCF_FROZEN | SCF_HALTED);
6613 }
6614
6615 /* Send context are frozen. Notify user space */
6616 hfi1_set_uevent_bits(ppd, _HFI1_EVENT_FROZEN_BIT);
6617
6618 if (flags & FREEZE_ABORT) {
6619 dd_dev_err(dd,
6620 "Aborted freeze recovery. Please REBOOT system\n");
6621 return;
6622 }
6623 /* queue non-interrupt handler */
6624 queue_work(ppd->hfi1_wq, &ppd->freeze_work);
6625}
6626
6627/*
6628 * Wait until all 4 sub-blocks indicate that they have frozen or unfrozen,
6629 * depending on the "freeze" parameter.
6630 *
6631 * No need to return an error if it times out, our only option
6632 * is to proceed anyway.
6633 */
6634static void wait_for_freeze_status(struct hfi1_devdata *dd, int freeze)
6635{
6636 unsigned long timeout;
6637 u64 reg;
6638
6639 timeout = jiffies + msecs_to_jiffies(FREEZE_STATUS_TIMEOUT);
6640 while (1) {
6641 reg = read_csr(dd, CCE_STATUS);
6642 if (freeze) {
6643 /* waiting until all indicators are set */
6644 if ((reg & ALL_FROZE) == ALL_FROZE)
6645 return; /* all done */
6646 } else {
6647 /* waiting until all indicators are clear */
6648 if ((reg & ALL_FROZE) == 0)
6649 return; /* all done */
6650 }
6651
6652 if (time_after(jiffies, timeout)) {
6653 dd_dev_err(dd,
6654 "Time out waiting for SPC %sfreeze, bits 0x%llx, expecting 0x%llx, continuing",
6655 freeze ? "" : "un",
6656 reg & ALL_FROZE,
6657 freeze ? ALL_FROZE : 0ull);
6658 return;
6659 }
6660 usleep_range(80, 120);
6661 }
6662}
6663
6664/*
6665 * Do all freeze handling for the RXE block.
6666 */
6667static void rxe_freeze(struct hfi1_devdata *dd)
6668{
6669 int i;
6670
6671 /* disable port */
6672 clear_rcvctrl(dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
6673
6674 /* disable all receive contexts */
6675 for (i = 0; i < dd->num_rcv_contexts; i++)
6676 hfi1_rcvctrl(dd, HFI1_RCVCTRL_CTXT_DIS, i);
6677}
6678
6679/*
6680 * Unfreeze handling for the RXE block - kernel contexts only.
6681 * This will also enable the port. User contexts will do unfreeze
6682 * handling on a per-context basis as they call into the driver.
6683 *
6684 */
6685static void rxe_kernel_unfreeze(struct hfi1_devdata *dd)
6686{
6687 int i;
6688
6689 /* enable all kernel contexts */
6690 for (i = 0; i < dd->n_krcv_queues; i++)
6691 hfi1_rcvctrl(dd, HFI1_RCVCTRL_CTXT_ENB, i);
6692
6693 /* enable port */
6694 add_rcvctrl(dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
6695}
6696
6697/*
6698 * Non-interrupt SPC freeze handling.
6699 *
6700 * This is a work-queue function outside of the triggering interrupt.
6701 */
6702void handle_freeze(struct work_struct *work)
6703{
6704 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
6705 freeze_work);
6706 struct hfi1_devdata *dd = ppd->dd;
6707
6708 /* wait for freeze indicators on all affected blocks */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6709 wait_for_freeze_status(dd, 1);
6710
6711 /* SPC is now frozen */
6712
6713 /* do send PIO freeze steps */
6714 pio_freeze(dd);
6715
6716 /* do send DMA freeze steps */
6717 sdma_freeze(dd);
6718
6719 /* do send egress freeze steps - nothing to do */
6720
6721 /* do receive freeze steps */
6722 rxe_freeze(dd);
6723
6724 /*
6725 * Unfreeze the hardware - clear the freeze, wait for each
6726 * block's frozen bit to clear, then clear the frozen flag.
6727 */
6728 write_csr(dd, CCE_CTRL, CCE_CTRL_SPC_UNFREEZE_SMASK);
6729 wait_for_freeze_status(dd, 0);
6730
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]6731 if (is_ax(dd)) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6732 write_csr(dd, CCE_CTRL, CCE_CTRL_SPC_FREEZE_SMASK);
6733 wait_for_freeze_status(dd, 1);
6734 write_csr(dd, CCE_CTRL, CCE_CTRL_SPC_UNFREEZE_SMASK);
6735 wait_for_freeze_status(dd, 0);
6736 }
6737
6738 /* do send PIO unfreeze steps for kernel contexts */
6739 pio_kernel_unfreeze(dd);
6740
6741 /* do send DMA unfreeze steps */
6742 sdma_unfreeze(dd);
6743
6744 /* do send egress unfreeze steps - nothing to do */
6745
6746 /* do receive unfreeze steps for kernel contexts */
6747 rxe_kernel_unfreeze(dd);
6748
6749 /*
6750 * The unfreeze procedure touches global device registers when
6751 * it disables and re-enables RXE. Mark the device unfrozen
6752 * after all that is done so other parts of the driver waiting
6753 * for the device to unfreeze don't do things out of order.
6754 *
6755 * The above implies that the meaning of HFI1_FROZEN flag is
6756 * "Device has gone into freeze mode and freeze mode handling
6757 * is still in progress."
6758 *
6759 * The flag will be removed when freeze mode processing has
6760 * completed.
6761 */
6762 dd->flags &= ~HFI1_FROZEN;
6763 wake_up(&dd->event_queue);
6764
6765 /* no longer frozen */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6766}
6767
6768/*
6769 * Handle a link up interrupt from the 8051.
6770 *
6771 * This is a work-queue function outside of the interrupt.
6772 */
6773void handle_link_up(struct work_struct *work)
6774{
6775 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
6776 link_up_work);
6777 set_link_state(ppd, HLS_UP_INIT);
6778
6779 /* cache the read of DC_LCB_STS_ROUND_TRIP_LTP_CNT */
6780 read_ltp_rtt(ppd->dd);
6781 /*
6782 * OPA specifies that certain counters are cleared on a transition
6783 * to link up, so do that.
6784 */
6785 clear_linkup_counters(ppd->dd);
6786 /*
6787 * And (re)set link up default values.
6788 */
6789 set_linkup_defaults(ppd);
6790
6791 /* enforce link speed enabled */
6792 if ((ppd->link_speed_active & ppd->link_speed_enabled) == 0) {
6793 /* oops - current speed is not enabled, bounce */
6794 dd_dev_err(ppd->dd,
6795 "Link speed active 0x%x is outside enabled 0x%x, downing link\n",
6796 ppd->link_speed_active, ppd->link_speed_enabled);
6797 set_link_down_reason(ppd, OPA_LINKDOWN_REASON_SPEED_POLICY, 0,
6798 OPA_LINKDOWN_REASON_SPEED_POLICY);
6799 set_link_state(ppd, HLS_DN_OFFLINE);
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]6800 tune_serdes(ppd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6801 start_link(ppd);
6802 }
6803}
6804
6805/* Several pieces of LNI information were cached for SMA in ppd.
6806 * Reset these on link down */
6807static void reset_neighbor_info(struct hfi1_pportdata *ppd)
6808{
6809 ppd->neighbor_guid = 0;
6810 ppd->neighbor_port_number = 0;
6811 ppd->neighbor_type = 0;
6812 ppd->neighbor_fm_security = 0;
6813}
6814
6815/*
6816 * Handle a link down interrupt from the 8051.
6817 *
6818 * This is a work-queue function outside of the interrupt.
6819 */
6820void handle_link_down(struct work_struct *work)
6821{
6822 u8 lcl_reason, neigh_reason = 0;
6823 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
6824 link_down_work);
6825
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]6826 if ((ppd->host_link_state &
6827 (HLS_DN_POLL | HLS_VERIFY_CAP | HLS_GOING_UP)) &&
6828 ppd->port_type == PORT_TYPE_FIXED)
6829 ppd->offline_disabled_reason =
6830 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_NOT_INSTALLED);
6831
6832 /* Go offline first, then deal with reading/writing through 8051 */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6833 set_link_state(ppd, HLS_DN_OFFLINE);
6834
6835 lcl_reason = 0;
6836 read_planned_down_reason_code(ppd->dd, &neigh_reason);
6837
6838 /*
6839 * If no reason, assume peer-initiated but missed
6840 * LinkGoingDown idle flits.
6841 */
6842 if (neigh_reason == 0)
6843 lcl_reason = OPA_LINKDOWN_REASON_NEIGHBOR_UNKNOWN;
6844
6845 set_link_down_reason(ppd, lcl_reason, neigh_reason, 0);
6846
6847 reset_neighbor_info(ppd);
6848
6849 /* disable the port */
6850 clear_rcvctrl(ppd->dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
6851
6852 /* If there is no cable attached, turn the DC off. Otherwise,
6853 * start the link bring up. */
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]6854 if (!qsfp_mod_present(ppd)) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6855 dc_shutdown(ppd->dd);
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]6856 } else {
6857 tune_serdes(ppd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6858 start_link(ppd);
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]6859 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6860}
6861
6862void handle_link_bounce(struct work_struct *work)
6863{
6864 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
6865 link_bounce_work);
6866
6867 /*
6868 * Only do something if the link is currently up.
6869 */
6870 if (ppd->host_link_state & HLS_UP) {
6871 set_link_state(ppd, HLS_DN_OFFLINE);
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]6872 tune_serdes(ppd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6873 start_link(ppd);
6874 } else {
6875 dd_dev_info(ppd->dd, "%s: link not up (%s), nothing to do\n",
6876 __func__, link_state_name(ppd->host_link_state));
6877 }
6878}
6879
6880/*
6881 * Mask conversion: Capability exchange to Port LTP. The capability
6882 * exchange has an implicit 16b CRC that is mandatory.
6883 */
6884static int cap_to_port_ltp(int cap)
6885{
6886 int port_ltp = PORT_LTP_CRC_MODE_16; /* this mode is mandatory */
6887
6888 if (cap & CAP_CRC_14B)
6889 port_ltp |= PORT_LTP_CRC_MODE_14;
6890 if (cap & CAP_CRC_48B)
6891 port_ltp |= PORT_LTP_CRC_MODE_48;
6892 if (cap & CAP_CRC_12B_16B_PER_LANE)
6893 port_ltp |= PORT_LTP_CRC_MODE_PER_LANE;
6894
6895 return port_ltp;
6896}
6897
6898/*
6899 * Convert an OPA Port LTP mask to capability mask
6900 */
6901int port_ltp_to_cap(int port_ltp)
6902{
6903 int cap_mask = 0;
6904
6905 if (port_ltp & PORT_LTP_CRC_MODE_14)
6906 cap_mask |= CAP_CRC_14B;
6907 if (port_ltp & PORT_LTP_CRC_MODE_48)
6908 cap_mask |= CAP_CRC_48B;
6909 if (port_ltp & PORT_LTP_CRC_MODE_PER_LANE)
6910 cap_mask |= CAP_CRC_12B_16B_PER_LANE;
6911
6912 return cap_mask;
6913}
6914
6915/*
6916 * Convert a single DC LCB CRC mode to an OPA Port LTP mask.
6917 */
6918static int lcb_to_port_ltp(int lcb_crc)
6919{
6920 int port_ltp = 0;
6921
6922 if (lcb_crc == LCB_CRC_12B_16B_PER_LANE)
6923 port_ltp = PORT_LTP_CRC_MODE_PER_LANE;
6924 else if (lcb_crc == LCB_CRC_48B)
6925 port_ltp = PORT_LTP_CRC_MODE_48;
6926 else if (lcb_crc == LCB_CRC_14B)
6927 port_ltp = PORT_LTP_CRC_MODE_14;
6928 else
6929 port_ltp = PORT_LTP_CRC_MODE_16;
6930
6931 return port_ltp;
6932}
6933
6934/*
6935 * Our neighbor has indicated that we are allowed to act as a fabric
6936 * manager, so place the full management partition key in the second
6937 * (0-based) pkey array position (see OPAv1, section 20.2.2.6.8). Note
6938 * that we should already have the limited management partition key in
6939 * array element 1, and also that the port is not yet up when
6940 * add_full_mgmt_pkey() is invoked.
6941 */
6942static void add_full_mgmt_pkey(struct hfi1_pportdata *ppd)
6943{
6944 struct hfi1_devdata *dd = ppd->dd;
6945
Dean Luick87645222015-12-01 15:38:21 -0500[diff] [blame]6946 /* Sanity check - ppd->pkeys[2] should be 0, or already initalized */
6947 if (!((ppd->pkeys[2] == 0) || (ppd->pkeys[2] == FULL_MGMT_P_KEY)))
6948 dd_dev_warn(dd, "%s pkey[2] already set to 0x%x, resetting it to 0x%x\n",
6949 __func__, ppd->pkeys[2], FULL_MGMT_P_KEY);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]6950 ppd->pkeys[2] = FULL_MGMT_P_KEY;
6951 (void)hfi1_set_ib_cfg(ppd, HFI1_IB_CFG_PKEYS, 0);
6952}
6953
6954/*
6955 * Convert the given link width to the OPA link width bitmask.
6956 */
6957static u16 link_width_to_bits(struct hfi1_devdata *dd, u16 width)
6958{
6959 switch (width) {
6960 case 0:
6961 /*
6962 * Simulator and quick linkup do not set the width.
6963 * Just set it to 4x without complaint.
6964 */
6965 if (dd->icode == ICODE_FUNCTIONAL_SIMULATOR || quick_linkup)
6966 return OPA_LINK_WIDTH_4X;
6967 return 0; /* no lanes up */
6968 case 1: return OPA_LINK_WIDTH_1X;
6969 case 2: return OPA_LINK_WIDTH_2X;
6970 case 3: return OPA_LINK_WIDTH_3X;
6971 default:
6972 dd_dev_info(dd, "%s: invalid width %d, using 4\n",
6973 __func__, width);
6974 /* fall through */
6975 case 4: return OPA_LINK_WIDTH_4X;
6976 }
6977}
6978
6979/*
6980 * Do a population count on the bottom nibble.
6981 */
6982static const u8 bit_counts[16] = {
6983 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
6984};
6985static inline u8 nibble_to_count(u8 nibble)
6986{
6987 return bit_counts[nibble & 0xf];
6988}
6989
6990/*
6991 * Read the active lane information from the 8051 registers and return
6992 * their widths.
6993 *
6994 * Active lane information is found in these 8051 registers:
6995 * enable_lane_tx
6996 * enable_lane_rx
6997 */
6998static void get_link_widths(struct hfi1_devdata *dd, u16 *tx_width,
6999 u16 *rx_width)
7000{
7001 u16 tx, rx;
7002 u8 enable_lane_rx;
7003 u8 enable_lane_tx;
7004 u8 tx_polarity_inversion;
7005 u8 rx_polarity_inversion;
7006 u8 max_rate;
7007
7008 /* read the active lanes */
7009 read_tx_settings(dd, &enable_lane_tx, &tx_polarity_inversion,
7010 &rx_polarity_inversion, &max_rate);
7011 read_local_lni(dd, &enable_lane_rx);
7012
7013 /* convert to counts */
7014 tx = nibble_to_count(enable_lane_tx);
7015 rx = nibble_to_count(enable_lane_rx);
7016
7017 /*
7018 * Set link_speed_active here, overriding what was set in
7019 * handle_verify_cap(). The ASIC 8051 firmware does not correctly
7020 * set the max_rate field in handle_verify_cap until v0.19.
7021 */
7022 if ((dd->icode == ICODE_RTL_SILICON)
7023 && (dd->dc8051_ver < dc8051_ver(0, 19))) {
7024 /* max_rate: 0 = 12.5G, 1 = 25G */
7025 switch (max_rate) {
7026 case 0:
7027 dd->pport[0].link_speed_active = OPA_LINK_SPEED_12_5G;
7028 break;
7029 default:
7030 dd_dev_err(dd,
7031 "%s: unexpected max rate %d, using 25Gb\n",
7032 __func__, (int)max_rate);
7033 /* fall through */
7034 case 1:
7035 dd->pport[0].link_speed_active = OPA_LINK_SPEED_25G;
7036 break;
7037 }
7038 }
7039
7040 dd_dev_info(dd,
7041 "Fabric active lanes (width): tx 0x%x (%d), rx 0x%x (%d)\n",
7042 enable_lane_tx, tx, enable_lane_rx, rx);
7043 *tx_width = link_width_to_bits(dd, tx);
7044 *rx_width = link_width_to_bits(dd, rx);
7045}
7046
7047/*
7048 * Read verify_cap_local_fm_link_width[1] to obtain the link widths.
7049 * Valid after the end of VerifyCap and during LinkUp. Does not change
7050 * after link up. I.e. look elsewhere for downgrade information.
7051 *
7052 * Bits are:
7053 * + bits [7:4] contain the number of active transmitters
7054 * + bits [3:0] contain the number of active receivers
7055 * These are numbers 1 through 4 and can be different values if the
7056 * link is asymmetric.
7057 *
7058 * verify_cap_local_fm_link_width[0] retains its original value.
7059 */
7060static void get_linkup_widths(struct hfi1_devdata *dd, u16 *tx_width,
7061 u16 *rx_width)
7062{
7063 u16 widths, tx, rx;
7064 u8 misc_bits, local_flags;
7065 u16 active_tx, active_rx;
7066
7067 read_vc_local_link_width(dd, &misc_bits, &local_flags, &widths);
7068 tx = widths >> 12;
7069 rx = (widths >> 8) & 0xf;
7070
7071 *tx_width = link_width_to_bits(dd, tx);
7072 *rx_width = link_width_to_bits(dd, rx);
7073
7074 /* print the active widths */
7075 get_link_widths(dd, &active_tx, &active_rx);
7076}
7077
7078/*
7079 * Set ppd->link_width_active and ppd->link_width_downgrade_active using
7080 * hardware information when the link first comes up.
7081 *
7082 * The link width is not available until after VerifyCap.AllFramesReceived
7083 * (the trigger for handle_verify_cap), so this is outside that routine
7084 * and should be called when the 8051 signals linkup.
7085 */
7086void get_linkup_link_widths(struct hfi1_pportdata *ppd)
7087{
7088 u16 tx_width, rx_width;
7089
7090 /* get end-of-LNI link widths */
7091 get_linkup_widths(ppd->dd, &tx_width, &rx_width);
7092
7093 /* use tx_width as the link is supposed to be symmetric on link up */
7094 ppd->link_width_active = tx_width;
7095 /* link width downgrade active (LWD.A) starts out matching LW.A */
7096 ppd->link_width_downgrade_tx_active = ppd->link_width_active;
7097 ppd->link_width_downgrade_rx_active = ppd->link_width_active;
7098 /* per OPA spec, on link up LWD.E resets to LWD.S */
7099 ppd->link_width_downgrade_enabled = ppd->link_width_downgrade_supported;
7100 /* cache the active egress rate (units {10^6 bits/sec]) */
7101 ppd->current_egress_rate = active_egress_rate(ppd);
7102}
7103
7104/*
7105 * Handle a verify capabilities interrupt from the 8051.
7106 *
7107 * This is a work-queue function outside of the interrupt.
7108 */
7109void handle_verify_cap(struct work_struct *work)
7110{
7111 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
7112 link_vc_work);
7113 struct hfi1_devdata *dd = ppd->dd;
7114 u64 reg;
7115 u8 power_management;
7116 u8 continious;
7117 u8 vcu;
7118 u8 vau;
7119 u8 z;
7120 u16 vl15buf;
7121 u16 link_widths;
7122 u16 crc_mask;
7123 u16 crc_val;
7124 u16 device_id;
7125 u16 active_tx, active_rx;
7126 u8 partner_supported_crc;
7127 u8 remote_tx_rate;
7128 u8 device_rev;
7129
7130 set_link_state(ppd, HLS_VERIFY_CAP);
7131
7132 lcb_shutdown(dd, 0);
7133 adjust_lcb_for_fpga_serdes(dd);
7134
7135 /*
7136 * These are now valid:
7137 * remote VerifyCap fields in the general LNI config
7138 * CSR DC8051_STS_REMOTE_GUID
7139 * CSR DC8051_STS_REMOTE_NODE_TYPE
7140 * CSR DC8051_STS_REMOTE_FM_SECURITY
7141 * CSR DC8051_STS_REMOTE_PORT_NO
7142 */
7143
7144 read_vc_remote_phy(dd, &power_management, &continious);
7145 read_vc_remote_fabric(
7146 dd,
7147 &vau,
7148 &z,
7149 &vcu,
7150 &vl15buf,
7151 &partner_supported_crc);
7152 read_vc_remote_link_width(dd, &remote_tx_rate, &link_widths);
7153 read_remote_device_id(dd, &device_id, &device_rev);
7154 /*
7155 * And the 'MgmtAllowed' information, which is exchanged during
7156 * LNI, is also be available at this point.
7157 */
7158 read_mgmt_allowed(dd, &ppd->mgmt_allowed);
7159 /* print the active widths */
7160 get_link_widths(dd, &active_tx, &active_rx);
7161 dd_dev_info(dd,
7162 "Peer PHY: power management 0x%x, continuous updates 0x%x\n",
7163 (int)power_management, (int)continious);
7164 dd_dev_info(dd,
7165 "Peer Fabric: vAU %d, Z %d, vCU %d, vl15 credits 0x%x, CRC sizes 0x%x\n",
7166 (int)vau,
7167 (int)z,
7168 (int)vcu,
7169 (int)vl15buf,
7170 (int)partner_supported_crc);
7171 dd_dev_info(dd, "Peer Link Width: tx rate 0x%x, widths 0x%x\n",
7172 (u32)remote_tx_rate, (u32)link_widths);
7173 dd_dev_info(dd, "Peer Device ID: 0x%04x, Revision 0x%02x\n",
7174 (u32)device_id, (u32)device_rev);
7175 /*
7176 * The peer vAU value just read is the peer receiver value. HFI does
7177 * not support a transmit vAU of 0 (AU == 8). We advertised that
7178 * with Z=1 in the fabric capabilities sent to the peer. The peer
7179 * will see our Z=1, and, if it advertised a vAU of 0, will move its
7180 * receive to vAU of 1 (AU == 16). Do the same here. We do not care
7181 * about the peer Z value - our sent vAU is 3 (hardwired) and is not
7182 * subject to the Z value exception.
7183 */
7184 if (vau == 0)
7185 vau = 1;
7186 set_up_vl15(dd, vau, vl15buf);
7187
7188 /* set up the LCB CRC mode */
7189 crc_mask = ppd->port_crc_mode_enabled & partner_supported_crc;
7190
7191 /* order is important: use the lowest bit in common */
7192 if (crc_mask & CAP_CRC_14B)
7193 crc_val = LCB_CRC_14B;
7194 else if (crc_mask & CAP_CRC_48B)
7195 crc_val = LCB_CRC_48B;
7196 else if (crc_mask & CAP_CRC_12B_16B_PER_LANE)
7197 crc_val = LCB_CRC_12B_16B_PER_LANE;
7198 else
7199 crc_val = LCB_CRC_16B;
7200
7201 dd_dev_info(dd, "Final LCB CRC mode: %d\n", (int)crc_val);
7202 write_csr(dd, DC_LCB_CFG_CRC_MODE,
7203 (u64)crc_val << DC_LCB_CFG_CRC_MODE_TX_VAL_SHIFT);
7204
7205 /* set (14b only) or clear sideband credit */
7206 reg = read_csr(dd, SEND_CM_CTRL);
7207 if (crc_val == LCB_CRC_14B && crc_14b_sideband) {
7208 write_csr(dd, SEND_CM_CTRL,
7209 reg | SEND_CM_CTRL_FORCE_CREDIT_MODE_SMASK);
7210 } else {
7211 write_csr(dd, SEND_CM_CTRL,
7212 reg & ~SEND_CM_CTRL_FORCE_CREDIT_MODE_SMASK);
7213 }
7214
7215 ppd->link_speed_active = 0; /* invalid value */
7216 if (dd->dc8051_ver < dc8051_ver(0, 20)) {
7217 /* remote_tx_rate: 0 = 12.5G, 1 = 25G */
7218 switch (remote_tx_rate) {
7219 case 0:
7220 ppd->link_speed_active = OPA_LINK_SPEED_12_5G;
7221 break;
7222 case 1:
7223 ppd->link_speed_active = OPA_LINK_SPEED_25G;
7224 break;
7225 }
7226 } else {
7227 /* actual rate is highest bit of the ANDed rates */
7228 u8 rate = remote_tx_rate & ppd->local_tx_rate;
7229
7230 if (rate & 2)
7231 ppd->link_speed_active = OPA_LINK_SPEED_25G;
7232 else if (rate & 1)
7233 ppd->link_speed_active = OPA_LINK_SPEED_12_5G;
7234 }
7235 if (ppd->link_speed_active == 0) {
7236 dd_dev_err(dd, "%s: unexpected remote tx rate %d, using 25Gb\n",
7237 __func__, (int)remote_tx_rate);
7238 ppd->link_speed_active = OPA_LINK_SPEED_25G;
7239 }
7240
7241 /*
7242 * Cache the values of the supported, enabled, and active
7243 * LTP CRC modes to return in 'portinfo' queries. But the bit
7244 * flags that are returned in the portinfo query differ from
7245 * what's in the link_crc_mask, crc_sizes, and crc_val
7246 * variables. Convert these here.
7247 */
7248 ppd->port_ltp_crc_mode = cap_to_port_ltp(link_crc_mask) << 8;
7249 /* supported crc modes */
7250 ppd->port_ltp_crc_mode |=
7251 cap_to_port_ltp(ppd->port_crc_mode_enabled) << 4;
7252 /* enabled crc modes */
7253 ppd->port_ltp_crc_mode |= lcb_to_port_ltp(crc_val);
7254 /* active crc mode */
7255
7256 /* set up the remote credit return table */
7257 assign_remote_cm_au_table(dd, vcu);
7258
7259 /*
7260 * The LCB is reset on entry to handle_verify_cap(), so this must
7261 * be applied on every link up.
7262 *
7263 * Adjust LCB error kill enable to kill the link if
7264 * these RBUF errors are seen:
7265 * REPLAY_BUF_MBE_SMASK
7266 * FLIT_INPUT_BUF_MBE_SMASK
7267 */
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]7268 if (is_ax(dd)) { /* fixed in B0 */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7269 reg = read_csr(dd, DC_LCB_CFG_LINK_KILL_EN);
7270 reg |= DC_LCB_CFG_LINK_KILL_EN_REPLAY_BUF_MBE_SMASK
7271 | DC_LCB_CFG_LINK_KILL_EN_FLIT_INPUT_BUF_MBE_SMASK;
7272 write_csr(dd, DC_LCB_CFG_LINK_KILL_EN, reg);
7273 }
7274
7275 /* pull LCB fifos out of reset - all fifo clocks must be stable */
7276 write_csr(dd, DC_LCB_CFG_TX_FIFOS_RESET, 0);
7277
7278 /* give 8051 access to the LCB CSRs */
7279 write_csr(dd, DC_LCB_ERR_EN, 0); /* mask LCB errors */
7280 set_8051_lcb_access(dd);
7281
7282 ppd->neighbor_guid =
7283 read_csr(dd, DC_DC8051_STS_REMOTE_GUID);
7284 ppd->neighbor_port_number = read_csr(dd, DC_DC8051_STS_REMOTE_PORT_NO) &
7285 DC_DC8051_STS_REMOTE_PORT_NO_VAL_SMASK;
7286 ppd->neighbor_type =
7287 read_csr(dd, DC_DC8051_STS_REMOTE_NODE_TYPE) &
7288 DC_DC8051_STS_REMOTE_NODE_TYPE_VAL_MASK;
7289 ppd->neighbor_fm_security =
7290 read_csr(dd, DC_DC8051_STS_REMOTE_FM_SECURITY) &
7291 DC_DC8051_STS_LOCAL_FM_SECURITY_DISABLED_MASK;
7292 dd_dev_info(dd,
7293 "Neighbor Guid: %llx Neighbor type %d MgmtAllowed %d FM security bypass %d\n",
7294 ppd->neighbor_guid, ppd->neighbor_type,
7295 ppd->mgmt_allowed, ppd->neighbor_fm_security);
7296 if (ppd->mgmt_allowed)
7297 add_full_mgmt_pkey(ppd);
7298
7299 /* tell the 8051 to go to LinkUp */
7300 set_link_state(ppd, HLS_GOING_UP);
7301}
7302
7303/*
7304 * Apply the link width downgrade enabled policy against the current active
7305 * link widths.
7306 *
7307 * Called when the enabled policy changes or the active link widths change.
7308 */
7309void apply_link_downgrade_policy(struct hfi1_pportdata *ppd, int refresh_widths)
7310{
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7311 int do_bounce = 0;
Dean Luick323fd782015-11-16 21:59:24 -0500[diff] [blame]7312 int tries;
7313 u16 lwde;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7314 u16 tx, rx;
7315
Dean Luick323fd782015-11-16 21:59:24 -0500[diff] [blame]7316 /* use the hls lock to avoid a race with actual link up */
7317 tries = 0;
7318retry:
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7319 mutex_lock(&ppd->hls_lock);
7320 /* only apply if the link is up */
Dean Luick323fd782015-11-16 21:59:24 -0500[diff] [blame]7321 if (!(ppd->host_link_state & HLS_UP)) {
7322 /* still going up..wait and retry */
7323 if (ppd->host_link_state & HLS_GOING_UP) {
7324 if (++tries < 1000) {
7325 mutex_unlock(&ppd->hls_lock);
7326 usleep_range(100, 120); /* arbitrary */
7327 goto retry;
7328 }
7329 dd_dev_err(ppd->dd,
7330 "%s: giving up waiting for link state change\n",
7331 __func__);
7332 }
7333 goto done;
7334 }
7335
7336 lwde = ppd->link_width_downgrade_enabled;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7337
7338 if (refresh_widths) {
7339 get_link_widths(ppd->dd, &tx, &rx);
7340 ppd->link_width_downgrade_tx_active = tx;
7341 ppd->link_width_downgrade_rx_active = rx;
7342 }
7343
7344 if (lwde == 0) {
7345 /* downgrade is disabled */
7346
7347 /* bounce if not at starting active width */
7348 if ((ppd->link_width_active !=
7349 ppd->link_width_downgrade_tx_active)
7350 || (ppd->link_width_active !=
7351 ppd->link_width_downgrade_rx_active)) {
7352 dd_dev_err(ppd->dd,
7353 "Link downgrade is disabled and link has downgraded, downing link\n");
7354 dd_dev_err(ppd->dd,
7355 " original 0x%x, tx active 0x%x, rx active 0x%x\n",
7356 ppd->link_width_active,
7357 ppd->link_width_downgrade_tx_active,
7358 ppd->link_width_downgrade_rx_active);
7359 do_bounce = 1;
7360 }
7361 } else if ((lwde & ppd->link_width_downgrade_tx_active) == 0
7362 || (lwde & ppd->link_width_downgrade_rx_active) == 0) {
7363 /* Tx or Rx is outside the enabled policy */
7364 dd_dev_err(ppd->dd,
7365 "Link is outside of downgrade allowed, downing link\n");
7366 dd_dev_err(ppd->dd,
7367 " enabled 0x%x, tx active 0x%x, rx active 0x%x\n",
7368 lwde,
7369 ppd->link_width_downgrade_tx_active,
7370 ppd->link_width_downgrade_rx_active);
7371 do_bounce = 1;
7372 }
7373
Dean Luick323fd782015-11-16 21:59:24 -0500[diff] [blame]7374done:
7375 mutex_unlock(&ppd->hls_lock);
7376
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7377 if (do_bounce) {
7378 set_link_down_reason(ppd, OPA_LINKDOWN_REASON_WIDTH_POLICY, 0,
7379 OPA_LINKDOWN_REASON_WIDTH_POLICY);
7380 set_link_state(ppd, HLS_DN_OFFLINE);
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]7381 tune_serdes(ppd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7382 start_link(ppd);
7383 }
7384}
7385
7386/*
7387 * Handle a link downgrade interrupt from the 8051.
7388 *
7389 * This is a work-queue function outside of the interrupt.
7390 */
7391void handle_link_downgrade(struct work_struct *work)
7392{
7393 struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
7394 link_downgrade_work);
7395
7396 dd_dev_info(ppd->dd, "8051: Link width downgrade\n");
7397 apply_link_downgrade_policy(ppd, 1);
7398}
7399
7400static char *dcc_err_string(char *buf, int buf_len, u64 flags)
7401{
7402 return flag_string(buf, buf_len, flags, dcc_err_flags,
7403 ARRAY_SIZE(dcc_err_flags));
7404}
7405
7406static char *lcb_err_string(char *buf, int buf_len, u64 flags)
7407{
7408 return flag_string(buf, buf_len, flags, lcb_err_flags,
7409 ARRAY_SIZE(lcb_err_flags));
7410}
7411
7412static char *dc8051_err_string(char *buf, int buf_len, u64 flags)
7413{
7414 return flag_string(buf, buf_len, flags, dc8051_err_flags,
7415 ARRAY_SIZE(dc8051_err_flags));
7416}
7417
7418static char *dc8051_info_err_string(char *buf, int buf_len, u64 flags)
7419{
7420 return flag_string(buf, buf_len, flags, dc8051_info_err_flags,
7421 ARRAY_SIZE(dc8051_info_err_flags));
7422}
7423
7424static char *dc8051_info_host_msg_string(char *buf, int buf_len, u64 flags)
7425{
7426 return flag_string(buf, buf_len, flags, dc8051_info_host_msg_flags,
7427 ARRAY_SIZE(dc8051_info_host_msg_flags));
7428}
7429
7430static void handle_8051_interrupt(struct hfi1_devdata *dd, u32 unused, u64 reg)
7431{
7432 struct hfi1_pportdata *ppd = dd->pport;
7433 u64 info, err, host_msg;
7434 int queue_link_down = 0;
7435 char buf[96];
7436
7437 /* look at the flags */
7438 if (reg & DC_DC8051_ERR_FLG_SET_BY_8051_SMASK) {
7439 /* 8051 information set by firmware */
7440 /* read DC8051_DBG_ERR_INFO_SET_BY_8051 for details */
7441 info = read_csr(dd, DC_DC8051_DBG_ERR_INFO_SET_BY_8051);
7442 err = (info >> DC_DC8051_DBG_ERR_INFO_SET_BY_8051_ERROR_SHIFT)
7443 & DC_DC8051_DBG_ERR_INFO_SET_BY_8051_ERROR_MASK;
7444 host_msg = (info >>
7445 DC_DC8051_DBG_ERR_INFO_SET_BY_8051_HOST_MSG_SHIFT)
7446 & DC_DC8051_DBG_ERR_INFO_SET_BY_8051_HOST_MSG_MASK;
7447
7448 /*
7449 * Handle error flags.
7450 */
7451 if (err & FAILED_LNI) {
7452 /*
7453 * LNI error indications are cleared by the 8051
7454 * only when starting polling. Only pay attention
7455 * to them when in the states that occur during
7456 * LNI.
7457 */
7458 if (ppd->host_link_state
7459 & (HLS_DN_POLL | HLS_VERIFY_CAP | HLS_GOING_UP)) {
7460 queue_link_down = 1;
7461 dd_dev_info(dd, "Link error: %s\n",
7462 dc8051_info_err_string(buf,
7463 sizeof(buf),
7464 err & FAILED_LNI));
7465 }
7466 err &= ~(u64)FAILED_LNI;
7467 }
Dean Luick6d014532015-12-01 15:38:23 -0500[diff] [blame]7468 /* unknown frames can happen durning LNI, just count */
7469 if (err & UNKNOWN_FRAME) {
7470 ppd->unknown_frame_count++;
7471 err &= ~(u64)UNKNOWN_FRAME;
7472 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7473 if (err) {
7474 /* report remaining errors, but do not do anything */
7475 dd_dev_err(dd, "8051 info error: %s\n",
7476 dc8051_info_err_string(buf, sizeof(buf), err));
7477 }
7478
7479 /*
7480 * Handle host message flags.
7481 */
7482 if (host_msg & HOST_REQ_DONE) {
7483 /*
7484 * Presently, the driver does a busy wait for
7485 * host requests to complete. This is only an
7486 * informational message.
7487 * NOTE: The 8051 clears the host message
7488 * information *on the next 8051 command*.
7489 * Therefore, when linkup is achieved,
7490 * this flag will still be set.
7491 */
7492 host_msg &= ~(u64)HOST_REQ_DONE;
7493 }
7494 if (host_msg & BC_SMA_MSG) {
7495 queue_work(ppd->hfi1_wq, &ppd->sma_message_work);
7496 host_msg &= ~(u64)BC_SMA_MSG;
7497 }
7498 if (host_msg & LINKUP_ACHIEVED) {
7499 dd_dev_info(dd, "8051: Link up\n");
7500 queue_work(ppd->hfi1_wq, &ppd->link_up_work);
7501 host_msg &= ~(u64)LINKUP_ACHIEVED;
7502 }
7503 if (host_msg & EXT_DEVICE_CFG_REQ) {
Easwar Hariharancbac3862016-02-03 14:31:31 -0800[diff] [blame]7504 queue_work(ppd->hfi1_wq, &ppd->dc_host_req_work);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7505 host_msg &= ~(u64)EXT_DEVICE_CFG_REQ;
7506 }
7507 if (host_msg & VERIFY_CAP_FRAME) {
7508 queue_work(ppd->hfi1_wq, &ppd->link_vc_work);
7509 host_msg &= ~(u64)VERIFY_CAP_FRAME;
7510 }
7511 if (host_msg & LINK_GOING_DOWN) {
7512 const char *extra = "";
7513 /* no downgrade action needed if going down */
7514 if (host_msg & LINK_WIDTH_DOWNGRADED) {
7515 host_msg &= ~(u64)LINK_WIDTH_DOWNGRADED;
7516 extra = " (ignoring downgrade)";
7517 }
7518 dd_dev_info(dd, "8051: Link down%s\n", extra);
7519 queue_link_down = 1;
7520 host_msg &= ~(u64)LINK_GOING_DOWN;
7521 }
7522 if (host_msg & LINK_WIDTH_DOWNGRADED) {
7523 queue_work(ppd->hfi1_wq, &ppd->link_downgrade_work);
7524 host_msg &= ~(u64)LINK_WIDTH_DOWNGRADED;
7525 }
7526 if (host_msg) {
7527 /* report remaining messages, but do not do anything */
7528 dd_dev_info(dd, "8051 info host message: %s\n",
7529 dc8051_info_host_msg_string(buf, sizeof(buf),
7530 host_msg));
7531 }
7532
7533 reg &= ~DC_DC8051_ERR_FLG_SET_BY_8051_SMASK;
7534 }
7535 if (reg & DC_DC8051_ERR_FLG_LOST_8051_HEART_BEAT_SMASK) {
7536 /*
7537 * Lost the 8051 heartbeat. If this happens, we
7538 * receive constant interrupts about it. Disable
7539 * the interrupt after the first.
7540 */
7541 dd_dev_err(dd, "Lost 8051 heartbeat\n");
7542 write_csr(dd, DC_DC8051_ERR_EN,
7543 read_csr(dd, DC_DC8051_ERR_EN)
7544 & ~DC_DC8051_ERR_EN_LOST_8051_HEART_BEAT_SMASK);
7545
7546 reg &= ~DC_DC8051_ERR_FLG_LOST_8051_HEART_BEAT_SMASK;
7547 }
7548 if (reg) {
7549 /* report the error, but do not do anything */
7550 dd_dev_err(dd, "8051 error: %s\n",
7551 dc8051_err_string(buf, sizeof(buf), reg));
7552 }
7553
7554 if (queue_link_down) {
7555 /* if the link is already going down or disabled, do not
7556 * queue another */
7557 if ((ppd->host_link_state
7558 & (HLS_GOING_OFFLINE|HLS_LINK_COOLDOWN))
7559 || ppd->link_enabled == 0) {
7560 dd_dev_info(dd, "%s: not queuing link down\n",
7561 __func__);
7562 } else {
7563 queue_work(ppd->hfi1_wq, &ppd->link_down_work);
7564 }
7565 }
7566}
7567
7568static const char * const fm_config_txt[] = {
7569[0] =
7570 "BadHeadDist: Distance violation between two head flits",
7571[1] =
7572 "BadTailDist: Distance violation between two tail flits",
7573[2] =
7574 "BadCtrlDist: Distance violation between two credit control flits",
7575[3] =
7576 "BadCrdAck: Credits return for unsupported VL",
7577[4] =
7578 "UnsupportedVLMarker: Received VL Marker",
7579[5] =
7580 "BadPreempt: Exceeded the preemption nesting level",
7581[6] =
7582 "BadControlFlit: Received unsupported control flit",
7583/* no 7 */
7584[8] =
7585 "UnsupportedVLMarker: Received VL Marker for unconfigured or disabled VL",
7586};
7587
7588static const char * const port_rcv_txt[] = {
7589[1] =
7590 "BadPktLen: Illegal PktLen",
7591[2] =
7592 "PktLenTooLong: Packet longer than PktLen",
7593[3] =
7594 "PktLenTooShort: Packet shorter than PktLen",
7595[4] =
7596 "BadSLID: Illegal SLID (0, using multicast as SLID, does not include security validation of SLID)",
7597[5] =
7598 "BadDLID: Illegal DLID (0, doesn't match HFI)",
7599[6] =
7600 "BadL2: Illegal L2 opcode",
7601[7] =
7602 "BadSC: Unsupported SC",
7603[9] =
7604 "BadRC: Illegal RC",
7605[11] =
7606 "PreemptError: Preempting with same VL",
7607[12] =
7608 "PreemptVL15: Preempting a VL15 packet",
7609};
7610
7611#define OPA_LDR_FMCONFIG_OFFSET 16
7612#define OPA_LDR_PORTRCV_OFFSET 0
7613static void handle_dcc_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
7614{
7615 u64 info, hdr0, hdr1;
7616 const char *extra;
7617 char buf[96];
7618 struct hfi1_pportdata *ppd = dd->pport;
7619 u8 lcl_reason = 0;
7620 int do_bounce = 0;
7621
7622 if (reg & DCC_ERR_FLG_UNCORRECTABLE_ERR_SMASK) {
7623 if (!(dd->err_info_uncorrectable & OPA_EI_STATUS_SMASK)) {
7624 info = read_csr(dd, DCC_ERR_INFO_UNCORRECTABLE);
7625 dd->err_info_uncorrectable = info & OPA_EI_CODE_SMASK;
7626 /* set status bit */
7627 dd->err_info_uncorrectable |= OPA_EI_STATUS_SMASK;
7628 }
7629 reg &= ~DCC_ERR_FLG_UNCORRECTABLE_ERR_SMASK;
7630 }
7631
7632 if (reg & DCC_ERR_FLG_LINK_ERR_SMASK) {
7633 struct hfi1_pportdata *ppd = dd->pport;
7634 /* this counter saturates at (2^32) - 1 */
7635 if (ppd->link_downed < (u32)UINT_MAX)
7636 ppd->link_downed++;
7637 reg &= ~DCC_ERR_FLG_LINK_ERR_SMASK;
7638 }
7639
7640 if (reg & DCC_ERR_FLG_FMCONFIG_ERR_SMASK) {
7641 u8 reason_valid = 1;
7642
7643 info = read_csr(dd, DCC_ERR_INFO_FMCONFIG);
7644 if (!(dd->err_info_fmconfig & OPA_EI_STATUS_SMASK)) {
7645 dd->err_info_fmconfig = info & OPA_EI_CODE_SMASK;
7646 /* set status bit */
7647 dd->err_info_fmconfig |= OPA_EI_STATUS_SMASK;
7648 }
7649 switch (info) {
7650 case 0:
7651 case 1:
7652 case 2:
7653 case 3:
7654 case 4:
7655 case 5:
7656 case 6:
7657 extra = fm_config_txt[info];
7658 break;
7659 case 8:
7660 extra = fm_config_txt[info];
7661 if (ppd->port_error_action &
7662 OPA_PI_MASK_FM_CFG_UNSUPPORTED_VL_MARKER) {
7663 do_bounce = 1;
7664 /*
7665 * lcl_reason cannot be derived from info
7666 * for this error
7667 */
7668 lcl_reason =
7669 OPA_LINKDOWN_REASON_UNSUPPORTED_VL_MARKER;
7670 }
7671 break;
7672 default:
7673 reason_valid = 0;
7674 snprintf(buf, sizeof(buf), "reserved%lld", info);
7675 extra = buf;
7676 break;
7677 }
7678
7679 if (reason_valid && !do_bounce) {
7680 do_bounce = ppd->port_error_action &
7681 (1 << (OPA_LDR_FMCONFIG_OFFSET + info));
7682 lcl_reason = info + OPA_LINKDOWN_REASON_BAD_HEAD_DIST;
7683 }
7684
7685 /* just report this */
7686 dd_dev_info(dd, "DCC Error: fmconfig error: %s\n", extra);
7687 reg &= ~DCC_ERR_FLG_FMCONFIG_ERR_SMASK;
7688 }
7689
7690 if (reg & DCC_ERR_FLG_RCVPORT_ERR_SMASK) {
7691 u8 reason_valid = 1;
7692
7693 info = read_csr(dd, DCC_ERR_INFO_PORTRCV);
7694 hdr0 = read_csr(dd, DCC_ERR_INFO_PORTRCV_HDR0);
7695 hdr1 = read_csr(dd, DCC_ERR_INFO_PORTRCV_HDR1);
7696 if (!(dd->err_info_rcvport.status_and_code &
7697 OPA_EI_STATUS_SMASK)) {
7698 dd->err_info_rcvport.status_and_code =
7699 info & OPA_EI_CODE_SMASK;
7700 /* set status bit */
7701 dd->err_info_rcvport.status_and_code |=
7702 OPA_EI_STATUS_SMASK;
7703 /* save first 2 flits in the packet that caused
7704 * the error */
7705 dd->err_info_rcvport.packet_flit1 = hdr0;
7706 dd->err_info_rcvport.packet_flit2 = hdr1;
7707 }
7708 switch (info) {
7709 case 1:
7710 case 2:
7711 case 3:
7712 case 4:
7713 case 5:
7714 case 6:
7715 case 7:
7716 case 9:
7717 case 11:
7718 case 12:
7719 extra = port_rcv_txt[info];
7720 break;
7721 default:
7722 reason_valid = 0;
7723 snprintf(buf, sizeof(buf), "reserved%lld", info);
7724 extra = buf;
7725 break;
7726 }
7727
7728 if (reason_valid && !do_bounce) {
7729 do_bounce = ppd->port_error_action &
7730 (1 << (OPA_LDR_PORTRCV_OFFSET + info));
7731 lcl_reason = info + OPA_LINKDOWN_REASON_RCV_ERROR_0;
7732 }
7733
7734 /* just report this */
7735 dd_dev_info(dd, "DCC Error: PortRcv error: %s\n", extra);
7736 dd_dev_info(dd, " hdr0 0x%llx, hdr1 0x%llx\n",
7737 hdr0, hdr1);
7738
7739 reg &= ~DCC_ERR_FLG_RCVPORT_ERR_SMASK;
7740 }
7741
7742 if (reg & DCC_ERR_FLG_EN_CSR_ACCESS_BLOCKED_UC_SMASK) {
7743 /* informative only */
7744 dd_dev_info(dd, "8051 access to LCB blocked\n");
7745 reg &= ~DCC_ERR_FLG_EN_CSR_ACCESS_BLOCKED_UC_SMASK;
7746 }
7747 if (reg & DCC_ERR_FLG_EN_CSR_ACCESS_BLOCKED_HOST_SMASK) {
7748 /* informative only */
7749 dd_dev_info(dd, "host access to LCB blocked\n");
7750 reg &= ~DCC_ERR_FLG_EN_CSR_ACCESS_BLOCKED_HOST_SMASK;
7751 }
7752
7753 /* report any remaining errors */
7754 if (reg)
7755 dd_dev_info(dd, "DCC Error: %s\n",
7756 dcc_err_string(buf, sizeof(buf), reg));
7757
7758 if (lcl_reason == 0)
7759 lcl_reason = OPA_LINKDOWN_REASON_UNKNOWN;
7760
7761 if (do_bounce) {
7762 dd_dev_info(dd, "%s: PortErrorAction bounce\n", __func__);
7763 set_link_down_reason(ppd, lcl_reason, 0, lcl_reason);
7764 queue_work(ppd->hfi1_wq, &ppd->link_bounce_work);
7765 }
7766}
7767
7768static void handle_lcb_err(struct hfi1_devdata *dd, u32 unused, u64 reg)
7769{
7770 char buf[96];
7771
7772 dd_dev_info(dd, "LCB Error: %s\n",
7773 lcb_err_string(buf, sizeof(buf), reg));
7774}
7775
7776/*
7777 * CCE block DC interrupt. Source is < 8.
7778 */
7779static void is_dc_int(struct hfi1_devdata *dd, unsigned int source)
7780{
7781 const struct err_reg_info *eri = &dc_errs[source];
7782
7783 if (eri->handler) {
7784 interrupt_clear_down(dd, 0, eri);
7785 } else if (source == 3 /* dc_lbm_int */) {
7786 /*
7787 * This indicates that a parity error has occurred on the
7788 * address/control lines presented to the LBM. The error
7789 * is a single pulse, there is no associated error flag,
7790 * and it is non-maskable. This is because if a parity
7791 * error occurs on the request the request is dropped.
7792 * This should never occur, but it is nice to know if it
7793 * ever does.
7794 */
7795 dd_dev_err(dd, "Parity error in DC LBM block\n");
7796 } else {
7797 dd_dev_err(dd, "Invalid DC interrupt %u\n", source);
7798 }
7799}
7800
7801/*
7802 * TX block send credit interrupt. Source is < 160.
7803 */
7804static void is_send_credit_int(struct hfi1_devdata *dd, unsigned int source)
7805{
7806 sc_group_release_update(dd, source);
7807}
7808
7809/*
7810 * TX block SDMA interrupt. Source is < 48.
7811 *
7812 * SDMA interrupts are grouped by type:
7813 *
7814 * 0 - N-1 = SDma
7815 * N - 2N-1 = SDmaProgress
7816 * 2N - 3N-1 = SDmaIdle
7817 */
7818static void is_sdma_eng_int(struct hfi1_devdata *dd, unsigned int source)
7819{
7820 /* what interrupt */
7821 unsigned int what = source / TXE_NUM_SDMA_ENGINES;
7822 /* which engine */
7823 unsigned int which = source % TXE_NUM_SDMA_ENGINES;
7824
7825#ifdef CONFIG_SDMA_VERBOSITY
7826 dd_dev_err(dd, "CONFIG SDMA(%u) %s:%d %s()\n", which,
7827 slashstrip(__FILE__), __LINE__, __func__);
7828 sdma_dumpstate(&dd->per_sdma[which]);
7829#endif
7830
7831 if (likely(what < 3 && which < dd->num_sdma)) {
7832 sdma_engine_interrupt(&dd->per_sdma[which], 1ull << source);
7833 } else {
7834 /* should not happen */
7835 dd_dev_err(dd, "Invalid SDMA interrupt 0x%x\n", source);
7836 }
7837}
7838
7839/*
7840 * RX block receive available interrupt. Source is < 160.
7841 */
7842static void is_rcv_avail_int(struct hfi1_devdata *dd, unsigned int source)
7843{
7844 struct hfi1_ctxtdata *rcd;
7845 char *err_detail;
7846
7847 if (likely(source < dd->num_rcv_contexts)) {
7848 rcd = dd->rcd[source];
7849 if (rcd) {
7850 if (source < dd->first_user_ctxt)
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]7851 rcd->do_interrupt(rcd, 0);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]7852 else
7853 handle_user_interrupt(rcd);
7854 return; /* OK */
7855 }
7856 /* received an interrupt, but no rcd */
7857 err_detail = "dataless";
7858 } else {
7859 /* received an interrupt, but are not using that context */
7860 err_detail = "out of range";
7861 }
7862 dd_dev_err(dd, "unexpected %s receive available context interrupt %u\n",
7863 err_detail, source);
7864}
7865
7866/*
7867 * RX block receive urgent interrupt. Source is < 160.
7868 */
7869static void is_rcv_urgent_int(struct hfi1_devdata *dd, unsigned int source)
7870{
7871 struct hfi1_ctxtdata *rcd;
7872 char *err_detail;
7873
7874 if (likely(source < dd->num_rcv_contexts)) {
7875 rcd = dd->rcd[source];
7876 if (rcd) {
7877 /* only pay attention to user urgent interrupts */
7878 if (source >= dd->first_user_ctxt)
7879 handle_user_interrupt(rcd);
7880 return; /* OK */
7881 }
7882 /* received an interrupt, but no rcd */
7883 err_detail = "dataless";
7884 } else {
7885 /* received an interrupt, but are not using that context */
7886 err_detail = "out of range";
7887 }
7888 dd_dev_err(dd, "unexpected %s receive urgent context interrupt %u\n",
7889 err_detail, source);
7890}
7891
7892/*
7893 * Reserved range interrupt. Should not be called in normal operation.
7894 */
7895static void is_reserved_int(struct hfi1_devdata *dd, unsigned int source)
7896{
7897 char name[64];
7898
7899 dd_dev_err(dd, "unexpected %s interrupt\n",
7900 is_reserved_name(name, sizeof(name), source));
7901}
7902
7903static const struct is_table is_table[] = {
7904/* start end
7905 name func interrupt func */
7906{ IS_GENERAL_ERR_START, IS_GENERAL_ERR_END,
7907 is_misc_err_name, is_misc_err_int },
7908{ IS_SDMAENG_ERR_START, IS_SDMAENG_ERR_END,
7909 is_sdma_eng_err_name, is_sdma_eng_err_int },
7910{ IS_SENDCTXT_ERR_START, IS_SENDCTXT_ERR_END,
7911 is_sendctxt_err_name, is_sendctxt_err_int },
7912{ IS_SDMA_START, IS_SDMA_END,
7913 is_sdma_eng_name, is_sdma_eng_int },
7914{ IS_VARIOUS_START, IS_VARIOUS_END,
7915 is_various_name, is_various_int },
7916{ IS_DC_START, IS_DC_END,
7917 is_dc_name, is_dc_int },
7918{ IS_RCVAVAIL_START, IS_RCVAVAIL_END,
7919 is_rcv_avail_name, is_rcv_avail_int },
7920{ IS_RCVURGENT_START, IS_RCVURGENT_END,
7921 is_rcv_urgent_name, is_rcv_urgent_int },
7922{ IS_SENDCREDIT_START, IS_SENDCREDIT_END,
7923 is_send_credit_name, is_send_credit_int},
7924{ IS_RESERVED_START, IS_RESERVED_END,
7925 is_reserved_name, is_reserved_int},
7926};
7927
7928/*
7929 * Interrupt source interrupt - called when the given source has an interrupt.
7930 * Source is a bit index into an array of 64-bit integers.
7931 */
7932static void is_interrupt(struct hfi1_devdata *dd, unsigned int source)
7933{
7934 const struct is_table *entry;
7935
7936 /* avoids a double compare by walking the table in-order */
7937 for (entry = &is_table[0]; entry->is_name; entry++) {
7938 if (source < entry->end) {
7939 trace_hfi1_interrupt(dd, entry, source);
7940 entry->is_int(dd, source - entry->start);
7941 return;
7942 }
7943 }
7944 /* fell off the end */
7945 dd_dev_err(dd, "invalid interrupt source %u\n", source);
7946}
7947
7948/*
7949 * General interrupt handler. This is able to correctly handle
7950 * all interrupts in case INTx is used.
7951 */
7952static irqreturn_t general_interrupt(int irq, void *data)
7953{
7954 struct hfi1_devdata *dd = data;
7955 u64 regs[CCE_NUM_INT_CSRS];
7956 u32 bit;
7957 int i;
7958
7959 this_cpu_inc(*dd->int_counter);
7960
7961 /* phase 1: scan and clear all handled interrupts */
7962 for (i = 0; i < CCE_NUM_INT_CSRS; i++) {
7963 if (dd->gi_mask[i] == 0) {
7964 regs[i] = 0; /* used later */
7965 continue;
7966 }
7967 regs[i] = read_csr(dd, CCE_INT_STATUS + (8 * i)) &
7968 dd->gi_mask[i];
7969 /* only clear if anything is set */
7970 if (regs[i])
7971 write_csr(dd, CCE_INT_CLEAR + (8 * i), regs[i]);
7972 }
7973
7974 /* phase 2: call the appropriate handler */
7975 for_each_set_bit(bit, (unsigned long *)&regs[0],
7976 CCE_NUM_INT_CSRS*64) {
7977 is_interrupt(dd, bit);
7978 }
7979
7980 return IRQ_HANDLED;
7981}
7982
7983static irqreturn_t sdma_interrupt(int irq, void *data)
7984{
7985 struct sdma_engine *sde = data;
7986 struct hfi1_devdata *dd = sde->dd;
7987 u64 status;
7988
7989#ifdef CONFIG_SDMA_VERBOSITY
7990 dd_dev_err(dd, "CONFIG SDMA(%u) %s:%d %s()\n", sde->this_idx,
7991 slashstrip(__FILE__), __LINE__, __func__);
7992 sdma_dumpstate(sde);
7993#endif
7994
7995 this_cpu_inc(*dd->int_counter);
7996
7997 /* This read_csr is really bad in the hot path */
7998 status = read_csr(dd,
7999 CCE_INT_STATUS + (8*(IS_SDMA_START/64)))
8000 & sde->imask;
8001 if (likely(status)) {
8002 /* clear the interrupt(s) */
8003 write_csr(dd,
8004 CCE_INT_CLEAR + (8*(IS_SDMA_START/64)),
8005 status);
8006
8007 /* handle the interrupt(s) */
8008 sdma_engine_interrupt(sde, status);
8009 } else
8010 dd_dev_err(dd, "SDMA engine %u interrupt, but no status bits set\n",
8011 sde->this_idx);
8012
8013 return IRQ_HANDLED;
8014}
8015
8016/*
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]8017 * Clear the receive interrupt, forcing the write and making sure
8018 * we have data from the chip, pushing everything in front of it
8019 * back to the host.
8020 */
8021static inline void clear_recv_intr(struct hfi1_ctxtdata *rcd)
8022{
8023 struct hfi1_devdata *dd = rcd->dd;
8024 u32 addr = CCE_INT_CLEAR + (8 * rcd->ireg);
8025
8026 mmiowb(); /* make sure everything before is written */
8027 write_csr(dd, addr, rcd->imask);
8028 /* force the above write on the chip and get a value back */
8029 (void)read_csr(dd, addr);
8030}
8031
8032/* force the receive interrupt */
Jim Snowfb9036d2016-01-11 18:32:21 -0500[diff] [blame]8033void force_recv_intr(struct hfi1_ctxtdata *rcd)
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]8034{
8035 write_csr(rcd->dd, CCE_INT_FORCE + (8 * rcd->ireg), rcd->imask);
8036}
8037
8038/* return non-zero if a packet is present */
8039static inline int check_packet_present(struct hfi1_ctxtdata *rcd)
8040{
8041 if (!HFI1_CAP_IS_KSET(DMA_RTAIL))
8042 return (rcd->seq_cnt ==
8043 rhf_rcv_seq(rhf_to_cpu(get_rhf_addr(rcd))));
8044
8045 /* else is RDMA rtail */
8046 return (rcd->head != get_rcvhdrtail(rcd));
8047}
8048
8049/*
8050 * Receive packet IRQ handler. This routine expects to be on its own IRQ.
8051 * This routine will try to handle packets immediately (latency), but if
8052 * it finds too many, it will invoke the thread handler (bandwitdh). The
8053 * chip receive interupt is *not* cleared down until this or the thread (if
8054 * invoked) is finished. The intent is to avoid extra interrupts while we
8055 * are processing packets anyway.
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8056 */
8057static irqreturn_t receive_context_interrupt(int irq, void *data)
8058{
8059 struct hfi1_ctxtdata *rcd = data;
8060 struct hfi1_devdata *dd = rcd->dd;
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]8061 int disposition;
8062 int present;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8063
8064 trace_hfi1_receive_interrupt(dd, rcd->ctxt);
8065 this_cpu_inc(*dd->int_counter);
8066
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]8067 /* receive interrupt remains blocked while processing packets */
8068 disposition = rcd->do_interrupt(rcd, 0);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8069
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]8070 /*
8071 * Too many packets were seen while processing packets in this
8072 * IRQ handler. Invoke the handler thread. The receive interrupt
8073 * remains blocked.
8074 */
8075 if (disposition == RCV_PKT_LIMIT)
8076 return IRQ_WAKE_THREAD;
8077
8078 /*
8079 * The packet processor detected no more packets. Clear the receive
8080 * interrupt and recheck for a packet packet that may have arrived
8081 * after the previous check and interrupt clear. If a packet arrived,
8082 * force another interrupt.
8083 */
8084 clear_recv_intr(rcd);
8085 present = check_packet_present(rcd);
8086 if (present)
8087 force_recv_intr(rcd);
8088
8089 return IRQ_HANDLED;
8090}
8091
8092/*
8093 * Receive packet thread handler. This expects to be invoked with the
8094 * receive interrupt still blocked.
8095 */
8096static irqreturn_t receive_context_thread(int irq, void *data)
8097{
8098 struct hfi1_ctxtdata *rcd = data;
8099 int present;
8100
8101 /* receive interrupt is still blocked from the IRQ handler */
8102 (void)rcd->do_interrupt(rcd, 1);
8103
8104 /*
8105 * The packet processor will only return if it detected no more
8106 * packets. Hold IRQs here so we can safely clear the interrupt and
8107 * recheck for a packet that may have arrived after the previous
8108 * check and the interrupt clear. If a packet arrived, force another
8109 * interrupt.
8110 */
8111 local_irq_disable();
8112 clear_recv_intr(rcd);
8113 present = check_packet_present(rcd);
8114 if (present)
8115 force_recv_intr(rcd);
8116 local_irq_enable();
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8117
8118 return IRQ_HANDLED;
8119}
8120
8121/* ========================================================================= */
8122
8123u32 read_physical_state(struct hfi1_devdata *dd)
8124{
8125 u64 reg;
8126
8127 reg = read_csr(dd, DC_DC8051_STS_CUR_STATE);
8128 return (reg >> DC_DC8051_STS_CUR_STATE_PORT_SHIFT)
8129 & DC_DC8051_STS_CUR_STATE_PORT_MASK;
8130}
8131
Jim Snowfb9036d2016-01-11 18:32:21 -0500[diff] [blame]8132u32 read_logical_state(struct hfi1_devdata *dd)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8133{
8134 u64 reg;
8135
8136 reg = read_csr(dd, DCC_CFG_PORT_CONFIG);
8137 return (reg >> DCC_CFG_PORT_CONFIG_LINK_STATE_SHIFT)
8138 & DCC_CFG_PORT_CONFIG_LINK_STATE_MASK;
8139}
8140
8141static void set_logical_state(struct hfi1_devdata *dd, u32 chip_lstate)
8142{
8143 u64 reg;
8144
8145 reg = read_csr(dd, DCC_CFG_PORT_CONFIG);
8146 /* clear current state, set new state */
8147 reg &= ~DCC_CFG_PORT_CONFIG_LINK_STATE_SMASK;
8148 reg |= (u64)chip_lstate << DCC_CFG_PORT_CONFIG_LINK_STATE_SHIFT;
8149 write_csr(dd, DCC_CFG_PORT_CONFIG, reg);
8150}
8151
8152/*
8153 * Use the 8051 to read a LCB CSR.
8154 */
8155static int read_lcb_via_8051(struct hfi1_devdata *dd, u32 addr, u64 *data)
8156{
8157 u32 regno;
8158 int ret;
8159
8160 if (dd->icode == ICODE_FUNCTIONAL_SIMULATOR) {
8161 if (acquire_lcb_access(dd, 0) == 0) {
8162 *data = read_csr(dd, addr);
8163 release_lcb_access(dd, 0);
8164 return 0;
8165 }
8166 return -EBUSY;
8167 }
8168
8169 /* register is an index of LCB registers: (offset - base) / 8 */
8170 regno = (addr - DC_LCB_CFG_RUN) >> 3;
8171 ret = do_8051_command(dd, HCMD_READ_LCB_CSR, regno, data);
8172 if (ret != HCMD_SUCCESS)
8173 return -EBUSY;
8174 return 0;
8175}
8176
8177/*
8178 * Read an LCB CSR. Access may not be in host control, so check.
8179 * Return 0 on success, -EBUSY on failure.
8180 */
8181int read_lcb_csr(struct hfi1_devdata *dd, u32 addr, u64 *data)
8182{
8183 struct hfi1_pportdata *ppd = dd->pport;
8184
8185 /* if up, go through the 8051 for the value */
8186 if (ppd->host_link_state & HLS_UP)
8187 return read_lcb_via_8051(dd, addr, data);
8188 /* if going up or down, no access */
8189 if (ppd->host_link_state & (HLS_GOING_UP | HLS_GOING_OFFLINE))
8190 return -EBUSY;
8191 /* otherwise, host has access */
8192 *data = read_csr(dd, addr);
8193 return 0;
8194}
8195
8196/*
8197 * Use the 8051 to write a LCB CSR.
8198 */
8199static int write_lcb_via_8051(struct hfi1_devdata *dd, u32 addr, u64 data)
8200{
Dean Luick3bf40d62015-11-06 20:07:04 -0500[diff] [blame]8201 u32 regno;
8202 int ret;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8203
Dean Luick3bf40d62015-11-06 20:07:04 -0500[diff] [blame]8204 if (dd->icode == ICODE_FUNCTIONAL_SIMULATOR ||
8205 (dd->dc8051_ver < dc8051_ver(0, 20))) {
8206 if (acquire_lcb_access(dd, 0) == 0) {
8207 write_csr(dd, addr, data);
8208 release_lcb_access(dd, 0);
8209 return 0;
8210 }
8211 return -EBUSY;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8212 }
Dean Luick3bf40d62015-11-06 20:07:04 -0500[diff] [blame]8213
8214 /* register is an index of LCB registers: (offset - base) / 8 */
8215 regno = (addr - DC_LCB_CFG_RUN) >> 3;
8216 ret = do_8051_command(dd, HCMD_WRITE_LCB_CSR, regno, &data);
8217 if (ret != HCMD_SUCCESS)
8218 return -EBUSY;
8219 return 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8220}
8221
8222/*
8223 * Write an LCB CSR. Access may not be in host control, so check.
8224 * Return 0 on success, -EBUSY on failure.
8225 */
8226int write_lcb_csr(struct hfi1_devdata *dd, u32 addr, u64 data)
8227{
8228 struct hfi1_pportdata *ppd = dd->pport;
8229
8230 /* if up, go through the 8051 for the value */
8231 if (ppd->host_link_state & HLS_UP)
8232 return write_lcb_via_8051(dd, addr, data);
8233 /* if going up or down, no access */
8234 if (ppd->host_link_state & (HLS_GOING_UP | HLS_GOING_OFFLINE))
8235 return -EBUSY;
8236 /* otherwise, host has access */
8237 write_csr(dd, addr, data);
8238 return 0;
8239}
8240
8241/*
8242 * Returns:
8243 * < 0 = Linux error, not able to get access
8244 * > 0 = 8051 command RETURN_CODE
8245 */
8246static int do_8051_command(
8247 struct hfi1_devdata *dd,
8248 u32 type,
8249 u64 in_data,
8250 u64 *out_data)
8251{
8252 u64 reg, completed;
8253 int return_code;
8254 unsigned long flags;
8255 unsigned long timeout;
8256
8257 hfi1_cdbg(DC8051, "type %d, data 0x%012llx", type, in_data);
8258
8259 /*
8260 * Alternative to holding the lock for a long time:
8261 * - keep busy wait - have other users bounce off
8262 */
8263 spin_lock_irqsave(&dd->dc8051_lock, flags);
8264
8265 /* We can't send any commands to the 8051 if it's in reset */
8266 if (dd->dc_shutdown) {
8267 return_code = -ENODEV;
8268 goto fail;
8269 }
8270
8271 /*
8272 * If an 8051 host command timed out previously, then the 8051 is
8273 * stuck.
8274 *
8275 * On first timeout, attempt to reset and restart the entire DC
8276 * block (including 8051). (Is this too big of a hammer?)
8277 *
8278 * If the 8051 times out a second time, the reset did not bring it
8279 * back to healthy life. In that case, fail any subsequent commands.
8280 */
8281 if (dd->dc8051_timed_out) {
8282 if (dd->dc8051_timed_out > 1) {
8283 dd_dev_err(dd,
8284 "Previous 8051 host command timed out, skipping command %u\n",
8285 type);
8286 return_code = -ENXIO;
8287 goto fail;
8288 }
8289 spin_unlock_irqrestore(&dd->dc8051_lock, flags);
8290 dc_shutdown(dd);
8291 dc_start(dd);
8292 spin_lock_irqsave(&dd->dc8051_lock, flags);
8293 }
8294
8295 /*
8296 * If there is no timeout, then the 8051 command interface is
8297 * waiting for a command.
8298 */
8299
8300 /*
Dean Luick3bf40d62015-11-06 20:07:04 -0500[diff] [blame]8301 * When writing a LCB CSR, out_data contains the full value to
8302 * to be written, while in_data contains the relative LCB
8303 * address in 7:0. Do the work here, rather than the caller,
8304 * of distrubting the write data to where it needs to go:
8305 *
8306 * Write data
8307 * 39:00 -> in_data[47:8]
8308 * 47:40 -> DC8051_CFG_EXT_DEV_0.RETURN_CODE
8309 * 63:48 -> DC8051_CFG_EXT_DEV_0.RSP_DATA
8310 */
8311 if (type == HCMD_WRITE_LCB_CSR) {
8312 in_data |= ((*out_data) & 0xffffffffffull) << 8;
8313 reg = ((((*out_data) >> 40) & 0xff) <<
8314 DC_DC8051_CFG_EXT_DEV_0_RETURN_CODE_SHIFT)
8315 | ((((*out_data) >> 48) & 0xffff) <<
8316 DC_DC8051_CFG_EXT_DEV_0_RSP_DATA_SHIFT);
8317 write_csr(dd, DC_DC8051_CFG_EXT_DEV_0, reg);
8318 }
8319
8320 /*
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8321 * Do two writes: the first to stabilize the type and req_data, the
8322 * second to activate.
8323 */
8324 reg = ((u64)type & DC_DC8051_CFG_HOST_CMD_0_REQ_TYPE_MASK)
8325 << DC_DC8051_CFG_HOST_CMD_0_REQ_TYPE_SHIFT
8326 | (in_data & DC_DC8051_CFG_HOST_CMD_0_REQ_DATA_MASK)
8327 << DC_DC8051_CFG_HOST_CMD_0_REQ_DATA_SHIFT;
8328 write_csr(dd, DC_DC8051_CFG_HOST_CMD_0, reg);
8329 reg |= DC_DC8051_CFG_HOST_CMD_0_REQ_NEW_SMASK;
8330 write_csr(dd, DC_DC8051_CFG_HOST_CMD_0, reg);
8331
8332 /* wait for completion, alternate: interrupt */
8333 timeout = jiffies + msecs_to_jiffies(DC8051_COMMAND_TIMEOUT);
8334 while (1) {
8335 reg = read_csr(dd, DC_DC8051_CFG_HOST_CMD_1);
8336 completed = reg & DC_DC8051_CFG_HOST_CMD_1_COMPLETED_SMASK;
8337 if (completed)
8338 break;
8339 if (time_after(jiffies, timeout)) {
8340 dd->dc8051_timed_out++;
8341 dd_dev_err(dd, "8051 host command %u timeout\n", type);
8342 if (out_data)
8343 *out_data = 0;
8344 return_code = -ETIMEDOUT;
8345 goto fail;
8346 }
8347 udelay(2);
8348 }
8349
8350 if (out_data) {
8351 *out_data = (reg >> DC_DC8051_CFG_HOST_CMD_1_RSP_DATA_SHIFT)
8352 & DC_DC8051_CFG_HOST_CMD_1_RSP_DATA_MASK;
8353 if (type == HCMD_READ_LCB_CSR) {
8354 /* top 16 bits are in a different register */
8355 *out_data |= (read_csr(dd, DC_DC8051_CFG_EXT_DEV_1)
8356 & DC_DC8051_CFG_EXT_DEV_1_REQ_DATA_SMASK)
8357 << (48
8358 - DC_DC8051_CFG_EXT_DEV_1_REQ_DATA_SHIFT);
8359 }
8360 }
8361 return_code = (reg >> DC_DC8051_CFG_HOST_CMD_1_RETURN_CODE_SHIFT)
8362 & DC_DC8051_CFG_HOST_CMD_1_RETURN_CODE_MASK;
8363 dd->dc8051_timed_out = 0;
8364 /*
8365 * Clear command for next user.
8366 */
8367 write_csr(dd, DC_DC8051_CFG_HOST_CMD_0, 0);
8368
8369fail:
8370 spin_unlock_irqrestore(&dd->dc8051_lock, flags);
8371
8372 return return_code;
8373}
8374
8375static int set_physical_link_state(struct hfi1_devdata *dd, u64 state)
8376{
8377 return do_8051_command(dd, HCMD_CHANGE_PHY_STATE, state, NULL);
8378}
8379
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]8380int load_8051_config(struct hfi1_devdata *dd, u8 field_id,
8381 u8 lane_id, u32 config_data)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8382{
8383 u64 data;
8384 int ret;
8385
8386 data = (u64)field_id << LOAD_DATA_FIELD_ID_SHIFT
8387 | (u64)lane_id << LOAD_DATA_LANE_ID_SHIFT
8388 | (u64)config_data << LOAD_DATA_DATA_SHIFT;
8389 ret = do_8051_command(dd, HCMD_LOAD_CONFIG_DATA, data, NULL);
8390 if (ret != HCMD_SUCCESS) {
8391 dd_dev_err(dd,
8392 "load 8051 config: field id %d, lane %d, err %d\n",
8393 (int)field_id, (int)lane_id, ret);
8394 }
8395 return ret;
8396}
8397
8398/*
8399 * Read the 8051 firmware "registers". Use the RAM directly. Always
8400 * set the result, even on error.
8401 * Return 0 on success, -errno on failure
8402 */
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]8403int read_8051_config(struct hfi1_devdata *dd, u8 field_id, u8 lane_id,
8404 u32 *result)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8405{
8406 u64 big_data;
8407 u32 addr;
8408 int ret;
8409
8410 /* address start depends on the lane_id */
8411 if (lane_id < 4)
8412 addr = (4 * NUM_GENERAL_FIELDS)
8413 + (lane_id * 4 * NUM_LANE_FIELDS);
8414 else
8415 addr = 0;
8416 addr += field_id * 4;
8417
8418 /* read is in 8-byte chunks, hardware will truncate the address down */
8419 ret = read_8051_data(dd, addr, 8, &big_data);
8420
8421 if (ret == 0) {
8422 /* extract the 4 bytes we want */
8423 if (addr & 0x4)
8424 *result = (u32)(big_data >> 32);
8425 else
8426 *result = (u32)big_data;
8427 } else {
8428 *result = 0;
8429 dd_dev_err(dd, "%s: direct read failed, lane %d, field %d!\n",
8430 __func__, lane_id, field_id);
8431 }
8432
8433 return ret;
8434}
8435
8436static int write_vc_local_phy(struct hfi1_devdata *dd, u8 power_management,
8437 u8 continuous)
8438{
8439 u32 frame;
8440
8441 frame = continuous << CONTINIOUS_REMOTE_UPDATE_SUPPORT_SHIFT
8442 | power_management << POWER_MANAGEMENT_SHIFT;
8443 return load_8051_config(dd, VERIFY_CAP_LOCAL_PHY,
8444 GENERAL_CONFIG, frame);
8445}
8446
8447static int write_vc_local_fabric(struct hfi1_devdata *dd, u8 vau, u8 z, u8 vcu,
8448 u16 vl15buf, u8 crc_sizes)
8449{
8450 u32 frame;
8451
8452 frame = (u32)vau << VAU_SHIFT
8453 | (u32)z << Z_SHIFT
8454 | (u32)vcu << VCU_SHIFT
8455 | (u32)vl15buf << VL15BUF_SHIFT
8456 | (u32)crc_sizes << CRC_SIZES_SHIFT;
8457 return load_8051_config(dd, VERIFY_CAP_LOCAL_FABRIC,
8458 GENERAL_CONFIG, frame);
8459}
8460
8461static void read_vc_local_link_width(struct hfi1_devdata *dd, u8 *misc_bits,
8462 u8 *flag_bits, u16 *link_widths)
8463{
8464 u32 frame;
8465
8466 read_8051_config(dd, VERIFY_CAP_LOCAL_LINK_WIDTH, GENERAL_CONFIG,
8467 &frame);
8468 *misc_bits = (frame >> MISC_CONFIG_BITS_SHIFT) & MISC_CONFIG_BITS_MASK;
8469 *flag_bits = (frame >> LOCAL_FLAG_BITS_SHIFT) & LOCAL_FLAG_BITS_MASK;
8470 *link_widths = (frame >> LINK_WIDTH_SHIFT) & LINK_WIDTH_MASK;
8471}
8472
8473static int write_vc_local_link_width(struct hfi1_devdata *dd,
8474 u8 misc_bits,
8475 u8 flag_bits,
8476 u16 link_widths)
8477{
8478 u32 frame;
8479
8480 frame = (u32)misc_bits << MISC_CONFIG_BITS_SHIFT
8481 | (u32)flag_bits << LOCAL_FLAG_BITS_SHIFT
8482 | (u32)link_widths << LINK_WIDTH_SHIFT;
8483 return load_8051_config(dd, VERIFY_CAP_LOCAL_LINK_WIDTH, GENERAL_CONFIG,
8484 frame);
8485}
8486
8487static int write_local_device_id(struct hfi1_devdata *dd, u16 device_id,
8488 u8 device_rev)
8489{
8490 u32 frame;
8491
8492 frame = ((u32)device_id << LOCAL_DEVICE_ID_SHIFT)
8493 | ((u32)device_rev << LOCAL_DEVICE_REV_SHIFT);
8494 return load_8051_config(dd, LOCAL_DEVICE_ID, GENERAL_CONFIG, frame);
8495}
8496
8497static void read_remote_device_id(struct hfi1_devdata *dd, u16 *device_id,
8498 u8 *device_rev)
8499{
8500 u32 frame;
8501
8502 read_8051_config(dd, REMOTE_DEVICE_ID, GENERAL_CONFIG, &frame);
8503 *device_id = (frame >> REMOTE_DEVICE_ID_SHIFT) & REMOTE_DEVICE_ID_MASK;
8504 *device_rev = (frame >> REMOTE_DEVICE_REV_SHIFT)
8505 & REMOTE_DEVICE_REV_MASK;
8506}
8507
8508void read_misc_status(struct hfi1_devdata *dd, u8 *ver_a, u8 *ver_b)
8509{
8510 u32 frame;
8511
8512 read_8051_config(dd, MISC_STATUS, GENERAL_CONFIG, &frame);
8513 *ver_a = (frame >> STS_FM_VERSION_A_SHIFT) & STS_FM_VERSION_A_MASK;
8514 *ver_b = (frame >> STS_FM_VERSION_B_SHIFT) & STS_FM_VERSION_B_MASK;
8515}
8516
8517static void read_vc_remote_phy(struct hfi1_devdata *dd, u8 *power_management,
8518 u8 *continuous)
8519{
8520 u32 frame;
8521
8522 read_8051_config(dd, VERIFY_CAP_REMOTE_PHY, GENERAL_CONFIG, &frame);
8523 *power_management = (frame >> POWER_MANAGEMENT_SHIFT)
8524 & POWER_MANAGEMENT_MASK;
8525 *continuous = (frame >> CONTINIOUS_REMOTE_UPDATE_SUPPORT_SHIFT)
8526 & CONTINIOUS_REMOTE_UPDATE_SUPPORT_MASK;
8527}
8528
8529static void read_vc_remote_fabric(struct hfi1_devdata *dd, u8 *vau, u8 *z,
8530 u8 *vcu, u16 *vl15buf, u8 *crc_sizes)
8531{
8532 u32 frame;
8533
8534 read_8051_config(dd, VERIFY_CAP_REMOTE_FABRIC, GENERAL_CONFIG, &frame);
8535 *vau = (frame >> VAU_SHIFT) & VAU_MASK;
8536 *z = (frame >> Z_SHIFT) & Z_MASK;
8537 *vcu = (frame >> VCU_SHIFT) & VCU_MASK;
8538 *vl15buf = (frame >> VL15BUF_SHIFT) & VL15BUF_MASK;
8539 *crc_sizes = (frame >> CRC_SIZES_SHIFT) & CRC_SIZES_MASK;
8540}
8541
8542static void read_vc_remote_link_width(struct hfi1_devdata *dd,
8543 u8 *remote_tx_rate,
8544 u16 *link_widths)
8545{
8546 u32 frame;
8547
8548 read_8051_config(dd, VERIFY_CAP_REMOTE_LINK_WIDTH, GENERAL_CONFIG,
8549 &frame);
8550 *remote_tx_rate = (frame >> REMOTE_TX_RATE_SHIFT)
8551 & REMOTE_TX_RATE_MASK;
8552 *link_widths = (frame >> LINK_WIDTH_SHIFT) & LINK_WIDTH_MASK;
8553}
8554
8555static void read_local_lni(struct hfi1_devdata *dd, u8 *enable_lane_rx)
8556{
8557 u32 frame;
8558
8559 read_8051_config(dd, LOCAL_LNI_INFO, GENERAL_CONFIG, &frame);
8560 *enable_lane_rx = (frame >> ENABLE_LANE_RX_SHIFT) & ENABLE_LANE_RX_MASK;
8561}
8562
8563static void read_mgmt_allowed(struct hfi1_devdata *dd, u8 *mgmt_allowed)
8564{
8565 u32 frame;
8566
8567 read_8051_config(dd, REMOTE_LNI_INFO, GENERAL_CONFIG, &frame);
8568 *mgmt_allowed = (frame >> MGMT_ALLOWED_SHIFT) & MGMT_ALLOWED_MASK;
8569}
8570
8571static void read_last_local_state(struct hfi1_devdata *dd, u32 *lls)
8572{
8573 read_8051_config(dd, LAST_LOCAL_STATE_COMPLETE, GENERAL_CONFIG, lls);
8574}
8575
8576static void read_last_remote_state(struct hfi1_devdata *dd, u32 *lrs)
8577{
8578 read_8051_config(dd, LAST_REMOTE_STATE_COMPLETE, GENERAL_CONFIG, lrs);
8579}
8580
8581void hfi1_read_link_quality(struct hfi1_devdata *dd, u8 *link_quality)
8582{
8583 u32 frame;
8584 int ret;
8585
8586 *link_quality = 0;
8587 if (dd->pport->host_link_state & HLS_UP) {
8588 ret = read_8051_config(dd, LINK_QUALITY_INFO, GENERAL_CONFIG,
8589 &frame);
8590 if (ret == 0)
8591 *link_quality = (frame >> LINK_QUALITY_SHIFT)
8592 & LINK_QUALITY_MASK;
8593 }
8594}
8595
8596static void read_planned_down_reason_code(struct hfi1_devdata *dd, u8 *pdrrc)
8597{
8598 u32 frame;
8599
8600 read_8051_config(dd, LINK_QUALITY_INFO, GENERAL_CONFIG, &frame);
8601 *pdrrc = (frame >> DOWN_REMOTE_REASON_SHIFT) & DOWN_REMOTE_REASON_MASK;
8602}
8603
8604static int read_tx_settings(struct hfi1_devdata *dd,
8605 u8 *enable_lane_tx,
8606 u8 *tx_polarity_inversion,
8607 u8 *rx_polarity_inversion,
8608 u8 *max_rate)
8609{
8610 u32 frame;
8611 int ret;
8612
8613 ret = read_8051_config(dd, TX_SETTINGS, GENERAL_CONFIG, &frame);
8614 *enable_lane_tx = (frame >> ENABLE_LANE_TX_SHIFT)
8615 & ENABLE_LANE_TX_MASK;
8616 *tx_polarity_inversion = (frame >> TX_POLARITY_INVERSION_SHIFT)
8617 & TX_POLARITY_INVERSION_MASK;
8618 *rx_polarity_inversion = (frame >> RX_POLARITY_INVERSION_SHIFT)
8619 & RX_POLARITY_INVERSION_MASK;
8620 *max_rate = (frame >> MAX_RATE_SHIFT) & MAX_RATE_MASK;
8621 return ret;
8622}
8623
8624static int write_tx_settings(struct hfi1_devdata *dd,
8625 u8 enable_lane_tx,
8626 u8 tx_polarity_inversion,
8627 u8 rx_polarity_inversion,
8628 u8 max_rate)
8629{
8630 u32 frame;
8631
8632 /* no need to mask, all variable sizes match field widths */
8633 frame = enable_lane_tx << ENABLE_LANE_TX_SHIFT
8634 | tx_polarity_inversion << TX_POLARITY_INVERSION_SHIFT
8635 | rx_polarity_inversion << RX_POLARITY_INVERSION_SHIFT
8636 | max_rate << MAX_RATE_SHIFT;
8637 return load_8051_config(dd, TX_SETTINGS, GENERAL_CONFIG, frame);
8638}
8639
8640static void check_fabric_firmware_versions(struct hfi1_devdata *dd)
8641{
8642 u32 frame, version, prod_id;
8643 int ret, lane;
8644
8645 /* 4 lanes */
8646 for (lane = 0; lane < 4; lane++) {
8647 ret = read_8051_config(dd, SPICO_FW_VERSION, lane, &frame);
8648 if (ret) {
8649 dd_dev_err(
8650 dd,
8651 "Unable to read lane %d firmware details\n",
8652 lane);
8653 continue;
8654 }
8655 version = (frame >> SPICO_ROM_VERSION_SHIFT)
8656 & SPICO_ROM_VERSION_MASK;
8657 prod_id = (frame >> SPICO_ROM_PROD_ID_SHIFT)
8658 & SPICO_ROM_PROD_ID_MASK;
8659 dd_dev_info(dd,
8660 "Lane %d firmware: version 0x%04x, prod_id 0x%04x\n",
8661 lane, version, prod_id);
8662 }
8663}
8664
8665/*
8666 * Read an idle LCB message.
8667 *
8668 * Returns 0 on success, -EINVAL on error
8669 */
8670static int read_idle_message(struct hfi1_devdata *dd, u64 type, u64 *data_out)
8671{
8672 int ret;
8673
8674 ret = do_8051_command(dd, HCMD_READ_LCB_IDLE_MSG,
8675 type, data_out);
8676 if (ret != HCMD_SUCCESS) {
8677 dd_dev_err(dd, "read idle message: type %d, err %d\n",
8678 (u32)type, ret);
8679 return -EINVAL;
8680 }
8681 dd_dev_info(dd, "%s: read idle message 0x%llx\n", __func__, *data_out);
8682 /* return only the payload as we already know the type */
8683 *data_out >>= IDLE_PAYLOAD_SHIFT;
8684 return 0;
8685}
8686
8687/*
8688 * Read an idle SMA message. To be done in response to a notification from
8689 * the 8051.
8690 *
8691 * Returns 0 on success, -EINVAL on error
8692 */
8693static int read_idle_sma(struct hfi1_devdata *dd, u64 *data)
8694{
8695 return read_idle_message(dd,
8696 (u64)IDLE_SMA << IDLE_MSG_TYPE_SHIFT, data);
8697}
8698
8699/*
8700 * Send an idle LCB message.
8701 *
8702 * Returns 0 on success, -EINVAL on error
8703 */
8704static int send_idle_message(struct hfi1_devdata *dd, u64 data)
8705{
8706 int ret;
8707
8708 dd_dev_info(dd, "%s: sending idle message 0x%llx\n", __func__, data);
8709 ret = do_8051_command(dd, HCMD_SEND_LCB_IDLE_MSG, data, NULL);
8710 if (ret != HCMD_SUCCESS) {
8711 dd_dev_err(dd, "send idle message: data 0x%llx, err %d\n",
8712 data, ret);
8713 return -EINVAL;
8714 }
8715 return 0;
8716}
8717
8718/*
8719 * Send an idle SMA message.
8720 *
8721 * Returns 0 on success, -EINVAL on error
8722 */
8723int send_idle_sma(struct hfi1_devdata *dd, u64 message)
8724{
8725 u64 data;
8726
8727 data = ((message & IDLE_PAYLOAD_MASK) << IDLE_PAYLOAD_SHIFT)
8728 | ((u64)IDLE_SMA << IDLE_MSG_TYPE_SHIFT);
8729 return send_idle_message(dd, data);
8730}
8731
8732/*
8733 * Initialize the LCB then do a quick link up. This may or may not be
8734 * in loopback.
8735 *
8736 * return 0 on success, -errno on error
8737 */
8738static int do_quick_linkup(struct hfi1_devdata *dd)
8739{
8740 u64 reg;
8741 unsigned long timeout;
8742 int ret;
8743
8744 lcb_shutdown(dd, 0);
8745
8746 if (loopback) {
8747 /* LCB_CFG_LOOPBACK.VAL = 2 */
8748 /* LCB_CFG_LANE_WIDTH.VAL = 0 */
8749 write_csr(dd, DC_LCB_CFG_LOOPBACK,
8750 IB_PACKET_TYPE << DC_LCB_CFG_LOOPBACK_VAL_SHIFT);
8751 write_csr(dd, DC_LCB_CFG_LANE_WIDTH, 0);
8752 }
8753
8754 /* start the LCBs */
8755 /* LCB_CFG_TX_FIFOS_RESET.VAL = 0 */
8756 write_csr(dd, DC_LCB_CFG_TX_FIFOS_RESET, 0);
8757
8758 /* simulator only loopback steps */
8759 if (loopback && dd->icode == ICODE_FUNCTIONAL_SIMULATOR) {
8760 /* LCB_CFG_RUN.EN = 1 */
8761 write_csr(dd, DC_LCB_CFG_RUN,
8762 1ull << DC_LCB_CFG_RUN_EN_SHIFT);
8763
8764 /* watch LCB_STS_LINK_TRANSFER_ACTIVE */
8765 timeout = jiffies + msecs_to_jiffies(10);
8766 while (1) {
8767 reg = read_csr(dd,
8768 DC_LCB_STS_LINK_TRANSFER_ACTIVE);
8769 if (reg)
8770 break;
8771 if (time_after(jiffies, timeout)) {
8772 dd_dev_err(dd,
8773 "timeout waiting for LINK_TRANSFER_ACTIVE\n");
8774 return -ETIMEDOUT;
8775 }
8776 udelay(2);
8777 }
8778
8779 write_csr(dd, DC_LCB_CFG_ALLOW_LINK_UP,
8780 1ull << DC_LCB_CFG_ALLOW_LINK_UP_VAL_SHIFT);
8781 }
8782
8783 if (!loopback) {
8784 /*
8785 * When doing quick linkup and not in loopback, both
8786 * sides must be done with LCB set-up before either
8787 * starts the quick linkup. Put a delay here so that
8788 * both sides can be started and have a chance to be
8789 * done with LCB set up before resuming.
8790 */
8791 dd_dev_err(dd,
8792 "Pausing for peer to be finished with LCB set up\n");
8793 msleep(5000);
8794 dd_dev_err(dd,
8795 "Continuing with quick linkup\n");
8796 }
8797
8798 write_csr(dd, DC_LCB_ERR_EN, 0); /* mask LCB errors */
8799 set_8051_lcb_access(dd);
8800
8801 /*
8802 * State "quick" LinkUp request sets the physical link state to
8803 * LinkUp without a verify capability sequence.
8804 * This state is in simulator v37 and later.
8805 */
8806 ret = set_physical_link_state(dd, PLS_QUICK_LINKUP);
8807 if (ret != HCMD_SUCCESS) {
8808 dd_dev_err(dd,
8809 "%s: set physical link state to quick LinkUp failed with return %d\n",
8810 __func__, ret);
8811
8812 set_host_lcb_access(dd);
8813 write_csr(dd, DC_LCB_ERR_EN, ~0ull); /* watch LCB errors */
8814
8815 if (ret >= 0)
8816 ret = -EINVAL;
8817 return ret;
8818 }
8819
8820 return 0; /* success */
8821}
8822
8823/*
8824 * Set the SerDes to internal loopback mode.
8825 * Returns 0 on success, -errno on error.
8826 */
8827static int set_serdes_loopback_mode(struct hfi1_devdata *dd)
8828{
8829 int ret;
8830
8831 ret = set_physical_link_state(dd, PLS_INTERNAL_SERDES_LOOPBACK);
8832 if (ret == HCMD_SUCCESS)
8833 return 0;
8834 dd_dev_err(dd,
8835 "Set physical link state to SerDes Loopback failed with return %d\n",
8836 ret);
8837 if (ret >= 0)
8838 ret = -EINVAL;
8839 return ret;
8840}
8841
8842/*
8843 * Do all special steps to set up loopback.
8844 */
8845static int init_loopback(struct hfi1_devdata *dd)
8846{
8847 dd_dev_info(dd, "Entering loopback mode\n");
8848
8849 /* all loopbacks should disable self GUID check */
8850 write_csr(dd, DC_DC8051_CFG_MODE,
8851 (read_csr(dd, DC_DC8051_CFG_MODE) | DISABLE_SELF_GUID_CHECK));
8852
8853 /*
8854 * The simulator has only one loopback option - LCB. Switch
8855 * to that option, which includes quick link up.
8856 *
8857 * Accept all valid loopback values.
8858 */
8859 if ((dd->icode == ICODE_FUNCTIONAL_SIMULATOR)
8860 && (loopback == LOOPBACK_SERDES
8861 || loopback == LOOPBACK_LCB
8862 || loopback == LOOPBACK_CABLE)) {
8863 loopback = LOOPBACK_LCB;
8864 quick_linkup = 1;
8865 return 0;
8866 }
8867
8868 /* handle serdes loopback */
8869 if (loopback == LOOPBACK_SERDES) {
8870 /* internal serdes loopack needs quick linkup on RTL */
8871 if (dd->icode == ICODE_RTL_SILICON)
8872 quick_linkup = 1;
8873 return set_serdes_loopback_mode(dd);
8874 }
8875
8876 /* LCB loopback - handled at poll time */
8877 if (loopback == LOOPBACK_LCB) {
8878 quick_linkup = 1; /* LCB is always quick linkup */
8879
8880 /* not supported in emulation due to emulation RTL changes */
8881 if (dd->icode == ICODE_FPGA_EMULATION) {
8882 dd_dev_err(dd,
8883 "LCB loopback not supported in emulation\n");
8884 return -EINVAL;
8885 }
8886 return 0;
8887 }
8888
8889 /* external cable loopback requires no extra steps */
8890 if (loopback == LOOPBACK_CABLE)
8891 return 0;
8892
8893 dd_dev_err(dd, "Invalid loopback mode %d\n", loopback);
8894 return -EINVAL;
8895}
8896
8897/*
8898 * Translate from the OPA_LINK_WIDTH handed to us by the FM to bits
8899 * used in the Verify Capability link width attribute.
8900 */
8901static u16 opa_to_vc_link_widths(u16 opa_widths)
8902{
8903 int i;
8904 u16 result = 0;
8905
8906 static const struct link_bits {
8907 u16 from;
8908 u16 to;
8909 } opa_link_xlate[] = {
8910 { OPA_LINK_WIDTH_1X, 1 << (1-1) },
8911 { OPA_LINK_WIDTH_2X, 1 << (2-1) },
8912 { OPA_LINK_WIDTH_3X, 1 << (3-1) },
8913 { OPA_LINK_WIDTH_4X, 1 << (4-1) },
8914 };
8915
8916 for (i = 0; i < ARRAY_SIZE(opa_link_xlate); i++) {
8917 if (opa_widths & opa_link_xlate[i].from)
8918 result |= opa_link_xlate[i].to;
8919 }
8920 return result;
8921}
8922
8923/*
8924 * Set link attributes before moving to polling.
8925 */
8926static int set_local_link_attributes(struct hfi1_pportdata *ppd)
8927{
8928 struct hfi1_devdata *dd = ppd->dd;
8929 u8 enable_lane_tx;
8930 u8 tx_polarity_inversion;
8931 u8 rx_polarity_inversion;
8932 int ret;
8933
8934 /* reset our fabric serdes to clear any lingering problems */
8935 fabric_serdes_reset(dd);
8936
8937 /* set the local tx rate - need to read-modify-write */
8938 ret = read_tx_settings(dd, &enable_lane_tx, &tx_polarity_inversion,
8939 &rx_polarity_inversion, &ppd->local_tx_rate);
8940 if (ret)
8941 goto set_local_link_attributes_fail;
8942
8943 if (dd->dc8051_ver < dc8051_ver(0, 20)) {
8944 /* set the tx rate to the fastest enabled */
8945 if (ppd->link_speed_enabled & OPA_LINK_SPEED_25G)
8946 ppd->local_tx_rate = 1;
8947 else
8948 ppd->local_tx_rate = 0;
8949 } else {
8950 /* set the tx rate to all enabled */
8951 ppd->local_tx_rate = 0;
8952 if (ppd->link_speed_enabled & OPA_LINK_SPEED_25G)
8953 ppd->local_tx_rate |= 2;
8954 if (ppd->link_speed_enabled & OPA_LINK_SPEED_12_5G)
8955 ppd->local_tx_rate |= 1;
8956 }
Easwar Hariharanfebffe22015-10-26 10:28:36 -0400[diff] [blame]8957
8958 enable_lane_tx = 0xF; /* enable all four lanes */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]8959 ret = write_tx_settings(dd, enable_lane_tx, tx_polarity_inversion,
8960 rx_polarity_inversion, ppd->local_tx_rate);
8961 if (ret != HCMD_SUCCESS)
8962 goto set_local_link_attributes_fail;
8963
8964 /*
8965 * DC supports continuous updates.
8966 */
8967 ret = write_vc_local_phy(dd, 0 /* no power management */,
8968 1 /* continuous updates */);
8969 if (ret != HCMD_SUCCESS)
8970 goto set_local_link_attributes_fail;
8971
8972 /* z=1 in the next call: AU of 0 is not supported by the hardware */
8973 ret = write_vc_local_fabric(dd, dd->vau, 1, dd->vcu, dd->vl15_init,
8974 ppd->port_crc_mode_enabled);
8975 if (ret != HCMD_SUCCESS)
8976 goto set_local_link_attributes_fail;
8977
8978 ret = write_vc_local_link_width(dd, 0, 0,
8979 opa_to_vc_link_widths(ppd->link_width_enabled));
8980 if (ret != HCMD_SUCCESS)
8981 goto set_local_link_attributes_fail;
8982
8983 /* let peer know who we are */
8984 ret = write_local_device_id(dd, dd->pcidev->device, dd->minrev);
8985 if (ret == HCMD_SUCCESS)
8986 return 0;
8987
8988set_local_link_attributes_fail:
8989 dd_dev_err(dd,
8990 "Failed to set local link attributes, return 0x%x\n",
8991 ret);
8992 return ret;
8993}
8994
8995/*
8996 * Call this to start the link. Schedule a retry if the cable is not
8997 * present or if unable to start polling. Do not do anything if the
8998 * link is disabled. Returns 0 if link is disabled or moved to polling
8999 */
9000int start_link(struct hfi1_pportdata *ppd)
9001{
9002 if (!ppd->link_enabled) {
9003 dd_dev_info(ppd->dd,
9004 "%s: stopping link start because link is disabled\n",
9005 __func__);
9006 return 0;
9007 }
9008 if (!ppd->driver_link_ready) {
9009 dd_dev_info(ppd->dd,
9010 "%s: stopping link start because driver is not ready\n",
9011 __func__);
9012 return 0;
9013 }
9014
9015 if (qsfp_mod_present(ppd) || loopback == LOOPBACK_SERDES ||
9016 loopback == LOOPBACK_LCB ||
9017 ppd->dd->icode == ICODE_FUNCTIONAL_SIMULATOR)
9018 return set_link_state(ppd, HLS_DN_POLL);
9019
9020 dd_dev_info(ppd->dd,
9021 "%s: stopping link start because no cable is present\n",
9022 __func__);
9023 return -EAGAIN;
9024}
9025
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9026static void wait_for_qsfp_init(struct hfi1_pportdata *ppd)
9027{
9028 struct hfi1_devdata *dd = ppd->dd;
9029 u64 mask;
9030 unsigned long timeout;
9031
9032 /*
9033 * Check for QSFP interrupt for t_init (SFF 8679)
9034 */
9035 timeout = jiffies + msecs_to_jiffies(2000);
9036 while (1) {
9037 mask = read_csr(dd, dd->hfi1_id ?
9038 ASIC_QSFP2_IN : ASIC_QSFP1_IN);
9039 if (!(mask & QSFP_HFI0_INT_N)) {
9040 write_csr(dd, dd->hfi1_id ? ASIC_QSFP2_CLEAR :
9041 ASIC_QSFP1_CLEAR, QSFP_HFI0_INT_N);
9042 break;
9043 }
9044 if (time_after(jiffies, timeout)) {
9045 dd_dev_info(dd, "%s: No IntN detected, reset complete\n",
9046 __func__);
9047 break;
9048 }
9049 udelay(2);
9050 }
9051}
9052
9053static void set_qsfp_int_n(struct hfi1_pportdata *ppd, u8 enable)
9054{
9055 struct hfi1_devdata *dd = ppd->dd;
9056 u64 mask;
9057
9058 mask = read_csr(dd, dd->hfi1_id ? ASIC_QSFP2_MASK : ASIC_QSFP1_MASK);
9059 if (enable)
9060 mask |= (u64)QSFP_HFI0_INT_N;
9061 else
9062 mask &= ~(u64)QSFP_HFI0_INT_N;
9063 write_csr(dd, dd->hfi1_id ? ASIC_QSFP2_MASK : ASIC_QSFP1_MASK, mask);
9064}
9065
9066void reset_qsfp(struct hfi1_pportdata *ppd)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9067{
9068 struct hfi1_devdata *dd = ppd->dd;
9069 u64 mask, qsfp_mask;
9070
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9071 /* Disable INT_N from triggering QSFP interrupts */
9072 set_qsfp_int_n(ppd, 0);
9073
9074 /* Reset the QSFP */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9075 mask = (u64)QSFP_HFI0_RESET_N;
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9076 qsfp_mask = read_csr(dd, dd->hfi1_id ? ASIC_QSFP2_OE : ASIC_QSFP1_OE);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9077 qsfp_mask |= mask;
9078 write_csr(dd,
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9079 dd->hfi1_id ? ASIC_QSFP2_OE : ASIC_QSFP1_OE, qsfp_mask);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9080
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9081 qsfp_mask = read_csr(dd, dd->hfi1_id ?
9082 ASIC_QSFP2_OUT : ASIC_QSFP1_OUT);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9083 qsfp_mask &= ~mask;
9084 write_csr(dd,
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9085 dd->hfi1_id ? ASIC_QSFP2_OUT : ASIC_QSFP1_OUT, qsfp_mask);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9086
9087 udelay(10);
9088
9089 qsfp_mask |= mask;
9090 write_csr(dd,
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9091 dd->hfi1_id ? ASIC_QSFP2_OUT : ASIC_QSFP1_OUT, qsfp_mask);
9092
9093 wait_for_qsfp_init(ppd);
9094
9095 /*
9096 * Allow INT_N to trigger the QSFP interrupt to watch
9097 * for alarms and warnings
9098 */
9099 set_qsfp_int_n(ppd, 1);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9100}
9101
9102static int handle_qsfp_error_conditions(struct hfi1_pportdata *ppd,
9103 u8 *qsfp_interrupt_status)
9104{
9105 struct hfi1_devdata *dd = ppd->dd;
9106
9107 if ((qsfp_interrupt_status[0] & QSFP_HIGH_TEMP_ALARM) ||
9108 (qsfp_interrupt_status[0] & QSFP_HIGH_TEMP_WARNING))
9109 dd_dev_info(dd,
9110 "%s: QSFP cable on fire\n",
9111 __func__);
9112
9113 if ((qsfp_interrupt_status[0] & QSFP_LOW_TEMP_ALARM) ||
9114 (qsfp_interrupt_status[0] & QSFP_LOW_TEMP_WARNING))
9115 dd_dev_info(dd,
9116 "%s: QSFP cable temperature too low\n",
9117 __func__);
9118
9119 if ((qsfp_interrupt_status[1] & QSFP_HIGH_VCC_ALARM) ||
9120 (qsfp_interrupt_status[1] & QSFP_HIGH_VCC_WARNING))
9121 dd_dev_info(dd,
9122 "%s: QSFP supply voltage too high\n",
9123 __func__);
9124
9125 if ((qsfp_interrupt_status[1] & QSFP_LOW_VCC_ALARM) ||
9126 (qsfp_interrupt_status[1] & QSFP_LOW_VCC_WARNING))
9127 dd_dev_info(dd,
9128 "%s: QSFP supply voltage too low\n",
9129 __func__);
9130
9131 /* Byte 2 is vendor specific */
9132
9133 if ((qsfp_interrupt_status[3] & QSFP_HIGH_POWER_ALARM) ||
9134 (qsfp_interrupt_status[3] & QSFP_HIGH_POWER_WARNING))
9135 dd_dev_info(dd,
9136 "%s: Cable RX channel 1/2 power too high\n",
9137 __func__);
9138
9139 if ((qsfp_interrupt_status[3] & QSFP_LOW_POWER_ALARM) ||
9140 (qsfp_interrupt_status[3] & QSFP_LOW_POWER_WARNING))
9141 dd_dev_info(dd,
9142 "%s: Cable RX channel 1/2 power too low\n",
9143 __func__);
9144
9145 if ((qsfp_interrupt_status[4] & QSFP_HIGH_POWER_ALARM) ||
9146 (qsfp_interrupt_status[4] & QSFP_HIGH_POWER_WARNING))
9147 dd_dev_info(dd,
9148 "%s: Cable RX channel 3/4 power too high\n",
9149 __func__);
9150
9151 if ((qsfp_interrupt_status[4] & QSFP_LOW_POWER_ALARM) ||
9152 (qsfp_interrupt_status[4] & QSFP_LOW_POWER_WARNING))
9153 dd_dev_info(dd,
9154 "%s: Cable RX channel 3/4 power too low\n",
9155 __func__);
9156
9157 if ((qsfp_interrupt_status[5] & QSFP_HIGH_BIAS_ALARM) ||
9158 (qsfp_interrupt_status[5] & QSFP_HIGH_BIAS_WARNING))
9159 dd_dev_info(dd,
9160 "%s: Cable TX channel 1/2 bias too high\n",
9161 __func__);
9162
9163 if ((qsfp_interrupt_status[5] & QSFP_LOW_BIAS_ALARM) ||
9164 (qsfp_interrupt_status[5] & QSFP_LOW_BIAS_WARNING))
9165 dd_dev_info(dd,
9166 "%s: Cable TX channel 1/2 bias too low\n",
9167 __func__);
9168
9169 if ((qsfp_interrupt_status[6] & QSFP_HIGH_BIAS_ALARM) ||
9170 (qsfp_interrupt_status[6] & QSFP_HIGH_BIAS_WARNING))
9171 dd_dev_info(dd,
9172 "%s: Cable TX channel 3/4 bias too high\n",
9173 __func__);
9174
9175 if ((qsfp_interrupt_status[6] & QSFP_LOW_BIAS_ALARM) ||
9176 (qsfp_interrupt_status[6] & QSFP_LOW_BIAS_WARNING))
9177 dd_dev_info(dd,
9178 "%s: Cable TX channel 3/4 bias too low\n",
9179 __func__);
9180
9181 if ((qsfp_interrupt_status[7] & QSFP_HIGH_POWER_ALARM) ||
9182 (qsfp_interrupt_status[7] & QSFP_HIGH_POWER_WARNING))
9183 dd_dev_info(dd,
9184 "%s: Cable TX channel 1/2 power too high\n",
9185 __func__);
9186
9187 if ((qsfp_interrupt_status[7] & QSFP_LOW_POWER_ALARM) ||
9188 (qsfp_interrupt_status[7] & QSFP_LOW_POWER_WARNING))
9189 dd_dev_info(dd,
9190 "%s: Cable TX channel 1/2 power too low\n",
9191 __func__);
9192
9193 if ((qsfp_interrupt_status[8] & QSFP_HIGH_POWER_ALARM) ||
9194 (qsfp_interrupt_status[8] & QSFP_HIGH_POWER_WARNING))
9195 dd_dev_info(dd,
9196 "%s: Cable TX channel 3/4 power too high\n",
9197 __func__);
9198
9199 if ((qsfp_interrupt_status[8] & QSFP_LOW_POWER_ALARM) ||
9200 (qsfp_interrupt_status[8] & QSFP_LOW_POWER_WARNING))
9201 dd_dev_info(dd,
9202 "%s: Cable TX channel 3/4 power too low\n",
9203 __func__);
9204
9205 /* Bytes 9-10 and 11-12 are reserved */
9206 /* Bytes 13-15 are vendor specific */
9207
9208 return 0;
9209}
9210
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9211/* This routine will only be scheduled if the QSFP module is present */
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9212void qsfp_event(struct work_struct *work)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9213{
9214 struct qsfp_data *qd;
9215 struct hfi1_pportdata *ppd;
9216 struct hfi1_devdata *dd;
9217
9218 qd = container_of(work, struct qsfp_data, qsfp_work);
9219 ppd = qd->ppd;
9220 dd = ppd->dd;
9221
9222 /* Sanity check */
9223 if (!qsfp_mod_present(ppd))
9224 return;
9225
9226 /*
9227 * Turn DC back on after cables has been
9228 * re-inserted. Up until now, the DC has been in
9229 * reset to save power.
9230 */
9231 dc_start(dd);
9232
9233 if (qd->cache_refresh_required) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9234
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9235 set_qsfp_int_n(ppd, 0);
9236
9237 wait_for_qsfp_init(ppd);
9238
9239 /*
9240 * Allow INT_N to trigger the QSFP interrupt to watch
9241 * for alarms and warnings
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9242 */
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9243 set_qsfp_int_n(ppd, 1);
9244
9245 tune_serdes(ppd);
9246
9247 start_link(ppd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9248 }
9249
9250 if (qd->check_interrupt_flags) {
9251 u8 qsfp_interrupt_status[16] = {0,};
9252
9253 if (qsfp_read(ppd, dd->hfi1_id, 6,
9254 &qsfp_interrupt_status[0], 16) != 16) {
9255 dd_dev_info(dd,
9256 "%s: Failed to read status of QSFP module\n",
9257 __func__);
9258 } else {
9259 unsigned long flags;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9260
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9261 handle_qsfp_error_conditions(
9262 ppd, qsfp_interrupt_status);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9263 spin_lock_irqsave(&ppd->qsfp_info.qsfp_lock, flags);
9264 ppd->qsfp_info.check_interrupt_flags = 0;
9265 spin_unlock_irqrestore(&ppd->qsfp_info.qsfp_lock,
9266 flags);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9267 }
9268 }
9269}
9270
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9271static void init_qsfp_int(struct hfi1_devdata *dd)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9272{
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9273 struct hfi1_pportdata *ppd = dd->pport;
9274 u64 qsfp_mask, cce_int_mask;
9275 const int qsfp1_int_smask = QSFP1_INT % 64;
9276 const int qsfp2_int_smask = QSFP2_INT % 64;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9277
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9278 /*
9279 * disable QSFP1 interrupts for HFI1, QSFP2 interrupts for HFI0
9280 * Qsfp1Int and Qsfp2Int are adjacent bits in the same CSR,
9281 * therefore just one of QSFP1_INT/QSFP2_INT can be used to find
9282 * the index of the appropriate CSR in the CCEIntMask CSR array
9283 */
9284 cce_int_mask = read_csr(dd, CCE_INT_MASK +
9285 (8 * (QSFP1_INT / 64)));
9286 if (dd->hfi1_id) {
9287 cce_int_mask &= ~((u64)1 << qsfp1_int_smask);
9288 write_csr(dd, CCE_INT_MASK + (8 * (QSFP1_INT / 64)),
9289 cce_int_mask);
9290 } else {
9291 cce_int_mask &= ~((u64)1 << qsfp2_int_smask);
9292 write_csr(dd, CCE_INT_MASK + (8 * (QSFP2_INT / 64)),
9293 cce_int_mask);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9294 }
9295
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9296 qsfp_mask = (u64)(QSFP_HFI0_INT_N | QSFP_HFI0_MODPRST_N);
9297 /* Clear current status to avoid spurious interrupts */
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9298 write_csr(dd, dd->hfi1_id ? ASIC_QSFP2_CLEAR : ASIC_QSFP1_CLEAR,
9299 qsfp_mask);
9300 write_csr(dd, dd->hfi1_id ? ASIC_QSFP2_MASK : ASIC_QSFP1_MASK,
9301 qsfp_mask);
9302
9303 set_qsfp_int_n(ppd, 0);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9304
9305 /* Handle active low nature of INT_N and MODPRST_N pins */
9306 if (qsfp_mod_present(ppd))
9307 qsfp_mask &= ~(u64)QSFP_HFI0_MODPRST_N;
9308 write_csr(dd,
9309 dd->hfi1_id ? ASIC_QSFP2_INVERT : ASIC_QSFP1_INVERT,
9310 qsfp_mask);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9311}
9312
Dean Luickbbdeb332015-12-01 15:38:15 -0500[diff] [blame]9313/*
9314 * Do a one-time initialize of the LCB block.
9315 */
9316static void init_lcb(struct hfi1_devdata *dd)
9317{
9318 /* the DC has been reset earlier in the driver load */
9319
9320 /* set LCB for cclk loopback on the port */
9321 write_csr(dd, DC_LCB_CFG_TX_FIFOS_RESET, 0x01);
9322 write_csr(dd, DC_LCB_CFG_LANE_WIDTH, 0x00);
9323 write_csr(dd, DC_LCB_CFG_REINIT_AS_SLAVE, 0x00);
9324 write_csr(dd, DC_LCB_CFG_CNT_FOR_SKIP_STALL, 0x110);
9325 write_csr(dd, DC_LCB_CFG_CLK_CNTR, 0x08);
9326 write_csr(dd, DC_LCB_CFG_LOOPBACK, 0x02);
9327 write_csr(dd, DC_LCB_CFG_TX_FIFOS_RESET, 0x00);
9328}
9329
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9330int bringup_serdes(struct hfi1_pportdata *ppd)
9331{
9332 struct hfi1_devdata *dd = ppd->dd;
9333 u64 guid;
9334 int ret;
9335
9336 if (HFI1_CAP_IS_KSET(EXTENDED_PSN))
9337 add_rcvctrl(dd, RCV_CTRL_RCV_EXTENDED_PSN_ENABLE_SMASK);
9338
9339 guid = ppd->guid;
9340 if (!guid) {
9341 if (dd->base_guid)
9342 guid = dd->base_guid + ppd->port - 1;
9343 ppd->guid = guid;
9344 }
9345
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9346 /* Set linkinit_reason on power up per OPA spec */
9347 ppd->linkinit_reason = OPA_LINKINIT_REASON_LINKUP;
9348
Dean Luickbbdeb332015-12-01 15:38:15 -0500[diff] [blame]9349 /* one-time init of the LCB */
9350 init_lcb(dd);
9351
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9352 if (loopback) {
9353 ret = init_loopback(dd);
9354 if (ret < 0)
9355 return ret;
9356 }
9357
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9358 /* tune the SERDES to a ballpark setting for
9359 * optimal signal and bit error rate
9360 * Needs to be done before starting the link
9361 */
9362 tune_serdes(ppd);
9363
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9364 return start_link(ppd);
9365}
9366
9367void hfi1_quiet_serdes(struct hfi1_pportdata *ppd)
9368{
9369 struct hfi1_devdata *dd = ppd->dd;
9370
9371 /*
9372 * Shut down the link and keep it down. First turn off that the
9373 * driver wants to allow the link to be up (driver_link_ready).
9374 * Then make sure the link is not automatically restarted
9375 * (link_enabled). Cancel any pending restart. And finally
9376 * go offline.
9377 */
9378 ppd->driver_link_ready = 0;
9379 ppd->link_enabled = 0;
9380
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9381 ppd->offline_disabled_reason =
9382 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_SMA_DISABLED);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9383 set_link_down_reason(ppd, OPA_LINKDOWN_REASON_SMA_DISABLED, 0,
9384 OPA_LINKDOWN_REASON_SMA_DISABLED);
9385 set_link_state(ppd, HLS_DN_OFFLINE);
9386
9387 /* disable the port */
9388 clear_rcvctrl(dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
9389}
9390
9391static inline int init_cpu_counters(struct hfi1_devdata *dd)
9392{
9393 struct hfi1_pportdata *ppd;
9394 int i;
9395
9396 ppd = (struct hfi1_pportdata *)(dd + 1);
9397 for (i = 0; i < dd->num_pports; i++, ppd++) {
Dennis Dalessandro4eb06882016-01-19 14:42:39 -0800[diff] [blame]9398 ppd->ibport_data.rvp.rc_acks = NULL;
9399 ppd->ibport_data.rvp.rc_qacks = NULL;
9400 ppd->ibport_data.rvp.rc_acks = alloc_percpu(u64);
9401 ppd->ibport_data.rvp.rc_qacks = alloc_percpu(u64);
9402 ppd->ibport_data.rvp.rc_delayed_comp = alloc_percpu(u64);
9403 if (!ppd->ibport_data.rvp.rc_acks ||
9404 !ppd->ibport_data.rvp.rc_delayed_comp ||
9405 !ppd->ibport_data.rvp.rc_qacks)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9406 return -ENOMEM;
9407 }
9408
9409 return 0;
9410}
9411
9412static const char * const pt_names[] = {
9413 "expected",
9414 "eager",
9415 "invalid"
9416};
9417
9418static const char *pt_name(u32 type)
9419{
9420 return type >= ARRAY_SIZE(pt_names) ? "unknown" : pt_names[type];
9421}
9422
9423/*
9424 * index is the index into the receive array
9425 */
9426void hfi1_put_tid(struct hfi1_devdata *dd, u32 index,
9427 u32 type, unsigned long pa, u16 order)
9428{
9429 u64 reg;
9430 void __iomem *base = (dd->rcvarray_wc ? dd->rcvarray_wc :
9431 (dd->kregbase + RCV_ARRAY));
9432
9433 if (!(dd->flags & HFI1_PRESENT))
9434 goto done;
9435
9436 if (type == PT_INVALID) {
9437 pa = 0;
9438 } else if (type > PT_INVALID) {
9439 dd_dev_err(dd,
9440 "unexpected receive array type %u for index %u, not handled\n",
9441 type, index);
9442 goto done;
9443 }
9444
9445 hfi1_cdbg(TID, "type %s, index 0x%x, pa 0x%lx, bsize 0x%lx",
9446 pt_name(type), index, pa, (unsigned long)order);
9447
9448#define RT_ADDR_SHIFT 12 /* 4KB kernel address boundary */
9449 reg = RCV_ARRAY_RT_WRITE_ENABLE_SMASK
9450 | (u64)order << RCV_ARRAY_RT_BUF_SIZE_SHIFT
9451 | ((pa >> RT_ADDR_SHIFT) & RCV_ARRAY_RT_ADDR_MASK)
9452 << RCV_ARRAY_RT_ADDR_SHIFT;
9453 writeq(reg, base + (index * 8));
9454
9455 if (type == PT_EAGER)
9456 /*
9457 * Eager entries are written one-by-one so we have to push them
9458 * after we write the entry.
9459 */
9460 flush_wc();
9461done:
9462 return;
9463}
9464
9465void hfi1_clear_tids(struct hfi1_ctxtdata *rcd)
9466{
9467 struct hfi1_devdata *dd = rcd->dd;
9468 u32 i;
9469
9470 /* this could be optimized */
9471 for (i = rcd->eager_base; i < rcd->eager_base +
9472 rcd->egrbufs.alloced; i++)
9473 hfi1_put_tid(dd, i, PT_INVALID, 0, 0);
9474
9475 for (i = rcd->expected_base;
9476 i < rcd->expected_base + rcd->expected_count; i++)
9477 hfi1_put_tid(dd, i, PT_INVALID, 0, 0);
9478}
9479
9480int hfi1_get_base_kinfo(struct hfi1_ctxtdata *rcd,
9481 struct hfi1_ctxt_info *kinfo)
9482{
9483 kinfo->runtime_flags = (HFI1_MISC_GET() << HFI1_CAP_USER_SHIFT) |
9484 HFI1_CAP_UGET(MASK) | HFI1_CAP_KGET(K2U);
9485 return 0;
9486}
9487
9488struct hfi1_message_header *hfi1_get_msgheader(
9489 struct hfi1_devdata *dd, __le32 *rhf_addr)
9490{
9491 u32 offset = rhf_hdrq_offset(rhf_to_cpu(rhf_addr));
9492
9493 return (struct hfi1_message_header *)
9494 (rhf_addr - dd->rhf_offset + offset);
9495}
9496
9497static const char * const ib_cfg_name_strings[] = {
9498 "HFI1_IB_CFG_LIDLMC",
9499 "HFI1_IB_CFG_LWID_DG_ENB",
9500 "HFI1_IB_CFG_LWID_ENB",
9501 "HFI1_IB_CFG_LWID",
9502 "HFI1_IB_CFG_SPD_ENB",
9503 "HFI1_IB_CFG_SPD",
9504 "HFI1_IB_CFG_RXPOL_ENB",
9505 "HFI1_IB_CFG_LREV_ENB",
9506 "HFI1_IB_CFG_LINKLATENCY",
9507 "HFI1_IB_CFG_HRTBT",
9508 "HFI1_IB_CFG_OP_VLS",
9509 "HFI1_IB_CFG_VL_HIGH_CAP",
9510 "HFI1_IB_CFG_VL_LOW_CAP",
9511 "HFI1_IB_CFG_OVERRUN_THRESH",
9512 "HFI1_IB_CFG_PHYERR_THRESH",
9513 "HFI1_IB_CFG_LINKDEFAULT",
9514 "HFI1_IB_CFG_PKEYS",
9515 "HFI1_IB_CFG_MTU",
9516 "HFI1_IB_CFG_LSTATE",
9517 "HFI1_IB_CFG_VL_HIGH_LIMIT",
9518 "HFI1_IB_CFG_PMA_TICKS",
9519 "HFI1_IB_CFG_PORT"
9520};
9521
9522static const char *ib_cfg_name(int which)
9523{
9524 if (which < 0 || which >= ARRAY_SIZE(ib_cfg_name_strings))
9525 return "invalid";
9526 return ib_cfg_name_strings[which];
9527}
9528
9529int hfi1_get_ib_cfg(struct hfi1_pportdata *ppd, int which)
9530{
9531 struct hfi1_devdata *dd = ppd->dd;
9532 int val = 0;
9533
9534 switch (which) {
9535 case HFI1_IB_CFG_LWID_ENB: /* allowed Link-width */
9536 val = ppd->link_width_enabled;
9537 break;
9538 case HFI1_IB_CFG_LWID: /* currently active Link-width */
9539 val = ppd->link_width_active;
9540 break;
9541 case HFI1_IB_CFG_SPD_ENB: /* allowed Link speeds */
9542 val = ppd->link_speed_enabled;
9543 break;
9544 case HFI1_IB_CFG_SPD: /* current Link speed */
9545 val = ppd->link_speed_active;
9546 break;
9547
9548 case HFI1_IB_CFG_RXPOL_ENB: /* Auto-RX-polarity enable */
9549 case HFI1_IB_CFG_LREV_ENB: /* Auto-Lane-reversal enable */
9550 case HFI1_IB_CFG_LINKLATENCY:
9551 goto unimplemented;
9552
9553 case HFI1_IB_CFG_OP_VLS:
9554 val = ppd->vls_operational;
9555 break;
9556 case HFI1_IB_CFG_VL_HIGH_CAP: /* VL arb high priority table size */
9557 val = VL_ARB_HIGH_PRIO_TABLE_SIZE;
9558 break;
9559 case HFI1_IB_CFG_VL_LOW_CAP: /* VL arb low priority table size */
9560 val = VL_ARB_LOW_PRIO_TABLE_SIZE;
9561 break;
9562 case HFI1_IB_CFG_OVERRUN_THRESH: /* IB overrun threshold */
9563 val = ppd->overrun_threshold;
9564 break;
9565 case HFI1_IB_CFG_PHYERR_THRESH: /* IB PHY error threshold */
9566 val = ppd->phy_error_threshold;
9567 break;
9568 case HFI1_IB_CFG_LINKDEFAULT: /* IB link default (sleep/poll) */
9569 val = dd->link_default;
9570 break;
9571
9572 case HFI1_IB_CFG_HRTBT: /* Heartbeat off/enable/auto */
9573 case HFI1_IB_CFG_PMA_TICKS:
9574 default:
9575unimplemented:
9576 if (HFI1_CAP_IS_KSET(PRINT_UNIMPL))
9577 dd_dev_info(
9578 dd,
9579 "%s: which %s: not implemented\n",
9580 __func__,
9581 ib_cfg_name(which));
9582 break;
9583 }
9584
9585 return val;
9586}
9587
9588/*
9589 * The largest MAD packet size.
9590 */
9591#define MAX_MAD_PACKET 2048
9592
9593/*
9594 * Return the maximum header bytes that can go on the _wire_
9595 * for this device. This count includes the ICRC which is
9596 * not part of the packet held in memory but it is appended
9597 * by the HW.
9598 * This is dependent on the device's receive header entry size.
9599 * HFI allows this to be set per-receive context, but the
9600 * driver presently enforces a global value.
9601 */
9602u32 lrh_max_header_bytes(struct hfi1_devdata *dd)
9603{
9604 /*
9605 * The maximum non-payload (MTU) bytes in LRH.PktLen are
9606 * the Receive Header Entry Size minus the PBC (or RHF) size
9607 * plus one DW for the ICRC appended by HW.
9608 *
9609 * dd->rcd[0].rcvhdrqentsize is in DW.
9610 * We use rcd[0] as all context will have the same value. Also,
9611 * the first kernel context would have been allocated by now so
9612 * we are guaranteed a valid value.
9613 */
9614 return (dd->rcd[0]->rcvhdrqentsize - 2/*PBC/RHF*/ + 1/*ICRC*/) << 2;
9615}
9616
9617/*
9618 * Set Send Length
9619 * @ppd - per port data
9620 *
9621 * Set the MTU by limiting how many DWs may be sent. The SendLenCheck*
9622 * registers compare against LRH.PktLen, so use the max bytes included
9623 * in the LRH.
9624 *
9625 * This routine changes all VL values except VL15, which it maintains at
9626 * the same value.
9627 */
9628static void set_send_length(struct hfi1_pportdata *ppd)
9629{
9630 struct hfi1_devdata *dd = ppd->dd;
Harish Chegondi6cc6ad22015-12-01 15:38:24 -0500[diff] [blame]9631 u32 max_hb = lrh_max_header_bytes(dd), dcmtu;
9632 u32 maxvlmtu = dd->vld[15].mtu;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9633 u64 len1 = 0, len2 = (((dd->vld[15].mtu + max_hb) >> 2)
9634 & SEND_LEN_CHECK1_LEN_VL15_MASK) <<
9635 SEND_LEN_CHECK1_LEN_VL15_SHIFT;
9636 int i;
9637
9638 for (i = 0; i < ppd->vls_supported; i++) {
9639 if (dd->vld[i].mtu > maxvlmtu)
9640 maxvlmtu = dd->vld[i].mtu;
9641 if (i <= 3)
9642 len1 |= (((dd->vld[i].mtu + max_hb) >> 2)
9643 & SEND_LEN_CHECK0_LEN_VL0_MASK) <<
9644 ((i % 4) * SEND_LEN_CHECK0_LEN_VL1_SHIFT);
9645 else
9646 len2 |= (((dd->vld[i].mtu + max_hb) >> 2)
9647 & SEND_LEN_CHECK1_LEN_VL4_MASK) <<
9648 ((i % 4) * SEND_LEN_CHECK1_LEN_VL5_SHIFT);
9649 }
9650 write_csr(dd, SEND_LEN_CHECK0, len1);
9651 write_csr(dd, SEND_LEN_CHECK1, len2);
9652 /* adjust kernel credit return thresholds based on new MTUs */
9653 /* all kernel receive contexts have the same hdrqentsize */
9654 for (i = 0; i < ppd->vls_supported; i++) {
9655 sc_set_cr_threshold(dd->vld[i].sc,
9656 sc_mtu_to_threshold(dd->vld[i].sc, dd->vld[i].mtu,
9657 dd->rcd[0]->rcvhdrqentsize));
9658 }
9659 sc_set_cr_threshold(dd->vld[15].sc,
9660 sc_mtu_to_threshold(dd->vld[15].sc, dd->vld[15].mtu,
9661 dd->rcd[0]->rcvhdrqentsize));
9662
9663 /* Adjust maximum MTU for the port in DC */
9664 dcmtu = maxvlmtu == 10240 ? DCC_CFG_PORT_MTU_CAP_10240 :
9665 (ilog2(maxvlmtu >> 8) + 1);
9666 len1 = read_csr(ppd->dd, DCC_CFG_PORT_CONFIG);
9667 len1 &= ~DCC_CFG_PORT_CONFIG_MTU_CAP_SMASK;
9668 len1 |= ((u64)dcmtu & DCC_CFG_PORT_CONFIG_MTU_CAP_MASK) <<
9669 DCC_CFG_PORT_CONFIG_MTU_CAP_SHIFT;
9670 write_csr(ppd->dd, DCC_CFG_PORT_CONFIG, len1);
9671}
9672
9673static void set_lidlmc(struct hfi1_pportdata *ppd)
9674{
9675 int i;
9676 u64 sreg = 0;
9677 struct hfi1_devdata *dd = ppd->dd;
9678 u32 mask = ~((1U << ppd->lmc) - 1);
9679 u64 c1 = read_csr(ppd->dd, DCC_CFG_PORT_CONFIG1);
9680
9681 if (dd->hfi1_snoop.mode_flag)
9682 dd_dev_info(dd, "Set lid/lmc while snooping");
9683
9684 c1 &= ~(DCC_CFG_PORT_CONFIG1_TARGET_DLID_SMASK
9685 | DCC_CFG_PORT_CONFIG1_DLID_MASK_SMASK);
9686 c1 |= ((ppd->lid & DCC_CFG_PORT_CONFIG1_TARGET_DLID_MASK)
9687 << DCC_CFG_PORT_CONFIG1_TARGET_DLID_SHIFT)|
9688 ((mask & DCC_CFG_PORT_CONFIG1_DLID_MASK_MASK)
9689 << DCC_CFG_PORT_CONFIG1_DLID_MASK_SHIFT);
9690 write_csr(ppd->dd, DCC_CFG_PORT_CONFIG1, c1);
9691
9692 /*
9693 * Iterate over all the send contexts and set their SLID check
9694 */
9695 sreg = ((mask & SEND_CTXT_CHECK_SLID_MASK_MASK) <<
9696 SEND_CTXT_CHECK_SLID_MASK_SHIFT) |
9697 (((ppd->lid & mask) & SEND_CTXT_CHECK_SLID_VALUE_MASK) <<
9698 SEND_CTXT_CHECK_SLID_VALUE_SHIFT);
9699
9700 for (i = 0; i < dd->chip_send_contexts; i++) {
9701 hfi1_cdbg(LINKVERB, "SendContext[%d].SLID_CHECK = 0x%x",
9702 i, (u32)sreg);
9703 write_kctxt_csr(dd, i, SEND_CTXT_CHECK_SLID, sreg);
9704 }
9705
9706 /* Now we have to do the same thing for the sdma engines */
9707 sdma_update_lmc(dd, mask, ppd->lid);
9708}
9709
9710static int wait_phy_linkstate(struct hfi1_devdata *dd, u32 state, u32 msecs)
9711{
9712 unsigned long timeout;
9713 u32 curr_state;
9714
9715 timeout = jiffies + msecs_to_jiffies(msecs);
9716 while (1) {
9717 curr_state = read_physical_state(dd);
9718 if (curr_state == state)
9719 break;
9720 if (time_after(jiffies, timeout)) {
9721 dd_dev_err(dd,
9722 "timeout waiting for phy link state 0x%x, current state is 0x%x\n",
9723 state, curr_state);
9724 return -ETIMEDOUT;
9725 }
9726 usleep_range(1950, 2050); /* sleep 2ms-ish */
9727 }
9728
9729 return 0;
9730}
9731
9732/*
9733 * Helper for set_link_state(). Do not call except from that routine.
9734 * Expects ppd->hls_mutex to be held.
9735 *
9736 * @rem_reason value to be sent to the neighbor
9737 *
9738 * LinkDownReasons only set if transition succeeds.
9739 */
9740static int goto_offline(struct hfi1_pportdata *ppd, u8 rem_reason)
9741{
9742 struct hfi1_devdata *dd = ppd->dd;
9743 u32 pstate, previous_state;
9744 u32 last_local_state;
9745 u32 last_remote_state;
9746 int ret;
9747 int do_transition;
9748 int do_wait;
9749
9750 previous_state = ppd->host_link_state;
9751 ppd->host_link_state = HLS_GOING_OFFLINE;
9752 pstate = read_physical_state(dd);
9753 if (pstate == PLS_OFFLINE) {
9754 do_transition = 0; /* in right state */
9755 do_wait = 0; /* ...no need to wait */
9756 } else if ((pstate & 0xff) == PLS_OFFLINE) {
9757 do_transition = 0; /* in an offline transient state */
9758 do_wait = 1; /* ...wait for it to settle */
9759 } else {
9760 do_transition = 1; /* need to move to offline */
9761 do_wait = 1; /* ...will need to wait */
9762 }
9763
9764 if (do_transition) {
9765 ret = set_physical_link_state(dd,
9766 PLS_OFFLINE | (rem_reason << 8));
9767
9768 if (ret != HCMD_SUCCESS) {
9769 dd_dev_err(dd,
9770 "Failed to transition to Offline link state, return %d\n",
9771 ret);
9772 return -EINVAL;
9773 }
Bryan Morgana9c05e32016-02-03 14:30:49 -0800[diff] [blame]9774 if (ppd->offline_disabled_reason ==
9775 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_NONE))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9776 ppd->offline_disabled_reason =
Bryan Morgana9c05e32016-02-03 14:30:49 -0800[diff] [blame]9777 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_TRANSIENT);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9778 }
9779
9780 if (do_wait) {
9781 /* it can take a while for the link to go down */
Dean Luickdc060242015-10-26 10:28:29 -0400[diff] [blame]9782 ret = wait_phy_linkstate(dd, PLS_OFFLINE, 10000);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9783 if (ret < 0)
9784 return ret;
9785 }
9786
9787 /* make sure the logical state is also down */
9788 wait_logical_linkstate(ppd, IB_PORT_DOWN, 1000);
9789
9790 /*
9791 * Now in charge of LCB - must be after the physical state is
9792 * offline.quiet and before host_link_state is changed.
9793 */
9794 set_host_lcb_access(dd);
9795 write_csr(dd, DC_LCB_ERR_EN, ~0ull); /* watch LCB errors */
9796 ppd->host_link_state = HLS_LINK_COOLDOWN; /* LCB access allowed */
9797
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]9798 if (ppd->port_type == PORT_TYPE_QSFP &&
9799 ppd->qsfp_info.limiting_active &&
9800 qsfp_mod_present(ppd)) {
9801 set_qsfp_tx(ppd, 0);
9802 }
9803
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9804 /*
9805 * The LNI has a mandatory wait time after the physical state
9806 * moves to Offline.Quiet. The wait time may be different
9807 * depending on how the link went down. The 8051 firmware
9808 * will observe the needed wait time and only move to ready
9809 * when that is completed. The largest of the quiet timeouts
Dean Luick05087f3b2015-12-01 15:38:16 -0500[diff] [blame]9810 * is 6s, so wait that long and then at least 0.5s more for
9811 * other transitions, and another 0.5s for a buffer.
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9812 */
Dean Luick05087f3b2015-12-01 15:38:16 -0500[diff] [blame]9813 ret = wait_fm_ready(dd, 7000);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]9814 if (ret) {
9815 dd_dev_err(dd,
9816 "After going offline, timed out waiting for the 8051 to become ready to accept host requests\n");
9817 /* state is really offline, so make it so */
9818 ppd->host_link_state = HLS_DN_OFFLINE;
9819 return ret;
9820 }
9821
9822 /*
9823 * The state is now offline and the 8051 is ready to accept host
9824 * requests.
9825 * - change our state
9826 * - notify others if we were previously in a linkup state
9827 */
9828 ppd->host_link_state = HLS_DN_OFFLINE;
9829 if (previous_state & HLS_UP) {
9830 /* went down while link was up */
9831 handle_linkup_change(dd, 0);
9832 } else if (previous_state
9833 & (HLS_DN_POLL | HLS_VERIFY_CAP | HLS_GOING_UP)) {
9834 /* went down while attempting link up */
9835 /* byte 1 of last_*_state is the failure reason */
9836 read_last_local_state(dd, &last_local_state);
9837 read_last_remote_state(dd, &last_remote_state);
9838 dd_dev_err(dd,
9839 "LNI failure last states: local 0x%08x, remote 0x%08x\n",
9840 last_local_state, last_remote_state);
9841 }
9842
9843 /* the active link width (downgrade) is 0 on link down */
9844 ppd->link_width_active = 0;
9845 ppd->link_width_downgrade_tx_active = 0;
9846 ppd->link_width_downgrade_rx_active = 0;
9847 ppd->current_egress_rate = 0;
9848 return 0;
9849}
9850
9851/* return the link state name */
9852static const char *link_state_name(u32 state)
9853{
9854 const char *name;
9855 int n = ilog2(state);
9856 static const char * const names[] = {
9857 [__HLS_UP_INIT_BP] = "INIT",
9858 [__HLS_UP_ARMED_BP] = "ARMED",
9859 [__HLS_UP_ACTIVE_BP] = "ACTIVE",
9860 [__HLS_DN_DOWNDEF_BP] = "DOWNDEF",
9861 [__HLS_DN_POLL_BP] = "POLL",
9862 [__HLS_DN_DISABLE_BP] = "DISABLE",
9863 [__HLS_DN_OFFLINE_BP] = "OFFLINE",
9864 [__HLS_VERIFY_CAP_BP] = "VERIFY_CAP",
9865 [__HLS_GOING_UP_BP] = "GOING_UP",
9866 [__HLS_GOING_OFFLINE_BP] = "GOING_OFFLINE",
9867 [__HLS_LINK_COOLDOWN_BP] = "LINK_COOLDOWN"
9868 };
9869
9870 name = n < ARRAY_SIZE(names) ? names[n] : NULL;
9871 return name ? name : "unknown";
9872}
9873
9874/* return the link state reason name */
9875static const char *link_state_reason_name(struct hfi1_pportdata *ppd, u32 state)
9876{
9877 if (state == HLS_UP_INIT) {
9878 switch (ppd->linkinit_reason) {
9879 case OPA_LINKINIT_REASON_LINKUP:
9880 return "(LINKUP)";
9881 case OPA_LINKINIT_REASON_FLAPPING:
9882 return "(FLAPPING)";
9883 case OPA_LINKINIT_OUTSIDE_POLICY:
9884 return "(OUTSIDE_POLICY)";
9885 case OPA_LINKINIT_QUARANTINED:
9886 return "(QUARANTINED)";
9887 case OPA_LINKINIT_INSUFIC_CAPABILITY:
9888 return "(INSUFIC_CAPABILITY)";
9889 default:
9890 break;
9891 }
9892 }
9893 return "";
9894}
9895
9896/*
9897 * driver_physical_state - convert the driver's notion of a port's
9898 * state (an HLS_*) into a physical state (a {IB,OPA}_PORTPHYSSTATE_*).
9899 * Return -1 (converted to a u32) to indicate error.
9900 */
9901u32 driver_physical_state(struct hfi1_pportdata *ppd)
9902{
9903 switch (ppd->host_link_state) {
9904 case HLS_UP_INIT:
9905 case HLS_UP_ARMED:
9906 case HLS_UP_ACTIVE:
9907 return IB_PORTPHYSSTATE_LINKUP;
9908 case HLS_DN_POLL:
9909 return IB_PORTPHYSSTATE_POLLING;
9910 case HLS_DN_DISABLE:
9911 return IB_PORTPHYSSTATE_DISABLED;
9912 case HLS_DN_OFFLINE:
9913 return OPA_PORTPHYSSTATE_OFFLINE;
9914 case HLS_VERIFY_CAP:
9915 return IB_PORTPHYSSTATE_POLLING;
9916 case HLS_GOING_UP:
9917 return IB_PORTPHYSSTATE_POLLING;
9918 case HLS_GOING_OFFLINE:
9919 return OPA_PORTPHYSSTATE_OFFLINE;
9920 case HLS_LINK_COOLDOWN:
9921 return OPA_PORTPHYSSTATE_OFFLINE;
9922 case HLS_DN_DOWNDEF:
9923 default:
9924 dd_dev_err(ppd->dd, "invalid host_link_state 0x%x\n",
9925 ppd->host_link_state);
9926 return -1;
9927 }
9928}
9929
9930/*
9931 * driver_logical_state - convert the driver's notion of a port's
9932 * state (an HLS_*) into a logical state (a IB_PORT_*). Return -1
9933 * (converted to a u32) to indicate error.
9934 */
9935u32 driver_logical_state(struct hfi1_pportdata *ppd)
9936{
9937 if (ppd->host_link_state && !(ppd->host_link_state & HLS_UP))
9938 return IB_PORT_DOWN;
9939
9940 switch (ppd->host_link_state & HLS_UP) {
9941 case HLS_UP_INIT:
9942 return IB_PORT_INIT;
9943 case HLS_UP_ARMED:
9944 return IB_PORT_ARMED;
9945 case HLS_UP_ACTIVE:
9946 return IB_PORT_ACTIVE;
9947 default:
9948 dd_dev_err(ppd->dd, "invalid host_link_state 0x%x\n",
9949 ppd->host_link_state);
9950 return -1;
9951 }
9952}
9953
9954void set_link_down_reason(struct hfi1_pportdata *ppd, u8 lcl_reason,
9955 u8 neigh_reason, u8 rem_reason)
9956{
9957 if (ppd->local_link_down_reason.latest == 0 &&
9958 ppd->neigh_link_down_reason.latest == 0) {
9959 ppd->local_link_down_reason.latest = lcl_reason;
9960 ppd->neigh_link_down_reason.latest = neigh_reason;
9961 ppd->remote_link_down_reason = rem_reason;
9962 }
9963}
9964
9965/*
9966 * Change the physical and/or logical link state.
9967 *
9968 * Do not call this routine while inside an interrupt. It contains
9969 * calls to routines that can take multiple seconds to finish.
9970 *
9971 * Returns 0 on success, -errno on failure.
9972 */
9973int set_link_state(struct hfi1_pportdata *ppd, u32 state)
9974{
9975 struct hfi1_devdata *dd = ppd->dd;
9976 struct ib_event event = {.device = NULL};
9977 int ret1, ret = 0;
9978 int was_up, is_down;
9979 int orig_new_state, poll_bounce;
9980
9981 mutex_lock(&ppd->hls_lock);
9982
9983 orig_new_state = state;
9984 if (state == HLS_DN_DOWNDEF)
9985 state = dd->link_default;
9986
9987 /* interpret poll -> poll as a link bounce */
9988 poll_bounce = ppd->host_link_state == HLS_DN_POLL
9989 && state == HLS_DN_POLL;
9990
9991 dd_dev_info(dd, "%s: current %s, new %s %s%s\n", __func__,
9992 link_state_name(ppd->host_link_state),
9993 link_state_name(orig_new_state),
9994 poll_bounce ? "(bounce) " : "",
9995 link_state_reason_name(ppd, state));
9996
9997 was_up = !!(ppd->host_link_state & HLS_UP);
9998
9999 /*
10000 * If we're going to a (HLS_*) link state that implies the logical
10001 * link state is neither of (IB_PORT_ARMED, IB_PORT_ACTIVE), then
10002 * reset is_sm_config_started to 0.
10003 */
10004 if (!(state & (HLS_UP_ARMED | HLS_UP_ACTIVE)))
10005 ppd->is_sm_config_started = 0;
10006
10007 /*
10008 * Do nothing if the states match. Let a poll to poll link bounce
10009 * go through.
10010 */
10011 if (ppd->host_link_state == state && !poll_bounce)
10012 goto done;
10013
10014 switch (state) {
10015 case HLS_UP_INIT:
10016 if (ppd->host_link_state == HLS_DN_POLL && (quick_linkup
10017 || dd->icode == ICODE_FUNCTIONAL_SIMULATOR)) {
10018 /*
10019 * Quick link up jumps from polling to here.
10020 *
10021 * Whether in normal or loopback mode, the
10022 * simulator jumps from polling to link up.
10023 * Accept that here.
10024 */
10025 /* OK */;
10026 } else if (ppd->host_link_state != HLS_GOING_UP) {
10027 goto unexpected;
10028 }
10029
10030 ppd->host_link_state = HLS_UP_INIT;
10031 ret = wait_logical_linkstate(ppd, IB_PORT_INIT, 1000);
10032 if (ret) {
10033 /* logical state didn't change, stay at going_up */
10034 ppd->host_link_state = HLS_GOING_UP;
10035 dd_dev_err(dd,
10036 "%s: logical state did not change to INIT\n",
10037 __func__);
10038 } else {
10039 /* clear old transient LINKINIT_REASON code */
10040 if (ppd->linkinit_reason >= OPA_LINKINIT_REASON_CLEAR)
10041 ppd->linkinit_reason =
10042 OPA_LINKINIT_REASON_LINKUP;
10043
10044 /* enable the port */
10045 add_rcvctrl(dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
10046
10047 handle_linkup_change(dd, 1);
10048 }
10049 break;
10050 case HLS_UP_ARMED:
10051 if (ppd->host_link_state != HLS_UP_INIT)
10052 goto unexpected;
10053
10054 ppd->host_link_state = HLS_UP_ARMED;
10055 set_logical_state(dd, LSTATE_ARMED);
10056 ret = wait_logical_linkstate(ppd, IB_PORT_ARMED, 1000);
10057 if (ret) {
10058 /* logical state didn't change, stay at init */
10059 ppd->host_link_state = HLS_UP_INIT;
10060 dd_dev_err(dd,
10061 "%s: logical state did not change to ARMED\n",
10062 __func__);
10063 }
10064 /*
10065 * The simulator does not currently implement SMA messages,
10066 * so neighbor_normal is not set. Set it here when we first
10067 * move to Armed.
10068 */
10069 if (dd->icode == ICODE_FUNCTIONAL_SIMULATOR)
10070 ppd->neighbor_normal = 1;
10071 break;
10072 case HLS_UP_ACTIVE:
10073 if (ppd->host_link_state != HLS_UP_ARMED)
10074 goto unexpected;
10075
10076 ppd->host_link_state = HLS_UP_ACTIVE;
10077 set_logical_state(dd, LSTATE_ACTIVE);
10078 ret = wait_logical_linkstate(ppd, IB_PORT_ACTIVE, 1000);
10079 if (ret) {
10080 /* logical state didn't change, stay at armed */
10081 ppd->host_link_state = HLS_UP_ARMED;
10082 dd_dev_err(dd,
10083 "%s: logical state did not change to ACTIVE\n",
10084 __func__);
10085 } else {
10086
10087 /* tell all engines to go running */
10088 sdma_all_running(dd);
10089
10090 /* Signal the IB layer that the port has went active */
Dennis Dalessandroec3f2c12016-01-19 14:41:33 -0800[diff] [blame]10091 event.device = &dd->verbs_dev.rdi.ibdev;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]10092 event.element.port_num = ppd->port;
10093 event.event = IB_EVENT_PORT_ACTIVE;
10094 }
10095 break;
10096 case HLS_DN_POLL:
10097 if ((ppd->host_link_state == HLS_DN_DISABLE ||
10098 ppd->host_link_state == HLS_DN_OFFLINE) &&
10099 dd->dc_shutdown)
10100 dc_start(dd);
10101 /* Hand LED control to the DC */
10102 write_csr(dd, DCC_CFG_LED_CNTRL, 0);
10103
10104 if (ppd->host_link_state != HLS_DN_OFFLINE) {
10105 u8 tmp = ppd->link_enabled;
10106
10107 ret = goto_offline(ppd, ppd->remote_link_down_reason);
10108 if (ret) {
10109 ppd->link_enabled = tmp;
10110 break;
10111 }
10112 ppd->remote_link_down_reason = 0;
10113
10114 if (ppd->driver_link_ready)
10115 ppd->link_enabled = 1;
10116 }
10117
Jim Snowfb9036d2016-01-11 18:32:21 -0500[diff] [blame]10118 set_all_slowpath(ppd->dd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]10119 ret = set_local_link_attributes(ppd);
10120 if (ret)
10121 break;
10122
10123 ppd->port_error_action = 0;
10124 ppd->host_link_state = HLS_DN_POLL;
10125
10126 if (quick_linkup) {
10127 /* quick linkup does not go into polling */
10128 ret = do_quick_linkup(dd);
10129 } else {
10130 ret1 = set_physical_link_state(dd, PLS_POLLING);
10131 if (ret1 != HCMD_SUCCESS) {
10132 dd_dev_err(dd,
10133 "Failed to transition to Polling link state, return 0x%x\n",
10134 ret1);
10135 ret = -EINVAL;
10136 }
10137 }
Bryan Morgana9c05e32016-02-03 14:30:49 -0800[diff] [blame]10138 ppd->offline_disabled_reason =
10139 HFI1_ODR_MASK(OPA_LINKDOWN_REASON_NONE);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]10140 /*
10141 * If an error occurred above, go back to offline. The
10142 * caller may reschedule another attempt.
10143 */
10144 if (ret)
10145 goto_offline(ppd, 0);
10146 break;
10147 case HLS_DN_DISABLE:
10148 /* link is disabled */
10149 ppd->link_enabled = 0;
10150
10151 /* allow any state to transition to disabled */
10152
10153 /* must transition to offline first */
10154 if (ppd->host_link_state != HLS_DN_OFFLINE) {
10155 ret = goto_offline(ppd, ppd->remote_link_down_reason);
10156 if (ret)
10157 break;
10158 ppd->remote_link_down_reason = 0;
10159 }
10160
10161 ret1 = set_physical_link_state(dd, PLS_DISABLED);
10162 if (ret1 != HCMD_SUCCESS) {
10163 dd_dev_err(dd,
10164 "Failed to transition to Disabled link state, return 0x%x\n",
10165 ret1);
10166 ret = -EINVAL;
10167 break;
10168 }
10169 ppd->host_link_state = HLS_DN_DISABLE;
10170 dc_shutdown(dd);
10171 break;
10172 case HLS_DN_OFFLINE:
10173 if (ppd->host_link_state == HLS_DN_DISABLE)
10174 dc_start(dd);
10175
10176 /* allow any state to transition to offline */
10177 ret = goto_offline(ppd, ppd->remote_link_down_reason);
10178 if (!ret)
10179 ppd->remote_link_down_reason = 0;
10180 break;
10181 case HLS_VERIFY_CAP:
10182 if (ppd->host_link_state != HLS_DN_POLL)
10183 goto unexpected;
10184 ppd->host_link_state = HLS_VERIFY_CAP;
10185 break;
10186 case HLS_GOING_UP:
10187 if (ppd->host_link_state != HLS_VERIFY_CAP)
10188 goto unexpected;
10189
10190 ret1 = set_physical_link_state(dd, PLS_LINKUP);
10191 if (ret1 != HCMD_SUCCESS) {
10192 dd_dev_err(dd,
10193 "Failed to transition to link up state, return 0x%x\n",
10194 ret1);
10195 ret = -EINVAL;
10196 break;
10197 }
10198 ppd->host_link_state = HLS_GOING_UP;
10199 break;
10200
10201 case HLS_GOING_OFFLINE: /* transient within goto_offline() */
10202 case HLS_LINK_COOLDOWN: /* transient within goto_offline() */
10203 default:
10204 dd_dev_info(dd, "%s: state 0x%x: not supported\n",
10205 __func__, state);
10206 ret = -EINVAL;
10207 break;
10208 }
10209
10210 is_down = !!(ppd->host_link_state & (HLS_DN_POLL |
10211 HLS_DN_DISABLE | HLS_DN_OFFLINE));
10212
10213 if (was_up && is_down && ppd->local_link_down_reason.sma == 0 &&
10214 ppd->neigh_link_down_reason.sma == 0) {
10215 ppd->local_link_down_reason.sma =
10216 ppd->local_link_down_reason.latest;
10217 ppd->neigh_link_down_reason.sma =
10218 ppd->neigh_link_down_reason.latest;
10219 }
10220
10221 goto done;
10222
10223unexpected:
10224 dd_dev_err(dd, "%s: unexpected state transition from %s to %s\n",
10225 __func__, link_state_name(ppd->host_link_state),
10226 link_state_name(state));
10227 ret = -EINVAL;
10228
10229done:
10230 mutex_unlock(&ppd->hls_lock);
10231
10232 if (event.device)
10233 ib_dispatch_event(&event);
10234
10235 return ret;
10236}
10237
10238int hfi1_set_ib_cfg(struct hfi1_pportdata *ppd, int which, u32 val)
10239{
10240 u64 reg;
10241 int ret = 0;
10242
10243 switch (which) {
10244 case HFI1_IB_CFG_LIDLMC:
10245 set_lidlmc(ppd);
10246 break;
10247 case HFI1_IB_CFG_VL_HIGH_LIMIT:
10248 /*
10249 * The VL Arbitrator high limit is sent in units of 4k
10250 * bytes, while HFI stores it in units of 64 bytes.
10251 */
10252 val *= 4096/64;
10253 reg = ((u64)val & SEND_HIGH_PRIORITY_LIMIT_LIMIT_MASK)
10254 << SEND_HIGH_PRIORITY_LIMIT_LIMIT_SHIFT;
10255 write_csr(ppd->dd, SEND_HIGH_PRIORITY_LIMIT, reg);
10256 break;
10257 case HFI1_IB_CFG_LINKDEFAULT: /* IB link default (sleep/poll) */
10258 /* HFI only supports POLL as the default link down state */
10259 if (val != HLS_DN_POLL)
10260 ret = -EINVAL;
10261 break;
10262 case HFI1_IB_CFG_OP_VLS:
10263 if (ppd->vls_operational != val) {
10264 ppd->vls_operational = val;
10265 if (!ppd->port)
10266 ret = -EINVAL;
10267 else
10268 ret = sdma_map_init(
10269 ppd->dd,
10270 ppd->port - 1,
10271 val,
10272 NULL);
10273 }
10274 break;
10275 /*
10276 * For link width, link width downgrade, and speed enable, always AND
10277 * the setting with what is actually supported. This has two benefits.
10278 * First, enabled can't have unsupported values, no matter what the
10279 * SM or FM might want. Second, the ALL_SUPPORTED wildcards that mean
10280 * "fill in with your supported value" have all the bits in the
10281 * field set, so simply ANDing with supported has the desired result.
10282 */
10283 case HFI1_IB_CFG_LWID_ENB: /* set allowed Link-width */
10284 ppd->link_width_enabled = val & ppd->link_width_supported;
10285 break;
10286 case HFI1_IB_CFG_LWID_DG_ENB: /* set allowed link width downgrade */
10287 ppd->link_width_downgrade_enabled =
10288 val & ppd->link_width_downgrade_supported;
10289 break;
10290 case HFI1_IB_CFG_SPD_ENB: /* allowed Link speeds */
10291 ppd->link_speed_enabled = val & ppd->link_speed_supported;
10292 break;
10293 case HFI1_IB_CFG_OVERRUN_THRESH: /* IB overrun threshold */
10294 /*
10295 * HFI does not follow IB specs, save this value
10296 * so we can report it, if asked.
10297 */
10298 ppd->overrun_threshold = val;
10299 break;
10300 case HFI1_IB_CFG_PHYERR_THRESH: /* IB PHY error threshold */
10301 /*
10302 * HFI does not follow IB specs, save this value
10303 * so we can report it, if asked.
10304 */
10305 ppd->phy_error_threshold = val;
10306 break;
10307
10308 case HFI1_IB_CFG_MTU:
10309 set_send_length(ppd);
10310 break;
10311
10312 case HFI1_IB_CFG_PKEYS:
10313 if (HFI1_CAP_IS_KSET(PKEY_CHECK))
10314 set_partition_keys(ppd);
10315 break;
10316
10317 default:
10318 if (HFI1_CAP_IS_KSET(PRINT_UNIMPL))
10319 dd_dev_info(ppd->dd,
10320 "%s: which %s, val 0x%x: not implemented\n",
10321 __func__, ib_cfg_name(which), val);
10322 break;
10323 }
10324 return ret;
10325}
10326
10327/* begin functions related to vl arbitration table caching */
10328static void init_vl_arb_caches(struct hfi1_pportdata *ppd)
10329{
10330 int i;
10331
10332 BUILD_BUG_ON(VL_ARB_TABLE_SIZE !=
10333 VL_ARB_LOW_PRIO_TABLE_SIZE);
10334 BUILD_BUG_ON(VL_ARB_TABLE_SIZE !=
10335 VL_ARB_HIGH_PRIO_TABLE_SIZE);
10336
10337 /*
10338 * Note that we always return values directly from the
10339 * 'vl_arb_cache' (and do no CSR reads) in response to a
10340 * 'Get(VLArbTable)'. This is obviously correct after a
10341 * 'Set(VLArbTable)', since the cache will then be up to
10342 * date. But it's also correct prior to any 'Set(VLArbTable)'
10343 * since then both the cache, and the relevant h/w registers
10344 * will be zeroed.
10345 */
10346
10347 for (i = 0; i < MAX_PRIO_TABLE; i++)
10348 spin_lock_init(&ppd->vl_arb_cache[i].lock);
10349}
10350
10351/*
10352 * vl_arb_lock_cache
10353 *
10354 * All other vl_arb_* functions should be called only after locking
10355 * the cache.
10356 */
10357static inline struct vl_arb_cache *
10358vl_arb_lock_cache(struct hfi1_pportdata *ppd, int idx)
10359{
10360 if (idx != LO_PRIO_TABLE && idx != HI_PRIO_TABLE)
10361 return NULL;
10362 spin_lock(&ppd->vl_arb_cache[idx].lock);
10363 return &ppd->vl_arb_cache[idx];
10364}
10365
10366static inline void vl_arb_unlock_cache(struct hfi1_pportdata *ppd, int idx)
10367{
10368 spin_unlock(&ppd->vl_arb_cache[idx].lock);
10369}
10370
10371static void vl_arb_get_cache(struct vl_arb_cache *cache,
10372 struct ib_vl_weight_elem *vl)
10373{
10374 memcpy(vl, cache->table, VL_ARB_TABLE_SIZE * sizeof(*vl));
10375}
10376
10377static void vl_arb_set_cache(struct vl_arb_cache *cache,
10378 struct ib_vl_weight_elem *vl)
10379{
10380 memcpy(cache->table, vl, VL_ARB_TABLE_SIZE * sizeof(*vl));
10381}
10382
10383static int vl_arb_match_cache(struct vl_arb_cache *cache,
10384 struct ib_vl_weight_elem *vl)
10385{
10386 return !memcmp(cache->table, vl, VL_ARB_TABLE_SIZE * sizeof(*vl));
10387}
10388/* end functions related to vl arbitration table caching */
10389
10390static int set_vl_weights(struct hfi1_pportdata *ppd, u32 target,
10391 u32 size, struct ib_vl_weight_elem *vl)
10392{
10393 struct hfi1_devdata *dd = ppd->dd;
10394 u64 reg;
10395 unsigned int i, is_up = 0;
10396 int drain, ret = 0;
10397
10398 mutex_lock(&ppd->hls_lock);
10399
10400 if (ppd->host_link_state & HLS_UP)
10401 is_up = 1;
10402
10403 drain = !is_ax(dd) && is_up;
10404
10405 if (drain)
10406 /*
10407 * Before adjusting VL arbitration weights, empty per-VL
10408 * FIFOs, otherwise a packet whose VL weight is being
10409 * set to 0 could get stuck in a FIFO with no chance to
10410 * egress.
10411 */
10412 ret = stop_drain_data_vls(dd);
10413
10414 if (ret) {
10415 dd_dev_err(
10416 dd,
10417 "%s: cannot stop/drain VLs - refusing to change VL arbitration weights\n",
10418 __func__);
10419 goto err;
10420 }
10421
10422 for (i = 0; i < size; i++, vl++) {
10423 /*
10424 * NOTE: The low priority shift and mask are used here, but
10425 * they are the same for both the low and high registers.
10426 */
10427 reg = (((u64)vl->vl & SEND_LOW_PRIORITY_LIST_VL_MASK)
10428 << SEND_LOW_PRIORITY_LIST_VL_SHIFT)
10429 | (((u64)vl->weight
10430 & SEND_LOW_PRIORITY_LIST_WEIGHT_MASK)
10431 << SEND_LOW_PRIORITY_LIST_WEIGHT_SHIFT);
10432 write_csr(dd, target + (i * 8), reg);
10433 }
10434 pio_send_control(dd, PSC_GLOBAL_VLARB_ENABLE);
10435
10436 if (drain)
10437 open_fill_data_vls(dd); /* reopen all VLs */
10438
10439err:
10440 mutex_unlock(&ppd->hls_lock);
10441
10442 return ret;
10443}
10444
10445/*
10446 * Read one credit merge VL register.
10447 */
10448static void read_one_cm_vl(struct hfi1_devdata *dd, u32 csr,
10449 struct vl_limit *vll)
10450{
10451 u64 reg = read_csr(dd, csr);
10452
10453 vll->dedicated = cpu_to_be16(
10454 (reg >> SEND_CM_CREDIT_VL_DEDICATED_LIMIT_VL_SHIFT)
10455 & SEND_CM_CREDIT_VL_DEDICATED_LIMIT_VL_MASK);
10456 vll->shared = cpu_to_be16(
10457 (reg >> SEND_CM_CREDIT_VL_SHARED_LIMIT_VL_SHIFT)
10458 & SEND_CM_CREDIT_VL_SHARED_LIMIT_VL_MASK);
10459}
10460
10461/*
10462 * Read the current credit merge limits.
10463 */
10464static int get_buffer_control(struct hfi1_devdata *dd,
10465 struct buffer_control *bc, u16 *overall_limit)
10466{
10467 u64 reg;
10468 int i;
10469
10470 /* not all entries are filled in */
10471 memset(bc, 0, sizeof(*bc));
10472
10473 /* OPA and HFI have a 1-1 mapping */
10474 for (i = 0; i < TXE_NUM_DATA_VL; i++)
10475 read_one_cm_vl(dd, SEND_CM_CREDIT_VL + (8*i), &bc->vl[i]);
10476
10477 /* NOTE: assumes that VL* and VL15 CSRs are bit-wise identical */
10478 read_one_cm_vl(dd, SEND_CM_CREDIT_VL15, &bc->vl[15]);
10479
10480 reg = read_csr(dd, SEND_CM_GLOBAL_CREDIT);
10481 bc->overall_shared_limit = cpu_to_be16(
10482 (reg >> SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT)
10483 & SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_MASK);
10484 if (overall_limit)
10485 *overall_limit = (reg
10486 >> SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT)
10487 & SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_MASK;
10488 return sizeof(struct buffer_control);
10489}
10490
10491static int get_sc2vlnt(struct hfi1_devdata *dd, struct sc2vlnt *dp)
10492{
10493 u64 reg;
10494 int i;
10495
10496 /* each register contains 16 SC->VLnt mappings, 4 bits each */
10497 reg = read_csr(dd, DCC_CFG_SC_VL_TABLE_15_0);
10498 for (i = 0; i < sizeof(u64); i++) {
10499 u8 byte = *(((u8 *)&reg) + i);
10500
10501 dp->vlnt[2 * i] = byte & 0xf;
10502 dp->vlnt[(2 * i) + 1] = (byte & 0xf0) >> 4;
10503 }
10504
10505 reg = read_csr(dd, DCC_CFG_SC_VL_TABLE_31_16);
10506 for (i = 0; i < sizeof(u64); i++) {
10507 u8 byte = *(((u8 *)&reg) + i);
10508
10509 dp->vlnt[16 + (2 * i)] = byte & 0xf;
10510 dp->vlnt[16 + (2 * i) + 1] = (byte & 0xf0) >> 4;
10511 }
10512 return sizeof(struct sc2vlnt);
10513}
10514
10515static void get_vlarb_preempt(struct hfi1_devdata *dd, u32 nelems,
10516 struct ib_vl_weight_elem *vl)
10517{
10518 unsigned int i;
10519
10520 for (i = 0; i < nelems; i++, vl++) {
10521 vl->vl = 0xf;
10522 vl->weight = 0;
10523 }
10524}
10525
10526static void set_sc2vlnt(struct hfi1_devdata *dd, struct sc2vlnt *dp)
10527{
10528 write_csr(dd, DCC_CFG_SC_VL_TABLE_15_0,
10529 DC_SC_VL_VAL(15_0,
10530 0, dp->vlnt[0] & 0xf,
10531 1, dp->vlnt[1] & 0xf,
10532 2, dp->vlnt[2] & 0xf,
10533 3, dp->vlnt[3] & 0xf,
10534 4, dp->vlnt[4] & 0xf,
10535 5, dp->vlnt[5] & 0xf,
10536 6, dp->vlnt[6] & 0xf,
10537 7, dp->vlnt[7] & 0xf,
10538 8, dp->vlnt[8] & 0xf,
10539 9, dp->vlnt[9] & 0xf,
10540 10, dp->vlnt[10] & 0xf,
10541 11, dp->vlnt[11] & 0xf,
10542 12, dp->vlnt[12] & 0xf,
10543 13, dp->vlnt[13] & 0xf,
10544 14, dp->vlnt[14] & 0xf,
10545 15, dp->vlnt[15] & 0xf));
10546 write_csr(dd, DCC_CFG_SC_VL_TABLE_31_16,
10547 DC_SC_VL_VAL(31_16,
10548 16, dp->vlnt[16] & 0xf,
10549 17, dp->vlnt[17] & 0xf,
10550 18, dp->vlnt[18] & 0xf,
10551 19, dp->vlnt[19] & 0xf,
10552 20, dp->vlnt[20] & 0xf,
10553 21, dp->vlnt[21] & 0xf,
10554 22, dp->vlnt[22] & 0xf,
10555 23, dp->vlnt[23] & 0xf,
10556 24, dp->vlnt[24] & 0xf,
10557 25, dp->vlnt[25] & 0xf,
10558 26, dp->vlnt[26] & 0xf,
10559 27, dp->vlnt[27] & 0xf,
10560 28, dp->vlnt[28] & 0xf,
10561 29, dp->vlnt[29] & 0xf,
10562 30, dp->vlnt[30] & 0xf,
10563 31, dp->vlnt[31] & 0xf));
10564}
10565
10566static void nonzero_msg(struct hfi1_devdata *dd, int idx, const char *what,
10567 u16 limit)
10568{
10569 if (limit != 0)
10570 dd_dev_info(dd, "Invalid %s limit %d on VL %d, ignoring\n",
10571 what, (int)limit, idx);
10572}
10573
10574/* change only the shared limit portion of SendCmGLobalCredit */
10575static void set_global_shared(struct hfi1_devdata *dd, u16 limit)
10576{
10577 u64 reg;
10578
10579 reg = read_csr(dd, SEND_CM_GLOBAL_CREDIT);
10580 reg &= ~SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SMASK;
10581 reg |= (u64)limit << SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT;
10582 write_csr(dd, SEND_CM_GLOBAL_CREDIT, reg);
10583}
10584
10585/* change only the total credit limit portion of SendCmGLobalCredit */
10586static void set_global_limit(struct hfi1_devdata *dd, u16 limit)
10587{
10588 u64 reg;
10589
10590 reg = read_csr(dd, SEND_CM_GLOBAL_CREDIT);
10591 reg &= ~SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SMASK;
10592 reg |= (u64)limit << SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT;
10593 write_csr(dd, SEND_CM_GLOBAL_CREDIT, reg);
10594}
10595
10596/* set the given per-VL shared limit */
10597static void set_vl_shared(struct hfi1_devdata *dd, int vl, u16 limit)
10598{
10599 u64 reg;
10600 u32 addr;
10601
10602 if (vl < TXE_NUM_DATA_VL)
10603 addr = SEND_CM_CREDIT_VL + (8 * vl);
10604 else
10605 addr = SEND_CM_CREDIT_VL15;
10606
10607 reg = read_csr(dd, addr);
10608 reg &= ~SEND_CM_CREDIT_VL_SHARED_LIMIT_VL_SMASK;
10609 reg |= (u64)limit << SEND_CM_CREDIT_VL_SHARED_LIMIT_VL_SHIFT;
10610 write_csr(dd, addr, reg);
10611}
10612
10613/* set the given per-VL dedicated limit */
10614static void set_vl_dedicated(struct hfi1_devdata *dd, int vl, u16 limit)
10615{
10616 u64 reg;
10617 u32 addr;
10618
10619 if (vl < TXE_NUM_DATA_VL)
10620 addr = SEND_CM_CREDIT_VL + (8 * vl);
10621 else
10622 addr = SEND_CM_CREDIT_VL15;
10623
10624 reg = read_csr(dd, addr);
10625 reg &= ~SEND_CM_CREDIT_VL_DEDICATED_LIMIT_VL_SMASK;
10626 reg |= (u64)limit << SEND_CM_CREDIT_VL_DEDICATED_LIMIT_VL_SHIFT;
10627 write_csr(dd, addr, reg);
10628}
10629
10630/* spin until the given per-VL status mask bits clear */
10631static void wait_for_vl_status_clear(struct hfi1_devdata *dd, u64 mask,
10632 const char *which)
10633{
10634 unsigned long timeout;
10635 u64 reg;
10636
10637 timeout = jiffies + msecs_to_jiffies(VL_STATUS_CLEAR_TIMEOUT);
10638 while (1) {
10639 reg = read_csr(dd, SEND_CM_CREDIT_USED_STATUS) & mask;
10640
10641 if (reg == 0)
10642 return; /* success */
10643 if (time_after(jiffies, timeout))
10644 break; /* timed out */
10645 udelay(1);
10646 }
10647
10648 dd_dev_err(dd,
10649 "%s credit change status not clearing after %dms, mask 0x%llx, not clear 0x%llx\n",
10650 which, VL_STATUS_CLEAR_TIMEOUT, mask, reg);
10651 /*
10652 * If this occurs, it is likely there was a credit loss on the link.
10653 * The only recovery from that is a link bounce.
10654 */
10655 dd_dev_err(dd,
10656 "Continuing anyway. A credit loss may occur. Suggest a link bounce\n");
10657}
10658
10659/*
10660 * The number of credits on the VLs may be changed while everything
10661 * is "live", but the following algorithm must be followed due to
10662 * how the hardware is actually implemented. In particular,
10663 * Return_Credit_Status[] is the only correct status check.
10664 *
10665 * if (reducing Global_Shared_Credit_Limit or any shared limit changing)
10666 * set Global_Shared_Credit_Limit = 0
10667 * use_all_vl = 1
10668 * mask0 = all VLs that are changing either dedicated or shared limits
10669 * set Shared_Limit[mask0] = 0
10670 * spin until Return_Credit_Status[use_all_vl ? all VL : mask0] == 0
10671 * if (changing any dedicated limit)
10672 * mask1 = all VLs that are lowering dedicated limits
10673 * lower Dedicated_Limit[mask1]
10674 * spin until Return_Credit_Status[mask1] == 0
10675 * raise Dedicated_Limits
10676 * raise Shared_Limits
10677 * raise Global_Shared_Credit_Limit
10678 *
10679 * lower = if the new limit is lower, set the limit to the new value
10680 * raise = if the new limit is higher than the current value (may be changed
10681 * earlier in the algorithm), set the new limit to the new value
10682 */
10683static int set_buffer_control(struct hfi1_devdata *dd,
10684 struct buffer_control *new_bc)
10685{
10686 u64 changing_mask, ld_mask, stat_mask;
10687 int change_count;
10688 int i, use_all_mask;
10689 int this_shared_changing;
10690 /*
10691 * A0: add the variable any_shared_limit_changing below and in the
10692 * algorithm above. If removing A0 support, it can be removed.
10693 */
10694 int any_shared_limit_changing;
10695 struct buffer_control cur_bc;
10696 u8 changing[OPA_MAX_VLS];
10697 u8 lowering_dedicated[OPA_MAX_VLS];
10698 u16 cur_total;
10699 u32 new_total = 0;
10700 const u64 all_mask =
10701 SEND_CM_CREDIT_USED_STATUS_VL0_RETURN_CREDIT_STATUS_SMASK
10702 | SEND_CM_CREDIT_USED_STATUS_VL1_RETURN_CREDIT_STATUS_SMASK
10703 | SEND_CM_CREDIT_USED_STATUS_VL2_RETURN_CREDIT_STATUS_SMASK
10704 | SEND_CM_CREDIT_USED_STATUS_VL3_RETURN_CREDIT_STATUS_SMASK
10705 | SEND_CM_CREDIT_USED_STATUS_VL4_RETURN_CREDIT_STATUS_SMASK
10706 | SEND_CM_CREDIT_USED_STATUS_VL5_RETURN_CREDIT_STATUS_SMASK
10707 | SEND_CM_CREDIT_USED_STATUS_VL6_RETURN_CREDIT_STATUS_SMASK
10708 | SEND_CM_CREDIT_USED_STATUS_VL7_RETURN_CREDIT_STATUS_SMASK
10709 | SEND_CM_CREDIT_USED_STATUS_VL15_RETURN_CREDIT_STATUS_SMASK;
10710
10711#define valid_vl(idx) ((idx) < TXE_NUM_DATA_VL || (idx) == 15)
10712#define NUM_USABLE_VLS 16 /* look at VL15 and less */
10713
10714
10715 /* find the new total credits, do sanity check on unused VLs */
10716 for (i = 0; i < OPA_MAX_VLS; i++) {
10717 if (valid_vl(i)) {
10718 new_total += be16_to_cpu(new_bc->vl[i].dedicated);
10719 continue;
10720 }
10721 nonzero_msg(dd, i, "dedicated",
10722 be16_to_cpu(new_bc->vl[i].dedicated));
10723 nonzero_msg(dd, i, "shared",
10724 be16_to_cpu(new_bc->vl[i].shared));
10725 new_bc->vl[i].dedicated = 0;
10726 new_bc->vl[i].shared = 0;
10727 }
10728 new_total += be16_to_cpu(new_bc->overall_shared_limit);
Dean Luickbff14bb2015-12-17 19:24:13 -0500[diff] [blame]10729
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]10730 /* fetch the current values */
10731 get_buffer_control(dd, &cur_bc, &cur_total);
10732
10733 /*
10734 * Create the masks we will use.
10735 */
10736 memset(changing, 0, sizeof(changing));
10737 memset(lowering_dedicated, 0, sizeof(lowering_dedicated));
10738 /* NOTE: Assumes that the individual VL bits are adjacent and in
10739 increasing order */
10740 stat_mask =
10741 SEND_CM_CREDIT_USED_STATUS_VL0_RETURN_CREDIT_STATUS_SMASK;
10742 changing_mask = 0;
10743 ld_mask = 0;
10744 change_count = 0;
10745 any_shared_limit_changing = 0;
10746 for (i = 0; i < NUM_USABLE_VLS; i++, stat_mask <<= 1) {
10747 if (!valid_vl(i))
10748 continue;
10749 this_shared_changing = new_bc->vl[i].shared
10750 != cur_bc.vl[i].shared;
10751 if (this_shared_changing)
10752 any_shared_limit_changing = 1;
10753 if (new_bc->vl[i].dedicated != cur_bc.vl[i].dedicated
10754 || this_shared_changing) {
10755 changing[i] = 1;
10756 changing_mask |= stat_mask;
10757 change_count++;
10758 }
10759 if (be16_to_cpu(new_bc->vl[i].dedicated) <
10760 be16_to_cpu(cur_bc.vl[i].dedicated)) {
10761 lowering_dedicated[i] = 1;
10762 ld_mask |= stat_mask;
10763 }
10764 }
10765
10766 /* bracket the credit change with a total adjustment */
10767 if (new_total > cur_total)
10768 set_global_limit(dd, new_total);
10769
10770 /*
10771 * Start the credit change algorithm.
10772 */
10773 use_all_mask = 0;
10774 if ((be16_to_cpu(new_bc->overall_shared_limit) <
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]10775 be16_to_cpu(cur_bc.overall_shared_limit)) ||
10776 (is_ax(dd) && any_shared_limit_changing)) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]10777 set_global_shared(dd, 0);
10778 cur_bc.overall_shared_limit = 0;
10779 use_all_mask = 1;
10780 }
10781
10782 for (i = 0; i < NUM_USABLE_VLS; i++) {
10783 if (!valid_vl(i))
10784 continue;
10785
10786 if (changing[i]) {
10787 set_vl_shared(dd, i, 0);
10788 cur_bc.vl[i].shared = 0;
10789 }
10790 }
10791
10792 wait_for_vl_status_clear(dd, use_all_mask ? all_mask : changing_mask,
10793 "shared");
10794
10795 if (change_count > 0) {
10796 for (i = 0; i < NUM_USABLE_VLS; i++) {
10797 if (!valid_vl(i))
10798 continue;
10799
10800 if (lowering_dedicated[i]) {
10801 set_vl_dedicated(dd, i,
10802 be16_to_cpu(new_bc->vl[i].dedicated));
10803 cur_bc.vl[i].dedicated =
10804 new_bc->vl[i].dedicated;
10805 }
10806 }
10807
10808 wait_for_vl_status_clear(dd, ld_mask, "dedicated");
10809
10810 /* now raise all dedicated that are going up */
10811 for (i = 0; i < NUM_USABLE_VLS; i++) {
10812 if (!valid_vl(i))
10813 continue;
10814
10815 if (be16_to_cpu(new_bc->vl[i].dedicated) >
10816 be16_to_cpu(cur_bc.vl[i].dedicated))
10817 set_vl_dedicated(dd, i,
10818 be16_to_cpu(new_bc->vl[i].dedicated));
10819 }
10820 }
10821
10822 /* next raise all shared that are going up */
10823 for (i = 0; i < NUM_USABLE_VLS; i++) {
10824 if (!valid_vl(i))
10825 continue;
10826
10827 if (be16_to_cpu(new_bc->vl[i].shared) >
10828 be16_to_cpu(cur_bc.vl[i].shared))
10829 set_vl_shared(dd, i, be16_to_cpu(new_bc->vl[i].shared));
10830 }
10831
10832 /* finally raise the global shared */
10833 if (be16_to_cpu(new_bc->overall_shared_limit) >
10834 be16_to_cpu(cur_bc.overall_shared_limit))
10835 set_global_shared(dd,
10836 be16_to_cpu(new_bc->overall_shared_limit));
10837
10838 /* bracket the credit change with a total adjustment */
10839 if (new_total < cur_total)
10840 set_global_limit(dd, new_total);
10841 return 0;
10842}
10843
10844/*
10845 * Read the given fabric manager table. Return the size of the
10846 * table (in bytes) on success, and a negative error code on
10847 * failure.
10848 */
10849int fm_get_table(struct hfi1_pportdata *ppd, int which, void *t)
10850
10851{
10852 int size;
10853 struct vl_arb_cache *vlc;
10854
10855 switch (which) {
10856 case FM_TBL_VL_HIGH_ARB:
10857 size = 256;
10858 /*
10859 * OPA specifies 128 elements (of 2 bytes each), though
10860 * HFI supports only 16 elements in h/w.
10861 */
10862 vlc = vl_arb_lock_cache(ppd, HI_PRIO_TABLE);
10863 vl_arb_get_cache(vlc, t);
10864 vl_arb_unlock_cache(ppd, HI_PRIO_TABLE);
10865 break;
10866 case FM_TBL_VL_LOW_ARB:
10867 size = 256;
10868 /*
10869 * OPA specifies 128 elements (of 2 bytes each), though
10870 * HFI supports only 16 elements in h/w.
10871 */
10872 vlc = vl_arb_lock_cache(ppd, LO_PRIO_TABLE);
10873 vl_arb_get_cache(vlc, t);
10874 vl_arb_unlock_cache(ppd, LO_PRIO_TABLE);
10875 break;
10876 case FM_TBL_BUFFER_CONTROL:
10877 size = get_buffer_control(ppd->dd, t, NULL);
10878 break;
10879 case FM_TBL_SC2VLNT:
10880 size = get_sc2vlnt(ppd->dd, t);
10881 break;
10882 case FM_TBL_VL_PREEMPT_ELEMS:
10883 size = 256;
10884 /* OPA specifies 128 elements, of 2 bytes each */
10885 get_vlarb_preempt(ppd->dd, OPA_MAX_VLS, t);
10886 break;
10887 case FM_TBL_VL_PREEMPT_MATRIX:
10888 size = 256;
10889 /*
10890 * OPA specifies that this is the same size as the VL
10891 * arbitration tables (i.e., 256 bytes).
10892 */
10893 break;
10894 default:
10895 return -EINVAL;
10896 }
10897 return size;
10898}
10899
10900/*
10901 * Write the given fabric manager table.
10902 */
10903int fm_set_table(struct hfi1_pportdata *ppd, int which, void *t)
10904{
10905 int ret = 0;
10906 struct vl_arb_cache *vlc;
10907
10908 switch (which) {
10909 case FM_TBL_VL_HIGH_ARB:
10910 vlc = vl_arb_lock_cache(ppd, HI_PRIO_TABLE);
10911 if (vl_arb_match_cache(vlc, t)) {
10912 vl_arb_unlock_cache(ppd, HI_PRIO_TABLE);
10913 break;
10914 }
10915 vl_arb_set_cache(vlc, t);
10916 vl_arb_unlock_cache(ppd, HI_PRIO_TABLE);
10917 ret = set_vl_weights(ppd, SEND_HIGH_PRIORITY_LIST,
10918 VL_ARB_HIGH_PRIO_TABLE_SIZE, t);
10919 break;
10920 case FM_TBL_VL_LOW_ARB:
10921 vlc = vl_arb_lock_cache(ppd, LO_PRIO_TABLE);
10922 if (vl_arb_match_cache(vlc, t)) {
10923 vl_arb_unlock_cache(ppd, LO_PRIO_TABLE);
10924 break;
10925 }
10926 vl_arb_set_cache(vlc, t);
10927 vl_arb_unlock_cache(ppd, LO_PRIO_TABLE);
10928 ret = set_vl_weights(ppd, SEND_LOW_PRIORITY_LIST,
10929 VL_ARB_LOW_PRIO_TABLE_SIZE, t);
10930 break;
10931 case FM_TBL_BUFFER_CONTROL:
10932 ret = set_buffer_control(ppd->dd, t);
10933 break;
10934 case FM_TBL_SC2VLNT:
10935 set_sc2vlnt(ppd->dd, t);
10936 break;
10937 default:
10938 ret = -EINVAL;
10939 }
10940 return ret;
10941}
10942
10943/*
10944 * Disable all data VLs.
10945 *
10946 * Return 0 if disabled, non-zero if the VLs cannot be disabled.
10947 */
10948static int disable_data_vls(struct hfi1_devdata *dd)
10949{
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]10950 if (is_ax(dd))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]10951 return 1;
10952
10953 pio_send_control(dd, PSC_DATA_VL_DISABLE);
10954
10955 return 0;
10956}
10957
10958/*
10959 * open_fill_data_vls() - the counterpart to stop_drain_data_vls().
10960 * Just re-enables all data VLs (the "fill" part happens
10961 * automatically - the name was chosen for symmetry with
10962 * stop_drain_data_vls()).
10963 *
10964 * Return 0 if successful, non-zero if the VLs cannot be enabled.
10965 */
10966int open_fill_data_vls(struct hfi1_devdata *dd)
10967{
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]10968 if (is_ax(dd))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]10969 return 1;
10970
10971 pio_send_control(dd, PSC_DATA_VL_ENABLE);
10972
10973 return 0;
10974}
10975
10976/*
10977 * drain_data_vls() - assumes that disable_data_vls() has been called,
10978 * wait for occupancy (of per-VL FIFOs) for all contexts, and SDMA
10979 * engines to drop to 0.
10980 */
10981static void drain_data_vls(struct hfi1_devdata *dd)
10982{
10983 sc_wait(dd);
10984 sdma_wait(dd);
10985 pause_for_credit_return(dd);
10986}
10987
10988/*
10989 * stop_drain_data_vls() - disable, then drain all per-VL fifos.
10990 *
10991 * Use open_fill_data_vls() to resume using data VLs. This pair is
10992 * meant to be used like this:
10993 *
10994 * stop_drain_data_vls(dd);
10995 * // do things with per-VL resources
10996 * open_fill_data_vls(dd);
10997 */
10998int stop_drain_data_vls(struct hfi1_devdata *dd)
10999{
11000 int ret;
11001
11002 ret = disable_data_vls(dd);
11003 if (ret == 0)
11004 drain_data_vls(dd);
11005
11006 return ret;
11007}
11008
11009/*
11010 * Convert a nanosecond time to a cclock count. No matter how slow
11011 * the cclock, a non-zero ns will always have a non-zero result.
11012 */
11013u32 ns_to_cclock(struct hfi1_devdata *dd, u32 ns)
11014{
11015 u32 cclocks;
11016
11017 if (dd->icode == ICODE_FPGA_EMULATION)
11018 cclocks = (ns * 1000) / FPGA_CCLOCK_PS;
11019 else /* simulation pretends to be ASIC */
11020 cclocks = (ns * 1000) / ASIC_CCLOCK_PS;
11021 if (ns && !cclocks) /* if ns nonzero, must be at least 1 */
11022 cclocks = 1;
11023 return cclocks;
11024}
11025
11026/*
11027 * Convert a cclock count to nanoseconds. Not matter how slow
11028 * the cclock, a non-zero cclocks will always have a non-zero result.
11029 */
11030u32 cclock_to_ns(struct hfi1_devdata *dd, u32 cclocks)
11031{
11032 u32 ns;
11033
11034 if (dd->icode == ICODE_FPGA_EMULATION)
11035 ns = (cclocks * FPGA_CCLOCK_PS) / 1000;
11036 else /* simulation pretends to be ASIC */
11037 ns = (cclocks * ASIC_CCLOCK_PS) / 1000;
11038 if (cclocks && !ns)
11039 ns = 1;
11040 return ns;
11041}
11042
11043/*
11044 * Dynamically adjust the receive interrupt timeout for a context based on
11045 * incoming packet rate.
11046 *
11047 * NOTE: Dynamic adjustment does not allow rcv_intr_count to be zero.
11048 */
11049static void adjust_rcv_timeout(struct hfi1_ctxtdata *rcd, u32 npkts)
11050{
11051 struct hfi1_devdata *dd = rcd->dd;
11052 u32 timeout = rcd->rcvavail_timeout;
11053
11054 /*
11055 * This algorithm doubles or halves the timeout depending on whether
11056 * the number of packets received in this interrupt were less than or
11057 * greater equal the interrupt count.
11058 *
11059 * The calculations below do not allow a steady state to be achieved.
11060 * Only at the endpoints it is possible to have an unchanging
11061 * timeout.
11062 */
11063 if (npkts < rcv_intr_count) {
11064 /*
11065 * Not enough packets arrived before the timeout, adjust
11066 * timeout downward.
11067 */
11068 if (timeout < 2) /* already at minimum? */
11069 return;
11070 timeout >>= 1;
11071 } else {
11072 /*
11073 * More than enough packets arrived before the timeout, adjust
11074 * timeout upward.
11075 */
11076 if (timeout >= dd->rcv_intr_timeout_csr) /* already at max? */
11077 return;
11078 timeout = min(timeout << 1, dd->rcv_intr_timeout_csr);
11079 }
11080
11081 rcd->rcvavail_timeout = timeout;
11082 /* timeout cannot be larger than rcv_intr_timeout_csr which has already
11083 been verified to be in range */
11084 write_kctxt_csr(dd, rcd->ctxt, RCV_AVAIL_TIME_OUT,
11085 (u64)timeout << RCV_AVAIL_TIME_OUT_TIME_OUT_RELOAD_SHIFT);
11086}
11087
11088void update_usrhead(struct hfi1_ctxtdata *rcd, u32 hd, u32 updegr, u32 egrhd,
11089 u32 intr_adjust, u32 npkts)
11090{
11091 struct hfi1_devdata *dd = rcd->dd;
11092 u64 reg;
11093 u32 ctxt = rcd->ctxt;
11094
11095 /*
11096 * Need to write timeout register before updating RcvHdrHead to ensure
11097 * that a new value is used when the HW decides to restart counting.
11098 */
11099 if (intr_adjust)
11100 adjust_rcv_timeout(rcd, npkts);
11101 if (updegr) {
11102 reg = (egrhd & RCV_EGR_INDEX_HEAD_HEAD_MASK)
11103 << RCV_EGR_INDEX_HEAD_HEAD_SHIFT;
11104 write_uctxt_csr(dd, ctxt, RCV_EGR_INDEX_HEAD, reg);
11105 }
11106 mmiowb();
11107 reg = ((u64)rcv_intr_count << RCV_HDR_HEAD_COUNTER_SHIFT) |
11108 (((u64)hd & RCV_HDR_HEAD_HEAD_MASK)
11109 << RCV_HDR_HEAD_HEAD_SHIFT);
11110 write_uctxt_csr(dd, ctxt, RCV_HDR_HEAD, reg);
11111 mmiowb();
11112}
11113
11114u32 hdrqempty(struct hfi1_ctxtdata *rcd)
11115{
11116 u32 head, tail;
11117
11118 head = (read_uctxt_csr(rcd->dd, rcd->ctxt, RCV_HDR_HEAD)
11119 & RCV_HDR_HEAD_HEAD_SMASK) >> RCV_HDR_HEAD_HEAD_SHIFT;
11120
11121 if (rcd->rcvhdrtail_kvaddr)
11122 tail = get_rcvhdrtail(rcd);
11123 else
11124 tail = read_uctxt_csr(rcd->dd, rcd->ctxt, RCV_HDR_TAIL);
11125
11126 return head == tail;
11127}
11128
11129/*
11130 * Context Control and Receive Array encoding for buffer size:
11131 * 0x0 invalid
11132 * 0x1 4 KB
11133 * 0x2 8 KB
11134 * 0x3 16 KB
11135 * 0x4 32 KB
11136 * 0x5 64 KB
11137 * 0x6 128 KB
11138 * 0x7 256 KB
11139 * 0x8 512 KB (Receive Array only)
11140 * 0x9 1 MB (Receive Array only)
11141 * 0xa 2 MB (Receive Array only)
11142 *
11143 * 0xB-0xF - reserved (Receive Array only)
11144 *
11145 *
11146 * This routine assumes that the value has already been sanity checked.
11147 */
11148static u32 encoded_size(u32 size)
11149{
11150 switch (size) {
11151 case 4*1024: return 0x1;
11152 case 8*1024: return 0x2;
11153 case 16*1024: return 0x3;
11154 case 32*1024: return 0x4;
11155 case 64*1024: return 0x5;
11156 case 128*1024: return 0x6;
11157 case 256*1024: return 0x7;
11158 case 512*1024: return 0x8;
11159 case 1*1024*1024: return 0x9;
11160 case 2*1024*1024: return 0xa;
11161 }
11162 return 0x1; /* if invalid, go with the minimum size */
11163}
11164
11165void hfi1_rcvctrl(struct hfi1_devdata *dd, unsigned int op, int ctxt)
11166{
11167 struct hfi1_ctxtdata *rcd;
11168 u64 rcvctrl, reg;
11169 int did_enable = 0;
11170
11171 rcd = dd->rcd[ctxt];
11172 if (!rcd)
11173 return;
11174
11175 hfi1_cdbg(RCVCTRL, "ctxt %d op 0x%x", ctxt, op);
11176
11177 rcvctrl = read_kctxt_csr(dd, ctxt, RCV_CTXT_CTRL);
11178 /* if the context already enabled, don't do the extra steps */
11179 if ((op & HFI1_RCVCTRL_CTXT_ENB)
11180 && !(rcvctrl & RCV_CTXT_CTRL_ENABLE_SMASK)) {
11181 /* reset the tail and hdr addresses, and sequence count */
11182 write_kctxt_csr(dd, ctxt, RCV_HDR_ADDR,
11183 rcd->rcvhdrq_phys);
11184 if (HFI1_CAP_KGET_MASK(rcd->flags, DMA_RTAIL))
11185 write_kctxt_csr(dd, ctxt, RCV_HDR_TAIL_ADDR,
11186 rcd->rcvhdrqtailaddr_phys);
11187 rcd->seq_cnt = 1;
11188
11189 /* reset the cached receive header queue head value */
11190 rcd->head = 0;
11191
11192 /*
11193 * Zero the receive header queue so we don't get false
11194 * positives when checking the sequence number. The
11195 * sequence numbers could land exactly on the same spot.
11196 * E.g. a rcd restart before the receive header wrapped.
11197 */
11198 memset(rcd->rcvhdrq, 0, rcd->rcvhdrq_size);
11199
11200 /* starting timeout */
11201 rcd->rcvavail_timeout = dd->rcv_intr_timeout_csr;
11202
11203 /* enable the context */
11204 rcvctrl |= RCV_CTXT_CTRL_ENABLE_SMASK;
11205
11206 /* clean the egr buffer size first */
11207 rcvctrl &= ~RCV_CTXT_CTRL_EGR_BUF_SIZE_SMASK;
11208 rcvctrl |= ((u64)encoded_size(rcd->egrbufs.rcvtid_size)
11209 & RCV_CTXT_CTRL_EGR_BUF_SIZE_MASK)
11210 << RCV_CTXT_CTRL_EGR_BUF_SIZE_SHIFT;
11211
11212 /* zero RcvHdrHead - set RcvHdrHead.Counter after enable */
11213 write_uctxt_csr(dd, ctxt, RCV_HDR_HEAD, 0);
11214 did_enable = 1;
11215
11216 /* zero RcvEgrIndexHead */
11217 write_uctxt_csr(dd, ctxt, RCV_EGR_INDEX_HEAD, 0);
11218
11219 /* set eager count and base index */
11220 reg = (((u64)(rcd->egrbufs.alloced >> RCV_SHIFT)
11221 & RCV_EGR_CTRL_EGR_CNT_MASK)
11222 << RCV_EGR_CTRL_EGR_CNT_SHIFT) |
11223 (((rcd->eager_base >> RCV_SHIFT)
11224 & RCV_EGR_CTRL_EGR_BASE_INDEX_MASK)
11225 << RCV_EGR_CTRL_EGR_BASE_INDEX_SHIFT);
11226 write_kctxt_csr(dd, ctxt, RCV_EGR_CTRL, reg);
11227
11228 /*
11229 * Set TID (expected) count and base index.
11230 * rcd->expected_count is set to individual RcvArray entries,
11231 * not pairs, and the CSR takes a pair-count in groups of
11232 * four, so divide by 8.
11233 */
11234 reg = (((rcd->expected_count >> RCV_SHIFT)
11235 & RCV_TID_CTRL_TID_PAIR_CNT_MASK)
11236 << RCV_TID_CTRL_TID_PAIR_CNT_SHIFT) |
11237 (((rcd->expected_base >> RCV_SHIFT)
11238 & RCV_TID_CTRL_TID_BASE_INDEX_MASK)
11239 << RCV_TID_CTRL_TID_BASE_INDEX_SHIFT);
11240 write_kctxt_csr(dd, ctxt, RCV_TID_CTRL, reg);
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]11241 if (ctxt == HFI1_CTRL_CTXT)
11242 write_csr(dd, RCV_VL15, HFI1_CTRL_CTXT);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11243 }
11244 if (op & HFI1_RCVCTRL_CTXT_DIS) {
11245 write_csr(dd, RCV_VL15, 0);
Mark F. Brown46b010d2015-11-09 19:18:20 -0500[diff] [blame]11246 /*
11247 * When receive context is being disabled turn on tail
11248 * update with a dummy tail address and then disable
11249 * receive context.
11250 */
11251 if (dd->rcvhdrtail_dummy_physaddr) {
11252 write_kctxt_csr(dd, ctxt, RCV_HDR_TAIL_ADDR,
11253 dd->rcvhdrtail_dummy_physaddr);
11254 rcvctrl |= RCV_CTXT_CTRL_TAIL_UPD_SMASK;
11255 }
11256
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11257 rcvctrl &= ~RCV_CTXT_CTRL_ENABLE_SMASK;
11258 }
11259 if (op & HFI1_RCVCTRL_INTRAVAIL_ENB)
11260 rcvctrl |= RCV_CTXT_CTRL_INTR_AVAIL_SMASK;
11261 if (op & HFI1_RCVCTRL_INTRAVAIL_DIS)
11262 rcvctrl &= ~RCV_CTXT_CTRL_INTR_AVAIL_SMASK;
11263 if (op & HFI1_RCVCTRL_TAILUPD_ENB && rcd->rcvhdrqtailaddr_phys)
11264 rcvctrl |= RCV_CTXT_CTRL_TAIL_UPD_SMASK;
11265 if (op & HFI1_RCVCTRL_TAILUPD_DIS)
11266 rcvctrl &= ~RCV_CTXT_CTRL_TAIL_UPD_SMASK;
11267 if (op & HFI1_RCVCTRL_TIDFLOW_ENB)
11268 rcvctrl |= RCV_CTXT_CTRL_TID_FLOW_ENABLE_SMASK;
11269 if (op & HFI1_RCVCTRL_TIDFLOW_DIS)
11270 rcvctrl &= ~RCV_CTXT_CTRL_TID_FLOW_ENABLE_SMASK;
11271 if (op & HFI1_RCVCTRL_ONE_PKT_EGR_ENB) {
11272 /* In one-packet-per-eager mode, the size comes from
11273 the RcvArray entry. */
11274 rcvctrl &= ~RCV_CTXT_CTRL_EGR_BUF_SIZE_SMASK;
11275 rcvctrl |= RCV_CTXT_CTRL_ONE_PACKET_PER_EGR_BUFFER_SMASK;
11276 }
11277 if (op & HFI1_RCVCTRL_ONE_PKT_EGR_DIS)
11278 rcvctrl &= ~RCV_CTXT_CTRL_ONE_PACKET_PER_EGR_BUFFER_SMASK;
11279 if (op & HFI1_RCVCTRL_NO_RHQ_DROP_ENB)
11280 rcvctrl |= RCV_CTXT_CTRL_DONT_DROP_RHQ_FULL_SMASK;
11281 if (op & HFI1_RCVCTRL_NO_RHQ_DROP_DIS)
11282 rcvctrl &= ~RCV_CTXT_CTRL_DONT_DROP_RHQ_FULL_SMASK;
11283 if (op & HFI1_RCVCTRL_NO_EGR_DROP_ENB)
11284 rcvctrl |= RCV_CTXT_CTRL_DONT_DROP_EGR_FULL_SMASK;
11285 if (op & HFI1_RCVCTRL_NO_EGR_DROP_DIS)
11286 rcvctrl &= ~RCV_CTXT_CTRL_DONT_DROP_EGR_FULL_SMASK;
11287 rcd->rcvctrl = rcvctrl;
11288 hfi1_cdbg(RCVCTRL, "ctxt %d rcvctrl 0x%llx\n", ctxt, rcvctrl);
11289 write_kctxt_csr(dd, ctxt, RCV_CTXT_CTRL, rcd->rcvctrl);
11290
11291 /* work around sticky RcvCtxtStatus.BlockedRHQFull */
11292 if (did_enable
11293 && (rcvctrl & RCV_CTXT_CTRL_DONT_DROP_RHQ_FULL_SMASK)) {
11294 reg = read_kctxt_csr(dd, ctxt, RCV_CTXT_STATUS);
11295 if (reg != 0) {
11296 dd_dev_info(dd, "ctxt %d status %lld (blocked)\n",
11297 ctxt, reg);
11298 read_uctxt_csr(dd, ctxt, RCV_HDR_HEAD);
11299 write_uctxt_csr(dd, ctxt, RCV_HDR_HEAD, 0x10);
11300 write_uctxt_csr(dd, ctxt, RCV_HDR_HEAD, 0x00);
11301 read_uctxt_csr(dd, ctxt, RCV_HDR_HEAD);
11302 reg = read_kctxt_csr(dd, ctxt, RCV_CTXT_STATUS);
11303 dd_dev_info(dd, "ctxt %d status %lld (%s blocked)\n",
11304 ctxt, reg, reg == 0 ? "not" : "still");
11305 }
11306 }
11307
11308 if (did_enable) {
11309 /*
11310 * The interrupt timeout and count must be set after
11311 * the context is enabled to take effect.
11312 */
11313 /* set interrupt timeout */
11314 write_kctxt_csr(dd, ctxt, RCV_AVAIL_TIME_OUT,
11315 (u64)rcd->rcvavail_timeout <<
11316 RCV_AVAIL_TIME_OUT_TIME_OUT_RELOAD_SHIFT);
11317
11318 /* set RcvHdrHead.Counter, zero RcvHdrHead.Head (again) */
11319 reg = (u64)rcv_intr_count << RCV_HDR_HEAD_COUNTER_SHIFT;
11320 write_uctxt_csr(dd, ctxt, RCV_HDR_HEAD, reg);
11321 }
11322
11323 if (op & (HFI1_RCVCTRL_TAILUPD_DIS | HFI1_RCVCTRL_CTXT_DIS))
11324 /*
11325 * If the context has been disabled and the Tail Update has
Mark F. Brown46b010d2015-11-09 19:18:20 -0500[diff] [blame]11326 * been cleared, set the RCV_HDR_TAIL_ADDR CSR to dummy address
11327 * so it doesn't contain an address that is invalid.
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11328 */
Mark F. Brown46b010d2015-11-09 19:18:20 -0500[diff] [blame]11329 write_kctxt_csr(dd, ctxt, RCV_HDR_TAIL_ADDR,
11330 dd->rcvhdrtail_dummy_physaddr);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11331}
11332
11333u32 hfi1_read_cntrs(struct hfi1_devdata *dd, loff_t pos, char **namep,
11334 u64 **cntrp)
11335{
11336 int ret;
11337 u64 val = 0;
11338
11339 if (namep) {
11340 ret = dd->cntrnameslen;
11341 if (pos != 0) {
11342 dd_dev_err(dd, "read_cntrs does not support indexing");
11343 return 0;
11344 }
11345 *namep = dd->cntrnames;
11346 } else {
11347 const struct cntr_entry *entry;
11348 int i, j;
11349
11350 ret = (dd->ndevcntrs) * sizeof(u64);
11351 if (pos != 0) {
11352 dd_dev_err(dd, "read_cntrs does not support indexing");
11353 return 0;
11354 }
11355
11356 /* Get the start of the block of counters */
11357 *cntrp = dd->cntrs;
11358
11359 /*
11360 * Now go and fill in each counter in the block.
11361 */
11362 for (i = 0; i < DEV_CNTR_LAST; i++) {
11363 entry = &dev_cntrs[i];
11364 hfi1_cdbg(CNTR, "reading %s", entry->name);
11365 if (entry->flags & CNTR_DISABLED) {
11366 /* Nothing */
11367 hfi1_cdbg(CNTR, "\tDisabled\n");
11368 } else {
11369 if (entry->flags & CNTR_VL) {
11370 hfi1_cdbg(CNTR, "\tPer VL\n");
11371 for (j = 0; j < C_VL_COUNT; j++) {
11372 val = entry->rw_cntr(entry,
11373 dd, j,
11374 CNTR_MODE_R,
11375 0);
11376 hfi1_cdbg(
11377 CNTR,
11378 "\t\tRead 0x%llx for %d\n",
11379 val, j);
11380 dd->cntrs[entry->offset + j] =
11381 val;
11382 }
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]11383 } else if (entry->flags & CNTR_SDMA) {
11384 hfi1_cdbg(CNTR,
11385 "\t Per SDMA Engine\n");
11386 for (j = 0; j < dd->chip_sdma_engines;
11387 j++) {
11388 val =
11389 entry->rw_cntr(entry, dd, j,
11390 CNTR_MODE_R, 0);
11391 hfi1_cdbg(CNTR,
11392 "\t\tRead 0x%llx for %d\n",
11393 val, j);
11394 dd->cntrs[entry->offset + j] =
11395 val;
11396 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11397 } else {
11398 val = entry->rw_cntr(entry, dd,
11399 CNTR_INVALID_VL,
11400 CNTR_MODE_R, 0);
11401 dd->cntrs[entry->offset] = val;
11402 hfi1_cdbg(CNTR, "\tRead 0x%llx", val);
11403 }
11404 }
11405 }
11406 }
11407 return ret;
11408}
11409
11410/*
11411 * Used by sysfs to create files for hfi stats to read
11412 */
11413u32 hfi1_read_portcntrs(struct hfi1_devdata *dd, loff_t pos, u32 port,
11414 char **namep, u64 **cntrp)
11415{
11416 int ret;
11417 u64 val = 0;
11418
11419 if (namep) {
11420 ret = dd->portcntrnameslen;
11421 if (pos != 0) {
11422 dd_dev_err(dd, "index not supported");
11423 return 0;
11424 }
11425 *namep = dd->portcntrnames;
11426 } else {
11427 const struct cntr_entry *entry;
11428 struct hfi1_pportdata *ppd;
11429 int i, j;
11430
11431 ret = (dd->nportcntrs) * sizeof(u64);
11432 if (pos != 0) {
11433 dd_dev_err(dd, "indexing not supported");
11434 return 0;
11435 }
11436 ppd = (struct hfi1_pportdata *)(dd + 1 + port);
11437 *cntrp = ppd->cntrs;
11438
11439 for (i = 0; i < PORT_CNTR_LAST; i++) {
11440 entry = &port_cntrs[i];
11441 hfi1_cdbg(CNTR, "reading %s", entry->name);
11442 if (entry->flags & CNTR_DISABLED) {
11443 /* Nothing */
11444 hfi1_cdbg(CNTR, "\tDisabled\n");
11445 continue;
11446 }
11447
11448 if (entry->flags & CNTR_VL) {
11449 hfi1_cdbg(CNTR, "\tPer VL");
11450 for (j = 0; j < C_VL_COUNT; j++) {
11451 val = entry->rw_cntr(entry, ppd, j,
11452 CNTR_MODE_R,
11453 0);
11454 hfi1_cdbg(
11455 CNTR,
11456 "\t\tRead 0x%llx for %d",
11457 val, j);
11458 ppd->cntrs[entry->offset + j] = val;
11459 }
11460 } else {
11461 val = entry->rw_cntr(entry, ppd,
11462 CNTR_INVALID_VL,
11463 CNTR_MODE_R,
11464 0);
11465 ppd->cntrs[entry->offset] = val;
11466 hfi1_cdbg(CNTR, "\tRead 0x%llx", val);
11467 }
11468 }
11469 }
11470 return ret;
11471}
11472
11473static void free_cntrs(struct hfi1_devdata *dd)
11474{
11475 struct hfi1_pportdata *ppd;
11476 int i;
11477
11478 if (dd->synth_stats_timer.data)
11479 del_timer_sync(&dd->synth_stats_timer);
11480 dd->synth_stats_timer.data = 0;
11481 ppd = (struct hfi1_pportdata *)(dd + 1);
11482 for (i = 0; i < dd->num_pports; i++, ppd++) {
11483 kfree(ppd->cntrs);
11484 kfree(ppd->scntrs);
Dennis Dalessandro4eb06882016-01-19 14:42:39 -0800[diff] [blame]11485 free_percpu(ppd->ibport_data.rvp.rc_acks);
11486 free_percpu(ppd->ibport_data.rvp.rc_qacks);
11487 free_percpu(ppd->ibport_data.rvp.rc_delayed_comp);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11488 ppd->cntrs = NULL;
11489 ppd->scntrs = NULL;
Dennis Dalessandro4eb06882016-01-19 14:42:39 -0800[diff] [blame]11490 ppd->ibport_data.rvp.rc_acks = NULL;
11491 ppd->ibport_data.rvp.rc_qacks = NULL;
11492 ppd->ibport_data.rvp.rc_delayed_comp = NULL;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11493 }
11494 kfree(dd->portcntrnames);
11495 dd->portcntrnames = NULL;
11496 kfree(dd->cntrs);
11497 dd->cntrs = NULL;
11498 kfree(dd->scntrs);
11499 dd->scntrs = NULL;
11500 kfree(dd->cntrnames);
11501 dd->cntrnames = NULL;
11502}
11503
11504#define CNTR_MAX 0xFFFFFFFFFFFFFFFFULL
11505#define CNTR_32BIT_MAX 0x00000000FFFFFFFF
11506
11507static u64 read_dev_port_cntr(struct hfi1_devdata *dd, struct cntr_entry *entry,
11508 u64 *psval, void *context, int vl)
11509{
11510 u64 val;
11511 u64 sval = *psval;
11512
11513 if (entry->flags & CNTR_DISABLED) {
11514 dd_dev_err(dd, "Counter %s not enabled", entry->name);
11515 return 0;
11516 }
11517
11518 hfi1_cdbg(CNTR, "cntr: %s vl %d psval 0x%llx", entry->name, vl, *psval);
11519
11520 val = entry->rw_cntr(entry, context, vl, CNTR_MODE_R, 0);
11521
11522 /* If its a synthetic counter there is more work we need to do */
11523 if (entry->flags & CNTR_SYNTH) {
11524 if (sval == CNTR_MAX) {
11525 /* No need to read already saturated */
11526 return CNTR_MAX;
11527 }
11528
11529 if (entry->flags & CNTR_32BIT) {
11530 /* 32bit counters can wrap multiple times */
11531 u64 upper = sval >> 32;
11532 u64 lower = (sval << 32) >> 32;
11533
11534 if (lower > val) { /* hw wrapped */
11535 if (upper == CNTR_32BIT_MAX)
11536 val = CNTR_MAX;
11537 else
11538 upper++;
11539 }
11540
11541 if (val != CNTR_MAX)
11542 val = (upper << 32) | val;
11543
11544 } else {
11545 /* If we rolled we are saturated */
11546 if ((val < sval) || (val > CNTR_MAX))
11547 val = CNTR_MAX;
11548 }
11549 }
11550
11551 *psval = val;
11552
11553 hfi1_cdbg(CNTR, "\tNew val=0x%llx", val);
11554
11555 return val;
11556}
11557
11558static u64 write_dev_port_cntr(struct hfi1_devdata *dd,
11559 struct cntr_entry *entry,
11560 u64 *psval, void *context, int vl, u64 data)
11561{
11562 u64 val;
11563
11564 if (entry->flags & CNTR_DISABLED) {
11565 dd_dev_err(dd, "Counter %s not enabled", entry->name);
11566 return 0;
11567 }
11568
11569 hfi1_cdbg(CNTR, "cntr: %s vl %d psval 0x%llx", entry->name, vl, *psval);
11570
11571 if (entry->flags & CNTR_SYNTH) {
11572 *psval = data;
11573 if (entry->flags & CNTR_32BIT) {
11574 val = entry->rw_cntr(entry, context, vl, CNTR_MODE_W,
11575 (data << 32) >> 32);
11576 val = data; /* return the full 64bit value */
11577 } else {
11578 val = entry->rw_cntr(entry, context, vl, CNTR_MODE_W,
11579 data);
11580 }
11581 } else {
11582 val = entry->rw_cntr(entry, context, vl, CNTR_MODE_W, data);
11583 }
11584
11585 *psval = val;
11586
11587 hfi1_cdbg(CNTR, "\tNew val=0x%llx", val);
11588
11589 return val;
11590}
11591
11592u64 read_dev_cntr(struct hfi1_devdata *dd, int index, int vl)
11593{
11594 struct cntr_entry *entry;
11595 u64 *sval;
11596
11597 entry = &dev_cntrs[index];
11598 sval = dd->scntrs + entry->offset;
11599
11600 if (vl != CNTR_INVALID_VL)
11601 sval += vl;
11602
11603 return read_dev_port_cntr(dd, entry, sval, dd, vl);
11604}
11605
11606u64 write_dev_cntr(struct hfi1_devdata *dd, int index, int vl, u64 data)
11607{
11608 struct cntr_entry *entry;
11609 u64 *sval;
11610
11611 entry = &dev_cntrs[index];
11612 sval = dd->scntrs + entry->offset;
11613
11614 if (vl != CNTR_INVALID_VL)
11615 sval += vl;
11616
11617 return write_dev_port_cntr(dd, entry, sval, dd, vl, data);
11618}
11619
11620u64 read_port_cntr(struct hfi1_pportdata *ppd, int index, int vl)
11621{
11622 struct cntr_entry *entry;
11623 u64 *sval;
11624
11625 entry = &port_cntrs[index];
11626 sval = ppd->scntrs + entry->offset;
11627
11628 if (vl != CNTR_INVALID_VL)
11629 sval += vl;
11630
11631 if ((index >= C_RCV_HDR_OVF_FIRST + ppd->dd->num_rcv_contexts) &&
11632 (index <= C_RCV_HDR_OVF_LAST)) {
11633 /* We do not want to bother for disabled contexts */
11634 return 0;
11635 }
11636
11637 return read_dev_port_cntr(ppd->dd, entry, sval, ppd, vl);
11638}
11639
11640u64 write_port_cntr(struct hfi1_pportdata *ppd, int index, int vl, u64 data)
11641{
11642 struct cntr_entry *entry;
11643 u64 *sval;
11644
11645 entry = &port_cntrs[index];
11646 sval = ppd->scntrs + entry->offset;
11647
11648 if (vl != CNTR_INVALID_VL)
11649 sval += vl;
11650
11651 if ((index >= C_RCV_HDR_OVF_FIRST + ppd->dd->num_rcv_contexts) &&
11652 (index <= C_RCV_HDR_OVF_LAST)) {
11653 /* We do not want to bother for disabled contexts */
11654 return 0;
11655 }
11656
11657 return write_dev_port_cntr(ppd->dd, entry, sval, ppd, vl, data);
11658}
11659
11660static void update_synth_timer(unsigned long opaque)
11661{
11662 u64 cur_tx;
11663 u64 cur_rx;
11664 u64 total_flits;
11665 u8 update = 0;
11666 int i, j, vl;
11667 struct hfi1_pportdata *ppd;
11668 struct cntr_entry *entry;
11669
11670 struct hfi1_devdata *dd = (struct hfi1_devdata *)opaque;
11671
11672 /*
11673 * Rather than keep beating on the CSRs pick a minimal set that we can
11674 * check to watch for potential roll over. We can do this by looking at
11675 * the number of flits sent/recv. If the total flits exceeds 32bits then
11676 * we have to iterate all the counters and update.
11677 */
11678 entry = &dev_cntrs[C_DC_RCV_FLITS];
11679 cur_rx = entry->rw_cntr(entry, dd, CNTR_INVALID_VL, CNTR_MODE_R, 0);
11680
11681 entry = &dev_cntrs[C_DC_XMIT_FLITS];
11682 cur_tx = entry->rw_cntr(entry, dd, CNTR_INVALID_VL, CNTR_MODE_R, 0);
11683
11684 hfi1_cdbg(
11685 CNTR,
11686 "[%d] curr tx=0x%llx rx=0x%llx :: last tx=0x%llx rx=0x%llx\n",
11687 dd->unit, cur_tx, cur_rx, dd->last_tx, dd->last_rx);
11688
11689 if ((cur_tx < dd->last_tx) || (cur_rx < dd->last_rx)) {
11690 /*
11691 * May not be strictly necessary to update but it won't hurt and
11692 * simplifies the logic here.
11693 */
11694 update = 1;
11695 hfi1_cdbg(CNTR, "[%d] Tripwire counter rolled, updating",
11696 dd->unit);
11697 } else {
11698 total_flits = (cur_tx - dd->last_tx) + (cur_rx - dd->last_rx);
11699 hfi1_cdbg(CNTR,
11700 "[%d] total flits 0x%llx limit 0x%llx\n", dd->unit,
11701 total_flits, (u64)CNTR_32BIT_MAX);
11702 if (total_flits >= CNTR_32BIT_MAX) {
11703 hfi1_cdbg(CNTR, "[%d] 32bit limit hit, updating",
11704 dd->unit);
11705 update = 1;
11706 }
11707 }
11708
11709 if (update) {
11710 hfi1_cdbg(CNTR, "[%d] Updating dd and ppd counters", dd->unit);
11711 for (i = 0; i < DEV_CNTR_LAST; i++) {
11712 entry = &dev_cntrs[i];
11713 if (entry->flags & CNTR_VL) {
11714 for (vl = 0; vl < C_VL_COUNT; vl++)
11715 read_dev_cntr(dd, i, vl);
11716 } else {
11717 read_dev_cntr(dd, i, CNTR_INVALID_VL);
11718 }
11719 }
11720 ppd = (struct hfi1_pportdata *)(dd + 1);
11721 for (i = 0; i < dd->num_pports; i++, ppd++) {
11722 for (j = 0; j < PORT_CNTR_LAST; j++) {
11723 entry = &port_cntrs[j];
11724 if (entry->flags & CNTR_VL) {
11725 for (vl = 0; vl < C_VL_COUNT; vl++)
11726 read_port_cntr(ppd, j, vl);
11727 } else {
11728 read_port_cntr(ppd, j, CNTR_INVALID_VL);
11729 }
11730 }
11731 }
11732
11733 /*
11734 * We want the value in the register. The goal is to keep track
11735 * of the number of "ticks" not the counter value. In other
11736 * words if the register rolls we want to notice it and go ahead
11737 * and force an update.
11738 */
11739 entry = &dev_cntrs[C_DC_XMIT_FLITS];
11740 dd->last_tx = entry->rw_cntr(entry, dd, CNTR_INVALID_VL,
11741 CNTR_MODE_R, 0);
11742
11743 entry = &dev_cntrs[C_DC_RCV_FLITS];
11744 dd->last_rx = entry->rw_cntr(entry, dd, CNTR_INVALID_VL,
11745 CNTR_MODE_R, 0);
11746
11747 hfi1_cdbg(CNTR, "[%d] setting last tx/rx to 0x%llx 0x%llx",
11748 dd->unit, dd->last_tx, dd->last_rx);
11749
11750 } else {
11751 hfi1_cdbg(CNTR, "[%d] No update necessary", dd->unit);
11752 }
11753
11754mod_timer(&dd->synth_stats_timer, jiffies + HZ * SYNTH_CNT_TIME);
11755}
11756
11757#define C_MAX_NAME 13 /* 12 chars + one for /0 */
11758static int init_cntrs(struct hfi1_devdata *dd)
11759{
Dean Luickc024c552016-01-11 18:30:57 -0500[diff] [blame]11760 int i, rcv_ctxts, j;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11761 size_t sz;
11762 char *p;
11763 char name[C_MAX_NAME];
11764 struct hfi1_pportdata *ppd;
11765
11766 /* set up the stats timer; the add_timer is done at the end */
Muhammad Falak R Wani24523a92015-10-25 16:13:23 +0530[diff] [blame]11767 setup_timer(&dd->synth_stats_timer, update_synth_timer,
11768 (unsigned long)dd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11769
11770 /***********************/
11771 /* per device counters */
11772 /***********************/
11773
11774 /* size names and determine how many we have*/
11775 dd->ndevcntrs = 0;
11776 sz = 0;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11777
11778 for (i = 0; i < DEV_CNTR_LAST; i++) {
11779 hfi1_dbg_early("Init cntr %s\n", dev_cntrs[i].name);
11780 if (dev_cntrs[i].flags & CNTR_DISABLED) {
11781 hfi1_dbg_early("\tSkipping %s\n", dev_cntrs[i].name);
11782 continue;
11783 }
11784
11785 if (dev_cntrs[i].flags & CNTR_VL) {
11786 hfi1_dbg_early("\tProcessing VL cntr\n");
Dean Luickc024c552016-01-11 18:30:57 -0500[diff] [blame]11787 dev_cntrs[i].offset = dd->ndevcntrs;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11788 for (j = 0; j < C_VL_COUNT; j++) {
11789 memset(name, '\0', C_MAX_NAME);
11790 snprintf(name, C_MAX_NAME, "%s%d",
11791 dev_cntrs[i].name,
11792 vl_from_idx(j));
11793 sz += strlen(name);
11794 sz++;
11795 hfi1_dbg_early("\t\t%s\n", name);
11796 dd->ndevcntrs++;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11797 }
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]11798 } else if (dev_cntrs[i].flags & CNTR_SDMA) {
11799 hfi1_dbg_early(
11800 "\tProcessing per SDE counters chip enginers %u\n",
11801 dd->chip_sdma_engines);
Dean Luickc024c552016-01-11 18:30:57 -0500[diff] [blame]11802 dev_cntrs[i].offset = dd->ndevcntrs;
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]11803 for (j = 0; j < dd->chip_sdma_engines; j++) {
11804 memset(name, '\0', C_MAX_NAME);
11805 snprintf(name, C_MAX_NAME, "%s%d",
11806 dev_cntrs[i].name, j);
11807 sz += strlen(name);
11808 sz++;
11809 hfi1_dbg_early("\t\t%s\n", name);
11810 dd->ndevcntrs++;
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]11811 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11812 } else {
11813 /* +1 for newline */
11814 sz += strlen(dev_cntrs[i].name) + 1;
Dean Luickc024c552016-01-11 18:30:57 -0500[diff] [blame]11815 dev_cntrs[i].offset = dd->ndevcntrs;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11816 dd->ndevcntrs++;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11817 hfi1_dbg_early("\tAdding %s\n", dev_cntrs[i].name);
11818 }
11819 }
11820
11821 /* allocate space for the counter values */
Dean Luickc024c552016-01-11 18:30:57 -0500[diff] [blame]11822 dd->cntrs = kcalloc(dd->ndevcntrs, sizeof(u64), GFP_KERNEL);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11823 if (!dd->cntrs)
11824 goto bail;
11825
Dean Luickc024c552016-01-11 18:30:57 -0500[diff] [blame]11826 dd->scntrs = kcalloc(dd->ndevcntrs, sizeof(u64), GFP_KERNEL);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11827 if (!dd->scntrs)
11828 goto bail;
11829
11830
11831 /* allocate space for the counter names */
11832 dd->cntrnameslen = sz;
11833 dd->cntrnames = kmalloc(sz, GFP_KERNEL);
11834 if (!dd->cntrnames)
11835 goto bail;
11836
11837 /* fill in the names */
Dean Luickc024c552016-01-11 18:30:57 -0500[diff] [blame]11838 for (p = dd->cntrnames, i = 0; i < DEV_CNTR_LAST; i++) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11839 if (dev_cntrs[i].flags & CNTR_DISABLED) {
11840 /* Nothing */
11841 } else {
11842 if (dev_cntrs[i].flags & CNTR_VL) {
11843 for (j = 0; j < C_VL_COUNT; j++) {
11844 memset(name, '\0', C_MAX_NAME);
11845 snprintf(name, C_MAX_NAME, "%s%d",
11846 dev_cntrs[i].name,
11847 vl_from_idx(j));
11848 memcpy(p, name, strlen(name));
11849 p += strlen(name);
11850 *p++ = '\n';
11851 }
Vennila Megavannana699c6c2016-01-11 18:30:56 -0500[diff] [blame]11852 } else if (dev_cntrs[i].flags & CNTR_SDMA) {
11853 for (j = 0; j < TXE_NUM_SDMA_ENGINES;
11854 j++) {
11855 memset(name, '\0', C_MAX_NAME);
11856 snprintf(name, C_MAX_NAME, "%s%d",
11857 dev_cntrs[i].name, j);
11858 memcpy(p, name, strlen(name));
11859 p += strlen(name);
11860 *p++ = '\n';
11861 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11862 } else {
11863 memcpy(p, dev_cntrs[i].name,
11864 strlen(dev_cntrs[i].name));
11865 p += strlen(dev_cntrs[i].name);
11866 *p++ = '\n';
11867 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]11868 }
11869 }
11870
11871 /*********************/
11872 /* per port counters */
11873 /*********************/
11874
11875 /*
11876 * Go through the counters for the overflows and disable the ones we
11877 * don't need. This varies based on platform so we need to do it
11878 * dynamically here.
11879 */
11880 rcv_ctxts = dd->num_rcv_contexts;
11881 for (i = C_RCV_HDR_OVF_FIRST + rcv_ctxts;
11882 i <= C_RCV_HDR_OVF_LAST; i++) {
11883 port_cntrs[i].flags |= CNTR_DISABLED;
11884 }
11885
11886 /* size port counter names and determine how many we have*/
11887 sz = 0;
11888 dd->nportcntrs = 0;
11889 for (i = 0; i < PORT_CNTR_LAST; i++) {
11890 hfi1_dbg_early("Init pcntr %s\n", port_cntrs[i].name);
11891 if (port_cntrs[i].flags & CNTR_DISABLED) {
11892 hfi1_dbg_early("\tSkipping %s\n", port_cntrs[i].name);
11893 continue;
11894 }
11895
11896 if (port_cntrs[i].flags & CNTR_VL) {
11897 hfi1_dbg_early("\tProcessing VL cntr\n");
11898 port_cntrs[i].offset = dd->nportcntrs;
11899 for (j = 0; j < C_VL_COUNT; j++) {
11900 memset(name, '\0', C_MAX_NAME);
11901 snprintf(name, C_MAX_NAME, "%s%d",
11902 port_cntrs[i].name,
11903 vl_from_idx(j));
11904 sz += strlen(name);
11905 sz++;
11906 hfi1_dbg_early("\t\t%s\n", name);
11907 dd->nportcntrs++;
11908 }
11909 } else {
11910 /* +1 for newline */
11911 sz += strlen(port_cntrs[i].name) + 1;
11912 port_cntrs[i].offset = dd->nportcntrs;
11913 dd->nportcntrs++;
11914 hfi1_dbg_early("\tAdding %s\n", port_cntrs[i].name);
11915 }
11916 }
11917
11918 /* allocate space for the counter names */
11919 dd->portcntrnameslen = sz;
11920 dd->portcntrnames = kmalloc(sz, GFP_KERNEL);
11921 if (!dd->portcntrnames)
11922 goto bail;
11923
11924 /* fill in port cntr names */
11925 for (p = dd->portcntrnames, i = 0; i < PORT_CNTR_LAST; i++) {
11926 if (port_cntrs[i].flags & CNTR_DISABLED)
11927 continue;
11928
11929 if (port_cntrs[i].flags & CNTR_VL) {
11930 for (j = 0; j < C_VL_COUNT; j++) {
11931 memset(name, '\0', C_MAX_NAME);
11932 snprintf(name, C_MAX_NAME, "%s%d",
11933 port_cntrs[i].name,
11934 vl_from_idx(j));
11935 memcpy(p, name, strlen(name));
11936 p += strlen(name);
11937 *p++ = '\n';
11938 }
11939 } else {
11940 memcpy(p, port_cntrs[i].name,
11941 strlen(port_cntrs[i].name));
11942 p += strlen(port_cntrs[i].name);
11943 *p++ = '\n';
11944 }
11945 }
11946
11947 /* allocate per port storage for counter values */
11948 ppd = (struct hfi1_pportdata *)(dd + 1);
11949 for (i = 0; i < dd->num_pports; i++, ppd++) {
11950 ppd->cntrs = kcalloc(dd->nportcntrs, sizeof(u64), GFP_KERNEL);
11951 if (!ppd->cntrs)
11952 goto bail;
11953
11954 ppd->scntrs = kcalloc(dd->nportcntrs, sizeof(u64), GFP_KERNEL);
11955 if (!ppd->scntrs)
11956 goto bail;
11957 }
11958
11959 /* CPU counters need to be allocated and zeroed */
11960 if (init_cpu_counters(dd))
11961 goto bail;
11962
11963 mod_timer(&dd->synth_stats_timer, jiffies + HZ * SYNTH_CNT_TIME);
11964 return 0;
11965bail:
11966 free_cntrs(dd);
11967 return -ENOMEM;
11968}
11969
11970
11971static u32 chip_to_opa_lstate(struct hfi1_devdata *dd, u32 chip_lstate)
11972{
11973 switch (chip_lstate) {
11974 default:
11975 dd_dev_err(dd,
11976 "Unknown logical state 0x%x, reporting IB_PORT_DOWN\n",
11977 chip_lstate);
11978 /* fall through */
11979 case LSTATE_DOWN:
11980 return IB_PORT_DOWN;
11981 case LSTATE_INIT:
11982 return IB_PORT_INIT;
11983 case LSTATE_ARMED:
11984 return IB_PORT_ARMED;
11985 case LSTATE_ACTIVE:
11986 return IB_PORT_ACTIVE;
11987 }
11988}
11989
11990u32 chip_to_opa_pstate(struct hfi1_devdata *dd, u32 chip_pstate)
11991{
11992 /* look at the HFI meta-states only */
11993 switch (chip_pstate & 0xf0) {
11994 default:
11995 dd_dev_err(dd, "Unexpected chip physical state of 0x%x\n",
11996 chip_pstate);
11997 /* fall through */
11998 case PLS_DISABLED:
11999 return IB_PORTPHYSSTATE_DISABLED;
12000 case PLS_OFFLINE:
12001 return OPA_PORTPHYSSTATE_OFFLINE;
12002 case PLS_POLLING:
12003 return IB_PORTPHYSSTATE_POLLING;
12004 case PLS_CONFIGPHY:
12005 return IB_PORTPHYSSTATE_TRAINING;
12006 case PLS_LINKUP:
12007 return IB_PORTPHYSSTATE_LINKUP;
12008 case PLS_PHYTEST:
12009 return IB_PORTPHYSSTATE_PHY_TEST;
12010 }
12011}
12012
12013/* return the OPA port logical state name */
12014const char *opa_lstate_name(u32 lstate)
12015{
12016 static const char * const port_logical_names[] = {
12017 "PORT_NOP",
12018 "PORT_DOWN",
12019 "PORT_INIT",
12020 "PORT_ARMED",
12021 "PORT_ACTIVE",
12022 "PORT_ACTIVE_DEFER",
12023 };
12024 if (lstate < ARRAY_SIZE(port_logical_names))
12025 return port_logical_names[lstate];
12026 return "unknown";
12027}
12028
12029/* return the OPA port physical state name */
12030const char *opa_pstate_name(u32 pstate)
12031{
12032 static const char * const port_physical_names[] = {
12033 "PHYS_NOP",
12034 "reserved1",
12035 "PHYS_POLL",
12036 "PHYS_DISABLED",
12037 "PHYS_TRAINING",
12038 "PHYS_LINKUP",
12039 "PHYS_LINK_ERR_RECOVER",
12040 "PHYS_PHY_TEST",
12041 "reserved8",
12042 "PHYS_OFFLINE",
12043 "PHYS_GANGED",
12044 "PHYS_TEST",
12045 };
12046 if (pstate < ARRAY_SIZE(port_physical_names))
12047 return port_physical_names[pstate];
12048 return "unknown";
12049}
12050
12051/*
12052 * Read the hardware link state and set the driver's cached value of it.
12053 * Return the (new) current value.
12054 */
12055u32 get_logical_state(struct hfi1_pportdata *ppd)
12056{
12057 u32 new_state;
12058
12059 new_state = chip_to_opa_lstate(ppd->dd, read_logical_state(ppd->dd));
12060 if (new_state != ppd->lstate) {
12061 dd_dev_info(ppd->dd, "logical state changed to %s (0x%x)\n",
12062 opa_lstate_name(new_state), new_state);
12063 ppd->lstate = new_state;
12064 }
12065 /*
12066 * Set port status flags in the page mapped into userspace
12067 * memory. Do it here to ensure a reliable state - this is
12068 * the only function called by all state handling code.
12069 * Always set the flags due to the fact that the cache value
12070 * might have been changed explicitly outside of this
12071 * function.
12072 */
12073 if (ppd->statusp) {
12074 switch (ppd->lstate) {
12075 case IB_PORT_DOWN:
12076 case IB_PORT_INIT:
12077 *ppd->statusp &= ~(HFI1_STATUS_IB_CONF |
12078 HFI1_STATUS_IB_READY);
12079 break;
12080 case IB_PORT_ARMED:
12081 *ppd->statusp |= HFI1_STATUS_IB_CONF;
12082 break;
12083 case IB_PORT_ACTIVE:
12084 *ppd->statusp |= HFI1_STATUS_IB_READY;
12085 break;
12086 }
12087 }
12088 return ppd->lstate;
12089}
12090
12091/**
12092 * wait_logical_linkstate - wait for an IB link state change to occur
12093 * @ppd: port device
12094 * @state: the state to wait for
12095 * @msecs: the number of milliseconds to wait
12096 *
12097 * Wait up to msecs milliseconds for IB link state change to occur.
12098 * For now, take the easy polling route.
12099 * Returns 0 if state reached, otherwise -ETIMEDOUT.
12100 */
12101static int wait_logical_linkstate(struct hfi1_pportdata *ppd, u32 state,
12102 int msecs)
12103{
12104 unsigned long timeout;
12105
12106 timeout = jiffies + msecs_to_jiffies(msecs);
12107 while (1) {
12108 if (get_logical_state(ppd) == state)
12109 return 0;
12110 if (time_after(jiffies, timeout))
12111 break;
12112 msleep(20);
12113 }
12114 dd_dev_err(ppd->dd, "timeout waiting for link state 0x%x\n", state);
12115
12116 return -ETIMEDOUT;
12117}
12118
12119u8 hfi1_ibphys_portstate(struct hfi1_pportdata *ppd)
12120{
12121 static u32 remembered_state = 0xff;
12122 u32 pstate;
12123 u32 ib_pstate;
12124
12125 pstate = read_physical_state(ppd->dd);
12126 ib_pstate = chip_to_opa_pstate(ppd->dd, pstate);
12127 if (remembered_state != ib_pstate) {
12128 dd_dev_info(ppd->dd,
12129 "%s: physical state changed to %s (0x%x), phy 0x%x\n",
12130 __func__, opa_pstate_name(ib_pstate), ib_pstate,
12131 pstate);
12132 remembered_state = ib_pstate;
12133 }
12134 return ib_pstate;
12135}
12136
12137/*
12138 * Read/modify/write ASIC_QSFP register bits as selected by mask
12139 * data: 0 or 1 in the positions depending on what needs to be written
12140 * dir: 0 for read, 1 for write
12141 * mask: select by setting
12142 * I2CCLK (bit 0)
12143 * I2CDATA (bit 1)
12144 */
12145u64 hfi1_gpio_mod(struct hfi1_devdata *dd, u32 target, u32 data, u32 dir,
12146 u32 mask)
12147{
12148 u64 qsfp_oe, target_oe;
12149
12150 target_oe = target ? ASIC_QSFP2_OE : ASIC_QSFP1_OE;
12151 if (mask) {
12152 /* We are writing register bits, so lock access */
12153 dir &= mask;
12154 data &= mask;
12155
12156 qsfp_oe = read_csr(dd, target_oe);
12157 qsfp_oe = (qsfp_oe & ~(u64)mask) | (u64)dir;
12158 write_csr(dd, target_oe, qsfp_oe);
12159 }
12160 /* We are exclusively reading bits here, but it is unlikely
12161 * we'll get valid data when we set the direction of the pin
12162 * in the same call, so read should call this function again
12163 * to get valid data
12164 */
12165 return read_csr(dd, target ? ASIC_QSFP2_IN : ASIC_QSFP1_IN);
12166}
12167
12168#define CLEAR_STATIC_RATE_CONTROL_SMASK(r) \
12169(r &= ~SEND_CTXT_CHECK_ENABLE_DISALLOW_PBC_STATIC_RATE_CONTROL_SMASK)
12170
12171#define SET_STATIC_RATE_CONTROL_SMASK(r) \
12172(r |= SEND_CTXT_CHECK_ENABLE_DISALLOW_PBC_STATIC_RATE_CONTROL_SMASK)
12173
12174int hfi1_init_ctxt(struct send_context *sc)
12175{
12176 if (sc != NULL) {
12177 struct hfi1_devdata *dd = sc->dd;
12178 u64 reg;
12179 u8 set = (sc->type == SC_USER ?
12180 HFI1_CAP_IS_USET(STATIC_RATE_CTRL) :
12181 HFI1_CAP_IS_KSET(STATIC_RATE_CTRL));
12182 reg = read_kctxt_csr(dd, sc->hw_context,
12183 SEND_CTXT_CHECK_ENABLE);
12184 if (set)
12185 CLEAR_STATIC_RATE_CONTROL_SMASK(reg);
12186 else
12187 SET_STATIC_RATE_CONTROL_SMASK(reg);
12188 write_kctxt_csr(dd, sc->hw_context,
12189 SEND_CTXT_CHECK_ENABLE, reg);
12190 }
12191 return 0;
12192}
12193
12194int hfi1_tempsense_rd(struct hfi1_devdata *dd, struct hfi1_temp *temp)
12195{
12196 int ret = 0;
12197 u64 reg;
12198
12199 if (dd->icode != ICODE_RTL_SILICON) {
12200 if (HFI1_CAP_IS_KSET(PRINT_UNIMPL))
12201 dd_dev_info(dd, "%s: tempsense not supported by HW\n",
12202 __func__);
12203 return -EINVAL;
12204 }
12205 reg = read_csr(dd, ASIC_STS_THERM);
12206 temp->curr = ((reg >> ASIC_STS_THERM_CURR_TEMP_SHIFT) &
12207 ASIC_STS_THERM_CURR_TEMP_MASK);
12208 temp->lo_lim = ((reg >> ASIC_STS_THERM_LO_TEMP_SHIFT) &
12209 ASIC_STS_THERM_LO_TEMP_MASK);
12210 temp->hi_lim = ((reg >> ASIC_STS_THERM_HI_TEMP_SHIFT) &
12211 ASIC_STS_THERM_HI_TEMP_MASK);
12212 temp->crit_lim = ((reg >> ASIC_STS_THERM_CRIT_TEMP_SHIFT) &
12213 ASIC_STS_THERM_CRIT_TEMP_MASK);
12214 /* triggers is a 3-bit value - 1 bit per trigger. */
12215 temp->triggers = (u8)((reg >> ASIC_STS_THERM_LOW_SHIFT) & 0x7);
12216
12217 return ret;
12218}
12219
12220/* ========================================================================= */
12221
12222/*
12223 * Enable/disable chip from delivering interrupts.
12224 */
12225void set_intr_state(struct hfi1_devdata *dd, u32 enable)
12226{
12227 int i;
12228
12229 /*
12230 * In HFI, the mask needs to be 1 to allow interrupts.
12231 */
12232 if (enable) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12233 /* enable all interrupts */
12234 for (i = 0; i < CCE_NUM_INT_CSRS; i++)
12235 write_csr(dd, CCE_INT_MASK + (8*i), ~(u64)0);
12236
Easwar Hariharan8ebd4cf2016-02-03 14:31:14 -0800[diff] [blame]12237 init_qsfp_int(dd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12238 } else {
12239 for (i = 0; i < CCE_NUM_INT_CSRS; i++)
12240 write_csr(dd, CCE_INT_MASK + (8*i), 0ull);
12241 }
12242}
12243
12244/*
12245 * Clear all interrupt sources on the chip.
12246 */
12247static void clear_all_interrupts(struct hfi1_devdata *dd)
12248{
12249 int i;
12250
12251 for (i = 0; i < CCE_NUM_INT_CSRS; i++)
12252 write_csr(dd, CCE_INT_CLEAR + (8*i), ~(u64)0);
12253
12254 write_csr(dd, CCE_ERR_CLEAR, ~(u64)0);
12255 write_csr(dd, MISC_ERR_CLEAR, ~(u64)0);
12256 write_csr(dd, RCV_ERR_CLEAR, ~(u64)0);
12257 write_csr(dd, SEND_ERR_CLEAR, ~(u64)0);
12258 write_csr(dd, SEND_PIO_ERR_CLEAR, ~(u64)0);
12259 write_csr(dd, SEND_DMA_ERR_CLEAR, ~(u64)0);
12260 write_csr(dd, SEND_EGRESS_ERR_CLEAR, ~(u64)0);
12261 for (i = 0; i < dd->chip_send_contexts; i++)
12262 write_kctxt_csr(dd, i, SEND_CTXT_ERR_CLEAR, ~(u64)0);
12263 for (i = 0; i < dd->chip_sdma_engines; i++)
12264 write_kctxt_csr(dd, i, SEND_DMA_ENG_ERR_CLEAR, ~(u64)0);
12265
12266 write_csr(dd, DCC_ERR_FLG_CLR, ~(u64)0);
12267 write_csr(dd, DC_LCB_ERR_CLR, ~(u64)0);
12268 write_csr(dd, DC_DC8051_ERR_CLR, ~(u64)0);
12269}
12270
12271/* Move to pcie.c? */
12272static void disable_intx(struct pci_dev *pdev)
12273{
12274 pci_intx(pdev, 0);
12275}
12276
12277static void clean_up_interrupts(struct hfi1_devdata *dd)
12278{
12279 int i;
12280
12281 /* remove irqs - must happen before disabling/turning off */
12282 if (dd->num_msix_entries) {
12283 /* MSI-X */
12284 struct hfi1_msix_entry *me = dd->msix_entries;
12285
12286 for (i = 0; i < dd->num_msix_entries; i++, me++) {
12287 if (me->arg == NULL) /* => no irq, no affinity */
12288 break;
12289 irq_set_affinity_hint(dd->msix_entries[i].msix.vector,
12290 NULL);
12291 free_irq(me->msix.vector, me->arg);
12292 }
12293 } else {
12294 /* INTx */
12295 if (dd->requested_intx_irq) {
12296 free_irq(dd->pcidev->irq, dd);
12297 dd->requested_intx_irq = 0;
12298 }
12299 }
12300
12301 /* turn off interrupts */
12302 if (dd->num_msix_entries) {
12303 /* MSI-X */
Amitoj Kaur Chawla6e5b6132015-11-01 16:14:32 +0530[diff] [blame]12304 pci_disable_msix(dd->pcidev);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12305 } else {
12306 /* INTx */
12307 disable_intx(dd->pcidev);
12308 }
12309
12310 /* clean structures */
12311 for (i = 0; i < dd->num_msix_entries; i++)
12312 free_cpumask_var(dd->msix_entries[i].mask);
12313 kfree(dd->msix_entries);
12314 dd->msix_entries = NULL;
12315 dd->num_msix_entries = 0;
12316}
12317
12318/*
12319 * Remap the interrupt source from the general handler to the given MSI-X
12320 * interrupt.
12321 */
12322static void remap_intr(struct hfi1_devdata *dd, int isrc, int msix_intr)
12323{
12324 u64 reg;
12325 int m, n;
12326
12327 /* clear from the handled mask of the general interrupt */
12328 m = isrc / 64;
12329 n = isrc % 64;
12330 dd->gi_mask[m] &= ~((u64)1 << n);
12331
12332 /* direct the chip source to the given MSI-X interrupt */
12333 m = isrc / 8;
12334 n = isrc % 8;
12335 reg = read_csr(dd, CCE_INT_MAP + (8*m));
12336 reg &= ~((u64)0xff << (8*n));
12337 reg |= ((u64)msix_intr & 0xff) << (8*n);
12338 write_csr(dd, CCE_INT_MAP + (8*m), reg);
12339}
12340
12341static void remap_sdma_interrupts(struct hfi1_devdata *dd,
12342 int engine, int msix_intr)
12343{
12344 /*
12345 * SDMA engine interrupt sources grouped by type, rather than
12346 * engine. Per-engine interrupts are as follows:
12347 * SDMA
12348 * SDMAProgress
12349 * SDMAIdle
12350 */
12351 remap_intr(dd, IS_SDMA_START + 0*TXE_NUM_SDMA_ENGINES + engine,
12352 msix_intr);
12353 remap_intr(dd, IS_SDMA_START + 1*TXE_NUM_SDMA_ENGINES + engine,
12354 msix_intr);
12355 remap_intr(dd, IS_SDMA_START + 2*TXE_NUM_SDMA_ENGINES + engine,
12356 msix_intr);
12357}
12358
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12359static int request_intx_irq(struct hfi1_devdata *dd)
12360{
12361 int ret;
12362
Jubin John98050712015-11-16 21:59:27 -0500[diff] [blame]12363 snprintf(dd->intx_name, sizeof(dd->intx_name), DRIVER_NAME "_%d",
12364 dd->unit);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12365 ret = request_irq(dd->pcidev->irq, general_interrupt,
12366 IRQF_SHARED, dd->intx_name, dd);
12367 if (ret)
12368 dd_dev_err(dd, "unable to request INTx interrupt, err %d\n",
12369 ret);
12370 else
12371 dd->requested_intx_irq = 1;
12372 return ret;
12373}
12374
12375static int request_msix_irqs(struct hfi1_devdata *dd)
12376{
12377 const struct cpumask *local_mask;
12378 cpumask_var_t def, rcv;
12379 bool def_ret, rcv_ret;
12380 int first_general, last_general;
12381 int first_sdma, last_sdma;
12382 int first_rx, last_rx;
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]12383 int first_cpu, curr_cpu;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12384 int rcv_cpu, sdma_cpu;
12385 int i, ret = 0, possible;
12386 int ht;
12387
12388 /* calculate the ranges we are going to use */
12389 first_general = 0;
12390 first_sdma = last_general = first_general + 1;
12391 first_rx = last_sdma = first_sdma + dd->num_sdma;
12392 last_rx = first_rx + dd->n_krcv_queues;
12393
12394 /*
12395 * Interrupt affinity.
12396 *
12397 * non-rcv avail gets a default mask that
12398 * starts as possible cpus with threads reset
12399 * and each rcv avail reset.
12400 *
12401 * rcv avail gets node relative 1 wrapping back
12402 * to the node relative 1 as necessary.
12403 *
12404 */
12405 local_mask = cpumask_of_pcibus(dd->pcidev->bus);
12406 /* if first cpu is invalid, use NUMA 0 */
12407 if (cpumask_first(local_mask) >= nr_cpu_ids)
12408 local_mask = topology_core_cpumask(0);
12409
12410 def_ret = zalloc_cpumask_var(&def, GFP_KERNEL);
12411 rcv_ret = zalloc_cpumask_var(&rcv, GFP_KERNEL);
12412 if (!def_ret || !rcv_ret)
12413 goto bail;
12414 /* use local mask as default */
12415 cpumask_copy(def, local_mask);
12416 possible = cpumask_weight(def);
12417 /* disarm threads from default */
12418 ht = cpumask_weight(
12419 topology_sibling_cpumask(cpumask_first(local_mask)));
12420 for (i = possible/ht; i < possible; i++)
12421 cpumask_clear_cpu(i, def);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12422 /* def now has full cores on chosen node*/
12423 first_cpu = cpumask_first(def);
12424 if (nr_cpu_ids >= first_cpu)
12425 first_cpu++;
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]12426 curr_cpu = first_cpu;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12427
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]12428 /* One context is reserved as control context */
12429 for (i = first_cpu; i < dd->n_krcv_queues + first_cpu - 1; i++) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12430 cpumask_clear_cpu(curr_cpu, def);
12431 cpumask_set_cpu(curr_cpu, rcv);
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]12432 curr_cpu = cpumask_next(curr_cpu, def);
12433 if (curr_cpu >= nr_cpu_ids)
12434 break;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12435 }
12436 /* def mask has non-rcv, rcv has recv mask */
12437 rcv_cpu = cpumask_first(rcv);
12438 sdma_cpu = cpumask_first(def);
12439
12440 /*
12441 * Sanity check - the code expects all SDMA chip source
12442 * interrupts to be in the same CSR, starting at bit 0. Verify
12443 * that this is true by checking the bit location of the start.
12444 */
12445 BUILD_BUG_ON(IS_SDMA_START % 64);
12446
12447 for (i = 0; i < dd->num_msix_entries; i++) {
12448 struct hfi1_msix_entry *me = &dd->msix_entries[i];
12449 const char *err_info;
12450 irq_handler_t handler;
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]12451 irq_handler_t thread = NULL;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12452 void *arg;
12453 int idx;
12454 struct hfi1_ctxtdata *rcd = NULL;
12455 struct sdma_engine *sde = NULL;
12456
12457 /* obtain the arguments to request_irq */
12458 if (first_general <= i && i < last_general) {
12459 idx = i - first_general;
12460 handler = general_interrupt;
12461 arg = dd;
12462 snprintf(me->name, sizeof(me->name),
Jubin John98050712015-11-16 21:59:27 -0500[diff] [blame]12463 DRIVER_NAME "_%d", dd->unit);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12464 err_info = "general";
12465 } else if (first_sdma <= i && i < last_sdma) {
12466 idx = i - first_sdma;
12467 sde = &dd->per_sdma[idx];
12468 handler = sdma_interrupt;
12469 arg = sde;
12470 snprintf(me->name, sizeof(me->name),
Jubin John98050712015-11-16 21:59:27 -0500[diff] [blame]12471 DRIVER_NAME "_%d sdma%d", dd->unit, idx);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12472 err_info = "sdma";
12473 remap_sdma_interrupts(dd, idx, i);
12474 } else if (first_rx <= i && i < last_rx) {
12475 idx = i - first_rx;
12476 rcd = dd->rcd[idx];
12477 /* no interrupt if no rcd */
12478 if (!rcd)
12479 continue;
12480 /*
12481 * Set the interrupt register and mask for this
12482 * context's interrupt.
12483 */
12484 rcd->ireg = (IS_RCVAVAIL_START+idx) / 64;
12485 rcd->imask = ((u64)1) <<
12486 ((IS_RCVAVAIL_START+idx) % 64);
12487 handler = receive_context_interrupt;
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]12488 thread = receive_context_thread;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12489 arg = rcd;
12490 snprintf(me->name, sizeof(me->name),
Jubin John98050712015-11-16 21:59:27 -0500[diff] [blame]12491 DRIVER_NAME "_%d kctxt%d", dd->unit, idx);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12492 err_info = "receive context";
Amitoj Kaur Chawla66c09332015-11-01 16:18:18 +0530[diff] [blame]12493 remap_intr(dd, IS_RCVAVAIL_START + idx, i);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12494 } else {
12495 /* not in our expected range - complain, then
12496 ignore it */
12497 dd_dev_err(dd,
12498 "Unexpected extra MSI-X interrupt %d\n", i);
12499 continue;
12500 }
12501 /* no argument, no interrupt */
12502 if (arg == NULL)
12503 continue;
12504 /* make sure the name is terminated */
12505 me->name[sizeof(me->name)-1] = 0;
12506
Dean Luickf4f30031c2015-10-26 10:28:44 -0400[diff] [blame]12507 ret = request_threaded_irq(me->msix.vector, handler, thread, 0,
12508 me->name, arg);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12509 if (ret) {
12510 dd_dev_err(dd,
12511 "unable to allocate %s interrupt, vector %d, index %d, err %d\n",
12512 err_info, me->msix.vector, idx, ret);
12513 return ret;
12514 }
12515 /*
12516 * assign arg after request_irq call, so it will be
12517 * cleaned up
12518 */
12519 me->arg = arg;
12520
12521 if (!zalloc_cpumask_var(
12522 &dd->msix_entries[i].mask,
12523 GFP_KERNEL))
12524 goto bail;
12525 if (handler == sdma_interrupt) {
12526 dd_dev_info(dd, "sdma engine %d cpu %d\n",
12527 sde->this_idx, sdma_cpu);
Mike Marciniszyn0a226ed2015-11-09 19:13:58 -0500[diff] [blame]12528 sde->cpu = sdma_cpu;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12529 cpumask_set_cpu(sdma_cpu, dd->msix_entries[i].mask);
12530 sdma_cpu = cpumask_next(sdma_cpu, def);
12531 if (sdma_cpu >= nr_cpu_ids)
12532 sdma_cpu = cpumask_first(def);
12533 } else if (handler == receive_context_interrupt) {
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]12534 dd_dev_info(dd, "rcv ctxt %d cpu %d\n", rcd->ctxt,
12535 (rcd->ctxt == HFI1_CTRL_CTXT) ?
12536 cpumask_first(def) : rcv_cpu);
12537 if (rcd->ctxt == HFI1_CTRL_CTXT) {
12538 /* map to first default */
12539 cpumask_set_cpu(cpumask_first(def),
12540 dd->msix_entries[i].mask);
12541 } else {
12542 cpumask_set_cpu(rcv_cpu,
12543 dd->msix_entries[i].mask);
12544 rcv_cpu = cpumask_next(rcv_cpu, rcv);
12545 if (rcv_cpu >= nr_cpu_ids)
12546 rcv_cpu = cpumask_first(rcv);
12547 }
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12548 } else {
12549 /* otherwise first def */
12550 dd_dev_info(dd, "%s cpu %d\n",
12551 err_info, cpumask_first(def));
12552 cpumask_set_cpu(
12553 cpumask_first(def), dd->msix_entries[i].mask);
12554 }
12555 irq_set_affinity_hint(
12556 dd->msix_entries[i].msix.vector,
12557 dd->msix_entries[i].mask);
12558 }
12559
12560out:
12561 free_cpumask_var(def);
12562 free_cpumask_var(rcv);
12563 return ret;
12564bail:
12565 ret = -ENOMEM;
12566 goto out;
12567}
12568
12569/*
12570 * Set the general handler to accept all interrupts, remap all
12571 * chip interrupts back to MSI-X 0.
12572 */
12573static void reset_interrupts(struct hfi1_devdata *dd)
12574{
12575 int i;
12576
12577 /* all interrupts handled by the general handler */
12578 for (i = 0; i < CCE_NUM_INT_CSRS; i++)
12579 dd->gi_mask[i] = ~(u64)0;
12580
12581 /* all chip interrupts map to MSI-X 0 */
12582 for (i = 0; i < CCE_NUM_INT_MAP_CSRS; i++)
12583 write_csr(dd, CCE_INT_MAP + (8*i), 0);
12584}
12585
12586static int set_up_interrupts(struct hfi1_devdata *dd)
12587{
12588 struct hfi1_msix_entry *entries;
12589 u32 total, request;
12590 int i, ret;
12591 int single_interrupt = 0; /* we expect to have all the interrupts */
12592
12593 /*
12594 * Interrupt count:
12595 * 1 general, "slow path" interrupt (includes the SDMA engines
12596 * slow source, SDMACleanupDone)
12597 * N interrupts - one per used SDMA engine
12598 * M interrupt - one per kernel receive context
12599 */
12600 total = 1 + dd->num_sdma + dd->n_krcv_queues;
12601
12602 entries = kcalloc(total, sizeof(*entries), GFP_KERNEL);
12603 if (!entries) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12604 ret = -ENOMEM;
12605 goto fail;
12606 }
12607 /* 1-1 MSI-X entry assignment */
12608 for (i = 0; i < total; i++)
12609 entries[i].msix.entry = i;
12610
12611 /* ask for MSI-X interrupts */
12612 request = total;
12613 request_msix(dd, &request, entries);
12614
12615 if (request == 0) {
12616 /* using INTx */
12617 /* dd->num_msix_entries already zero */
12618 kfree(entries);
12619 single_interrupt = 1;
12620 dd_dev_err(dd, "MSI-X failed, using INTx interrupts\n");
12621 } else {
12622 /* using MSI-X */
12623 dd->num_msix_entries = request;
12624 dd->msix_entries = entries;
12625
12626 if (request != total) {
12627 /* using MSI-X, with reduced interrupts */
12628 dd_dev_err(
12629 dd,
12630 "cannot handle reduced interrupt case, want %u, got %u\n",
12631 total, request);
12632 ret = -EINVAL;
12633 goto fail;
12634 }
12635 dd_dev_info(dd, "%u MSI-X interrupts allocated\n", total);
12636 }
12637
12638 /* mask all interrupts */
12639 set_intr_state(dd, 0);
12640 /* clear all pending interrupts */
12641 clear_all_interrupts(dd);
12642
12643 /* reset general handler mask, chip MSI-X mappings */
12644 reset_interrupts(dd);
12645
12646 if (single_interrupt)
12647 ret = request_intx_irq(dd);
12648 else
12649 ret = request_msix_irqs(dd);
12650 if (ret)
12651 goto fail;
12652
12653 return 0;
12654
12655fail:
12656 clean_up_interrupts(dd);
12657 return ret;
12658}
12659
12660/*
12661 * Set up context values in dd. Sets:
12662 *
12663 * num_rcv_contexts - number of contexts being used
12664 * n_krcv_queues - number of kernel contexts
12665 * first_user_ctxt - first non-kernel context in array of contexts
12666 * freectxts - number of free user contexts
12667 * num_send_contexts - number of PIO send contexts being used
12668 */
12669static int set_up_context_variables(struct hfi1_devdata *dd)
12670{
12671 int num_kernel_contexts;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12672 int total_contexts;
12673 int ret;
12674 unsigned ngroups;
12675
12676 /*
12677 * Kernel contexts: (to be fixed later):
12678 * - min or 2 or 1 context/numa
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]12679 * - Context 0 - control context (VL15/multicast/error)
12680 * - Context 1 - default context
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12681 */
12682 if (n_krcvqs)
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]12683 /*
12684 * Don't count context 0 in n_krcvqs since
12685 * is isn't used for normal verbs traffic.
12686 *
12687 * krcvqs will reflect number of kernel
12688 * receive contexts above 0.
12689 */
12690 num_kernel_contexts = n_krcvqs + MIN_KERNEL_KCTXTS - 1;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12691 else
jubin.john@intel.com0edf80e2016-01-11 18:30:55 -0500[diff] [blame]12692 num_kernel_contexts = num_online_nodes() + 1;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12693 num_kernel_contexts =
12694 max_t(int, MIN_KERNEL_KCTXTS, num_kernel_contexts);
12695 /*
12696 * Every kernel receive context needs an ACK send context.
12697 * one send context is allocated for each VL{0-7} and VL15
12698 */
12699 if (num_kernel_contexts > (dd->chip_send_contexts - num_vls - 1)) {
12700 dd_dev_err(dd,
12701 "Reducing # kernel rcv contexts to: %d, from %d\n",
12702 (int)(dd->chip_send_contexts - num_vls - 1),
12703 (int)num_kernel_contexts);
12704 num_kernel_contexts = dd->chip_send_contexts - num_vls - 1;
12705 }
12706 /*
12707 * User contexts: (to be fixed later)
Sebastian Sanchez2ce6bf22015-12-11 08:44:48 -0500[diff] [blame]12708 * - default to 1 user context per CPU if num_user_contexts is
12709 * negative
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12710 */
Sebastian Sanchez2ce6bf22015-12-11 08:44:48 -0500[diff] [blame]12711 if (num_user_contexts < 0)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12712 num_user_contexts = num_online_cpus();
12713
12714 total_contexts = num_kernel_contexts + num_user_contexts;
12715
12716 /*
12717 * Adjust the counts given a global max.
12718 */
12719 if (total_contexts > dd->chip_rcv_contexts) {
12720 dd_dev_err(dd,
12721 "Reducing # user receive contexts to: %d, from %d\n",
12722 (int)(dd->chip_rcv_contexts - num_kernel_contexts),
12723 (int)num_user_contexts);
12724 num_user_contexts = dd->chip_rcv_contexts - num_kernel_contexts;
12725 /* recalculate */
12726 total_contexts = num_kernel_contexts + num_user_contexts;
12727 }
12728
12729 /* the first N are kernel contexts, the rest are user contexts */
12730 dd->num_rcv_contexts = total_contexts;
12731 dd->n_krcv_queues = num_kernel_contexts;
12732 dd->first_user_ctxt = num_kernel_contexts;
12733 dd->freectxts = num_user_contexts;
12734 dd_dev_info(dd,
12735 "rcv contexts: chip %d, used %d (kernel %d, user %d)\n",
12736 (int)dd->chip_rcv_contexts,
12737 (int)dd->num_rcv_contexts,
12738 (int)dd->n_krcv_queues,
12739 (int)dd->num_rcv_contexts - dd->n_krcv_queues);
12740
12741 /*
12742 * Receive array allocation:
12743 * All RcvArray entries are divided into groups of 8. This
12744 * is required by the hardware and will speed up writes to
12745 * consecutive entries by using write-combining of the entire
12746 * cacheline.
12747 *
12748 * The number of groups are evenly divided among all contexts.
12749 * any left over groups will be given to the first N user
12750 * contexts.
12751 */
12752 dd->rcv_entries.group_size = RCV_INCREMENT;
12753 ngroups = dd->chip_rcv_array_count / dd->rcv_entries.group_size;
12754 dd->rcv_entries.ngroups = ngroups / dd->num_rcv_contexts;
12755 dd->rcv_entries.nctxt_extra = ngroups -
12756 (dd->num_rcv_contexts * dd->rcv_entries.ngroups);
12757 dd_dev_info(dd, "RcvArray groups %u, ctxts extra %u\n",
12758 dd->rcv_entries.ngroups,
12759 dd->rcv_entries.nctxt_extra);
12760 if (dd->rcv_entries.ngroups * dd->rcv_entries.group_size >
12761 MAX_EAGER_ENTRIES * 2) {
12762 dd->rcv_entries.ngroups = (MAX_EAGER_ENTRIES * 2) /
12763 dd->rcv_entries.group_size;
12764 dd_dev_info(dd,
12765 "RcvArray group count too high, change to %u\n",
12766 dd->rcv_entries.ngroups);
12767 dd->rcv_entries.nctxt_extra = 0;
12768 }
12769 /*
12770 * PIO send contexts
12771 */
12772 ret = init_sc_pools_and_sizes(dd);
12773 if (ret >= 0) { /* success */
12774 dd->num_send_contexts = ret;
12775 dd_dev_info(
12776 dd,
12777 "send contexts: chip %d, used %d (kernel %d, ack %d, user %d)\n",
12778 dd->chip_send_contexts,
12779 dd->num_send_contexts,
12780 dd->sc_sizes[SC_KERNEL].count,
12781 dd->sc_sizes[SC_ACK].count,
12782 dd->sc_sizes[SC_USER].count);
12783 ret = 0; /* success */
12784 }
12785
12786 return ret;
12787}
12788
12789/*
12790 * Set the device/port partition key table. The MAD code
12791 * will ensure that, at least, the partial management
12792 * partition key is present in the table.
12793 */
12794static void set_partition_keys(struct hfi1_pportdata *ppd)
12795{
12796 struct hfi1_devdata *dd = ppd->dd;
12797 u64 reg = 0;
12798 int i;
12799
12800 dd_dev_info(dd, "Setting partition keys\n");
12801 for (i = 0; i < hfi1_get_npkeys(dd); i++) {
12802 reg |= (ppd->pkeys[i] &
12803 RCV_PARTITION_KEY_PARTITION_KEY_A_MASK) <<
12804 ((i % 4) *
12805 RCV_PARTITION_KEY_PARTITION_KEY_B_SHIFT);
12806 /* Each register holds 4 PKey values. */
12807 if ((i % 4) == 3) {
12808 write_csr(dd, RCV_PARTITION_KEY +
12809 ((i - 3) * 2), reg);
12810 reg = 0;
12811 }
12812 }
12813
12814 /* Always enable HW pkeys check when pkeys table is set */
12815 add_rcvctrl(dd, RCV_CTRL_RCV_PARTITION_KEY_ENABLE_SMASK);
12816}
12817
12818/*
12819 * These CSRs and memories are uninitialized on reset and must be
12820 * written before reading to set the ECC/parity bits.
12821 *
12822 * NOTE: All user context CSRs that are not mmaped write-only
12823 * (e.g. the TID flows) must be initialized even if the driver never
12824 * reads them.
12825 */
12826static void write_uninitialized_csrs_and_memories(struct hfi1_devdata *dd)
12827{
12828 int i, j;
12829
12830 /* CceIntMap */
12831 for (i = 0; i < CCE_NUM_INT_MAP_CSRS; i++)
12832 write_csr(dd, CCE_INT_MAP+(8*i), 0);
12833
12834 /* SendCtxtCreditReturnAddr */
12835 for (i = 0; i < dd->chip_send_contexts; i++)
12836 write_kctxt_csr(dd, i, SEND_CTXT_CREDIT_RETURN_ADDR, 0);
12837
12838 /* PIO Send buffers */
12839 /* SDMA Send buffers */
12840 /* These are not normally read, and (presently) have no method
12841 to be read, so are not pre-initialized */
12842
12843 /* RcvHdrAddr */
12844 /* RcvHdrTailAddr */
12845 /* RcvTidFlowTable */
12846 for (i = 0; i < dd->chip_rcv_contexts; i++) {
12847 write_kctxt_csr(dd, i, RCV_HDR_ADDR, 0);
12848 write_kctxt_csr(dd, i, RCV_HDR_TAIL_ADDR, 0);
12849 for (j = 0; j < RXE_NUM_TID_FLOWS; j++)
12850 write_uctxt_csr(dd, i, RCV_TID_FLOW_TABLE+(8*j), 0);
12851 }
12852
12853 /* RcvArray */
12854 for (i = 0; i < dd->chip_rcv_array_count; i++)
12855 write_csr(dd, RCV_ARRAY + (8*i),
12856 RCV_ARRAY_RT_WRITE_ENABLE_SMASK);
12857
12858 /* RcvQPMapTable */
12859 for (i = 0; i < 32; i++)
12860 write_csr(dd, RCV_QP_MAP_TABLE + (8 * i), 0);
12861}
12862
12863/*
12864 * Use the ctrl_bits in CceCtrl to clear the status_bits in CceStatus.
12865 */
12866static void clear_cce_status(struct hfi1_devdata *dd, u64 status_bits,
12867 u64 ctrl_bits)
12868{
12869 unsigned long timeout;
12870 u64 reg;
12871
12872 /* is the condition present? */
12873 reg = read_csr(dd, CCE_STATUS);
12874 if ((reg & status_bits) == 0)
12875 return;
12876
12877 /* clear the condition */
12878 write_csr(dd, CCE_CTRL, ctrl_bits);
12879
12880 /* wait for the condition to clear */
12881 timeout = jiffies + msecs_to_jiffies(CCE_STATUS_TIMEOUT);
12882 while (1) {
12883 reg = read_csr(dd, CCE_STATUS);
12884 if ((reg & status_bits) == 0)
12885 return;
12886 if (time_after(jiffies, timeout)) {
12887 dd_dev_err(dd,
12888 "Timeout waiting for CceStatus to clear bits 0x%llx, remaining 0x%llx\n",
12889 status_bits, reg & status_bits);
12890 return;
12891 }
12892 udelay(1);
12893 }
12894}
12895
12896/* set CCE CSRs to chip reset defaults */
12897static void reset_cce_csrs(struct hfi1_devdata *dd)
12898{
12899 int i;
12900
12901 /* CCE_REVISION read-only */
12902 /* CCE_REVISION2 read-only */
12903 /* CCE_CTRL - bits clear automatically */
12904 /* CCE_STATUS read-only, use CceCtrl to clear */
12905 clear_cce_status(dd, ALL_FROZE, CCE_CTRL_SPC_UNFREEZE_SMASK);
12906 clear_cce_status(dd, ALL_TXE_PAUSE, CCE_CTRL_TXE_RESUME_SMASK);
12907 clear_cce_status(dd, ALL_RXE_PAUSE, CCE_CTRL_RXE_RESUME_SMASK);
12908 for (i = 0; i < CCE_NUM_SCRATCH; i++)
12909 write_csr(dd, CCE_SCRATCH + (8 * i), 0);
12910 /* CCE_ERR_STATUS read-only */
12911 write_csr(dd, CCE_ERR_MASK, 0);
12912 write_csr(dd, CCE_ERR_CLEAR, ~0ull);
12913 /* CCE_ERR_FORCE leave alone */
12914 for (i = 0; i < CCE_NUM_32_BIT_COUNTERS; i++)
12915 write_csr(dd, CCE_COUNTER_ARRAY32 + (8 * i), 0);
12916 write_csr(dd, CCE_DC_CTRL, CCE_DC_CTRL_RESETCSR);
12917 /* CCE_PCIE_CTRL leave alone */
12918 for (i = 0; i < CCE_NUM_MSIX_VECTORS; i++) {
12919 write_csr(dd, CCE_MSIX_TABLE_LOWER + (8 * i), 0);
12920 write_csr(dd, CCE_MSIX_TABLE_UPPER + (8 * i),
12921 CCE_MSIX_TABLE_UPPER_RESETCSR);
12922 }
12923 for (i = 0; i < CCE_NUM_MSIX_PBAS; i++) {
12924 /* CCE_MSIX_PBA read-only */
12925 write_csr(dd, CCE_MSIX_INT_GRANTED, ~0ull);
12926 write_csr(dd, CCE_MSIX_VEC_CLR_WITHOUT_INT, ~0ull);
12927 }
12928 for (i = 0; i < CCE_NUM_INT_MAP_CSRS; i++)
12929 write_csr(dd, CCE_INT_MAP, 0);
12930 for (i = 0; i < CCE_NUM_INT_CSRS; i++) {
12931 /* CCE_INT_STATUS read-only */
12932 write_csr(dd, CCE_INT_MASK + (8 * i), 0);
12933 write_csr(dd, CCE_INT_CLEAR + (8 * i), ~0ull);
12934 /* CCE_INT_FORCE leave alone */
12935 /* CCE_INT_BLOCKED read-only */
12936 }
12937 for (i = 0; i < CCE_NUM_32_BIT_INT_COUNTERS; i++)
12938 write_csr(dd, CCE_INT_COUNTER_ARRAY32 + (8 * i), 0);
12939}
12940
12941/* set ASIC CSRs to chip reset defaults */
12942static void reset_asic_csrs(struct hfi1_devdata *dd)
12943{
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12944 int i;
12945
12946 /*
12947 * If the HFIs are shared between separate nodes or VMs,
12948 * then more will need to be done here. One idea is a module
12949 * parameter that returns early, letting the first power-on or
12950 * a known first load do the reset and blocking all others.
12951 */
12952
Easwar Hariharan7c03ed82015-10-26 10:28:28 -0400[diff] [blame]12953 if (!(dd->flags & HFI1_DO_INIT_ASIC))
12954 return;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12955
12956 if (dd->icode != ICODE_FPGA_EMULATION) {
12957 /* emulation does not have an SBus - leave these alone */
12958 /*
12959 * All writes to ASIC_CFG_SBUS_REQUEST do something.
12960 * Notes:
12961 * o The reset is not zero if aimed at the core. See the
12962 * SBus documentation for details.
12963 * o If the SBus firmware has been updated (e.g. by the BIOS),
12964 * will the reset revert that?
12965 */
12966 /* ASIC_CFG_SBUS_REQUEST leave alone */
12967 write_csr(dd, ASIC_CFG_SBUS_EXECUTE, 0);
12968 }
12969 /* ASIC_SBUS_RESULT read-only */
12970 write_csr(dd, ASIC_STS_SBUS_COUNTERS, 0);
12971 for (i = 0; i < ASIC_NUM_SCRATCH; i++)
12972 write_csr(dd, ASIC_CFG_SCRATCH + (8 * i), 0);
12973 write_csr(dd, ASIC_CFG_MUTEX, 0); /* this will clear it */
Easwar Hariharan7c03ed82015-10-26 10:28:28 -0400[diff] [blame]12974
12975 /* We might want to retain this state across FLR if we ever use it */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12976 write_csr(dd, ASIC_CFG_DRV_STR, 0);
Easwar Hariharan7c03ed82015-10-26 10:28:28 -0400[diff] [blame]12977
Jareer Abdel-Qader4ef98982015-11-06 20:07:00 -0500[diff] [blame]12978 /* ASIC_CFG_THERM_POLL_EN leave alone */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]12979 /* ASIC_STS_THERM read-only */
12980 /* ASIC_CFG_RESET leave alone */
12981
12982 write_csr(dd, ASIC_PCIE_SD_HOST_CMD, 0);
12983 /* ASIC_PCIE_SD_HOST_STATUS read-only */
12984 write_csr(dd, ASIC_PCIE_SD_INTRPT_DATA_CODE, 0);
12985 write_csr(dd, ASIC_PCIE_SD_INTRPT_ENABLE, 0);
12986 /* ASIC_PCIE_SD_INTRPT_PROGRESS read-only */
12987 write_csr(dd, ASIC_PCIE_SD_INTRPT_STATUS, ~0ull); /* clear */
12988 /* ASIC_HFI0_PCIE_SD_INTRPT_RSPD_DATA read-only */
12989 /* ASIC_HFI1_PCIE_SD_INTRPT_RSPD_DATA read-only */
12990 for (i = 0; i < 16; i++)
12991 write_csr(dd, ASIC_PCIE_SD_INTRPT_LIST + (8 * i), 0);
12992
12993 /* ASIC_GPIO_IN read-only */
12994 write_csr(dd, ASIC_GPIO_OE, 0);
12995 write_csr(dd, ASIC_GPIO_INVERT, 0);
12996 write_csr(dd, ASIC_GPIO_OUT, 0);
12997 write_csr(dd, ASIC_GPIO_MASK, 0);
12998 /* ASIC_GPIO_STATUS read-only */
12999 write_csr(dd, ASIC_GPIO_CLEAR, ~0ull);
13000 /* ASIC_GPIO_FORCE leave alone */
13001
13002 /* ASIC_QSFP1_IN read-only */
13003 write_csr(dd, ASIC_QSFP1_OE, 0);
13004 write_csr(dd, ASIC_QSFP1_INVERT, 0);
13005 write_csr(dd, ASIC_QSFP1_OUT, 0);
13006 write_csr(dd, ASIC_QSFP1_MASK, 0);
13007 /* ASIC_QSFP1_STATUS read-only */
13008 write_csr(dd, ASIC_QSFP1_CLEAR, ~0ull);
13009 /* ASIC_QSFP1_FORCE leave alone */
13010
13011 /* ASIC_QSFP2_IN read-only */
13012 write_csr(dd, ASIC_QSFP2_OE, 0);
13013 write_csr(dd, ASIC_QSFP2_INVERT, 0);
13014 write_csr(dd, ASIC_QSFP2_OUT, 0);
13015 write_csr(dd, ASIC_QSFP2_MASK, 0);
13016 /* ASIC_QSFP2_STATUS read-only */
13017 write_csr(dd, ASIC_QSFP2_CLEAR, ~0ull);
13018 /* ASIC_QSFP2_FORCE leave alone */
13019
13020 write_csr(dd, ASIC_EEP_CTL_STAT, ASIC_EEP_CTL_STAT_RESETCSR);
13021 /* this also writes a NOP command, clearing paging mode */
13022 write_csr(dd, ASIC_EEP_ADDR_CMD, 0);
13023 write_csr(dd, ASIC_EEP_DATA, 0);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13024}
13025
13026/* set MISC CSRs to chip reset defaults */
13027static void reset_misc_csrs(struct hfi1_devdata *dd)
13028{
13029 int i;
13030
13031 for (i = 0; i < 32; i++) {
13032 write_csr(dd, MISC_CFG_RSA_R2 + (8 * i), 0);
13033 write_csr(dd, MISC_CFG_RSA_SIGNATURE + (8 * i), 0);
13034 write_csr(dd, MISC_CFG_RSA_MODULUS + (8 * i), 0);
13035 }
13036 /* MISC_CFG_SHA_PRELOAD leave alone - always reads 0 and can
13037 only be written 128-byte chunks */
13038 /* init RSA engine to clear lingering errors */
13039 write_csr(dd, MISC_CFG_RSA_CMD, 1);
13040 write_csr(dd, MISC_CFG_RSA_MU, 0);
13041 write_csr(dd, MISC_CFG_FW_CTRL, 0);
13042 /* MISC_STS_8051_DIGEST read-only */
13043 /* MISC_STS_SBM_DIGEST read-only */
13044 /* MISC_STS_PCIE_DIGEST read-only */
13045 /* MISC_STS_FAB_DIGEST read-only */
13046 /* MISC_ERR_STATUS read-only */
13047 write_csr(dd, MISC_ERR_MASK, 0);
13048 write_csr(dd, MISC_ERR_CLEAR, ~0ull);
13049 /* MISC_ERR_FORCE leave alone */
13050}
13051
13052/* set TXE CSRs to chip reset defaults */
13053static void reset_txe_csrs(struct hfi1_devdata *dd)
13054{
13055 int i;
13056
13057 /*
13058 * TXE Kernel CSRs
13059 */
13060 write_csr(dd, SEND_CTRL, 0);
13061 __cm_reset(dd, 0); /* reset CM internal state */
13062 /* SEND_CONTEXTS read-only */
13063 /* SEND_DMA_ENGINES read-only */
13064 /* SEND_PIO_MEM_SIZE read-only */
13065 /* SEND_DMA_MEM_SIZE read-only */
13066 write_csr(dd, SEND_HIGH_PRIORITY_LIMIT, 0);
13067 pio_reset_all(dd); /* SEND_PIO_INIT_CTXT */
13068 /* SEND_PIO_ERR_STATUS read-only */
13069 write_csr(dd, SEND_PIO_ERR_MASK, 0);
13070 write_csr(dd, SEND_PIO_ERR_CLEAR, ~0ull);
13071 /* SEND_PIO_ERR_FORCE leave alone */
13072 /* SEND_DMA_ERR_STATUS read-only */
13073 write_csr(dd, SEND_DMA_ERR_MASK, 0);
13074 write_csr(dd, SEND_DMA_ERR_CLEAR, ~0ull);
13075 /* SEND_DMA_ERR_FORCE leave alone */
13076 /* SEND_EGRESS_ERR_STATUS read-only */
13077 write_csr(dd, SEND_EGRESS_ERR_MASK, 0);
13078 write_csr(dd, SEND_EGRESS_ERR_CLEAR, ~0ull);
13079 /* SEND_EGRESS_ERR_FORCE leave alone */
13080 write_csr(dd, SEND_BTH_QP, 0);
13081 write_csr(dd, SEND_STATIC_RATE_CONTROL, 0);
13082 write_csr(dd, SEND_SC2VLT0, 0);
13083 write_csr(dd, SEND_SC2VLT1, 0);
13084 write_csr(dd, SEND_SC2VLT2, 0);
13085 write_csr(dd, SEND_SC2VLT3, 0);
13086 write_csr(dd, SEND_LEN_CHECK0, 0);
13087 write_csr(dd, SEND_LEN_CHECK1, 0);
13088 /* SEND_ERR_STATUS read-only */
13089 write_csr(dd, SEND_ERR_MASK, 0);
13090 write_csr(dd, SEND_ERR_CLEAR, ~0ull);
13091 /* SEND_ERR_FORCE read-only */
13092 for (i = 0; i < VL_ARB_LOW_PRIO_TABLE_SIZE; i++)
13093 write_csr(dd, SEND_LOW_PRIORITY_LIST + (8*i), 0);
13094 for (i = 0; i < VL_ARB_HIGH_PRIO_TABLE_SIZE; i++)
13095 write_csr(dd, SEND_HIGH_PRIORITY_LIST + (8*i), 0);
13096 for (i = 0; i < dd->chip_send_contexts/NUM_CONTEXTS_PER_SET; i++)
13097 write_csr(dd, SEND_CONTEXT_SET_CTRL + (8*i), 0);
13098 for (i = 0; i < TXE_NUM_32_BIT_COUNTER; i++)
13099 write_csr(dd, SEND_COUNTER_ARRAY32 + (8*i), 0);
13100 for (i = 0; i < TXE_NUM_64_BIT_COUNTER; i++)
13101 write_csr(dd, SEND_COUNTER_ARRAY64 + (8*i), 0);
13102 write_csr(dd, SEND_CM_CTRL, SEND_CM_CTRL_RESETCSR);
13103 write_csr(dd, SEND_CM_GLOBAL_CREDIT,
13104 SEND_CM_GLOBAL_CREDIT_RESETCSR);
13105 /* SEND_CM_CREDIT_USED_STATUS read-only */
13106 write_csr(dd, SEND_CM_TIMER_CTRL, 0);
13107 write_csr(dd, SEND_CM_LOCAL_AU_TABLE0_TO3, 0);
13108 write_csr(dd, SEND_CM_LOCAL_AU_TABLE4_TO7, 0);
13109 write_csr(dd, SEND_CM_REMOTE_AU_TABLE0_TO3, 0);
13110 write_csr(dd, SEND_CM_REMOTE_AU_TABLE4_TO7, 0);
13111 for (i = 0; i < TXE_NUM_DATA_VL; i++)
13112 write_csr(dd, SEND_CM_CREDIT_VL + (8*i), 0);
13113 write_csr(dd, SEND_CM_CREDIT_VL15, 0);
13114 /* SEND_CM_CREDIT_USED_VL read-only */
13115 /* SEND_CM_CREDIT_USED_VL15 read-only */
13116 /* SEND_EGRESS_CTXT_STATUS read-only */
13117 /* SEND_EGRESS_SEND_DMA_STATUS read-only */
13118 write_csr(dd, SEND_EGRESS_ERR_INFO, ~0ull);
13119 /* SEND_EGRESS_ERR_INFO read-only */
13120 /* SEND_EGRESS_ERR_SOURCE read-only */
13121
13122 /*
13123 * TXE Per-Context CSRs
13124 */
13125 for (i = 0; i < dd->chip_send_contexts; i++) {
13126 write_kctxt_csr(dd, i, SEND_CTXT_CTRL, 0);
13127 write_kctxt_csr(dd, i, SEND_CTXT_CREDIT_CTRL, 0);
13128 write_kctxt_csr(dd, i, SEND_CTXT_CREDIT_RETURN_ADDR, 0);
13129 write_kctxt_csr(dd, i, SEND_CTXT_CREDIT_FORCE, 0);
13130 write_kctxt_csr(dd, i, SEND_CTXT_ERR_MASK, 0);
13131 write_kctxt_csr(dd, i, SEND_CTXT_ERR_CLEAR, ~0ull);
13132 write_kctxt_csr(dd, i, SEND_CTXT_CHECK_ENABLE, 0);
13133 write_kctxt_csr(dd, i, SEND_CTXT_CHECK_VL, 0);
13134 write_kctxt_csr(dd, i, SEND_CTXT_CHECK_JOB_KEY, 0);
13135 write_kctxt_csr(dd, i, SEND_CTXT_CHECK_PARTITION_KEY, 0);
13136 write_kctxt_csr(dd, i, SEND_CTXT_CHECK_SLID, 0);
13137 write_kctxt_csr(dd, i, SEND_CTXT_CHECK_OPCODE, 0);
13138 }
13139
13140 /*
13141 * TXE Per-SDMA CSRs
13142 */
13143 for (i = 0; i < dd->chip_sdma_engines; i++) {
13144 write_kctxt_csr(dd, i, SEND_DMA_CTRL, 0);
13145 /* SEND_DMA_STATUS read-only */
13146 write_kctxt_csr(dd, i, SEND_DMA_BASE_ADDR, 0);
13147 write_kctxt_csr(dd, i, SEND_DMA_LEN_GEN, 0);
13148 write_kctxt_csr(dd, i, SEND_DMA_TAIL, 0);
13149 /* SEND_DMA_HEAD read-only */
13150 write_kctxt_csr(dd, i, SEND_DMA_HEAD_ADDR, 0);
13151 write_kctxt_csr(dd, i, SEND_DMA_PRIORITY_THLD, 0);
13152 /* SEND_DMA_IDLE_CNT read-only */
13153 write_kctxt_csr(dd, i, SEND_DMA_RELOAD_CNT, 0);
13154 write_kctxt_csr(dd, i, SEND_DMA_DESC_CNT, 0);
13155 /* SEND_DMA_DESC_FETCHED_CNT read-only */
13156 /* SEND_DMA_ENG_ERR_STATUS read-only */
13157 write_kctxt_csr(dd, i, SEND_DMA_ENG_ERR_MASK, 0);
13158 write_kctxt_csr(dd, i, SEND_DMA_ENG_ERR_CLEAR, ~0ull);
13159 /* SEND_DMA_ENG_ERR_FORCE leave alone */
13160 write_kctxt_csr(dd, i, SEND_DMA_CHECK_ENABLE, 0);
13161 write_kctxt_csr(dd, i, SEND_DMA_CHECK_VL, 0);
13162 write_kctxt_csr(dd, i, SEND_DMA_CHECK_JOB_KEY, 0);
13163 write_kctxt_csr(dd, i, SEND_DMA_CHECK_PARTITION_KEY, 0);
13164 write_kctxt_csr(dd, i, SEND_DMA_CHECK_SLID, 0);
13165 write_kctxt_csr(dd, i, SEND_DMA_CHECK_OPCODE, 0);
13166 write_kctxt_csr(dd, i, SEND_DMA_MEMORY, 0);
13167 }
13168}
13169
13170/*
13171 * Expect on entry:
13172 * o Packet ingress is disabled, i.e. RcvCtrl.RcvPortEnable == 0
13173 */
13174static void init_rbufs(struct hfi1_devdata *dd)
13175{
13176 u64 reg;
13177 int count;
13178
13179 /*
13180 * Wait for DMA to stop: RxRbufPktPending and RxPktInProgress are
13181 * clear.
13182 */
13183 count = 0;
13184 while (1) {
13185 reg = read_csr(dd, RCV_STATUS);
13186 if ((reg & (RCV_STATUS_RX_RBUF_PKT_PENDING_SMASK
13187 | RCV_STATUS_RX_PKT_IN_PROGRESS_SMASK)) == 0)
13188 break;
13189 /*
13190 * Give up after 1ms - maximum wait time.
13191 *
13192 * RBuf size is 148KiB. Slowest possible is PCIe Gen1 x1 at
13193 * 250MB/s bandwidth. Lower rate to 66% for overhead to get:
13194 * 148 KB / (66% * 250MB/s) = 920us
13195 */
13196 if (count++ > 500) {
13197 dd_dev_err(dd,
13198 "%s: in-progress DMA not clearing: RcvStatus 0x%llx, continuing\n",
13199 __func__, reg);
13200 break;
13201 }
13202 udelay(2); /* do not busy-wait the CSR */
13203 }
13204
13205 /* start the init - expect RcvCtrl to be 0 */
13206 write_csr(dd, RCV_CTRL, RCV_CTRL_RX_RBUF_INIT_SMASK);
13207
13208 /*
13209 * Read to force the write of Rcvtrl.RxRbufInit. There is a brief
13210 * period after the write before RcvStatus.RxRbufInitDone is valid.
13211 * The delay in the first run through the loop below is sufficient and
13212 * required before the first read of RcvStatus.RxRbufInintDone.
13213 */
13214 read_csr(dd, RCV_CTRL);
13215
13216 /* wait for the init to finish */
13217 count = 0;
13218 while (1) {
13219 /* delay is required first time through - see above */
13220 udelay(2); /* do not busy-wait the CSR */
13221 reg = read_csr(dd, RCV_STATUS);
13222 if (reg & (RCV_STATUS_RX_RBUF_INIT_DONE_SMASK))
13223 break;
13224
13225 /* give up after 100us - slowest possible at 33MHz is 73us */
13226 if (count++ > 50) {
13227 dd_dev_err(dd,
13228 "%s: RcvStatus.RxRbufInit not set, continuing\n",
13229 __func__);
13230 break;
13231 }
13232 }
13233}
13234
13235/* set RXE CSRs to chip reset defaults */
13236static void reset_rxe_csrs(struct hfi1_devdata *dd)
13237{
13238 int i, j;
13239
13240 /*
13241 * RXE Kernel CSRs
13242 */
13243 write_csr(dd, RCV_CTRL, 0);
13244 init_rbufs(dd);
13245 /* RCV_STATUS read-only */
13246 /* RCV_CONTEXTS read-only */
13247 /* RCV_ARRAY_CNT read-only */
13248 /* RCV_BUF_SIZE read-only */
13249 write_csr(dd, RCV_BTH_QP, 0);
13250 write_csr(dd, RCV_MULTICAST, 0);
13251 write_csr(dd, RCV_BYPASS, 0);
13252 write_csr(dd, RCV_VL15, 0);
13253 /* this is a clear-down */
13254 write_csr(dd, RCV_ERR_INFO,
13255 RCV_ERR_INFO_RCV_EXCESS_BUFFER_OVERRUN_SMASK);
13256 /* RCV_ERR_STATUS read-only */
13257 write_csr(dd, RCV_ERR_MASK, 0);
13258 write_csr(dd, RCV_ERR_CLEAR, ~0ull);
13259 /* RCV_ERR_FORCE leave alone */
13260 for (i = 0; i < 32; i++)
13261 write_csr(dd, RCV_QP_MAP_TABLE + (8 * i), 0);
13262 for (i = 0; i < 4; i++)
13263 write_csr(dd, RCV_PARTITION_KEY + (8 * i), 0);
13264 for (i = 0; i < RXE_NUM_32_BIT_COUNTERS; i++)
13265 write_csr(dd, RCV_COUNTER_ARRAY32 + (8 * i), 0);
13266 for (i = 0; i < RXE_NUM_64_BIT_COUNTERS; i++)
13267 write_csr(dd, RCV_COUNTER_ARRAY64 + (8 * i), 0);
13268 for (i = 0; i < RXE_NUM_RSM_INSTANCES; i++) {
13269 write_csr(dd, RCV_RSM_CFG + (8 * i), 0);
13270 write_csr(dd, RCV_RSM_SELECT + (8 * i), 0);
13271 write_csr(dd, RCV_RSM_MATCH + (8 * i), 0);
13272 }
13273 for (i = 0; i < 32; i++)
13274 write_csr(dd, RCV_RSM_MAP_TABLE + (8 * i), 0);
13275
13276 /*
13277 * RXE Kernel and User Per-Context CSRs
13278 */
13279 for (i = 0; i < dd->chip_rcv_contexts; i++) {
13280 /* kernel */
13281 write_kctxt_csr(dd, i, RCV_CTXT_CTRL, 0);
13282 /* RCV_CTXT_STATUS read-only */
13283 write_kctxt_csr(dd, i, RCV_EGR_CTRL, 0);
13284 write_kctxt_csr(dd, i, RCV_TID_CTRL, 0);
13285 write_kctxt_csr(dd, i, RCV_KEY_CTRL, 0);
13286 write_kctxt_csr(dd, i, RCV_HDR_ADDR, 0);
13287 write_kctxt_csr(dd, i, RCV_HDR_CNT, 0);
13288 write_kctxt_csr(dd, i, RCV_HDR_ENT_SIZE, 0);
13289 write_kctxt_csr(dd, i, RCV_HDR_SIZE, 0);
13290 write_kctxt_csr(dd, i, RCV_HDR_TAIL_ADDR, 0);
13291 write_kctxt_csr(dd, i, RCV_AVAIL_TIME_OUT, 0);
13292 write_kctxt_csr(dd, i, RCV_HDR_OVFL_CNT, 0);
13293
13294 /* user */
13295 /* RCV_HDR_TAIL read-only */
13296 write_uctxt_csr(dd, i, RCV_HDR_HEAD, 0);
13297 /* RCV_EGR_INDEX_TAIL read-only */
13298 write_uctxt_csr(dd, i, RCV_EGR_INDEX_HEAD, 0);
13299 /* RCV_EGR_OFFSET_TAIL read-only */
13300 for (j = 0; j < RXE_NUM_TID_FLOWS; j++) {
13301 write_uctxt_csr(dd, i, RCV_TID_FLOW_TABLE + (8 * j),
13302 0);
13303 }
13304 }
13305}
13306
13307/*
13308 * Set sc2vl tables.
13309 *
13310 * They power on to zeros, so to avoid send context errors
13311 * they need to be set:
13312 *
13313 * SC 0-7 -> VL 0-7 (respectively)
13314 * SC 15 -> VL 15
13315 * otherwise
13316 * -> VL 0
13317 */
13318static void init_sc2vl_tables(struct hfi1_devdata *dd)
13319{
13320 int i;
13321 /* init per architecture spec, constrained by hardware capability */
13322
13323 /* HFI maps sent packets */
13324 write_csr(dd, SEND_SC2VLT0, SC2VL_VAL(
13325 0,
13326 0, 0, 1, 1,
13327 2, 2, 3, 3,
13328 4, 4, 5, 5,
13329 6, 6, 7, 7));
13330 write_csr(dd, SEND_SC2VLT1, SC2VL_VAL(
13331 1,
13332 8, 0, 9, 0,
13333 10, 0, 11, 0,
13334 12, 0, 13, 0,
13335 14, 0, 15, 15));
13336 write_csr(dd, SEND_SC2VLT2, SC2VL_VAL(
13337 2,
13338 16, 0, 17, 0,
13339 18, 0, 19, 0,
13340 20, 0, 21, 0,
13341 22, 0, 23, 0));
13342 write_csr(dd, SEND_SC2VLT3, SC2VL_VAL(
13343 3,
13344 24, 0, 25, 0,
13345 26, 0, 27, 0,
13346 28, 0, 29, 0,
13347 30, 0, 31, 0));
13348
13349 /* DC maps received packets */
13350 write_csr(dd, DCC_CFG_SC_VL_TABLE_15_0, DC_SC_VL_VAL(
13351 15_0,
13352 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7,
13353 8, 0, 9, 0, 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 15));
13354 write_csr(dd, DCC_CFG_SC_VL_TABLE_31_16, DC_SC_VL_VAL(
13355 31_16,
13356 16, 0, 17, 0, 18, 0, 19, 0, 20, 0, 21, 0, 22, 0, 23, 0,
13357 24, 0, 25, 0, 26, 0, 27, 0, 28, 0, 29, 0, 30, 0, 31, 0));
13358
13359 /* initialize the cached sc2vl values consistently with h/w */
13360 for (i = 0; i < 32; i++) {
13361 if (i < 8 || i == 15)
13362 *((u8 *)(dd->sc2vl) + i) = (u8)i;
13363 else
13364 *((u8 *)(dd->sc2vl) + i) = 0;
13365 }
13366}
13367
13368/*
13369 * Read chip sizes and then reset parts to sane, disabled, values. We cannot
13370 * depend on the chip going through a power-on reset - a driver may be loaded
13371 * and unloaded many times.
13372 *
13373 * Do not write any CSR values to the chip in this routine - there may be
13374 * a reset following the (possible) FLR in this routine.
13375 *
13376 */
13377static void init_chip(struct hfi1_devdata *dd)
13378{
13379 int i;
13380
13381 /*
13382 * Put the HFI CSRs in a known state.
13383 * Combine this with a DC reset.
13384 *
13385 * Stop the device from doing anything while we do a
13386 * reset. We know there are no other active users of
13387 * the device since we are now in charge. Turn off
13388 * off all outbound and inbound traffic and make sure
13389 * the device does not generate any interrupts.
13390 */
13391
13392 /* disable send contexts and SDMA engines */
13393 write_csr(dd, SEND_CTRL, 0);
13394 for (i = 0; i < dd->chip_send_contexts; i++)
13395 write_kctxt_csr(dd, i, SEND_CTXT_CTRL, 0);
13396 for (i = 0; i < dd->chip_sdma_engines; i++)
13397 write_kctxt_csr(dd, i, SEND_DMA_CTRL, 0);
13398 /* disable port (turn off RXE inbound traffic) and contexts */
13399 write_csr(dd, RCV_CTRL, 0);
13400 for (i = 0; i < dd->chip_rcv_contexts; i++)
13401 write_csr(dd, RCV_CTXT_CTRL, 0);
13402 /* mask all interrupt sources */
13403 for (i = 0; i < CCE_NUM_INT_CSRS; i++)
13404 write_csr(dd, CCE_INT_MASK + (8*i), 0ull);
13405
13406 /*
13407 * DC Reset: do a full DC reset before the register clear.
13408 * A recommended length of time to hold is one CSR read,
13409 * so reread the CceDcCtrl. Then, hold the DC in reset
13410 * across the clear.
13411 */
13412 write_csr(dd, CCE_DC_CTRL, CCE_DC_CTRL_DC_RESET_SMASK);
13413 (void) read_csr(dd, CCE_DC_CTRL);
13414
13415 if (use_flr) {
13416 /*
13417 * A FLR will reset the SPC core and part of the PCIe.
13418 * The parts that need to be restored have already been
13419 * saved.
13420 */
13421 dd_dev_info(dd, "Resetting CSRs with FLR\n");
13422
13423 /* do the FLR, the DC reset will remain */
13424 hfi1_pcie_flr(dd);
13425
13426 /* restore command and BARs */
13427 restore_pci_variables(dd);
13428
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]13429 if (is_ax(dd)) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13430 dd_dev_info(dd, "Resetting CSRs with FLR\n");
13431 hfi1_pcie_flr(dd);
13432 restore_pci_variables(dd);
13433 }
13434
Easwar Hariharan7c03ed82015-10-26 10:28:28 -0400[diff] [blame]13435 reset_asic_csrs(dd);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13436 } else {
13437 dd_dev_info(dd, "Resetting CSRs with writes\n");
13438 reset_cce_csrs(dd);
13439 reset_txe_csrs(dd);
13440 reset_rxe_csrs(dd);
13441 reset_asic_csrs(dd);
13442 reset_misc_csrs(dd);
13443 }
13444 /* clear the DC reset */
13445 write_csr(dd, CCE_DC_CTRL, 0);
Easwar Hariharan7c03ed82015-10-26 10:28:28 -0400[diff] [blame]13446
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13447 /* Set the LED off */
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]13448 if (is_ax(dd))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13449 setextled(dd, 0);
13450 /*
13451 * Clear the QSFP reset.
Easwar Hariharan72a67ba2015-11-06 20:06:57 -0500[diff] [blame]13452 * An FLR enforces a 0 on all out pins. The driver does not touch
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13453 * ASIC_QSFPn_OUT otherwise. This leaves RESET_N low and
Easwar Hariharan72a67ba2015-11-06 20:06:57 -0500[diff] [blame]13454 * anything plugged constantly in reset, if it pays attention
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13455 * to RESET_N.
Easwar Hariharan72a67ba2015-11-06 20:06:57 -0500[diff] [blame]13456 * Prime examples of this are optical cables. Set all pins high.
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13457 * I2CCLK and I2CDAT will change per direction, and INT_N and
13458 * MODPRS_N are input only and their value is ignored.
13459 */
Easwar Hariharan72a67ba2015-11-06 20:06:57 -0500[diff] [blame]13460 write_csr(dd, ASIC_QSFP1_OUT, 0x1f);
13461 write_csr(dd, ASIC_QSFP2_OUT, 0x1f);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13462}
13463
13464static void init_early_variables(struct hfi1_devdata *dd)
13465{
13466 int i;
13467
13468 /* assign link credit variables */
13469 dd->vau = CM_VAU;
13470 dd->link_credits = CM_GLOBAL_CREDITS;
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]13471 if (is_ax(dd))
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13472 dd->link_credits--;
13473 dd->vcu = cu_to_vcu(hfi1_cu);
13474 /* enough room for 8 MAD packets plus header - 17K */
13475 dd->vl15_init = (8 * (2048 + 128)) / vau_to_au(dd->vau);
13476 if (dd->vl15_init > dd->link_credits)
13477 dd->vl15_init = dd->link_credits;
13478
13479 write_uninitialized_csrs_and_memories(dd);
13480
13481 if (HFI1_CAP_IS_KSET(PKEY_CHECK))
13482 for (i = 0; i < dd->num_pports; i++) {
13483 struct hfi1_pportdata *ppd = &dd->pport[i];
13484
13485 set_partition_keys(ppd);
13486 }
13487 init_sc2vl_tables(dd);
13488}
13489
13490static void init_kdeth_qp(struct hfi1_devdata *dd)
13491{
13492 /* user changed the KDETH_QP */
13493 if (kdeth_qp != 0 && kdeth_qp >= 0xff) {
13494 /* out of range or illegal value */
13495 dd_dev_err(dd, "Invalid KDETH queue pair prefix, ignoring");
13496 kdeth_qp = 0;
13497 }
13498 if (kdeth_qp == 0) /* not set, or failed range check */
13499 kdeth_qp = DEFAULT_KDETH_QP;
13500
13501 write_csr(dd, SEND_BTH_QP,
13502 (kdeth_qp & SEND_BTH_QP_KDETH_QP_MASK)
13503 << SEND_BTH_QP_KDETH_QP_SHIFT);
13504
13505 write_csr(dd, RCV_BTH_QP,
13506 (kdeth_qp & RCV_BTH_QP_KDETH_QP_MASK)
13507 << RCV_BTH_QP_KDETH_QP_SHIFT);
13508}
13509
13510/**
13511 * init_qpmap_table
13512 * @dd - device data
13513 * @first_ctxt - first context
13514 * @last_ctxt - first context
13515 *
13516 * This return sets the qpn mapping table that
13517 * is indexed by qpn[8:1].
13518 *
13519 * The routine will round robin the 256 settings
13520 * from first_ctxt to last_ctxt.
13521 *
13522 * The first/last looks ahead to having specialized
13523 * receive contexts for mgmt and bypass. Normal
13524 * verbs traffic will assumed to be on a range
13525 * of receive contexts.
13526 */
13527static void init_qpmap_table(struct hfi1_devdata *dd,
13528 u32 first_ctxt,
13529 u32 last_ctxt)
13530{
13531 u64 reg = 0;
13532 u64 regno = RCV_QP_MAP_TABLE;
13533 int i;
13534 u64 ctxt = first_ctxt;
13535
13536 for (i = 0; i < 256;) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13537 reg |= ctxt << (8 * (i % 8));
13538 i++;
13539 ctxt++;
13540 if (ctxt > last_ctxt)
13541 ctxt = first_ctxt;
13542 if (i % 8 == 0) {
13543 write_csr(dd, regno, reg);
13544 reg = 0;
13545 regno += 8;
13546 }
13547 }
13548 if (i % 8)
13549 write_csr(dd, regno, reg);
13550
13551 add_rcvctrl(dd, RCV_CTRL_RCV_QP_MAP_ENABLE_SMASK
13552 | RCV_CTRL_RCV_BYPASS_ENABLE_SMASK);
13553}
13554
13555/**
13556 * init_qos - init RX qos
13557 * @dd - device data
13558 * @first_context
13559 *
13560 * This routine initializes Rule 0 and the
13561 * RSM map table to implement qos.
13562 *
13563 * If all of the limit tests succeed,
13564 * qos is applied based on the array
13565 * interpretation of krcvqs where
13566 * entry 0 is VL0.
13567 *
13568 * The number of vl bits (n) and the number of qpn
13569 * bits (m) are computed to feed both the RSM map table
13570 * and the single rule.
13571 *
13572 */
13573static void init_qos(struct hfi1_devdata *dd, u32 first_ctxt)
13574{
13575 u8 max_by_vl = 0;
13576 unsigned qpns_per_vl, ctxt, i, qpn, n = 1, m;
13577 u64 *rsmmap;
13578 u64 reg;
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]13579 u8 rxcontext = is_ax(dd) ? 0 : 0xff; /* 0 is default if a0 ver. */
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13580
13581 /* validate */
13582 if (dd->n_krcv_queues <= MIN_KERNEL_KCTXTS ||
13583 num_vls == 1 ||
13584 krcvqsset <= 1)
13585 goto bail;
13586 for (i = 0; i < min_t(unsigned, num_vls, krcvqsset); i++)
13587 if (krcvqs[i] > max_by_vl)
13588 max_by_vl = krcvqs[i];
13589 if (max_by_vl > 32)
13590 goto bail;
13591 qpns_per_vl = __roundup_pow_of_two(max_by_vl);
13592 /* determine bits vl */
13593 n = ilog2(num_vls);
13594 /* determine bits for qpn */
13595 m = ilog2(qpns_per_vl);
13596 if ((m + n) > 7)
13597 goto bail;
13598 if (num_vls * qpns_per_vl > dd->chip_rcv_contexts)
13599 goto bail;
13600 rsmmap = kmalloc_array(NUM_MAP_REGS, sizeof(u64), GFP_KERNEL);
Easwar Hariharan859bcad2015-12-10 11:13:38 -0500[diff] [blame]13601 if (!rsmmap)
13602 goto bail;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13603 memset(rsmmap, rxcontext, NUM_MAP_REGS * sizeof(u64));
13604 /* init the local copy of the table */
13605 for (i = 0, ctxt = first_ctxt; i < num_vls; i++) {
13606 unsigned tctxt;
13607
13608 for (qpn = 0, tctxt = ctxt;
13609 krcvqs[i] && qpn < qpns_per_vl; qpn++) {
13610 unsigned idx, regoff, regidx;
13611
13612 /* generate index <= 128 */
13613 idx = (qpn << n) ^ i;
13614 regoff = (idx % 8) * 8;
13615 regidx = idx / 8;
13616 reg = rsmmap[regidx];
13617 /* replace 0xff with context number */
13618 reg &= ~(RCV_RSM_MAP_TABLE_RCV_CONTEXT_A_MASK
13619 << regoff);
13620 reg |= (u64)(tctxt++) << regoff;
13621 rsmmap[regidx] = reg;
13622 if (tctxt == ctxt + krcvqs[i])
13623 tctxt = ctxt;
13624 }
13625 ctxt += krcvqs[i];
13626 }
13627 /* flush cached copies to chip */
13628 for (i = 0; i < NUM_MAP_REGS; i++)
13629 write_csr(dd, RCV_RSM_MAP_TABLE + (8 * i), rsmmap[i]);
13630 /* add rule0 */
13631 write_csr(dd, RCV_RSM_CFG /* + (8 * 0) */,
13632 RCV_RSM_CFG_ENABLE_OR_CHAIN_RSM0_MASK
13633 << RCV_RSM_CFG_ENABLE_OR_CHAIN_RSM0_SHIFT |
13634 2ull << RCV_RSM_CFG_PACKET_TYPE_SHIFT);
13635 write_csr(dd, RCV_RSM_SELECT /* + (8 * 0) */,
13636 LRH_BTH_MATCH_OFFSET
13637 << RCV_RSM_SELECT_FIELD1_OFFSET_SHIFT |
13638 LRH_SC_MATCH_OFFSET << RCV_RSM_SELECT_FIELD2_OFFSET_SHIFT |
13639 LRH_SC_SELECT_OFFSET << RCV_RSM_SELECT_INDEX1_OFFSET_SHIFT |
13640 ((u64)n) << RCV_RSM_SELECT_INDEX1_WIDTH_SHIFT |
13641 QPN_SELECT_OFFSET << RCV_RSM_SELECT_INDEX2_OFFSET_SHIFT |
13642 ((u64)m + (u64)n) << RCV_RSM_SELECT_INDEX2_WIDTH_SHIFT);
13643 write_csr(dd, RCV_RSM_MATCH /* + (8 * 0) */,
13644 LRH_BTH_MASK << RCV_RSM_MATCH_MASK1_SHIFT |
13645 LRH_BTH_VALUE << RCV_RSM_MATCH_VALUE1_SHIFT |
13646 LRH_SC_MASK << RCV_RSM_MATCH_MASK2_SHIFT |
13647 LRH_SC_VALUE << RCV_RSM_MATCH_VALUE2_SHIFT);
13648 /* Enable RSM */
13649 add_rcvctrl(dd, RCV_CTRL_RCV_RSM_ENABLE_SMASK);
13650 kfree(rsmmap);
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]13651 /* map everything else to first context */
13652 init_qpmap_table(dd, FIRST_KERNEL_KCTXT, MIN_KERNEL_KCTXTS - 1);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13653 dd->qos_shift = n + 1;
13654 return;
13655bail:
13656 dd->qos_shift = 1;
Niranjana Vishwanathapura82c26112015-11-11 00:35:19 -0500[diff] [blame]13657 init_qpmap_table(dd, FIRST_KERNEL_KCTXT, dd->n_krcv_queues - 1);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13658}
13659
13660static void init_rxe(struct hfi1_devdata *dd)
13661{
13662 /* enable all receive errors */
13663 write_csr(dd, RCV_ERR_MASK, ~0ull);
13664 /* setup QPN map table - start where VL15 context leaves off */
13665 init_qos(
13666 dd,
13667 dd->n_krcv_queues > MIN_KERNEL_KCTXTS ? MIN_KERNEL_KCTXTS : 0);
13668 /*
13669 * make sure RcvCtrl.RcvWcb <= PCIe Device Control
13670 * Register Max_Payload_Size (PCI_EXP_DEVCTL in Linux PCIe config
13671 * space, PciCfgCap2.MaxPayloadSize in HFI). There is only one
13672 * invalid configuration: RcvCtrl.RcvWcb set to its max of 256 and
13673 * Max_PayLoad_Size set to its minimum of 128.
13674 *
13675 * Presently, RcvCtrl.RcvWcb is not modified from its default of 0
13676 * (64 bytes). Max_Payload_Size is possibly modified upward in
13677 * tune_pcie_caps() which is called after this routine.
13678 */
13679}
13680
13681static void init_other(struct hfi1_devdata *dd)
13682{
13683 /* enable all CCE errors */
13684 write_csr(dd, CCE_ERR_MASK, ~0ull);
13685 /* enable *some* Misc errors */
13686 write_csr(dd, MISC_ERR_MASK, DRIVER_MISC_MASK);
13687 /* enable all DC errors, except LCB */
13688 write_csr(dd, DCC_ERR_FLG_EN, ~0ull);
13689 write_csr(dd, DC_DC8051_ERR_EN, ~0ull);
13690}
13691
13692/*
13693 * Fill out the given AU table using the given CU. A CU is defined in terms
13694 * AUs. The table is a an encoding: given the index, how many AUs does that
13695 * represent?
13696 *
13697 * NOTE: Assumes that the register layout is the same for the
13698 * local and remote tables.
13699 */
13700static void assign_cm_au_table(struct hfi1_devdata *dd, u32 cu,
13701 u32 csr0to3, u32 csr4to7)
13702{
13703 write_csr(dd, csr0to3,
13704 0ull <<
13705 SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE0_SHIFT
13706 | 1ull <<
13707 SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE1_SHIFT
13708 | 2ull * cu <<
13709 SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE2_SHIFT
13710 | 4ull * cu <<
13711 SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE3_SHIFT);
13712 write_csr(dd, csr4to7,
13713 8ull * cu <<
13714 SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE4_SHIFT
13715 | 16ull * cu <<
13716 SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE5_SHIFT
13717 | 32ull * cu <<
13718 SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE6_SHIFT
13719 | 64ull * cu <<
13720 SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE7_SHIFT);
13721
13722}
13723
13724static void assign_local_cm_au_table(struct hfi1_devdata *dd, u8 vcu)
13725{
13726 assign_cm_au_table(dd, vcu_to_cu(vcu), SEND_CM_LOCAL_AU_TABLE0_TO3,
13727 SEND_CM_LOCAL_AU_TABLE4_TO7);
13728}
13729
13730void assign_remote_cm_au_table(struct hfi1_devdata *dd, u8 vcu)
13731{
13732 assign_cm_au_table(dd, vcu_to_cu(vcu), SEND_CM_REMOTE_AU_TABLE0_TO3,
13733 SEND_CM_REMOTE_AU_TABLE4_TO7);
13734}
13735
13736static void init_txe(struct hfi1_devdata *dd)
13737{
13738 int i;
13739
13740 /* enable all PIO, SDMA, general, and Egress errors */
13741 write_csr(dd, SEND_PIO_ERR_MASK, ~0ull);
13742 write_csr(dd, SEND_DMA_ERR_MASK, ~0ull);
13743 write_csr(dd, SEND_ERR_MASK, ~0ull);
13744 write_csr(dd, SEND_EGRESS_ERR_MASK, ~0ull);
13745
13746 /* enable all per-context and per-SDMA engine errors */
13747 for (i = 0; i < dd->chip_send_contexts; i++)
13748 write_kctxt_csr(dd, i, SEND_CTXT_ERR_MASK, ~0ull);
13749 for (i = 0; i < dd->chip_sdma_engines; i++)
13750 write_kctxt_csr(dd, i, SEND_DMA_ENG_ERR_MASK, ~0ull);
13751
13752 /* set the local CU to AU mapping */
13753 assign_local_cm_au_table(dd, dd->vcu);
13754
13755 /*
13756 * Set reasonable default for Credit Return Timer
13757 * Don't set on Simulator - causes it to choke.
13758 */
13759 if (dd->icode != ICODE_FUNCTIONAL_SIMULATOR)
13760 write_csr(dd, SEND_CM_TIMER_CTRL, HFI1_CREDIT_RETURN_RATE);
13761}
13762
13763int hfi1_set_ctxt_jkey(struct hfi1_devdata *dd, unsigned ctxt, u16 jkey)
13764{
13765 struct hfi1_ctxtdata *rcd = dd->rcd[ctxt];
13766 unsigned sctxt;
13767 int ret = 0;
13768 u64 reg;
13769
13770 if (!rcd || !rcd->sc) {
13771 ret = -EINVAL;
13772 goto done;
13773 }
13774 sctxt = rcd->sc->hw_context;
13775 reg = SEND_CTXT_CHECK_JOB_KEY_MASK_SMASK | /* mask is always 1's */
13776 ((jkey & SEND_CTXT_CHECK_JOB_KEY_VALUE_MASK) <<
13777 SEND_CTXT_CHECK_JOB_KEY_VALUE_SHIFT);
13778 /* JOB_KEY_ALLOW_PERMISSIVE is not allowed by default */
13779 if (HFI1_CAP_KGET_MASK(rcd->flags, ALLOW_PERM_JKEY))
13780 reg |= SEND_CTXT_CHECK_JOB_KEY_ALLOW_PERMISSIVE_SMASK;
13781 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_JOB_KEY, reg);
13782 /*
13783 * Enable send-side J_KEY integrity check, unless this is A0 h/w
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13784 */
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]13785 if (!is_ax(dd)) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13786 reg = read_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE);
13787 reg |= SEND_CTXT_CHECK_ENABLE_CHECK_JOB_KEY_SMASK;
13788 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE, reg);
13789 }
13790
13791 /* Enable J_KEY check on receive context. */
13792 reg = RCV_KEY_CTRL_JOB_KEY_ENABLE_SMASK |
13793 ((jkey & RCV_KEY_CTRL_JOB_KEY_VALUE_MASK) <<
13794 RCV_KEY_CTRL_JOB_KEY_VALUE_SHIFT);
13795 write_kctxt_csr(dd, ctxt, RCV_KEY_CTRL, reg);
13796done:
13797 return ret;
13798}
13799
13800int hfi1_clear_ctxt_jkey(struct hfi1_devdata *dd, unsigned ctxt)
13801{
13802 struct hfi1_ctxtdata *rcd = dd->rcd[ctxt];
13803 unsigned sctxt;
13804 int ret = 0;
13805 u64 reg;
13806
13807 if (!rcd || !rcd->sc) {
13808 ret = -EINVAL;
13809 goto done;
13810 }
13811 sctxt = rcd->sc->hw_context;
13812 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_JOB_KEY, 0);
13813 /*
13814 * Disable send-side J_KEY integrity check, unless this is A0 h/w.
13815 * This check would not have been enabled for A0 h/w, see
13816 * set_ctxt_jkey().
13817 */
Mike Marciniszyn995deaf2015-11-16 21:59:29 -0500[diff] [blame]13818 if (!is_ax(dd)) {
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13819 reg = read_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE);
13820 reg &= ~SEND_CTXT_CHECK_ENABLE_CHECK_JOB_KEY_SMASK;
13821 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE, reg);
13822 }
13823 /* Turn off the J_KEY on the receive side */
13824 write_kctxt_csr(dd, ctxt, RCV_KEY_CTRL, 0);
13825done:
13826 return ret;
13827}
13828
13829int hfi1_set_ctxt_pkey(struct hfi1_devdata *dd, unsigned ctxt, u16 pkey)
13830{
13831 struct hfi1_ctxtdata *rcd;
13832 unsigned sctxt;
13833 int ret = 0;
13834 u64 reg;
13835
13836 if (ctxt < dd->num_rcv_contexts)
13837 rcd = dd->rcd[ctxt];
13838 else {
13839 ret = -EINVAL;
13840 goto done;
13841 }
13842 if (!rcd || !rcd->sc) {
13843 ret = -EINVAL;
13844 goto done;
13845 }
13846 sctxt = rcd->sc->hw_context;
13847 reg = ((u64)pkey & SEND_CTXT_CHECK_PARTITION_KEY_VALUE_MASK) <<
13848 SEND_CTXT_CHECK_PARTITION_KEY_VALUE_SHIFT;
13849 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_PARTITION_KEY, reg);
13850 reg = read_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE);
13851 reg |= SEND_CTXT_CHECK_ENABLE_CHECK_PARTITION_KEY_SMASK;
13852 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE, reg);
13853done:
13854 return ret;
13855}
13856
13857int hfi1_clear_ctxt_pkey(struct hfi1_devdata *dd, unsigned ctxt)
13858{
13859 struct hfi1_ctxtdata *rcd;
13860 unsigned sctxt;
13861 int ret = 0;
13862 u64 reg;
13863
13864 if (ctxt < dd->num_rcv_contexts)
13865 rcd = dd->rcd[ctxt];
13866 else {
13867 ret = -EINVAL;
13868 goto done;
13869 }
13870 if (!rcd || !rcd->sc) {
13871 ret = -EINVAL;
13872 goto done;
13873 }
13874 sctxt = rcd->sc->hw_context;
13875 reg = read_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE);
13876 reg &= ~SEND_CTXT_CHECK_ENABLE_CHECK_PARTITION_KEY_SMASK;
13877 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_ENABLE, reg);
13878 write_kctxt_csr(dd, sctxt, SEND_CTXT_CHECK_PARTITION_KEY, 0);
13879done:
13880 return ret;
13881}
13882
13883/*
13884 * Start doing the clean up the the chip. Our clean up happens in multiple
13885 * stages and this is just the first.
13886 */
13887void hfi1_start_cleanup(struct hfi1_devdata *dd)
13888{
13889 free_cntrs(dd);
13890 free_rcverr(dd);
13891 clean_up_interrupts(dd);
13892}
13893
13894#define HFI_BASE_GUID(dev) \
13895 ((dev)->base_guid & ~(1ULL << GUID_HFI_INDEX_SHIFT))
13896
13897/*
13898 * Certain chip functions need to be initialized only once per asic
13899 * instead of per-device. This function finds the peer device and
13900 * checks whether that chip initialization needs to be done by this
13901 * device.
13902 */
13903static void asic_should_init(struct hfi1_devdata *dd)
13904{
13905 unsigned long flags;
13906 struct hfi1_devdata *tmp, *peer = NULL;
13907
13908 spin_lock_irqsave(&hfi1_devs_lock, flags);
13909 /* Find our peer device */
13910 list_for_each_entry(tmp, &hfi1_dev_list, list) {
13911 if ((HFI_BASE_GUID(dd) == HFI_BASE_GUID(tmp)) &&
13912 dd->unit != tmp->unit) {
13913 peer = tmp;
13914 break;
13915 }
13916 }
13917
13918 /*
13919 * "Claim" the ASIC for initialization if it hasn't been
13920 " "claimed" yet.
13921 */
13922 if (!peer || !(peer->flags & HFI1_DO_INIT_ASIC))
13923 dd->flags |= HFI1_DO_INIT_ASIC;
13924 spin_unlock_irqrestore(&hfi1_devs_lock, flags);
13925}
13926
Dean Luick5d9157a2015-11-16 21:59:34 -0500[diff] [blame]13927/*
13928 * Set dd->boardname. Use a generic name if a name is not returned from
13929 * EFI variable space.
13930 *
13931 * Return 0 on success, -ENOMEM if space could not be allocated.
13932 */
13933static int obtain_boardname(struct hfi1_devdata *dd)
13934{
13935 /* generic board description */
13936 const char generic[] =
13937 "Intel Omni-Path Host Fabric Interface Adapter 100 Series";
13938 unsigned long size;
13939 int ret;
13940
13941 ret = read_hfi1_efi_var(dd, "description", &size,
13942 (void **)&dd->boardname);
13943 if (ret) {
Dean Luick845f8762016-02-03 14:31:57 -0800[diff] [blame^]13944 dd_dev_info(dd, "Board description not found\n");
Dean Luick5d9157a2015-11-16 21:59:34 -0500[diff] [blame]13945 /* use generic description */
13946 dd->boardname = kstrdup(generic, GFP_KERNEL);
13947 if (!dd->boardname)
13948 return -ENOMEM;
13949 }
13950 return 0;
13951}
13952
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13953/**
Easwar Hariharan7c03ed82015-10-26 10:28:28 -0400[diff] [blame]13954 * Allocate and initialize the device structure for the hfi.
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]13955 * @dev: the pci_dev for hfi1_ib device
13956 * @ent: pci_device_id struct for this dev
13957 *
13958 * Also allocates, initializes, and returns the devdata struct for this
13959 * device instance
13960 *
13961 * This is global, and is called directly at init to set up the
13962 * chip-specific function pointers for later use.
13963 */
13964struct hfi1_devdata *hfi1_init_dd(struct pci_dev *pdev,
13965 const struct pci_device_id *ent)
13966{
13967 struct hfi1_devdata *dd;
13968 struct hfi1_pportdata *ppd;
13969 u64 reg;
13970 int i, ret;
13971 static const char * const inames[] = { /* implementation names */
13972 "RTL silicon",
13973 "RTL VCS simulation",
13974 "RTL FPGA emulation",
13975 "Functional simulator"
13976 };
13977
13978 dd = hfi1_alloc_devdata(pdev,
13979 NUM_IB_PORTS * sizeof(struct hfi1_pportdata));
13980 if (IS_ERR(dd))
13981 goto bail;
13982 ppd = dd->pport;
13983 for (i = 0; i < dd->num_pports; i++, ppd++) {
13984 int vl;
13985 /* init common fields */
13986 hfi1_init_pportdata(pdev, ppd, dd, 0, 1);
13987 /* DC supports 4 link widths */
13988 ppd->link_width_supported =
13989 OPA_LINK_WIDTH_1X | OPA_LINK_WIDTH_2X |
13990 OPA_LINK_WIDTH_3X | OPA_LINK_WIDTH_4X;
13991 ppd->link_width_downgrade_supported =
13992 ppd->link_width_supported;
13993 /* start out enabling only 4X */
13994 ppd->link_width_enabled = OPA_LINK_WIDTH_4X;
13995 ppd->link_width_downgrade_enabled =
13996 ppd->link_width_downgrade_supported;
13997 /* link width active is 0 when link is down */
13998 /* link width downgrade active is 0 when link is down */
13999
14000 if (num_vls < HFI1_MIN_VLS_SUPPORTED
14001 || num_vls > HFI1_MAX_VLS_SUPPORTED) {
14002 hfi1_early_err(&pdev->dev,
14003 "Invalid num_vls %u, using %u VLs\n",
14004 num_vls, HFI1_MAX_VLS_SUPPORTED);
14005 num_vls = HFI1_MAX_VLS_SUPPORTED;
14006 }
14007 ppd->vls_supported = num_vls;
14008 ppd->vls_operational = ppd->vls_supported;
14009 /* Set the default MTU. */
14010 for (vl = 0; vl < num_vls; vl++)
14011 dd->vld[vl].mtu = hfi1_max_mtu;
14012 dd->vld[15].mtu = MAX_MAD_PACKET;
14013 /*
14014 * Set the initial values to reasonable default, will be set
14015 * for real when link is up.
14016 */
14017 ppd->lstate = IB_PORT_DOWN;
14018 ppd->overrun_threshold = 0x4;
14019 ppd->phy_error_threshold = 0xf;
14020 ppd->port_crc_mode_enabled = link_crc_mask;
14021 /* initialize supported LTP CRC mode */
14022 ppd->port_ltp_crc_mode = cap_to_port_ltp(link_crc_mask) << 8;
14023 /* initialize enabled LTP CRC mode */
14024 ppd->port_ltp_crc_mode |= cap_to_port_ltp(link_crc_mask) << 4;
14025 /* start in offline */
14026 ppd->host_link_state = HLS_DN_OFFLINE;
14027 init_vl_arb_caches(ppd);
14028 }
14029
14030 dd->link_default = HLS_DN_POLL;
14031
14032 /*
14033 * Do remaining PCIe setup and save PCIe values in dd.
14034 * Any error printing is already done by the init code.
14035 * On return, we have the chip mapped.
14036 */
14037 ret = hfi1_pcie_ddinit(dd, pdev, ent);
14038 if (ret < 0)
14039 goto bail_free;
14040
14041 /* verify that reads actually work, save revision for reset check */
14042 dd->revision = read_csr(dd, CCE_REVISION);
14043 if (dd->revision == ~(u64)0) {
14044 dd_dev_err(dd, "cannot read chip CSRs\n");
14045 ret = -EINVAL;
14046 goto bail_cleanup;
14047 }
14048 dd->majrev = (dd->revision >> CCE_REVISION_CHIP_REV_MAJOR_SHIFT)
14049 & CCE_REVISION_CHIP_REV_MAJOR_MASK;
14050 dd->minrev = (dd->revision >> CCE_REVISION_CHIP_REV_MINOR_SHIFT)
14051 & CCE_REVISION_CHIP_REV_MINOR_MASK;
14052
14053 /* obtain the hardware ID - NOT related to unit, which is a
14054 software enumeration */
14055 reg = read_csr(dd, CCE_REVISION2);
14056 dd->hfi1_id = (reg >> CCE_REVISION2_HFI_ID_SHIFT)
14057 & CCE_REVISION2_HFI_ID_MASK;
14058 /* the variable size will remove unwanted bits */
14059 dd->icode = reg >> CCE_REVISION2_IMPL_CODE_SHIFT;
14060 dd->irev = reg >> CCE_REVISION2_IMPL_REVISION_SHIFT;
14061 dd_dev_info(dd, "Implementation: %s, revision 0x%x\n",
14062 dd->icode < ARRAY_SIZE(inames) ? inames[dd->icode] : "unknown",
14063 (int)dd->irev);
14064
14065 /* speeds the hardware can support */
14066 dd->pport->link_speed_supported = OPA_LINK_SPEED_25G;
14067 /* speeds allowed to run at */
14068 dd->pport->link_speed_enabled = dd->pport->link_speed_supported;
14069 /* give a reasonable active value, will be set on link up */
14070 dd->pport->link_speed_active = OPA_LINK_SPEED_25G;
14071
14072 dd->chip_rcv_contexts = read_csr(dd, RCV_CONTEXTS);
14073 dd->chip_send_contexts = read_csr(dd, SEND_CONTEXTS);
14074 dd->chip_sdma_engines = read_csr(dd, SEND_DMA_ENGINES);
14075 dd->chip_pio_mem_size = read_csr(dd, SEND_PIO_MEM_SIZE);
14076 dd->chip_sdma_mem_size = read_csr(dd, SEND_DMA_MEM_SIZE);
14077 /* fix up link widths for emulation _p */
14078 ppd = dd->pport;
14079 if (dd->icode == ICODE_FPGA_EMULATION && is_emulator_p(dd)) {
14080 ppd->link_width_supported =
14081 ppd->link_width_enabled =
14082 ppd->link_width_downgrade_supported =
14083 ppd->link_width_downgrade_enabled =
14084 OPA_LINK_WIDTH_1X;
14085 }
14086 /* insure num_vls isn't larger than number of sdma engines */
14087 if (HFI1_CAP_IS_KSET(SDMA) && num_vls > dd->chip_sdma_engines) {
14088 dd_dev_err(dd, "num_vls %u too large, using %u VLs\n",
Dean Luick11a59092015-12-01 15:38:18 -0500[diff] [blame]14089 num_vls, dd->chip_sdma_engines);
14090 num_vls = dd->chip_sdma_engines;
14091 ppd->vls_supported = dd->chip_sdma_engines;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14092 }
14093
14094 /*
14095 * Convert the ns parameter to the 64 * cclocks used in the CSR.
14096 * Limit the max if larger than the field holds. If timeout is
14097 * non-zero, then the calculated field will be at least 1.
14098 *
14099 * Must be after icode is set up - the cclock rate depends
14100 * on knowing the hardware being used.
14101 */
14102 dd->rcv_intr_timeout_csr = ns_to_cclock(dd, rcv_intr_timeout) / 64;
14103 if (dd->rcv_intr_timeout_csr >
14104 RCV_AVAIL_TIME_OUT_TIME_OUT_RELOAD_MASK)
14105 dd->rcv_intr_timeout_csr =
14106 RCV_AVAIL_TIME_OUT_TIME_OUT_RELOAD_MASK;
14107 else if (dd->rcv_intr_timeout_csr == 0 && rcv_intr_timeout)
14108 dd->rcv_intr_timeout_csr = 1;
14109
Easwar Hariharan7c03ed82015-10-26 10:28:28 -0400[diff] [blame]14110 /* needs to be done before we look for the peer device */
14111 read_guid(dd);
14112
14113 /* should this device init the ASIC block? */
14114 asic_should_init(dd);
14115
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14116 /* obtain chip sizes, reset chip CSRs */
14117 init_chip(dd);
14118
14119 /* read in the PCIe link speed information */
14120 ret = pcie_speeds(dd);
14121 if (ret)
14122 goto bail_cleanup;
14123
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14124 /* read in firmware */
14125 ret = hfi1_firmware_init(dd);
14126 if (ret)
14127 goto bail_cleanup;
14128
14129 /*
14130 * In general, the PCIe Gen3 transition must occur after the
14131 * chip has been idled (so it won't initiate any PCIe transactions
14132 * e.g. an interrupt) and before the driver changes any registers
14133 * (the transition will reset the registers).
14134 *
14135 * In particular, place this call after:
14136 * - init_chip() - the chip will not initiate any PCIe transactions
14137 * - pcie_speeds() - reads the current link speed
14138 * - hfi1_firmware_init() - the needed firmware is ready to be
14139 * downloaded
14140 */
14141 ret = do_pcie_gen3_transition(dd);
14142 if (ret)
14143 goto bail_cleanup;
14144
14145 /* start setting dd values and adjusting CSRs */
14146 init_early_variables(dd);
14147
14148 parse_platform_config(dd);
14149
Dean Luick5d9157a2015-11-16 21:59:34 -0500[diff] [blame]14150 ret = obtain_boardname(dd);
14151 if (ret)
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14152 goto bail_cleanup;
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14153
14154 snprintf(dd->boardversion, BOARD_VERS_MAX,
Dean Luick5d9157a2015-11-16 21:59:34 -0500[diff] [blame]14155 "ChipABI %u.%u, ChipRev %u.%u, SW Compat %llu\n",
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14156 HFI1_CHIP_VERS_MAJ, HFI1_CHIP_VERS_MIN,
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14157 (u32)dd->majrev,
14158 (u32)dd->minrev,
14159 (dd->revision >> CCE_REVISION_SW_SHIFT)
14160 & CCE_REVISION_SW_MASK);
14161
14162 ret = set_up_context_variables(dd);
14163 if (ret)
14164 goto bail_cleanup;
14165
14166 /* set initial RXE CSRs */
14167 init_rxe(dd);
14168 /* set initial TXE CSRs */
14169 init_txe(dd);
14170 /* set initial non-RXE, non-TXE CSRs */
14171 init_other(dd);
14172 /* set up KDETH QP prefix in both RX and TX CSRs */
14173 init_kdeth_qp(dd);
14174
14175 /* send contexts must be set up before receive contexts */
14176 ret = init_send_contexts(dd);
14177 if (ret)
14178 goto bail_cleanup;
14179
14180 ret = hfi1_create_ctxts(dd);
14181 if (ret)
14182 goto bail_cleanup;
14183
14184 dd->rcvhdrsize = DEFAULT_RCVHDRSIZE;
14185 /*
14186 * rcd[0] is guaranteed to be valid by this point. Also, all
14187 * context are using the same value, as per the module parameter.
14188 */
14189 dd->rhf_offset = dd->rcd[0]->rcvhdrqentsize - sizeof(u64) / sizeof(u32);
14190
14191 ret = init_pervl_scs(dd);
14192 if (ret)
14193 goto bail_cleanup;
14194
14195 /* sdma init */
14196 for (i = 0; i < dd->num_pports; ++i) {
14197 ret = sdma_init(dd, i);
14198 if (ret)
14199 goto bail_cleanup;
14200 }
14201
14202 /* use contexts created by hfi1_create_ctxts */
14203 ret = set_up_interrupts(dd);
14204 if (ret)
14205 goto bail_cleanup;
14206
14207 /* set up LCB access - must be after set_up_interrupts() */
14208 init_lcb_access(dd);
14209
14210 snprintf(dd->serial, SERIAL_MAX, "0x%08llx\n",
14211 dd->base_guid & 0xFFFFFF);
14212
14213 dd->oui1 = dd->base_guid >> 56 & 0xFF;
14214 dd->oui2 = dd->base_guid >> 48 & 0xFF;
14215 dd->oui3 = dd->base_guid >> 40 & 0xFF;
14216
14217 ret = load_firmware(dd); /* asymmetric with dispose_firmware() */
14218 if (ret)
14219 goto bail_clear_intr;
14220 check_fabric_firmware_versions(dd);
14221
14222 thermal_init(dd);
14223
14224 ret = init_cntrs(dd);
14225 if (ret)
14226 goto bail_clear_intr;
14227
14228 ret = init_rcverr(dd);
14229 if (ret)
14230 goto bail_free_cntrs;
14231
14232 ret = eprom_init(dd);
14233 if (ret)
14234 goto bail_free_rcverr;
14235
14236 goto bail;
14237
14238bail_free_rcverr:
14239 free_rcverr(dd);
14240bail_free_cntrs:
14241 free_cntrs(dd);
14242bail_clear_intr:
14243 clean_up_interrupts(dd);
14244bail_cleanup:
14245 hfi1_pcie_ddcleanup(dd);
14246bail_free:
14247 hfi1_free_devdata(dd);
14248 dd = ERR_PTR(ret);
14249bail:
14250 return dd;
14251}
14252
14253static u16 delay_cycles(struct hfi1_pportdata *ppd, u32 desired_egress_rate,
14254 u32 dw_len)
14255{
14256 u32 delta_cycles;
14257 u32 current_egress_rate = ppd->current_egress_rate;
14258 /* rates here are in units of 10^6 bits/sec */
14259
14260 if (desired_egress_rate == -1)
14261 return 0; /* shouldn't happen */
14262
14263 if (desired_egress_rate >= current_egress_rate)
14264 return 0; /* we can't help go faster, only slower */
14265
14266 delta_cycles = egress_cycles(dw_len * 4, desired_egress_rate) -
14267 egress_cycles(dw_len * 4, current_egress_rate);
14268
14269 return (u16)delta_cycles;
14270}
14271
14272
14273/**
14274 * create_pbc - build a pbc for transmission
14275 * @flags: special case flags or-ed in built pbc
14276 * @srate: static rate
14277 * @vl: vl
14278 * @dwlen: dword length (header words + data words + pbc words)
14279 *
14280 * Create a PBC with the given flags, rate, VL, and length.
14281 *
14282 * NOTE: The PBC created will not insert any HCRC - all callers but one are
14283 * for verbs, which does not use this PSM feature. The lone other caller
14284 * is for the diagnostic interface which calls this if the user does not
14285 * supply their own PBC.
14286 */
14287u64 create_pbc(struct hfi1_pportdata *ppd, u64 flags, int srate_mbs, u32 vl,
14288 u32 dw_len)
14289{
14290 u64 pbc, delay = 0;
14291
14292 if (unlikely(srate_mbs))
14293 delay = delay_cycles(ppd, srate_mbs, dw_len);
14294
14295 pbc = flags
14296 | (delay << PBC_STATIC_RATE_CONTROL_COUNT_SHIFT)
14297 | ((u64)PBC_IHCRC_NONE << PBC_INSERT_HCRC_SHIFT)
14298 | (vl & PBC_VL_MASK) << PBC_VL_SHIFT
14299 | (dw_len & PBC_LENGTH_DWS_MASK)
14300 << PBC_LENGTH_DWS_SHIFT;
14301
14302 return pbc;
14303}
14304
14305#define SBUS_THERMAL 0x4f
14306#define SBUS_THERM_MONITOR_MODE 0x1
14307
14308#define THERM_FAILURE(dev, ret, reason) \
14309 dd_dev_err((dd), \
14310 "Thermal sensor initialization failed: %s (%d)\n", \
14311 (reason), (ret))
14312
14313/*
14314 * Initialize the Avago Thermal sensor.
14315 *
14316 * After initialization, enable polling of thermal sensor through
14317 * SBus interface. In order for this to work, the SBus Master
14318 * firmware has to be loaded due to the fact that the HW polling
14319 * logic uses SBus interrupts, which are not supported with
14320 * default firmware. Otherwise, no data will be returned through
14321 * the ASIC_STS_THERM CSR.
14322 */
14323static int thermal_init(struct hfi1_devdata *dd)
14324{
14325 int ret = 0;
14326
14327 if (dd->icode != ICODE_RTL_SILICON ||
14328 !(dd->flags & HFI1_DO_INIT_ASIC))
14329 return ret;
14330
14331 acquire_hw_mutex(dd);
14332 dd_dev_info(dd, "Initializing thermal sensor\n");
Jareer Abdel-Qader4ef98982015-11-06 20:07:00 -0500[diff] [blame]14333 /* Disable polling of thermal readings */
14334 write_csr(dd, ASIC_CFG_THERM_POLL_EN, 0x0);
14335 msleep(100);
Mike Marciniszyn77241052015-07-30 15:17:43 -0400[diff] [blame]14336 /* Thermal Sensor Initialization */
14337 /* Step 1: Reset the Thermal SBus Receiver */
14338 ret = sbus_request_slow(dd, SBUS_THERMAL, 0x0,
14339 RESET_SBUS_RECEIVER, 0);
14340 if (ret) {
14341 THERM_FAILURE(dd, ret, "Bus Reset");
14342 goto done;
14343 }
14344 /* Step 2: Set Reset bit in Thermal block */
14345 ret = sbus_request_slow(dd, SBUS_THERMAL, 0x0,
14346 WRITE_SBUS_RECEIVER, 0x1);
14347 if (ret) {
14348 THERM_FAILURE(dd, ret, "Therm Block Reset");
14349 goto done;
14350 }
14351 /* Step 3: Write clock divider value (100MHz -> 2MHz) */
14352 ret = sbus_request_slow(dd, SBUS_THERMAL, 0x1,
14353 WRITE_SBUS_RECEIVER, 0x32);
14354 if (ret) {
14355 THERM_FAILURE(dd, ret, "Write Clock Div");
14356 goto done;
14357 }
14358 /* Step 4: Select temperature mode */
14359 ret = sbus_request_slow(dd, SBUS_THERMAL, 0x3,
14360 WRITE_SBUS_RECEIVER,
14361 SBUS_THERM_MONITOR_MODE);
14362 if (ret) {
14363 THERM_FAILURE(dd, ret, "Write Mode Sel");
14364 goto done;
14365 }
14366 /* Step 5: De-assert block reset and start conversion */
14367 ret = sbus_request_slow(dd, SBUS_THERMAL, 0x0,
14368 WRITE_SBUS_RECEIVER, 0x2);
14369 if (ret) {
14370 THERM_FAILURE(dd, ret, "Write Reset Deassert");
14371 goto done;
14372 }
14373 /* Step 5.1: Wait for first conversion (21.5ms per spec) */
14374 msleep(22);
14375
14376 /* Enable polling of thermal readings */
14377 write_csr(dd, ASIC_CFG_THERM_POLL_EN, 0x1);
14378done:
14379 release_hw_mutex(dd);
14380 return ret;
14381}
14382
14383static void handle_temp_err(struct hfi1_devdata *dd)
14384{
14385 struct hfi1_pportdata *ppd = &dd->pport[0];
14386 /*
14387 * Thermal Critical Interrupt
14388 * Put the device into forced freeze mode, take link down to
14389 * offline, and put DC into reset.
14390 */
14391 dd_dev_emerg(dd,
14392 "Critical temperature reached! Forcing device into freeze mode!\n");
14393 dd->flags |= HFI1_FORCED_FREEZE;
14394 start_freeze_handling(ppd, FREEZE_SELF|FREEZE_ABORT);
14395 /*
14396 * Shut DC down as much and as quickly as possible.
14397 *
14398 * Step 1: Take the link down to OFFLINE. This will cause the
14399 * 8051 to put the Serdes in reset. However, we don't want to
14400 * go through the entire link state machine since we want to
14401 * shutdown ASAP. Furthermore, this is not a graceful shutdown
14402 * but rather an attempt to save the chip.
14403 * Code below is almost the same as quiet_serdes() but avoids
14404 * all the extra work and the sleeps.
14405 */
14406 ppd->driver_link_ready = 0;
14407 ppd->link_enabled = 0;
14408 set_physical_link_state(dd, PLS_OFFLINE |
14409 (OPA_LINKDOWN_REASON_SMA_DISABLED << 8));
14410 /*
14411 * Step 2: Shutdown LCB and 8051
14412 * After shutdown, do not restore DC_CFG_RESET value.
14413 */
14414 dc_shutdown(dd);
14415}