RDMA: Update workqueue usage
[linux-3.10.git] / drivers / infiniband / hw / qib / qib_iba7322.c
1 /*
2  * Copyright (c) 2008, 2009, 2010 QLogic Corporation. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32
33 /*
34  * This file contains all of the code that is specific to the
35  * InfiniPath 7322 chip
36  */
37
38 #include <linux/interrupt.h>
39 #include <linux/pci.h>
40 #include <linux/delay.h>
41 #include <linux/io.h>
42 #include <linux/jiffies.h>
43 #include <rdma/ib_verbs.h>
44 #include <rdma/ib_smi.h>
45
46 #include "qib.h"
47 #include "qib_7322_regs.h"
48 #include "qib_qsfp.h"
49
50 #include "qib_mad.h"
51
52 static void qib_setup_7322_setextled(struct qib_pportdata *, u32);
53 static void qib_7322_handle_hwerrors(struct qib_devdata *, char *, size_t);
54 static void sendctrl_7322_mod(struct qib_pportdata *ppd, u32 op);
55 static irqreturn_t qib_7322intr(int irq, void *data);
56 static irqreturn_t qib_7322bufavail(int irq, void *data);
57 static irqreturn_t sdma_intr(int irq, void *data);
58 static irqreturn_t sdma_idle_intr(int irq, void *data);
59 static irqreturn_t sdma_progress_intr(int irq, void *data);
60 static irqreturn_t sdma_cleanup_intr(int irq, void *data);
61 static void qib_7322_txchk_change(struct qib_devdata *, u32, u32, u32,
62                                   struct qib_ctxtdata *rcd);
63 static u8 qib_7322_phys_portstate(u64);
64 static u32 qib_7322_iblink_state(u64);
65 static void qib_set_ib_7322_lstate(struct qib_pportdata *ppd, u16 linkcmd,
66                                    u16 linitcmd);
67 static void force_h1(struct qib_pportdata *);
68 static void adj_tx_serdes(struct qib_pportdata *);
69 static u32 qib_7322_setpbc_control(struct qib_pportdata *, u32, u8, u8);
70 static void qib_7322_mini_pcs_reset(struct qib_pportdata *);
71
72 static u32 ahb_mod(struct qib_devdata *, int, int, int, u32, u32);
73 static void ibsd_wr_allchans(struct qib_pportdata *, int, unsigned, unsigned);
74 static void serdes_7322_los_enable(struct qib_pportdata *, int);
75 static int serdes_7322_init_old(struct qib_pportdata *);
76 static int serdes_7322_init_new(struct qib_pportdata *);
77
78 #define BMASK(msb, lsb) (((1 << ((msb) + 1 - (lsb))) - 1) << (lsb))
79
80 /* LE2 serdes values for different cases */
81 #define LE2_DEFAULT 5
82 #define LE2_5m 4
83 #define LE2_QME 0
84
85 /* Below is special-purpose, so only really works for the IB SerDes blocks. */
86 #define IBSD(hw_pidx) (hw_pidx + 2)
87
88 /* these are variables for documentation and experimentation purposes */
89 static const unsigned rcv_int_timeout = 375;
90 static const unsigned rcv_int_count = 16;
91 static const unsigned sdma_idle_cnt = 64;
92
93 /* Time to stop altering Rx Equalization parameters, after link up. */
94 #define RXEQ_DISABLE_MSECS 2500
95
96 /*
97  * Number of VLs we are configured to use (to allow for more
98  * credits per vl, etc.)
99  */
100 ushort qib_num_cfg_vls = 2;
101 module_param_named(num_vls, qib_num_cfg_vls, ushort, S_IRUGO);
102 MODULE_PARM_DESC(num_vls, "Set number of Virtual Lanes to use (1-8)");
103
104 static ushort qib_chase = 1;
105 module_param_named(chase, qib_chase, ushort, S_IRUGO);
106 MODULE_PARM_DESC(chase, "Enable state chase handling");
107
108 static ushort qib_long_atten = 10; /* 10 dB ~= 5m length */
109 module_param_named(long_attenuation, qib_long_atten, ushort, S_IRUGO);
110 MODULE_PARM_DESC(long_attenuation, \
111                  "attenuation cutoff (dB) for long copper cable setup");
112
113 static ushort qib_singleport;
114 module_param_named(singleport, qib_singleport, ushort, S_IRUGO);
115 MODULE_PARM_DESC(singleport, "Use only IB port 1; more per-port buffer space");
116
117 /*
118  * Receive header queue sizes
119  */
120 static unsigned qib_rcvhdrcnt;
121 module_param_named(rcvhdrcnt, qib_rcvhdrcnt, uint, S_IRUGO);
122 MODULE_PARM_DESC(rcvhdrcnt, "receive header count");
123
124 static unsigned qib_rcvhdrsize;
125 module_param_named(rcvhdrsize, qib_rcvhdrsize, uint, S_IRUGO);
126 MODULE_PARM_DESC(rcvhdrsize, "receive header size in 32-bit words");
127
128 static unsigned qib_rcvhdrentsize;
129 module_param_named(rcvhdrentsize, qib_rcvhdrentsize, uint, S_IRUGO);
130 MODULE_PARM_DESC(rcvhdrentsize, "receive header entry size in 32-bit words");
131
132 #define MAX_ATTEN_LEN 64 /* plenty for any real system */
133 /* for read back, default index is ~5m copper cable */
134 static char txselect_list[MAX_ATTEN_LEN] = "10";
135 static struct kparam_string kp_txselect = {
136         .string = txselect_list,
137         .maxlen = MAX_ATTEN_LEN
138 };
139 static int  setup_txselect(const char *, struct kernel_param *);
140 module_param_call(txselect, setup_txselect, param_get_string,
141                   &kp_txselect, S_IWUSR | S_IRUGO);
142 MODULE_PARM_DESC(txselect, \
143                  "Tx serdes indices (for no QSFP or invalid QSFP data)");
144
145 #define BOARD_QME7342 5
146 #define BOARD_QMH7342 6
147 #define IS_QMH(dd) (SYM_FIELD((dd)->revision, Revision, BoardID) == \
148                     BOARD_QMH7342)
149 #define IS_QME(dd) (SYM_FIELD((dd)->revision, Revision, BoardID) == \
150                     BOARD_QME7342)
151
152 #define KREG_IDX(regname)     (QIB_7322_##regname##_OFFS / sizeof(u64))
153
154 #define KREG_IBPORT_IDX(regname) ((QIB_7322_##regname##_0_OFFS / sizeof(u64)))
155
156 #define MASK_ACROSS(lsb, msb) \
157         (((1ULL << ((msb) + 1 - (lsb))) - 1) << (lsb))
158
159 #define SYM_RMASK(regname, fldname) ((u64)              \
160         QIB_7322_##regname##_##fldname##_RMASK)
161
162 #define SYM_MASK(regname, fldname) ((u64)               \
163         QIB_7322_##regname##_##fldname##_RMASK <<       \
164          QIB_7322_##regname##_##fldname##_LSB)
165
166 #define SYM_FIELD(value, regname, fldname) ((u64)       \
167         (((value) >> SYM_LSB(regname, fldname)) &       \
168          SYM_RMASK(regname, fldname)))
169
170 /* useful for things like LaFifoEmpty_0...7, TxCreditOK_0...7, etc. */
171 #define SYM_FIELD_ACROSS(value, regname, fldname, nbits) \
172         (((value) >> SYM_LSB(regname, fldname)) & MASK_ACROSS(0, nbits))
173
174 #define HWE_MASK(fldname) SYM_MASK(HwErrMask, fldname##Mask)
175 #define ERR_MASK(fldname) SYM_MASK(ErrMask, fldname##Mask)
176 #define ERR_MASK_N(fldname) SYM_MASK(ErrMask_0, fldname##Mask)
177 #define INT_MASK(fldname) SYM_MASK(IntMask, fldname##IntMask)
178 #define INT_MASK_P(fldname, port) SYM_MASK(IntMask, fldname##IntMask##_##port)
179 /* Below because most, but not all, fields of IntMask have that full suffix */
180 #define INT_MASK_PM(fldname, port) SYM_MASK(IntMask, fldname##Mask##_##port)
181
182
183 #define SYM_LSB(regname, fldname) (QIB_7322_##regname##_##fldname##_LSB)
184
185 /*
186  * the size bits give us 2^N, in KB units.  0 marks as invalid,
187  * and 7 is reserved.  We currently use only 2KB and 4KB
188  */
189 #define IBA7322_TID_SZ_SHIFT QIB_7322_RcvTIDArray0_RT_BufSize_LSB
190 #define IBA7322_TID_SZ_2K (1UL<<IBA7322_TID_SZ_SHIFT) /* 2KB */
191 #define IBA7322_TID_SZ_4K (2UL<<IBA7322_TID_SZ_SHIFT) /* 4KB */
192 #define IBA7322_TID_PA_SHIFT 11U /* TID addr in chip stored w/o low bits */
193
194 #define SendIBSLIDAssignMask \
195         QIB_7322_SendIBSLIDAssign_0_SendIBSLIDAssign_15_0_RMASK
196 #define SendIBSLMCMask \
197         QIB_7322_SendIBSLIDMask_0_SendIBSLIDMask_15_0_RMASK
198
199 #define ExtLED_IB1_YEL SYM_MASK(EXTCtrl, LEDPort0YellowOn)
200 #define ExtLED_IB1_GRN SYM_MASK(EXTCtrl, LEDPort0GreenOn)
201 #define ExtLED_IB2_YEL SYM_MASK(EXTCtrl, LEDPort1YellowOn)
202 #define ExtLED_IB2_GRN SYM_MASK(EXTCtrl, LEDPort1GreenOn)
203 #define ExtLED_IB1_MASK (ExtLED_IB1_YEL | ExtLED_IB1_GRN)
204 #define ExtLED_IB2_MASK (ExtLED_IB2_YEL | ExtLED_IB2_GRN)
205
206 #define _QIB_GPIO_SDA_NUM 1
207 #define _QIB_GPIO_SCL_NUM 0
208 #define QIB_EEPROM_WEN_NUM 14
209 #define QIB_TWSI_EEPROM_DEV 0xA2 /* All Production 7322 cards. */
210
211 /* HW counter clock is at 4nsec */
212 #define QIB_7322_PSXMITWAIT_CHECK_RATE 4000
213
214 /* full speed IB port 1 only */
215 #define PORT_SPD_CAP (QIB_IB_SDR | QIB_IB_DDR | QIB_IB_QDR)
216 #define PORT_SPD_CAP_SHIFT 3
217
218 /* full speed featuremask, both ports */
219 #define DUAL_PORT_CAP (PORT_SPD_CAP | (PORT_SPD_CAP << PORT_SPD_CAP_SHIFT))
220
221 /*
222  * This file contains almost all the chip-specific register information and
223  * access functions for the FAKED QLogic InfiniPath 7322 PCI-Express chip.
224  */
225
226 /* Use defines to tie machine-generated names to lower-case names */
227 #define kr_contextcnt KREG_IDX(ContextCnt)
228 #define kr_control KREG_IDX(Control)
229 #define kr_counterregbase KREG_IDX(CntrRegBase)
230 #define kr_errclear KREG_IDX(ErrClear)
231 #define kr_errmask KREG_IDX(ErrMask)
232 #define kr_errstatus KREG_IDX(ErrStatus)
233 #define kr_extctrl KREG_IDX(EXTCtrl)
234 #define kr_extstatus KREG_IDX(EXTStatus)
235 #define kr_gpio_clear KREG_IDX(GPIOClear)
236 #define kr_gpio_mask KREG_IDX(GPIOMask)
237 #define kr_gpio_out KREG_IDX(GPIOOut)
238 #define kr_gpio_status KREG_IDX(GPIOStatus)
239 #define kr_hwdiagctrl KREG_IDX(HwDiagCtrl)
240 #define kr_debugportval KREG_IDX(DebugPortValueReg)
241 #define kr_fmask KREG_IDX(feature_mask)
242 #define kr_act_fmask KREG_IDX(active_feature_mask)
243 #define kr_hwerrclear KREG_IDX(HwErrClear)
244 #define kr_hwerrmask KREG_IDX(HwErrMask)
245 #define kr_hwerrstatus KREG_IDX(HwErrStatus)
246 #define kr_intclear KREG_IDX(IntClear)
247 #define kr_intmask KREG_IDX(IntMask)
248 #define kr_intredirect KREG_IDX(IntRedirect0)
249 #define kr_intstatus KREG_IDX(IntStatus)
250 #define kr_pagealign KREG_IDX(PageAlign)
251 #define kr_rcvavailtimeout KREG_IDX(RcvAvailTimeOut0)
252 #define kr_rcvctrl KREG_IDX(RcvCtrl) /* Common, but chip also has per-port */
253 #define kr_rcvegrbase KREG_IDX(RcvEgrBase)
254 #define kr_rcvegrcnt KREG_IDX(RcvEgrCnt)
255 #define kr_rcvhdrcnt KREG_IDX(RcvHdrCnt)
256 #define kr_rcvhdrentsize KREG_IDX(RcvHdrEntSize)
257 #define kr_rcvhdrsize KREG_IDX(RcvHdrSize)
258 #define kr_rcvtidbase KREG_IDX(RcvTIDBase)
259 #define kr_rcvtidcnt KREG_IDX(RcvTIDCnt)
260 #define kr_revision KREG_IDX(Revision)
261 #define kr_scratch KREG_IDX(Scratch)
262 #define kr_sendbuffererror KREG_IDX(SendBufErr0) /* and base for 1 and 2 */
263 #define kr_sendcheckmask KREG_IDX(SendCheckMask0) /* and 1, 2 */
264 #define kr_sendctrl KREG_IDX(SendCtrl)
265 #define kr_sendgrhcheckmask KREG_IDX(SendGRHCheckMask0) /* and 1, 2 */
266 #define kr_sendibpktmask KREG_IDX(SendIBPacketMask0) /* and 1, 2 */
267 #define kr_sendpioavailaddr KREG_IDX(SendBufAvailAddr)
268 #define kr_sendpiobufbase KREG_IDX(SendBufBase)
269 #define kr_sendpiobufcnt KREG_IDX(SendBufCnt)
270 #define kr_sendpiosize KREG_IDX(SendBufSize)
271 #define kr_sendregbase KREG_IDX(SendRegBase)
272 #define kr_sendbufavail0 KREG_IDX(SendBufAvail0)
273 #define kr_userregbase KREG_IDX(UserRegBase)
274 #define kr_intgranted KREG_IDX(Int_Granted)
275 #define kr_vecclr_wo_int KREG_IDX(vec_clr_without_int)
276 #define kr_intblocked KREG_IDX(IntBlocked)
277 #define kr_r_access KREG_IDX(SPC_JTAG_ACCESS_REG)
278
279 /*
280  * per-port kernel registers.  Access only with qib_read_kreg_port()
281  * or qib_write_kreg_port()
282  */
283 #define krp_errclear KREG_IBPORT_IDX(ErrClear)
284 #define krp_errmask KREG_IBPORT_IDX(ErrMask)
285 #define krp_errstatus KREG_IBPORT_IDX(ErrStatus)
286 #define krp_highprio_0 KREG_IBPORT_IDX(HighPriority0)
287 #define krp_highprio_limit KREG_IBPORT_IDX(HighPriorityLimit)
288 #define krp_hrtbt_guid KREG_IBPORT_IDX(HRTBT_GUID)
289 #define krp_ib_pcsconfig KREG_IBPORT_IDX(IBPCSConfig)
290 #define krp_ibcctrl_a KREG_IBPORT_IDX(IBCCtrlA)
291 #define krp_ibcctrl_b KREG_IBPORT_IDX(IBCCtrlB)
292 #define krp_ibcctrl_c KREG_IBPORT_IDX(IBCCtrlC)
293 #define krp_ibcstatus_a KREG_IBPORT_IDX(IBCStatusA)
294 #define krp_ibcstatus_b KREG_IBPORT_IDX(IBCStatusB)
295 #define krp_txestatus KREG_IBPORT_IDX(TXEStatus)
296 #define krp_lowprio_0 KREG_IBPORT_IDX(LowPriority0)
297 #define krp_ncmodectrl KREG_IBPORT_IDX(IBNCModeCtrl)
298 #define krp_partitionkey KREG_IBPORT_IDX(RcvPartitionKey)
299 #define krp_psinterval KREG_IBPORT_IDX(PSInterval)
300 #define krp_psstart KREG_IBPORT_IDX(PSStart)
301 #define krp_psstat KREG_IBPORT_IDX(PSStat)
302 #define krp_rcvbthqp KREG_IBPORT_IDX(RcvBTHQP)
303 #define krp_rcvctrl KREG_IBPORT_IDX(RcvCtrl)
304 #define krp_rcvpktledcnt KREG_IBPORT_IDX(RcvPktLEDCnt)
305 #define krp_rcvqpmaptable KREG_IBPORT_IDX(RcvQPMapTableA)
306 #define krp_rxcreditvl0 KREG_IBPORT_IDX(RxCreditVL0)
307 #define krp_rxcreditvl15 (KREG_IBPORT_IDX(RxCreditVL0)+15)
308 #define krp_sendcheckcontrol KREG_IBPORT_IDX(SendCheckControl)
309 #define krp_sendctrl KREG_IBPORT_IDX(SendCtrl)
310 #define krp_senddmabase KREG_IBPORT_IDX(SendDmaBase)
311 #define krp_senddmabufmask0 KREG_IBPORT_IDX(SendDmaBufMask0)
312 #define krp_senddmabufmask1 (KREG_IBPORT_IDX(SendDmaBufMask0) + 1)
313 #define krp_senddmabufmask2 (KREG_IBPORT_IDX(SendDmaBufMask0) + 2)
314 #define krp_senddmabuf_use0 KREG_IBPORT_IDX(SendDmaBufUsed0)
315 #define krp_senddmabuf_use1 (KREG_IBPORT_IDX(SendDmaBufUsed0) + 1)
316 #define krp_senddmabuf_use2 (KREG_IBPORT_IDX(SendDmaBufUsed0) + 2)
317 #define krp_senddmadesccnt KREG_IBPORT_IDX(SendDmaDescCnt)
318 #define krp_senddmahead KREG_IBPORT_IDX(SendDmaHead)
319 #define krp_senddmaheadaddr KREG_IBPORT_IDX(SendDmaHeadAddr)
320 #define krp_senddmaidlecnt KREG_IBPORT_IDX(SendDmaIdleCnt)
321 #define krp_senddmalengen KREG_IBPORT_IDX(SendDmaLenGen)
322 #define krp_senddmaprioritythld KREG_IBPORT_IDX(SendDmaPriorityThld)
323 #define krp_senddmareloadcnt KREG_IBPORT_IDX(SendDmaReloadCnt)
324 #define krp_senddmastatus KREG_IBPORT_IDX(SendDmaStatus)
325 #define krp_senddmatail KREG_IBPORT_IDX(SendDmaTail)
326 #define krp_sendhdrsymptom KREG_IBPORT_IDX(SendHdrErrSymptom)
327 #define krp_sendslid KREG_IBPORT_IDX(SendIBSLIDAssign)
328 #define krp_sendslidmask KREG_IBPORT_IDX(SendIBSLIDMask)
329 #define krp_ibsdtestiftx KREG_IBPORT_IDX(IB_SDTEST_IF_TX)
330 #define krp_adapt_dis_timer KREG_IBPORT_IDX(ADAPT_DISABLE_TIMER_THRESHOLD)
331 #define krp_tx_deemph_override KREG_IBPORT_IDX(IBSD_TX_DEEMPHASIS_OVERRIDE)
332 #define krp_serdesctrl KREG_IBPORT_IDX(IBSerdesCtrl)
333
334 /*
335  * Per-context kernel registers.  Acess only with qib_read_kreg_ctxt()
336  * or qib_write_kreg_ctxt()
337  */
338 #define krc_rcvhdraddr KREG_IDX(RcvHdrAddr0)
339 #define krc_rcvhdrtailaddr KREG_IDX(RcvHdrTailAddr0)
340
341 /*
342  * TID Flow table, per context.  Reduces
343  * number of hdrq updates to one per flow (or on errors).
344  * context 0 and 1 share same memory, but have distinct
345  * addresses.  Since for now, we never use expected sends
346  * on kernel contexts, we don't worry about that (we initialize
347  * those entries for ctxt 0/1 on driver load twice, for example).
348  */
349 #define NUM_TIDFLOWS_CTXT 0x20 /* 0x20 per context; have to hardcode */
350 #define ur_rcvflowtable (KREG_IDX(RcvTIDFlowTable0) - KREG_IDX(RcvHdrTail0))
351
352 /* these are the error bits in the tid flows, and are W1C */
353 #define TIDFLOW_ERRBITS  ( \
354         (SYM_MASK(RcvTIDFlowTable0, GenMismatch) << \
355         SYM_LSB(RcvTIDFlowTable0, GenMismatch)) | \
356         (SYM_MASK(RcvTIDFlowTable0, SeqMismatch) << \
357         SYM_LSB(RcvTIDFlowTable0, SeqMismatch)))
358
359 /* Most (not all) Counters are per-IBport.
360  * Requires LBIntCnt is at offset 0 in the group
361  */
362 #define CREG_IDX(regname) \
363 ((QIB_7322_##regname##_0_OFFS - QIB_7322_LBIntCnt_OFFS) / sizeof(u64))
364
365 #define crp_badformat CREG_IDX(RxVersionErrCnt)
366 #define crp_err_rlen CREG_IDX(RxLenErrCnt)
367 #define crp_erricrc CREG_IDX(RxICRCErrCnt)
368 #define crp_errlink CREG_IDX(RxLinkMalformCnt)
369 #define crp_errlpcrc CREG_IDX(RxLPCRCErrCnt)
370 #define crp_errpkey CREG_IDX(RxPKeyMismatchCnt)
371 #define crp_errvcrc CREG_IDX(RxVCRCErrCnt)
372 #define crp_excessbufferovfl CREG_IDX(ExcessBufferOvflCnt)
373 #define crp_iblinkdown CREG_IDX(IBLinkDownedCnt)
374 #define crp_iblinkerrrecov CREG_IDX(IBLinkErrRecoveryCnt)
375 #define crp_ibstatuschange CREG_IDX(IBStatusChangeCnt)
376 #define crp_ibsymbolerr CREG_IDX(IBSymbolErrCnt)
377 #define crp_invalidrlen CREG_IDX(RxMaxMinLenErrCnt)
378 #define crp_locallinkintegrityerr CREG_IDX(LocalLinkIntegrityErrCnt)
379 #define crp_pktrcv CREG_IDX(RxDataPktCnt)
380 #define crp_pktrcvflowctrl CREG_IDX(RxFlowPktCnt)
381 #define crp_pktsend CREG_IDX(TxDataPktCnt)
382 #define crp_pktsendflow CREG_IDX(TxFlowPktCnt)
383 #define crp_psrcvdatacount CREG_IDX(PSRcvDataCount)
384 #define crp_psrcvpktscount CREG_IDX(PSRcvPktsCount)
385 #define crp_psxmitdatacount CREG_IDX(PSXmitDataCount)
386 #define crp_psxmitpktscount CREG_IDX(PSXmitPktsCount)
387 #define crp_psxmitwaitcount CREG_IDX(PSXmitWaitCount)
388 #define crp_rcvebp CREG_IDX(RxEBPCnt)
389 #define crp_rcvflowctrlviol CREG_IDX(RxFlowCtrlViolCnt)
390 #define crp_rcvovfl CREG_IDX(RxBufOvflCnt)
391 #define crp_rxdlidfltr CREG_IDX(RxDlidFltrCnt)
392 #define crp_rxdroppkt CREG_IDX(RxDroppedPktCnt)
393 #define crp_rxotherlocalphyerr CREG_IDX(RxOtherLocalPhyErrCnt)
394 #define crp_rxqpinvalidctxt CREG_IDX(RxQPInvalidContextCnt)
395 #define crp_rxvlerr CREG_IDX(RxVlErrCnt)
396 #define crp_sendstall CREG_IDX(TxFlowStallCnt)
397 #define crp_txdroppedpkt CREG_IDX(TxDroppedPktCnt)
398 #define crp_txhdrerr CREG_IDX(TxHeadersErrCnt)
399 #define crp_txlenerr CREG_IDX(TxLenErrCnt)
400 #define crp_txlenerr CREG_IDX(TxLenErrCnt)
401 #define crp_txminmaxlenerr CREG_IDX(TxMaxMinLenErrCnt)
402 #define crp_txsdmadesc CREG_IDX(TxSDmaDescCnt)
403 #define crp_txunderrun CREG_IDX(TxUnderrunCnt)
404 #define crp_txunsupvl CREG_IDX(TxUnsupVLErrCnt)
405 #define crp_vl15droppedpkt CREG_IDX(RxVL15DroppedPktCnt)
406 #define crp_wordrcv CREG_IDX(RxDwordCnt)
407 #define crp_wordsend CREG_IDX(TxDwordCnt)
408 #define crp_tx_creditstalls CREG_IDX(TxCreditUpToDateTimeOut)
409
410 /* these are the (few) counters that are not port-specific */
411 #define CREG_DEVIDX(regname) ((QIB_7322_##regname##_OFFS - \
412                         QIB_7322_LBIntCnt_OFFS) / sizeof(u64))
413 #define cr_base_egrovfl CREG_DEVIDX(RxP0HdrEgrOvflCnt)
414 #define cr_lbint CREG_DEVIDX(LBIntCnt)
415 #define cr_lbstall CREG_DEVIDX(LBFlowStallCnt)
416 #define cr_pcieretrydiag CREG_DEVIDX(PcieRetryBufDiagQwordCnt)
417 #define cr_rxtidflowdrop CREG_DEVIDX(RxTidFlowDropCnt)
418 #define cr_tidfull CREG_DEVIDX(RxTIDFullErrCnt)
419 #define cr_tidinvalid CREG_DEVIDX(RxTIDValidErrCnt)
420
421 /* no chip register for # of IB ports supported, so define */
422 #define NUM_IB_PORTS 2
423
424 /* 1 VL15 buffer per hardware IB port, no register for this, so define */
425 #define NUM_VL15_BUFS NUM_IB_PORTS
426
427 /*
428  * context 0 and 1 are special, and there is no chip register that
429  * defines this value, so we have to define it here.
430  * These are all allocated to either 0 or 1 for single port
431  * hardware configuration, otherwise each gets half
432  */
433 #define KCTXT0_EGRCNT 2048
434
435 /* values for vl and port fields in PBC, 7322-specific */
436 #define PBC_PORT_SEL_LSB 26
437 #define PBC_PORT_SEL_RMASK 1
438 #define PBC_VL_NUM_LSB 27
439 #define PBC_VL_NUM_RMASK 7
440 #define PBC_7322_VL15_SEND (1ULL << 63) /* pbc; VL15, no credit check */
441 #define PBC_7322_VL15_SEND_CTRL (1ULL << 31) /* control version of same */
442
443 static u8 ib_rate_to_delay[IB_RATE_120_GBPS + 1] = {
444         [IB_RATE_2_5_GBPS] = 16,
445         [IB_RATE_5_GBPS] = 8,
446         [IB_RATE_10_GBPS] = 4,
447         [IB_RATE_20_GBPS] = 2,
448         [IB_RATE_30_GBPS] = 2,
449         [IB_RATE_40_GBPS] = 1
450 };
451
452 #define IBA7322_LINKSPEED_SHIFT SYM_LSB(IBCStatusA_0, LinkSpeedActive)
453 #define IBA7322_LINKWIDTH_SHIFT SYM_LSB(IBCStatusA_0, LinkWidthActive)
454
455 /* link training states, from IBC */
456 #define IB_7322_LT_STATE_DISABLED        0x00
457 #define IB_7322_LT_STATE_LINKUP          0x01
458 #define IB_7322_LT_STATE_POLLACTIVE      0x02
459 #define IB_7322_LT_STATE_POLLQUIET       0x03
460 #define IB_7322_LT_STATE_SLEEPDELAY      0x04
461 #define IB_7322_LT_STATE_SLEEPQUIET      0x05
462 #define IB_7322_LT_STATE_CFGDEBOUNCE     0x08
463 #define IB_7322_LT_STATE_CFGRCVFCFG      0x09
464 #define IB_7322_LT_STATE_CFGWAITRMT      0x0a
465 #define IB_7322_LT_STATE_CFGIDLE         0x0b
466 #define IB_7322_LT_STATE_RECOVERRETRAIN  0x0c
467 #define IB_7322_LT_STATE_TXREVLANES      0x0d
468 #define IB_7322_LT_STATE_RECOVERWAITRMT  0x0e
469 #define IB_7322_LT_STATE_RECOVERIDLE     0x0f
470 #define IB_7322_LT_STATE_CFGENH          0x10
471 #define IB_7322_LT_STATE_CFGTEST         0x11
472
473 /* link state machine states from IBC */
474 #define IB_7322_L_STATE_DOWN             0x0
475 #define IB_7322_L_STATE_INIT             0x1
476 #define IB_7322_L_STATE_ARM              0x2
477 #define IB_7322_L_STATE_ACTIVE           0x3
478 #define IB_7322_L_STATE_ACT_DEFER        0x4
479
480 static const u8 qib_7322_physportstate[0x20] = {
481         [IB_7322_LT_STATE_DISABLED] = IB_PHYSPORTSTATE_DISABLED,
482         [IB_7322_LT_STATE_LINKUP] = IB_PHYSPORTSTATE_LINKUP,
483         [IB_7322_LT_STATE_POLLACTIVE] = IB_PHYSPORTSTATE_POLL,
484         [IB_7322_LT_STATE_POLLQUIET] = IB_PHYSPORTSTATE_POLL,
485         [IB_7322_LT_STATE_SLEEPDELAY] = IB_PHYSPORTSTATE_SLEEP,
486         [IB_7322_LT_STATE_SLEEPQUIET] = IB_PHYSPORTSTATE_SLEEP,
487         [IB_7322_LT_STATE_CFGDEBOUNCE] = IB_PHYSPORTSTATE_CFG_TRAIN,
488         [IB_7322_LT_STATE_CFGRCVFCFG] =
489                 IB_PHYSPORTSTATE_CFG_TRAIN,
490         [IB_7322_LT_STATE_CFGWAITRMT] =
491                 IB_PHYSPORTSTATE_CFG_TRAIN,
492         [IB_7322_LT_STATE_CFGIDLE] = IB_PHYSPORTSTATE_CFG_IDLE,
493         [IB_7322_LT_STATE_RECOVERRETRAIN] =
494                 IB_PHYSPORTSTATE_LINK_ERR_RECOVER,
495         [IB_7322_LT_STATE_RECOVERWAITRMT] =
496                 IB_PHYSPORTSTATE_LINK_ERR_RECOVER,
497         [IB_7322_LT_STATE_RECOVERIDLE] =
498                 IB_PHYSPORTSTATE_LINK_ERR_RECOVER,
499         [IB_7322_LT_STATE_CFGENH] = IB_PHYSPORTSTATE_CFG_ENH,
500         [IB_7322_LT_STATE_CFGTEST] = IB_PHYSPORTSTATE_CFG_TRAIN,
501         [0x12] = IB_PHYSPORTSTATE_CFG_TRAIN,
502         [0x13] = IB_PHYSPORTSTATE_CFG_WAIT_ENH,
503         [0x14] = IB_PHYSPORTSTATE_CFG_TRAIN,
504         [0x15] = IB_PHYSPORTSTATE_CFG_TRAIN,
505         [0x16] = IB_PHYSPORTSTATE_CFG_TRAIN,
506         [0x17] = IB_PHYSPORTSTATE_CFG_TRAIN
507 };
508
509 struct qib_chip_specific {
510         u64 __iomem *cregbase;
511         u64 *cntrs;
512         spinlock_t rcvmod_lock; /* protect rcvctrl shadow changes */
513         spinlock_t gpio_lock; /* RMW of shadows/regs for ExtCtrl and GPIO */
514         u64 main_int_mask;      /* clear bits which have dedicated handlers */
515         u64 int_enable_mask;  /* for per port interrupts in single port mode */
516         u64 errormask;
517         u64 hwerrmask;
518         u64 gpio_out; /* shadow of kr_gpio_out, for rmw ops */
519         u64 gpio_mask; /* shadow the gpio mask register */
520         u64 extctrl; /* shadow the gpio output enable, etc... */
521         u32 ncntrs;
522         u32 nportcntrs;
523         u32 cntrnamelen;
524         u32 portcntrnamelen;
525         u32 numctxts;
526         u32 rcvegrcnt;
527         u32 updthresh; /* current AvailUpdThld */
528         u32 updthresh_dflt; /* default AvailUpdThld */
529         u32 r1;
530         int irq;
531         u32 num_msix_entries;
532         u32 sdmabufcnt;
533         u32 lastbuf_for_pio;
534         u32 stay_in_freeze;
535         u32 recovery_ports_initted;
536         struct msix_entry *msix_entries;
537         void  **msix_arg;
538         unsigned long *sendchkenable;
539         unsigned long *sendgrhchk;
540         unsigned long *sendibchk;
541         u32 rcvavail_timeout[18];
542         char emsgbuf[128]; /* for device error interrupt msg buffer */
543 };
544
545 /* Table of entries in "human readable" form Tx Emphasis. */
546 struct txdds_ent {
547         u8 amp;
548         u8 pre;
549         u8 main;
550         u8 post;
551 };
552
553 struct vendor_txdds_ent {
554         u8 oui[QSFP_VOUI_LEN];
555         u8 *partnum;
556         struct txdds_ent sdr;
557         struct txdds_ent ddr;
558         struct txdds_ent qdr;
559 };
560
561 static void write_tx_serdes_param(struct qib_pportdata *, struct txdds_ent *);
562
563 #define TXDDS_TABLE_SZ 16 /* number of entries per speed in onchip table */
564 #define TXDDS_EXTRA_SZ 13 /* number of extra tx settings entries */
565 #define TXDDS_MFG_SZ 2    /* number of mfg tx settings entries */
566 #define SERDES_CHANS 4 /* yes, it's obvious, but one less magic number */
567
568 #define H1_FORCE_VAL 8
569 #define H1_FORCE_QME 1 /*  may be overridden via setup_txselect() */
570 #define H1_FORCE_QMH 7 /*  may be overridden via setup_txselect() */
571
572 /* The static and dynamic registers are paired, and the pairs indexed by spd */
573 #define krp_static_adapt_dis(spd) (KREG_IBPORT_IDX(ADAPT_DISABLE_STATIC_SDR) \
574         + ((spd) * 2))
575
576 #define QDR_DFE_DISABLE_DELAY 4000 /* msec after LINKUP */
577 #define QDR_STATIC_ADAPT_DOWN 0xf0f0f0f0ULL /* link down, H1-H4 QDR adapts */
578 #define QDR_STATIC_ADAPT_DOWN_R1 0ULL /* r1 link down, H1-H4 QDR adapts */
579 #define QDR_STATIC_ADAPT_INIT 0xffffffffffULL /* up, disable H0,H1-8, LE */
580 #define QDR_STATIC_ADAPT_INIT_R1 0xf0ffffffffULL /* r1 up, disable H0,H1-8 */
581
582 struct qib_chippport_specific {
583         u64 __iomem *kpregbase;
584         u64 __iomem *cpregbase;
585         u64 *portcntrs;
586         struct qib_pportdata *ppd;
587         wait_queue_head_t autoneg_wait;
588         struct delayed_work autoneg_work;
589         struct delayed_work ipg_work;
590         struct timer_list chase_timer;
591         /*
592          * these 5 fields are used to establish deltas for IB symbol
593          * errors and linkrecovery errors.  They can be reported on
594          * some chips during link negotiation prior to INIT, and with
595          * DDR when faking DDR negotiations with non-IBTA switches.
596          * The chip counters are adjusted at driver unload if there is
597          * a non-zero delta.
598          */
599         u64 ibdeltainprog;
600         u64 ibsymdelta;
601         u64 ibsymsnap;
602         u64 iblnkerrdelta;
603         u64 iblnkerrsnap;
604         u64 iblnkdownsnap;
605         u64 iblnkdowndelta;
606         u64 ibmalfdelta;
607         u64 ibmalfsnap;
608         u64 ibcctrl_a; /* krp_ibcctrl_a shadow */
609         u64 ibcctrl_b; /* krp_ibcctrl_b shadow */
610         u64 qdr_dfe_time;
611         u64 chase_end;
612         u32 autoneg_tries;
613         u32 recovery_init;
614         u32 qdr_dfe_on;
615         u32 qdr_reforce;
616         /*
617          * Per-bay per-channel rcv QMH H1 values and Tx values for QDR.
618          * entry zero is unused, to simplify indexing
619          */
620         u8 h1_val;
621         u8 no_eep;  /* txselect table index to use if no qsfp info */
622         u8 ipg_tries;
623         u8 ibmalfusesnap;
624         struct qib_qsfp_data qsfp_data;
625         char epmsgbuf[192]; /* for port error interrupt msg buffer */
626         u8 bounced;
627 };
628
629 static struct {
630         const char *name;
631         irq_handler_t handler;
632         int lsb;
633         int port; /* 0 if not port-specific, else port # */
634 } irq_table[] = {
635         { QIB_DRV_NAME, qib_7322intr, -1, 0 },
636         { QIB_DRV_NAME " (buf avail)", qib_7322bufavail,
637                 SYM_LSB(IntStatus, SendBufAvail), 0 },
638         { QIB_DRV_NAME " (sdma 0)", sdma_intr,
639                 SYM_LSB(IntStatus, SDmaInt_0), 1 },
640         { QIB_DRV_NAME " (sdma 1)", sdma_intr,
641                 SYM_LSB(IntStatus, SDmaInt_1), 2 },
642         { QIB_DRV_NAME " (sdmaI 0)", sdma_idle_intr,
643                 SYM_LSB(IntStatus, SDmaIdleInt_0), 1 },
644         { QIB_DRV_NAME " (sdmaI 1)", sdma_idle_intr,
645                 SYM_LSB(IntStatus, SDmaIdleInt_1), 2 },
646         { QIB_DRV_NAME " (sdmaP 0)", sdma_progress_intr,
647                 SYM_LSB(IntStatus, SDmaProgressInt_0), 1 },
648         { QIB_DRV_NAME " (sdmaP 1)", sdma_progress_intr,
649                 SYM_LSB(IntStatus, SDmaProgressInt_1), 2 },
650         { QIB_DRV_NAME " (sdmaC 0)", sdma_cleanup_intr,
651                 SYM_LSB(IntStatus, SDmaCleanupDone_0), 1 },
652         { QIB_DRV_NAME " (sdmaC 1)", sdma_cleanup_intr,
653                 SYM_LSB(IntStatus, SDmaCleanupDone_1), 2 },
654 };
655
656 /* ibcctrl bits */
657 #define QLOGIC_IB_IBCC_LINKINITCMD_DISABLE 1
658 /* cycle through TS1/TS2 till OK */
659 #define QLOGIC_IB_IBCC_LINKINITCMD_POLL 2
660 /* wait for TS1, then go on */
661 #define QLOGIC_IB_IBCC_LINKINITCMD_SLEEP 3
662 #define QLOGIC_IB_IBCC_LINKINITCMD_SHIFT 16
663
664 #define QLOGIC_IB_IBCC_LINKCMD_DOWN 1           /* move to 0x11 */
665 #define QLOGIC_IB_IBCC_LINKCMD_ARMED 2          /* move to 0x21 */
666 #define QLOGIC_IB_IBCC_LINKCMD_ACTIVE 3 /* move to 0x31 */
667
668 #define BLOB_7322_IBCHG 0x101
669
670 static inline void qib_write_kreg(const struct qib_devdata *dd,
671                                   const u32 regno, u64 value);
672 static inline u32 qib_read_kreg32(const struct qib_devdata *, const u32);
673 static void write_7322_initregs(struct qib_devdata *);
674 static void write_7322_init_portregs(struct qib_pportdata *);
675 static void setup_7322_link_recovery(struct qib_pportdata *, u32);
676 static void check_7322_rxe_status(struct qib_pportdata *);
677 static u32 __iomem *qib_7322_getsendbuf(struct qib_pportdata *, u64, u32 *);
678
679 /**
680  * qib_read_ureg32 - read 32-bit virtualized per-context register
681  * @dd: device
682  * @regno: register number
683  * @ctxt: context number
684  *
685  * Return the contents of a register that is virtualized to be per context.
686  * Returns -1 on errors (not distinguishable from valid contents at
687  * runtime; we may add a separate error variable at some point).
688  */
689 static inline u32 qib_read_ureg32(const struct qib_devdata *dd,
690                                   enum qib_ureg regno, int ctxt)
691 {
692         if (!dd->kregbase || !(dd->flags & QIB_PRESENT))
693                 return 0;
694         return readl(regno + (u64 __iomem *)(
695                 (dd->ureg_align * ctxt) + (dd->userbase ?
696                  (char __iomem *)dd->userbase :
697                  (char __iomem *)dd->kregbase + dd->uregbase)));
698 }
699
700 /**
701  * qib_read_ureg - read virtualized per-context register
702  * @dd: device
703  * @regno: register number
704  * @ctxt: context number
705  *
706  * Return the contents of a register that is virtualized to be per context.
707  * Returns -1 on errors (not distinguishable from valid contents at
708  * runtime; we may add a separate error variable at some point).
709  */
710 static inline u64 qib_read_ureg(const struct qib_devdata *dd,
711                                 enum qib_ureg regno, int ctxt)
712 {
713
714         if (!dd->kregbase || !(dd->flags & QIB_PRESENT))
715                 return 0;
716         return readq(regno + (u64 __iomem *)(
717                 (dd->ureg_align * ctxt) + (dd->userbase ?
718                  (char __iomem *)dd->userbase :
719                  (char __iomem *)dd->kregbase + dd->uregbase)));
720 }
721
722 /**
723  * qib_write_ureg - write virtualized per-context register
724  * @dd: device
725  * @regno: register number
726  * @value: value
727  * @ctxt: context
728  *
729  * Write the contents of a register that is virtualized to be per context.
730  */
731 static inline void qib_write_ureg(const struct qib_devdata *dd,
732                                   enum qib_ureg regno, u64 value, int ctxt)
733 {
734         u64 __iomem *ubase;
735         if (dd->userbase)
736                 ubase = (u64 __iomem *)
737                         ((char __iomem *) dd->userbase +
738                          dd->ureg_align * ctxt);
739         else
740                 ubase = (u64 __iomem *)
741                         (dd->uregbase +
742                          (char __iomem *) dd->kregbase +
743                          dd->ureg_align * ctxt);
744
745         if (dd->kregbase && (dd->flags & QIB_PRESENT))
746                 writeq(value, &ubase[regno]);
747 }
748
749 static inline u32 qib_read_kreg32(const struct qib_devdata *dd,
750                                   const u32 regno)
751 {
752         if (!dd->kregbase || !(dd->flags & QIB_PRESENT))
753                 return -1;
754         return readl((u32 __iomem *) &dd->kregbase[regno]);
755 }
756
757 static inline u64 qib_read_kreg64(const struct qib_devdata *dd,
758                                   const u32 regno)
759 {
760         if (!dd->kregbase || !(dd->flags & QIB_PRESENT))
761                 return -1;
762         return readq(&dd->kregbase[regno]);
763 }
764
765 static inline void qib_write_kreg(const struct qib_devdata *dd,
766                                   const u32 regno, u64 value)
767 {
768         if (dd->kregbase && (dd->flags & QIB_PRESENT))
769                 writeq(value, &dd->kregbase[regno]);
770 }
771
772 /*
773  * not many sanity checks for the port-specific kernel register routines,
774  * since they are only used when it's known to be safe.
775 */
776 static inline u64 qib_read_kreg_port(const struct qib_pportdata *ppd,
777                                      const u16 regno)
778 {
779         if (!ppd->cpspec->kpregbase || !(ppd->dd->flags & QIB_PRESENT))
780                 return 0ULL;
781         return readq(&ppd->cpspec->kpregbase[regno]);
782 }
783
784 static inline void qib_write_kreg_port(const struct qib_pportdata *ppd,
785                                        const u16 regno, u64 value)
786 {
787         if (ppd->cpspec && ppd->dd && ppd->cpspec->kpregbase &&
788             (ppd->dd->flags & QIB_PRESENT))
789                 writeq(value, &ppd->cpspec->kpregbase[regno]);
790 }
791
792 /**
793  * qib_write_kreg_ctxt - write a device's per-ctxt 64-bit kernel register
794  * @dd: the qlogic_ib device
795  * @regno: the register number to write
796  * @ctxt: the context containing the register
797  * @value: the value to write
798  */
799 static inline void qib_write_kreg_ctxt(const struct qib_devdata *dd,
800                                        const u16 regno, unsigned ctxt,
801                                        u64 value)
802 {
803         qib_write_kreg(dd, regno + ctxt, value);
804 }
805
806 static inline u64 read_7322_creg(const struct qib_devdata *dd, u16 regno)
807 {
808         if (!dd->cspec->cregbase || !(dd->flags & QIB_PRESENT))
809                 return 0;
810         return readq(&dd->cspec->cregbase[regno]);
811
812
813 }
814
815 static inline u32 read_7322_creg32(const struct qib_devdata *dd, u16 regno)
816 {
817         if (!dd->cspec->cregbase || !(dd->flags & QIB_PRESENT))
818                 return 0;
819         return readl(&dd->cspec->cregbase[regno]);
820
821
822 }
823
824 static inline void write_7322_creg_port(const struct qib_pportdata *ppd,
825                                         u16 regno, u64 value)
826 {
827         if (ppd->cpspec && ppd->cpspec->cpregbase &&
828             (ppd->dd->flags & QIB_PRESENT))
829                 writeq(value, &ppd->cpspec->cpregbase[regno]);
830 }
831
832 static inline u64 read_7322_creg_port(const struct qib_pportdata *ppd,
833                                       u16 regno)
834 {
835         if (!ppd->cpspec || !ppd->cpspec->cpregbase ||
836             !(ppd->dd->flags & QIB_PRESENT))
837                 return 0;
838         return readq(&ppd->cpspec->cpregbase[regno]);
839 }
840
841 static inline u32 read_7322_creg32_port(const struct qib_pportdata *ppd,
842                                         u16 regno)
843 {
844         if (!ppd->cpspec || !ppd->cpspec->cpregbase ||
845             !(ppd->dd->flags & QIB_PRESENT))
846                 return 0;
847         return readl(&ppd->cpspec->cpregbase[regno]);
848 }
849
850 /* bits in Control register */
851 #define QLOGIC_IB_C_RESET SYM_MASK(Control, SyncReset)
852 #define QLOGIC_IB_C_SDMAFETCHPRIOEN SYM_MASK(Control, SDmaDescFetchPriorityEn)
853
854 /* bits in general interrupt regs */
855 #define QIB_I_RCVURG_LSB SYM_LSB(IntMask, RcvUrg0IntMask)
856 #define QIB_I_RCVURG_RMASK MASK_ACROSS(0, 17)
857 #define QIB_I_RCVURG_MASK (QIB_I_RCVURG_RMASK << QIB_I_RCVURG_LSB)
858 #define QIB_I_RCVAVAIL_LSB SYM_LSB(IntMask, RcvAvail0IntMask)
859 #define QIB_I_RCVAVAIL_RMASK MASK_ACROSS(0, 17)
860 #define QIB_I_RCVAVAIL_MASK (QIB_I_RCVAVAIL_RMASK << QIB_I_RCVAVAIL_LSB)
861 #define QIB_I_C_ERROR INT_MASK(Err)
862
863 #define QIB_I_SPIOSENT (INT_MASK_P(SendDone, 0) | INT_MASK_P(SendDone, 1))
864 #define QIB_I_SPIOBUFAVAIL INT_MASK(SendBufAvail)
865 #define QIB_I_GPIO INT_MASK(AssertGPIO)
866 #define QIB_I_P_SDMAINT(pidx) \
867         (INT_MASK_P(SDma, pidx) | INT_MASK_P(SDmaIdle, pidx) | \
868          INT_MASK_P(SDmaProgress, pidx) | \
869          INT_MASK_PM(SDmaCleanupDone, pidx))
870
871 /* Interrupt bits that are "per port" */
872 #define QIB_I_P_BITSEXTANT(pidx) \
873         (INT_MASK_P(Err, pidx) | INT_MASK_P(SendDone, pidx) | \
874         INT_MASK_P(SDma, pidx) | INT_MASK_P(SDmaIdle, pidx) | \
875         INT_MASK_P(SDmaProgress, pidx) | \
876         INT_MASK_PM(SDmaCleanupDone, pidx))
877
878 /* Interrupt bits that are common to a device */
879 /* currently unused: QIB_I_SPIOSENT */
880 #define QIB_I_C_BITSEXTANT \
881         (QIB_I_RCVURG_MASK | QIB_I_RCVAVAIL_MASK | \
882         QIB_I_SPIOSENT | \
883         QIB_I_C_ERROR | QIB_I_SPIOBUFAVAIL | QIB_I_GPIO)
884
885 #define QIB_I_BITSEXTANT (QIB_I_C_BITSEXTANT | \
886         QIB_I_P_BITSEXTANT(0) | QIB_I_P_BITSEXTANT(1))
887
888 /*
889  * Error bits that are "per port".
890  */
891 #define QIB_E_P_IBSTATUSCHANGED ERR_MASK_N(IBStatusChanged)
892 #define QIB_E_P_SHDR ERR_MASK_N(SHeadersErr)
893 #define QIB_E_P_VL15_BUF_MISUSE ERR_MASK_N(VL15BufMisuseErr)
894 #define QIB_E_P_SND_BUF_MISUSE ERR_MASK_N(SendBufMisuseErr)
895 #define QIB_E_P_SUNSUPVL ERR_MASK_N(SendUnsupportedVLErr)
896 #define QIB_E_P_SUNEXP_PKTNUM ERR_MASK_N(SendUnexpectedPktNumErr)
897 #define QIB_E_P_SDROP_DATA ERR_MASK_N(SendDroppedDataPktErr)
898 #define QIB_E_P_SDROP_SMP ERR_MASK_N(SendDroppedSmpPktErr)
899 #define QIB_E_P_SPKTLEN ERR_MASK_N(SendPktLenErr)
900 #define QIB_E_P_SUNDERRUN ERR_MASK_N(SendUnderRunErr)
901 #define QIB_E_P_SMAXPKTLEN ERR_MASK_N(SendMaxPktLenErr)
902 #define QIB_E_P_SMINPKTLEN ERR_MASK_N(SendMinPktLenErr)
903 #define QIB_E_P_RIBLOSTLINK ERR_MASK_N(RcvIBLostLinkErr)
904 #define QIB_E_P_RHDR ERR_MASK_N(RcvHdrErr)
905 #define QIB_E_P_RHDRLEN ERR_MASK_N(RcvHdrLenErr)
906 #define QIB_E_P_RBADTID ERR_MASK_N(RcvBadTidErr)
907 #define QIB_E_P_RBADVERSION ERR_MASK_N(RcvBadVersionErr)
908 #define QIB_E_P_RIBFLOW ERR_MASK_N(RcvIBFlowErr)
909 #define QIB_E_P_REBP ERR_MASK_N(RcvEBPErr)
910 #define QIB_E_P_RUNSUPVL ERR_MASK_N(RcvUnsupportedVLErr)
911 #define QIB_E_P_RUNEXPCHAR ERR_MASK_N(RcvUnexpectedCharErr)
912 #define QIB_E_P_RSHORTPKTLEN ERR_MASK_N(RcvShortPktLenErr)
913 #define QIB_E_P_RLONGPKTLEN ERR_MASK_N(RcvLongPktLenErr)
914 #define QIB_E_P_RMAXPKTLEN ERR_MASK_N(RcvMaxPktLenErr)
915 #define QIB_E_P_RMINPKTLEN ERR_MASK_N(RcvMinPktLenErr)
916 #define QIB_E_P_RICRC ERR_MASK_N(RcvICRCErr)
917 #define QIB_E_P_RVCRC ERR_MASK_N(RcvVCRCErr)
918 #define QIB_E_P_RFORMATERR ERR_MASK_N(RcvFormatErr)
919
920 #define QIB_E_P_SDMA1STDESC ERR_MASK_N(SDma1stDescErr)
921 #define QIB_E_P_SDMABASE ERR_MASK_N(SDmaBaseErr)
922 #define QIB_E_P_SDMADESCADDRMISALIGN ERR_MASK_N(SDmaDescAddrMisalignErr)
923 #define QIB_E_P_SDMADWEN ERR_MASK_N(SDmaDwEnErr)
924 #define QIB_E_P_SDMAGENMISMATCH ERR_MASK_N(SDmaGenMismatchErr)
925 #define QIB_E_P_SDMAHALT ERR_MASK_N(SDmaHaltErr)
926 #define QIB_E_P_SDMAMISSINGDW ERR_MASK_N(SDmaMissingDwErr)
927 #define QIB_E_P_SDMAOUTOFBOUND ERR_MASK_N(SDmaOutOfBoundErr)
928 #define QIB_E_P_SDMARPYTAG ERR_MASK_N(SDmaRpyTagErr)
929 #define QIB_E_P_SDMATAILOUTOFBOUND ERR_MASK_N(SDmaTailOutOfBoundErr)
930 #define QIB_E_P_SDMAUNEXPDATA ERR_MASK_N(SDmaUnexpDataErr)
931
932 /* Error bits that are common to a device */
933 #define QIB_E_RESET ERR_MASK(ResetNegated)
934 #define QIB_E_HARDWARE ERR_MASK(HardwareErr)
935 #define QIB_E_INVALIDADDR ERR_MASK(InvalidAddrErr)
936
937
938 /*
939  * Per chip (rather than per-port) errors.  Most either do
940  * nothing but trigger a print (because they self-recover, or
941  * always occur in tandem with other errors that handle the
942  * issue), or because they indicate errors with no recovery,
943  * but we want to know that they happened.
944  */
945 #define QIB_E_SBUF_VL15_MISUSE ERR_MASK(SBufVL15MisUseErr)
946 #define QIB_E_BADEEP ERR_MASK(InvalidEEPCmd)
947 #define QIB_E_VLMISMATCH ERR_MASK(SendVLMismatchErr)
948 #define QIB_E_ARMLAUNCH ERR_MASK(SendArmLaunchErr)
949 #define QIB_E_SPCLTRIG ERR_MASK(SendSpecialTriggerErr)
950 #define QIB_E_RRCVHDRFULL ERR_MASK(RcvHdrFullErr)
951 #define QIB_E_RRCVEGRFULL ERR_MASK(RcvEgrFullErr)
952 #define QIB_E_RCVCTXTSHARE ERR_MASK(RcvContextShareErr)
953
954 /* SDMA chip errors (not per port)
955  * QIB_E_SDMA_BUF_DUP needs no special handling, because we will also get
956  * the SDMAHALT error immediately, so we just print the dup error via the
957  * E_AUTO mechanism.  This is true of most of the per-port fatal errors
958  * as well, but since this is port-independent, by definition, it's
959  * handled a bit differently.  SDMA_VL15 and SDMA_WRONG_PORT are per
960  * packet send errors, and so are handled in the same manner as other
961  * per-packet errors.
962  */
963 #define QIB_E_SDMA_VL15 ERR_MASK(SDmaVL15Err)
964 #define QIB_E_SDMA_WRONG_PORT ERR_MASK(SDmaWrongPortErr)
965 #define QIB_E_SDMA_BUF_DUP ERR_MASK(SDmaBufMaskDuplicateErr)
966
967 /*
968  * Below functionally equivalent to legacy QLOGIC_IB_E_PKTERRS
969  * it is used to print "common" packet errors.
970  */
971 #define QIB_E_P_PKTERRS (QIB_E_P_SPKTLEN |\
972         QIB_E_P_SDROP_DATA | QIB_E_P_RVCRC |\
973         QIB_E_P_RICRC | QIB_E_P_RSHORTPKTLEN |\
974         QIB_E_P_VL15_BUF_MISUSE | QIB_E_P_SHDR | \
975         QIB_E_P_REBP)
976
977 /* Error Bits that Packet-related (Receive, per-port) */
978 #define QIB_E_P_RPKTERRS (\
979         QIB_E_P_RHDRLEN | QIB_E_P_RBADTID | \
980         QIB_E_P_RBADVERSION | QIB_E_P_RHDR | \
981         QIB_E_P_RLONGPKTLEN | QIB_E_P_RSHORTPKTLEN |\
982         QIB_E_P_RMAXPKTLEN | QIB_E_P_RMINPKTLEN | \
983         QIB_E_P_RFORMATERR | QIB_E_P_RUNSUPVL | \
984         QIB_E_P_RUNEXPCHAR | QIB_E_P_RIBFLOW | QIB_E_P_REBP)
985
986 /*
987  * Error bits that are Send-related (per port)
988  * (ARMLAUNCH excluded from E_SPKTERRS because it gets special handling).
989  * All of these potentially need to have a buffer disarmed
990  */
991 #define QIB_E_P_SPKTERRS (\
992         QIB_E_P_SUNEXP_PKTNUM |\
993         QIB_E_P_SDROP_DATA | QIB_E_P_SDROP_SMP |\
994         QIB_E_P_SMAXPKTLEN |\
995         QIB_E_P_VL15_BUF_MISUSE | QIB_E_P_SHDR | \
996         QIB_E_P_SMINPKTLEN | QIB_E_P_SPKTLEN | \
997         QIB_E_P_SND_BUF_MISUSE | QIB_E_P_SUNSUPVL)
998
999 #define QIB_E_SPKTERRS ( \
1000                 QIB_E_SBUF_VL15_MISUSE | QIB_E_VLMISMATCH | \
1001                 ERR_MASK_N(SendUnsupportedVLErr) |                      \
1002                 QIB_E_SPCLTRIG | QIB_E_SDMA_VL15 | QIB_E_SDMA_WRONG_PORT)
1003
1004 #define QIB_E_P_SDMAERRS ( \
1005         QIB_E_P_SDMAHALT | \
1006         QIB_E_P_SDMADESCADDRMISALIGN | \
1007         QIB_E_P_SDMAUNEXPDATA | \
1008         QIB_E_P_SDMAMISSINGDW | \
1009         QIB_E_P_SDMADWEN | \
1010         QIB_E_P_SDMARPYTAG | \
1011         QIB_E_P_SDMA1STDESC | \
1012         QIB_E_P_SDMABASE | \
1013         QIB_E_P_SDMATAILOUTOFBOUND | \
1014         QIB_E_P_SDMAOUTOFBOUND | \
1015         QIB_E_P_SDMAGENMISMATCH)
1016
1017 /*
1018  * This sets some bits more than once, but makes it more obvious which
1019  * bits are not handled under other categories, and the repeat definition
1020  * is not a problem.
1021  */
1022 #define QIB_E_P_BITSEXTANT ( \
1023         QIB_E_P_SPKTERRS | QIB_E_P_PKTERRS | QIB_E_P_RPKTERRS | \
1024         QIB_E_P_RIBLOSTLINK | QIB_E_P_IBSTATUSCHANGED | \
1025         QIB_E_P_SND_BUF_MISUSE | QIB_E_P_SUNDERRUN | \
1026         QIB_E_P_SHDR | QIB_E_P_VL15_BUF_MISUSE | QIB_E_P_SDMAERRS \
1027         )
1028
1029 /*
1030  * These are errors that can occur when the link
1031  * changes state while a packet is being sent or received.  This doesn't
1032  * cover things like EBP or VCRC that can be the result of a sending
1033  * having the link change state, so we receive a "known bad" packet.
1034  * All of these are "per port", so renamed:
1035  */
1036 #define QIB_E_P_LINK_PKTERRS (\
1037         QIB_E_P_SDROP_DATA | QIB_E_P_SDROP_SMP |\
1038         QIB_E_P_SMINPKTLEN | QIB_E_P_SPKTLEN |\
1039         QIB_E_P_RSHORTPKTLEN | QIB_E_P_RMINPKTLEN |\
1040         QIB_E_P_RUNEXPCHAR)
1041
1042 /*
1043  * This sets some bits more than once, but makes it more obvious which
1044  * bits are not handled under other categories (such as QIB_E_SPKTERRS),
1045  * and the repeat definition is not a problem.
1046  */
1047 #define QIB_E_C_BITSEXTANT (\
1048         QIB_E_HARDWARE | QIB_E_INVALIDADDR | QIB_E_BADEEP |\
1049         QIB_E_ARMLAUNCH | QIB_E_VLMISMATCH | QIB_E_RRCVHDRFULL |\
1050         QIB_E_RRCVEGRFULL | QIB_E_RESET | QIB_E_SBUF_VL15_MISUSE)
1051
1052 /* Likewise Neuter E_SPKT_ERRS_IGNORE */
1053 #define E_SPKT_ERRS_IGNORE 0
1054
1055 #define QIB_EXTS_MEMBIST_DISABLED \
1056         SYM_MASK(EXTStatus, MemBISTDisabled)
1057 #define QIB_EXTS_MEMBIST_ENDTEST \
1058         SYM_MASK(EXTStatus, MemBISTEndTest)
1059
1060 #define QIB_E_SPIOARMLAUNCH \
1061         ERR_MASK(SendArmLaunchErr)
1062
1063 #define IBA7322_IBCC_LINKINITCMD_MASK SYM_RMASK(IBCCtrlA_0, LinkInitCmd)
1064 #define IBA7322_IBCC_LINKCMD_SHIFT SYM_LSB(IBCCtrlA_0, LinkCmd)
1065
1066 /*
1067  * IBTA_1_2 is set when multiple speeds are enabled (normal),
1068  * and also if forced QDR (only QDR enabled).  It's enabled for the
1069  * forced QDR case so that scrambling will be enabled by the TS3
1070  * exchange, when supported by both sides of the link.
1071  */
1072 #define IBA7322_IBC_IBTA_1_2_MASK SYM_MASK(IBCCtrlB_0, IB_ENHANCED_MODE)
1073 #define IBA7322_IBC_MAX_SPEED_MASK SYM_MASK(IBCCtrlB_0, SD_SPEED)
1074 #define IBA7322_IBC_SPEED_QDR SYM_MASK(IBCCtrlB_0, SD_SPEED_QDR)
1075 #define IBA7322_IBC_SPEED_DDR SYM_MASK(IBCCtrlB_0, SD_SPEED_DDR)
1076 #define IBA7322_IBC_SPEED_SDR SYM_MASK(IBCCtrlB_0, SD_SPEED_SDR)
1077 #define IBA7322_IBC_SPEED_MASK (SYM_MASK(IBCCtrlB_0, SD_SPEED_SDR) | \
1078         SYM_MASK(IBCCtrlB_0, SD_SPEED_DDR) | SYM_MASK(IBCCtrlB_0, SD_SPEED_QDR))
1079 #define IBA7322_IBC_SPEED_LSB SYM_LSB(IBCCtrlB_0, SD_SPEED_SDR)
1080
1081 #define IBA7322_LEDBLINK_OFF_SHIFT SYM_LSB(RcvPktLEDCnt_0, OFFperiod)
1082 #define IBA7322_LEDBLINK_ON_SHIFT SYM_LSB(RcvPktLEDCnt_0, ONperiod)
1083
1084 #define IBA7322_IBC_WIDTH_AUTONEG SYM_MASK(IBCCtrlB_0, IB_NUM_CHANNELS)
1085 #define IBA7322_IBC_WIDTH_4X_ONLY (1<<SYM_LSB(IBCCtrlB_0, IB_NUM_CHANNELS))
1086 #define IBA7322_IBC_WIDTH_1X_ONLY (0<<SYM_LSB(IBCCtrlB_0, IB_NUM_CHANNELS))
1087
1088 #define IBA7322_IBC_RXPOL_MASK SYM_MASK(IBCCtrlB_0, IB_POLARITY_REV_SUPP)
1089 #define IBA7322_IBC_RXPOL_LSB SYM_LSB(IBCCtrlB_0, IB_POLARITY_REV_SUPP)
1090 #define IBA7322_IBC_HRTBT_MASK (SYM_MASK(IBCCtrlB_0, HRTBT_AUTO) | \
1091         SYM_MASK(IBCCtrlB_0, HRTBT_ENB))
1092 #define IBA7322_IBC_HRTBT_RMASK (IBA7322_IBC_HRTBT_MASK >> \
1093         SYM_LSB(IBCCtrlB_0, HRTBT_ENB))
1094 #define IBA7322_IBC_HRTBT_LSB SYM_LSB(IBCCtrlB_0, HRTBT_ENB)
1095
1096 #define IBA7322_REDIRECT_VEC_PER_REG 12
1097
1098 #define IBA7322_SENDCHK_PKEY SYM_MASK(SendCheckControl_0, PKey_En)
1099 #define IBA7322_SENDCHK_BTHQP SYM_MASK(SendCheckControl_0, BTHQP_En)
1100 #define IBA7322_SENDCHK_SLID SYM_MASK(SendCheckControl_0, SLID_En)
1101 #define IBA7322_SENDCHK_RAW_IPV6 SYM_MASK(SendCheckControl_0, RawIPV6_En)
1102 #define IBA7322_SENDCHK_MINSZ SYM_MASK(SendCheckControl_0, PacketTooSmall_En)
1103
1104 #define AUTONEG_TRIES 3 /* sequential retries to negotiate DDR */
1105
1106 #define HWE_AUTO(fldname) { .mask = SYM_MASK(HwErrMask, fldname##Mask), \
1107         .msg = #fldname }
1108 #define HWE_AUTO_P(fldname, port) { .mask = SYM_MASK(HwErrMask, \
1109         fldname##Mask##_##port), .msg = #fldname }
1110 static const struct qib_hwerror_msgs qib_7322_hwerror_msgs[] = {
1111         HWE_AUTO_P(IBSerdesPClkNotDetect, 1),
1112         HWE_AUTO_P(IBSerdesPClkNotDetect, 0),
1113         HWE_AUTO(PCIESerdesPClkNotDetect),
1114         HWE_AUTO(PowerOnBISTFailed),
1115         HWE_AUTO(TempsenseTholdReached),
1116         HWE_AUTO(MemoryErr),
1117         HWE_AUTO(PCIeBusParityErr),
1118         HWE_AUTO(PcieCplTimeout),
1119         HWE_AUTO(PciePoisonedTLP),
1120         HWE_AUTO_P(SDmaMemReadErr, 1),
1121         HWE_AUTO_P(SDmaMemReadErr, 0),
1122         HWE_AUTO_P(IBCBusFromSPCParityErr, 1),
1123         HWE_AUTO_P(IBCBusToSPCParityErr, 1),
1124         HWE_AUTO_P(IBCBusFromSPCParityErr, 0),
1125         HWE_AUTO(statusValidNoEop),
1126         HWE_AUTO(LATriggered),
1127         { .mask = 0 }
1128 };
1129
1130 #define E_AUTO(fldname) { .mask = SYM_MASK(ErrMask, fldname##Mask), \
1131         .msg = #fldname }
1132 #define E_P_AUTO(fldname) { .mask = SYM_MASK(ErrMask_0, fldname##Mask), \
1133         .msg = #fldname }
1134 static const struct qib_hwerror_msgs qib_7322error_msgs[] = {
1135         E_AUTO(ResetNegated),
1136         E_AUTO(HardwareErr),
1137         E_AUTO(InvalidAddrErr),
1138         E_AUTO(SDmaVL15Err),
1139         E_AUTO(SBufVL15MisUseErr),
1140         E_AUTO(InvalidEEPCmd),
1141         E_AUTO(RcvContextShareErr),
1142         E_AUTO(SendVLMismatchErr),
1143         E_AUTO(SendArmLaunchErr),
1144         E_AUTO(SendSpecialTriggerErr),
1145         E_AUTO(SDmaWrongPortErr),
1146         E_AUTO(SDmaBufMaskDuplicateErr),
1147         E_AUTO(RcvHdrFullErr),
1148         E_AUTO(RcvEgrFullErr),
1149         { .mask = 0 }
1150 };
1151
1152 static const struct  qib_hwerror_msgs qib_7322p_error_msgs[] = {
1153         E_P_AUTO(IBStatusChanged),
1154         E_P_AUTO(SHeadersErr),
1155         E_P_AUTO(VL15BufMisuseErr),
1156         /*
1157          * SDmaHaltErr is not really an error, make it clearer;
1158          */
1159         {.mask = SYM_MASK(ErrMask_0, SDmaHaltErrMask), .msg = "SDmaHalted"},
1160         E_P_AUTO(SDmaDescAddrMisalignErr),
1161         E_P_AUTO(SDmaUnexpDataErr),
1162         E_P_AUTO(SDmaMissingDwErr),
1163         E_P_AUTO(SDmaDwEnErr),
1164         E_P_AUTO(SDmaRpyTagErr),
1165         E_P_AUTO(SDma1stDescErr),
1166         E_P_AUTO(SDmaBaseErr),
1167         E_P_AUTO(SDmaTailOutOfBoundErr),
1168         E_P_AUTO(SDmaOutOfBoundErr),
1169         E_P_AUTO(SDmaGenMismatchErr),
1170         E_P_AUTO(SendBufMisuseErr),
1171         E_P_AUTO(SendUnsupportedVLErr),
1172         E_P_AUTO(SendUnexpectedPktNumErr),
1173         E_P_AUTO(SendDroppedDataPktErr),
1174         E_P_AUTO(SendDroppedSmpPktErr),
1175         E_P_AUTO(SendPktLenErr),
1176         E_P_AUTO(SendUnderRunErr),
1177         E_P_AUTO(SendMaxPktLenErr),
1178         E_P_AUTO(SendMinPktLenErr),
1179         E_P_AUTO(RcvIBLostLinkErr),
1180         E_P_AUTO(RcvHdrErr),
1181         E_P_AUTO(RcvHdrLenErr),
1182         E_P_AUTO(RcvBadTidErr),
1183         E_P_AUTO(RcvBadVersionErr),
1184         E_P_AUTO(RcvIBFlowErr),
1185         E_P_AUTO(RcvEBPErr),
1186         E_P_AUTO(RcvUnsupportedVLErr),
1187         E_P_AUTO(RcvUnexpectedCharErr),
1188         E_P_AUTO(RcvShortPktLenErr),
1189         E_P_AUTO(RcvLongPktLenErr),
1190         E_P_AUTO(RcvMaxPktLenErr),
1191         E_P_AUTO(RcvMinPktLenErr),
1192         E_P_AUTO(RcvICRCErr),
1193         E_P_AUTO(RcvVCRCErr),
1194         E_P_AUTO(RcvFormatErr),
1195         { .mask = 0 }
1196 };
1197
1198 /*
1199  * Below generates "auto-message" for interrupts not specific to any port or
1200  * context
1201  */
1202 #define INTR_AUTO(fldname) { .mask = SYM_MASK(IntMask, fldname##Mask), \
1203         .msg = #fldname }
1204 /* Below generates "auto-message" for interrupts specific to a port */
1205 #define INTR_AUTO_P(fldname) { .mask = MASK_ACROSS(\
1206         SYM_LSB(IntMask, fldname##Mask##_0), \
1207         SYM_LSB(IntMask, fldname##Mask##_1)), \
1208         .msg = #fldname "_P" }
1209 /* For some reason, the SerDesTrimDone bits are reversed */
1210 #define INTR_AUTO_PI(fldname) { .mask = MASK_ACROSS(\
1211         SYM_LSB(IntMask, fldname##Mask##_1), \
1212         SYM_LSB(IntMask, fldname##Mask##_0)), \
1213         .msg = #fldname "_P" }
1214 /*
1215  * Below generates "auto-message" for interrupts specific to a context,
1216  * with ctxt-number appended
1217  */
1218 #define INTR_AUTO_C(fldname) { .mask = MASK_ACROSS(\
1219         SYM_LSB(IntMask, fldname##0IntMask), \
1220         SYM_LSB(IntMask, fldname##17IntMask)), \
1221         .msg = #fldname "_C"}
1222
1223 static const struct  qib_hwerror_msgs qib_7322_intr_msgs[] = {
1224         INTR_AUTO_P(SDmaInt),
1225         INTR_AUTO_P(SDmaProgressInt),
1226         INTR_AUTO_P(SDmaIdleInt),
1227         INTR_AUTO_P(SDmaCleanupDone),
1228         INTR_AUTO_C(RcvUrg),
1229         INTR_AUTO_P(ErrInt),
1230         INTR_AUTO(ErrInt),      /* non-port-specific errs */
1231         INTR_AUTO(AssertGPIOInt),
1232         INTR_AUTO_P(SendDoneInt),
1233         INTR_AUTO(SendBufAvailInt),
1234         INTR_AUTO_C(RcvAvail),
1235         { .mask = 0 }
1236 };
1237
1238 #define TXSYMPTOM_AUTO_P(fldname) \
1239         { .mask = SYM_MASK(SendHdrErrSymptom_0, fldname), .msg = #fldname }
1240 static const struct  qib_hwerror_msgs hdrchk_msgs[] = {
1241         TXSYMPTOM_AUTO_P(NonKeyPacket),
1242         TXSYMPTOM_AUTO_P(GRHFail),
1243         TXSYMPTOM_AUTO_P(PkeyFail),
1244         TXSYMPTOM_AUTO_P(QPFail),
1245         TXSYMPTOM_AUTO_P(SLIDFail),
1246         TXSYMPTOM_AUTO_P(RawIPV6),
1247         TXSYMPTOM_AUTO_P(PacketTooSmall),
1248         { .mask = 0 }
1249 };
1250
1251 #define IBA7322_HDRHEAD_PKTINT_SHIFT 32 /* interrupt cnt in upper 32 bits */
1252
1253 /*
1254  * Called when we might have an error that is specific to a particular
1255  * PIO buffer, and may need to cancel that buffer, so it can be re-used,
1256  * because we don't need to force the update of pioavail
1257  */
1258 static void qib_disarm_7322_senderrbufs(struct qib_pportdata *ppd)
1259 {
1260         struct qib_devdata *dd = ppd->dd;
1261         u32 i;
1262         int any;
1263         u32 piobcnt = dd->piobcnt2k + dd->piobcnt4k + NUM_VL15_BUFS;
1264         u32 regcnt = (piobcnt + BITS_PER_LONG - 1) / BITS_PER_LONG;
1265         unsigned long sbuf[4];
1266
1267         /*
1268          * It's possible that sendbuffererror could have bits set; might
1269          * have already done this as a result of hardware error handling.
1270          */
1271         any = 0;
1272         for (i = 0; i < regcnt; ++i) {
1273                 sbuf[i] = qib_read_kreg64(dd, kr_sendbuffererror + i);
1274                 if (sbuf[i]) {
1275                         any = 1;
1276                         qib_write_kreg(dd, kr_sendbuffererror + i, sbuf[i]);
1277                 }
1278         }
1279
1280         if (any)
1281                 qib_disarm_piobufs_set(dd, sbuf, piobcnt);
1282 }
1283
1284 /* No txe_recover yet, if ever */
1285
1286 /* No decode__errors yet */
1287 static void err_decode(char *msg, size_t len, u64 errs,
1288                        const struct qib_hwerror_msgs *msp)
1289 {
1290         u64 these, lmask;
1291         int took, multi, n = 0;
1292
1293         while (msp && msp->mask) {
1294                 multi = (msp->mask & (msp->mask - 1));
1295                 while (errs & msp->mask) {
1296                         these = (errs & msp->mask);
1297                         lmask = (these & (these - 1)) ^ these;
1298                         if (len) {
1299                                 if (n++) {
1300                                         /* separate the strings */
1301                                         *msg++ = ',';
1302                                         len--;
1303                                 }
1304                                 took = scnprintf(msg, len, "%s", msp->msg);
1305                                 len -= took;
1306                                 msg += took;
1307                         }
1308                         errs &= ~lmask;
1309                         if (len && multi) {
1310                                 /* More than one bit this mask */
1311                                 int idx = -1;
1312
1313                                 while (lmask & msp->mask) {
1314                                         ++idx;
1315                                         lmask >>= 1;
1316                                 }
1317                                 took = scnprintf(msg, len, "_%d", idx);
1318                                 len -= took;
1319                                 msg += took;
1320                         }
1321                 }
1322                 ++msp;
1323         }
1324         /* If some bits are left, show in hex. */
1325         if (len && errs)
1326                 snprintf(msg, len, "%sMORE:%llX", n ? "," : "",
1327                         (unsigned long long) errs);
1328 }
1329
1330 /* only called if r1 set */
1331 static void flush_fifo(struct qib_pportdata *ppd)
1332 {
1333         struct qib_devdata *dd = ppd->dd;
1334         u32 __iomem *piobuf;
1335         u32 bufn;
1336         u32 *hdr;
1337         u64 pbc;
1338         const unsigned hdrwords = 7;
1339         static struct qib_ib_header ibhdr = {
1340                 .lrh[0] = cpu_to_be16(0xF000 | QIB_LRH_BTH),
1341                 .lrh[1] = IB_LID_PERMISSIVE,
1342                 .lrh[2] = cpu_to_be16(hdrwords + SIZE_OF_CRC),
1343                 .lrh[3] = IB_LID_PERMISSIVE,
1344                 .u.oth.bth[0] = cpu_to_be32(
1345                         (IB_OPCODE_UD_SEND_ONLY << 24) | QIB_DEFAULT_P_KEY),
1346                 .u.oth.bth[1] = cpu_to_be32(0),
1347                 .u.oth.bth[2] = cpu_to_be32(0),
1348                 .u.oth.u.ud.deth[0] = cpu_to_be32(0),
1349                 .u.oth.u.ud.deth[1] = cpu_to_be32(0),
1350         };
1351
1352         /*
1353          * Send a dummy VL15 packet to flush the launch FIFO.
1354          * This will not actually be sent since the TxeBypassIbc bit is set.
1355          */
1356         pbc = PBC_7322_VL15_SEND |
1357                 (((u64)ppd->hw_pidx) << (PBC_PORT_SEL_LSB + 32)) |
1358                 (hdrwords + SIZE_OF_CRC);
1359         piobuf = qib_7322_getsendbuf(ppd, pbc, &bufn);
1360         if (!piobuf)
1361                 return;
1362         writeq(pbc, piobuf);
1363         hdr = (u32 *) &ibhdr;
1364         if (dd->flags & QIB_PIO_FLUSH_WC) {
1365                 qib_flush_wc();
1366                 qib_pio_copy(piobuf + 2, hdr, hdrwords - 1);
1367                 qib_flush_wc();
1368                 __raw_writel(hdr[hdrwords - 1], piobuf + hdrwords + 1);
1369                 qib_flush_wc();
1370         } else
1371                 qib_pio_copy(piobuf + 2, hdr, hdrwords);
1372         qib_sendbuf_done(dd, bufn);
1373 }
1374
1375 /*
1376  * This is called with interrupts disabled and sdma_lock held.
1377  */
1378 static void qib_7322_sdma_sendctrl(struct qib_pportdata *ppd, unsigned op)
1379 {
1380         struct qib_devdata *dd = ppd->dd;
1381         u64 set_sendctrl = 0;
1382         u64 clr_sendctrl = 0;
1383
1384         if (op & QIB_SDMA_SENDCTRL_OP_ENABLE)
1385                 set_sendctrl |= SYM_MASK(SendCtrl_0, SDmaEnable);
1386         else
1387                 clr_sendctrl |= SYM_MASK(SendCtrl_0, SDmaEnable);
1388
1389         if (op & QIB_SDMA_SENDCTRL_OP_INTENABLE)
1390                 set_sendctrl |= SYM_MASK(SendCtrl_0, SDmaIntEnable);
1391         else
1392                 clr_sendctrl |= SYM_MASK(SendCtrl_0, SDmaIntEnable);
1393
1394         if (op & QIB_SDMA_SENDCTRL_OP_HALT)
1395                 set_sendctrl |= SYM_MASK(SendCtrl_0, SDmaHalt);
1396         else
1397                 clr_sendctrl |= SYM_MASK(SendCtrl_0, SDmaHalt);
1398
1399         if (op & QIB_SDMA_SENDCTRL_OP_DRAIN)
1400                 set_sendctrl |= SYM_MASK(SendCtrl_0, TxeBypassIbc) |
1401                                 SYM_MASK(SendCtrl_0, TxeAbortIbc) |
1402                                 SYM_MASK(SendCtrl_0, TxeDrainRmFifo);
1403         else
1404                 clr_sendctrl |= SYM_MASK(SendCtrl_0, TxeBypassIbc) |
1405                                 SYM_MASK(SendCtrl_0, TxeAbortIbc) |
1406                                 SYM_MASK(SendCtrl_0, TxeDrainRmFifo);
1407
1408         spin_lock(&dd->sendctrl_lock);
1409
1410         /* If we are draining everything, block sends first */
1411         if (op & QIB_SDMA_SENDCTRL_OP_DRAIN) {
1412                 ppd->p_sendctrl &= ~SYM_MASK(SendCtrl_0, SendEnable);
1413                 qib_write_kreg_port(ppd, krp_sendctrl, ppd->p_sendctrl);
1414                 qib_write_kreg(dd, kr_scratch, 0);
1415         }
1416
1417         ppd->p_sendctrl |= set_sendctrl;
1418         ppd->p_sendctrl &= ~clr_sendctrl;
1419
1420         if (op & QIB_SDMA_SENDCTRL_OP_CLEANUP)
1421                 qib_write_kreg_port(ppd, krp_sendctrl,
1422                                     ppd->p_sendctrl |
1423                                     SYM_MASK(SendCtrl_0, SDmaCleanup));
1424         else
1425                 qib_write_kreg_port(ppd, krp_sendctrl, ppd->p_sendctrl);
1426         qib_write_kreg(dd, kr_scratch, 0);
1427
1428         if (op & QIB_SDMA_SENDCTRL_OP_DRAIN) {
1429                 ppd->p_sendctrl |= SYM_MASK(SendCtrl_0, SendEnable);
1430                 qib_write_kreg_port(ppd, krp_sendctrl, ppd->p_sendctrl);
1431                 qib_write_kreg(dd, kr_scratch, 0);
1432         }
1433
1434         spin_unlock(&dd->sendctrl_lock);
1435
1436         if ((op & QIB_SDMA_SENDCTRL_OP_DRAIN) && ppd->dd->cspec->r1)
1437                 flush_fifo(ppd);
1438 }
1439
1440 static void qib_7322_sdma_hw_clean_up(struct qib_pportdata *ppd)
1441 {
1442         __qib_sdma_process_event(ppd, qib_sdma_event_e50_hw_cleaned);
1443 }
1444
1445 static void qib_sdma_7322_setlengen(struct qib_pportdata *ppd)
1446 {
1447         /*
1448          * Set SendDmaLenGen and clear and set
1449          * the MSB of the generation count to enable generation checking
1450          * and load the internal generation counter.
1451          */
1452         qib_write_kreg_port(ppd, krp_senddmalengen, ppd->sdma_descq_cnt);
1453         qib_write_kreg_port(ppd, krp_senddmalengen,
1454                             ppd->sdma_descq_cnt |
1455                             (1ULL << QIB_7322_SendDmaLenGen_0_Generation_MSB));
1456 }
1457
1458 /*
1459  * Must be called with sdma_lock held, or before init finished.
1460  */
1461 static void qib_sdma_update_7322_tail(struct qib_pportdata *ppd, u16 tail)
1462 {
1463         /* Commit writes to memory and advance the tail on the chip */
1464         wmb();
1465         ppd->sdma_descq_tail = tail;
1466         qib_write_kreg_port(ppd, krp_senddmatail, tail);
1467 }
1468
1469 /*
1470  * This is called with interrupts disabled and sdma_lock held.
1471  */
1472 static void qib_7322_sdma_hw_start_up(struct qib_pportdata *ppd)
1473 {
1474         /*
1475          * Drain all FIFOs.
1476          * The hardware doesn't require this but we do it so that verbs
1477          * and user applications don't wait for link active to send stale
1478          * data.
1479          */
1480         sendctrl_7322_mod(ppd, QIB_SENDCTRL_FLUSH);
1481
1482         qib_sdma_7322_setlengen(ppd);
1483         qib_sdma_update_7322_tail(ppd, 0); /* Set SendDmaTail */
1484         ppd->sdma_head_dma[0] = 0;
1485         qib_7322_sdma_sendctrl(ppd,
1486                 ppd->sdma_state.current_op | QIB_SDMA_SENDCTRL_OP_CLEANUP);
1487 }
1488
1489 #define DISABLES_SDMA ( \
1490         QIB_E_P_SDMAHALT | \
1491         QIB_E_P_SDMADESCADDRMISALIGN | \
1492         QIB_E_P_SDMAMISSINGDW | \
1493         QIB_E_P_SDMADWEN | \
1494         QIB_E_P_SDMARPYTAG | \
1495         QIB_E_P_SDMA1STDESC | \
1496         QIB_E_P_SDMABASE | \
1497         QIB_E_P_SDMATAILOUTOFBOUND | \
1498         QIB_E_P_SDMAOUTOFBOUND | \
1499         QIB_E_P_SDMAGENMISMATCH)
1500
1501 static void sdma_7322_p_errors(struct qib_pportdata *ppd, u64 errs)
1502 {
1503         unsigned long flags;
1504         struct qib_devdata *dd = ppd->dd;
1505
1506         errs &= QIB_E_P_SDMAERRS;
1507
1508         if (errs & QIB_E_P_SDMAUNEXPDATA)
1509                 qib_dev_err(dd, "IB%u:%u SDmaUnexpData\n", dd->unit,
1510                             ppd->port);
1511
1512         spin_lock_irqsave(&ppd->sdma_lock, flags);
1513
1514         switch (ppd->sdma_state.current_state) {
1515         case qib_sdma_state_s00_hw_down:
1516                 break;
1517
1518         case qib_sdma_state_s10_hw_start_up_wait:
1519                 if (errs & QIB_E_P_SDMAHALT)
1520                         __qib_sdma_process_event(ppd,
1521                                 qib_sdma_event_e20_hw_started);
1522                 break;
1523
1524         case qib_sdma_state_s20_idle:
1525                 break;
1526
1527         case qib_sdma_state_s30_sw_clean_up_wait:
1528                 break;
1529
1530         case qib_sdma_state_s40_hw_clean_up_wait:
1531                 if (errs & QIB_E_P_SDMAHALT)
1532                         __qib_sdma_process_event(ppd,
1533                                 qib_sdma_event_e50_hw_cleaned);
1534                 break;
1535
1536         case qib_sdma_state_s50_hw_halt_wait:
1537                 if (errs & QIB_E_P_SDMAHALT)
1538                         __qib_sdma_process_event(ppd,
1539                                 qib_sdma_event_e60_hw_halted);
1540                 break;
1541
1542         case qib_sdma_state_s99_running:
1543                 __qib_sdma_process_event(ppd, qib_sdma_event_e7322_err_halted);
1544                 __qib_sdma_process_event(ppd, qib_sdma_event_e60_hw_halted);
1545                 break;
1546         }
1547
1548         spin_unlock_irqrestore(&ppd->sdma_lock, flags);
1549 }
1550
1551 /*
1552  * handle per-device errors (not per-port errors)
1553  */
1554 static noinline void handle_7322_errors(struct qib_devdata *dd)
1555 {
1556         char *msg;
1557         u64 iserr = 0;
1558         u64 errs;
1559         u64 mask;
1560         int log_idx;
1561
1562         qib_stats.sps_errints++;
1563         errs = qib_read_kreg64(dd, kr_errstatus);
1564         if (!errs) {
1565                 qib_devinfo(dd->pcidev, "device error interrupt, "
1566                          "but no error bits set!\n");
1567                 goto done;
1568         }
1569
1570         /* don't report errors that are masked */
1571         errs &= dd->cspec->errormask;
1572         msg = dd->cspec->emsgbuf;
1573
1574         /* do these first, they are most important */
1575         if (errs & QIB_E_HARDWARE) {
1576                 *msg = '\0';
1577                 qib_7322_handle_hwerrors(dd, msg, sizeof dd->cspec->emsgbuf);
1578         } else
1579                 for (log_idx = 0; log_idx < QIB_EEP_LOG_CNT; ++log_idx)
1580                         if (errs & dd->eep_st_masks[log_idx].errs_to_log)
1581                                 qib_inc_eeprom_err(dd, log_idx, 1);
1582
1583         if (errs & QIB_E_SPKTERRS) {
1584                 qib_disarm_7322_senderrbufs(dd->pport);
1585                 qib_stats.sps_txerrs++;
1586         } else if (errs & QIB_E_INVALIDADDR)
1587                 qib_stats.sps_txerrs++;
1588         else if (errs & QIB_E_ARMLAUNCH) {
1589                 qib_stats.sps_txerrs++;
1590                 qib_disarm_7322_senderrbufs(dd->pport);
1591         }
1592         qib_write_kreg(dd, kr_errclear, errs);
1593
1594         /*
1595          * The ones we mask off are handled specially below
1596          * or above.  Also mask SDMADISABLED by default as it
1597          * is too chatty.
1598          */
1599         mask = QIB_E_HARDWARE;
1600         *msg = '\0';
1601
1602         err_decode(msg, sizeof dd->cspec->emsgbuf, errs & ~mask,
1603                    qib_7322error_msgs);
1604
1605         /*
1606          * Getting reset is a tragedy for all ports. Mark the device
1607          * _and_ the ports as "offline" in way meaningful to each.
1608          */
1609         if (errs & QIB_E_RESET) {
1610                 int pidx;
1611
1612                 qib_dev_err(dd, "Got reset, requires re-init "
1613                             "(unload and reload driver)\n");
1614                 dd->flags &= ~QIB_INITTED;  /* needs re-init */
1615                 /* mark as having had error */
1616                 *dd->devstatusp |= QIB_STATUS_HWERROR;
1617                 for (pidx = 0; pidx < dd->num_pports; ++pidx)
1618                         if (dd->pport[pidx].link_speed_supported)
1619                                 *dd->pport[pidx].statusp &= ~QIB_STATUS_IB_CONF;
1620         }
1621
1622         if (*msg && iserr)
1623                 qib_dev_err(dd, "%s error\n", msg);
1624
1625         /*
1626          * If there were hdrq or egrfull errors, wake up any processes
1627          * waiting in poll.  We used to try to check which contexts had
1628          * the overflow, but given the cost of that and the chip reads
1629          * to support it, it's better to just wake everybody up if we
1630          * get an overflow; waiters can poll again if it's not them.
1631          */
1632         if (errs & (ERR_MASK(RcvEgrFullErr) | ERR_MASK(RcvHdrFullErr))) {
1633                 qib_handle_urcv(dd, ~0U);
1634                 if (errs & ERR_MASK(RcvEgrFullErr))
1635                         qib_stats.sps_buffull++;
1636                 else
1637                         qib_stats.sps_hdrfull++;
1638         }
1639
1640 done:
1641         return;
1642 }
1643
1644 static void reenable_chase(unsigned long opaque)
1645 {
1646         struct qib_pportdata *ppd = (struct qib_pportdata *)opaque;
1647
1648         ppd->cpspec->chase_timer.expires = 0;
1649         qib_set_ib_7322_lstate(ppd, QLOGIC_IB_IBCC_LINKCMD_DOWN,
1650                 QLOGIC_IB_IBCC_LINKINITCMD_POLL);
1651 }
1652
1653 static void disable_chase(struct qib_pportdata *ppd, u64 tnow, u8 ibclt)
1654 {
1655         ppd->cpspec->chase_end = 0;
1656
1657         if (!qib_chase)
1658                 return;
1659
1660         qib_set_ib_7322_lstate(ppd, QLOGIC_IB_IBCC_LINKCMD_DOWN,
1661                 QLOGIC_IB_IBCC_LINKINITCMD_DISABLE);
1662         ppd->cpspec->chase_timer.expires = jiffies + QIB_CHASE_DIS_TIME;
1663         add_timer(&ppd->cpspec->chase_timer);
1664 }
1665
1666 static void handle_serdes_issues(struct qib_pportdata *ppd, u64 ibcst)
1667 {
1668         u8 ibclt;
1669         u64 tnow;
1670
1671         ibclt = (u8)SYM_FIELD(ibcst, IBCStatusA_0, LinkTrainingState);
1672
1673         /*
1674          * Detect and handle the state chase issue, where we can
1675          * get stuck if we are unlucky on timing on both sides of
1676          * the link.   If we are, we disable, set a timer, and
1677          * then re-enable.
1678          */
1679         switch (ibclt) {
1680         case IB_7322_LT_STATE_CFGRCVFCFG:
1681         case IB_7322_LT_STATE_CFGWAITRMT:
1682         case IB_7322_LT_STATE_TXREVLANES:
1683         case IB_7322_LT_STATE_CFGENH:
1684                 tnow = get_jiffies_64();
1685                 if (ppd->cpspec->chase_end &&
1686                      time_after64(tnow, ppd->cpspec->chase_end))
1687                         disable_chase(ppd, tnow, ibclt);
1688                 else if (!ppd->cpspec->chase_end)
1689                         ppd->cpspec->chase_end = tnow + QIB_CHASE_TIME;
1690                 break;
1691         default:
1692                 ppd->cpspec->chase_end = 0;
1693                 break;
1694         }
1695
1696         if (ibclt == IB_7322_LT_STATE_CFGTEST &&
1697             (ibcst & SYM_MASK(IBCStatusA_0, LinkSpeedQDR))) {
1698                 force_h1(ppd);
1699                 ppd->cpspec->qdr_reforce = 1;
1700                 if (!ppd->dd->cspec->r1)
1701                         serdes_7322_los_enable(ppd, 0);
1702         } else if (ppd->cpspec->qdr_reforce &&
1703                 (ibcst & SYM_MASK(IBCStatusA_0, LinkSpeedQDR)) &&
1704                  (ibclt == IB_7322_LT_STATE_CFGENH ||
1705                 ibclt == IB_7322_LT_STATE_CFGIDLE ||
1706                 ibclt == IB_7322_LT_STATE_LINKUP))
1707                 force_h1(ppd);
1708
1709         if ((IS_QMH(ppd->dd) || IS_QME(ppd->dd)) &&
1710             ppd->link_speed_enabled == QIB_IB_QDR &&
1711             (ibclt == IB_7322_LT_STATE_CFGTEST ||
1712              ibclt == IB_7322_LT_STATE_CFGENH ||
1713              (ibclt >= IB_7322_LT_STATE_POLLACTIVE &&
1714               ibclt <= IB_7322_LT_STATE_SLEEPQUIET)))
1715                 adj_tx_serdes(ppd);
1716
1717         if (ibclt != IB_7322_LT_STATE_LINKUP) {
1718                 u8 ltstate = qib_7322_phys_portstate(ibcst);
1719                 u8 pibclt = (u8)SYM_FIELD(ppd->lastibcstat, IBCStatusA_0,
1720                                           LinkTrainingState);
1721                 if (!ppd->dd->cspec->r1 &&
1722                     pibclt == IB_7322_LT_STATE_LINKUP &&
1723                     ltstate != IB_PHYSPORTSTATE_LINK_ERR_RECOVER &&
1724                     ltstate != IB_PHYSPORTSTATE_RECOVERY_RETRAIN &&
1725                     ltstate != IB_PHYSPORTSTATE_RECOVERY_WAITRMT &&
1726                     ltstate != IB_PHYSPORTSTATE_RECOVERY_IDLE)
1727                         /* If the link went down (but no into recovery,
1728                          * turn LOS back on */
1729                         serdes_7322_los_enable(ppd, 1);
1730                 if (!ppd->cpspec->qdr_dfe_on &&
1731                     ibclt <= IB_7322_LT_STATE_SLEEPQUIET) {
1732                         ppd->cpspec->qdr_dfe_on = 1;
1733                         ppd->cpspec->qdr_dfe_time = 0;
1734                         /* On link down, reenable QDR adaptation */
1735                         qib_write_kreg_port(ppd, krp_static_adapt_dis(2),
1736                                             ppd->dd->cspec->r1 ?
1737                                             QDR_STATIC_ADAPT_DOWN_R1 :
1738                                             QDR_STATIC_ADAPT_DOWN);
1739                         printk(KERN_INFO QIB_DRV_NAME
1740                                 " IB%u:%u re-enabled QDR adaptation "
1741                                 "ibclt %x\n", ppd->dd->unit, ppd->port, ibclt);
1742                 }
1743         }
1744 }
1745
1746 static int qib_7322_set_ib_cfg(struct qib_pportdata *, int, u32);
1747
1748 /*
1749  * This is per-pport error handling.
1750  * will likely get it's own MSIx interrupt (one for each port,
1751  * although just a single handler).
1752  */
1753 static noinline void handle_7322_p_errors(struct qib_pportdata *ppd)
1754 {
1755         char *msg;
1756         u64 ignore_this_time = 0, iserr = 0, errs, fmask;
1757         struct qib_devdata *dd = ppd->dd;
1758
1759         /* do this as soon as possible */
1760         fmask = qib_read_kreg64(dd, kr_act_fmask);
1761         if (!fmask)
1762                 check_7322_rxe_status(ppd);
1763
1764         errs = qib_read_kreg_port(ppd, krp_errstatus);
1765         if (!errs)
1766                 qib_devinfo(dd->pcidev,
1767                          "Port%d error interrupt, but no error bits set!\n",
1768                          ppd->port);
1769         if (!fmask)
1770                 errs &= ~QIB_E_P_IBSTATUSCHANGED;
1771         if (!errs)
1772                 goto done;
1773
1774         msg = ppd->cpspec->epmsgbuf;
1775         *msg = '\0';
1776
1777         if (errs & ~QIB_E_P_BITSEXTANT) {
1778                 err_decode(msg, sizeof ppd->cpspec->epmsgbuf,
1779                            errs & ~QIB_E_P_BITSEXTANT, qib_7322p_error_msgs);
1780                 if (!*msg)
1781                         snprintf(msg, sizeof ppd->cpspec->epmsgbuf,
1782                                  "no others");
1783                 qib_dev_porterr(dd, ppd->port, "error interrupt with unknown"
1784                                 " errors 0x%016Lx set (and %s)\n",
1785                                 (errs & ~QIB_E_P_BITSEXTANT), msg);
1786                 *msg = '\0';
1787         }
1788
1789         if (errs & QIB_E_P_SHDR) {
1790                 u64 symptom;
1791
1792                 /* determine cause, then write to clear */
1793                 symptom = qib_read_kreg_port(ppd, krp_sendhdrsymptom);
1794                 qib_write_kreg_port(ppd, krp_sendhdrsymptom, 0);
1795                 err_decode(msg, sizeof ppd->cpspec->epmsgbuf, symptom,
1796                            hdrchk_msgs);
1797                 *msg = '\0';
1798                 /* senderrbuf cleared in SPKTERRS below */
1799         }
1800
1801         if (errs & QIB_E_P_SPKTERRS) {
1802                 if ((errs & QIB_E_P_LINK_PKTERRS) &&
1803                     !(ppd->lflags & QIBL_LINKACTIVE)) {
1804                         /*
1805                          * This can happen when trying to bring the link
1806                          * up, but the IB link changes state at the "wrong"
1807                          * time. The IB logic then complains that the packet
1808                          * isn't valid.  We don't want to confuse people, so
1809                          * we just don't print them, except at debug
1810                          */
1811                         err_decode(msg, sizeof ppd->cpspec->epmsgbuf,
1812                                    (errs & QIB_E_P_LINK_PKTERRS),
1813                                    qib_7322p_error_msgs);
1814                         *msg = '\0';
1815                         ignore_this_time = errs & QIB_E_P_LINK_PKTERRS;
1816                 }
1817                 qib_disarm_7322_senderrbufs(ppd);
1818         } else if ((errs & QIB_E_P_LINK_PKTERRS) &&
1819                    !(ppd->lflags & QIBL_LINKACTIVE)) {
1820                 /*
1821                  * This can happen when SMA is trying to bring the link
1822                  * up, but the IB link changes state at the "wrong" time.
1823                  * The IB logic then complains that the packet isn't
1824                  * valid.  We don't want to confuse people, so we just
1825                  * don't print them, except at debug
1826                  */
1827                 err_decode(msg, sizeof ppd->cpspec->epmsgbuf, errs,
1828                            qib_7322p_error_msgs);
1829                 ignore_this_time = errs & QIB_E_P_LINK_PKTERRS;
1830                 *msg = '\0';
1831         }
1832
1833         qib_write_kreg_port(ppd, krp_errclear, errs);
1834
1835         errs &= ~ignore_this_time;
1836         if (!errs)
1837                 goto done;
1838
1839         if (errs & QIB_E_P_RPKTERRS)
1840                 qib_stats.sps_rcverrs++;
1841         if (errs & QIB_E_P_SPKTERRS)
1842                 qib_stats.sps_txerrs++;
1843
1844         iserr = errs & ~(QIB_E_P_RPKTERRS | QIB_E_P_PKTERRS);
1845
1846         if (errs & QIB_E_P_SDMAERRS)
1847                 sdma_7322_p_errors(ppd, errs);
1848
1849         if (errs & QIB_E_P_IBSTATUSCHANGED) {
1850                 u64 ibcs;
1851                 u8 ltstate;
1852
1853                 ibcs = qib_read_kreg_port(ppd, krp_ibcstatus_a);
1854                 ltstate = qib_7322_phys_portstate(ibcs);
1855
1856                 if (!(ppd->lflags & QIBL_IB_AUTONEG_INPROG))
1857                         handle_serdes_issues(ppd, ibcs);
1858                 if (!(ppd->cpspec->ibcctrl_a &
1859                       SYM_MASK(IBCCtrlA_0, IBStatIntReductionEn))) {
1860                         /*
1861                          * We got our interrupt, so init code should be
1862                          * happy and not try alternatives. Now squelch
1863                          * other "chatter" from link-negotiation (pre Init)
1864                          */
1865                         ppd->cpspec->ibcctrl_a |=
1866                                 SYM_MASK(IBCCtrlA_0, IBStatIntReductionEn);
1867                         qib_write_kreg_port(ppd, krp_ibcctrl_a,
1868                                             ppd->cpspec->ibcctrl_a);
1869                 }
1870
1871                 /* Update our picture of width and speed from chip */
1872                 ppd->link_width_active =
1873                         (ibcs & SYM_MASK(IBCStatusA_0, LinkWidthActive)) ?
1874                             IB_WIDTH_4X : IB_WIDTH_1X;
1875                 ppd->link_speed_active = (ibcs & SYM_MASK(IBCStatusA_0,
1876                         LinkSpeedQDR)) ? QIB_IB_QDR : (ibcs &
1877                           SYM_MASK(IBCStatusA_0, LinkSpeedActive)) ?
1878                                    QIB_IB_DDR : QIB_IB_SDR;
1879
1880                 if ((ppd->lflags & QIBL_IB_LINK_DISABLED) && ltstate !=
1881                     IB_PHYSPORTSTATE_DISABLED)
1882                         qib_set_ib_7322_lstate(ppd, 0,
1883                                QLOGIC_IB_IBCC_LINKINITCMD_DISABLE);
1884                 else {
1885                         u32 lstate;
1886                         /*
1887                          * We need the current logical link state before
1888                          * lflags are set in handle_e_ibstatuschanged.
1889                          */
1890                         lstate = qib_7322_iblink_state(ibcs);
1891
1892                         if (IS_QMH(dd) && !ppd->cpspec->bounced &&
1893                             ltstate == IB_PHYSPORTSTATE_LINKUP &&
1894                             (lstate >= IB_PORT_INIT &&
1895                                 lstate <= IB_PORT_ACTIVE)) {
1896                                 ppd->cpspec->bounced = 1;
1897                                 qib_7322_set_ib_cfg(ppd, QIB_IB_CFG_LSTATE,
1898                                         IB_LINKCMD_DOWN | IB_LINKINITCMD_POLL);
1899                         }
1900
1901                         /*
1902                          * Since going into a recovery state causes the link
1903                          * state to go down and since recovery is transitory,
1904                          * it is better if we "miss" ever seeing the link
1905                          * training state go into recovery (i.e., ignore this
1906                          * transition for link state special handling purposes)
1907                          * without updating lastibcstat.
1908                          */
1909                         if (ltstate != IB_PHYSPORTSTATE_LINK_ERR_RECOVER &&
1910                             ltstate != IB_PHYSPORTSTATE_RECOVERY_RETRAIN &&
1911                             ltstate != IB_PHYSPORTSTATE_RECOVERY_WAITRMT &&
1912                             ltstate != IB_PHYSPORTSTATE_RECOVERY_IDLE)
1913                                 qib_handle_e_ibstatuschanged(ppd, ibcs);
1914                 }
1915         }
1916         if (*msg && iserr)
1917                 qib_dev_porterr(dd, ppd->port, "%s error\n", msg);
1918
1919         if (ppd->state_wanted & ppd->lflags)
1920                 wake_up_interruptible(&ppd->state_wait);
1921 done:
1922         return;
1923 }
1924
1925 /* enable/disable chip from delivering interrupts */
1926 static void qib_7322_set_intr_state(struct qib_devdata *dd, u32 enable)
1927 {
1928         if (enable) {
1929                 if (dd->flags & QIB_BADINTR)
1930                         return;
1931                 qib_write_kreg(dd, kr_intmask, dd->cspec->int_enable_mask);
1932                 /* cause any pending enabled interrupts to be re-delivered */
1933                 qib_write_kreg(dd, kr_intclear, 0ULL);
1934                 if (dd->cspec->num_msix_entries) {
1935                         /* and same for MSIx */
1936                         u64 val = qib_read_kreg64(dd, kr_intgranted);
1937                         if (val)
1938                                 qib_write_kreg(dd, kr_intgranted, val);
1939                 }
1940         } else
1941                 qib_write_kreg(dd, kr_intmask, 0ULL);
1942 }
1943
1944 /*
1945  * Try to cleanup as much as possible for anything that might have gone
1946  * wrong while in freeze mode, such as pio buffers being written by user
1947  * processes (causing armlaunch), send errors due to going into freeze mode,
1948  * etc., and try to avoid causing extra interrupts while doing so.
1949  * Forcibly update the in-memory pioavail register copies after cleanup
1950  * because the chip won't do it while in freeze mode (the register values
1951  * themselves are kept correct).
1952  * Make sure that we don't lose any important interrupts by using the chip
1953  * feature that says that writing 0 to a bit in *clear that is set in
1954  * *status will cause an interrupt to be generated again (if allowed by
1955  * the *mask value).
1956  * This is in chip-specific code because of all of the register accesses,
1957  * even though the details are similar on most chips.
1958  */
1959 static void qib_7322_clear_freeze(struct qib_devdata *dd)
1960 {
1961         int pidx;
1962
1963         /* disable error interrupts, to avoid confusion */
1964         qib_write_kreg(dd, kr_errmask, 0ULL);
1965
1966         for (pidx = 0; pidx < dd->num_pports; ++pidx)
1967                 if (dd->pport[pidx].link_speed_supported)
1968                         qib_write_kreg_port(dd->pport + pidx, krp_errmask,
1969                                             0ULL);
1970
1971         /* also disable interrupts; errormask is sometimes overwriten */
1972         qib_7322_set_intr_state(dd, 0);
1973
1974         /* clear the freeze, and be sure chip saw it */
1975         qib_write_kreg(dd, kr_control, dd->control);
1976         qib_read_kreg32(dd, kr_scratch);
1977
1978         /*
1979          * Force new interrupt if any hwerr, error or interrupt bits are
1980          * still set, and clear "safe" send packet errors related to freeze
1981          * and cancelling sends.  Re-enable error interrupts before possible
1982          * force of re-interrupt on pending interrupts.
1983          */
1984         qib_write_kreg(dd, kr_hwerrclear, 0ULL);
1985         qib_write_kreg(dd, kr_errclear, E_SPKT_ERRS_IGNORE);
1986         qib_write_kreg(dd, kr_errmask, dd->cspec->errormask);
1987         /* We need to purge per-port errs and reset mask, too */
1988         for (pidx = 0; pidx < dd->num_pports; ++pidx) {
1989                 if (!dd->pport[pidx].link_speed_supported)
1990                         continue;
1991                 qib_write_kreg_port(dd->pport + pidx, krp_errclear, ~0Ull);
1992                 qib_write_kreg_port(dd->pport + pidx, krp_errmask, ~0Ull);
1993         }
1994         qib_7322_set_intr_state(dd, 1);
1995 }
1996
1997 /* no error handling to speak of */
1998 /**
1999  * qib_7322_handle_hwerrors - display hardware errors.
2000  * @dd: the qlogic_ib device
2001  * @msg: the output buffer
2002  * @msgl: the size of the output buffer
2003  *
2004  * Use same msg buffer as regular errors to avoid excessive stack
2005  * use.  Most hardware errors are catastrophic, but for right now,
2006  * we'll print them and continue.  We reuse the same message buffer as
2007  * qib_handle_errors() to avoid excessive stack usage.
2008  */
2009 static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
2010                                      size_t msgl)
2011 {
2012         u64 hwerrs;
2013         u32 ctrl;
2014         int isfatal = 0;
2015
2016         hwerrs = qib_read_kreg64(dd, kr_hwerrstatus);
2017         if (!hwerrs)
2018                 goto bail;
2019         if (hwerrs == ~0ULL) {
2020                 qib_dev_err(dd, "Read of hardware error status failed "
2021                             "(all bits set); ignoring\n");
2022                 goto bail;
2023         }
2024         qib_stats.sps_hwerrs++;
2025
2026         /* Always clear the error status register, except BIST fail */
2027         qib_write_kreg(dd, kr_hwerrclear, hwerrs &
2028                        ~HWE_MASK(PowerOnBISTFailed));
2029
2030         hwerrs &= dd->cspec->hwerrmask;
2031
2032         /* no EEPROM logging, yet */
2033
2034         if (hwerrs)
2035                 qib_devinfo(dd->pcidev, "Hardware error: hwerr=0x%llx "
2036                             "(cleared)\n", (unsigned long long) hwerrs);
2037
2038         ctrl = qib_read_kreg32(dd, kr_control);
2039         if ((ctrl & SYM_MASK(Control, FreezeMode)) && !dd->diag_client) {
2040                 /*
2041                  * No recovery yet...
2042                  */
2043                 if ((hwerrs & ~HWE_MASK(LATriggered)) ||
2044                     dd->cspec->stay_in_freeze) {
2045                         /*
2046                          * If any set that we aren't ignoring only make the
2047                          * complaint once, in case it's stuck or recurring,
2048                          * and we get here multiple times
2049                          * Force link down, so switch knows, and
2050                          * LEDs are turned off.
2051                          */
2052                         if (dd->flags & QIB_INITTED)
2053                                 isfatal = 1;
2054                 } else
2055                         qib_7322_clear_freeze(dd);
2056         }
2057
2058         if (hwerrs & HWE_MASK(PowerOnBISTFailed)) {
2059                 isfatal = 1;
2060                 strlcpy(msg, "[Memory BIST test failed, "
2061                         "InfiniPath hardware unusable]", msgl);
2062                 /* ignore from now on, so disable until driver reloaded */
2063                 dd->cspec->hwerrmask &= ~HWE_MASK(PowerOnBISTFailed);
2064                 qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
2065         }
2066
2067         err_decode(msg, msgl, hwerrs, qib_7322_hwerror_msgs);
2068
2069         /* Ignore esoteric PLL failures et al. */
2070
2071         qib_dev_err(dd, "%s hardware error\n", msg);
2072
2073         if (isfatal && !dd->diag_client) {
2074                 qib_dev_err(dd, "Fatal Hardware Error, no longer"
2075                             " usable, SN %.16s\n", dd->serial);
2076                 /*
2077                  * for /sys status file and user programs to print; if no
2078                  * trailing brace is copied, we'll know it was truncated.
2079                  */
2080                 if (dd->freezemsg)
2081                         snprintf(dd->freezemsg, dd->freezelen,
2082                                  "{%s}", msg);
2083                 qib_disable_after_error(dd);
2084         }
2085 bail:;
2086 }
2087
2088 /**
2089  * qib_7322_init_hwerrors - enable hardware errors
2090  * @dd: the qlogic_ib device
2091  *
2092  * now that we have finished initializing everything that might reasonably
2093  * cause a hardware error, and cleared those errors bits as they occur,
2094  * we can enable hardware errors in the mask (potentially enabling
2095  * freeze mode), and enable hardware errors as errors (along with
2096  * everything else) in errormask
2097  */
2098 static void qib_7322_init_hwerrors(struct qib_devdata *dd)
2099 {
2100         int pidx;
2101         u64 extsval;
2102
2103         extsval = qib_read_kreg64(dd, kr_extstatus);
2104         if (!(extsval & (QIB_EXTS_MEMBIST_DISABLED |
2105                          QIB_EXTS_MEMBIST_ENDTEST)))
2106                 qib_dev_err(dd, "MemBIST did not complete!\n");
2107
2108         /* never clear BIST failure, so reported on each driver load */
2109         qib_write_kreg(dd, kr_hwerrclear, ~HWE_MASK(PowerOnBISTFailed));
2110         qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
2111
2112         /* clear all */
2113         qib_write_kreg(dd, kr_errclear, ~0ULL);
2114         /* enable errors that are masked, at least this first time. */
2115         qib_write_kreg(dd, kr_errmask, ~0ULL);
2116         dd->cspec->errormask = qib_read_kreg64(dd, kr_errmask);
2117         for (pidx = 0; pidx < dd->num_pports; ++pidx)
2118                 if (dd->pport[pidx].link_speed_supported)
2119                         qib_write_kreg_port(dd->pport + pidx, krp_errmask,
2120                                             ~0ULL);
2121 }
2122
2123 /*
2124  * Disable and enable the armlaunch error.  Used for PIO bandwidth testing
2125  * on chips that are count-based, rather than trigger-based.  There is no
2126  * reference counting, but that's also fine, given the intended use.
2127  * Only chip-specific because it's all register accesses
2128  */
2129 static void qib_set_7322_armlaunch(struct qib_devdata *dd, u32 enable)
2130 {
2131         if (enable) {
2132                 qib_write_kreg(dd, kr_errclear, QIB_E_SPIOARMLAUNCH);
2133                 dd->cspec->errormask |= QIB_E_SPIOARMLAUNCH;
2134         } else
2135                 dd->cspec->errormask &= ~QIB_E_SPIOARMLAUNCH;
2136         qib_write_kreg(dd, kr_errmask, dd->cspec->errormask);
2137 }
2138
2139 /*
2140  * Formerly took parameter <which> in pre-shifted,
2141  * pre-merged form with LinkCmd and LinkInitCmd
2142  * together, and assuming the zero was NOP.
2143  */
2144 static void qib_set_ib_7322_lstate(struct qib_pportdata *ppd, u16 linkcmd,
2145                                    u16 linitcmd)
2146 {
2147         u64 mod_wd;
2148         struct qib_devdata *dd = ppd->dd;
2149         unsigned long flags;
2150
2151         if (linitcmd == QLOGIC_IB_IBCC_LINKINITCMD_DISABLE) {
2152                 /*
2153                  * If we are told to disable, note that so link-recovery
2154                  * code does not attempt to bring us back up.
2155                  * Also reset everything that we can, so we start
2156                  * completely clean when re-enabled (before we
2157                  * actually issue the disable to the IBC)
2158                  */
2159                 qib_7322_mini_pcs_reset(ppd);
2160                 spin_lock_irqsave(&ppd->lflags_lock, flags);
2161                 ppd->lflags |= QIBL_IB_LINK_DISABLED;
2162                 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
2163         } else if (linitcmd || linkcmd == QLOGIC_IB_IBCC_LINKCMD_DOWN) {
2164                 /*
2165                  * Any other linkinitcmd will lead to LINKDOWN and then
2166                  * to INIT (if all is well), so clear flag to let
2167                  * link-recovery code attempt to bring us back up.
2168                  */
2169                 spin_lock_irqsave(&ppd->lflags_lock, flags);
2170                 ppd->lflags &= ~QIBL_IB_LINK_DISABLED;
2171                 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
2172                 /*
2173                  * Clear status change interrupt reduction so the
2174                  * new state is seen.
2175                  */
2176                 ppd->cpspec->ibcctrl_a &=
2177                         ~SYM_MASK(IBCCtrlA_0, IBStatIntReductionEn);
2178         }
2179
2180         mod_wd = (linkcmd << IBA7322_IBCC_LINKCMD_SHIFT) |
2181                 (linitcmd << QLOGIC_IB_IBCC_LINKINITCMD_SHIFT);
2182
2183         qib_write_kreg_port(ppd, krp_ibcctrl_a, ppd->cpspec->ibcctrl_a |
2184                             mod_wd);
2185         /* write to chip to prevent back-to-back writes of ibc reg */
2186         qib_write_kreg(dd, kr_scratch, 0);
2187
2188 }
2189
2190 /*
2191  * The total RCV buffer memory is 64KB, used for both ports, and is
2192  * in units of 64 bytes (same as IB flow control credit unit).
2193  * The consumedVL unit in the same registers are in 32 byte units!
2194  * So, a VL15 packet needs 4.50 IB credits, and 9 rx buffer chunks,
2195  * and we can therefore allocate just 9 IB credits for 2 VL15 packets
2196  * in krp_rxcreditvl15, rather than 10.
2197  */
2198 #define RCV_BUF_UNITSZ 64
2199 #define NUM_RCV_BUF_UNITS(dd) ((64 * 1024) / (RCV_BUF_UNITSZ * dd->num_pports))
2200
2201 static void set_vls(struct qib_pportdata *ppd)
2202 {
2203         int i, numvls, totcred, cred_vl, vl0extra;
2204         struct qib_devdata *dd = ppd->dd;
2205         u64 val;
2206
2207         numvls = qib_num_vls(ppd->vls_operational);
2208
2209         /*
2210          * Set up per-VL credits. Below is kluge based on these assumptions:
2211          * 1) port is disabled at the time early_init is called.
2212          * 2) give VL15 17 credits, for two max-plausible packets.
2213          * 3) Give VL0-N the rest, with any rounding excess used for VL0
2214          */
2215         /* 2 VL15 packets @ 288 bytes each (including IB headers) */
2216         totcred = NUM_RCV_BUF_UNITS(dd);
2217         cred_vl = (2 * 288 + RCV_BUF_UNITSZ - 1) / RCV_BUF_UNITSZ;
2218         totcred -= cred_vl;
2219         qib_write_kreg_port(ppd, krp_rxcreditvl15, (u64) cred_vl);
2220         cred_vl = totcred / numvls;
2221         vl0extra = totcred - cred_vl * numvls;
2222         qib_write_kreg_port(ppd, krp_rxcreditvl0, cred_vl + vl0extra);
2223         for (i = 1; i < numvls; i++)
2224                 qib_write_kreg_port(ppd, krp_rxcreditvl0 + i, cred_vl);
2225         for (; i < 8; i++) /* no buffer space for other VLs */
2226                 qib_write_kreg_port(ppd, krp_rxcreditvl0 + i, 0);
2227
2228         /* Notify IBC that credits need to be recalculated */
2229         val = qib_read_kreg_port(ppd, krp_ibsdtestiftx);
2230         val |= SYM_MASK(IB_SDTEST_IF_TX_0, CREDIT_CHANGE);
2231         qib_write_kreg_port(ppd, krp_ibsdtestiftx, val);
2232         qib_write_kreg(dd, kr_scratch, 0ULL);
2233         val &= ~SYM_MASK(IB_SDTEST_IF_TX_0, CREDIT_CHANGE);
2234         qib_write_kreg_port(ppd, krp_ibsdtestiftx, val);
2235
2236         for (i = 0; i < numvls; i++)
2237                 val = qib_read_kreg_port(ppd, krp_rxcreditvl0 + i);
2238         val = qib_read_kreg_port(ppd, krp_rxcreditvl15);
2239
2240         /* Change the number of operational VLs */
2241         ppd->cpspec->ibcctrl_a = (ppd->cpspec->ibcctrl_a &
2242                                 ~SYM_MASK(IBCCtrlA_0, NumVLane)) |
2243                 ((u64)(numvls - 1) << SYM_LSB(IBCCtrlA_0, NumVLane));
2244         qib_write_kreg_port(ppd, krp_ibcctrl_a, ppd->cpspec->ibcctrl_a);
2245         qib_write_kreg(dd, kr_scratch, 0ULL);
2246 }
2247
2248 /*
2249  * The code that deals with actual SerDes is in serdes_7322_init().
2250  * Compared to the code for iba7220, it is minimal.
2251  */
2252 static int serdes_7322_init(struct qib_pportdata *ppd);
2253
2254 /**
2255  * qib_7322_bringup_serdes - bring up the serdes
2256  * @ppd: physical port on the qlogic_ib device
2257  */
2258 static int qib_7322_bringup_serdes(struct qib_pportdata *ppd)
2259 {
2260         struct qib_devdata *dd = ppd->dd;
2261         u64 val, guid, ibc;
2262         unsigned long flags;
2263         int ret = 0;
2264
2265         /*
2266          * SerDes model not in Pd, but still need to
2267          * set up much of IBCCtrl and IBCDDRCtrl; move elsewhere
2268          * eventually.
2269          */
2270         /* Put IBC in reset, sends disabled (should be in reset already) */
2271         ppd->cpspec->ibcctrl_a &= ~SYM_MASK(IBCCtrlA_0, IBLinkEn);
2272         qib_write_kreg_port(ppd, krp_ibcctrl_a, ppd->cpspec->ibcctrl_a);
2273         qib_write_kreg(dd, kr_scratch, 0ULL);
2274
2275         if (qib_compat_ddr_negotiate) {
2276                 ppd->cpspec->ibdeltainprog = 1;
2277                 ppd->cpspec->ibsymsnap = read_7322_creg32_port(ppd,
2278                                                 crp_ibsymbolerr);
2279                 ppd->cpspec->iblnkerrsnap = read_7322_creg32_port(ppd,
2280                                                 crp_iblinkerrrecov);
2281         }
2282
2283         /* flowcontrolwatermark is in units of KBytes */
2284         ibc = 0x5ULL << SYM_LSB(IBCCtrlA_0, FlowCtrlWaterMark);
2285         /*
2286          * Flow control is sent this often, even if no changes in
2287          * buffer space occur.  Units are 128ns for this chip.
2288          * Set to 3usec.
2289          */
2290         ibc |= 24ULL << SYM_LSB(IBCCtrlA_0, FlowCtrlPeriod);
2291         /* max error tolerance */
2292         ibc |= 0xfULL << SYM_LSB(IBCCtrlA_0, PhyerrThreshold);
2293         /* IB credit flow control. */
2294         ibc |= 0xfULL << SYM_LSB(IBCCtrlA_0, OverrunThreshold);
2295         /*
2296          * set initial max size pkt IBC will send, including ICRC; it's the
2297          * PIO buffer size in dwords, less 1; also see qib_set_mtu()
2298          */
2299         ibc |= ((u64)(ppd->ibmaxlen >> 2) + 1) <<
2300                 SYM_LSB(IBCCtrlA_0, MaxPktLen);
2301         ppd->cpspec->ibcctrl_a = ibc; /* without linkcmd or linkinitcmd! */
2302
2303         /* initially come up waiting for TS1, without sending anything. */
2304         val = ppd->cpspec->ibcctrl_a | (QLOGIC_IB_IBCC_LINKINITCMD_DISABLE <<
2305                 QLOGIC_IB_IBCC_LINKINITCMD_SHIFT);
2306
2307         /*
2308          * Reset the PCS interface to the serdes (and also ibc, which is still
2309          * in reset from above).  Writes new value of ibcctrl_a as last step.
2310          */
2311         qib_7322_mini_pcs_reset(ppd);
2312         qib_write_kreg(dd, kr_scratch, 0ULL);
2313
2314         if (!ppd->cpspec->ibcctrl_b) {
2315                 unsigned lse = ppd->link_speed_enabled;
2316
2317                 /*
2318                  * Not on re-init after reset, establish shadow
2319                  * and force initial config.
2320                  */
2321                 ppd->cpspec->ibcctrl_b = qib_read_kreg_port(ppd,
2322                                                              krp_ibcctrl_b);
2323                 ppd->cpspec->ibcctrl_b &= ~(IBA7322_IBC_SPEED_QDR |
2324                                 IBA7322_IBC_SPEED_DDR |
2325                                 IBA7322_IBC_SPEED_SDR |
2326                                 IBA7322_IBC_WIDTH_AUTONEG |
2327                                 SYM_MASK(IBCCtrlB_0, IB_LANE_REV_SUPPORTED));
2328                 if (lse & (lse - 1)) /* Muliple speeds enabled */
2329                         ppd->cpspec->ibcctrl_b |=
2330                                 (lse << IBA7322_IBC_SPEED_LSB) |
2331                                 IBA7322_IBC_IBTA_1_2_MASK |
2332                                 IBA7322_IBC_MAX_SPEED_MASK;
2333                 else
2334                         ppd->cpspec->ibcctrl_b |= (lse == QIB_IB_QDR) ?
2335                                 IBA7322_IBC_SPEED_QDR |
2336                                  IBA7322_IBC_IBTA_1_2_MASK :
2337                                 (lse == QIB_IB_DDR) ?
2338                                         IBA7322_IBC_SPEED_DDR :
2339                                         IBA7322_IBC_SPEED_SDR;
2340                 if ((ppd->link_width_enabled & (IB_WIDTH_1X | IB_WIDTH_4X)) ==
2341                     (IB_WIDTH_1X | IB_WIDTH_4X))
2342                         ppd->cpspec->ibcctrl_b |= IBA7322_IBC_WIDTH_AUTONEG;
2343                 else
2344                         ppd->cpspec->ibcctrl_b |=
2345                                 ppd->link_width_enabled == IB_WIDTH_4X ?
2346                                 IBA7322_IBC_WIDTH_4X_ONLY :
2347                                 IBA7322_IBC_WIDTH_1X_ONLY;
2348
2349                 /* always enable these on driver reload, not sticky */
2350                 ppd->cpspec->ibcctrl_b |= (IBA7322_IBC_RXPOL_MASK |
2351                         IBA7322_IBC_HRTBT_MASK);
2352         }
2353         qib_write_kreg_port(ppd, krp_ibcctrl_b, ppd->cpspec->ibcctrl_b);
2354
2355         /* setup so we have more time at CFGTEST to change H1 */
2356         val = qib_read_kreg_port(ppd, krp_ibcctrl_c);
2357         val &= ~SYM_MASK(IBCCtrlC_0, IB_FRONT_PORCH);
2358         val |= 0xfULL << SYM_LSB(IBCCtrlC_0, IB_FRONT_PORCH);
2359         qib_write_kreg_port(ppd, krp_ibcctrl_c, val);
2360
2361         serdes_7322_init(ppd);
2362
2363         guid = be64_to_cpu(ppd->guid);
2364         if (!guid) {
2365                 if (dd->base_guid)
2366                         guid = be64_to_cpu(dd->base_guid) + ppd->port - 1;
2367                 ppd->guid = cpu_to_be64(guid);
2368         }
2369
2370         qib_write_kreg_port(ppd, krp_hrtbt_guid, guid);
2371         /* write to chip to prevent back-to-back writes of ibc reg */
2372         qib_write_kreg(dd, kr_scratch, 0);
2373
2374         /* Enable port */
2375         ppd->cpspec->ibcctrl_a |= SYM_MASK(IBCCtrlA_0, IBLinkEn);
2376         set_vls(ppd);
2377
2378         /* be paranoid against later code motion, etc. */
2379         spin_lock_irqsave(&dd->cspec->rcvmod_lock, flags);
2380         ppd->p_rcvctrl |= SYM_MASK(RcvCtrl_0, RcvIBPortEnable);
2381         qib_write_kreg_port(ppd, krp_rcvctrl, ppd->p_rcvctrl);
2382         spin_unlock_irqrestore(&dd->cspec->rcvmod_lock, flags);
2383
2384         /* Also enable IBSTATUSCHG interrupt.  */
2385         val = qib_read_kreg_port(ppd, krp_errmask);
2386         qib_write_kreg_port(ppd, krp_errmask,
2387                 val | ERR_MASK_N(IBStatusChanged));
2388
2389         /* Always zero until we start messing with SerDes for real */
2390         return ret;
2391 }
2392
2393 /**
2394  * qib_7322_quiet_serdes - set serdes to txidle
2395  * @dd: the qlogic_ib device
2396  * Called when driver is being unloaded
2397  */
2398 static void qib_7322_mini_quiet_serdes(struct qib_pportdata *ppd)
2399 {
2400         u64 val;
2401         unsigned long flags;
2402
2403         qib_set_ib_7322_lstate(ppd, 0, QLOGIC_IB_IBCC_LINKINITCMD_DISABLE);
2404
2405         spin_lock_irqsave(&ppd->lflags_lock, flags);
2406         ppd->lflags &= ~QIBL_IB_AUTONEG_INPROG;
2407         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
2408         wake_up(&ppd->cpspec->autoneg_wait);
2409         cancel_delayed_work_sync(&ppd->cpspec->autoneg_work);
2410         if (ppd->dd->cspec->r1)
2411                 cancel_delayed_work_sync(&ppd->cpspec->ipg_work);
2412
2413         ppd->cpspec->chase_end = 0;
2414         if (ppd->cpspec->chase_timer.data) /* if initted */
2415                 del_timer_sync(&ppd->cpspec->chase_timer);
2416
2417         /*
2418          * Despite the name, actually disables IBC as well. Do it when
2419          * we are as sure as possible that no more packets can be
2420          * received, following the down and the PCS reset.
2421          * The actual disabling happens in qib_7322_mini_pci_reset(),
2422          * along with the PCS being reset.
2423          */
2424         ppd->cpspec->ibcctrl_a &= ~SYM_MASK(IBCCtrlA_0, IBLinkEn);
2425         qib_7322_mini_pcs_reset(ppd);
2426
2427         /*
2428          * Update the adjusted counters so the adjustment persists
2429          * across driver reload.
2430          */
2431         if (ppd->cpspec->ibsymdelta || ppd->cpspec->iblnkerrdelta ||
2432             ppd->cpspec->ibdeltainprog || ppd->cpspec->iblnkdowndelta) {
2433                 struct qib_devdata *dd = ppd->dd;
2434                 u64 diagc;
2435
2436                 /* enable counter writes */
2437                 diagc = qib_read_kreg64(dd, kr_hwdiagctrl);
2438                 qib_write_kreg(dd, kr_hwdiagctrl,
2439                                diagc | SYM_MASK(HwDiagCtrl, CounterWrEnable));
2440
2441                 if (ppd->cpspec->ibsymdelta || ppd->cpspec->ibdeltainprog) {
2442                         val = read_7322_creg32_port(ppd, crp_ibsymbolerr);
2443                         if (ppd->cpspec->ibdeltainprog)
2444                                 val -= val - ppd->cpspec->ibsymsnap;
2445                         val -= ppd->cpspec->ibsymdelta;
2446                         write_7322_creg_port(ppd, crp_ibsymbolerr, val);
2447                 }
2448                 if (ppd->cpspec->iblnkerrdelta || ppd->cpspec->ibdeltainprog) {
2449                         val = read_7322_creg32_port(ppd, crp_iblinkerrrecov);
2450                         if (ppd->cpspec->ibdeltainprog)
2451                                 val -= val - ppd->cpspec->iblnkerrsnap;
2452                         val -= ppd->cpspec->iblnkerrdelta;
2453                         write_7322_creg_port(ppd, crp_iblinkerrrecov, val);
2454                 }
2455                 if (ppd->cpspec->iblnkdowndelta) {
2456                         val = read_7322_creg32_port(ppd, crp_iblinkdown);
2457                         val += ppd->cpspec->iblnkdowndelta;
2458                         write_7322_creg_port(ppd, crp_iblinkdown, val);
2459                 }
2460                 /*
2461                  * No need to save ibmalfdelta since IB perfcounters
2462                  * are cleared on driver reload.
2463                  */
2464
2465                 /* and disable counter writes */
2466                 qib_write_kreg(dd, kr_hwdiagctrl, diagc);
2467         }
2468 }
2469
2470 /**
2471  * qib_setup_7322_setextled - set the state of the two external LEDs
2472  * @ppd: physical port on the qlogic_ib device
2473  * @on: whether the link is up or not
2474  *
2475  * The exact combo of LEDs if on is true is determined by looking
2476  * at the ibcstatus.
2477  *
2478  * These LEDs indicate the physical and logical state of IB link.
2479  * For this chip (at least with recommended board pinouts), LED1
2480  * is Yellow (logical state) and LED2 is Green (physical state),
2481  *
2482  * Note:  We try to match the Mellanox HCA LED behavior as best
2483  * we can.  Green indicates physical link state is OK (something is
2484  * plugged in, and we can train).
2485  * Amber indicates the link is logically up (ACTIVE).
2486  * Mellanox further blinks the amber LED to indicate data packet
2487  * activity, but we have no hardware support for that, so it would
2488  * require waking up every 10-20 msecs and checking the counters
2489  * on the chip, and then turning the LED off if appropriate.  That's
2490  * visible overhead, so not something we will do.
2491  */
2492 static void qib_setup_7322_setextled(struct qib_pportdata *ppd, u32 on)
2493 {
2494         struct qib_devdata *dd = ppd->dd;
2495         u64 extctl, ledblink = 0, val;
2496         unsigned long flags;
2497         int yel, grn;
2498
2499         /*
2500          * The diags use the LED to indicate diag info, so we leave
2501          * the external LED alone when the diags are running.
2502          */
2503         if (dd->diag_client)
2504                 return;
2505
2506         /* Allow override of LED display for, e.g. Locating system in rack */
2507         if (ppd->led_override) {
2508                 grn = (ppd->led_override & QIB_LED_PHYS);
2509                 yel = (ppd->led_override & QIB_LED_LOG);
2510         } else if (on) {
2511                 val = qib_read_kreg_port(ppd, krp_ibcstatus_a);
2512                 grn = qib_7322_phys_portstate(val) ==
2513                         IB_PHYSPORTSTATE_LINKUP;
2514                 yel = qib_7322_iblink_state(val) == IB_PORT_ACTIVE;
2515         } else {
2516                 grn = 0;
2517                 yel = 0;
2518         }
2519
2520         spin_lock_irqsave(&dd->cspec->gpio_lock, flags);
2521         extctl = dd->cspec->extctrl & (ppd->port == 1 ?
2522                 ~ExtLED_IB1_MASK : ~ExtLED_IB2_MASK);
2523         if (grn) {
2524                 extctl |= ppd->port == 1 ? ExtLED_IB1_GRN : ExtLED_IB2_GRN;
2525                 /*
2526                  * Counts are in chip clock (4ns) periods.
2527                  * This is 1/16 sec (66.6ms) on,
2528                  * 3/16 sec (187.5 ms) off, with packets rcvd.
2529                  */
2530                 ledblink = ((66600 * 1000UL / 4) << IBA7322_LEDBLINK_ON_SHIFT) |
2531                         ((187500 * 1000UL / 4) << IBA7322_LEDBLINK_OFF_SHIFT);
2532         }
2533         if (yel)
2534                 extctl |= ppd->port == 1 ? ExtLED_IB1_YEL : ExtLED_IB2_YEL;
2535         dd->cspec->extctrl = extctl;
2536         qib_write_kreg(dd, kr_extctrl, dd->cspec->extctrl);
2537         spin_unlock_irqrestore(&dd->cspec->gpio_lock, flags);
2538
2539         if (ledblink) /* blink the LED on packet receive */
2540                 qib_write_kreg_port(ppd, krp_rcvpktledcnt, ledblink);
2541 }
2542
2543 /*
2544  * Disable MSIx interrupt if enabled, call generic MSIx code
2545  * to cleanup, and clear pending MSIx interrupts.
2546  * Used for fallback to INTx, after reset, and when MSIx setup fails.
2547  */
2548 static void qib_7322_nomsix(struct qib_devdata *dd)
2549 {
2550         u64 intgranted;
2551         int n;
2552
2553         dd->cspec->main_int_mask = ~0ULL;
2554         n = dd->cspec->num_msix_entries;
2555         if (n) {
2556                 int i;
2557
2558                 dd->cspec->num_msix_entries = 0;
2559                 for (i = 0; i < n; i++)
2560                         free_irq(dd->cspec->msix_entries[i].vector,
2561                                  dd->cspec->msix_arg[i]);
2562                 qib_nomsix(dd);
2563         }
2564         /* make sure no MSIx interrupts are left pending */
2565         intgranted = qib_read_kreg64(dd, kr_intgranted);
2566         if (intgranted)
2567                 qib_write_kreg(dd, kr_intgranted, intgranted);
2568 }
2569
2570 static void qib_7322_free_irq(struct qib_devdata *dd)
2571 {
2572         if (dd->cspec->irq) {
2573                 free_irq(dd->cspec->irq, dd);
2574                 dd->cspec->irq = 0;
2575         }
2576         qib_7322_nomsix(dd);
2577 }
2578
2579 static void qib_setup_7322_cleanup(struct qib_devdata *dd)
2580 {
2581         int i;
2582
2583         qib_7322_free_irq(dd);
2584         kfree(dd->cspec->cntrs);
2585         kfree(dd->cspec->sendchkenable);
2586         kfree(dd->cspec->sendgrhchk);
2587         kfree(dd->cspec->sendibchk);
2588         kfree(dd->cspec->msix_entries);
2589         kfree(dd->cspec->msix_arg);
2590         for (i = 0; i < dd->num_pports; i++) {
2591                 unsigned long flags;
2592                 u32 mask = QSFP_GPIO_MOD_PRS_N |
2593                         (QSFP_GPIO_MOD_PRS_N << QSFP_GPIO_PORT2_SHIFT);
2594
2595                 kfree(dd->pport[i].cpspec->portcntrs);
2596                 if (dd->flags & QIB_HAS_QSFP) {
2597                         spin_lock_irqsave(&dd->cspec->gpio_lock, flags);
2598                         dd->cspec->gpio_mask &= ~mask;
2599                         qib_write_kreg(dd, kr_gpio_mask, dd->cspec->gpio_mask);
2600                         spin_unlock_irqrestore(&dd->cspec->gpio_lock, flags);
2601                         qib_qsfp_deinit(&dd->pport[i].cpspec->qsfp_data);
2602                 }
2603                 if (dd->pport[i].ibport_data.smi_ah)
2604                         ib_destroy_ah(&dd->pport[i].ibport_data.smi_ah->ibah);
2605         }
2606 }
2607
2608 /* handle SDMA interrupts */
2609 static void sdma_7322_intr(struct qib_devdata *dd, u64 istat)
2610 {
2611         struct qib_pportdata *ppd0 = &dd->pport[0];
2612         struct qib_pportdata *ppd1 = &dd->pport[1];
2613         u64 intr0 = istat & (INT_MASK_P(SDma, 0) |
2614                 INT_MASK_P(SDmaIdle, 0) | INT_MASK_P(SDmaProgress, 0));
2615         u64 intr1 = istat & (INT_MASK_P(SDma, 1) |
2616                 INT_MASK_P(SDmaIdle, 1) | INT_MASK_P(SDmaProgress, 1));
2617
2618         if (intr0)
2619                 qib_sdma_intr(ppd0);
2620         if (intr1)
2621                 qib_sdma_intr(ppd1);
2622
2623         if (istat & INT_MASK_PM(SDmaCleanupDone, 0))
2624                 qib_sdma_process_event(ppd0, qib_sdma_event_e20_hw_started);
2625         if (istat & INT_MASK_PM(SDmaCleanupDone, 1))
2626                 qib_sdma_process_event(ppd1, qib_sdma_event_e20_hw_started);
2627 }
2628
2629 /*
2630  * Set or clear the Send buffer available interrupt enable bit.
2631  */
2632 static void qib_wantpiobuf_7322_intr(struct qib_devdata *dd, u32 needint)
2633 {
2634         unsigned long flags;
2635
2636         spin_lock_irqsave(&dd->sendctrl_lock, flags);
2637         if (needint)
2638                 dd->sendctrl |= SYM_MASK(SendCtrl, SendIntBufAvail);
2639         else
2640                 dd->sendctrl &= ~SYM_MASK(SendCtrl, SendIntBufAvail);
2641         qib_write_kreg(dd, kr_sendctrl, dd->sendctrl);
2642         qib_write_kreg(dd, kr_scratch, 0ULL);
2643         spin_unlock_irqrestore(&dd->sendctrl_lock, flags);
2644 }
2645
2646 /*
2647  * Somehow got an interrupt with reserved bits set in interrupt status.
2648  * Print a message so we know it happened, then clear them.
2649  * keep mainline interrupt handler cache-friendly
2650  */
2651 static noinline void unknown_7322_ibits(struct qib_devdata *dd, u64 istat)
2652 {
2653         u64 kills;
2654         char msg[128];
2655
2656         kills = istat & ~QIB_I_BITSEXTANT;
2657         qib_dev_err(dd, "Clearing reserved interrupt(s) 0x%016llx:"
2658                     " %s\n", (unsigned long long) kills, msg);
2659         qib_write_kreg(dd, kr_intmask, (dd->cspec->int_enable_mask & ~kills));
2660 }
2661
2662 /* keep mainline interrupt handler cache-friendly */
2663 static noinline void unknown_7322_gpio_intr(struct qib_devdata *dd)
2664 {
2665         u32 gpiostatus;
2666         int handled = 0;
2667         int pidx;
2668
2669         /*
2670          * Boards for this chip currently don't use GPIO interrupts,
2671          * so clear by writing GPIOstatus to GPIOclear, and complain
2672          * to developer.  To avoid endless repeats, clear
2673          * the bits in the mask, since there is some kind of
2674          * programming error or chip problem.
2675          */
2676         gpiostatus = qib_read_kreg32(dd, kr_gpio_status);
2677         /*
2678          * In theory, writing GPIOstatus to GPIOclear could
2679          * have a bad side-effect on some diagnostic that wanted
2680          * to poll for a status-change, but the various shadows
2681          * make that problematic at best. Diags will just suppress
2682          * all GPIO interrupts during such tests.
2683          */
2684         qib_write_kreg(dd, kr_gpio_clear, gpiostatus);
2685         /*
2686          * Check for QSFP MOD_PRS changes
2687          * only works for single port if IB1 != pidx1
2688          */
2689         for (pidx = 0; pidx < dd->num_pports && (dd->flags & QIB_HAS_QSFP);
2690              ++pidx) {
2691                 struct qib_pportdata *ppd;
2692                 struct qib_qsfp_data *qd;
2693                 u32 mask;
2694                 if (!dd->pport[pidx].link_speed_supported)
2695                         continue;
2696                 mask = QSFP_GPIO_MOD_PRS_N;
2697                 ppd = dd->pport + pidx;
2698                 mask <<= (QSFP_GPIO_PORT2_SHIFT * ppd->hw_pidx);
2699                 if (gpiostatus & dd->cspec->gpio_mask & mask) {
2700                         u64 pins;
2701                         qd = &ppd->cpspec->qsfp_data;
2702                         gpiostatus &= ~mask;
2703                         pins = qib_read_kreg64(dd, kr_extstatus);
2704                         pins >>= SYM_LSB(EXTStatus, GPIOIn);
2705                         if (!(pins & mask)) {
2706                                 ++handled;
2707                                 qd->t_insert = get_jiffies_64();
2708                                 queue_work(ib_wq, &qd->work);
2709                         }
2710                 }
2711         }
2712
2713         if (gpiostatus && !handled) {
2714                 const u32 mask = qib_read_kreg32(dd, kr_gpio_mask);
2715                 u32 gpio_irq = mask & gpiostatus;
2716
2717                 /*
2718                  * Clear any troublemakers, and update chip from shadow
2719                  */
2720                 dd->cspec->gpio_mask &= ~gpio_irq;
2721                 qib_write_kreg(dd, kr_gpio_mask, dd->cspec->gpio_mask);
2722         }
2723 }
2724
2725 /*
2726  * Handle errors and unusual events first, separate function
2727  * to improve cache hits for fast path interrupt handling.
2728  */
2729 static noinline void unlikely_7322_intr(struct qib_devdata *dd, u64 istat)
2730 {
2731         if (istat & ~QIB_I_BITSEXTANT)
2732                 unknown_7322_ibits(dd, istat);
2733         if (istat & QIB_I_GPIO)
2734                 unknown_7322_gpio_intr(dd);
2735         if (istat & QIB_I_C_ERROR)
2736                 handle_7322_errors(dd);
2737         if (istat & INT_MASK_P(Err, 0) && dd->rcd[0])
2738                 handle_7322_p_errors(dd->rcd[0]->ppd);
2739         if (istat & INT_MASK_P(Err, 1) && dd->rcd[1])
2740                 handle_7322_p_errors(dd->rcd[1]->ppd);
2741 }
2742
2743 /*
2744  * Dynamically adjust the rcv int timeout for a context based on incoming
2745  * packet rate.
2746  */
2747 static void adjust_rcv_timeout(struct qib_ctxtdata *rcd, int npkts)
2748 {
2749         struct qib_devdata *dd = rcd->dd;
2750         u32 timeout = dd->cspec->rcvavail_timeout[rcd->ctxt];
2751
2752         /*
2753          * Dynamically adjust idle timeout on chip
2754          * based on number of packets processed.
2755          */
2756         if (npkts < rcv_int_count && timeout > 2)
2757                 timeout >>= 1;
2758         else if (npkts >= rcv_int_count && timeout < rcv_int_timeout)
2759                 timeout = min(timeout << 1, rcv_int_timeout);
2760         else
2761                 return;
2762
2763         dd->cspec->rcvavail_timeout[rcd->ctxt] = timeout;
2764         qib_write_kreg(dd, kr_rcvavailtimeout + rcd->ctxt, timeout);
2765 }
2766
2767 /*
2768  * This is the main interrupt handler.
2769  * It will normally only be used for low frequency interrupts but may
2770  * have to handle all interrupts if INTx is enabled or fewer than normal
2771  * MSIx interrupts were allocated.
2772  * This routine should ignore the interrupt bits for any of the
2773  * dedicated MSIx handlers.
2774  */
2775 static irqreturn_t qib_7322intr(int irq, void *data)
2776 {
2777         struct qib_devdata *dd = data;
2778         irqreturn_t ret;
2779         u64 istat;
2780         u64 ctxtrbits;
2781         u64 rmask;
2782         unsigned i;
2783         u32 npkts;
2784
2785         if ((dd->flags & (QIB_PRESENT | QIB_BADINTR)) != QIB_PRESENT) {
2786                 /*
2787                  * This return value is not great, but we do not want the
2788                  * interrupt core code to remove our interrupt handler
2789                  * because we don't appear to be handling an interrupt
2790                  * during a chip reset.
2791                  */
2792                 ret = IRQ_HANDLED;
2793                 goto bail;
2794         }
2795
2796         istat = qib_read_kreg64(dd, kr_intstatus);
2797
2798         if (unlikely(istat == ~0ULL)) {
2799                 qib_bad_intrstatus(dd);
2800                 qib_dev_err(dd, "Interrupt status all f's, skipping\n");
2801                 /* don't know if it was our interrupt or not */
2802                 ret = IRQ_NONE;
2803                 goto bail;
2804         }
2805
2806         istat &= dd->cspec->main_int_mask;
2807         if (unlikely(!istat)) {
2808                 /* already handled, or shared and not us */
2809                 ret = IRQ_NONE;
2810                 goto bail;
2811         }
2812
2813         qib_stats.sps_ints++;
2814         if (dd->int_counter != (u32) -1)
2815                 dd->int_counter++;
2816
2817         /* handle "errors" of various kinds first, device ahead of port */
2818         if (unlikely(istat & (~QIB_I_BITSEXTANT | QIB_I_GPIO |
2819                               QIB_I_C_ERROR | INT_MASK_P(Err, 0) |
2820                               INT_MASK_P(Err, 1))))
2821                 unlikely_7322_intr(dd, istat);
2822
2823         /*
2824          * Clear the interrupt bits we found set, relatively early, so we
2825          * "know" know the chip will have seen this by the time we process
2826          * the queue, and will re-interrupt if necessary.  The processor
2827          * itself won't take the interrupt again until we return.
2828          */
2829         qib_write_kreg(dd, kr_intclear, istat);
2830
2831         /*
2832          * Handle kernel receive queues before checking for pio buffers
2833          * available since receives can overflow; piobuf waiters can afford
2834          * a few extra cycles, since they were waiting anyway.
2835          */
2836         ctxtrbits = istat & (QIB_I_RCVAVAIL_MASK | QIB_I_RCVURG_MASK);
2837         if (ctxtrbits) {
2838                 rmask = (1ULL << QIB_I_RCVAVAIL_LSB) |
2839                         (1ULL << QIB_I_RCVURG_LSB);
2840                 for (i = 0; i < dd->first_user_ctxt; i++) {
2841                         if (ctxtrbits & rmask) {
2842                                 ctxtrbits &= ~rmask;
2843                                 if (dd->rcd[i]) {
2844                                         qib_kreceive(dd->rcd[i], NULL, &npkts);
2845                                 }
2846                         }
2847                         rmask <<= 1;
2848                 }
2849                 if (ctxtrbits) {
2850                         ctxtrbits = (ctxtrbits >> QIB_I_RCVAVAIL_LSB) |
2851                                 (ctxtrbits >> QIB_I_RCVURG_LSB);
2852                         qib_handle_urcv(dd, ctxtrbits);
2853                 }
2854         }
2855
2856         if (istat & (QIB_I_P_SDMAINT(0) | QIB_I_P_SDMAINT(1)))
2857                 sdma_7322_intr(dd, istat);
2858
2859         if ((istat & QIB_I_SPIOBUFAVAIL) && (dd->flags & QIB_INITTED))
2860                 qib_ib_piobufavail(dd);
2861
2862         ret = IRQ_HANDLED;
2863 bail:
2864         return ret;
2865 }
2866
2867 /*
2868  * Dedicated receive packet available interrupt handler.
2869  */
2870 static irqreturn_t qib_7322pintr(int irq, void *data)
2871 {
2872         struct qib_ctxtdata *rcd = data;
2873         struct qib_devdata *dd = rcd->dd;
2874         u32 npkts;
2875
2876         if ((dd->flags & (QIB_PRESENT | QIB_BADINTR)) != QIB_PRESENT)
2877                 /*
2878                  * This return value is not great, but we do not want the
2879                  * interrupt core code to remove our interrupt handler
2880                  * because we don't appear to be handling an interrupt
2881                  * during a chip reset.
2882                  */
2883                 return IRQ_HANDLED;
2884
2885         qib_stats.sps_ints++;
2886         if (dd->int_counter != (u32) -1)
2887                 dd->int_counter++;
2888
2889         /* Clear the interrupt bit we expect to be set. */
2890         qib_write_kreg(dd, kr_intclear, ((1ULL << QIB_I_RCVAVAIL_LSB) |
2891                        (1ULL << QIB_I_RCVURG_LSB)) << rcd->ctxt);
2892
2893         qib_kreceive(rcd, NULL, &npkts);
2894
2895         return IRQ_HANDLED;
2896 }
2897
2898 /*
2899  * Dedicated Send buffer available interrupt handler.
2900  */
2901 static irqreturn_t qib_7322bufavail(int irq, void *data)
2902 {
2903         struct qib_devdata *dd = data;
2904
2905         if ((dd->flags & (QIB_PRESENT | QIB_BADINTR)) != QIB_PRESENT)
2906                 /*
2907                  * This return value is not great, but we do not want the
2908                  * interrupt core code to remove our interrupt handler
2909                  * because we don't appear to be handling an interrupt
2910                  * during a chip reset.
2911                  */
2912                 return IRQ_HANDLED;
2913
2914         qib_stats.sps_ints++;
2915         if (dd->int_counter != (u32) -1)
2916                 dd->int_counter++;
2917
2918         /* Clear the interrupt bit we expect to be set. */
2919         qib_write_kreg(dd, kr_intclear, QIB_I_SPIOBUFAVAIL);
2920
2921         /* qib_ib_piobufavail() will clear the want PIO interrupt if needed */
2922         if (dd->flags & QIB_INITTED)
2923                 qib_ib_piobufavail(dd);
2924         else
2925                 qib_wantpiobuf_7322_intr(dd, 0);
2926
2927         return IRQ_HANDLED;
2928 }
2929
2930 /*
2931  * Dedicated Send DMA interrupt handler.
2932  */
2933 static irqreturn_t sdma_intr(int irq, void *data)
2934 {
2935         struct qib_pportdata *ppd = data;
2936         struct qib_devdata *dd = ppd->dd;
2937
2938         if ((dd->flags & (QIB_PRESENT | QIB_BADINTR)) != QIB_PRESENT)
2939                 /*
2940                  * This return value is not great, but we do not want the
2941                  * interrupt core code to remove our interrupt handler
2942                  * because we don't appear to be handling an interrupt
2943                  * during a chip reset.
2944                  */
2945                 return IRQ_HANDLED;
2946
2947         qib_stats.sps_ints++;
2948         if (dd->int_counter != (u32) -1)
2949                 dd->int_counter++;
2950
2951         /* Clear the interrupt bit we expect to be set. */
2952         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
2953                        INT_MASK_P(SDma, 1) : INT_MASK_P(SDma, 0));
2954         qib_sdma_intr(ppd);
2955
2956         return IRQ_HANDLED;
2957 }
2958
2959 /*
2960  * Dedicated Send DMA idle interrupt handler.
2961  */
2962 static irqreturn_t sdma_idle_intr(int irq, void *data)
2963 {
2964         struct qib_pportdata *ppd = data;
2965         struct qib_devdata *dd = ppd->dd;
2966
2967         if ((dd->flags & (QIB_PRESENT | QIB_BADINTR)) != QIB_PRESENT)
2968                 /*
2969                  * This return value is not great, but we do not want the
2970                  * interrupt core code to remove our interrupt handler
2971                  * because we don't appear to be handling an interrupt
2972                  * during a chip reset.
2973                  */
2974                 return IRQ_HANDLED;
2975
2976         qib_stats.sps_ints++;
2977         if (dd->int_counter != (u32) -1)
2978                 dd->int_counter++;
2979
2980         /* Clear the interrupt bit we expect to be set. */
2981         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
2982                        INT_MASK_P(SDmaIdle, 1) : INT_MASK_P(SDmaIdle, 0));
2983         qib_sdma_intr(ppd);
2984
2985         return IRQ_HANDLED;
2986 }
2987
2988 /*
2989  * Dedicated Send DMA progress interrupt handler.
2990  */
2991 static irqreturn_t sdma_progress_intr(int irq, void *data)
2992 {
2993         struct qib_pportdata *ppd = data;
2994         struct qib_devdata *dd = ppd->dd;
2995
2996         if ((dd->flags & (QIB_PRESENT | QIB_BADINTR)) != QIB_PRESENT)
2997                 /*
2998                  * This return value is not great, but we do not want the
2999                  * interrupt core code to remove our interrupt handler
3000                  * because we don't appear to be handling an interrupt
3001                  * during a chip reset.
3002                  */
3003                 return IRQ_HANDLED;
3004
3005         qib_stats.sps_ints++;
3006         if (dd->int_counter != (u32) -1)
3007                 dd->int_counter++;
3008
3009         /* Clear the interrupt bit we expect to be set. */
3010         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
3011                        INT_MASK_P(SDmaProgress, 1) :
3012                        INT_MASK_P(SDmaProgress, 0));
3013         qib_sdma_intr(ppd);
3014
3015         return IRQ_HANDLED;
3016 }
3017
3018 /*
3019  * Dedicated Send DMA cleanup interrupt handler.
3020  */
3021 static irqreturn_t sdma_cleanup_intr(int irq, void *data)
3022 {
3023         struct qib_pportdata *ppd = data;
3024         struct qib_devdata *dd = ppd->dd;
3025
3026         if ((dd->flags & (QIB_PRESENT | QIB_BADINTR)) != QIB_PRESENT)
3027                 /*
3028                  * This return value is not great, but we do not want the
3029                  * interrupt core code to remove our interrupt handler
3030                  * because we don't appear to be handling an interrupt
3031                  * during a chip reset.
3032                  */
3033                 return IRQ_HANDLED;
3034
3035         qib_stats.sps_ints++;
3036         if (dd->int_counter != (u32) -1)
3037                 dd->int_counter++;
3038
3039         /* Clear the interrupt bit we expect to be set. */
3040         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
3041                        INT_MASK_PM(SDmaCleanupDone, 1) :
3042                        INT_MASK_PM(SDmaCleanupDone, 0));
3043         qib_sdma_process_event(ppd, qib_sdma_event_e20_hw_started);
3044
3045         return IRQ_HANDLED;
3046 }
3047
3048 /*
3049  * Set up our chip-specific interrupt handler.
3050  * The interrupt type has already been setup, so
3051  * we just need to do the registration and error checking.
3052  * If we are using MSIx interrupts, we may fall back to
3053  * INTx later, if the interrupt handler doesn't get called
3054  * within 1/2 second (see verify_interrupt()).
3055  */
3056 static void qib_setup_7322_interrupt(struct qib_devdata *dd, int clearpend)
3057 {
3058         int ret, i, msixnum;
3059         u64 redirect[6];
3060         u64 mask;
3061
3062         if (!dd->num_pports)
3063                 return;
3064
3065         if (clearpend) {
3066                 /*
3067                  * if not switching interrupt types, be sure interrupts are
3068                  * disabled, and then clear anything pending at this point,
3069                  * because we are starting clean.
3070                  */
3071                 qib_7322_set_intr_state(dd, 0);
3072
3073                 /* clear the reset error, init error/hwerror mask */
3074                 qib_7322_init_hwerrors(dd);
3075
3076                 /* clear any interrupt bits that might be set */
3077                 qib_write_kreg(dd, kr_intclear, ~0ULL);
3078
3079                 /* make sure no pending MSIx intr, and clear diag reg */
3080                 qib_write_kreg(dd, kr_intgranted, ~0ULL);
3081                 qib_write_kreg(dd, kr_vecclr_wo_int, ~0ULL);
3082         }
3083
3084         if (!dd->cspec->num_msix_entries) {
3085                 /* Try to get INTx interrupt */
3086 try_intx:
3087                 if (!dd->pcidev->irq) {
3088                         qib_dev_err(dd, "irq is 0, BIOS error?  "
3089                                     "Interrupts won't work\n");
3090                         goto bail;
3091                 }
3092                 ret = request_irq(dd->pcidev->irq, qib_7322intr,
3093                                   IRQF_SHARED, QIB_DRV_NAME, dd);
3094                 if (ret) {
3095                         qib_dev_err(dd, "Couldn't setup INTx "
3096                                     "interrupt (irq=%d): %d\n",
3097                                     dd->pcidev->irq, ret);
3098                         goto bail;
3099                 }
3100                 dd->cspec->irq = dd->pcidev->irq;
3101                 dd->cspec->main_int_mask = ~0ULL;
3102                 goto bail;
3103         }
3104
3105         /* Try to get MSIx interrupts */
3106         memset(redirect, 0, sizeof redirect);
3107         mask = ~0ULL;
3108         msixnum = 0;
3109         for (i = 0; msixnum < dd->cspec->num_msix_entries; i++) {
3110                 irq_handler_t handler;
3111                 const char *name;
3112                 void *arg;
3113                 u64 val;
3114                 int lsb, reg, sh;
3115
3116                 if (i < ARRAY_SIZE(irq_table)) {
3117                         if (irq_table[i].port) {
3118                                 /* skip if for a non-configured port */
3119                                 if (irq_table[i].port > dd->num_pports)
3120                                         continue;
3121                                 arg = dd->pport + irq_table[i].port - 1;
3122                         } else
3123                                 arg = dd;
3124                         lsb = irq_table[i].lsb;
3125                         handler = irq_table[i].handler;
3126                         name = irq_table[i].name;
3127                 } else {
3128                         unsigned ctxt;
3129
3130                         ctxt = i - ARRAY_SIZE(irq_table);
3131                         /* per krcvq context receive interrupt */
3132                         arg = dd->rcd[ctxt];
3133                         if (!arg)
3134                                 continue;
3135                         lsb = QIB_I_RCVAVAIL_LSB + ctxt;
3136                         handler = qib_7322pintr;
3137                         name = QIB_DRV_NAME " (kctx)";
3138                 }
3139                 ret = request_irq(dd->cspec->msix_entries[msixnum].vector,
3140                                   handler, 0, name, arg);
3141                 if (ret) {
3142                         /*
3143                          * Shouldn't happen since the enable said we could
3144                          * have as many as we are trying to setup here.
3145                          */
3146                         qib_dev_err(dd, "Couldn't setup MSIx "
3147                                     "interrupt (vec=%d, irq=%d): %d\n", msixnum,
3148                                     dd->cspec->msix_entries[msixnum].vector,
3149                                     ret);
3150                         qib_7322_nomsix(dd);
3151                         goto try_intx;
3152                 }
3153                 dd->cspec->msix_arg[msixnum] = arg;
3154                 if (lsb >= 0) {
3155                         reg = lsb / IBA7322_REDIRECT_VEC_PER_REG;
3156                         sh = (lsb % IBA7322_REDIRECT_VEC_PER_REG) *
3157                                 SYM_LSB(IntRedirect0, vec1);
3158                         mask &= ~(1ULL << lsb);
3159                         redirect[reg] |= ((u64) msixnum) << sh;
3160                 }
3161                 val = qib_read_kreg64(dd, 2 * msixnum + 1 +
3162                         (QIB_7322_MsixTable_OFFS / sizeof(u64)));
3163                 msixnum++;
3164         }
3165         /* Initialize the vector mapping */
3166         for (i = 0; i < ARRAY_SIZE(redirect); i++)
3167                 qib_write_kreg(dd, kr_intredirect + i, redirect[i]);
3168         dd->cspec->main_int_mask = mask;
3169 bail:;
3170 }
3171
3172 /**
3173  * qib_7322_boardname - fill in the board name and note features
3174  * @dd: the qlogic_ib device
3175  *
3176  * info will be based on the board revision register
3177  */
3178 static unsigned qib_7322_boardname(struct qib_devdata *dd)
3179 {
3180         /* Will need enumeration of board-types here */
3181         char *n;
3182         u32 boardid, namelen;
3183         unsigned features = DUAL_PORT_CAP;
3184
3185         boardid = SYM_FIELD(dd->revision, Revision, BoardID);
3186
3187         switch (boardid) {
3188         case 0:
3189                 n = "InfiniPath_QLE7342_Emulation";
3190                 break;
3191         case 1:
3192                 n = "InfiniPath_QLE7340";
3193                 dd->flags |= QIB_HAS_QSFP;
3194                 features = PORT_SPD_CAP;
3195                 break;
3196         case 2:
3197                 n = "InfiniPath_QLE7342";
3198                 dd->flags |= QIB_HAS_QSFP;
3199                 break;
3200         case 3:
3201                 n = "InfiniPath_QMI7342";
3202                 break;
3203         case 4:
3204                 n = "InfiniPath_Unsupported7342";
3205                 qib_dev_err(dd, "Unsupported version of QMH7342\n");
3206                 features = 0;
3207                 break;
3208         case BOARD_QMH7342:
3209                 n = "InfiniPath_QMH7342";
3210                 features = 0x24;
3211                 break;
3212         case BOARD_QME7342:
3213                 n = "InfiniPath_QME7342";
3214                 break;
3215         case 8:
3216                 n = "InfiniPath_QME7362";
3217                 dd->flags |= QIB_HAS_QSFP;
3218                 break;
3219         case 15:
3220                 n = "InfiniPath_QLE7342_TEST";
3221                 dd->flags |= QIB_HAS_QSFP;
3222                 break;
3223         default:
3224                 n = "InfiniPath_QLE73xy_UNKNOWN";
3225                 qib_dev_err(dd, "Unknown 7322 board type %u\n", boardid);
3226                 break;
3227         }
3228         dd->board_atten = 1; /* index into txdds_Xdr */
3229
3230         namelen = strlen(n) + 1;
3231         dd->boardname = kmalloc(namelen, GFP_KERNEL);
3232         if (!dd->boardname)
3233                 qib_dev_err(dd, "Failed allocation for board name: %s\n", n);
3234         else
3235                 snprintf(dd->boardname, namelen, "%s", n);
3236
3237         snprintf(dd->boardversion, sizeof(dd->boardversion),
3238                  "ChipABI %u.%u, %s, InfiniPath%u %u.%u, SW Compat %u\n",
3239                  QIB_CHIP_VERS_MAJ, QIB_CHIP_VERS_MIN, dd->boardname,
3240                  (unsigned)SYM_FIELD(dd->revision, Revision_R, Arch),
3241                  dd->majrev, dd->minrev,
3242                  (unsigned)SYM_FIELD(dd->revision, Revision_R, SW));
3243
3244         if (qib_singleport && (features >> PORT_SPD_CAP_SHIFT) & PORT_SPD_CAP) {
3245                 qib_devinfo(dd->pcidev, "IB%u: Forced to single port mode"
3246                             " by module parameter\n", dd->unit);
3247                 features &= PORT_SPD_CAP;
3248         }
3249
3250         return features;
3251 }
3252
3253 /*
3254  * This routine sleeps, so it can only be called from user context, not
3255  * from interrupt context.
3256  */
3257 static int qib_do_7322_reset(struct qib_devdata *dd)
3258 {
3259         u64 val;
3260         u64 *msix_vecsave;
3261         int i, msix_entries, ret = 1;
3262         u16 cmdval;
3263         u8 int_line, clinesz;
3264         unsigned long flags;
3265
3266         /* Use dev_err so it shows up in logs, etc. */
3267         qib_dev_err(dd, "Resetting InfiniPath unit %u\n", dd->unit);
3268
3269         qib_pcie_getcmd(dd, &cmdval, &int_line, &clinesz);
3270
3271         msix_entries = dd->cspec->num_msix_entries;
3272
3273         /* no interrupts till re-initted */
3274         qib_7322_set_intr_state(dd, 0);
3275
3276         if (msix_entries) {
3277                 qib_7322_nomsix(dd);
3278                 /* can be up to 512 bytes, too big for stack */
3279                 msix_vecsave = kmalloc(2 * dd->cspec->num_msix_entries *
3280                         sizeof(u64), GFP_KERNEL);
3281                 if (!msix_vecsave)
3282                         qib_dev_err(dd, "No mem to save MSIx data\n");
3283         } else
3284                 msix_vecsave = NULL;
3285
3286         /*
3287          * Core PCI (as of 2.6.18) doesn't save or rewrite the full vector
3288          * info that is set up by the BIOS, so we have to save and restore
3289          * it ourselves.   There is some risk something could change it,
3290          * after we save it, but since we have disabled the MSIx, it
3291          * shouldn't be touched...
3292          */
3293         for (i = 0; i < msix_entries; i++) {
3294                 u64 vecaddr, vecdata;
3295                 vecaddr = qib_read_kreg64(dd, 2 * i +
3296                                   (QIB_7322_MsixTable_OFFS / sizeof(u64)));
3297                 vecdata = qib_read_kreg64(dd, 1 + 2 * i +
3298                                   (QIB_7322_MsixTable_OFFS / sizeof(u64)));
3299                 if (msix_vecsave) {
3300                         msix_vecsave[2 * i] = vecaddr;
3301                         /* save it without the masked bit set */
3302                         msix_vecsave[1 + 2 * i] = vecdata & ~0x100000000ULL;
3303                 }
3304         }
3305
3306         dd->pport->cpspec->ibdeltainprog = 0;
3307         dd->pport->cpspec->ibsymdelta = 0;
3308         dd->pport->cpspec->iblnkerrdelta = 0;
3309         dd->pport->cpspec->ibmalfdelta = 0;
3310         dd->int_counter = 0; /* so we check interrupts work again */
3311
3312         /*
3313          * Keep chip from being accessed until we are ready.  Use
3314          * writeq() directly, to allow the write even though QIB_PRESENT
3315          * isnt' set.
3316          */
3317         dd->flags &= ~(QIB_INITTED | QIB_PRESENT | QIB_BADINTR);
3318         dd->flags |= QIB_DOING_RESET;
3319         val = dd->control | QLOGIC_IB_C_RESET;
3320         writeq(val, &dd->kregbase[kr_control]);
3321
3322         for (i = 1; i <= 5; i++) {
3323                 /*
3324                  * Allow MBIST, etc. to complete; longer on each retry.
3325                  * We sometimes get machine checks from bus timeout if no
3326                  * response, so for now, make it *really* long.
3327                  */
3328                 msleep(1000 + (1 + i) * 3000);
3329
3330                 qib_pcie_reenable(dd, cmdval, int_line, clinesz);
3331
3332                 /*
3333                  * Use readq directly, so we don't need to mark it as PRESENT
3334                  * until we get a successful indication that all is well.
3335                  */
3336                 val = readq(&dd->kregbase[kr_revision]);
3337                 if (val == dd->revision)
3338                         break;
3339                 if (i == 5) {
3340                         qib_dev_err(dd, "Failed to initialize after reset, "
3341                                     "unusable\n");
3342                         ret = 0;
3343                         goto  bail;
3344                 }
3345         }
3346
3347         dd->flags |= QIB_PRESENT; /* it's back */
3348
3349         if (msix_entries) {
3350                 /* restore the MSIx vector address and data if saved above */
3351                 for (i = 0; i < msix_entries; i++) {
3352                         dd->cspec->msix_entries[i].entry = i;
3353                         if (!msix_vecsave || !msix_vecsave[2 * i])
3354                                 continue;
3355                         qib_write_kreg(dd, 2 * i +
3356                                 (QIB_7322_MsixTable_OFFS / sizeof(u64)),
3357                                 msix_vecsave[2 * i]);
3358                         qib_write_kreg(dd, 1 + 2 * i +
3359                                 (QIB_7322_MsixTable_OFFS / sizeof(u64)),
3360                                 msix_vecsave[1 + 2 * i]);
3361                 }
3362         }
3363
3364         /* initialize the remaining registers.  */
3365         for (i = 0; i < dd->num_pports; ++i)
3366                 write_7322_init_portregs(&dd->pport[i]);
3367         write_7322_initregs(dd);
3368
3369         if (qib_pcie_params(dd, dd->lbus_width,
3370                             &dd->cspec->num_msix_entries,
3371                             dd->cspec->msix_entries))
3372                 qib_dev_err(dd, "Reset failed to setup PCIe or interrupts; "
3373                                 "continuing anyway\n");
3374
3375         qib_setup_7322_interrupt(dd, 1);
3376
3377         for (i = 0; i < dd->num_pports; ++i) {
3378                 struct qib_pportdata *ppd = &dd->pport[i];
3379
3380                 spin_lock_irqsave(&ppd->lflags_lock, flags);
3381                 ppd->lflags |= QIBL_IB_FORCE_NOTIFY;
3382                 ppd->lflags &= ~QIBL_IB_AUTONEG_FAILED;
3383                 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
3384         }
3385
3386 bail:
3387         dd->flags &= ~QIB_DOING_RESET; /* OK or not, no longer resetting */
3388         kfree(msix_vecsave);
3389         return ret;
3390 }
3391
3392 /**
3393  * qib_7322_put_tid - write a TID to the chip
3394  * @dd: the qlogic_ib device
3395  * @tidptr: pointer to the expected TID (in chip) to update
3396  * @tidtype: 0 for eager, 1 for expected
3397  * @pa: physical address of in memory buffer; tidinvalid if freeing
3398  */
3399 static void qib_7322_put_tid(struct qib_devdata *dd, u64 __iomem *tidptr,
3400                              u32 type, unsigned long pa)
3401 {
3402         if (!(dd->flags & QIB_PRESENT))
3403                 return;
3404         if (pa != dd->tidinvalid) {
3405                 u64 chippa = pa >> IBA7322_TID_PA_SHIFT;
3406
3407                 /* paranoia checks */
3408                 if (pa != (chippa << IBA7322_TID_PA_SHIFT)) {
3409                         qib_dev_err(dd, "Physaddr %lx not 2KB aligned!\n",
3410                                     pa);
3411                         return;
3412                 }
3413                 if (chippa >= (1UL << IBA7322_TID_SZ_SHIFT)) {
3414                         qib_dev_err(dd, "Physical page address 0x%lx "
3415                                 "larger than supported\n", pa);
3416                         return;
3417                 }
3418
3419                 if (type == RCVHQ_RCV_TYPE_EAGER)
3420                         chippa |= dd->tidtemplate;
3421                 else /* for now, always full 4KB page */
3422                         chippa |= IBA7322_TID_SZ_4K;
3423                 pa = chippa;
3424         }
3425         writeq(pa, tidptr);
3426         mmiowb();
3427 }
3428
3429 /**
3430  * qib_7322_clear_tids - clear all TID entries for a ctxt, expected and eager
3431  * @dd: the qlogic_ib device
3432  * @ctxt: the ctxt
3433  *
3434  * clear all TID entries for a ctxt, expected and eager.
3435  * Used from qib_close().
3436  */
3437 static void qib_7322_clear_tids(struct qib_devdata *dd,
3438                                 struct qib_ctxtdata *rcd)
3439 {
3440         u64 __iomem *tidbase;
3441         unsigned long tidinv;
3442         u32 ctxt;
3443         int i;
3444
3445         if (!dd->kregbase || !rcd)
3446                 return;
3447
3448         ctxt = rcd->ctxt;
3449
3450         tidinv = dd->tidinvalid;
3451         tidbase = (u64 __iomem *)
3452                 ((char __iomem *) dd->kregbase +
3453                  dd->rcvtidbase +
3454                  ctxt * dd->rcvtidcnt * sizeof(*tidbase));
3455
3456         for (i = 0; i < dd->rcvtidcnt; i++)
3457                 qib_7322_put_tid(dd, &tidbase[i], RCVHQ_RCV_TYPE_EXPECTED,
3458                                  tidinv);
3459
3460         tidbase = (u64 __iomem *)
3461                 ((char __iomem *) dd->kregbase +
3462                  dd->rcvegrbase +
3463                  rcd->rcvegr_tid_base * sizeof(*tidbase));
3464
3465         for (i = 0; i < rcd->rcvegrcnt; i++)
3466                 qib_7322_put_tid(dd, &tidbase[i], RCVHQ_RCV_TYPE_EAGER,
3467                                  tidinv);
3468 }
3469
3470 /**
3471  * qib_7322_tidtemplate - setup constants for TID updates
3472  * @dd: the qlogic_ib device
3473  *
3474  * We setup stuff that we use a lot, to avoid calculating each time
3475  */
3476 static void qib_7322_tidtemplate(struct qib_devdata *dd)
3477 {
3478         /*
3479          * For now, we always allocate 4KB buffers (at init) so we can
3480          * receive max size packets.  We may want a module parameter to
3481          * specify 2KB or 4KB and/or make it per port instead of per device
3482          * for those who want to reduce memory footprint.  Note that the
3483          * rcvhdrentsize size must be large enough to hold the largest
3484          * IB header (currently 96 bytes) that we expect to handle (plus of
3485          * course the 2 dwords of RHF).
3486          */
3487         if (dd->rcvegrbufsize == 2048)
3488                 dd->tidtemplate = IBA7322_TID_SZ_2K;
3489         else if (dd->rcvegrbufsize == 4096)
3490                 dd->tidtemplate = IBA7322_TID_SZ_4K;
3491         dd->tidinvalid = 0;
3492 }
3493
3494 /**
3495  * qib_init_7322_get_base_info - set chip-specific flags for user code
3496  * @rcd: the qlogic_ib ctxt
3497  * @kbase: qib_base_info pointer
3498  *
3499  * We set the PCIE flag because the lower bandwidth on PCIe vs
3500  * HyperTransport can affect some user packet algorithims.
3501  */
3502
3503 static int qib_7322_get_base_info(struct qib_ctxtdata *rcd,
3504                                   struct qib_base_info *kinfo)
3505 {
3506         kinfo->spi_runtime_flags |= QIB_RUNTIME_CTXT_MSB_IN_QP |
3507                 QIB_RUNTIME_PCIE | QIB_RUNTIME_NODMA_RTAIL |
3508                 QIB_RUNTIME_HDRSUPP | QIB_RUNTIME_SDMA;
3509         if (rcd->dd->cspec->r1)
3510                 kinfo->spi_runtime_flags |= QIB_RUNTIME_RCHK;
3511         if (rcd->dd->flags & QIB_USE_SPCL_TRIG)
3512                 kinfo->spi_runtime_flags |= QIB_RUNTIME_SPECIAL_TRIGGER;
3513
3514         return 0;
3515 }
3516
3517 static struct qib_message_header *
3518 qib_7322_get_msgheader(struct qib_devdata *dd, __le32 *rhf_addr)
3519 {
3520         u32 offset = qib_hdrget_offset(rhf_addr);
3521
3522         return (struct qib_message_header *)
3523                 (rhf_addr - dd->rhf_offset + offset);
3524 }
3525
3526 /*
3527  * Configure number of contexts.
3528  */
3529 static void qib_7322_config_ctxts(struct qib_devdata *dd)
3530 {
3531         unsigned long flags;
3532         u32 nchipctxts;
3533
3534         nchipctxts = qib_read_kreg32(dd, kr_contextcnt);
3535         dd->cspec->numctxts = nchipctxts;
3536         if (qib_n_krcv_queues > 1 && dd->num_pports) {
3537                 dd->first_user_ctxt = NUM_IB_PORTS +
3538                         (qib_n_krcv_queues - 1) * dd->num_pports;
3539                 if (dd->first_user_ctxt > nchipctxts)
3540                         dd->first_user_ctxt = nchipctxts;
3541                 dd->n_krcv_queues = dd->first_user_ctxt / dd->num_pports;
3542         } else {
3543                 dd->first_user_ctxt = NUM_IB_PORTS;
3544                 dd->n_krcv_queues = 1;
3545         }
3546
3547         if (!qib_cfgctxts) {
3548                 int nctxts = dd->first_user_ctxt + num_online_cpus();
3549
3550                 if (nctxts <= 6)
3551                         dd->ctxtcnt = 6;
3552                 else if (nctxts <= 10)
3553                         dd->ctxtcnt = 10;
3554                 else if (nctxts <= nchipctxts)
3555                         dd->ctxtcnt = nchipctxts;
3556         } else if (qib_cfgctxts < dd->num_pports)
3557                 dd->ctxtcnt = dd->num_pports;
3558         else if (qib_cfgctxts <= nchipctxts)
3559                 dd->ctxtcnt = qib_cfgctxts;
3560         if (!dd->ctxtcnt) /* none of the above, set to max */
3561                 dd->ctxtcnt = nchipctxts;
3562
3563         /*
3564          * Chip can be configured for 6, 10, or 18 ctxts, and choice
3565          * affects number of eager TIDs per ctxt (1K, 2K, 4K).
3566          * Lock to be paranoid about later motion, etc.
3567          */
3568         spin_lock_irqsave(&dd->cspec->rcvmod_lock, flags);
3569         if (dd->ctxtcnt > 10)
3570                 dd->rcvctrl |= 2ULL << SYM_LSB(RcvCtrl, ContextCfg);
3571         else if (dd->ctxtcnt > 6)
3572                 dd->rcvctrl |= 1ULL << SYM_LSB(RcvCtrl, ContextCfg);
3573         /* else configure for default 6 receive ctxts */
3574
3575         /* The XRC opcode is 5. */
3576         dd->rcvctrl |= 5ULL << SYM_LSB(RcvCtrl, XrcTypeCode);
3577
3578         /*
3579          * RcvCtrl *must* be written here so that the
3580          * chip understands how to change rcvegrcnt below.
3581          */
3582         qib_write_kreg(dd, kr_rcvctrl, dd->rcvctrl);
3583         spin_unlock_irqrestore(&dd->cspec->rcvmod_lock, flags);
3584
3585         /* kr_rcvegrcnt changes based on the number of contexts enabled */
3586         dd->cspec->rcvegrcnt = qib_read_kreg32(dd, kr_rcvegrcnt);
3587         if (qib_rcvhdrcnt)
3588                 dd->rcvhdrcnt = max(dd->cspec->rcvegrcnt, qib_rcvhdrcnt);
3589         else
3590                 dd->rcvhdrcnt = max(dd->cspec->rcvegrcnt,
3591                                     dd->num_pports > 1 ? 1024U : 2048U);
3592 }
3593
3594 static int qib_7322_get_ib_cfg(struct qib_pportdata *ppd, int which)
3595 {
3596
3597         int lsb, ret = 0;
3598         u64 maskr; /* right-justified mask */
3599
3600         switch (which) {
3601
3602         case QIB_IB_CFG_LWID_ENB: /* Get allowed Link-width */
3603                 ret = ppd->link_width_enabled;
3604                 goto done;
3605
3606         case QIB_IB_CFG_LWID: /* Get currently active Link-width */
3607                 ret = ppd->link_width_active;
3608                 goto done;
3609
3610         case QIB_IB_CFG_SPD_ENB: /* Get allowed Link speeds */
3611                 ret = ppd->link_speed_enabled;
3612                 goto done;
3613
3614         case QIB_IB_CFG_SPD: /* Get current Link spd */
3615                 ret = ppd->link_speed_active;
3616                 goto done;
3617
3618         case QIB_IB_CFG_RXPOL_ENB: /* Get Auto-RX-polarity enable */
3619                 lsb = SYM_LSB(IBCCtrlB_0, IB_POLARITY_REV_SUPP);
3620                 maskr = SYM_RMASK(IBCCtrlB_0, IB_POLARITY_REV_SUPP);
3621                 break;
3622
3623         case QIB_IB_CFG_LREV_ENB: /* Get Auto-Lane-reversal enable */
3624                 lsb = SYM_LSB(IBCCtrlB_0, IB_LANE_REV_SUPPORTED);
3625                 maskr = SYM_RMASK(IBCCtrlB_0, IB_LANE_REV_SUPPORTED);
3626                 break;
3627
3628         case QIB_IB_CFG_LINKLATENCY:
3629                 ret = qib_read_kreg_port(ppd, krp_ibcstatus_b) &
3630                         SYM_MASK(IBCStatusB_0, LinkRoundTripLatency);
3631                 goto done;
3632
3633         case QIB_IB_CFG_OP_VLS:
3634                 ret = ppd->vls_operational;
3635                 goto done;
3636
3637         case QIB_IB_CFG_VL_HIGH_CAP:
3638                 ret = 16;
3639                 goto done;
3640
3641         case QIB_IB_CFG_VL_LOW_CAP:
3642                 ret = 16;
3643                 goto done;
3644
3645         case QIB_IB_CFG_OVERRUN_THRESH: /* IB overrun threshold */
3646                 ret = SYM_FIELD(ppd->cpspec->ibcctrl_a, IBCCtrlA_0,
3647                                 OverrunThreshold);
3648                 goto done;
3649
3650         case QIB_IB_CFG_PHYERR_THRESH: /* IB PHY error threshold */
3651                 ret = SYM_FIELD(ppd->cpspec->ibcctrl_a, IBCCtrlA_0,
3652                                 PhyerrThreshold);
3653                 goto done;
3654
3655         case QIB_IB_CFG_LINKDEFAULT: /* IB link default (sleep/poll) */
3656                 /* will only take effect when the link state changes */
3657                 ret = (ppd->cpspec->ibcctrl_a &
3658                        SYM_MASK(IBCCtrlA_0, LinkDownDefaultState)) ?
3659                         IB_LINKINITCMD_SLEEP : IB_LINKINITCMD_POLL;
3660                 goto done;
3661
3662         case QIB_IB_CFG_HRTBT: /* Get Heartbeat off/enable/auto */
3663                 lsb = IBA7322_IBC_HRTBT_LSB;
3664                 maskr = IBA7322_IBC_HRTBT_RMASK; /* OR of AUTO and ENB */
3665                 break;
3666
3667         case QIB_IB_CFG_PMA_TICKS:
3668                 /*
3669                  * 0x00 = 10x link transfer rate or 4 nsec. for 2.5Gbs
3670                  * Since the clock is always 250MHz, the value is 3, 1 or 0.
3671                  */
3672                 if (ppd->link_speed_active == QIB_IB_QDR)
3673                         ret = 3;
3674                 else if (ppd->link_speed_active == QIB_IB_DDR)
3675                         ret = 1;
3676                 else
3677                         ret = 0;
3678                 goto done;
3679
3680         default:
3681                 ret = -EINVAL;
3682                 goto done;
3683         }
3684         ret = (int)((ppd->cpspec->ibcctrl_b >> lsb) & maskr);
3685 done:
3686         return ret;
3687 }
3688
3689 /*
3690  * Below again cribbed liberally from older version. Do not lean
3691  * heavily on it.
3692  */
3693 #define IBA7322_IBC_DLIDLMC_SHIFT QIB_7322_IBCCtrlB_0_IB_DLID_LSB
3694 #define IBA7322_IBC_DLIDLMC_MASK (QIB_7322_IBCCtrlB_0_IB_DLID_RMASK \
3695         | (QIB_7322_IBCCtrlB_0_IB_DLID_MASK_RMASK << 16))
3696
3697 static int qib_7322_set_ib_cfg(struct qib_pportdata *ppd, int which, u32 val)
3698 {
3699         struct qib_devdata *dd = ppd->dd;
3700         u64 maskr; /* right-justified mask */
3701         int lsb, ret = 0;
3702         u16 lcmd, licmd;
3703         unsigned long flags;
3704
3705         switch (which) {
3706         case QIB_IB_CFG_LIDLMC:
3707                 /*
3708                  * Set LID and LMC. Combined to avoid possible hazard
3709                  * caller puts LMC in 16MSbits, DLID in 16LSbits of val
3710                  */
3711                 lsb = IBA7322_IBC_DLIDLMC_SHIFT;
3712                 maskr = IBA7322_IBC_DLIDLMC_MASK;
3713                 /*
3714                  * For header-checking, the SLID in the packet will
3715                  * be masked with SendIBSLMCMask, and compared
3716                  * with SendIBSLIDAssignMask. Make sure we do not
3717                  * set any bits not covered by the mask, or we get
3718                  * false-positives.
3719                  */
3720                 qib_write_kreg_port(ppd, krp_sendslid,
3721                                     val & (val >> 16) & SendIBSLIDAssignMask);
3722                 qib_write_kreg_port(ppd, krp_sendslidmask,
3723                                     (val >> 16) & SendIBSLMCMask);
3724                 break;
3725
3726         case QIB_IB_CFG_LWID_ENB: /* set allowed Link-width */
3727                 ppd->link_width_enabled = val;
3728                 /* convert IB value to chip register value */
3729                 if (val == IB_WIDTH_1X)
3730                         val = 0;
3731                 else if (val == IB_WIDTH_4X)
3732                         val = 1;
3733                 else
3734                         val = 3;
3735                 maskr = SYM_RMASK(IBCCtrlB_0, IB_NUM_CHANNELS);
3736                 lsb = SYM_LSB(IBCCtrlB_0, IB_NUM_CHANNELS);
3737                 break;
3738
3739         case QIB_IB_CFG_SPD_ENB: /* set allowed Link speeds */
3740                 /*
3741                  * As with width, only write the actual register if the
3742                  * link is currently down, otherwise takes effect on next
3743                  * link change.  Since setting is being explictly requested
3744                  * (via MAD or sysfs), clear autoneg failure status if speed
3745                  * autoneg is enabled.
3746                  */
3747                 ppd->link_speed_enabled = val;
3748                 val <<= IBA7322_IBC_SPEED_LSB;
3749                 maskr = IBA7322_IBC_SPEED_MASK | IBA7322_IBC_IBTA_1_2_MASK |
3750                         IBA7322_IBC_MAX_SPEED_MASK;
3751                 if (val & (val - 1)) {
3752                         /* Muliple speeds enabled */
3753                         val |= IBA7322_IBC_IBTA_1_2_MASK |
3754                                 IBA7322_IBC_MAX_SPEED_MASK;
3755                         spin_lock_irqsave(&ppd->lflags_lock, flags);
3756                         ppd->lflags &= ~QIBL_IB_AUTONEG_FAILED;
3757                         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
3758                 } else if (val & IBA7322_IBC_SPEED_QDR)
3759                         val |= IBA7322_IBC_IBTA_1_2_MASK;
3760                 /* IBTA 1.2 mode + min/max + speed bits are contiguous */
3761                 lsb = SYM_LSB(IBCCtrlB_0, IB_ENHANCED_MODE);
3762                 break;
3763
3764         case QIB_IB_CFG_RXPOL_ENB: /* set Auto-RX-polarity enable */
3765                 lsb = SYM_LSB(IBCCtrlB_0, IB_POLARITY_REV_SUPP);
3766                 maskr = SYM_RMASK(IBCCtrlB_0, IB_POLARITY_REV_SUPP);
3767                 break;
3768
3769         case QIB_IB_CFG_LREV_ENB: /* set Auto-Lane-reversal enable */
3770                 lsb = SYM_LSB(IBCCtrlB_0, IB_LANE_REV_SUPPORTED);
3771                 maskr = SYM_RMASK(IBCCtrlB_0, IB_LANE_REV_SUPPORTED);
3772                 break;
3773
3774         case QIB_IB_CFG_OVERRUN_THRESH: /* IB overrun threshold */
3775                 maskr = SYM_FIELD(ppd->cpspec->ibcctrl_a, IBCCtrlA_0,
3776                                   OverrunThreshold);
3777                 if (maskr != val) {
3778                         ppd->cpspec->ibcctrl_a &=
3779                                 ~SYM_MASK(IBCCtrlA_0, OverrunThreshold);
3780                         ppd->cpspec->ibcctrl_a |= (u64) val <<
3781                                 SYM_LSB(IBCCtrlA_0, OverrunThreshold);
3782                         qib_write_kreg_port(ppd, krp_ibcctrl_a,
3783                                             ppd->cpspec->ibcctrl_a);
3784                         qib_write_kreg(dd, kr_scratch, 0ULL);
3785                 }
3786                 goto bail;
3787
3788         case QIB_IB_CFG_PHYERR_THRESH: /* IB PHY error threshold */
3789                 maskr = SYM_FIELD(ppd->cpspec->ibcctrl_a, IBCCtrlA_0,
3790                                   PhyerrThreshold);
3791                 if (maskr != val) {
3792                         ppd->cpspec->ibcctrl_a &=
3793                                 ~SYM_MASK(IBCCtrlA_0, PhyerrThreshold);
3794                         ppd->cpspec->ibcctrl_a |= (u64) val <<
3795                                 SYM_LSB(IBCCtrlA_0, PhyerrThreshold);
3796                         qib_write_kreg_port(ppd, krp_ibcctrl_a,
3797                                             ppd->cpspec->ibcctrl_a);
3798                         qib_write_kreg(dd, kr_scratch, 0ULL);
3799                 }
3800                 goto bail;
3801
3802         case QIB_IB_CFG_PKEYS: /* update pkeys */
3803                 maskr = (u64) ppd->pkeys[0] | ((u64) ppd->pkeys[1] << 16) |
3804                         ((u64) ppd->pkeys[2] << 32) |
3805                         ((u64) ppd->pkeys[3] << 48);
3806                 qib_write_kreg_port(ppd, krp_partitionkey, maskr);
3807                 goto bail;
3808
3809         case QIB_IB_CFG_LINKDEFAULT: /* IB link default (sleep/poll) */
3810                 /* will only take effect when the link state changes */
3811                 if (val == IB_LINKINITCMD_POLL)
3812                         ppd->cpspec->ibcctrl_a &=
3813                                 ~SYM_MASK(IBCCtrlA_0, LinkDownDefaultState);
3814                 else /* SLEEP */
3815                         ppd->cpspec->ibcctrl_a |=
3816                                 SYM_MASK(IBCCtrlA_0, LinkDownDefaultState);
3817                 qib_write_kreg_port(ppd, krp_ibcctrl_a, ppd->cpspec->ibcctrl_a);
3818                 qib_write_kreg(dd, kr_scratch, 0ULL);
3819                 goto bail;
3820
3821         case QIB_IB_CFG_MTU: /* update the MTU in IBC */
3822                 /*
3823                  * Update our housekeeping variables, and set IBC max
3824                  * size, same as init code; max IBC is max we allow in
3825                  * buffer, less the qword pbc, plus 1 for ICRC, in dwords
3826                  * Set even if it's unchanged, print debug message only
3827                  * on changes.
3828                  */
3829                 val = (ppd->ibmaxlen >> 2) + 1;
3830                 ppd->cpspec->ibcctrl_a &= ~SYM_MASK(IBCCtrlA_0, MaxPktLen);
3831                 ppd->cpspec->ibcctrl_a |= (u64)val <<
3832                         SYM_LSB(IBCCtrlA_0, MaxPktLen);
3833                 qib_write_kreg_port(ppd, krp_ibcctrl_a,
3834                                     ppd->cpspec->ibcctrl_a);
3835                 qib_write_kreg(dd, kr_scratch, 0ULL);
3836                 goto bail;
3837
3838         case QIB_IB_CFG_LSTATE: /* set the IB link state */
3839                 switch (val & 0xffff0000) {
3840                 case IB_LINKCMD_DOWN:
3841                         lcmd = QLOGIC_IB_IBCC_LINKCMD_DOWN;
3842                         ppd->cpspec->ibmalfusesnap = 1;
3843                         ppd->cpspec->ibmalfsnap = read_7322_creg32_port(ppd,
3844                                 crp_errlink);
3845                         if (!ppd->cpspec->ibdeltainprog &&
3846                             qib_compat_ddr_negotiate) {
3847                                 ppd->cpspec->ibdeltainprog = 1;
3848                                 ppd->cpspec->ibsymsnap =
3849                                         read_7322_creg32_port(ppd,
3850                                                               crp_ibsymbolerr);
3851                                 ppd->cpspec->iblnkerrsnap =
3852                                         read_7322_creg32_port(ppd,
3853                                                       crp_iblinkerrrecov);
3854                         }
3855                         break;
3856
3857                 case IB_LINKCMD_ARMED:
3858                         lcmd = QLOGIC_IB_IBCC_LINKCMD_ARMED;
3859                         if (ppd->cpspec->ibmalfusesnap) {
3860                                 ppd->cpspec->ibmalfusesnap = 0;
3861                                 ppd->cpspec->ibmalfdelta +=
3862                                         read_7322_creg32_port(ppd,
3863                                                               crp_errlink) -
3864                                         ppd->cpspec->ibmalfsnap;
3865                         }
3866                         break;
3867
3868                 case IB_LINKCMD_ACTIVE:
3869                         lcmd = QLOGIC_IB_IBCC_LINKCMD_ACTIVE;
3870                         break;
3871
3872                 default:
3873                         ret = -EINVAL;
3874                         qib_dev_err(dd, "bad linkcmd req 0x%x\n", val >> 16);
3875                         goto bail;
3876                 }
3877                 switch (val & 0xffff) {
3878                 case IB_LINKINITCMD_NOP:
3879                         licmd = 0;
3880                         break;
3881
3882                 case IB_LINKINITCMD_POLL:
3883                         licmd = QLOGIC_IB_IBCC_LINKINITCMD_POLL;
3884                         break;
3885
3886                 case IB_LINKINITCMD_SLEEP:
3887                         licmd = QLOGIC_IB_IBCC_LINKINITCMD_SLEEP;
3888                         break;
3889
3890                 case IB_LINKINITCMD_DISABLE:
3891                         licmd = QLOGIC_IB_IBCC_LINKINITCMD_DISABLE;
3892                         ppd->cpspec->chase_end = 0;
3893                         /*
3894                          * stop state chase counter and timer, if running.
3895                          * wait forpending timer, but don't clear .data (ppd)!
3896                          */
3897                         if (ppd->cpspec->chase_timer.expires) {
3898                                 del_timer_sync(&ppd->cpspec->chase_timer);
3899                                 ppd->cpspec->chase_timer.expires = 0;
3900                         }
3901                         break;
3902
3903                 default:
3904                         ret = -EINVAL;
3905                         qib_dev_err(dd, "bad linkinitcmd req 0x%x\n",
3906                                     val & 0xffff);
3907                         goto bail;
3908                 }
3909                 qib_set_ib_7322_lstate(ppd, lcmd, licmd);
3910                 goto bail;
3911
3912         case QIB_IB_CFG_OP_VLS:
3913                 if (ppd->vls_operational != val) {
3914                         ppd->vls_operational = val;
3915                         set_vls(ppd);
3916                 }
3917                 goto bail;
3918
3919         case QIB_IB_CFG_VL_HIGH_LIMIT:
3920                 qib_write_kreg_port(ppd, krp_highprio_limit, val);
3921                 goto bail;
3922
3923         case QIB_IB_CFG_HRTBT: /* set Heartbeat off/enable/auto */
3924                 if (val > 3) {
3925                         ret = -EINVAL;
3926                         goto bail;
3927                 }
3928                 lsb = IBA7322_IBC_HRTBT_LSB;
3929                 maskr = IBA7322_IBC_HRTBT_RMASK; /* OR of AUTO and ENB */
3930                 break;
3931
3932         case QIB_IB_CFG_PORT:
3933                 /* val is the port number of the switch we are connected to. */
3934                 if (ppd->dd->cspec->r1) {
3935                         cancel_delayed_work(&ppd->cpspec->ipg_work);
3936                         ppd->cpspec->ipg_tries = 0;
3937                 }
3938                 goto bail;
3939
3940         default:
3941                 ret = -EINVAL;
3942                 goto bail;
3943         }
3944         ppd->cpspec->ibcctrl_b &= ~(maskr << lsb);
3945         ppd->cpspec->ibcctrl_b |= (((u64) val & maskr) << lsb);
3946         qib_write_kreg_port(ppd, krp_ibcctrl_b, ppd->cpspec->ibcctrl_b);
3947         qib_write_kreg(dd, kr_scratch, 0);
3948 bail:
3949         return ret;
3950 }
3951
3952 static int qib_7322_set_loopback(struct qib_pportdata *ppd, const char *what)
3953 {
3954         int ret = 0;
3955         u64 val, ctrlb;
3956
3957         /* only IBC loopback, may add serdes and xgxs loopbacks later */
3958         if (!strncmp(what, "ibc", 3)) {
3959                 ppd->cpspec->ibcctrl_a |= SYM_MASK(IBCCtrlA_0,
3960                                                        Loopback);
3961                 val = 0; /* disable heart beat, so link will come up */
3962                 qib_devinfo(ppd->dd->pcidev, "Enabling IB%u:%u IBC loopback\n",
3963                          ppd->dd->unit, ppd->port);
3964         } else if (!strncmp(what, "off", 3)) {
3965                 ppd->cpspec->ibcctrl_a &= ~SYM_MASK(IBCCtrlA_0,
3966                                                         Loopback);
3967                 /* enable heart beat again */
3968                 val = IBA7322_IBC_HRTBT_RMASK << IBA7322_IBC_HRTBT_LSB;
3969                 qib_devinfo(ppd->dd->pcidev, "Disabling IB%u:%u IBC loopback "
3970                             "(normal)\n", ppd->dd->unit, ppd->port);
3971         } else
3972                 ret = -EINVAL;
3973         if (!ret) {
3974                 qib_write_kreg_port(ppd, krp_ibcctrl_a,
3975                                     ppd->cpspec->ibcctrl_a);
3976                 ctrlb = ppd->cpspec->ibcctrl_b & ~(IBA7322_IBC_HRTBT_MASK
3977                                              << IBA7322_IBC_HRTBT_LSB);
3978                 ppd->cpspec->ibcctrl_b = ctrlb | val;
3979                 qib_write_kreg_port(ppd, krp_ibcctrl_b,
3980                                     ppd->cpspec->ibcctrl_b);
3981                 qib_write_kreg(ppd->dd, kr_scratch, 0);
3982         }
3983         return ret;
3984 }
3985
3986 static void get_vl_weights(struct qib_pportdata *ppd, unsigned regno,
3987                            struct ib_vl_weight_elem *vl)
3988 {
3989         unsigned i;
3990
3991         for (i = 0; i < 16; i++, regno++, vl++) {
3992                 u32 val = qib_read_kreg_port(ppd, regno);
3993
3994                 vl->vl = (val >> SYM_LSB(LowPriority0_0, VirtualLane)) &
3995                         SYM_RMASK(LowPriority0_0, VirtualLane);
3996                 vl->weight = (val >> SYM_LSB(LowPriority0_0, Weight)) &
3997                         SYM_RMASK(LowPriority0_0, Weight);
3998         }
3999 }
4000
4001 static void set_vl_weights(struct qib_pportdata *ppd, unsigned regno,
4002                            struct ib_vl_weight_elem *vl)
4003 {
4004         unsigned i;
4005
4006         for (i = 0; i < 16; i++, regno++, vl++) {
4007                 u64 val;
4008
4009                 val = ((vl->vl & SYM_RMASK(LowPriority0_0, VirtualLane)) <<
4010                         SYM_LSB(LowPriority0_0, VirtualLane)) |
4011                       ((vl->weight & SYM_RMASK(LowPriority0_0, Weight)) <<
4012                         SYM_LSB(LowPriority0_0, Weight));
4013                 qib_write_kreg_port(ppd, regno, val);
4014         }
4015         if (!(ppd->p_sendctrl & SYM_MASK(SendCtrl_0, IBVLArbiterEn))) {
4016                 struct qib_devdata *dd = ppd->dd;
4017                 unsigned long flags;
4018
4019                 spin_lock_irqsave(&dd->sendctrl_lock, flags);
4020                 ppd->p_sendctrl |= SYM_MASK(SendCtrl_0, IBVLArbiterEn);
4021                 qib_write_kreg_port(ppd, krp_sendctrl, ppd->p_sendctrl);
4022                 qib_write_kreg(dd, kr_scratch, 0);
4023                 spin_unlock_irqrestore(&dd->sendctrl_lock, flags);
4024         }
4025 }
4026
4027 static int qib_7322_get_ib_table(struct qib_pportdata *ppd, int which, void *t)
4028 {
4029         switch (which) {
4030         case QIB_IB_TBL_VL_HIGH_ARB:
4031                 get_vl_weights(ppd, krp_highprio_0, t);
4032                 break;
4033
4034         case QIB_IB_TBL_VL_LOW_ARB:
4035                 get_vl_weights(ppd, krp_lowprio_0, t);
4036                 break;
4037
4038         default:
4039                 return -EINVAL;
4040         }
4041         return 0;
4042 }
4043
4044 static int qib_7322_set_ib_table(struct qib_pportdata *ppd, int which, void *t)
4045 {
4046         switch (which) {
4047         case QIB_IB_TBL_VL_HIGH_ARB:
4048                 set_vl_weights(ppd, krp_highprio_0, t);
4049                 break;
4050
4051         case QIB_IB_TBL_VL_LOW_ARB:
4052                 set_vl_weights(ppd, krp_lowprio_0, t);
4053                 break;
4054
4055         default:
4056                 return -EINVAL;
4057         }
4058         return 0;
4059 }
4060
4061 static void qib_update_7322_usrhead(struct qib_ctxtdata *rcd, u64 hd,
4062                                     u32 updegr, u32 egrhd, u32 npkts)
4063 {
4064         /*
4065          * Need to write timeout register before updating rcvhdrhead to ensure
4066          * that the timer is enabled on reception of a packet.
4067          */
4068         if (hd >> IBA7322_HDRHEAD_PKTINT_SHIFT)
4069                 adjust_rcv_timeout(rcd, npkts);
4070         qib_write_ureg(rcd->dd, ur_rcvhdrhead, hd, rcd->ctxt);
4071         qib_write_ureg(rcd->dd, ur_rcvhdrhead, hd, rcd->ctxt);
4072         if (updegr)
4073                 qib_write_ureg(rcd->dd, ur_rcvegrindexhead, egrhd, rcd->ctxt);
4074 }
4075
4076 static u32 qib_7322_hdrqempty(struct qib_ctxtdata *rcd)
4077 {
4078         u32 head, tail;
4079
4080         head = qib_read_ureg32(rcd->dd, ur_rcvhdrhead, rcd->ctxt);
4081         if (rcd->rcvhdrtail_kvaddr)
4082                 tail = qib_get_rcvhdrtail(rcd);
4083         else
4084                 tail = qib_read_ureg32(rcd->dd, ur_rcvhdrtail, rcd->ctxt);
4085         return head == tail;
4086 }
4087
4088 #define RCVCTRL_COMMON_MODS (QIB_RCVCTRL_CTXT_ENB | \
4089         QIB_RCVCTRL_CTXT_DIS | \
4090         QIB_RCVCTRL_TIDFLOW_ENB | \
4091         QIB_RCVCTRL_TIDFLOW_DIS | \
4092         QIB_RCVCTRL_TAILUPD_ENB | \
4093         QIB_RCVCTRL_TAILUPD_DIS | \
4094         QIB_RCVCTRL_INTRAVAIL_ENB | \
4095         QIB_RCVCTRL_INTRAVAIL_DIS | \
4096         QIB_RCVCTRL_BP_ENB | \
4097         QIB_RCVCTRL_BP_DIS)
4098
4099 #define RCVCTRL_PORT_MODS (QIB_RCVCTRL_CTXT_ENB | \
4100         QIB_RCVCTRL_CTXT_DIS | \
4101         QIB_RCVCTRL_PKEY_DIS | \
4102         QIB_RCVCTRL_PKEY_ENB)
4103
4104 /*
4105  * Modify the RCVCTRL register in chip-specific way. This
4106  * is a function because bit positions and (future) register
4107  * location is chip-specifc, but the needed operations are
4108  * generic. <op> is a bit-mask because we often want to
4109  * do multiple modifications.
4110  */
4111 static void rcvctrl_7322_mod(struct qib_pportdata *ppd, unsigned int op,
4112                              int ctxt)
4113 {
4114         struct qib_devdata *dd = ppd->dd;
4115         struct qib_ctxtdata *rcd;
4116         u64 mask, val;
4117         unsigned long flags;
4118
4119         spin_lock_irqsave(&dd->cspec->rcvmod_lock, flags);
4120
4121         if (op & QIB_RCVCTRL_TIDFLOW_ENB)
4122                 dd->rcvctrl |= SYM_MASK(RcvCtrl, TidFlowEnable);
4123         if (op & QIB_RCVCTRL_TIDFLOW_DIS)
4124                 dd->rcvctrl &= ~SYM_MASK(RcvCtrl, TidFlowEnable);
4125         if (op & QIB_RCVCTRL_TAILUPD_ENB)
4126                 dd->rcvctrl |= SYM_MASK(RcvCtrl, TailUpd);
4127         if (op & QIB_RCVCTRL_TAILUPD_DIS)
4128                 dd->rcvctrl &= ~SYM_MASK(RcvCtrl, TailUpd);
4129         if (op & QIB_RCVCTRL_PKEY_ENB)
4130                 ppd->p_rcvctrl &= ~SYM_MASK(RcvCtrl_0, RcvPartitionKeyDisable);
4131         if (op & QIB_RCVCTRL_PKEY_DIS)
4132                 ppd->p_rcvctrl |= SYM_MASK(RcvCtrl_0, RcvPartitionKeyDisable);
4133         if (ctxt < 0) {
4134                 mask = (1ULL << dd->ctxtcnt) - 1;
4135                 rcd = NULL;
4136         } else {
4137                 mask = (1ULL << ctxt);
4138                 rcd = dd->rcd[ctxt];
4139         }
4140         if ((op & QIB_RCVCTRL_CTXT_ENB) && rcd) {
4141                 ppd->p_rcvctrl |=
4142                         (mask << SYM_LSB(RcvCtrl_0, ContextEnableKernel));
4143                 if (!(dd->flags & QIB_NODMA_RTAIL)) {
4144                         op |= QIB_RCVCTRL_TAILUPD_ENB; /* need reg write */
4145                         dd->rcvctrl |= SYM_MASK(RcvCtrl, TailUpd);
4146                 }
4147                 /* Write these registers before the context is enabled. */
4148                 qib_write_kreg_ctxt(dd, krc_rcvhdrtailaddr, ctxt,
4149                                     rcd->rcvhdrqtailaddr_phys);
4150                 qib_write_kreg_ctxt(dd, krc_rcvhdraddr, ctxt,
4151                                     rcd->rcvhdrq_phys);
4152                 rcd->seq_cnt = 1;
4153         }
4154         if (op & QIB_RCVCTRL_CTXT_DIS)
4155                 ppd->p_rcvctrl &=
4156                         ~(mask << SYM_LSB(RcvCtrl_0, ContextEnableKernel));
4157         if (op & QIB_RCVCTRL_BP_ENB)
4158                 dd->rcvctrl |= mask << SYM_LSB(RcvCtrl, dontDropRHQFull);
4159         if (op & QIB_RCVCTRL_BP_DIS)
4160                 dd->rcvctrl &= ~(mask << SYM_LSB(RcvCtrl, dontDropRHQFull));
4161         if (op & QIB_RCVCTRL_INTRAVAIL_ENB)
4162                 dd->rcvctrl |= (mask << SYM_LSB(RcvCtrl, IntrAvail));
4163         if (op & QIB_RCVCTRL_INTRAVAIL_DIS)
4164                 dd->rcvctrl &= ~(mask << SYM_LSB(RcvCtrl, IntrAvail));
4165         /*
4166          * Decide which registers to write depending on the ops enabled.
4167          * Special case is "flush" (no bits set at all)
4168          * which needs to write both.
4169          */
4170         if (op == 0 || (op & RCVCTRL_COMMON_MODS))
4171                 qib_write_kreg(dd, kr_rcvctrl, dd->rcvctrl);
4172         if (op == 0 || (op & RCVCTRL_PORT_MODS))
4173                 qib_write_kreg_port(ppd, krp_rcvctrl, ppd->p_rcvctrl);
4174         if ((op & QIB_RCVCTRL_CTXT_ENB) && dd->rcd[ctxt]) {
4175                 /*
4176                  * Init the context registers also; if we were
4177                  * disabled, tail and head should both be zero
4178                  * already from the enable, but since we don't
4179                  * know, we have to do it explictly.
4180                  */
4181                 val = qib_read_ureg32(dd, ur_rcvegrindextail, ctxt);
4182                 qib_write_ureg(dd, ur_rcvegrindexhead, val, ctxt);
4183
4184                 /* be sure enabling write seen; hd/tl should be 0 */
4185                 (void) qib_read_kreg32(dd, kr_scratch);
4186                 val = qib_read_ureg32(dd, ur_rcvhdrtail, ctxt);
4187                 dd->rcd[ctxt]->head = val;
4188                 /* If kctxt, interrupt on next receive. */
4189                 if (ctxt < dd->first_user_ctxt)
4190                         val |= dd->rhdrhead_intr_off;
4191                 qib_write_ureg(dd, ur_rcvhdrhead, val, ctxt);
4192         } else if ((op & QIB_RCVCTRL_INTRAVAIL_ENB) &&
4193                 dd->rcd[ctxt] && dd->rhdrhead_intr_off) {
4194                 /* arm rcv interrupt */
4195                 val = dd->rcd[ctxt]->head | dd->rhdrhead_intr_off;
4196                 qib_write_ureg(dd, ur_rcvhdrhead, val, ctxt);
4197         }
4198         if (op & QIB_RCVCTRL_CTXT_DIS) {
4199                 unsigned f;
4200
4201                 /* Now that the context is disabled, clear these registers. */
4202                 if (ctxt >= 0) {
4203                         qib_write_kreg_ctxt(dd, krc_rcvhdrtailaddr, ctxt, 0);
4204                         qib_write_kreg_ctxt(dd, krc_rcvhdraddr, ctxt, 0);
4205                         for (f = 0; f < NUM_TIDFLOWS_CTXT; f++)
4206                                 qib_write_ureg(dd, ur_rcvflowtable + f,
4207                                                TIDFLOW_ERRBITS, ctxt);
4208                 } else {
4209                         unsigned i;
4210
4211                         for (i = 0; i < dd->cfgctxts; i++) {
4212                                 qib_write_kreg_ctxt(dd, krc_rcvhdrtailaddr,
4213                                                     i, 0);
4214                                 qib_write_kreg_ctxt(dd, krc_rcvhdraddr, i, 0);
4215                                 for (f = 0; f < NUM_TIDFLOWS_CTXT; f++)
4216                                         qib_write_ureg(dd, ur_rcvflowtable + f,
4217                                                        TIDFLOW_ERRBITS, i);
4218                         }
4219                 }
4220         }
4221         spin_unlock_irqrestore(&dd->cspec->rcvmod_lock, flags);
4222 }
4223
4224 /*
4225  * Modify the SENDCTRL register in chip-specific way. This
4226  * is a function where there are multiple such registers with
4227  * slightly different layouts.
4228  * The chip doesn't allow back-to-back sendctrl writes, so write
4229  * the scratch register after writing sendctrl.
4230  *
4231  * Which register is written depends on the operation.
4232  * Most operate on the common register, while
4233  * SEND_ENB and SEND_DIS operate on the per-port ones.
4234  * SEND_ENB is included in common because it can change SPCL_TRIG
4235  */
4236 #define SENDCTRL_COMMON_MODS (\
4237         QIB_SENDCTRL_CLEAR | \
4238         QIB_SENDCTRL_AVAIL_DIS | \
4239         QIB_SENDCTRL_AVAIL_ENB | \
4240         QIB_SENDCTRL_AVAIL_BLIP | \
4241         QIB_SENDCTRL_DISARM | \
4242         QIB_SENDCTRL_DISARM_ALL | \
4243         QIB_SENDCTRL_SEND_ENB)
4244
4245 #define SENDCTRL_PORT_MODS (\
4246         QIB_SENDCTRL_CLEAR | \
4247         QIB_SENDCTRL_SEND_ENB | \
4248         QIB_SENDCTRL_SEND_DIS | \
4249         QIB_SENDCTRL_FLUSH)
4250
4251 static void sendctrl_7322_mod(struct qib_pportdata *ppd, u32 op)
4252 {
4253         struct qib_devdata *dd = ppd->dd;
4254         u64 tmp_dd_sendctrl;
4255         unsigned long flags;
4256
4257         spin_lock_irqsave(&dd->sendctrl_lock, flags);
4258
4259         /* First the dd ones that are "sticky", saved in shadow */
4260         if (op & QIB_SENDCTRL_CLEAR)
4261                 dd->sendctrl = 0;
4262         if (op & QIB_SENDCTRL_AVAIL_DIS)
4263                 dd->sendctrl &= ~SYM_MASK(SendCtrl, SendBufAvailUpd);
4264         else if (op & QIB_SENDCTRL_AVAIL_ENB) {
4265                 dd->sendctrl |= SYM_MASK(SendCtrl, SendBufAvailUpd);
4266                 if (dd->flags & QIB_USE_SPCL_TRIG)
4267                         dd->sendctrl |= SYM_MASK(SendCtrl, SpecialTriggerEn);
4268         }
4269
4270         /* Then the ppd ones that are "sticky", saved in shadow */
4271         if (op & QIB_SENDCTRL_SEND_DIS)
4272                 ppd->p_sendctrl &= ~SYM_MASK(SendCtrl_0, SendEnable);
4273         else if (op & QIB_SENDCTRL_SEND_ENB)
4274                 ppd->p_sendctrl |= SYM_MASK(SendCtrl_0, SendEnable);
4275
4276         if (op & QIB_SENDCTRL_DISARM_ALL) {
4277                 u32 i, last;
4278
4279                 tmp_dd_sendctrl = dd->sendctrl;
4280                 last = dd->piobcnt2k + dd->piobcnt4k + NUM_VL15_BUFS;
4281                 /*
4282                  * Disarm any buffers that are not yet launched,
4283                  * disabling updates until done.
4284                  */
4285                 tmp_dd_sendctrl &= ~SYM_MASK(SendCtrl, SendBufAvailUpd);
4286                 for (i = 0; i < last; i++) {
4287                         qib_write_kreg(dd, kr_sendctrl,
4288                                        tmp_dd_sendctrl |
4289                                        SYM_MASK(SendCtrl, Disarm) | i);
4290                         qib_write_kreg(dd, kr_scratch, 0);
4291                 }
4292         }
4293
4294         if (op & QIB_SENDCTRL_FLUSH) {
4295                 u64 tmp_ppd_sendctrl = ppd->p_sendctrl;
4296
4297                 /*
4298                  * Now drain all the fifos.  The Abort bit should never be
4299                  * needed, so for now, at least, we don't use it.
4300                  */
4301                 tmp_ppd_sendctrl |=
4302                         SYM_MASK(SendCtrl_0, TxeDrainRmFifo) |
4303                         SYM_MASK(SendCtrl_0, TxeDrainLaFifo) |
4304                         SYM_MASK(SendCtrl_0, TxeBypassIbc);
4305                 qib_write_kreg_port(ppd, krp_sendctrl, tmp_ppd_sendctrl);
4306                 qib_write_kreg(dd, kr_scratch, 0);
4307         }
4308
4309         tmp_dd_sendctrl = dd->sendctrl;
4310
4311         if (op & QIB_SENDCTRL_DISARM)
4312                 tmp_dd_sendctrl |= SYM_MASK(SendCtrl, Disarm) |
4313                         ((op & QIB_7322_SendCtrl_DisarmSendBuf_RMASK) <<
4314                          SYM_LSB(SendCtrl, DisarmSendBuf));
4315         if ((op & QIB_SENDCTRL_AVAIL_BLIP) &&
4316             (dd->sendctrl & SYM_MASK(SendCtrl, SendBufAvailUpd)))
4317                 tmp_dd_sendctrl &= ~SYM_MASK(SendCtrl, SendBufAvailUpd);
4318
4319         if (op == 0 || (op & SENDCTRL_COMMON_MODS)) {
4320                 qib_write_kreg(dd, kr_sendctrl, tmp_dd_sendctrl);
4321                 qib_write_kreg(dd, kr_scratch, 0);
4322         }
4323
4324         if (op == 0 || (op & SENDCTRL_PORT_MODS)) {
4325                 qib_write_kreg_port(ppd, krp_sendctrl, ppd->p_sendctrl);
4326                 qib_write_kreg(dd, kr_scratch, 0);
4327         }
4328
4329         if (op & QIB_SENDCTRL_AVAIL_BLIP) {
4330                 qib_write_kreg(dd, kr_sendctrl, dd->sendctrl);
4331                 qib_write_kreg(dd, kr_scratch, 0);
4332         }
4333
4334         spin_unlock_irqrestore(&dd->sendctrl_lock, flags);
4335
4336         if (op & QIB_SENDCTRL_FLUSH) {
4337                 u32 v;
4338                 /*
4339                  * ensure writes have hit chip, then do a few
4340                  * more reads, to allow DMA of pioavail registers
4341                  * to occur, so in-memory copy is in sync with
4342                  * the chip.  Not always safe to sleep.
4343                  */
4344                 v = qib_read_kreg32(dd, kr_scratch);
4345                 qib_write_kreg(dd, kr_scratch, v);
4346                 v = qib_read_kreg32(dd, kr_scratch);
4347                 qib_write_kreg(dd, kr_scratch, v);
4348                 qib_read_kreg32(dd, kr_scratch);
4349         }
4350 }
4351
4352 #define _PORT_VIRT_FLAG 0x8000U /* "virtual", need adjustments */
4353 #define _PORT_64BIT_FLAG 0x10000U /* not "virtual", but 64bit */
4354 #define _PORT_CNTR_IDXMASK 0x7fffU /* mask off flags above */
4355
4356 /**
4357  * qib_portcntr_7322 - read a per-port chip counter
4358  * @ppd: the qlogic_ib pport
4359  * @creg: the counter to read (not a chip offset)
4360  */
4361 static u64 qib_portcntr_7322(struct qib_pportdata *ppd, u32 reg)
4362 {
4363         struct qib_devdata *dd = ppd->dd;
4364         u64 ret = 0ULL;
4365         u16 creg;
4366         /* 0xffff for unimplemented or synthesized counters */
4367         static const u32 xlator[] = {
4368                 [QIBPORTCNTR_PKTSEND] = crp_pktsend | _PORT_64BIT_FLAG,
4369                 [QIBPORTCNTR_WORDSEND] = crp_wordsend | _PORT_64BIT_FLAG,
4370                 [QIBPORTCNTR_PSXMITDATA] = crp_psxmitdatacount,
4371                 [QIBPORTCNTR_PSXMITPKTS] = crp_psxmitpktscount,
4372                 [QIBPORTCNTR_PSXMITWAIT] = crp_psxmitwaitcount,
4373                 [QIBPORTCNTR_SENDSTALL] = crp_sendstall,
4374                 [QIBPORTCNTR_PKTRCV] = crp_pktrcv | _PORT_64BIT_FLAG,
4375                 [QIBPORTCNTR_PSRCVDATA] = crp_psrcvdatacount,
4376                 [QIBPORTCNTR_PSRCVPKTS] = crp_psrcvpktscount,
4377                 [QIBPORTCNTR_RCVEBP] = crp_rcvebp,
4378                 [QIBPORTCNTR_RCVOVFL] = crp_rcvovfl,
4379                 [QIBPORTCNTR_WORDRCV] = crp_wordrcv | _PORT_64BIT_FLAG,
4380                 [QIBPORTCNTR_RXDROPPKT] = 0xffff, /* not needed  for 7322 */
4381                 [QIBPORTCNTR_RXLOCALPHYERR] = crp_rxotherlocalphyerr,
4382                 [QIBPORTCNTR_RXVLERR] = crp_rxvlerr,
4383                 [QIBPORTCNTR_ERRICRC] = crp_erricrc,
4384                 [QIBPORTCNTR_ERRVCRC] = crp_errvcrc,
4385                 [QIBPORTCNTR_ERRLPCRC] = crp_errlpcrc,
4386                 [QIBPORTCNTR_BADFORMAT] = crp_badformat,
4387                 [QIBPORTCNTR_ERR_RLEN] = crp_err_rlen,
4388                 [QIBPORTCNTR_IBSYMBOLERR] = crp_ibsymbolerr,
4389                 [QIBPORTCNTR_INVALIDRLEN] = crp_invalidrlen,
4390                 [QIBPORTCNTR_UNSUPVL] = crp_txunsupvl,
4391                 [QIBPORTCNTR_EXCESSBUFOVFL] = crp_excessbufferovfl,
4392                 [QIBPORTCNTR_ERRLINK] = crp_errlink,
4393                 [QIBPORTCNTR_IBLINKDOWN] = crp_iblinkdown,
4394                 [QIBPORTCNTR_IBLINKERRRECOV] = crp_iblinkerrrecov,
4395                 [QIBPORTCNTR_LLI] = crp_locallinkintegrityerr,
4396                 [QIBPORTCNTR_VL15PKTDROP] = crp_vl15droppedpkt,
4397                 [QIBPORTCNTR_ERRPKEY] = crp_errpkey,
4398                 /*
4399                  * the next 3 aren't really counters, but were implemented
4400                  * as counters in older chips, so still get accessed as
4401                  * though they were counters from this code.
4402                  */
4403                 [QIBPORTCNTR_PSINTERVAL] = krp_psinterval,
4404                 [QIBPORTCNTR_PSSTART] = krp_psstart,
4405                 [QIBPORTCNTR_PSSTAT] = krp_psstat,
4406                 /* pseudo-counter, summed for all ports */
4407                 [QIBPORTCNTR_KHDROVFL] = 0xffff,
4408         };
4409
4410         if (reg >= ARRAY_SIZE(xlator)) {
4411                 qib_devinfo(ppd->dd->pcidev,
4412                          "Unimplemented portcounter %u\n", reg);
4413                 goto done;
4414         }
4415         creg = xlator[reg] & _PORT_CNTR_IDXMASK;
4416
4417         /* handle non-counters and special cases first */
4418         if (reg == QIBPORTCNTR_KHDROVFL) {
4419                 int i;
4420
4421                 /* sum over all kernel contexts (skip if mini_init) */
4422                 for (i = 0; dd->rcd && i < dd->first_user_ctxt; i++) {
4423                         struct qib_ctxtdata *rcd = dd->rcd[i];
4424
4425                         if (!rcd || rcd->ppd != ppd)
4426                                 continue;
4427                         ret += read_7322_creg32(dd, cr_base_egrovfl + i);
4428                 }
4429                 goto done;
4430         } else if (reg == QIBPORTCNTR_RXDROPPKT) {
4431                 /*
4432                  * Used as part of the synthesis of port_rcv_errors
4433                  * in the verbs code for IBTA counters.  Not needed for 7322,
4434                  * because all the errors are already counted by other cntrs.
4435                  */
4436                 goto done;
4437         } else if (reg == QIBPORTCNTR_PSINTERVAL ||
4438                    reg == QIBPORTCNTR_PSSTART || reg == QIBPORTCNTR_PSSTAT) {
4439                 /* were counters in older chips, now per-port kernel regs */
4440                 ret = qib_read_kreg_port(ppd, creg);
4441                 goto done;
4442         }
4443
4444         /*
4445          * Only fast increment counters are 64 bits; use 32 bit reads to
4446          * avoid two independent reads when on Opteron.
4447          */
4448         if (xlator[reg] & _PORT_64BIT_FLAG)
4449                 ret = read_7322_creg_port(ppd, creg);
4450         else
4451                 ret = read_7322_creg32_port(ppd, creg);
4452         if (creg == crp_ibsymbolerr) {
4453                 if (ppd->cpspec->ibdeltainprog)
4454                         ret -= ret - ppd->cpspec->ibsymsnap;
4455                 ret -= ppd->cpspec->ibsymdelta;
4456         } else if (creg == crp_iblinkerrrecov) {
4457                 if (ppd->cpspec->ibdeltainprog)
4458                         ret -= ret - ppd->cpspec->iblnkerrsnap;
4459                 ret -= ppd->cpspec->iblnkerrdelta;
4460         } else if (creg == crp_errlink)
4461                 ret -= ppd->cpspec->ibmalfdelta;
4462         else if (creg == crp_iblinkdown)
4463                 ret += ppd->cpspec->iblnkdowndelta;
4464 done:
4465         return ret;
4466 }
4467
4468 /*
4469  * Device counter names (not port-specific), one line per stat,
4470  * single string.  Used by utilities like ipathstats to print the stats
4471  * in a way which works for different versions of drivers, without changing
4472  * the utility.  Names need to be 12 chars or less (w/o newline), for proper
4473  * display by utility.
4474  * Non-error counters are first.
4475  * Start of "error" conters is indicated by a leading "E " on the first
4476  * "error" counter, and doesn't count in label length.
4477  * The EgrOvfl list needs to be last so we truncate them at the configured
4478  * context count for the device.
4479  * cntr7322indices contains the corresponding register indices.
4480  */
4481 static const char cntr7322names[] =
4482         "Interrupts\n"
4483         "HostBusStall\n"
4484         "E RxTIDFull\n"
4485         "RxTIDInvalid\n"
4486         "RxTIDFloDrop\n" /* 7322 only */
4487         "Ctxt0EgrOvfl\n"
4488         "Ctxt1EgrOvfl\n"
4489         "Ctxt2EgrOvfl\n"
4490         "Ctxt3EgrOvfl\n"
4491         "Ctxt4EgrOvfl\n"
4492         "Ctxt5EgrOvfl\n"
4493         "Ctxt6EgrOvfl\n"
4494         "Ctxt7EgrOvfl\n"
4495         "Ctxt8EgrOvfl\n"
4496         "Ctxt9EgrOvfl\n"
4497         "Ctx10EgrOvfl\n"
4498         "Ctx11EgrOvfl\n"
4499         "Ctx12EgrOvfl\n"
4500         "Ctx13EgrOvfl\n"
4501         "Ctx14EgrOvfl\n"
4502         "Ctx15EgrOvfl\n"
4503         "Ctx16EgrOvfl\n"
4504         "Ctx17EgrOvfl\n"
4505         ;
4506
4507 static const u32 cntr7322indices[] = {
4508         cr_lbint | _PORT_64BIT_FLAG,
4509         cr_lbstall | _PORT_64BIT_FLAG,
4510         cr_tidfull,
4511         cr_tidinvalid,
4512         cr_rxtidflowdrop,
4513         cr_base_egrovfl + 0,
4514         cr_base_egrovfl + 1,
4515         cr_base_egrovfl + 2,
4516         cr_base_egrovfl + 3,
4517         cr_base_egrovfl + 4,
4518         cr_base_egrovfl + 5,
4519         cr_base_egrovfl + 6,
4520         cr_base_egrovfl + 7,
4521         cr_base_egrovfl + 8,
4522         cr_base_egrovfl + 9,
4523         cr_base_egrovfl + 10,
4524         cr_base_egrovfl + 11,
4525         cr_base_egrovfl + 12,
4526         cr_base_egrovfl + 13,
4527         cr_base_egrovfl + 14,
4528         cr_base_egrovfl + 15,
4529         cr_base_egrovfl + 16,
4530         cr_base_egrovfl + 17,
4531 };
4532
4533 /*
4534  * same as cntr7322names and cntr7322indices, but for port-specific counters.
4535  * portcntr7322indices is somewhat complicated by some registers needing
4536  * adjustments of various kinds, and those are ORed with _PORT_VIRT_FLAG
4537  */
4538 static const char portcntr7322names[] =
4539         "TxPkt\n"
4540         "TxFlowPkt\n"
4541         "TxWords\n"
4542         "RxPkt\n"
4543         "RxFlowPkt\n"
4544         "RxWords\n"
4545         "TxFlowStall\n"
4546         "TxDmaDesc\n"  /* 7220 and 7322-only */
4547         "E RxDlidFltr\n"  /* 7220 and 7322-only */
4548         "IBStatusChng\n"
4549         "IBLinkDown\n"
4550         "IBLnkRecov\n"
4551         "IBRxLinkErr\n"
4552         "IBSymbolErr\n"
4553         "RxLLIErr\n"
4554         "RxBadFormat\n"
4555         "RxBadLen\n"
4556         "RxBufOvrfl\n"
4557         "RxEBP\n"
4558         "RxFlowCtlErr\n"
4559         "RxICRCerr\n"
4560         "RxLPCRCerr\n"
4561         "RxVCRCerr\n"
4562         "RxInvalLen\n"
4563         "RxInvalPKey\n"
4564         "RxPktDropped\n"
4565         "TxBadLength\n"
4566         "TxDropped\n"
4567         "TxInvalLen\n"
4568         "TxUnderrun\n"
4569         "TxUnsupVL\n"
4570         "RxLclPhyErr\n" /* 7220 and 7322-only from here down */
4571         "RxVL15Drop\n"
4572         "RxVlErr\n"
4573         "XcessBufOvfl\n"
4574         "RxQPBadCtxt\n" /* 7322-only from here down */
4575         "TXBadHeader\n"
4576         ;
4577
4578 static const u32 portcntr7322indices[] = {
4579         QIBPORTCNTR_PKTSEND | _PORT_VIRT_FLAG,
4580         crp_pktsendflow,
4581         QIBPORTCNTR_WORDSEND | _PORT_VIRT_FLAG,
4582         QIBPORTCNTR_PKTRCV | _PORT_VIRT_FLAG,
4583         crp_pktrcvflowctrl,
4584         QIBPORTCNTR_WORDRCV | _PORT_VIRT_FLAG,
4585         QIBPORTCNTR_SENDSTALL | _PORT_VIRT_FLAG,
4586         crp_txsdmadesc | _PORT_64BIT_FLAG,
4587         crp_rxdlidfltr,
4588         crp_ibstatuschange,
4589         QIBPORTCNTR_IBLINKDOWN | _PORT_VIRT_FLAG,
4590         QIBPORTCNTR_IBLINKERRRECOV | _PORT_VIRT_FLAG,
4591         QIBPORTCNTR_ERRLINK | _PORT_VIRT_FLAG,
4592         QIBPORTCNTR_IBSYMBOLERR | _PORT_VIRT_FLAG,
4593         QIBPORTCNTR_LLI | _PORT_VIRT_FLAG,
4594         QIBPORTCNTR_BADFORMAT | _PORT_VIRT_FLAG,
4595         QIBPORTCNTR_ERR_RLEN | _PORT_VIRT_FLAG,
4596         QIBPORTCNTR_RCVOVFL | _PORT_VIRT_FLAG,
4597         QIBPORTCNTR_RCVEBP | _PORT_VIRT_FLAG,
4598         crp_rcvflowctrlviol,
4599         QIBPORTCNTR_ERRICRC | _PORT_VIRT_FLAG,
4600         QIBPORTCNTR_ERRLPCRC | _PORT_VIRT_FLAG,
4601         QIBPORTCNTR_ERRVCRC | _PORT_VIRT_FLAG,
4602         QIBPORTCNTR_INVALIDRLEN | _PORT_VIRT_FLAG,
4603         QIBPORTCNTR_ERRPKEY | _PORT_VIRT_FLAG,
4604         QIBPORTCNTR_RXDROPPKT | _PORT_VIRT_FLAG,
4605         crp_txminmaxlenerr,
4606         crp_txdroppedpkt,
4607         crp_txlenerr,
4608         crp_txunderrun,
4609         crp_txunsupvl,
4610         QIBPORTCNTR_RXLOCALPHYERR | _PORT_VIRT_FLAG,
4611         QIBPORTCNTR_VL15PKTDROP | _PORT_VIRT_FLAG,
4612         QIBPORTCNTR_RXVLERR | _PORT_VIRT_FLAG,
4613         QIBPORTCNTR_EXCESSBUFOVFL | _PORT_VIRT_FLAG,
4614         crp_rxqpinvalidctxt,
4615         crp_txhdrerr,
4616 };
4617
4618 /* do all the setup to make the counter reads efficient later */
4619 static void init_7322_cntrnames(struct qib_devdata *dd)
4620 {
4621         int i, j = 0;
4622         char *s;
4623
4624         for (i = 0, s = (char *)cntr7322names; s && j <= dd->cfgctxts;
4625              i++) {
4626                 /* we always have at least one counter before the egrovfl */
4627                 if (!j && !strncmp("Ctxt0EgrOvfl", s + 1, 12))
4628                         j = 1;
4629                 s = strchr(s + 1, '\n');
4630                 if (s && j)
4631                         j++;
4632         }
4633         dd->cspec->ncntrs = i;
4634         if (!s)
4635                 /* full list; size is without terminating null */
4636                 dd->cspec->cntrnamelen = sizeof(cntr7322names) - 1;
4637         else
4638                 dd->cspec->cntrnamelen = 1 + s - cntr7322names;
4639         dd->cspec->cntrs = kmalloc(dd->cspec->ncntrs
4640                 * sizeof(u64), GFP_KERNEL);
4641         if (!dd->cspec->cntrs)
4642                 qib_dev_err(dd, "Failed allocation for counters\n");
4643
4644         for (i = 0, s = (char *)portcntr7322names; s; i++)
4645                 s = strchr(s + 1, '\n');
4646         dd->cspec->nportcntrs = i - 1;
4647         dd->cspec->portcntrnamelen = sizeof(portcntr7322names) - 1;
4648         for (i = 0; i < dd->num_pports; ++i) {
4649                 dd->pport[i].cpspec->portcntrs = kmalloc(dd->cspec->nportcntrs
4650                         * sizeof(u64), GFP_KERNEL);
4651                 if (!dd->pport[i].cpspec->portcntrs)
4652                         qib_dev_err(dd, "Failed allocation for"
4653                                     " portcounters\n");
4654         }
4655 }
4656
4657 static u32 qib_read_7322cntrs(struct qib_devdata *dd, loff_t pos, char **namep,
4658                               u64 **cntrp)
4659 {
4660         u32 ret;
4661
4662         if (namep) {
4663                 ret = dd->cspec->cntrnamelen;
4664                 if (pos >= ret)
4665                         ret = 0; /* final read after getting everything */
4666                 else
4667                         *namep = (char *) cntr7322names;
4668         } else {
4669                 u64 *cntr = dd->cspec->cntrs;
4670                 int i;
4671
4672                 ret = dd->cspec->ncntrs * sizeof(u64);
4673                 if (!cntr || pos >= ret) {
4674                         /* everything read, or couldn't get memory */
4675                         ret = 0;
4676                         goto done;
4677                 }
4678                 *cntrp = cntr;
4679                 for (i = 0; i < dd->cspec->ncntrs; i++)
4680                         if (cntr7322indices[i] & _PORT_64BIT_FLAG)
4681                                 *cntr++ = read_7322_creg(dd,
4682                                                          cntr7322indices[i] &
4683                                                          _PORT_CNTR_IDXMASK);
4684                         else
4685                                 *cntr++ = read_7322_creg32(dd,
4686                                                            cntr7322indices[i]);
4687         }
4688 done:
4689         return ret;
4690 }
4691
4692 static u32 qib_read_7322portcntrs(struct qib_devdata *dd, loff_t pos, u32 port,
4693                                   char **namep, u64 **cntrp)
4694 {
4695         u32 ret;
4696
4697         if (namep) {
4698                 ret = dd->cspec->portcntrnamelen;
4699                 if (pos >= ret)
4700                         ret = 0; /* final read after getting everything */
4701                 else
4702                         *namep = (char *)portcntr7322names;
4703         } else {
4704                 struct qib_pportdata *ppd = &dd->pport[port];
4705                 u64 *cntr = ppd->cpspec->portcntrs;
4706                 int i;
4707
4708                 ret = dd->cspec->nportcntrs * sizeof(u64);
4709                 if (!cntr || pos >= ret) {
4710                         /* everything read, or couldn't get memory */
4711                         ret = 0;
4712                         goto done;
4713                 }
4714                 *cntrp = cntr;
4715                 for (i = 0; i < dd->cspec->nportcntrs; i++) {
4716                         if (portcntr7322indices[i] & _PORT_VIRT_FLAG)
4717                                 *cntr++ = qib_portcntr_7322(ppd,
4718                                         portcntr7322indices[i] &
4719                                         _PORT_CNTR_IDXMASK);
4720                         else if (portcntr7322indices[i] & _PORT_64BIT_FLAG)
4721                                 *cntr++ = read_7322_creg_port(ppd,
4722                                            portcntr7322indices[i] &
4723                                             _PORT_CNTR_IDXMASK);
4724                         else
4725                                 *cntr++ = read_7322_creg32_port(ppd,
4726                                            portcntr7322indices[i]);
4727                 }
4728         }
4729 done:
4730         return ret;
4731 }
4732
4733 /**
4734  * qib_get_7322_faststats - get word counters from chip before they overflow
4735  * @opaque - contains a pointer to the qlogic_ib device qib_devdata
4736  *
4737  * VESTIGIAL IBA7322 has no "small fast counters", so the only
4738  * real purpose of this function is to maintain the notion of
4739  * "active time", which in turn is only logged into the eeprom,
4740  * which we don;t have, yet, for 7322-based boards.
4741  *
4742  * called from add_timer
4743  */
4744 static void qib_get_7322_faststats(unsigned long opaque)
4745 {
4746         struct qib_devdata *dd = (struct qib_devdata *) opaque;
4747         struct qib_pportdata *ppd;
4748         unsigned long flags;
4749         u64 traffic_wds;
4750         int pidx;
4751
4752         for (pidx = 0; pidx < dd->num_pports; ++pidx) {
4753                 ppd = dd->pport + pidx;
4754
4755                 /*
4756                  * If port isn't enabled or not operational ports, or
4757                  * diags is running (can cause memory diags to fail)
4758                  * skip this port this time.
4759                  */
4760                 if (!ppd->link_speed_supported || !(dd->flags & QIB_INITTED)
4761                     || dd->diag_client)
4762                         continue;
4763
4764                 /*
4765                  * Maintain an activity timer, based on traffic
4766                  * exceeding a threshold, so we need to check the word-counts
4767                  * even if they are 64-bit.
4768                  */
4769                 traffic_wds = qib_portcntr_7322(ppd, QIBPORTCNTR_WORDRCV) +
4770                         qib_portcntr_7322(ppd, QIBPORTCNTR_WORDSEND);
4771                 spin_lock_irqsave(&ppd->dd->eep_st_lock, flags);
4772                 traffic_wds -= ppd->dd->traffic_wds;
4773                 ppd->dd->traffic_wds += traffic_wds;
4774                 if (traffic_wds >= QIB_TRAFFIC_ACTIVE_THRESHOLD)
4775                         atomic_add(ACTIVITY_TIMER, &ppd->dd->active_time);
4776                 spin_unlock_irqrestore(&ppd->dd->eep_st_lock, flags);
4777                 if (ppd->cpspec->qdr_dfe_on && (ppd->link_speed_active &
4778                                                 QIB_IB_QDR) &&
4779                     (ppd->lflags & (QIBL_LINKINIT | QIBL_LINKARMED |
4780                                     QIBL_LINKACTIVE)) &&
4781                     ppd->cpspec->qdr_dfe_time &&
4782                     time_after64(get_jiffies_64(), ppd->cpspec->qdr_dfe_time)) {
4783                         ppd->cpspec->qdr_dfe_on = 0;
4784
4785                         qib_write_kreg_port(ppd, krp_static_adapt_dis(2),
4786                                             ppd->dd->cspec->r1 ?
4787                                             QDR_STATIC_ADAPT_INIT_R1 :
4788                                             QDR_STATIC_ADAPT_INIT);
4789                         force_h1(ppd);
4790                 }
4791         }
4792         mod_timer(&dd->stats_timer, jiffies + HZ * ACTIVITY_TIMER);
4793 }
4794
4795 /*
4796  * If we were using MSIx, try to fallback to INTx.
4797  */
4798 static int qib_7322_intr_fallback(struct qib_devdata *dd)
4799 {
4800         if (!dd->cspec->num_msix_entries)
4801                 return 0; /* already using INTx */
4802
4803         qib_devinfo(dd->pcidev, "MSIx interrupt not detected,"
4804                  " trying INTx interrupts\n");
4805         qib_7322_nomsix(dd);
4806         qib_enable_intx(dd->pcidev);
4807         qib_setup_7322_interrupt(dd, 0);
4808         return 1;
4809 }
4810
4811 /*
4812  * Reset the XGXS (between serdes and IBC).  Slightly less intrusive
4813  * than resetting the IBC or external link state, and useful in some
4814  * cases to cause some retraining.  To do this right, we reset IBC
4815  * as well, then return to previous state (which may be still in reset)
4816  * NOTE: some callers of this "know" this writes the current value
4817  * of cpspec->ibcctrl_a as part of it's operation, so if that changes,
4818  * check all callers.
4819  */
4820 static void qib_7322_mini_pcs_reset(struct qib_pportdata *ppd)
4821 {
4822         u64 val;
4823         struct qib_devdata *dd = ppd->dd;
4824         const u64 reset_bits = SYM_MASK(IBPCSConfig_0, xcv_rreset) |
4825                 SYM_MASK(IBPCSConfig_0, xcv_treset) |
4826                 SYM_MASK(IBPCSConfig_0, tx_rx_reset);
4827
4828         val = qib_read_kreg_port(ppd, krp_ib_pcsconfig);
4829         qib_write_kreg(dd, kr_hwerrmask,
4830                        dd->cspec->hwerrmask & ~HWE_MASK(statusValidNoEop));
4831         qib_write_kreg_port(ppd, krp_ibcctrl_a,
4832                             ppd->cpspec->ibcctrl_a &
4833                             ~SYM_MASK(IBCCtrlA_0, IBLinkEn));
4834
4835         qib_write_kreg_port(ppd, krp_ib_pcsconfig, val | reset_bits);
4836         qib_read_kreg32(dd, kr_scratch);
4837         qib_write_kreg_port(ppd, krp_ib_pcsconfig, val & ~reset_bits);
4838         qib_write_kreg_port(ppd, krp_ibcctrl_a, ppd->cpspec->ibcctrl_a);
4839         qib_write_kreg(dd, kr_scratch, 0ULL);
4840         qib_write_kreg(dd, kr_hwerrclear,
4841                        SYM_MASK(HwErrClear, statusValidNoEopClear));
4842         qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
4843 }
4844
4845 /*
4846  * This code for non-IBTA-compliant IB speed negotiation is only known to
4847  * work for the SDR to DDR transition, and only between an HCA and a switch
4848  * with recent firmware.  It is based on observed heuristics, rather than
4849  * actual knowledge of the non-compliant speed negotiation.
4850  * It has a number of hard-coded fields, since the hope is to rewrite this
4851  * when a spec is available on how the negoation is intended to work.
4852  */
4853 static void autoneg_7322_sendpkt(struct qib_pportdata *ppd, u32 *hdr,
4854                                  u32 dcnt, u32 *data)
4855 {
4856         int i;
4857         u64 pbc;
4858         u32 __iomem *piobuf;
4859         u32 pnum, control, len;
4860         struct qib_devdata *dd = ppd->dd;
4861
4862         i = 0;
4863         len = 7 + dcnt + 1; /* 7 dword header, dword data, icrc */
4864         control = qib_7322_setpbc_control(ppd, len, 0, 15);
4865         pbc = ((u64) control << 32) | len;
4866         while (!(piobuf = qib_7322_getsendbuf(ppd, pbc, &pnum))) {
4867                 if (i++ > 15)
4868                         return;
4869                 udelay(2);
4870         }
4871         /* disable header check on this packet, since it can't be valid */
4872         dd->f_txchk_change(dd, pnum, 1, TXCHK_CHG_TYPE_DIS1, NULL);
4873         writeq(pbc, piobuf);
4874         qib_flush_wc();
4875         qib_pio_copy(piobuf + 2, hdr, 7);
4876         qib_pio_copy(piobuf + 9, data, dcnt);
4877         if (dd->flags & QIB_USE_SPCL_TRIG) {
4878                 u32 spcl_off = (pnum >= dd->piobcnt2k) ? 2047 : 1023;
4879
4880                 qib_flush_wc();
4881                 __raw_writel(0xaebecede, piobuf + spcl_off);
4882         }
4883         qib_flush_wc();
4884         qib_sendbuf_done(dd, pnum);
4885         /* and re-enable hdr check */
4886         dd->f_txchk_change(dd, pnum, 1, TXCHK_CHG_TYPE_ENAB1, NULL);
4887 }
4888
4889 /*
4890  * _start packet gets sent twice at start, _done gets sent twice at end
4891  */
4892 static void qib_autoneg_7322_send(struct qib_pportdata *ppd, int which)
4893 {
4894         struct qib_devdata *dd = ppd->dd;
4895         static u32 swapped;
4896         u32 dw, i, hcnt, dcnt, *data;
4897         static u32 hdr[7] = { 0xf002ffff, 0x48ffff, 0x6400abba };
4898         static u32 madpayload_start[0x40] = {
4899                 0x1810103, 0x1, 0x0, 0x0, 0x2c90000, 0x2c9, 0x0, 0x0,
4900                 0xffffffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4901                 0x1, 0x1388, 0x15e, 0x1, /* rest 0's */
4902                 };
4903         static u32 madpayload_done[0x40] = {
4904                 0x1810103, 0x1, 0x0, 0x0, 0x2c90000, 0x2c9, 0x0, 0x0,
4905                 0xffffffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4906                 0x40000001, 0x1388, 0x15e, /* rest 0's */
4907                 };
4908
4909         dcnt = ARRAY_SIZE(madpayload_start);
4910         hcnt = ARRAY_SIZE(hdr);
4911         if (!swapped) {
4912                 /* for maintainability, do it at runtime */
4913                 for (i = 0; i < hcnt; i++) {
4914                         dw = (__force u32) cpu_to_be32(hdr[i]);
4915                         hdr[i] = dw;
4916                 }
4917                 for (i = 0; i < dcnt; i++) {
4918                         dw = (__force u32) cpu_to_be32(madpayload_start[i]);
4919                         madpayload_start[i] = dw;
4920                         dw = (__force u32) cpu_to_be32(madpayload_done[i]);
4921                         madpayload_done[i] = dw;
4922                 }
4923                 swapped = 1;
4924         }
4925
4926         data = which ? madpayload_done : madpayload_start;
4927
4928         autoneg_7322_sendpkt(ppd, hdr, dcnt, data);
4929         qib_read_kreg64(dd, kr_scratch);
4930         udelay(2);
4931         autoneg_7322_sendpkt(ppd, hdr, dcnt, data);
4932         qib_read_kreg64(dd, kr_scratch);
4933         udelay(2);
4934 }
4935
4936 /*
4937  * Do the absolute minimum to cause an IB speed change, and make it
4938  * ready, but don't actually trigger the change.   The caller will
4939  * do that when ready (if link is in Polling training state, it will
4940  * happen immediately, otherwise when link next goes down)
4941  *
4942  * This routine should only be used as part of the DDR autonegotation
4943  * code for devices that are not compliant with IB 1.2 (or code that
4944  * fixes things up for same).
4945  *
4946  * When link has gone down, and autoneg enabled, or autoneg has
4947  * failed and we give up until next time we set both speeds, and
4948  * then we want IBTA enabled as well as "use max enabled speed.
4949  */
4950 static void set_7322_ibspeed_fast(struct qib_pportdata *ppd, u32 speed)
4951 {
4952         u64 newctrlb;
4953         newctrlb = ppd->cpspec->ibcctrl_b & ~(IBA7322_IBC_SPEED_MASK |
4954                                     IBA7322_IBC_IBTA_1_2_MASK |
4955                                     IBA7322_IBC_MAX_SPEED_MASK);
4956
4957         if (speed & (speed - 1)) /* multiple speeds */
4958                 newctrlb |= (speed << IBA7322_IBC_SPEED_LSB) |
4959                                     IBA7322_IBC_IBTA_1_2_MASK |
4960                                     IBA7322_IBC_MAX_SPEED_MASK;
4961         else
4962                 newctrlb |= speed == QIB_IB_QDR ?
4963                         IBA7322_IBC_SPEED_QDR | IBA7322_IBC_IBTA_1_2_MASK :
4964                         ((speed == QIB_IB_DDR ?
4965                           IBA7322_IBC_SPEED_DDR : IBA7322_IBC_SPEED_SDR));
4966
4967         if (newctrlb == ppd->cpspec->ibcctrl_b)
4968                 return;
4969
4970         ppd->cpspec->ibcctrl_b = newctrlb;
4971         qib_write_kreg_port(ppd, krp_ibcctrl_b, ppd->cpspec->ibcctrl_b);
4972         qib_write_kreg(ppd->dd, kr_scratch, 0);
4973 }
4974
4975 /*
4976  * This routine is only used when we are not talking to another
4977  * IB 1.2-compliant device that we think can do DDR.
4978  * (This includes all existing switch chips as of Oct 2007.)
4979  * 1.2-compliant devices go directly to DDR prior to reaching INIT
4980  */
4981 static void try_7322_autoneg(struct qib_pportdata *ppd)
4982 {
4983         unsigned long flags;
4984
4985         spin_lock_irqsave(&ppd->lflags_lock, flags);
4986         ppd->lflags |= QIBL_IB_AUTONEG_INPROG;
4987         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
4988         qib_autoneg_7322_send(ppd, 0);
4989         set_7322_ibspeed_fast(ppd, QIB_IB_DDR);
4990         qib_7322_mini_pcs_reset(ppd);
4991         /* 2 msec is minimum length of a poll cycle */
4992         queue_delayed_work(ib_wq, &ppd->cpspec->autoneg_work,
4993                            msecs_to_jiffies(2));
4994 }
4995
4996 /*
4997  * Handle the empirically determined mechanism for auto-negotiation
4998  * of DDR speed with switches.
4999  */
5000 static void autoneg_7322_work(struct work_struct *work)
5001 {
5002         struct qib_pportdata *ppd;
5003         struct qib_devdata *dd;
5004         u64 startms;
5005         u32 i;
5006         unsigned long flags;
5007
5008         ppd = container_of(work, struct qib_chippport_specific,
5009                             autoneg_work.work)->ppd;
5010         dd = ppd->dd;
5011
5012         startms = jiffies_to_msecs(jiffies);
5013
5014         /*
5015          * Busy wait for this first part, it should be at most a
5016          * few hundred usec, since we scheduled ourselves for 2msec.
5017          */
5018         for (i = 0; i < 25; i++) {
5019                 if (SYM_FIELD(ppd->lastibcstat, IBCStatusA_0, LinkState)
5020                      == IB_7322_LT_STATE_POLLQUIET) {
5021                         qib_set_linkstate(ppd, QIB_IB_LINKDOWN_DISABLE);
5022                         break;
5023                 }
5024                 udelay(100);
5025         }
5026
5027         if (!(ppd->lflags & QIBL_IB_AUTONEG_INPROG))
5028                 goto done; /* we got there early or told to stop */
5029
5030         /* we expect this to timeout */
5031         if (wait_event_timeout(ppd->cpspec->autoneg_wait,
5032                                !(ppd->lflags & QIBL_IB_AUTONEG_INPROG),
5033                                msecs_to_jiffies(90)))
5034                 goto done;
5035         qib_7322_mini_pcs_reset(ppd);
5036
5037         /* we expect this to timeout */
5038         if (wait_event_timeout(ppd->cpspec->autoneg_wait,
5039                                !(ppd->lflags & QIBL_IB_AUTONEG_INPROG),
5040                                msecs_to_jiffies(1700)))
5041                 goto done;
5042         qib_7322_mini_pcs_reset(ppd);
5043
5044         set_7322_ibspeed_fast(ppd, QIB_IB_SDR);
5045
5046         /*
5047          * Wait up to 250 msec for link to train and get to INIT at DDR;
5048          * this should terminate early.
5049          */
5050         wait_event_timeout(ppd->cpspec->autoneg_wait,
5051                 !(ppd->lflags & QIBL_IB_AUTONEG_INPROG),
5052                 msecs_to_jiffies(250));
5053 done:
5054         if (ppd->lflags & QIBL_IB_AUTONEG_INPROG) {
5055                 spin_lock_irqsave(&ppd->lflags_lock, flags);
5056                 ppd->lflags &= ~QIBL_IB_AUTONEG_INPROG;
5057                 if (ppd->cpspec->autoneg_tries == AUTONEG_TRIES) {
5058                         ppd->lflags |= QIBL_IB_AUTONEG_FAILED;
5059                         ppd->cpspec->autoneg_tries = 0;
5060                 }
5061                 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
5062                 set_7322_ibspeed_fast(ppd, ppd->link_speed_enabled);
5063         }
5064 }
5065
5066 /*
5067  * This routine is used to request IPG set in the QLogic switch.
5068  * Only called if r1.
5069  */
5070 static void try_7322_ipg(struct qib_pportdata *ppd)
5071 {
5072         struct qib_ibport *ibp = &ppd->ibport_data;
5073         struct ib_mad_send_buf *send_buf;
5074         struct ib_mad_agent *agent;
5075         struct ib_smp *smp;
5076         unsigned delay;
5077         int ret;
5078
5079         agent = ibp->send_agent;
5080         if (!agent)
5081                 goto retry;
5082
5083         send_buf = ib_create_send_mad(agent, 0, 0, 0, IB_MGMT_MAD_HDR,
5084                                       IB_MGMT_MAD_DATA, GFP_ATOMIC);
5085         if (IS_ERR(send_buf))
5086                 goto retry;
5087
5088         if (!ibp->smi_ah) {
5089                 struct ib_ah_attr attr;
5090                 struct ib_ah *ah;
5091
5092                 memset(&attr, 0, sizeof attr);
5093                 attr.dlid = be16_to_cpu(IB_LID_PERMISSIVE);
5094                 attr.port_num = ppd->port;
5095                 ah = ib_create_ah(ibp->qp0->ibqp.pd, &attr);
5096                 if (IS_ERR(ah))
5097                         ret = -EINVAL;
5098                 else {
5099                         send_buf->ah = ah;
5100                         ibp->smi_ah = to_iah(ah);
5101                         ret = 0;
5102                 }
5103         } else {
5104                 send_buf->ah = &ibp->smi_ah->ibah;
5105                 ret = 0;
5106         }
5107
5108         smp = send_buf->mad;
5109         smp->base_version = IB_MGMT_BASE_VERSION;
5110         smp->mgmt_class = IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE;
5111         smp->class_version = 1;
5112         smp->method = IB_MGMT_METHOD_SEND;
5113         smp->hop_cnt = 1;
5114         smp->attr_id = QIB_VENDOR_IPG;
5115         smp->attr_mod = 0;
5116
5117         if (!ret)
5118                 ret = ib_post_send_mad(send_buf, NULL);
5119         if (ret)
5120                 ib_free_send_mad(send_buf);
5121 retry:
5122         delay = 2 << ppd->cpspec->ipg_tries;
5123         queue_delayed_work(ib_wq, &ppd->cpspec->ipg_work,
5124                            msecs_to_jiffies(delay));
5125 }
5126
5127 /*
5128  * Timeout handler for setting IPG.
5129  * Only called if r1.
5130  */
5131 static void ipg_7322_work(struct work_struct *work)
5132 {
5133         struct qib_pportdata *ppd;
5134
5135         ppd = container_of(work, struct qib_chippport_specific,
5136                            ipg_work.work)->ppd;
5137         if ((ppd->lflags & (QIBL_LINKINIT | QIBL_LINKARMED | QIBL_LINKACTIVE))
5138             && ++ppd->cpspec->ipg_tries <= 10)
5139                 try_7322_ipg(ppd);
5140 }
5141
5142 static u32 qib_7322_iblink_state(u64 ibcs)
5143 {
5144         u32 state = (u32)SYM_FIELD(ibcs, IBCStatusA_0, LinkState);
5145
5146         switch (state) {
5147         case IB_7322_L_STATE_INIT:
5148                 state = IB_PORT_INIT;
5149                 break;
5150         case IB_7322_L_STATE_ARM:
5151                 state = IB_PORT_ARMED;
5152                 break;
5153         case IB_7322_L_STATE_ACTIVE:
5154                 /* fall through */
5155         case IB_7322_L_STATE_ACT_DEFER:
5156                 state = IB_PORT_ACTIVE;
5157                 break;
5158         default: /* fall through */
5159         case IB_7322_L_STATE_DOWN:
5160                 state = IB_PORT_DOWN;
5161                 break;
5162         }
5163         return state;
5164 }
5165
5166 /* returns the IBTA port state, rather than the IBC link training state */
5167 static u8 qib_7322_phys_portstate(u64 ibcs)
5168 {
5169         u8 state = (u8)SYM_FIELD(ibcs, IBCStatusA_0, LinkTrainingState);
5170         return qib_7322_physportstate[state];
5171 }
5172
5173 static int qib_7322_ib_updown(struct qib_pportdata *ppd, int ibup, u64 ibcs)
5174 {
5175         int ret = 0, symadj = 0;
5176         unsigned long flags;
5177         int mult;
5178
5179         spin_lock_irqsave(&ppd->lflags_lock, flags);
5180         ppd->lflags &= ~QIBL_IB_FORCE_NOTIFY;
5181         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
5182
5183         /* Update our picture of width and speed from chip */
5184         if (ibcs & SYM_MASK(IBCStatusA_0, LinkSpeedQDR)) {
5185                 ppd->link_speed_active = QIB_IB_QDR;
5186                 mult = 4;
5187         } else if (ibcs & SYM_MASK(IBCStatusA_0, LinkSpeedActive)) {
5188                 ppd->link_speed_active = QIB_IB_DDR;
5189                 mult = 2;
5190         } else {
5191                 ppd->link_speed_active = QIB_IB_SDR;
5192                 mult = 1;
5193         }
5194         if (ibcs & SYM_MASK(IBCStatusA_0, LinkWidthActive)) {
5195                 ppd->link_width_active = IB_WIDTH_4X;
5196                 mult *= 4;
5197         } else
5198                 ppd->link_width_active = IB_WIDTH_1X;
5199         ppd->delay_mult = ib_rate_to_delay[mult_to_ib_rate(mult)];
5200
5201         if (!ibup) {
5202                 u64 clr;
5203
5204                 /* Link went down. */
5205                 /* do IPG MAD again after linkdown, even if last time failed */
5206                 ppd->cpspec->ipg_tries = 0;
5207                 clr = qib_read_kreg_port(ppd, krp_ibcstatus_b) &
5208                         (SYM_MASK(IBCStatusB_0, heartbeat_timed_out) |
5209                          SYM_MASK(IBCStatusB_0, heartbeat_crosstalk));
5210                 if (clr)
5211                         qib_write_kreg_port(ppd, krp_ibcstatus_b, clr);
5212                 if (!(ppd->lflags & (QIBL_IB_AUTONEG_FAILED |
5213                                      QIBL_IB_AUTONEG_INPROG)))
5214                         set_7322_ibspeed_fast(ppd, ppd->link_speed_enabled);
5215                 if (!(ppd->lflags & QIBL_IB_AUTONEG_INPROG)) {
5216                         /* unlock the Tx settings, speed may change */
5217                         qib_write_kreg_port(ppd, krp_tx_deemph_override,
5218                                 SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
5219                                 reset_tx_deemphasis_override));
5220                         qib_cancel_sends(ppd);
5221                         /* on link down, ensure sane pcs state */
5222                         qib_7322_mini_pcs_reset(ppd);
5223                         spin_lock_irqsave(&ppd->sdma_lock, flags);
5224                         if (__qib_sdma_running(ppd))
5225                                 __qib_sdma_process_event(ppd,
5226                                         qib_sdma_event_e70_go_idle);
5227                         spin_unlock_irqrestore(&ppd->sdma_lock, flags);
5228                 }
5229                 clr = read_7322_creg32_port(ppd, crp_iblinkdown);
5230                 if (clr == ppd->cpspec->iblnkdownsnap)
5231                         ppd->cpspec->iblnkdowndelta++;
5232         } else {
5233                 if (qib_compat_ddr_negotiate &&
5234                     !(ppd->lflags & (QIBL_IB_AUTONEG_FAILED |
5235                                      QIBL_IB_AUTONEG_INPROG)) &&
5236                     ppd->link_speed_active == QIB_IB_SDR &&
5237                     (ppd->link_speed_enabled & QIB_IB_DDR)
5238                     && ppd->cpspec->autoneg_tries < AUTONEG_TRIES) {
5239                         /* we are SDR, and auto-negotiation enabled */
5240                         ++ppd->cpspec->autoneg_tries;
5241                         if (!ppd->cpspec->ibdeltainprog) {
5242                                 ppd->cpspec->ibdeltainprog = 1;
5243                                 ppd->cpspec->ibsymdelta +=
5244                                         read_7322_creg32_port(ppd,
5245                                                 crp_ibsymbolerr) -
5246                                                 ppd->cpspec->ibsymsnap;
5247                                 ppd->cpspec->iblnkerrdelta +=
5248                                         read_7322_creg32_port(ppd,
5249                                                 crp_iblinkerrrecov) -
5250                                                 ppd->cpspec->iblnkerrsnap;
5251                         }
5252                         try_7322_autoneg(ppd);
5253                         ret = 1; /* no other IB status change processing */
5254                 } else if ((ppd->lflags & QIBL_IB_AUTONEG_INPROG) &&
5255                            ppd->link_speed_active == QIB_IB_SDR) {
5256                         qib_autoneg_7322_send(ppd, 1);
5257                         set_7322_ibspeed_fast(ppd, QIB_IB_DDR);
5258                         qib_7322_mini_pcs_reset(ppd);
5259                         udelay(2);
5260                         ret = 1; /* no other IB status change processing */
5261                 } else if ((ppd->lflags & QIBL_IB_AUTONEG_INPROG) &&
5262                            (ppd->link_speed_active & QIB_IB_DDR)) {
5263                         spin_lock_irqsave(&ppd->lflags_lock, flags);
5264                         ppd->lflags &= ~(QIBL_IB_AUTONEG_INPROG |
5265                                          QIBL_IB_AUTONEG_FAILED);
5266                         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
5267                         ppd->cpspec->autoneg_tries = 0;
5268                         /* re-enable SDR, for next link down */
5269                         set_7322_ibspeed_fast(ppd, ppd->link_speed_enabled);
5270                         wake_up(&ppd->cpspec->autoneg_wait);
5271                         symadj = 1;
5272                 } else if (ppd->lflags & QIBL_IB_AUTONEG_FAILED) {
5273                         /*
5274                          * Clear autoneg failure flag, and do setup
5275                          * so we'll try next time link goes down and
5276                          * back to INIT (possibly connected to a
5277                          * different device).
5278                          */
5279                         spin_lock_irqsave(&ppd->lflags_lock, flags);
5280                         ppd->lflags &= ~QIBL_IB_AUTONEG_FAILED;
5281                         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
5282                         ppd->cpspec->ibcctrl_b |= IBA7322_IBC_IBTA_1_2_MASK;
5283                         symadj = 1;
5284                 }
5285                 if (!(ppd->lflags & QIBL_IB_AUTONEG_INPROG)) {
5286                         symadj = 1;
5287                         if (ppd->dd->cspec->r1 && ppd->cpspec->ipg_tries <= 10)
5288                                 try_7322_ipg(ppd);
5289                         if (!ppd->cpspec->recovery_init)
5290                                 setup_7322_link_recovery(ppd, 0);
5291                         ppd->cpspec->qdr_dfe_time = jiffies +
5292                                 msecs_to_jiffies(QDR_DFE_DISABLE_DELAY);
5293                 }
5294                 ppd->cpspec->ibmalfusesnap = 0;
5295                 ppd->cpspec->ibmalfsnap = read_7322_creg32_port(ppd,
5296                         crp_errlink);
5297         }
5298         if (symadj) {
5299                 ppd->cpspec->iblnkdownsnap =
5300                         read_7322_creg32_port(ppd, crp_iblinkdown);
5301                 if (ppd->cpspec->ibdeltainprog) {
5302                         ppd->cpspec->ibdeltainprog = 0;
5303                         ppd->cpspec->ibsymdelta += read_7322_creg32_port(ppd,
5304                                 crp_ibsymbolerr) - ppd->cpspec->ibsymsnap;
5305                         ppd->cpspec->iblnkerrdelta += read_7322_creg32_port(ppd,
5306                                 crp_iblinkerrrecov) - ppd->cpspec->iblnkerrsnap;
5307                 }
5308         } else if (!ibup && qib_compat_ddr_negotiate &&
5309                    !ppd->cpspec->ibdeltainprog &&
5310                         !(ppd->lflags & QIBL_IB_AUTONEG_INPROG)) {
5311                 ppd->cpspec->ibdeltainprog = 1;
5312                 ppd->cpspec->ibsymsnap = read_7322_creg32_port(ppd,
5313                         crp_ibsymbolerr);
5314                 ppd->cpspec->iblnkerrsnap = read_7322_creg32_port(ppd,
5315                         crp_iblinkerrrecov);
5316         }
5317
5318         if (!ret)
5319                 qib_setup_7322_setextled(ppd, ibup);
5320         return ret;
5321 }
5322
5323 /*
5324  * Does read/modify/write to appropriate registers to
5325  * set output and direction bits selected by mask.
5326  * these are in their canonical postions (e.g. lsb of
5327  * dir will end up in D48 of extctrl on existing chips).
5328  * returns contents of GP Inputs.
5329  */
5330 static int gpio_7322_mod(struct qib_devdata *dd, u32 out, u32 dir, u32 mask)
5331 {
5332         u64 read_val, new_out;
5333         unsigned long flags;
5334
5335         if (mask) {
5336                 /* some bits being written, lock access to GPIO */
5337                 dir &= mask;
5338                 out &= mask;
5339                 spin_lock_irqsave(&dd->cspec->gpio_lock, flags);
5340                 dd->cspec->extctrl &= ~((u64)mask << SYM_LSB(EXTCtrl, GPIOOe));
5341                 dd->cspec->extctrl |= ((u64) dir << SYM_LSB(EXTCtrl, GPIOOe));
5342                 new_out = (dd->cspec->gpio_out & ~mask) | out;
5343
5344                 qib_write_kreg(dd, kr_extctrl, dd->cspec->extctrl);
5345                 qib_write_kreg(dd, kr_gpio_out, new_out);
5346                 dd->cspec->gpio_out = new_out;
5347                 spin_unlock_irqrestore(&dd->cspec->gpio_lock, flags);
5348         }
5349         /*
5350          * It is unlikely that a read at this time would get valid
5351          * data on a pin whose direction line was set in the same
5352          * call to this function. We include the read here because
5353          * that allows us to potentially combine a change on one pin with
5354          * a read on another, and because the old code did something like
5355          * this.
5356          */
5357         read_val = qib_read_kreg64(dd, kr_extstatus);
5358         return SYM_FIELD(read_val, EXTStatus, GPIOIn);
5359 }
5360
5361 /* Enable writes to config EEPROM, if possible. Returns previous state */
5362 static int qib_7322_eeprom_wen(struct qib_devdata *dd, int wen)
5363 {
5364         int prev_wen;
5365         u32 mask;
5366
5367         mask = 1 << QIB_EEPROM_WEN_NUM;
5368         prev_wen = ~gpio_7322_mod(dd, 0, 0, 0) >> QIB_EEPROM_WEN_NUM;
5369         gpio_7322_mod(dd, wen ? 0 : mask, mask, mask);
5370
5371         return prev_wen & 1;
5372 }
5373
5374 /*
5375  * Read fundamental info we need to use the chip.  These are
5376  * the registers that describe chip capabilities, and are
5377  * saved in shadow registers.
5378  */
5379 static void get_7322_chip_params(struct qib_devdata *dd)
5380 {
5381         u64 val;
5382         u32 piobufs;
5383         int mtu;
5384
5385         dd->palign = qib_read_kreg32(dd, kr_pagealign);
5386
5387         dd->uregbase = qib_read_kreg32(dd, kr_userregbase);
5388
5389         dd->rcvtidcnt = qib_read_kreg32(dd, kr_rcvtidcnt);
5390         dd->rcvtidbase = qib_read_kreg32(dd, kr_rcvtidbase);
5391         dd->rcvegrbase = qib_read_kreg32(dd, kr_rcvegrbase);
5392         dd->piobufbase = qib_read_kreg64(dd, kr_sendpiobufbase);
5393         dd->pio2k_bufbase = dd->piobufbase & 0xffffffff;
5394
5395         val = qib_read_kreg64(dd, kr_sendpiobufcnt);
5396         dd->piobcnt2k = val & ~0U;
5397         dd->piobcnt4k = val >> 32;
5398         val = qib_read_kreg64(dd, kr_sendpiosize);
5399         dd->piosize2k = val & ~0U;
5400         dd->piosize4k = val >> 32;
5401
5402         mtu = ib_mtu_enum_to_int(qib_ibmtu);
5403         if (mtu == -1)
5404                 mtu = QIB_DEFAULT_MTU;
5405         dd->pport[0].ibmtu = (u32)mtu;
5406         dd->pport[1].ibmtu = (u32)mtu;
5407
5408         /* these may be adjusted in init_chip_wc_pat() */
5409         dd->pio2kbase = (u32 __iomem *)
5410                 ((char __iomem *) dd->kregbase + dd->pio2k_bufbase);
5411         dd->pio4kbase = (u32 __iomem *)
5412                 ((char __iomem *) dd->kregbase +
5413                  (dd->piobufbase >> 32));
5414         /*
5415          * 4K buffers take 2 pages; we use roundup just to be
5416          * paranoid; we calculate it once here, rather than on
5417          * ever buf allocate
5418          */
5419         dd->align4k = ALIGN(dd->piosize4k, dd->palign);
5420
5421         piobufs = dd->piobcnt4k + dd->piobcnt2k + NUM_VL15_BUFS;
5422
5423         dd->pioavregs = ALIGN(piobufs, sizeof(u64) * BITS_PER_BYTE / 2) /
5424                 (sizeof(u64) * BITS_PER_BYTE / 2);
5425 }
5426
5427 /*
5428  * The chip base addresses in cspec and cpspec have to be set
5429  * after possible init_chip_wc_pat(), rather than in
5430  * get_7322_chip_params(), so split out as separate function
5431  */
5432 static void qib_7322_set_baseaddrs(struct qib_devdata *dd)
5433 {
5434         u32 cregbase;
5435         cregbase = qib_read_kreg32(dd, kr_counterregbase);
5436
5437         dd->cspec->cregbase = (u64 __iomem *)(cregbase +
5438                 (char __iomem *)dd->kregbase);
5439
5440         dd->egrtidbase = (u64 __iomem *)
5441                 ((char __iomem *) dd->kregbase + dd->rcvegrbase);
5442
5443         /* port registers are defined as relative to base of chip */
5444         dd->pport[0].cpspec->kpregbase =
5445                 (u64 __iomem *)((char __iomem *)dd->kregbase);
5446         dd->pport[1].cpspec->kpregbase =
5447                 (u64 __iomem *)(dd->palign +
5448                 (char __iomem *)dd->kregbase);
5449         dd->pport[0].cpspec->cpregbase =
5450                 (u64 __iomem *)(qib_read_kreg_port(&dd->pport[0],
5451                 kr_counterregbase) + (char __iomem *)dd->kregbase);
5452         dd->pport[1].cpspec->cpregbase =
5453                 (u64 __iomem *)(qib_read_kreg_port(&dd->pport[1],
5454                 kr_counterregbase) + (char __iomem *)dd->kregbase);
5455 }
5456
5457 /*
5458  * This is a fairly special-purpose observer, so we only support
5459  * the port-specific parts of SendCtrl
5460  */
5461
5462 #define SENDCTRL_SHADOWED (SYM_MASK(SendCtrl_0, SendEnable) |           \
5463                            SYM_MASK(SendCtrl_0, SDmaEnable) |           \
5464                            SYM_MASK(SendCtrl_0, SDmaIntEnable) |        \
5465                            SYM_MASK(SendCtrl_0, SDmaSingleDescriptor) | \
5466                            SYM_MASK(SendCtrl_0, SDmaHalt) |             \
5467                            SYM_MASK(SendCtrl_0, IBVLArbiterEn) |        \
5468                            SYM_MASK(SendCtrl_0, ForceCreditUpToDate))
5469
5470 static int sendctrl_hook(struct qib_devdata *dd,
5471                          const struct diag_observer *op, u32 offs,
5472                          u64 *data, u64 mask, int only_32)
5473 {
5474         unsigned long flags;
5475         unsigned idx;
5476         unsigned pidx;
5477         struct qib_pportdata *ppd = NULL;
5478         u64 local_data, all_bits;
5479
5480         /*
5481          * The fixed correspondence between Physical ports and pports is
5482          * severed. We need to hunt for the ppd that corresponds
5483          * to the offset we got. And we have to do that without admitting
5484          * we know the stride, apparently.
5485          */
5486         for (pidx = 0; pidx < dd->num_pports; ++pidx) {
5487                 u64 __iomem *psptr;
5488                 u32 psoffs;
5489
5490                 ppd = dd->pport + pidx;
5491                 if (!ppd->cpspec->kpregbase)
5492                         continue;
5493
5494                 psptr = ppd->cpspec->kpregbase + krp_sendctrl;
5495                 psoffs = (u32) (psptr - dd->kregbase) * sizeof(*psptr);
5496                 if (psoffs == offs)
5497                         break;
5498         }
5499
5500         /* If pport is not being managed by driver, just avoid shadows. */
5501         if (pidx >= dd->num_pports)
5502                 ppd = NULL;
5503
5504         /* In any case, "idx" is flat index in kreg space */
5505         idx = offs / sizeof(u64);
5506
5507         all_bits = ~0ULL;
5508         if (only_32)
5509                 all_bits >>= 32;
5510
5511         spin_lock_irqsave(&dd->sendctrl_lock, flags);
5512         if (!ppd || (mask & all_bits) != all_bits) {
5513                 /*
5514                  * At least some mask bits are zero, so we need
5515                  * to read. The judgement call is whether from
5516                  * reg or shadow. First-cut: read reg, and complain
5517                  * if any bits which should be shadowed are different
5518                  * from their shadowed value.
5519                  */
5520                 if (only_32)
5521                         local_data = (u64)qib_read_kreg32(dd, idx);
5522                 else
5523                         local_data = qib_read_kreg64(dd, idx);
5524                 *data = (local_data & ~mask) | (*data & mask);
5525         }
5526         if (mask) {
5527                 /*
5528                  * At least some mask bits are one, so we need
5529                  * to write, but only shadow some bits.
5530                  */
5531                 u64 sval, tval; /* Shadowed, transient */
5532
5533                 /*
5534                  * New shadow val is bits we don't want to touch,
5535                  * ORed with bits we do, that are intended for shadow.
5536                  */
5537                 if (ppd) {
5538                         sval = ppd->p_sendctrl & ~mask;
5539                         sval |= *data & SENDCTRL_SHADOWED & mask;
5540                         ppd->p_sendctrl = sval;
5541                 } else
5542                         sval = *data & SENDCTRL_SHADOWED & mask;
5543                 tval = sval | (*data & ~SENDCTRL_SHADOWED & mask);
5544                 qib_write_kreg(dd, idx, tval);
5545                 qib_write_kreg(dd, kr_scratch, 0Ull);
5546         }
5547         spin_unlock_irqrestore(&dd->sendctrl_lock, flags);
5548         return only_32 ? 4 : 8;
5549 }
5550
5551 static const struct diag_observer sendctrl_0_observer = {
5552         sendctrl_hook, KREG_IDX(SendCtrl_0) * sizeof(u64),
5553         KREG_IDX(SendCtrl_0) * sizeof(u64)
5554 };
5555
5556 static const struct diag_observer sendctrl_1_observer = {
5557         sendctrl_hook, KREG_IDX(SendCtrl_1) * sizeof(u64),
5558         KREG_IDX(SendCtrl_1) * sizeof(u64)
5559 };
5560
5561 static ushort sdma_fetch_prio = 8;
5562 module_param_named(sdma_fetch_prio, sdma_fetch_prio, ushort, S_IRUGO);
5563 MODULE_PARM_DESC(sdma_fetch_prio, "SDMA descriptor fetch priority");
5564
5565 /* Besides logging QSFP events, we set appropriate TxDDS values */
5566 static void init_txdds_table(struct qib_pportdata *ppd, int override);
5567
5568 static void qsfp_7322_event(struct work_struct *work)
5569 {
5570         struct qib_qsfp_data *qd;
5571         struct qib_pportdata *ppd;
5572         u64 pwrup;
5573         int ret;
5574         u32 le2;
5575
5576         qd = container_of(work, struct qib_qsfp_data, work);
5577         ppd = qd->ppd;
5578         pwrup = qd->t_insert + msecs_to_jiffies(QSFP_PWR_LAG_MSEC);
5579
5580         /*
5581          * Some QSFP's not only do not respond until the full power-up
5582          * time, but may behave badly if we try. So hold off responding
5583          * to insertion.
5584          */
5585         while (1) {
5586                 u64 now = get_jiffies_64();
5587                 if (time_after64(now, pwrup))
5588                         break;
5589                 msleep(20);
5590         }
5591         ret = qib_refresh_qsfp_cache(ppd, &qd->cache);
5592         /*
5593          * Need to change LE2 back to defaults if we couldn't
5594          * read the cable type (to handle cable swaps), so do this
5595          * even on failure to read cable information.  We don't
5596          * get here for QME, so IS_QME check not needed here.
5597          */
5598         le2 = (!ret && qd->cache.atten[1] >= qib_long_atten &&
5599                !ppd->dd->cspec->r1 && QSFP_IS_CU(qd->cache.tech)) ?
5600                 LE2_5m : LE2_DEFAULT;
5601         ibsd_wr_allchans(ppd, 13, (le2 << 7), BMASK(9, 7));
5602         init_txdds_table(ppd, 0);
5603 }
5604
5605 /*
5606  * There is little we can do but complain to the user if QSFP
5607  * initialization fails.
5608  */
5609 static void qib_init_7322_qsfp(struct qib_pportdata *ppd)
5610 {
5611         unsigned long flags;
5612         struct qib_qsfp_data *qd = &ppd->cpspec->qsfp_data;
5613         struct qib_devdata *dd = ppd->dd;
5614         u64 mod_prs_bit = QSFP_GPIO_MOD_PRS_N;
5615
5616         mod_prs_bit <<= (QSFP_GPIO_PORT2_SHIFT * ppd->hw_pidx);
5617         qd->ppd = ppd;
5618         qib_qsfp_init(qd, qsfp_7322_event);
5619         spin_lock_irqsave(&dd->cspec->gpio_lock, flags);
5620         dd->cspec->extctrl |= (mod_prs_bit << SYM_LSB(EXTCtrl, GPIOInvert));
5621         dd->cspec->gpio_mask |= mod_prs_bit;
5622         qib_write_kreg(dd, kr_extctrl, dd->cspec->extctrl);
5623         qib_write_kreg(dd, kr_gpio_mask, dd->cspec->gpio_mask);
5624         spin_unlock_irqrestore(&dd->cspec->gpio_lock, flags);
5625 }
5626
5627 /*
5628  * called at device initialization time, and also if the txselect
5629  * module parameter is changed.  This is used for cables that don't
5630  * have valid QSFP EEPROMs (not present, or attenuation is zero).
5631  * We initialize to the default, then if there is a specific
5632  * unit,port match, we use that (and set it immediately, for the
5633  * current speed, if the link is at INIT or better).
5634  * String format is "default# unit#,port#=# ... u,p=#", separators must
5635  * be a SPACE character.  A newline terminates.  The u,p=# tuples may
5636  * optionally have "u,p=#,#", where the final # is the H1 value
5637  * The last specific match is used (actually, all are used, but last
5638  * one is the one that winds up set); if none at all, fall back on default.
5639  */
5640 static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
5641 {
5642         char *nxt, *str;
5643         u32 pidx, unit, port, deflt, h1;
5644         unsigned long val;
5645         int any = 0, seth1;
5646         int txdds_size;
5647
5648         str = txselect_list;
5649
5650         /* default number is validated in setup_txselect() */
5651         deflt = simple_strtoul(str, &nxt, 0);
5652         for (pidx = 0; pidx < dd->num_pports; ++pidx)
5653                 dd->pport[pidx].cpspec->no_eep = deflt;
5654
5655         txdds_size = TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ;
5656         if (IS_QME(dd) || IS_QMH(dd))
5657                 txdds_size += TXDDS_MFG_SZ;
5658
5659         while (*nxt && nxt[1]) {
5660                 str = ++nxt;
5661                 unit = simple_strtoul(str, &nxt, 0);
5662                 if (nxt == str || !*nxt || *nxt != ',') {
5663                         while (*nxt && *nxt++ != ' ') /* skip to next, if any */
5664                                 ;
5665                         continue;
5666                 }
5667                 str = ++nxt;
5668                 port = simple_strtoul(str, &nxt, 0);
5669                 if (nxt == str || *nxt != '=') {
5670                         while (*nxt && *nxt++ != ' ') /* skip to next, if any */
5671                                 ;
5672                         continue;
5673                 }
5674                 str = ++nxt;
5675                 val = simple_strtoul(str, &nxt, 0);
5676                 if (nxt == str) {
5677                         while (*nxt && *nxt++ != ' ') /* skip to next, if any */
5678                                 ;
5679                         continue;
5680                 }
5681                 if (val >= txdds_size)
5682                         continue;
5683                 seth1 = 0;
5684                 h1 = 0; /* gcc thinks it might be used uninitted */
5685                 if (*nxt == ',' && nxt[1]) {
5686                         str = ++nxt;
5687                         h1 = (u32)simple_strtoul(str, &nxt, 0);
5688                         if (nxt == str)
5689                                 while (*nxt && *nxt++ != ' ') /* skip */
5690                                         ;
5691                         else
5692                                 seth1 = 1;
5693                 }
5694                 for (pidx = 0; dd->unit == unit && pidx < dd->num_pports;
5695                      ++pidx) {
5696                         struct qib_pportdata *ppd = &dd->pport[pidx];
5697
5698                         if (ppd->port != port || !ppd->link_speed_supported)
5699                                 continue;
5700                         ppd->cpspec->no_eep = val;
5701                         if (seth1)
5702                                 ppd->cpspec->h1_val = h1;
5703                         /* now change the IBC and serdes, overriding generic */
5704                         init_txdds_table(ppd, 1);
5705                         any++;
5706                 }
5707                 if (*nxt == '\n')
5708                         break; /* done */
5709         }
5710         if (change && !any) {
5711                 /* no specific setting, use the default.
5712                  * Change the IBC and serdes, but since it's
5713                  * general, don't override specific settings.
5714                  */
5715                 for (pidx = 0; pidx < dd->num_pports; ++pidx)
5716                         if (dd->pport[pidx].link_speed_supported)
5717                                 init_txdds_table(&dd->pport[pidx], 0);
5718         }
5719 }
5720
5721 /* handle the txselect parameter changing */
5722 static int setup_txselect(const char *str, struct kernel_param *kp)
5723 {
5724         struct qib_devdata *dd;
5725         unsigned long val;
5726         char *n;
5727         if (strlen(str) >= MAX_ATTEN_LEN) {
5728                 printk(KERN_INFO QIB_DRV_NAME " txselect_values string "
5729                        "too long\n");
5730                 return -ENOSPC;
5731         }
5732         val = simple_strtoul(str, &n, 0);
5733         if (n == str || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
5734                                 TXDDS_MFG_SZ)) {
5735                 printk(KERN_INFO QIB_DRV_NAME
5736                        "txselect_values must start with a number < %d\n",
5737                         TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ + TXDDS_MFG_SZ);
5738                 return -EINVAL;
5739         }
5740         strcpy(txselect_list, str);
5741
5742         list_for_each_entry(dd, &qib_dev_list, list)
5743                 if (dd->deviceid == PCI_DEVICE_ID_QLOGIC_IB_7322)
5744                         set_no_qsfp_atten(dd, 1);
5745         return 0;
5746 }
5747
5748 /*
5749  * Write the final few registers that depend on some of the
5750  * init setup.  Done late in init, just before bringing up
5751  * the serdes.
5752  */
5753 static int qib_late_7322_initreg(struct qib_devdata *dd)
5754 {
5755         int ret = 0, n;
5756         u64 val;
5757
5758         qib_write_kreg(dd, kr_rcvhdrentsize, dd->rcvhdrentsize);
5759         qib_write_kreg(dd, kr_rcvhdrsize, dd->rcvhdrsize);
5760         qib_write_kreg(dd, kr_rcvhdrcnt, dd->rcvhdrcnt);
5761         qib_write_kreg(dd, kr_sendpioavailaddr, dd->pioavailregs_phys);
5762         val = qib_read_kreg64(dd, kr_sendpioavailaddr);
5763         if (val != dd->pioavailregs_phys) {
5764                 qib_dev_err(dd, "Catastrophic software error, "
5765                             "SendPIOAvailAddr written as %lx, "
5766                             "read back as %llx\n",
5767                             (unsigned long) dd->pioavailregs_phys,
5768                             (unsigned long long) val);
5769                 ret = -EINVAL;
5770         }
5771
5772         n = dd->piobcnt2k + dd->piobcnt4k + NUM_VL15_BUFS;
5773         qib_7322_txchk_change(dd, 0, n, TXCHK_CHG_TYPE_KERN, NULL);
5774         /* driver sends get pkey, lid, etc. checking also, to catch bugs */
5775         qib_7322_txchk_change(dd, 0, n, TXCHK_CHG_TYPE_ENAB1, NULL);
5776
5777         qib_register_observer(dd, &sendctrl_0_observer);
5778         qib_register_observer(dd, &sendctrl_1_observer);
5779
5780         dd->control &= ~QLOGIC_IB_C_SDMAFETCHPRIOEN;
5781         qib_write_kreg(dd, kr_control, dd->control);
5782         /*
5783          * Set SendDmaFetchPriority and init Tx params, including
5784          * QSFP handler on boards that have QSFP.
5785          * First set our default attenuation entry for cables that
5786          * don't have valid attenuation.
5787          */
5788         set_no_qsfp_atten(dd, 0);
5789         for (n = 0; n < dd->num_pports; ++n) {
5790                 struct qib_pportdata *ppd = dd->pport + n;
5791
5792                 qib_write_kreg_port(ppd, krp_senddmaprioritythld,
5793                                     sdma_fetch_prio & 0xf);
5794                 /* Initialize qsfp if present on board. */
5795                 if (dd->flags & QIB_HAS_QSFP)
5796                         qib_init_7322_qsfp(ppd);
5797         }
5798         dd->control |= QLOGIC_IB_C_SDMAFETCHPRIOEN;
5799         qib_write_kreg(dd, kr_control, dd->control);
5800
5801         return ret;
5802 }
5803
5804 /* per IB port errors.  */
5805 #define SENDCTRL_PIBP (MASK_ACROSS(0, 1) | MASK_ACROSS(3, 3) | \
5806         MASK_ACROSS(8, 15))
5807 #define RCVCTRL_PIBP (MASK_ACROSS(0, 17) | MASK_ACROSS(39, 41))
5808 #define ERRS_PIBP (MASK_ACROSS(57, 58) | MASK_ACROSS(54, 54) | \
5809         MASK_ACROSS(36, 49) | MASK_ACROSS(29, 34) | MASK_ACROSS(14, 17) | \
5810         MASK_ACROSS(0, 11))
5811
5812 /*
5813  * Write the initialization per-port registers that need to be done at
5814  * driver load and after reset completes (i.e., that aren't done as part
5815  * of other init procedures called from qib_init.c).
5816  * Some of these should be redundant on reset, but play safe.
5817  */
5818 static void write_7322_init_portregs(struct qib_pportdata *ppd)
5819 {
5820         u64 val;
5821         int i;
5822
5823         if (!ppd->link_speed_supported) {
5824                 /* no buffer credits for this port */
5825                 for (i = 1; i < 8; i++)
5826                         qib_write_kreg_port(ppd, krp_rxcreditvl0 + i, 0);
5827                 qib_write_kreg_port(ppd, krp_ibcctrl_b, 0);
5828                 qib_write_kreg(ppd->dd, kr_scratch, 0);
5829                 return;
5830         }
5831
5832         /*
5833          * Set the number of supported virtual lanes in IBC,
5834          * for flow control packet handling on unsupported VLs
5835          */
5836         val = qib_read_kreg_port(ppd, krp_ibsdtestiftx);
5837         val &= ~SYM_MASK(IB_SDTEST_IF_TX_0, VL_CAP);
5838         val |= (u64)(ppd->vls_supported - 1) <<
5839                 SYM_LSB(IB_SDTEST_IF_TX_0, VL_CAP);
5840         qib_write_kreg_port(ppd, krp_ibsdtestiftx, val);
5841
5842         qib_write_kreg_port(ppd, krp_rcvbthqp, QIB_KD_QP);
5843
5844         /* enable tx header checking */
5845         qib_write_kreg_port(ppd, krp_sendcheckcontrol, IBA7322_SENDCHK_PKEY |
5846                             IBA7322_SENDCHK_BTHQP | IBA7322_SENDCHK_SLID |
5847                             IBA7322_SENDCHK_RAW_IPV6 | IBA7322_SENDCHK_MINSZ);
5848
5849         qib_write_kreg_port(ppd, krp_ncmodectrl,
5850                 SYM_MASK(IBNCModeCtrl_0, ScrambleCapLocal));
5851
5852         /*
5853          * Unconditionally clear the bufmask bits.  If SDMA is
5854          * enabled, we'll set them appropriately later.
5855          */
5856         qib_write_kreg_port(ppd, krp_senddmabufmask0, 0);
5857         qib_write_kreg_port(ppd, krp_senddmabufmask1, 0);
5858         qib_write_kreg_port(ppd, krp_senddmabufmask2, 0);
5859         if (ppd->dd->cspec->r1)
5860                 ppd->p_sendctrl |= SYM_MASK(SendCtrl_0, ForceCreditUpToDate);
5861 }
5862
5863 /*
5864  * Write the initialization per-device registers that need to be done at