1 /*
2  * Copyright (c) 2013 Intel Corporation. All rights reserved.
3  * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
4  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  */
34 /*
35  * This file contains all of the code that is specific to the SerDes
36  * on the QLogic_IB 7220 chip.
37  */
38 
39 #include <linux/pci.h>
40 #include <linux/delay.h>
41 #include <linux/module.h>
42 #include <linux/firmware.h>
43 
44 #include "qib.h"
45 #include "qib_7220.h"
46 
47 #define SD7220_FW_NAME "qlogic/sd7220.fw"
48 MODULE_FIRMWARE(SD7220_FW_NAME);
49 
50 /*
51  * Same as in qib_iba7220.c, but just the registers needed here.
52  * Could move whole set to qib_7220.h, but decided better to keep
53  * local.
54  */
55 #define KREG_IDX(regname) (QIB_7220_##regname##_OFFS / sizeof(u64))
56 #define kr_hwerrclear KREG_IDX(HwErrClear)
57 #define kr_hwerrmask KREG_IDX(HwErrMask)
58 #define kr_hwerrstatus KREG_IDX(HwErrStatus)
59 #define kr_ibcstatus KREG_IDX(IBCStatus)
60 #define kr_ibserdesctrl KREG_IDX(IBSerDesCtrl)
61 #define kr_scratch KREG_IDX(Scratch)
62 #define kr_xgxs_cfg KREG_IDX(XGXSCfg)
63 /* these are used only here, not in qib_iba7220.c */
64 #define kr_ibsd_epb_access_ctrl KREG_IDX(ibsd_epb_access_ctrl)
65 #define kr_ibsd_epb_transaction_reg KREG_IDX(ibsd_epb_transaction_reg)
66 #define kr_pciesd_epb_transaction_reg KREG_IDX(pciesd_epb_transaction_reg)
67 #define kr_pciesd_epb_access_ctrl KREG_IDX(pciesd_epb_access_ctrl)
68 #define kr_serdes_ddsrxeq0 KREG_IDX(SerDes_DDSRXEQ0)
69 
70 /*
71  * The IBSerDesMappTable is a memory that holds values to be stored in
72  * various SerDes registers by IBC.
73  */
74 #define kr_serdes_maptable KREG_IDX(IBSerDesMappTable)
75 
76 /*
77  * Below used for sdnum parameter, selecting one of the two sections
78  * used for PCIe, or the single SerDes used for IB.
79  */
80 #define PCIE_SERDES0 0
81 #define PCIE_SERDES1 1
82 
83 /*
84  * The EPB requires addressing in a particular form. EPB_LOC() is intended
85  * to make #definitions a little more readable.
86  */
87 #define EPB_ADDR_SHF 8
88 #define EPB_LOC(chn, elt, reg) \
89 	(((elt & 0xf) | ((chn & 7) << 4) | ((reg & 0x3f) << 9)) << \
90 	 EPB_ADDR_SHF)
91 #define EPB_IB_QUAD0_CS_SHF (25)
92 #define EPB_IB_QUAD0_CS (1U <<  EPB_IB_QUAD0_CS_SHF)
93 #define EPB_IB_UC_CS_SHF (26)
94 #define EPB_PCIE_UC_CS_SHF (27)
95 #define EPB_GLOBAL_WR (1U << (EPB_ADDR_SHF + 8))
96 
97 /* Forward declarations. */
98 static int qib_sd7220_reg_mod(struct qib_devdata *dd, int sdnum, u32 loc,
99 			      u32 data, u32 mask);
100 static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
101 			     int mask);
102 static int qib_sd_trimdone_poll(struct qib_devdata *dd);
103 static void qib_sd_trimdone_monitor(struct qib_devdata *dd, const char *where);
104 static int qib_sd_setvals(struct qib_devdata *dd);
105 static int qib_sd_early(struct qib_devdata *dd);
106 static int qib_sd_dactrim(struct qib_devdata *dd);
107 static int qib_internal_presets(struct qib_devdata *dd);
108 /* Tweak the register (CMUCTRL5) that contains the TRIMSELF controls */
109 static int qib_sd_trimself(struct qib_devdata *dd, int val);
110 static int epb_access(struct qib_devdata *dd, int sdnum, int claim);
111 static int qib_sd7220_ib_load(struct qib_devdata *dd,
112 			      const struct firmware *fw);
113 static int qib_sd7220_ib_vfy(struct qib_devdata *dd,
114 			     const struct firmware *fw);
115 
116 /*
117  * Below keeps track of whether the "once per power-on" initialization has
118  * been done, because uC code Version 1.32.17 or higher allows the uC to
119  * be reset at will, and Automatic Equalization may require it. So the
120  * state of the reset "pin", is no longer valid. Instead, we check for the
121  * actual uC code having been loaded.
122  */
123 static int qib_ibsd_ucode_loaded(struct qib_pportdata *ppd,
124 				 const struct firmware *fw)
125 {
126 	struct qib_devdata *dd = ppd->dd;
127 
128 	if (!dd->cspec->serdes_first_init_done &&
129 	    qib_sd7220_ib_vfy(dd, fw) > 0)
130 		dd->cspec->serdes_first_init_done = 1;
131 	return dd->cspec->serdes_first_init_done;
132 }
133 
134 /* repeat #define for local use. "Real" #define is in qib_iba7220.c */
135 #define QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR      0x0000004000000000ULL
136 #define IB_MPREG5 (EPB_LOC(6, 0, 0xE) | (1L << EPB_IB_UC_CS_SHF))
137 #define IB_MPREG6 (EPB_LOC(6, 0, 0xF) | (1U << EPB_IB_UC_CS_SHF))
138 #define UC_PAR_CLR_D 8
139 #define UC_PAR_CLR_M 0xC
140 #define IB_CTRL2(chn) (EPB_LOC(chn, 7, 3) | EPB_IB_QUAD0_CS)
141 #define START_EQ1(chan) EPB_LOC(chan, 7, 0x27)
142 
143 void qib_sd7220_clr_ibpar(struct qib_devdata *dd)
144 {
145 	int ret;
146 
147 	/* clear, then re-enable parity errs */
148 	ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, IB_MPREG6,
149 		UC_PAR_CLR_D, UC_PAR_CLR_M);
150 	if (ret < 0) {
151 		qib_dev_err(dd, "Failed clearing IBSerDes Parity err\n");
152 		goto bail;
153 	}
154 	ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, IB_MPREG6, 0,
155 		UC_PAR_CLR_M);
156 
157 	qib_read_kreg32(dd, kr_scratch);
158 	udelay(4);
159 	qib_write_kreg(dd, kr_hwerrclear,
160 		QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR);
161 	qib_read_kreg32(dd, kr_scratch);
162 bail:
163 	return;
164 }
165 
166 /*
167  * After a reset or other unusual event, the epb interface may need
168  * to be re-synchronized, between the host and the uC.
169  * returns <0 for failure to resync within IBSD_RESYNC_TRIES (not expected)
170  */
171 #define IBSD_RESYNC_TRIES 3
172 #define IB_PGUDP(chn) (EPB_LOC((chn), 2, 1) | EPB_IB_QUAD0_CS)
173 #define IB_CMUDONE(chn) (EPB_LOC((chn), 7, 0xF) | EPB_IB_QUAD0_CS)
174 
175 static int qib_resync_ibepb(struct qib_devdata *dd)
176 {
177 	int ret, pat, tries, chn;
178 	u32 loc;
179 
180 	ret = -1;
181 	chn = 0;
182 	for (tries = 0; tries < (4 * IBSD_RESYNC_TRIES); ++tries) {
183 		loc = IB_PGUDP(chn);
184 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, loc, 0, 0);
185 		if (ret < 0) {
186 			qib_dev_err(dd, "Failed read in resync\n");
187 			continue;
188 		}
189 		if (ret != 0xF0 && ret != 0x55 && tries == 0)
190 			qib_dev_err(dd, "unexpected pattern in resync\n");
191 		pat = ret ^ 0xA5; /* alternate F0 and 55 */
192 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, loc, pat, 0xFF);
193 		if (ret < 0) {
194 			qib_dev_err(dd, "Failed write in resync\n");
195 			continue;
196 		}
197 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, loc, 0, 0);
198 		if (ret < 0) {
199 			qib_dev_err(dd, "Failed re-read in resync\n");
200 			continue;
201 		}
202 		if (ret != pat) {
203 			qib_dev_err(dd, "Failed compare1 in resync\n");
204 			continue;
205 		}
206 		loc = IB_CMUDONE(chn);
207 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, loc, 0, 0);
208 		if (ret < 0) {
209 			qib_dev_err(dd, "Failed CMUDONE rd in resync\n");
210 			continue;
211 		}
212 		if ((ret & 0x70) != ((chn << 4) | 0x40)) {
213 			qib_dev_err(dd, "Bad CMUDONE value %02X, chn %d\n",
214 				    ret, chn);
215 			continue;
216 		}
217 		if (++chn == 4)
218 			break;  /* Success */
219 	}
220 	return (ret > 0) ? 0 : ret;
221 }
222 
223 /*
224  * Localize the stuff that should be done to change IB uC reset
225  * returns <0 for errors.
226  */
227 static int qib_ibsd_reset(struct qib_devdata *dd, int assert_rst)
228 {
229 	u64 rst_val;
230 	int ret = 0;
231 	unsigned long flags;
232 
233 	rst_val = qib_read_kreg64(dd, kr_ibserdesctrl);
234 	if (assert_rst) {
235 		/*
236 		 * Vendor recommends "interrupting" uC before reset, to
237 		 * minimize possible glitches.
238 		 */
239 		spin_lock_irqsave(&dd->cspec->sdepb_lock, flags);
240 		epb_access(dd, IB_7220_SERDES, 1);
241 		rst_val |= 1ULL;
242 		/* Squelch possible parity error from _asserting_ reset */
243 		qib_write_kreg(dd, kr_hwerrmask,
244 			       dd->cspec->hwerrmask &
245 			       ~QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR);
246 		qib_write_kreg(dd, kr_ibserdesctrl, rst_val);
247 		/* flush write, delay to ensure it took effect */
248 		qib_read_kreg32(dd, kr_scratch);
249 		udelay(2);
250 		/* once it's reset, can remove interrupt */
251 		epb_access(dd, IB_7220_SERDES, -1);
252 		spin_unlock_irqrestore(&dd->cspec->sdepb_lock, flags);
253 	} else {
254 		/*
255 		 * Before we de-assert reset, we need to deal with
256 		 * possible glitch on the Parity-error line.
257 		 * Suppress it around the reset, both in chip-level
258 		 * hwerrmask and in IB uC control reg. uC will allow
259 		 * it again during startup.
260 		 */
261 		u64 val;
262 
263 		rst_val &= ~(1ULL);
264 		qib_write_kreg(dd, kr_hwerrmask,
265 			       dd->cspec->hwerrmask &
266 			       ~QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR);
267 
268 		ret = qib_resync_ibepb(dd);
269 		if (ret < 0)
270 			qib_dev_err(dd, "unable to re-sync IB EPB\n");
271 
272 		/* set uC control regs to suppress parity errs */
273 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, IB_MPREG5, 1, 1);
274 		if (ret < 0)
275 			goto bail;
276 		/* IB uC code past Version 1.32.17 allow suppression of wdog */
277 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, IB_MPREG6, 0x80,
278 			0x80);
279 		if (ret < 0) {
280 			qib_dev_err(dd, "Failed to set WDOG disable\n");
281 			goto bail;
282 		}
283 		qib_write_kreg(dd, kr_ibserdesctrl, rst_val);
284 		/* flush write, delay for startup */
285 		qib_read_kreg32(dd, kr_scratch);
286 		udelay(1);
287 		/* clear, then re-enable parity errs */
288 		qib_sd7220_clr_ibpar(dd);
289 		val = qib_read_kreg64(dd, kr_hwerrstatus);
290 		if (val & QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR) {
291 			qib_dev_err(dd, "IBUC Parity still set after RST\n");
292 			dd->cspec->hwerrmask &=
293 				~QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR;
294 		}
295 		qib_write_kreg(dd, kr_hwerrmask,
296 			dd->cspec->hwerrmask);
297 	}
298 
299 bail:
300 	return ret;
301 }
302 
303 static void qib_sd_trimdone_monitor(struct qib_devdata *dd,
304 	const char *where)
305 {
306 	int ret, chn, baduns;
307 	u64 val;
308 
309 	if (!where)
310 		where = "?";
311 
312 	/* give time for reset to settle out in EPB */
313 	udelay(2);
314 
315 	ret = qib_resync_ibepb(dd);
316 	if (ret < 0)
317 		qib_dev_err(dd, "not able to re-sync IB EPB (%s)\n", where);
318 
319 	/* Do "sacrificial read" to get EPB in sane state after reset */
320 	ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, IB_CTRL2(0), 0, 0);
321 	if (ret < 0)
322 		qib_dev_err(dd, "Failed TRIMDONE 1st read, (%s)\n", where);
323 
324 	/* Check/show "summary" Trim-done bit in IBCStatus */
325 	val = qib_read_kreg64(dd, kr_ibcstatus);
326 	if (!(val & (1ULL << 11)))
327 		qib_dev_err(dd, "IBCS TRIMDONE clear (%s)\n", where);
328 	/*
329 	 * Do "dummy read/mod/wr" to get EPB in sane state after reset
330 	 * The default value for MPREG6 is 0.
331 	 */
332 	udelay(2);
333 
334 	ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, IB_MPREG6, 0x80, 0x80);
335 	if (ret < 0)
336 		qib_dev_err(dd, "Failed Dummy RMW, (%s)\n", where);
337 	udelay(10);
338 
339 	baduns = 0;
340 
341 	for (chn = 3; chn >= 0; --chn) {
342 		/* Read CTRL reg for each channel to check TRIMDONE */
343 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
344 			IB_CTRL2(chn), 0, 0);
345 		if (ret < 0)
346 			qib_dev_err(dd,
347 				"Failed checking TRIMDONE, chn %d (%s)\n",
348 				chn, where);
349 
350 		if (!(ret & 0x10)) {
351 			int probe;
352 
353 			baduns |= (1 << chn);
354 			qib_dev_err(dd,
355 				"TRIMDONE cleared on chn %d (%02X). (%s)\n",
356 				chn, ret, where);
357 			probe = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
358 				IB_PGUDP(0), 0, 0);
359 			qib_dev_err(dd, "probe is %d (%02X)\n",
360 				probe, probe);
361 			probe = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
362 				IB_CTRL2(chn), 0, 0);
363 			qib_dev_err(dd, "re-read: %d (%02X)\n",
364 				probe, probe);
365 			ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
366 				IB_CTRL2(chn), 0x10, 0x10);
367 			if (ret < 0)
368 				qib_dev_err(dd,
369 					"Err on TRIMDONE rewrite1\n");
370 		}
371 	}
372 	for (chn = 3; chn >= 0; --chn) {
373 		/* Read CTRL reg for each channel to check TRIMDONE */
374 		if (baduns & (1 << chn)) {
375 			qib_dev_err(dd,
376 				"Resetting TRIMDONE on chn %d (%s)\n",
377 				chn, where);
378 			ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
379 				IB_CTRL2(chn), 0x10, 0x10);
380 			if (ret < 0)
381 				qib_dev_err(dd,
382 					"Failed re-setting TRIMDONE, chn %d (%s)\n",
383 					chn, where);
384 		}
385 	}
386 }
387 
388 /*
389  * Below is portion of IBA7220-specific bringup_serdes() that actually
390  * deals with registers and memory within the SerDes itself.
391  * Post IB uC code version 1.32.17, was_reset being 1 is not really
392  * informative, so we double-check.
393  */
394 int qib_sd7220_init(struct qib_devdata *dd)
395 {
396 	const struct firmware *fw;
397 	int ret = 1; /* default to failure */
398 	int first_reset, was_reset;
399 
400 	/* SERDES MPU reset recorded in D0 */
401 	was_reset = (qib_read_kreg64(dd, kr_ibserdesctrl) & 1);
402 	if (!was_reset) {
403 		/* entered with reset not asserted, we need to do it */
404 		qib_ibsd_reset(dd, 1);
405 		qib_sd_trimdone_monitor(dd, "Driver-reload");
406 	}
407 
408 	ret = request_firmware(&fw, SD7220_FW_NAME, &dd->pcidev->dev);
409 	if (ret) {
410 		qib_dev_err(dd, "Failed to load IB SERDES image\n");
411 		goto done;
412 	}
413 
414 	/* Substitute our deduced value for was_reset */
415 	ret = qib_ibsd_ucode_loaded(dd->pport, fw);
416 	if (ret < 0)
417 		goto bail;
418 
419 	first_reset = !ret; /* First reset if IBSD uCode not yet loaded */
420 	/*
421 	 * Alter some regs per vendor latest doc, reset-defaults
422 	 * are not right for IB.
423 	 */
424 	ret = qib_sd_early(dd);
425 	if (ret < 0) {
426 		qib_dev_err(dd, "Failed to set IB SERDES early defaults\n");
427 		goto bail;
428 	}
429 	/*
430 	 * Set DAC manual trim IB.
431 	 * We only do this once after chip has been reset (usually
432 	 * same as once per system boot).
433 	 */
434 	if (first_reset) {
435 		ret = qib_sd_dactrim(dd);
436 		if (ret < 0) {
437 			qib_dev_err(dd, "Failed IB SERDES DAC trim\n");
438 			goto bail;
439 		}
440 	}
441 	/*
442 	 * Set various registers (DDS and RXEQ) that will be
443 	 * controlled by IBC (in 1.2 mode) to reasonable preset values
444 	 * Calling the "internal" version avoids the "check for needed"
445 	 * and "trimdone monitor" that might be counter-productive.
446 	 */
447 	ret = qib_internal_presets(dd);
448 	if (ret < 0) {
449 		qib_dev_err(dd, "Failed to set IB SERDES presets\n");
450 		goto bail;
451 	}
452 	ret = qib_sd_trimself(dd, 0x80);
453 	if (ret < 0) {
454 		qib_dev_err(dd, "Failed to set IB SERDES TRIMSELF\n");
455 		goto bail;
456 	}
457 
458 	/* Load image, then try to verify */
459 	ret = 0;        /* Assume success */
460 	if (first_reset) {
461 		int vfy;
462 		int trim_done;
463 
464 		ret = qib_sd7220_ib_load(dd, fw);
465 		if (ret < 0) {
466 			qib_dev_err(dd, "Failed to load IB SERDES image\n");
467 			goto bail;
468 		} else {
469 			/* Loaded image, try to verify */
470 			vfy = qib_sd7220_ib_vfy(dd, fw);
471 			if (vfy != ret) {
472 				qib_dev_err(dd, "SERDES PRAM VFY failed\n");
473 				goto bail;
474 			} /* end if verified */
475 		} /* end if loaded */
476 
477 		/*
478 		 * Loaded and verified. Almost good...
479 		 * hold "success" in ret
480 		 */
481 		ret = 0;
482 		/*
483 		 * Prev steps all worked, continue bringup
484 		 * De-assert RESET to uC, only in first reset, to allow
485 		 * trimming.
486 		 *
487 		 * Since our default setup sets START_EQ1 to
488 		 * PRESET, we need to clear that for this very first run.
489 		 */
490 		ret = ibsd_mod_allchnls(dd, START_EQ1(0), 0, 0x38);
491 		if (ret < 0) {
492 			qib_dev_err(dd, "Failed clearing START_EQ1\n");
493 			goto bail;
494 		}
495 
496 		qib_ibsd_reset(dd, 0);
497 		/*
498 		 * If this is not the first reset, trimdone should be set
499 		 * already. We may need to check about this.
500 		 */
501 		trim_done = qib_sd_trimdone_poll(dd);
502 		/*
503 		 * Whether or not trimdone succeeded, we need to put the
504 		 * uC back into reset to avoid a possible fight with the
505 		 * IBC state-machine.
506 		 */
507 		qib_ibsd_reset(dd, 1);
508 
509 		if (!trim_done) {
510 			qib_dev_err(dd, "No TRIMDONE seen\n");
511 			goto bail;
512 		}
513 		/*
514 		 * DEBUG: check each time we reset if trimdone bits have
515 		 * gotten cleared, and re-set them.
516 		 */
517 		qib_sd_trimdone_monitor(dd, "First-reset");
518 		/* Remember so we do not re-do the load, dactrim, etc. */
519 		dd->cspec->serdes_first_init_done = 1;
520 	}
521 	/*
522 	 * setup for channel training and load values for
523 	 * RxEq and DDS in tables used by IBC in IB1.2 mode
524 	 */
525 	ret = 0;
526 	if (qib_sd_setvals(dd) >= 0)
527 		goto done;
528 bail:
529 	ret = 1;
530 done:
531 	/* start relock timer regardless, but start at 1 second */
532 	set_7220_relock_poll(dd, -1);
533 
534 	release_firmware(fw);
535 	return ret;
536 }
537 
538 #define EPB_ACC_REQ 1
539 #define EPB_ACC_GNT 0x100
540 #define EPB_DATA_MASK 0xFF
541 #define EPB_RD (1ULL << 24)
542 #define EPB_TRANS_RDY (1ULL << 31)
543 #define EPB_TRANS_ERR (1ULL << 30)
544 #define EPB_TRANS_TRIES 5
545 
546 /*
547  * query, claim, release ownership of the EPB (External Parallel Bus)
548  * for a specified SERDES.
549  * the "claim" parameter is >0 to claim, <0 to release, 0 to query.
550  * Returns <0 for errors, >0 if we had ownership, else 0.
551  */
552 static int epb_access(struct qib_devdata *dd, int sdnum, int claim)
553 {
554 	u16 acc;
555 	u64 accval;
556 	int owned = 0;
557 	u64 oct_sel = 0;
558 
559 	switch (sdnum) {
560 	case IB_7220_SERDES:
561 		/*
562 		 * The IB SERDES "ownership" is fairly simple. A single each
563 		 * request/grant.
564 		 */
565 		acc = kr_ibsd_epb_access_ctrl;
566 		break;
567 
568 	case PCIE_SERDES0:
569 	case PCIE_SERDES1:
570 		/* PCIe SERDES has two "octants", need to select which */
571 		acc = kr_pciesd_epb_access_ctrl;
572 		oct_sel = (2 << (sdnum - PCIE_SERDES0));
573 		break;
574 
575 	default:
576 		return 0;
577 	}
578 
579 	/* Make sure any outstanding transaction was seen */
580 	qib_read_kreg32(dd, kr_scratch);
581 	udelay(15);
582 
583 	accval = qib_read_kreg32(dd, acc);
584 
585 	owned = !!(accval & EPB_ACC_GNT);
586 	if (claim < 0) {
587 		/* Need to release */
588 		u64 pollval;
589 		/*
590 		 * The only writeable bits are the request and CS.
591 		 * Both should be clear
592 		 */
593 		u64 newval = 0;
594 
595 		qib_write_kreg(dd, acc, newval);
596 		/* First read after write is not trustworthy */
597 		pollval = qib_read_kreg32(dd, acc);
598 		udelay(5);
599 		pollval = qib_read_kreg32(dd, acc);
600 		if (pollval & EPB_ACC_GNT)
601 			owned = -1;
602 	} else if (claim > 0) {
603 		/* Need to claim */
604 		u64 pollval;
605 		u64 newval = EPB_ACC_REQ | oct_sel;
606 
607 		qib_write_kreg(dd, acc, newval);
608 		/* First read after write is not trustworthy */
609 		pollval = qib_read_kreg32(dd, acc);
610 		udelay(5);
611 		pollval = qib_read_kreg32(dd, acc);
612 		if (!(pollval & EPB_ACC_GNT))
613 			owned = -1;
614 	}
615 	return owned;
616 }
617 
618 /*
619  * Lemma to deal with race condition of write..read to epb regs
620  */
621 static int epb_trans(struct qib_devdata *dd, u16 reg, u64 i_val, u64 *o_vp)
622 {
623 	int tries;
624 	u64 transval;
625 
626 	qib_write_kreg(dd, reg, i_val);
627 	/* Throw away first read, as RDY bit may be stale */
628 	transval = qib_read_kreg64(dd, reg);
629 
630 	for (tries = EPB_TRANS_TRIES; tries; --tries) {
631 		transval = qib_read_kreg32(dd, reg);
632 		if (transval & EPB_TRANS_RDY)
633 			break;
634 		udelay(5);
635 	}
636 	if (transval & EPB_TRANS_ERR)
637 		return -1;
638 	if (tries > 0 && o_vp)
639 		*o_vp = transval;
640 	return tries;
641 }
642 
643 /**
644  * qib_sd7220_reg_mod - modify SERDES register
645  * @dd: the qlogic_ib device
646  * @sdnum: which SERDES to access
647  * @loc: location - channel, element, register, as packed by EPB_LOC() macro.
648  * @wd: Write Data - value to set in register
649  * @mask: ones where data should be spliced into reg.
650  *
651  * Basic register read/modify/write, with un-needed acesses elided. That is,
652  * a mask of zero will prevent write, while a mask of 0xFF will prevent read.
653  * returns current (presumed, if a write was done) contents of selected
654  * register, or <0 if errors.
655  */
656 static int qib_sd7220_reg_mod(struct qib_devdata *dd, int sdnum, u32 loc,
657 			      u32 wd, u32 mask)
658 {
659 	u16 trans;
660 	u64 transval;
661 	int owned;
662 	int tries, ret;
663 	unsigned long flags;
664 
665 	switch (sdnum) {
666 	case IB_7220_SERDES:
667 		trans = kr_ibsd_epb_transaction_reg;
668 		break;
669 
670 	case PCIE_SERDES0:
671 	case PCIE_SERDES1:
672 		trans = kr_pciesd_epb_transaction_reg;
673 		break;
674 
675 	default:
676 		return -1;
677 	}
678 
679 	/*
680 	 * All access is locked in software (vs other host threads) and
681 	 * hardware (vs uC access).
682 	 */
683 	spin_lock_irqsave(&dd->cspec->sdepb_lock, flags);
684 
685 	owned = epb_access(dd, sdnum, 1);
686 	if (owned < 0) {
687 		spin_unlock_irqrestore(&dd->cspec->sdepb_lock, flags);
688 		return -1;
689 	}
690 	ret = 0;
691 	for (tries = EPB_TRANS_TRIES; tries; --tries) {
692 		transval = qib_read_kreg32(dd, trans);
693 		if (transval & EPB_TRANS_RDY)
694 			break;
695 		udelay(5);
696 	}
697 
698 	if (tries > 0) {
699 		tries = 1;      /* to make read-skip work */
700 		if (mask != 0xFF) {
701 			/*
702 			 * Not a pure write, so need to read.
703 			 * loc encodes chip-select as well as address
704 			 */
705 			transval = loc | EPB_RD;
706 			tries = epb_trans(dd, trans, transval, &transval);
707 		}
708 		if (tries > 0 && mask != 0) {
709 			/*
710 			 * Not a pure read, so need to write.
711 			 */
712 			wd = (wd & mask) | (transval & ~mask);
713 			transval = loc | (wd & EPB_DATA_MASK);
714 			tries = epb_trans(dd, trans, transval, &transval);
715 		}
716 	}
717 	/* else, failed to see ready, what error-handling? */
718 
719 	/*
720 	 * Release bus. Failure is an error.
721 	 */
722 	if (epb_access(dd, sdnum, -1) < 0)
723 		ret = -1;
724 	else
725 		ret = transval & EPB_DATA_MASK;
726 
727 	spin_unlock_irqrestore(&dd->cspec->sdepb_lock, flags);
728 	if (tries <= 0)
729 		ret = -1;
730 	return ret;
731 }
732 
733 #define EPB_ROM_R (2)
734 #define EPB_ROM_W (1)
735 /*
736  * Below, all uC-related, use appropriate UC_CS, depending
737  * on which SerDes is used.
738  */
739 #define EPB_UC_CTL EPB_LOC(6, 0, 0)
740 #define EPB_MADDRL EPB_LOC(6, 0, 2)
741 #define EPB_MADDRH EPB_LOC(6, 0, 3)
742 #define EPB_ROMDATA EPB_LOC(6, 0, 4)
743 #define EPB_RAMDATA EPB_LOC(6, 0, 5)
744 
745 /* Transfer date to/from uC Program RAM of IB or PCIe SerDes */
746 static int qib_sd7220_ram_xfer(struct qib_devdata *dd, int sdnum, u32 loc,
747 			       u8 *buf, int cnt, int rd_notwr)
748 {
749 	u16 trans;
750 	u64 transval;
751 	u64 csbit;
752 	int owned;
753 	int tries;
754 	int sofar;
755 	int addr;
756 	int ret;
757 	unsigned long flags;
758 
759 	/* Pick appropriate transaction reg and "Chip select" for this serdes */
760 	switch (sdnum) {
761 	case IB_7220_SERDES:
762 		csbit = 1ULL << EPB_IB_UC_CS_SHF;
763 		trans = kr_ibsd_epb_transaction_reg;
764 		break;
765 
766 	case PCIE_SERDES0:
767 	case PCIE_SERDES1:
768 		/* PCIe SERDES has uC "chip select" in different bit, too */
769 		csbit = 1ULL << EPB_PCIE_UC_CS_SHF;
770 		trans = kr_pciesd_epb_transaction_reg;
771 		break;
772 
773 	default:
774 		return -1;
775 	}
776 
777 	spin_lock_irqsave(&dd->cspec->sdepb_lock, flags);
778 
779 	owned = epb_access(dd, sdnum, 1);
780 	if (owned < 0) {
781 		spin_unlock_irqrestore(&dd->cspec->sdepb_lock, flags);
782 		return -1;
783 	}
784 
785 	/*
786 	 * In future code, we may need to distinguish several address ranges,
787 	 * and select various memories based on this. For now, just trim
788 	 * "loc" (location including address and memory select) to
789 	 * "addr" (address within memory). we will only support PRAM
790 	 * The memory is 8KB.
791 	 */
792 	addr = loc & 0x1FFF;
793 	for (tries = EPB_TRANS_TRIES; tries; --tries) {
794 		transval = qib_read_kreg32(dd, trans);
795 		if (transval & EPB_TRANS_RDY)
796 			break;
797 		udelay(5);
798 	}
799 
800 	sofar = 0;
801 	if (tries > 0) {
802 		/*
803 		 * Every "memory" access is doubly-indirect.
804 		 * We set two bytes of address, then read/write
805 		 * one or mores bytes of data.
806 		 */
807 
808 		/* First, we set control to "Read" or "Write" */
809 		transval = csbit | EPB_UC_CTL |
810 			(rd_notwr ? EPB_ROM_R : EPB_ROM_W);
811 		tries = epb_trans(dd, trans, transval, &transval);
812 		while (tries > 0 && sofar < cnt) {
813 			if (!sofar) {
814 				/* Only set address at start of chunk */
815 				int addrbyte = (addr + sofar) >> 8;
816 
817 				transval = csbit | EPB_MADDRH | addrbyte;
818 				tries = epb_trans(dd, trans, transval,
819 						  &transval);
820 				if (tries <= 0)
821 					break;
822 				addrbyte = (addr + sofar) & 0xFF;
823 				transval = csbit | EPB_MADDRL | addrbyte;
824 				tries = epb_trans(dd, trans, transval,
825 						 &transval);
826 				if (tries <= 0)
827 					break;
828 			}
829 
830 			if (rd_notwr)
831 				transval = csbit | EPB_ROMDATA | EPB_RD;
832 			else
833 				transval = csbit | EPB_ROMDATA | buf[sofar];
834 			tries = epb_trans(dd, trans, transval, &transval);
835 			if (tries <= 0)
836 				break;
837 			if (rd_notwr)
838 				buf[sofar] = transval & EPB_DATA_MASK;
839 			++sofar;
840 		}
841 		/* Finally, clear control-bit for Read or Write */
842 		transval = csbit | EPB_UC_CTL;
843 		tries = epb_trans(dd, trans, transval, &transval);
844 	}
845 
846 	ret = sofar;
847 	/* Release bus. Failure is an error */
848 	if (epb_access(dd, sdnum, -1) < 0)
849 		ret = -1;
850 
851 	spin_unlock_irqrestore(&dd->cspec->sdepb_lock, flags);
852 	if (tries <= 0)
853 		ret = -1;
854 	return ret;
855 }
856 
857 #define PROG_CHUNK 64
858 
859 static int qib_sd7220_prog_ld(struct qib_devdata *dd, int sdnum,
860 			      const u8 *img, int len, int offset)
861 {
862 	int cnt, sofar, req;
863 
864 	sofar = 0;
865 	while (sofar < len) {
866 		req = len - sofar;
867 		if (req > PROG_CHUNK)
868 			req = PROG_CHUNK;
869 		cnt = qib_sd7220_ram_xfer(dd, sdnum, offset + sofar,
870 					  (u8 *)img + sofar, req, 0);
871 		if (cnt < req) {
872 			sofar = -1;
873 			break;
874 		}
875 		sofar += req;
876 	}
877 	return sofar;
878 }
879 
880 #define VFY_CHUNK 64
881 #define SD_PRAM_ERROR_LIMIT 42
882 
883 static int qib_sd7220_prog_vfy(struct qib_devdata *dd, int sdnum,
884 			       const u8 *img, int len, int offset)
885 {
886 	int cnt, sofar, req, idx, errors;
887 	unsigned char readback[VFY_CHUNK];
888 
889 	errors = 0;
890 	sofar = 0;
891 	while (sofar < len) {
892 		req = len - sofar;
893 		if (req > VFY_CHUNK)
894 			req = VFY_CHUNK;
895 		cnt = qib_sd7220_ram_xfer(dd, sdnum, sofar + offset,
896 					  readback, req, 1);
897 		if (cnt < req) {
898 			/* failed in read itself */
899 			sofar = -1;
900 			break;
901 		}
902 		for (idx = 0; idx < cnt; ++idx) {
903 			if (readback[idx] != img[idx+sofar])
904 				++errors;
905 		}
906 		sofar += cnt;
907 	}
908 	return errors ? -errors : sofar;
909 }
910 
911 static int
912 qib_sd7220_ib_load(struct qib_devdata *dd, const struct firmware *fw)
913 {
914 	return qib_sd7220_prog_ld(dd, IB_7220_SERDES, fw->data, fw->size, 0);
915 }
916 
917 static int
918 qib_sd7220_ib_vfy(struct qib_devdata *dd, const struct firmware *fw)
919 {
920 	return qib_sd7220_prog_vfy(dd, IB_7220_SERDES, fw->data, fw->size, 0);
921 }
922 
923 /*
924  * IRQ not set up at this point in init, so we poll.
925  */
926 #define IB_SERDES_TRIM_DONE (1ULL << 11)
927 #define TRIM_TMO (15)
928 
929 static int qib_sd_trimdone_poll(struct qib_devdata *dd)
930 {
931 	int trim_tmo, ret;
932 	uint64_t val;
933 
934 	/*
935 	 * Default to failure, so IBC will not start
936 	 * without IB_SERDES_TRIM_DONE.
937 	 */
938 	ret = 0;
939 	for (trim_tmo = 0; trim_tmo < TRIM_TMO; ++trim_tmo) {
940 		val = qib_read_kreg64(dd, kr_ibcstatus);
941 		if (val & IB_SERDES_TRIM_DONE) {
942 			ret = 1;
943 			break;
944 		}
945 		msleep(20);
946 	}
947 	if (trim_tmo >= TRIM_TMO) {
948 		qib_dev_err(dd, "No TRIMDONE in %d tries\n", trim_tmo);
949 		ret = 0;
950 	}
951 	return ret;
952 }
953 
954 #define TX_FAST_ELT (9)
955 
956 /*
957  * Set the "negotiation" values for SERDES. These are used by the IB1.2
958  * link negotiation. Macros below are attempt to keep the values a
959  * little more human-editable.
960  * First, values related to Drive De-emphasis Settings.
961  */
962 
963 #define NUM_DDS_REGS 6
964 #define DDS_REG_MAP 0x76A910 /* LSB-first list of regs (in elt 9) to mod */
965 
966 #define DDS_VAL(amp_d, main_d, ipst_d, ipre_d, amp_s, main_s, ipst_s, ipre_s) \
967 	{ { ((amp_d & 0x1F) << 1) | 1, ((amp_s & 0x1F) << 1) | 1, \
968 	  (main_d << 3) | 4 | (ipre_d >> 2), \
969 	  (main_s << 3) | 4 | (ipre_s >> 2), \
970 	  ((ipst_d & 0xF) << 1) | ((ipre_d & 3) << 6) | 0x21, \
971 	  ((ipst_s & 0xF) << 1) | ((ipre_s & 3) << 6) | 0x21 } }
972 
973 static struct dds_init {
974 	uint8_t reg_vals[NUM_DDS_REGS];
975 } dds_init_vals[] = {
976 	/*       DDR(FDR)       SDR(HDR)   */
977 	/* Vendor recommends below for 3m cable */
978 #define DDS_3M 0
979 	DDS_VAL(31, 19, 12, 0, 29, 22,  9, 0),
980 	DDS_VAL(31, 12, 15, 4, 31, 15, 15, 1),
981 	DDS_VAL(31, 13, 15, 3, 31, 16, 15, 0),
982 	DDS_VAL(31, 14, 15, 2, 31, 17, 14, 0),
983 	DDS_VAL(31, 15, 15, 1, 31, 18, 13, 0),
984 	DDS_VAL(31, 16, 15, 0, 31, 19, 12, 0),
985 	DDS_VAL(31, 17, 14, 0, 31, 20, 11, 0),
986 	DDS_VAL(31, 18, 13, 0, 30, 21, 10, 0),
987 	DDS_VAL(31, 20, 11, 0, 28, 23,  8, 0),
988 	DDS_VAL(31, 21, 10, 0, 27, 24,  7, 0),
989 	DDS_VAL(31, 22,  9, 0, 26, 25,  6, 0),
990 	DDS_VAL(30, 23,  8, 0, 25, 26,  5, 0),
991 	DDS_VAL(29, 24,  7, 0, 23, 27,  4, 0),
992 	/* Vendor recommends below for 1m cable */
993 #define DDS_1M 13
994 	DDS_VAL(28, 25,  6, 0, 21, 28,  3, 0),
995 	DDS_VAL(27, 26,  5, 0, 19, 29,  2, 0),
996 	DDS_VAL(25, 27,  4, 0, 17, 30,  1, 0)
997 };
998 
999 /*
1000  * Now the RXEQ section of the table.
1001  */
1002 /* Hardware packs an element number and register address thus: */
1003 #define RXEQ_INIT_RDESC(elt, addr) (((elt) & 0xF) | ((addr) << 4))
1004 #define RXEQ_VAL(elt, adr, val0, val1, val2, val3) \
1005 	{RXEQ_INIT_RDESC((elt), (adr)), {(val0), (val1), (val2), (val3)} }
1006 
1007 #define RXEQ_VAL_ALL(elt, adr, val)  \
1008 	{RXEQ_INIT_RDESC((elt), (adr)), {(val), (val), (val), (val)} }
1009 
1010 #define RXEQ_SDR_DFELTH 0
1011 #define RXEQ_SDR_TLTH 0
1012 #define RXEQ_SDR_G1CNT_Z1CNT 0x11
1013 #define RXEQ_SDR_ZCNT 23
1014 
1015 static struct rxeq_init {
1016 	u16 rdesc;      /* in form used in SerDesDDSRXEQ */
1017 	u8  rdata[4];
1018 } rxeq_init_vals[] = {
1019 	/* Set Rcv Eq. to Preset node */
1020 	RXEQ_VAL_ALL(7, 0x27, 0x10),
1021 	/* Set DFELTHFDR/HDR thresholds */
1022 	RXEQ_VAL(7, 8,    0, 0, 0, 0), /* FDR, was 0, 1, 2, 3 */
1023 	RXEQ_VAL(7, 0x21, 0, 0, 0, 0), /* HDR */
1024 	/* Set TLTHFDR/HDR theshold */
1025 	RXEQ_VAL(7, 9,    2, 2, 2, 2), /* FDR, was 0, 2, 4, 6 */
1026 	RXEQ_VAL(7, 0x23, 2, 2, 2, 2), /* HDR, was  0, 1, 2, 3 */
1027 	/* Set Preamp setting 2 (ZFR/ZCNT) */
1028 	RXEQ_VAL(7, 0x1B, 12, 12, 12, 12), /* FDR, was 12, 16, 20, 24 */
1029 	RXEQ_VAL(7, 0x1C, 12, 12, 12, 12), /* HDR, was 12, 16, 20, 24 */
1030 	/* Set Preamp DC gain and Setting 1 (GFR/GHR) */
1031 	RXEQ_VAL(7, 0x1E, 16, 16, 16, 16), /* FDR, was 16, 17, 18, 20 */
1032 	RXEQ_VAL(7, 0x1F, 16, 16, 16, 16), /* HDR, was 16, 17, 18, 20 */
1033 	/* Toggle RELOCK (in VCDL_CTRL0) to lock to data */
1034 	RXEQ_VAL_ALL(6, 6, 0x20), /* Set D5 High */
1035 	RXEQ_VAL_ALL(6, 6, 0), /* Set D5 Low */
1036 };
1037 
1038 /* There are 17 values from vendor, but IBC only accesses the first 16 */
1039 #define DDS_ROWS (16)
1040 #define RXEQ_ROWS ARRAY_SIZE(rxeq_init_vals)
1041 
1042 static int qib_sd_setvals(struct qib_devdata *dd)
1043 {
1044 	int idx, midx;
1045 	int min_idx;     /* Minimum index for this portion of table */
1046 	uint32_t dds_reg_map;
1047 	u64 __iomem *taddr, *iaddr;
1048 	uint64_t data;
1049 	uint64_t sdctl;
1050 
1051 	taddr = dd->kregbase + kr_serdes_maptable;
1052 	iaddr = dd->kregbase + kr_serdes_ddsrxeq0;
1053 
1054 	/*
1055 	 * Init the DDS section of the table.
1056 	 * Each "row" of the table provokes NUM_DDS_REG writes, to the
1057 	 * registers indicated in DDS_REG_MAP.
1058 	 */
1059 	sdctl = qib_read_kreg64(dd, kr_ibserdesctrl);
1060 	sdctl = (sdctl & ~(0x1f << 8)) | (NUM_DDS_REGS << 8);
1061 	sdctl = (sdctl & ~(0x1f << 13)) | (RXEQ_ROWS << 13);
1062 	qib_write_kreg(dd, kr_ibserdesctrl, sdctl);
1063 
1064 	/*
1065 	 * Iterate down table within loop for each register to store.
1066 	 */
1067 	dds_reg_map = DDS_REG_MAP;
1068 	for (idx = 0; idx < NUM_DDS_REGS; ++idx) {
1069 		data = ((dds_reg_map & 0xF) << 4) | TX_FAST_ELT;
1070 		writeq(data, iaddr + idx);
1071 		qib_read_kreg32(dd, kr_scratch);
1072 		dds_reg_map >>= 4;
1073 		for (midx = 0; midx < DDS_ROWS; ++midx) {
1074 			u64 __iomem *daddr = taddr + ((midx << 4) + idx);
1075 
1076 			data = dds_init_vals[midx].reg_vals[idx];
1077 			writeq(data, daddr);
1078 			qib_read_kreg32(dd, kr_scratch);
1079 		} /* End inner for (vals for this reg, each row) */
1080 	} /* end outer for (regs to be stored) */
1081 
1082 	/*
1083 	 * Init the RXEQ section of the table.
1084 	 * This runs in a different order, as the pattern of
1085 	 * register references is more complex, but there are only
1086 	 * four "data" values per register.
1087 	 */
1088 	min_idx = idx; /* RXEQ indices pick up where DDS left off */
1089 	taddr += 0x100; /* RXEQ data is in second half of table */
1090 	/* Iterate through RXEQ register addresses */
1091 	for (idx = 0; idx < RXEQ_ROWS; ++idx) {
1092 		int didx; /* "destination" */
1093 		int vidx;
1094 
1095 		/* didx is offset by min_idx to address RXEQ range of regs */
1096 		didx = idx + min_idx;
1097 		/* Store the next RXEQ register address */
1098 		writeq(rxeq_init_vals[idx].rdesc, iaddr + didx);
1099 		qib_read_kreg32(dd, kr_scratch);
1100 		/* Iterate through RXEQ values */
1101 		for (vidx = 0; vidx < 4; vidx++) {
1102 			data = rxeq_init_vals[idx].rdata[vidx];
1103 			writeq(data, taddr + (vidx << 6) + idx);
1104 			qib_read_kreg32(dd, kr_scratch);
1105 		}
1106 	} /* end outer for (Reg-writes for RXEQ) */
1107 	return 0;
1108 }
1109 
1110 #define CMUCTRL5 EPB_LOC(7, 0, 0x15)
1111 #define RXHSCTRL0(chan) EPB_LOC(chan, 6, 0)
1112 #define VCDL_DAC2(chan) EPB_LOC(chan, 6, 5)
1113 #define VCDL_CTRL0(chan) EPB_LOC(chan, 6, 6)
1114 #define VCDL_CTRL2(chan) EPB_LOC(chan, 6, 8)
1115 #define START_EQ2(chan) EPB_LOC(chan, 7, 0x28)
1116 
1117 /*
1118  * Repeat a "store" across all channels of the IB SerDes.
1119  * Although nominally it inherits the "read value" of the last
1120  * channel it modified, the only really useful return is <0 for
1121  * failure, >= 0 for success. The parameter 'loc' is assumed to
1122  * be the location in some channel of the register to be modified
1123  * The caller can specify use of the "gang write" option of EPB,
1124  * in which case we use the specified channel data for any fields
1125  * not explicitely written.
1126  */
1127 static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
1128 			     int mask)
1129 {
1130 	int ret = -1;
1131 	int chnl;
1132 
1133 	if (loc & EPB_GLOBAL_WR) {
1134 		/*
1135 		 * Our caller has assured us that we can set all four
1136 		 * channels at once. Trust that. If mask is not 0xFF,
1137 		 * we will read the _specified_ channel for our starting
1138 		 * value.
1139 		 */
1140 		loc |= (1U << EPB_IB_QUAD0_CS_SHF);
1141 		chnl = (loc >> (4 + EPB_ADDR_SHF)) & 7;
1142 		if (mask != 0xFF) {
1143 			ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
1144 						 loc & ~EPB_GLOBAL_WR, 0, 0);
1145 			if (ret < 0) {
1146 				int sloc = loc >> EPB_ADDR_SHF;
1147 
1148 				qib_dev_err(dd,
1149 					"pre-read failed: elt %d, addr 0x%X, chnl %d\n",
1150 					(sloc & 0xF),
1151 					(sloc >> 9) & 0x3f, chnl);
1152 				return ret;
1153 			}
1154 			val = (ret & ~mask) | (val & mask);
1155 		}
1156 		loc &=  ~(7 << (4+EPB_ADDR_SHF));
1157 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, loc, val, 0xFF);
1158 		if (ret < 0) {
1159 			int sloc = loc >> EPB_ADDR_SHF;
1160 
1161 			qib_dev_err(dd,
1162 				"Global WR failed: elt %d, addr 0x%X, val %02X\n",
1163 				(sloc & 0xF), (sloc >> 9) & 0x3f, val);
1164 		}
1165 		return ret;
1166 	}
1167 	/* Clear "channel" and set CS so we can simply iterate */
1168 	loc &=  ~(7 << (4+EPB_ADDR_SHF));
1169 	loc |= (1U << EPB_IB_QUAD0_CS_SHF);
1170 	for (chnl = 0; chnl < 4; ++chnl) {
1171 		int cloc = loc | (chnl << (4+EPB_ADDR_SHF));
1172 
1173 		ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES, cloc, val, mask);
1174 		if (ret < 0) {
1175 			int sloc = loc >> EPB_ADDR_SHF;
1176 
1177 			qib_dev_err(dd,
1178 				"Write failed: elt %d, addr 0x%X, chnl %d, val 0x%02X, mask 0x%02X\n",
1179 				(sloc & 0xF), (sloc >> 9) & 0x3f, chnl,
1180 				val & 0xFF, mask & 0xFF);
1181 			break;
1182 		}
1183 	}
1184 	return ret;
1185 }
1186 
1187 /*
1188  * Set the Tx values normally modified by IBC in IB1.2 mode to default
1189  * values, as gotten from first row of init table.
1190  */
1191 static int set_dds_vals(struct qib_devdata *dd, struct dds_init *ddi)
1192 {
1193 	int ret;
1194 	int idx, reg, data;
1195 	uint32_t regmap;
1196 
1197 	regmap = DDS_REG_MAP;
1198 	for (idx = 0; idx < NUM_DDS_REGS; ++idx) {
1199 		reg = (regmap & 0xF);
1200 		regmap >>= 4;
1201 		data = ddi->reg_vals[idx];
1202 		/* Vendor says RMW not needed for these regs, use 0xFF mask */
1203 		ret = ibsd_mod_allchnls(dd, EPB_LOC(0, 9, reg), data, 0xFF);
1204 		if (ret < 0)
1205 			break;
1206 	}
1207 	return ret;
1208 }
1209 
1210 /*
1211  * Set the Rx values normally modified by IBC in IB1.2 mode to default
1212  * values, as gotten from selected column of init table.
1213  */
1214 static int set_rxeq_vals(struct qib_devdata *dd, int vsel)
1215 {
1216 	int ret;
1217 	int ridx;
1218 	int cnt = ARRAY_SIZE(rxeq_init_vals);
1219 
1220 	for (ridx = 0; ridx < cnt; ++ridx) {
1221 		int elt, reg, val, loc;
1222 
1223 		elt = rxeq_init_vals[ridx].rdesc & 0xF;
1224 		reg = rxeq_init_vals[ridx].rdesc >> 4;
1225 		loc = EPB_LOC(0, elt, reg);
1226 		val = rxeq_init_vals[ridx].rdata[vsel];
1227 		/* mask of 0xFF, because hardware does full-byte store. */
1228 		ret = ibsd_mod_allchnls(dd, loc, val, 0xFF);
1229 		if (ret < 0)
1230 			break;
1231 	}
1232 	return ret;
1233 }
1234 
1235 /*
1236  * Set the default values (row 0) for DDR Driver Demphasis.
1237  * we do this initially and whenever we turn off IB-1.2
1238  *
1239  * The "default" values for Rx equalization are also stored to
1240  * SerDes registers. Formerly (and still default), we used set 2.
1241  * For experimenting with cables and link-partners, we allow changing
1242  * that via a module parameter.
1243  */
1244 static unsigned qib_rxeq_set = 2;
1245 module_param_named(rxeq_default_set, qib_rxeq_set, uint,
1246 		   S_IWUSR | S_IRUGO);
1247 MODULE_PARM_DESC(rxeq_default_set,
1248 		 "Which set [0..3] of Rx Equalization values is default");
1249 
1250 static int qib_internal_presets(struct qib_devdata *dd)
1251 {
1252 	int ret = 0;
1253 
1254 	ret = set_dds_vals(dd, dds_init_vals + DDS_3M);
1255 
1256 	if (ret < 0)
1257 		qib_dev_err(dd, "Failed to set default DDS values\n");
1258 	ret = set_rxeq_vals(dd, qib_rxeq_set & 3);
1259 	if (ret < 0)
1260 		qib_dev_err(dd, "Failed to set default RXEQ values\n");
1261 	return ret;
1262 }
1263 
1264 int qib_sd7220_presets(struct qib_devdata *dd)
1265 {
1266 	int ret = 0;
1267 
1268 	if (!dd->cspec->presets_needed)
1269 		return ret;
1270 	dd->cspec->presets_needed = 0;
1271 	/* Assert uC reset, so we don't clash with it. */
1272 	qib_ibsd_reset(dd, 1);
1273 	udelay(2);
1274 	qib_sd_trimdone_monitor(dd, "link-down");
1275 
1276 	ret = qib_internal_presets(dd);
1277 	return ret;
1278 }
1279 
1280 static int qib_sd_trimself(struct qib_devdata *dd, int val)
1281 {
1282 	int loc = CMUCTRL5 | (1U << EPB_IB_QUAD0_CS_SHF);
1283 
1284 	return qib_sd7220_reg_mod(dd, IB_7220_SERDES, loc, val, 0xFF);
1285 }
1286 
1287 static int qib_sd_early(struct qib_devdata *dd)
1288 {
1289 	int ret;
1290 
1291 	ret = ibsd_mod_allchnls(dd, RXHSCTRL0(0) | EPB_GLOBAL_WR, 0xD4, 0xFF);
1292 	if (ret < 0)
1293 		goto bail;
1294 	ret = ibsd_mod_allchnls(dd, START_EQ1(0) | EPB_GLOBAL_WR, 0x10, 0xFF);
1295 	if (ret < 0)
1296 		goto bail;
1297 	ret = ibsd_mod_allchnls(dd, START_EQ2(0) | EPB_GLOBAL_WR, 0x30, 0xFF);
1298 bail:
1299 	return ret;
1300 }
1301 
1302 #define BACTRL(chnl) EPB_LOC(chnl, 6, 0x0E)
1303 #define LDOUTCTRL1(chnl) EPB_LOC(chnl, 7, 6)
1304 #define RXHSSTATUS(chnl) EPB_LOC(chnl, 6, 0xF)
1305 
1306 static int qib_sd_dactrim(struct qib_devdata *dd)
1307 {
1308 	int ret;
1309 
1310 	ret = ibsd_mod_allchnls(dd, VCDL_DAC2(0) | EPB_GLOBAL_WR, 0x2D, 0xFF);
1311 	if (ret < 0)
1312 		goto bail;
1313 
1314 	/* more fine-tuning of what will be default */
1315 	ret = ibsd_mod_allchnls(dd, VCDL_CTRL2(0), 3, 0xF);
1316 	if (ret < 0)
1317 		goto bail;
1318 
1319 	ret = ibsd_mod_allchnls(dd, BACTRL(0) | EPB_GLOBAL_WR, 0x40, 0xFF);
1320 	if (ret < 0)
1321 		goto bail;
1322 
1323 	ret = ibsd_mod_allchnls(dd, LDOUTCTRL1(0) | EPB_GLOBAL_WR, 0x04, 0xFF);
1324 	if (ret < 0)
1325 		goto bail;
1326 
1327 	ret = ibsd_mod_allchnls(dd, RXHSSTATUS(0) | EPB_GLOBAL_WR, 0x04, 0xFF);
1328 	if (ret < 0)
1329 		goto bail;
1330 
1331 	/*
1332 	 * Delay for max possible number of steps, with slop.
1333 	 * Each step is about 4usec.
1334 	 */
1335 	udelay(415);
1336 
1337 	ret = ibsd_mod_allchnls(dd, LDOUTCTRL1(0) | EPB_GLOBAL_WR, 0x00, 0xFF);
1338 
1339 bail:
1340 	return ret;
1341 }
1342 
1343 #define RELOCK_FIRST_MS 3
1344 #define RXLSPPM(chan) EPB_LOC(chan, 0, 2)
1345 void toggle_7220_rclkrls(struct qib_devdata *dd)
1346 {
1347 	int loc = RXLSPPM(0) | EPB_GLOBAL_WR;
1348 	int ret;
1349 
1350 	ret = ibsd_mod_allchnls(dd, loc, 0, 0x80);
1351 	if (ret < 0)
1352 		qib_dev_err(dd, "RCLKRLS failed to clear D7\n");
1353 	else {
1354 		udelay(1);
1355 		ibsd_mod_allchnls(dd, loc, 0x80, 0x80);
1356 	}
1357 	/* And again for good measure */
1358 	udelay(1);
1359 	ret = ibsd_mod_allchnls(dd, loc, 0, 0x80);
1360 	if (ret < 0)
1361 		qib_dev_err(dd, "RCLKRLS failed to clear D7\n");
1362 	else {
1363 		udelay(1);
1364 		ibsd_mod_allchnls(dd, loc, 0x80, 0x80);
1365 	}
1366 	/* Now reset xgxs and IBC to complete the recovery */
1367 	dd->f_xgxs_reset(dd->pport);
1368 }
1369 
1370 /*
1371  * Shut down the timer that polls for relock occasions, if needed
1372  * this is "hooked" from qib_7220_quiet_serdes(), which is called
1373  * just before qib_shutdown_device() in qib_driver.c shuts down all
1374  * the other timers
1375  */
1376 void shutdown_7220_relock_poll(struct qib_devdata *dd)
1377 {
1378 	if (dd->cspec->relock_timer_active)
1379 		del_timer_sync(&dd->cspec->relock_timer);
1380 }
1381 
1382 static unsigned qib_relock_by_timer = 1;
1383 module_param_named(relock_by_timer, qib_relock_by_timer, uint,
1384 		   S_IWUSR | S_IRUGO);
1385 MODULE_PARM_DESC(relock_by_timer, "Allow relock attempt if link not up");
1386 
1387 static void qib_run_relock(struct timer_list *t)
1388 {
1389 	struct qib_chip_specific *cs = from_timer(cs, t, relock_timer);
1390 	struct qib_devdata *dd = cs->dd;
1391 	struct qib_pportdata *ppd = dd->pport;
1392 	int timeoff;
1393 
1394 	/*
1395 	 * Check link-training state for "stuck" state, when down.
1396 	 * if found, try relock and schedule another try at
1397 	 * exponentially growing delay, maxed at one second.
1398 	 * if not stuck, our work is done.
1399 	 */
1400 	if ((dd->flags & QIB_INITTED) && !(ppd->lflags &
1401 	    (QIBL_IB_AUTONEG_INPROG | QIBL_LINKINIT | QIBL_LINKARMED |
1402 	     QIBL_LINKACTIVE))) {
1403 		if (qib_relock_by_timer) {
1404 			if (!(ppd->lflags & QIBL_IB_LINK_DISABLED))
1405 				toggle_7220_rclkrls(dd);
1406 		}
1407 		/* re-set timer for next check */
1408 		timeoff = cs->relock_interval << 1;
1409 		if (timeoff > HZ)
1410 			timeoff = HZ;
1411 		cs->relock_interval = timeoff;
1412 	} else
1413 		timeoff = HZ;
1414 	mod_timer(&cs->relock_timer, jiffies + timeoff);
1415 }
1416 
1417 void set_7220_relock_poll(struct qib_devdata *dd, int ibup)
1418 {
1419 	struct qib_chip_specific *cs = dd->cspec;
1420 
1421 	if (ibup) {
1422 		/* We are now up, relax timer to 1 second interval */
1423 		if (cs->relock_timer_active) {
1424 			cs->relock_interval = HZ;
1425 			mod_timer(&cs->relock_timer, jiffies + HZ);
1426 		}
1427 	} else {
1428 		/* Transition to down, (re-)set timer to short interval. */
1429 		unsigned int timeout;
1430 
1431 		timeout = msecs_to_jiffies(RELOCK_FIRST_MS);
1432 		if (timeout == 0)
1433 			timeout = 1;
1434 		/* If timer has not yet been started, do so. */
1435 		if (!cs->relock_timer_active) {
1436 			cs->relock_timer_active = 1;
1437 			timer_setup(&cs->relock_timer, qib_run_relock, 0);
1438 			cs->relock_interval = timeout;
1439 			cs->relock_timer.expires = jiffies + timeout;
1440 			add_timer(&cs->relock_timer);
1441 		} else {
1442 			cs->relock_interval = timeout;
1443 			mod_timer(&cs->relock_timer, jiffies + timeout);
1444 		}
1445 	}
1446 }
1447