1 /*
2  * Copyright (c) 2003-2008 Chelsio, Inc. 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 #include <linux/etherdevice.h>
33 #include "common.h"
34 #include "regs.h"
35 #include "sge_defs.h"
36 #include "firmware_exports.h"
37 
38 static void t3_port_intr_clear(struct adapter *adapter, int idx);
39 
40 /**
41  *	t3_wait_op_done_val - wait until an operation is completed
42  *	@adapter: the adapter performing the operation
43  *	@reg: the register to check for completion
44  *	@mask: a single-bit field within @reg that indicates completion
45  *	@polarity: the value of the field when the operation is completed
46  *	@attempts: number of check iterations
47  *	@delay: delay in usecs between iterations
48  *	@valp: where to store the value of the register at completion time
49  *
50  *	Wait until an operation is completed by checking a bit in a register
51  *	up to @attempts times.  If @valp is not NULL the value of the register
52  *	at the time it indicated completion is stored there.  Returns 0 if the
53  *	operation completes and -EAGAIN otherwise.
54  */
55 
56 int t3_wait_op_done_val(struct adapter *adapter, int reg, u32 mask,
57 			int polarity, int attempts, int delay, u32 *valp)
58 {
59 	while (1) {
60 		u32 val = t3_read_reg(adapter, reg);
61 
62 		if (!!(val & mask) == polarity) {
63 			if (valp)
64 				*valp = val;
65 			return 0;
66 		}
67 		if (--attempts == 0)
68 			return -EAGAIN;
69 		if (delay)
70 			udelay(delay);
71 	}
72 }
73 
74 /**
75  *	t3_write_regs - write a bunch of registers
76  *	@adapter: the adapter to program
77  *	@p: an array of register address/register value pairs
78  *	@n: the number of address/value pairs
79  *	@offset: register address offset
80  *
81  *	Takes an array of register address/register value pairs and writes each
82  *	value to the corresponding register.  Register addresses are adjusted
83  *	by the supplied offset.
84  */
85 void t3_write_regs(struct adapter *adapter, const struct addr_val_pair *p,
86 		   int n, unsigned int offset)
87 {
88 	while (n--) {
89 		t3_write_reg(adapter, p->reg_addr + offset, p->val);
90 		p++;
91 	}
92 }
93 
94 /**
95  *	t3_set_reg_field - set a register field to a value
96  *	@adapter: the adapter to program
97  *	@addr: the register address
98  *	@mask: specifies the portion of the register to modify
99  *	@val: the new value for the register field
100  *
101  *	Sets a register field specified by the supplied mask to the
102  *	given value.
103  */
104 void t3_set_reg_field(struct adapter *adapter, unsigned int addr, u32 mask,
105 		      u32 val)
106 {
107 	u32 v = t3_read_reg(adapter, addr) & ~mask;
108 
109 	t3_write_reg(adapter, addr, v | val);
110 	t3_read_reg(adapter, addr);	/* flush */
111 }
112 
113 /**
114  *	t3_read_indirect - read indirectly addressed registers
115  *	@adap: the adapter
116  *	@addr_reg: register holding the indirect address
117  *	@data_reg: register holding the value of the indirect register
118  *	@vals: where the read register values are stored
119  *	@start_idx: index of first indirect register to read
120  *	@nregs: how many indirect registers to read
121  *
122  *	Reads registers that are accessed indirectly through an address/data
123  *	register pair.
124  */
125 static void t3_read_indirect(struct adapter *adap, unsigned int addr_reg,
126 			     unsigned int data_reg, u32 *vals,
127 			     unsigned int nregs, unsigned int start_idx)
128 {
129 	while (nregs--) {
130 		t3_write_reg(adap, addr_reg, start_idx);
131 		*vals++ = t3_read_reg(adap, data_reg);
132 		start_idx++;
133 	}
134 }
135 
136 /**
137  *	t3_mc7_bd_read - read from MC7 through backdoor accesses
138  *	@mc7: identifies MC7 to read from
139  *	@start: index of first 64-bit word to read
140  *	@n: number of 64-bit words to read
141  *	@buf: where to store the read result
142  *
143  *	Read n 64-bit words from MC7 starting at word start, using backdoor
144  *	accesses.
145  */
146 int t3_mc7_bd_read(struct mc7 *mc7, unsigned int start, unsigned int n,
147 		   u64 *buf)
148 {
149 	static const int shift[] = { 0, 0, 16, 24 };
150 	static const int step[] = { 0, 32, 16, 8 };
151 
152 	unsigned int size64 = mc7->size / 8;	/* # of 64-bit words */
153 	struct adapter *adap = mc7->adapter;
154 
155 	if (start >= size64 || start + n > size64)
156 		return -EINVAL;
157 
158 	start *= (8 << mc7->width);
159 	while (n--) {
160 		int i;
161 		u64 val64 = 0;
162 
163 		for (i = (1 << mc7->width) - 1; i >= 0; --i) {
164 			int attempts = 10;
165 			u32 val;
166 
167 			t3_write_reg(adap, mc7->offset + A_MC7_BD_ADDR, start);
168 			t3_write_reg(adap, mc7->offset + A_MC7_BD_OP, 0);
169 			val = t3_read_reg(adap, mc7->offset + A_MC7_BD_OP);
170 			while ((val & F_BUSY) && attempts--)
171 				val = t3_read_reg(adap,
172 						  mc7->offset + A_MC7_BD_OP);
173 			if (val & F_BUSY)
174 				return -EIO;
175 
176 			val = t3_read_reg(adap, mc7->offset + A_MC7_BD_DATA1);
177 			if (mc7->width == 0) {
178 				val64 = t3_read_reg(adap,
179 						    mc7->offset +
180 						    A_MC7_BD_DATA0);
181 				val64 |= (u64) val << 32;
182 			} else {
183 				if (mc7->width > 1)
184 					val >>= shift[mc7->width];
185 				val64 |= (u64) val << (step[mc7->width] * i);
186 			}
187 			start += 8;
188 		}
189 		*buf++ = val64;
190 	}
191 	return 0;
192 }
193 
194 /*
195  * Initialize MI1.
196  */
197 static void mi1_init(struct adapter *adap, const struct adapter_info *ai)
198 {
199 	u32 clkdiv = adap->params.vpd.cclk / (2 * adap->params.vpd.mdc) - 1;
200 	u32 val = F_PREEN | V_CLKDIV(clkdiv);
201 
202 	t3_write_reg(adap, A_MI1_CFG, val);
203 }
204 
205 #define MDIO_ATTEMPTS 20
206 
207 /*
208  * MI1 read/write operations for clause 22 PHYs.
209  */
210 static int t3_mi1_read(struct net_device *dev, int phy_addr, int mmd_addr,
211 		       u16 reg_addr)
212 {
213 	struct port_info *pi = netdev_priv(dev);
214 	struct adapter *adapter = pi->adapter;
215 	int ret;
216 	u32 addr = V_REGADDR(reg_addr) | V_PHYADDR(phy_addr);
217 
218 	mutex_lock(&adapter->mdio_lock);
219 	t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), V_ST(1));
220 	t3_write_reg(adapter, A_MI1_ADDR, addr);
221 	t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(2));
222 	ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
223 	if (!ret)
224 		ret = t3_read_reg(adapter, A_MI1_DATA);
225 	mutex_unlock(&adapter->mdio_lock);
226 	return ret;
227 }
228 
229 static int t3_mi1_write(struct net_device *dev, int phy_addr, int mmd_addr,
230 			u16 reg_addr, u16 val)
231 {
232 	struct port_info *pi = netdev_priv(dev);
233 	struct adapter *adapter = pi->adapter;
234 	int ret;
235 	u32 addr = V_REGADDR(reg_addr) | V_PHYADDR(phy_addr);
236 
237 	mutex_lock(&adapter->mdio_lock);
238 	t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), V_ST(1));
239 	t3_write_reg(adapter, A_MI1_ADDR, addr);
240 	t3_write_reg(adapter, A_MI1_DATA, val);
241 	t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(1));
242 	ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
243 	mutex_unlock(&adapter->mdio_lock);
244 	return ret;
245 }
246 
247 static const struct mdio_ops mi1_mdio_ops = {
248 	.read = t3_mi1_read,
249 	.write = t3_mi1_write,
250 	.mode_support = MDIO_SUPPORTS_C22
251 };
252 
253 /*
254  * Performs the address cycle for clause 45 PHYs.
255  * Must be called with the MDIO_LOCK held.
256  */
257 static int mi1_wr_addr(struct adapter *adapter, int phy_addr, int mmd_addr,
258 		       int reg_addr)
259 {
260 	u32 addr = V_REGADDR(mmd_addr) | V_PHYADDR(phy_addr);
261 
262 	t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), 0);
263 	t3_write_reg(adapter, A_MI1_ADDR, addr);
264 	t3_write_reg(adapter, A_MI1_DATA, reg_addr);
265 	t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(0));
266 	return t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
267 			       MDIO_ATTEMPTS, 10);
268 }
269 
270 /*
271  * MI1 read/write operations for indirect-addressed PHYs.
272  */
273 static int mi1_ext_read(struct net_device *dev, int phy_addr, int mmd_addr,
274 			u16 reg_addr)
275 {
276 	struct port_info *pi = netdev_priv(dev);
277 	struct adapter *adapter = pi->adapter;
278 	int ret;
279 
280 	mutex_lock(&adapter->mdio_lock);
281 	ret = mi1_wr_addr(adapter, phy_addr, mmd_addr, reg_addr);
282 	if (!ret) {
283 		t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(3));
284 		ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
285 				      MDIO_ATTEMPTS, 10);
286 		if (!ret)
287 			ret = t3_read_reg(adapter, A_MI1_DATA);
288 	}
289 	mutex_unlock(&adapter->mdio_lock);
290 	return ret;
291 }
292 
293 static int mi1_ext_write(struct net_device *dev, int phy_addr, int mmd_addr,
294 			 u16 reg_addr, u16 val)
295 {
296 	struct port_info *pi = netdev_priv(dev);
297 	struct adapter *adapter = pi->adapter;
298 	int ret;
299 
300 	mutex_lock(&adapter->mdio_lock);
301 	ret = mi1_wr_addr(adapter, phy_addr, mmd_addr, reg_addr);
302 	if (!ret) {
303 		t3_write_reg(adapter, A_MI1_DATA, val);
304 		t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(1));
305 		ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
306 				      MDIO_ATTEMPTS, 10);
307 	}
308 	mutex_unlock(&adapter->mdio_lock);
309 	return ret;
310 }
311 
312 static const struct mdio_ops mi1_mdio_ext_ops = {
313 	.read = mi1_ext_read,
314 	.write = mi1_ext_write,
315 	.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22
316 };
317 
318 /**
319  *	t3_mdio_change_bits - modify the value of a PHY register
320  *	@phy: the PHY to operate on
321  *	@mmd: the device address
322  *	@reg: the register address
323  *	@clear: what part of the register value to mask off
324  *	@set: what part of the register value to set
325  *
326  *	Changes the value of a PHY register by applying a mask to its current
327  *	value and ORing the result with a new value.
328  */
329 int t3_mdio_change_bits(struct cphy *phy, int mmd, int reg, unsigned int clear,
330 			unsigned int set)
331 {
332 	int ret;
333 	unsigned int val;
334 
335 	ret = t3_mdio_read(phy, mmd, reg, &val);
336 	if (!ret) {
337 		val &= ~clear;
338 		ret = t3_mdio_write(phy, mmd, reg, val | set);
339 	}
340 	return ret;
341 }
342 
343 /**
344  *	t3_phy_reset - reset a PHY block
345  *	@phy: the PHY to operate on
346  *	@mmd: the device address of the PHY block to reset
347  *	@wait: how long to wait for the reset to complete in 1ms increments
348  *
349  *	Resets a PHY block and optionally waits for the reset to complete.
350  *	@mmd should be 0 for 10/100/1000 PHYs and the device address to reset
351  *	for 10G PHYs.
352  */
353 int t3_phy_reset(struct cphy *phy, int mmd, int wait)
354 {
355 	int err;
356 	unsigned int ctl;
357 
358 	err = t3_mdio_change_bits(phy, mmd, MDIO_CTRL1, MDIO_CTRL1_LPOWER,
359 				  MDIO_CTRL1_RESET);
360 	if (err || !wait)
361 		return err;
362 
363 	do {
364 		err = t3_mdio_read(phy, mmd, MDIO_CTRL1, &ctl);
365 		if (err)
366 			return err;
367 		ctl &= MDIO_CTRL1_RESET;
368 		if (ctl)
369 			msleep(1);
370 	} while (ctl && --wait);
371 
372 	return ctl ? -1 : 0;
373 }
374 
375 /**
376  *	t3_phy_advertise - set the PHY advertisement registers for autoneg
377  *	@phy: the PHY to operate on
378  *	@advert: bitmap of capabilities the PHY should advertise
379  *
380  *	Sets a 10/100/1000 PHY's advertisement registers to advertise the
381  *	requested capabilities.
382  */
383 int t3_phy_advertise(struct cphy *phy, unsigned int advert)
384 {
385 	int err;
386 	unsigned int val = 0;
387 
388 	err = t3_mdio_read(phy, MDIO_DEVAD_NONE, MII_CTRL1000, &val);
389 	if (err)
390 		return err;
391 
392 	val &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
393 	if (advert & ADVERTISED_1000baseT_Half)
394 		val |= ADVERTISE_1000HALF;
395 	if (advert & ADVERTISED_1000baseT_Full)
396 		val |= ADVERTISE_1000FULL;
397 
398 	err = t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_CTRL1000, val);
399 	if (err)
400 		return err;
401 
402 	val = 1;
403 	if (advert & ADVERTISED_10baseT_Half)
404 		val |= ADVERTISE_10HALF;
405 	if (advert & ADVERTISED_10baseT_Full)
406 		val |= ADVERTISE_10FULL;
407 	if (advert & ADVERTISED_100baseT_Half)
408 		val |= ADVERTISE_100HALF;
409 	if (advert & ADVERTISED_100baseT_Full)
410 		val |= ADVERTISE_100FULL;
411 	if (advert & ADVERTISED_Pause)
412 		val |= ADVERTISE_PAUSE_CAP;
413 	if (advert & ADVERTISED_Asym_Pause)
414 		val |= ADVERTISE_PAUSE_ASYM;
415 	return t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_ADVERTISE, val);
416 }
417 
418 /**
419  *	t3_phy_advertise_fiber - set fiber PHY advertisement register
420  *	@phy: the PHY to operate on
421  *	@advert: bitmap of capabilities the PHY should advertise
422  *
423  *	Sets a fiber PHY's advertisement register to advertise the
424  *	requested capabilities.
425  */
426 int t3_phy_advertise_fiber(struct cphy *phy, unsigned int advert)
427 {
428 	unsigned int val = 0;
429 
430 	if (advert & ADVERTISED_1000baseT_Half)
431 		val |= ADVERTISE_1000XHALF;
432 	if (advert & ADVERTISED_1000baseT_Full)
433 		val |= ADVERTISE_1000XFULL;
434 	if (advert & ADVERTISED_Pause)
435 		val |= ADVERTISE_1000XPAUSE;
436 	if (advert & ADVERTISED_Asym_Pause)
437 		val |= ADVERTISE_1000XPSE_ASYM;
438 	return t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_ADVERTISE, val);
439 }
440 
441 /**
442  *	t3_set_phy_speed_duplex - force PHY speed and duplex
443  *	@phy: the PHY to operate on
444  *	@speed: requested PHY speed
445  *	@duplex: requested PHY duplex
446  *
447  *	Force a 10/100/1000 PHY's speed and duplex.  This also disables
448  *	auto-negotiation except for GigE, where auto-negotiation is mandatory.
449  */
450 int t3_set_phy_speed_duplex(struct cphy *phy, int speed, int duplex)
451 {
452 	int err;
453 	unsigned int ctl;
454 
455 	err = t3_mdio_read(phy, MDIO_DEVAD_NONE, MII_BMCR, &ctl);
456 	if (err)
457 		return err;
458 
459 	if (speed >= 0) {
460 		ctl &= ~(BMCR_SPEED100 | BMCR_SPEED1000 | BMCR_ANENABLE);
461 		if (speed == SPEED_100)
462 			ctl |= BMCR_SPEED100;
463 		else if (speed == SPEED_1000)
464 			ctl |= BMCR_SPEED1000;
465 	}
466 	if (duplex >= 0) {
467 		ctl &= ~(BMCR_FULLDPLX | BMCR_ANENABLE);
468 		if (duplex == DUPLEX_FULL)
469 			ctl |= BMCR_FULLDPLX;
470 	}
471 	if (ctl & BMCR_SPEED1000) /* auto-negotiation required for GigE */
472 		ctl |= BMCR_ANENABLE;
473 	return t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_BMCR, ctl);
474 }
475 
476 int t3_phy_lasi_intr_enable(struct cphy *phy)
477 {
478 	return t3_mdio_write(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_CTRL,
479 			     MDIO_PMA_LASI_LSALARM);
480 }
481 
482 int t3_phy_lasi_intr_disable(struct cphy *phy)
483 {
484 	return t3_mdio_write(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_CTRL, 0);
485 }
486 
487 int t3_phy_lasi_intr_clear(struct cphy *phy)
488 {
489 	u32 val;
490 
491 	return t3_mdio_read(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_STAT, &val);
492 }
493 
494 int t3_phy_lasi_intr_handler(struct cphy *phy)
495 {
496 	unsigned int status;
497 	int err = t3_mdio_read(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_STAT,
498 			       &status);
499 
500 	if (err)
501 		return err;
502 	return (status & MDIO_PMA_LASI_LSALARM) ? cphy_cause_link_change : 0;
503 }
504 
505 static const struct adapter_info t3_adap_info[] = {
506 	{1, 1, 0,
507 	 F_GPIO2_OEN | F_GPIO4_OEN |
508 	 F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, { S_GPIO3, S_GPIO5 }, 0,
509 	 &mi1_mdio_ops, "Chelsio PE9000"},
510 	{1, 1, 0,
511 	 F_GPIO2_OEN | F_GPIO4_OEN |
512 	 F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, { S_GPIO3, S_GPIO5 }, 0,
513 	 &mi1_mdio_ops, "Chelsio T302"},
514 	{1, 0, 0,
515 	 F_GPIO1_OEN | F_GPIO6_OEN | F_GPIO7_OEN | F_GPIO10_OEN |
516 	 F_GPIO11_OEN | F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
517 	 { 0 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
518 	 &mi1_mdio_ext_ops, "Chelsio T310"},
519 	{1, 1, 0,
520 	 F_GPIO1_OEN | F_GPIO2_OEN | F_GPIO4_OEN | F_GPIO5_OEN | F_GPIO6_OEN |
521 	 F_GPIO7_OEN | F_GPIO10_OEN | F_GPIO11_OEN | F_GPIO1_OUT_VAL |
522 	 F_GPIO5_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
523 	 { S_GPIO9, S_GPIO3 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
524 	 &mi1_mdio_ext_ops, "Chelsio T320"},
525 	{},
526 	{},
527 	{1, 0, 0,
528 	 F_GPIO1_OEN | F_GPIO2_OEN | F_GPIO4_OEN | F_GPIO6_OEN | F_GPIO7_OEN |
529 	 F_GPIO10_OEN | F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
530 	 { S_GPIO9 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
531 	 &mi1_mdio_ext_ops, "Chelsio T310" },
532 	{1, 0, 0,
533 	 F_GPIO1_OEN | F_GPIO6_OEN | F_GPIO7_OEN |
534 	 F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL,
535 	 { S_GPIO9 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
536 	 &mi1_mdio_ext_ops, "Chelsio N320E-G2" },
537 };
538 
539 /*
540  * Return the adapter_info structure with a given index.  Out-of-range indices
541  * return NULL.
542  */
543 const struct adapter_info *t3_get_adapter_info(unsigned int id)
544 {
545 	return id < ARRAY_SIZE(t3_adap_info) ? &t3_adap_info[id] : NULL;
546 }
547 
548 struct port_type_info {
549 	int (*phy_prep)(struct cphy *phy, struct adapter *adapter,
550 			int phy_addr, const struct mdio_ops *ops);
551 };
552 
553 static const struct port_type_info port_types[] = {
554 	{ NULL },
555 	{ t3_ael1002_phy_prep },
556 	{ t3_vsc8211_phy_prep },
557 	{ NULL},
558 	{ t3_xaui_direct_phy_prep },
559 	{ t3_ael2005_phy_prep },
560 	{ t3_qt2045_phy_prep },
561 	{ t3_ael1006_phy_prep },
562 	{ NULL },
563 	{ t3_aq100x_phy_prep },
564 	{ t3_ael2020_phy_prep },
565 };
566 
567 #define VPD_ENTRY(name, len) \
568 	u8 name##_kword[2]; u8 name##_len; u8 name##_data[len]
569 
570 /*
571  * Partial EEPROM Vital Product Data structure.  Includes only the ID and
572  * VPD-R sections.
573  */
574 struct t3_vpd {
575 	u8 id_tag;
576 	u8 id_len[2];
577 	u8 id_data[16];
578 	u8 vpdr_tag;
579 	u8 vpdr_len[2];
580 	VPD_ENTRY(pn, 16);	/* part number */
581 	VPD_ENTRY(ec, 16);	/* EC level */
582 	VPD_ENTRY(sn, SERNUM_LEN); /* serial number */
583 	VPD_ENTRY(na, 12);	/* MAC address base */
584 	VPD_ENTRY(cclk, 6);	/* core clock */
585 	VPD_ENTRY(mclk, 6);	/* mem clock */
586 	VPD_ENTRY(uclk, 6);	/* uP clk */
587 	VPD_ENTRY(mdc, 6);	/* MDIO clk */
588 	VPD_ENTRY(mt, 2);	/* mem timing */
589 	VPD_ENTRY(xaui0cfg, 6);	/* XAUI0 config */
590 	VPD_ENTRY(xaui1cfg, 6);	/* XAUI1 config */
591 	VPD_ENTRY(port0, 2);	/* PHY0 complex */
592 	VPD_ENTRY(port1, 2);	/* PHY1 complex */
593 	VPD_ENTRY(port2, 2);	/* PHY2 complex */
594 	VPD_ENTRY(port3, 2);	/* PHY3 complex */
595 	VPD_ENTRY(rv, 1);	/* csum */
596 	u32 pad;		/* for multiple-of-4 sizing and alignment */
597 };
598 
599 #define EEPROM_STAT_ADDR  0x4000
600 #define VPD_BASE          0xc00
601 
602 /**
603  *	t3_seeprom_wp - enable/disable EEPROM write protection
604  *	@adapter: the adapter
605  *	@enable: 1 to enable write protection, 0 to disable it
606  *
607  *	Enables or disables write protection on the serial EEPROM.
608  */
609 int t3_seeprom_wp(struct adapter *adapter, int enable)
610 {
611 	u32 data = enable ? 0xc : 0;
612 	int ret;
613 
614 	/* EEPROM_STAT_ADDR is outside VPD area, use pci_write_vpd_any() */
615 	ret = pci_write_vpd_any(adapter->pdev, EEPROM_STAT_ADDR, sizeof(u32),
616 				&data);
617 
618 	return ret < 0 ? ret : 0;
619 }
620 
621 static int vpdstrtouint(char *s, u8 len, unsigned int base, unsigned int *val)
622 {
623 	char tok[256];
624 
625 	memcpy(tok, s, len);
626 	tok[len] = 0;
627 	return kstrtouint(strim(tok), base, val);
628 }
629 
630 static int vpdstrtou16(char *s, u8 len, unsigned int base, u16 *val)
631 {
632 	char tok[256];
633 
634 	memcpy(tok, s, len);
635 	tok[len] = 0;
636 	return kstrtou16(strim(tok), base, val);
637 }
638 
639 /**
640  *	get_vpd_params - read VPD parameters from VPD EEPROM
641  *	@adapter: adapter to read
642  *	@p: where to store the parameters
643  *
644  *	Reads card parameters stored in VPD EEPROM.
645  */
646 static int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
647 {
648 	struct t3_vpd vpd;
649 	u8 base_val = 0;
650 	int addr, ret;
651 
652 	/*
653 	 * Card information is normally at VPD_BASE but some early cards had
654 	 * it at 0.
655 	 */
656 	ret = pci_read_vpd(adapter->pdev, VPD_BASE, 1, &base_val);
657 	if (ret < 0)
658 		return ret;
659 	addr = base_val == PCI_VPD_LRDT_ID_STRING ? VPD_BASE : 0;
660 
661 	ret = pci_read_vpd(adapter->pdev, addr, sizeof(vpd), &vpd);
662 	if (ret < 0)
663 		return ret;
664 
665 	ret = vpdstrtouint(vpd.cclk_data, vpd.cclk_len, 10, &p->cclk);
666 	if (ret)
667 		return ret;
668 	ret = vpdstrtouint(vpd.mclk_data, vpd.mclk_len, 10, &p->mclk);
669 	if (ret)
670 		return ret;
671 	ret = vpdstrtouint(vpd.uclk_data, vpd.uclk_len, 10, &p->uclk);
672 	if (ret)
673 		return ret;
674 	ret = vpdstrtouint(vpd.mdc_data, vpd.mdc_len, 10, &p->mdc);
675 	if (ret)
676 		return ret;
677 	ret = vpdstrtouint(vpd.mt_data, vpd.mt_len, 10, &p->mem_timing);
678 	if (ret)
679 		return ret;
680 	memcpy(p->sn, vpd.sn_data, SERNUM_LEN);
681 
682 	/* Old eeproms didn't have port information */
683 	if (adapter->params.rev == 0 && !vpd.port0_data[0]) {
684 		p->port_type[0] = uses_xaui(adapter) ? 1 : 2;
685 		p->port_type[1] = uses_xaui(adapter) ? 6 : 2;
686 	} else {
687 		p->port_type[0] = hex_to_bin(vpd.port0_data[0]);
688 		p->port_type[1] = hex_to_bin(vpd.port1_data[0]);
689 		ret = vpdstrtou16(vpd.xaui0cfg_data, vpd.xaui0cfg_len, 16,
690 				  &p->xauicfg[0]);
691 		if (ret)
692 			return ret;
693 		ret = vpdstrtou16(vpd.xaui1cfg_data, vpd.xaui1cfg_len, 16,
694 				  &p->xauicfg[1]);
695 		if (ret)
696 			return ret;
697 	}
698 
699 	ret = hex2bin(p->eth_base, vpd.na_data, 6);
700 	if (ret < 0)
701 		return -EINVAL;
702 	return 0;
703 }
704 
705 /* serial flash and firmware constants */
706 enum {
707 	SF_ATTEMPTS = 5,	/* max retries for SF1 operations */
708 	SF_SEC_SIZE = 64 * 1024,	/* serial flash sector size */
709 	SF_SIZE = SF_SEC_SIZE * 8,	/* serial flash size */
710 
711 	/* flash command opcodes */
712 	SF_PROG_PAGE = 2,	/* program page */
713 	SF_WR_DISABLE = 4,	/* disable writes */
714 	SF_RD_STATUS = 5,	/* read status register */
715 	SF_WR_ENABLE = 6,	/* enable writes */
716 	SF_RD_DATA_FAST = 0xb,	/* read flash */
717 	SF_ERASE_SECTOR = 0xd8,	/* erase sector */
718 
719 	FW_FLASH_BOOT_ADDR = 0x70000,	/* start address of FW in flash */
720 	FW_VERS_ADDR = 0x7fffc,    /* flash address holding FW version */
721 	FW_MIN_SIZE = 8            /* at least version and csum */
722 };
723 
724 /**
725  *	sf1_read - read data from the serial flash
726  *	@adapter: the adapter
727  *	@byte_cnt: number of bytes to read
728  *	@cont: whether another operation will be chained
729  *	@valp: where to store the read data
730  *
731  *	Reads up to 4 bytes of data from the serial flash.  The location of
732  *	the read needs to be specified prior to calling this by issuing the
733  *	appropriate commands to the serial flash.
734  */
735 static int sf1_read(struct adapter *adapter, unsigned int byte_cnt, int cont,
736 		    u32 *valp)
737 {
738 	int ret;
739 
740 	if (!byte_cnt || byte_cnt > 4)
741 		return -EINVAL;
742 	if (t3_read_reg(adapter, A_SF_OP) & F_BUSY)
743 		return -EBUSY;
744 	t3_write_reg(adapter, A_SF_OP, V_CONT(cont) | V_BYTECNT(byte_cnt - 1));
745 	ret = t3_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 10);
746 	if (!ret)
747 		*valp = t3_read_reg(adapter, A_SF_DATA);
748 	return ret;
749 }
750 
751 /**
752  *	sf1_write - write data to the serial flash
753  *	@adapter: the adapter
754  *	@byte_cnt: number of bytes to write
755  *	@cont: whether another operation will be chained
756  *	@val: value to write
757  *
758  *	Writes up to 4 bytes of data to the serial flash.  The location of
759  *	the write needs to be specified prior to calling this by issuing the
760  *	appropriate commands to the serial flash.
761  */
762 static int sf1_write(struct adapter *adapter, unsigned int byte_cnt, int cont,
763 		     u32 val)
764 {
765 	if (!byte_cnt || byte_cnt > 4)
766 		return -EINVAL;
767 	if (t3_read_reg(adapter, A_SF_OP) & F_BUSY)
768 		return -EBUSY;
769 	t3_write_reg(adapter, A_SF_DATA, val);
770 	t3_write_reg(adapter, A_SF_OP,
771 		     V_CONT(cont) | V_BYTECNT(byte_cnt - 1) | V_OP(1));
772 	return t3_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 10);
773 }
774 
775 /**
776  *	flash_wait_op - wait for a flash operation to complete
777  *	@adapter: the adapter
778  *	@attempts: max number of polls of the status register
779  *	@delay: delay between polls in ms
780  *
781  *	Wait for a flash operation to complete by polling the status register.
782  */
783 static int flash_wait_op(struct adapter *adapter, int attempts, int delay)
784 {
785 	int ret;
786 	u32 status;
787 
788 	while (1) {
789 		if ((ret = sf1_write(adapter, 1, 1, SF_RD_STATUS)) != 0 ||
790 		    (ret = sf1_read(adapter, 1, 0, &status)) != 0)
791 			return ret;
792 		if (!(status & 1))
793 			return 0;
794 		if (--attempts == 0)
795 			return -EAGAIN;
796 		if (delay)
797 			msleep(delay);
798 	}
799 }
800 
801 /**
802  *	t3_read_flash - read words from serial flash
803  *	@adapter: the adapter
804  *	@addr: the start address for the read
805  *	@nwords: how many 32-bit words to read
806  *	@data: where to store the read data
807  *	@byte_oriented: whether to store data as bytes or as words
808  *
809  *	Read the specified number of 32-bit words from the serial flash.
810  *	If @byte_oriented is set the read data is stored as a byte array
811  *	(i.e., big-endian), otherwise as 32-bit words in the platform's
812  *	natural endianness.
813  */
814 static int t3_read_flash(struct adapter *adapter, unsigned int addr,
815 			 unsigned int nwords, u32 *data, int byte_oriented)
816 {
817 	int ret;
818 
819 	if (addr + nwords * sizeof(u32) > SF_SIZE || (addr & 3))
820 		return -EINVAL;
821 
822 	addr = swab32(addr) | SF_RD_DATA_FAST;
823 
824 	if ((ret = sf1_write(adapter, 4, 1, addr)) != 0 ||
825 	    (ret = sf1_read(adapter, 1, 1, data)) != 0)
826 		return ret;
827 
828 	for (; nwords; nwords--, data++) {
829 		ret = sf1_read(adapter, 4, nwords > 1, data);
830 		if (ret)
831 			return ret;
832 		if (byte_oriented)
833 			*data = htonl(*data);
834 	}
835 	return 0;
836 }
837 
838 /**
839  *	t3_write_flash - write up to a page of data to the serial flash
840  *	@adapter: the adapter
841  *	@addr: the start address to write
842  *	@n: length of data to write
843  *	@data: the data to write
844  *
845  *	Writes up to a page of data (256 bytes) to the serial flash starting
846  *	at the given address.
847  */
848 static int t3_write_flash(struct adapter *adapter, unsigned int addr,
849 			  unsigned int n, const u8 *data)
850 {
851 	int ret;
852 	u32 buf[64];
853 	unsigned int i, c, left, val, offset = addr & 0xff;
854 
855 	if (addr + n > SF_SIZE || offset + n > 256)
856 		return -EINVAL;
857 
858 	val = swab32(addr) | SF_PROG_PAGE;
859 
860 	if ((ret = sf1_write(adapter, 1, 0, SF_WR_ENABLE)) != 0 ||
861 	    (ret = sf1_write(adapter, 4, 1, val)) != 0)
862 		return ret;
863 
864 	for (left = n; left; left -= c) {
865 		c = min(left, 4U);
866 		for (val = 0, i = 0; i < c; ++i)
867 			val = (val << 8) + *data++;
868 
869 		ret = sf1_write(adapter, c, c != left, val);
870 		if (ret)
871 			return ret;
872 	}
873 	if ((ret = flash_wait_op(adapter, 5, 1)) != 0)
874 		return ret;
875 
876 	/* Read the page to verify the write succeeded */
877 	ret = t3_read_flash(adapter, addr & ~0xff, ARRAY_SIZE(buf), buf, 1);
878 	if (ret)
879 		return ret;
880 
881 	if (memcmp(data - n, (u8 *) buf + offset, n))
882 		return -EIO;
883 	return 0;
884 }
885 
886 /**
887  *	t3_get_tp_version - read the tp sram version
888  *	@adapter: the adapter
889  *	@vers: where to place the version
890  *
891  *	Reads the protocol sram version from sram.
892  */
893 int t3_get_tp_version(struct adapter *adapter, u32 *vers)
894 {
895 	int ret;
896 
897 	/* Get version loaded in SRAM */
898 	t3_write_reg(adapter, A_TP_EMBED_OP_FIELD0, 0);
899 	ret = t3_wait_op_done(adapter, A_TP_EMBED_OP_FIELD0,
900 			      1, 1, 5, 1);
901 	if (ret)
902 		return ret;
903 
904 	*vers = t3_read_reg(adapter, A_TP_EMBED_OP_FIELD1);
905 
906 	return 0;
907 }
908 
909 /**
910  *	t3_check_tpsram_version - read the tp sram version
911  *	@adapter: the adapter
912  *
913  *	Reads the protocol sram version from flash.
914  */
915 int t3_check_tpsram_version(struct adapter *adapter)
916 {
917 	int ret;
918 	u32 vers;
919 	unsigned int major, minor;
920 
921 	if (adapter->params.rev == T3_REV_A)
922 		return 0;
923 
924 
925 	ret = t3_get_tp_version(adapter, &vers);
926 	if (ret)
927 		return ret;
928 
929 	major = G_TP_VERSION_MAJOR(vers);
930 	minor = G_TP_VERSION_MINOR(vers);
931 
932 	if (major == TP_VERSION_MAJOR && minor == TP_VERSION_MINOR)
933 		return 0;
934 	else {
935 		CH_ERR(adapter, "found wrong TP version (%u.%u), "
936 		       "driver compiled for version %d.%d\n", major, minor,
937 		       TP_VERSION_MAJOR, TP_VERSION_MINOR);
938 	}
939 	return -EINVAL;
940 }
941 
942 /**
943  *	t3_check_tpsram - check if provided protocol SRAM
944  *			  is compatible with this driver
945  *	@adapter: the adapter
946  *	@tp_sram: the firmware image to write
947  *	@size: image size
948  *
949  *	Checks if an adapter's tp sram is compatible with the driver.
950  *	Returns 0 if the versions are compatible, a negative error otherwise.
951  */
952 int t3_check_tpsram(struct adapter *adapter, const u8 *tp_sram,
953 		    unsigned int size)
954 {
955 	u32 csum;
956 	unsigned int i;
957 	const __be32 *p = (const __be32 *)tp_sram;
958 
959 	/* Verify checksum */
960 	for (csum = 0, i = 0; i < size / sizeof(csum); i++)
961 		csum += ntohl(p[i]);
962 	if (csum != 0xffffffff) {
963 		CH_ERR(adapter, "corrupted protocol SRAM image, checksum %u\n",
964 		       csum);
965 		return -EINVAL;
966 	}
967 
968 	return 0;
969 }
970 
971 enum fw_version_type {
972 	FW_VERSION_N3,
973 	FW_VERSION_T3
974 };
975 
976 /**
977  *	t3_get_fw_version - read the firmware version
978  *	@adapter: the adapter
979  *	@vers: where to place the version
980  *
981  *	Reads the FW version from flash.
982  */
983 int t3_get_fw_version(struct adapter *adapter, u32 *vers)
984 {
985 	return t3_read_flash(adapter, FW_VERS_ADDR, 1, vers, 0);
986 }
987 
988 /**
989  *	t3_check_fw_version - check if the FW is compatible with this driver
990  *	@adapter: the adapter
991  *
992  *	Checks if an adapter's FW is compatible with the driver.  Returns 0
993  *	if the versions are compatible, a negative error otherwise.
994  */
995 int t3_check_fw_version(struct adapter *adapter)
996 {
997 	int ret;
998 	u32 vers;
999 	unsigned int type, major, minor;
1000 
1001 	ret = t3_get_fw_version(adapter, &vers);
1002 	if (ret)
1003 		return ret;
1004 
1005 	type = G_FW_VERSION_TYPE(vers);
1006 	major = G_FW_VERSION_MAJOR(vers);
1007 	minor = G_FW_VERSION_MINOR(vers);
1008 
1009 	if (type == FW_VERSION_T3 && major == FW_VERSION_MAJOR &&
1010 	    minor == FW_VERSION_MINOR)
1011 		return 0;
1012 	else if (major != FW_VERSION_MAJOR || minor < FW_VERSION_MINOR)
1013 		CH_WARN(adapter, "found old FW minor version(%u.%u), "
1014 		        "driver compiled for version %u.%u\n", major, minor,
1015 			FW_VERSION_MAJOR, FW_VERSION_MINOR);
1016 	else {
1017 		CH_WARN(adapter, "found newer FW version(%u.%u), "
1018 		        "driver compiled for version %u.%u\n", major, minor,
1019 			FW_VERSION_MAJOR, FW_VERSION_MINOR);
1020 		return 0;
1021 	}
1022 	return -EINVAL;
1023 }
1024 
1025 /**
1026  *	t3_flash_erase_sectors - erase a range of flash sectors
1027  *	@adapter: the adapter
1028  *	@start: the first sector to erase
1029  *	@end: the last sector to erase
1030  *
1031  *	Erases the sectors in the given range.
1032  */
1033 static int t3_flash_erase_sectors(struct adapter *adapter, int start, int end)
1034 {
1035 	while (start <= end) {
1036 		int ret;
1037 
1038 		if ((ret = sf1_write(adapter, 1, 0, SF_WR_ENABLE)) != 0 ||
1039 		    (ret = sf1_write(adapter, 4, 0,
1040 				     SF_ERASE_SECTOR | (start << 8))) != 0 ||
1041 		    (ret = flash_wait_op(adapter, 5, 500)) != 0)
1042 			return ret;
1043 		start++;
1044 	}
1045 	return 0;
1046 }
1047 
1048 /**
1049  *	t3_load_fw - download firmware
1050  *	@adapter: the adapter
1051  *	@fw_data: the firmware image to write
1052  *	@size: image size
1053  *
1054  *	Write the supplied firmware image to the card's serial flash.
1055  *	The FW image has the following sections: @size - 8 bytes of code and
1056  *	data, followed by 4 bytes of FW version, followed by the 32-bit
1057  *	1's complement checksum of the whole image.
1058  */
1059 int t3_load_fw(struct adapter *adapter, const u8 *fw_data, unsigned int size)
1060 {
1061 	u32 csum;
1062 	unsigned int i;
1063 	const __be32 *p = (const __be32 *)fw_data;
1064 	int ret, addr, fw_sector = FW_FLASH_BOOT_ADDR >> 16;
1065 
1066 	if ((size & 3) || size < FW_MIN_SIZE)
1067 		return -EINVAL;
1068 	if (size > FW_VERS_ADDR + 8 - FW_FLASH_BOOT_ADDR)
1069 		return -EFBIG;
1070 
1071 	for (csum = 0, i = 0; i < size / sizeof(csum); i++)
1072 		csum += ntohl(p[i]);
1073 	if (csum != 0xffffffff) {
1074 		CH_ERR(adapter, "corrupted firmware image, checksum %u\n",
1075 		       csum);
1076 		return -EINVAL;
1077 	}
1078 
1079 	ret = t3_flash_erase_sectors(adapter, fw_sector, fw_sector);
1080 	if (ret)
1081 		goto out;
1082 
1083 	size -= 8;		/* trim off version and checksum */
1084 	for (addr = FW_FLASH_BOOT_ADDR; size;) {
1085 		unsigned int chunk_size = min(size, 256U);
1086 
1087 		ret = t3_write_flash(adapter, addr, chunk_size, fw_data);
1088 		if (ret)
1089 			goto out;
1090 
1091 		addr += chunk_size;
1092 		fw_data += chunk_size;
1093 		size -= chunk_size;
1094 	}
1095 
1096 	ret = t3_write_flash(adapter, FW_VERS_ADDR, 4, fw_data);
1097 out:
1098 	if (ret)
1099 		CH_ERR(adapter, "firmware download failed, error %d\n", ret);
1100 	return ret;
1101 }
1102 
1103 #define CIM_CTL_BASE 0x2000
1104 
1105 /**
1106  *      t3_cim_ctl_blk_read - read a block from CIM control region
1107  *
1108  *      @adap: the adapter
1109  *      @addr: the start address within the CIM control region
1110  *      @n: number of words to read
1111  *      @valp: where to store the result
1112  *
1113  *      Reads a block of 4-byte words from the CIM control region.
1114  */
1115 int t3_cim_ctl_blk_read(struct adapter *adap, unsigned int addr,
1116 			unsigned int n, unsigned int *valp)
1117 {
1118 	int ret = 0;
1119 
1120 	if (t3_read_reg(adap, A_CIM_HOST_ACC_CTRL) & F_HOSTBUSY)
1121 		return -EBUSY;
1122 
1123 	for ( ; !ret && n--; addr += 4) {
1124 		t3_write_reg(adap, A_CIM_HOST_ACC_CTRL, CIM_CTL_BASE + addr);
1125 		ret = t3_wait_op_done(adap, A_CIM_HOST_ACC_CTRL, F_HOSTBUSY,
1126 				      0, 5, 2);
1127 		if (!ret)
1128 			*valp++ = t3_read_reg(adap, A_CIM_HOST_ACC_DATA);
1129 	}
1130 	return ret;
1131 }
1132 
1133 static void t3_gate_rx_traffic(struct cmac *mac, u32 *rx_cfg,
1134 			       u32 *rx_hash_high, u32 *rx_hash_low)
1135 {
1136 	/* stop Rx unicast traffic */
1137 	t3_mac_disable_exact_filters(mac);
1138 
1139 	/* stop broadcast, multicast, promiscuous mode traffic */
1140 	*rx_cfg = t3_read_reg(mac->adapter, A_XGM_RX_CFG);
1141 	t3_set_reg_field(mac->adapter, A_XGM_RX_CFG,
1142 			 F_ENHASHMCAST | F_DISBCAST | F_COPYALLFRAMES,
1143 			 F_DISBCAST);
1144 
1145 	*rx_hash_high = t3_read_reg(mac->adapter, A_XGM_RX_HASH_HIGH);
1146 	t3_write_reg(mac->adapter, A_XGM_RX_HASH_HIGH, 0);
1147 
1148 	*rx_hash_low = t3_read_reg(mac->adapter, A_XGM_RX_HASH_LOW);
1149 	t3_write_reg(mac->adapter, A_XGM_RX_HASH_LOW, 0);
1150 
1151 	/* Leave time to drain max RX fifo */
1152 	msleep(1);
1153 }
1154 
1155 static void t3_open_rx_traffic(struct cmac *mac, u32 rx_cfg,
1156 			       u32 rx_hash_high, u32 rx_hash_low)
1157 {
1158 	t3_mac_enable_exact_filters(mac);
1159 	t3_set_reg_field(mac->adapter, A_XGM_RX_CFG,
1160 			 F_ENHASHMCAST | F_DISBCAST | F_COPYALLFRAMES,
1161 			 rx_cfg);
1162 	t3_write_reg(mac->adapter, A_XGM_RX_HASH_HIGH, rx_hash_high);
1163 	t3_write_reg(mac->adapter, A_XGM_RX_HASH_LOW, rx_hash_low);
1164 }
1165 
1166 /**
1167  *	t3_link_changed - handle interface link changes
1168  *	@adapter: the adapter
1169  *	@port_id: the port index that changed link state
1170  *
1171  *	Called when a port's link settings change to propagate the new values
1172  *	to the associated PHY and MAC.  After performing the common tasks it
1173  *	invokes an OS-specific handler.
1174  */
1175 void t3_link_changed(struct adapter *adapter, int port_id)
1176 {
1177 	int link_ok, speed, duplex, fc;
1178 	struct port_info *pi = adap2pinfo(adapter, port_id);
1179 	struct cphy *phy = &pi->phy;
1180 	struct cmac *mac = &pi->mac;
1181 	struct link_config *lc = &pi->link_config;
1182 
1183 	phy->ops->get_link_status(phy, &link_ok, &speed, &duplex, &fc);
1184 
1185 	if (!lc->link_ok && link_ok) {
1186 		u32 rx_cfg, rx_hash_high, rx_hash_low;
1187 		u32 status;
1188 
1189 		t3_xgm_intr_enable(adapter, port_id);
1190 		t3_gate_rx_traffic(mac, &rx_cfg, &rx_hash_high, &rx_hash_low);
1191 		t3_write_reg(adapter, A_XGM_RX_CTRL + mac->offset, 0);
1192 		t3_mac_enable(mac, MAC_DIRECTION_RX);
1193 
1194 		status = t3_read_reg(adapter, A_XGM_INT_STATUS + mac->offset);
1195 		if (status & F_LINKFAULTCHANGE) {
1196 			mac->stats.link_faults++;
1197 			pi->link_fault = 1;
1198 		}
1199 		t3_open_rx_traffic(mac, rx_cfg, rx_hash_high, rx_hash_low);
1200 	}
1201 
1202 	if (lc->requested_fc & PAUSE_AUTONEG)
1203 		fc &= lc->requested_fc;
1204 	else
1205 		fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
1206 
1207 	if (link_ok == lc->link_ok && speed == lc->speed &&
1208 	    duplex == lc->duplex && fc == lc->fc)
1209 		return;                            /* nothing changed */
1210 
1211 	if (link_ok != lc->link_ok && adapter->params.rev > 0 &&
1212 	    uses_xaui(adapter)) {
1213 		if (link_ok)
1214 			t3b_pcs_reset(mac);
1215 		t3_write_reg(adapter, A_XGM_XAUI_ACT_CTRL + mac->offset,
1216 			     link_ok ? F_TXACTENABLE | F_RXEN : 0);
1217 	}
1218 	lc->link_ok = link_ok;
1219 	lc->speed = speed < 0 ? SPEED_INVALID : speed;
1220 	lc->duplex = duplex < 0 ? DUPLEX_INVALID : duplex;
1221 
1222 	if (link_ok && speed >= 0 && lc->autoneg == AUTONEG_ENABLE) {
1223 		/* Set MAC speed, duplex, and flow control to match PHY. */
1224 		t3_mac_set_speed_duplex_fc(mac, speed, duplex, fc);
1225 		lc->fc = fc;
1226 	}
1227 
1228 	t3_os_link_changed(adapter, port_id, link_ok && !pi->link_fault,
1229 			   speed, duplex, fc);
1230 }
1231 
1232 void t3_link_fault(struct adapter *adapter, int port_id)
1233 {
1234 	struct port_info *pi = adap2pinfo(adapter, port_id);
1235 	struct cmac *mac = &pi->mac;
1236 	struct cphy *phy = &pi->phy;
1237 	struct link_config *lc = &pi->link_config;
1238 	int link_ok, speed, duplex, fc, link_fault;
1239 	u32 rx_cfg, rx_hash_high, rx_hash_low;
1240 
1241 	t3_gate_rx_traffic(mac, &rx_cfg, &rx_hash_high, &rx_hash_low);
1242 
1243 	if (adapter->params.rev > 0 && uses_xaui(adapter))
1244 		t3_write_reg(adapter, A_XGM_XAUI_ACT_CTRL + mac->offset, 0);
1245 
1246 	t3_write_reg(adapter, A_XGM_RX_CTRL + mac->offset, 0);
1247 	t3_mac_enable(mac, MAC_DIRECTION_RX);
1248 
1249 	t3_open_rx_traffic(mac, rx_cfg, rx_hash_high, rx_hash_low);
1250 
1251 	link_fault = t3_read_reg(adapter,
1252 				 A_XGM_INT_STATUS + mac->offset);
1253 	link_fault &= F_LINKFAULTCHANGE;
1254 
1255 	link_ok = lc->link_ok;
1256 	speed = lc->speed;
1257 	duplex = lc->duplex;
1258 	fc = lc->fc;
1259 
1260 	phy->ops->get_link_status(phy, &link_ok, &speed, &duplex, &fc);
1261 
1262 	if (link_fault) {
1263 		lc->link_ok = 0;
1264 		lc->speed = SPEED_INVALID;
1265 		lc->duplex = DUPLEX_INVALID;
1266 
1267 		t3_os_link_fault(adapter, port_id, 0);
1268 
1269 		/* Account link faults only when the phy reports a link up */
1270 		if (link_ok)
1271 			mac->stats.link_faults++;
1272 	} else {
1273 		if (link_ok)
1274 			t3_write_reg(adapter, A_XGM_XAUI_ACT_CTRL + mac->offset,
1275 				     F_TXACTENABLE | F_RXEN);
1276 
1277 		pi->link_fault = 0;
1278 		lc->link_ok = (unsigned char)link_ok;
1279 		lc->speed = speed < 0 ? SPEED_INVALID : speed;
1280 		lc->duplex = duplex < 0 ? DUPLEX_INVALID : duplex;
1281 		t3_os_link_fault(adapter, port_id, link_ok);
1282 	}
1283 }
1284 
1285 /**
1286  *	t3_link_start - apply link configuration to MAC/PHY
1287  *	@phy: the PHY to setup
1288  *	@mac: the MAC to setup
1289  *	@lc: the requested link configuration
1290  *
1291  *	Set up a port's MAC and PHY according to a desired link configuration.
1292  *	- If the PHY can auto-negotiate first decide what to advertise, then
1293  *	  enable/disable auto-negotiation as desired, and reset.
1294  *	- If the PHY does not auto-negotiate just reset it.
1295  *	- If auto-negotiation is off set the MAC to the proper speed/duplex/FC,
1296  *	  otherwise do it later based on the outcome of auto-negotiation.
1297  */
1298 int t3_link_start(struct cphy *phy, struct cmac *mac, struct link_config *lc)
1299 {
1300 	unsigned int fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
1301 
1302 	lc->link_ok = 0;
1303 	if (lc->supported & SUPPORTED_Autoneg) {
1304 		lc->advertising &= ~(ADVERTISED_Asym_Pause | ADVERTISED_Pause);
1305 		if (fc) {
1306 			lc->advertising |= ADVERTISED_Asym_Pause;
1307 			if (fc & PAUSE_RX)
1308 				lc->advertising |= ADVERTISED_Pause;
1309 		}
1310 		phy->ops->advertise(phy, lc->advertising);
1311 
1312 		if (lc->autoneg == AUTONEG_DISABLE) {
1313 			lc->speed = lc->requested_speed;
1314 			lc->duplex = lc->requested_duplex;
1315 			lc->fc = (unsigned char)fc;
1316 			t3_mac_set_speed_duplex_fc(mac, lc->speed, lc->duplex,
1317 						   fc);
1318 			/* Also disables autoneg */
1319 			phy->ops->set_speed_duplex(phy, lc->speed, lc->duplex);
1320 		} else
1321 			phy->ops->autoneg_enable(phy);
1322 	} else {
1323 		t3_mac_set_speed_duplex_fc(mac, -1, -1, fc);
1324 		lc->fc = (unsigned char)fc;
1325 		phy->ops->reset(phy, 0);
1326 	}
1327 	return 0;
1328 }
1329 
1330 /**
1331  *	t3_set_vlan_accel - control HW VLAN extraction
1332  *	@adapter: the adapter
1333  *	@ports: bitmap of adapter ports to operate on
1334  *	@on: enable (1) or disable (0) HW VLAN extraction
1335  *
1336  *	Enables or disables HW extraction of VLAN tags for the given port.
1337  */
1338 void t3_set_vlan_accel(struct adapter *adapter, unsigned int ports, int on)
1339 {
1340 	t3_set_reg_field(adapter, A_TP_OUT_CONFIG,
1341 			 ports << S_VLANEXTRACTIONENABLE,
1342 			 on ? (ports << S_VLANEXTRACTIONENABLE) : 0);
1343 }
1344 
1345 struct intr_info {
1346 	unsigned int mask;	/* bits to check in interrupt status */
1347 	const char *msg;	/* message to print or NULL */
1348 	short stat_idx;		/* stat counter to increment or -1 */
1349 	unsigned short fatal;	/* whether the condition reported is fatal */
1350 };
1351 
1352 /**
1353  *	t3_handle_intr_status - table driven interrupt handler
1354  *	@adapter: the adapter that generated the interrupt
1355  *	@reg: the interrupt status register to process
1356  *	@mask: a mask to apply to the interrupt status
1357  *	@acts: table of interrupt actions
1358  *	@stats: statistics counters tracking interrupt occurrences
1359  *
1360  *	A table driven interrupt handler that applies a set of masks to an
1361  *	interrupt status word and performs the corresponding actions if the
1362  *	interrupts described by the mask have occurred.  The actions include
1363  *	optionally printing a warning or alert message, and optionally
1364  *	incrementing a stat counter.  The table is terminated by an entry
1365  *	specifying mask 0.  Returns the number of fatal interrupt conditions.
1366  */
1367 static int t3_handle_intr_status(struct adapter *adapter, unsigned int reg,
1368 				 unsigned int mask,
1369 				 const struct intr_info *acts,
1370 				 unsigned long *stats)
1371 {
1372 	int fatal = 0;
1373 	unsigned int status = t3_read_reg(adapter, reg) & mask;
1374 
1375 	for (; acts->mask; ++acts) {
1376 		if (!(status & acts->mask))
1377 			continue;
1378 		if (acts->fatal) {
1379 			fatal++;
1380 			CH_ALERT(adapter, "%s (0x%x)\n",
1381 				 acts->msg, status & acts->mask);
1382 			status &= ~acts->mask;
1383 		} else if (acts->msg)
1384 			CH_WARN(adapter, "%s (0x%x)\n",
1385 				acts->msg, status & acts->mask);
1386 		if (acts->stat_idx >= 0)
1387 			stats[acts->stat_idx]++;
1388 	}
1389 	if (status)		/* clear processed interrupts */
1390 		t3_write_reg(adapter, reg, status);
1391 	return fatal;
1392 }
1393 
1394 #define SGE_INTR_MASK (F_RSPQDISABLED | \
1395 		       F_UC_REQ_FRAMINGERROR | F_R_REQ_FRAMINGERROR | \
1396 		       F_CPPARITYERROR | F_OCPARITYERROR | F_RCPARITYERROR | \
1397 		       F_IRPARITYERROR | V_ITPARITYERROR(M_ITPARITYERROR) | \
1398 		       V_FLPARITYERROR(M_FLPARITYERROR) | F_LODRBPARITYERROR | \
1399 		       F_HIDRBPARITYERROR | F_LORCQPARITYERROR | \
1400 		       F_HIRCQPARITYERROR | F_LOPRIORITYDBFULL | \
1401 		       F_HIPRIORITYDBFULL | F_LOPRIORITYDBEMPTY | \
1402 		       F_HIPRIORITYDBEMPTY | F_HIPIODRBDROPERR | \
1403 		       F_LOPIODRBDROPERR)
1404 #define MC5_INTR_MASK (F_PARITYERR | F_ACTRGNFULL | F_UNKNOWNCMD | \
1405 		       F_REQQPARERR | F_DISPQPARERR | F_DELACTEMPTY | \
1406 		       F_NFASRCHFAIL)
1407 #define MC7_INTR_MASK (F_AE | F_UE | F_CE | V_PE(M_PE))
1408 #define XGM_INTR_MASK (V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR) | \
1409 		       V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR) | \
1410 		       F_TXFIFO_UNDERRUN)
1411 #define PCIX_INTR_MASK (F_MSTDETPARERR | F_SIGTARABT | F_RCVTARABT | \
1412 			F_RCVMSTABT | F_SIGSYSERR | F_DETPARERR | \
1413 			F_SPLCMPDIS | F_UNXSPLCMP | F_RCVSPLCMPERR | \
1414 			F_DETCORECCERR | F_DETUNCECCERR | F_PIOPARERR | \
1415 			V_WFPARERR(M_WFPARERR) | V_RFPARERR(M_RFPARERR) | \
1416 			V_CFPARERR(M_CFPARERR) /* | V_MSIXPARERR(M_MSIXPARERR) */)
1417 #define PCIE_INTR_MASK (F_UNXSPLCPLERRR | F_UNXSPLCPLERRC | F_PCIE_PIOPARERR |\
1418 			F_PCIE_WFPARERR | F_PCIE_RFPARERR | F_PCIE_CFPARERR | \
1419 			/* V_PCIE_MSIXPARERR(M_PCIE_MSIXPARERR) | */ \
1420 			F_RETRYBUFPARERR | F_RETRYLUTPARERR | F_RXPARERR | \
1421 			F_TXPARERR | V_BISTERR(M_BISTERR))
1422 #define ULPRX_INTR_MASK (F_PARERRDATA | F_PARERRPCMD | F_ARBPF1PERR | \
1423 			 F_ARBPF0PERR | F_ARBFPERR | F_PCMDMUXPERR | \
1424 			 F_DATASELFRAMEERR1 | F_DATASELFRAMEERR0)
1425 #define ULPTX_INTR_MASK 0xfc
1426 #define CPLSW_INTR_MASK (F_CIM_OP_MAP_PERR | F_TP_FRAMING_ERROR | \
1427 			 F_SGE_FRAMING_ERROR | F_CIM_FRAMING_ERROR | \
1428 			 F_ZERO_SWITCH_ERROR)
1429 #define CIM_INTR_MASK (F_BLKWRPLINT | F_BLKRDPLINT | F_BLKWRCTLINT | \
1430 		       F_BLKRDCTLINT | F_BLKWRFLASHINT | F_BLKRDFLASHINT | \
1431 		       F_SGLWRFLASHINT | F_WRBLKFLASHINT | F_BLKWRBOOTINT | \
1432 	 	       F_FLASHRANGEINT | F_SDRAMRANGEINT | F_RSVDSPACEINT | \
1433 		       F_DRAMPARERR | F_ICACHEPARERR | F_DCACHEPARERR | \
1434 		       F_OBQSGEPARERR | F_OBQULPHIPARERR | F_OBQULPLOPARERR | \
1435 		       F_IBQSGELOPARERR | F_IBQSGEHIPARERR | F_IBQULPPARERR | \
1436 		       F_IBQTPPARERR | F_ITAGPARERR | F_DTAGPARERR)
1437 #define PMTX_INTR_MASK (F_ZERO_C_CMD_ERROR | ICSPI_FRM_ERR | OESPI_FRM_ERR | \
1438 			V_ICSPI_PAR_ERROR(M_ICSPI_PAR_ERROR) | \
1439 			V_OESPI_PAR_ERROR(M_OESPI_PAR_ERROR))
1440 #define PMRX_INTR_MASK (F_ZERO_E_CMD_ERROR | IESPI_FRM_ERR | OCSPI_FRM_ERR | \
1441 			V_IESPI_PAR_ERROR(M_IESPI_PAR_ERROR) | \
1442 			V_OCSPI_PAR_ERROR(M_OCSPI_PAR_ERROR))
1443 #define MPS_INTR_MASK (V_TX0TPPARERRENB(M_TX0TPPARERRENB) | \
1444 		       V_TX1TPPARERRENB(M_TX1TPPARERRENB) | \
1445 		       V_RXTPPARERRENB(M_RXTPPARERRENB) | \
1446 		       V_MCAPARERRENB(M_MCAPARERRENB))
1447 #define XGM_EXTRA_INTR_MASK (F_LINKFAULTCHANGE)
1448 #define PL_INTR_MASK (F_T3DBG | F_XGMAC0_0 | F_XGMAC0_1 | F_MC5A | F_PM1_TX | \
1449 		      F_PM1_RX | F_ULP2_TX | F_ULP2_RX | F_TP1 | F_CIM | \
1450 		      F_MC7_CM | F_MC7_PMTX | F_MC7_PMRX | F_SGE3 | F_PCIM0 | \
1451 		      F_MPS0 | F_CPL_SWITCH)
1452 /*
1453  * Interrupt handler for the PCIX1 module.
1454  */
1455 static void pci_intr_handler(struct adapter *adapter)
1456 {
1457 	static const struct intr_info pcix1_intr_info[] = {
1458 		{F_MSTDETPARERR, "PCI master detected parity error", -1, 1},
1459 		{F_SIGTARABT, "PCI signaled target abort", -1, 1},
1460 		{F_RCVTARABT, "PCI received target abort", -1, 1},
1461 		{F_RCVMSTABT, "PCI received master abort", -1, 1},
1462 		{F_SIGSYSERR, "PCI signaled system error", -1, 1},
1463 		{F_DETPARERR, "PCI detected parity error", -1, 1},
1464 		{F_SPLCMPDIS, "PCI split completion discarded", -1, 1},
1465 		{F_UNXSPLCMP, "PCI unexpected split completion error", -1, 1},
1466 		{F_RCVSPLCMPERR, "PCI received split completion error", -1,
1467 		 1},
1468 		{F_DETCORECCERR, "PCI correctable ECC error",
1469 		 STAT_PCI_CORR_ECC, 0},
1470 		{F_DETUNCECCERR, "PCI uncorrectable ECC error", -1, 1},
1471 		{F_PIOPARERR, "PCI PIO FIFO parity error", -1, 1},
1472 		{V_WFPARERR(M_WFPARERR), "PCI write FIFO parity error", -1,
1473 		 1},
1474 		{V_RFPARERR(M_RFPARERR), "PCI read FIFO parity error", -1,
1475 		 1},
1476 		{V_CFPARERR(M_CFPARERR), "PCI command FIFO parity error", -1,
1477 		 1},
1478 		{V_MSIXPARERR(M_MSIXPARERR), "PCI MSI-X table/PBA parity "
1479 		 "error", -1, 1},
1480 		{0}
1481 	};
1482 
1483 	if (t3_handle_intr_status(adapter, A_PCIX_INT_CAUSE, PCIX_INTR_MASK,
1484 				  pcix1_intr_info, adapter->irq_stats))
1485 		t3_fatal_err(adapter);
1486 }
1487 
1488 /*
1489  * Interrupt handler for the PCIE module.
1490  */
1491 static void pcie_intr_handler(struct adapter *adapter)
1492 {
1493 	static const struct intr_info pcie_intr_info[] = {
1494 		{F_PEXERR, "PCI PEX error", -1, 1},
1495 		{F_UNXSPLCPLERRR,
1496 		 "PCI unexpected split completion DMA read error", -1, 1},
1497 		{F_UNXSPLCPLERRC,
1498 		 "PCI unexpected split completion DMA command error", -1, 1},
1499 		{F_PCIE_PIOPARERR, "PCI PIO FIFO parity error", -1, 1},
1500 		{F_PCIE_WFPARERR, "PCI write FIFO parity error", -1, 1},
1501 		{F_PCIE_RFPARERR, "PCI read FIFO parity error", -1, 1},
1502 		{F_PCIE_CFPARERR, "PCI command FIFO parity error", -1, 1},
1503 		{V_PCIE_MSIXPARERR(M_PCIE_MSIXPARERR),
1504 		 "PCI MSI-X table/PBA parity error", -1, 1},
1505 		{F_RETRYBUFPARERR, "PCI retry buffer parity error", -1, 1},
1506 		{F_RETRYLUTPARERR, "PCI retry LUT parity error", -1, 1},
1507 		{F_RXPARERR, "PCI Rx parity error", -1, 1},
1508 		{F_TXPARERR, "PCI Tx parity error", -1, 1},
1509 		{V_BISTERR(M_BISTERR), "PCI BIST error", -1, 1},
1510 		{0}
1511 	};
1512 
1513 	if (t3_read_reg(adapter, A_PCIE_INT_CAUSE) & F_PEXERR)
1514 		CH_ALERT(adapter, "PEX error code 0x%x\n",
1515 			 t3_read_reg(adapter, A_PCIE_PEX_ERR));
1516 
1517 	if (t3_handle_intr_status(adapter, A_PCIE_INT_CAUSE, PCIE_INTR_MASK,
1518 				  pcie_intr_info, adapter->irq_stats))
1519 		t3_fatal_err(adapter);
1520 }
1521 
1522 /*
1523  * TP interrupt handler.
1524  */
1525 static void tp_intr_handler(struct adapter *adapter)
1526 {
1527 	static const struct intr_info tp_intr_info[] = {
1528 		{0xffffff, "TP parity error", -1, 1},
1529 		{0x1000000, "TP out of Rx pages", -1, 1},
1530 		{0x2000000, "TP out of Tx pages", -1, 1},
1531 		{0}
1532 	};
1533 
1534 	static const struct intr_info tp_intr_info_t3c[] = {
1535 		{0x1fffffff, "TP parity error", -1, 1},
1536 		{F_FLMRXFLSTEMPTY, "TP out of Rx pages", -1, 1},
1537 		{F_FLMTXFLSTEMPTY, "TP out of Tx pages", -1, 1},
1538 		{0}
1539 	};
1540 
1541 	if (t3_handle_intr_status(adapter, A_TP_INT_CAUSE, 0xffffffff,
1542 				  adapter->params.rev < T3_REV_C ?
1543 				  tp_intr_info : tp_intr_info_t3c, NULL))
1544 		t3_fatal_err(adapter);
1545 }
1546 
1547 /*
1548  * CIM interrupt handler.
1549  */
1550 static void cim_intr_handler(struct adapter *adapter)
1551 {
1552 	static const struct intr_info cim_intr_info[] = {
1553 		{F_RSVDSPACEINT, "CIM reserved space write", -1, 1},
1554 		{F_SDRAMRANGEINT, "CIM SDRAM address out of range", -1, 1},
1555 		{F_FLASHRANGEINT, "CIM flash address out of range", -1, 1},
1556 		{F_BLKWRBOOTINT, "CIM block write to boot space", -1, 1},
1557 		{F_WRBLKFLASHINT, "CIM write to cached flash space", -1, 1},
1558 		{F_SGLWRFLASHINT, "CIM single write to flash space", -1, 1},
1559 		{F_BLKRDFLASHINT, "CIM block read from flash space", -1, 1},
1560 		{F_BLKWRFLASHINT, "CIM block write to flash space", -1, 1},
1561 		{F_BLKRDCTLINT, "CIM block read from CTL space", -1, 1},
1562 		{F_BLKWRCTLINT, "CIM block write to CTL space", -1, 1},
1563 		{F_BLKRDPLINT, "CIM block read from PL space", -1, 1},
1564 		{F_BLKWRPLINT, "CIM block write to PL space", -1, 1},
1565 		{F_DRAMPARERR, "CIM DRAM parity error", -1, 1},
1566 		{F_ICACHEPARERR, "CIM icache parity error", -1, 1},
1567 		{F_DCACHEPARERR, "CIM dcache parity error", -1, 1},
1568 		{F_OBQSGEPARERR, "CIM OBQ SGE parity error", -1, 1},
1569 		{F_OBQULPHIPARERR, "CIM OBQ ULPHI parity error", -1, 1},
1570 		{F_OBQULPLOPARERR, "CIM OBQ ULPLO parity error", -1, 1},
1571 		{F_IBQSGELOPARERR, "CIM IBQ SGELO parity error", -1, 1},
1572 		{F_IBQSGEHIPARERR, "CIM IBQ SGEHI parity error", -1, 1},
1573 		{F_IBQULPPARERR, "CIM IBQ ULP parity error", -1, 1},
1574 		{F_IBQTPPARERR, "CIM IBQ TP parity error", -1, 1},
1575 		{F_ITAGPARERR, "CIM itag parity error", -1, 1},
1576 		{F_DTAGPARERR, "CIM dtag parity error", -1, 1},
1577 		{0}
1578 	};
1579 
1580 	if (t3_handle_intr_status(adapter, A_CIM_HOST_INT_CAUSE, 0xffffffff,
1581 				  cim_intr_info, NULL))
1582 		t3_fatal_err(adapter);
1583 }
1584 
1585 /*
1586  * ULP RX interrupt handler.
1587  */
1588 static void ulprx_intr_handler(struct adapter *adapter)
1589 {
1590 	static const struct intr_info ulprx_intr_info[] = {
1591 		{F_PARERRDATA, "ULP RX data parity error", -1, 1},
1592 		{F_PARERRPCMD, "ULP RX command parity error", -1, 1},
1593 		{F_ARBPF1PERR, "ULP RX ArbPF1 parity error", -1, 1},
1594 		{F_ARBPF0PERR, "ULP RX ArbPF0 parity error", -1, 1},
1595 		{F_ARBFPERR, "ULP RX ArbF parity error", -1, 1},
1596 		{F_PCMDMUXPERR, "ULP RX PCMDMUX parity error", -1, 1},
1597 		{F_DATASELFRAMEERR1, "ULP RX frame error", -1, 1},
1598 		{F_DATASELFRAMEERR0, "ULP RX frame error", -1, 1},
1599 		{0}
1600 	};
1601 
1602 	if (t3_handle_intr_status(adapter, A_ULPRX_INT_CAUSE, 0xffffffff,
1603 				  ulprx_intr_info, NULL))
1604 		t3_fatal_err(adapter);
1605 }
1606 
1607 /*
1608  * ULP TX interrupt handler.
1609  */
1610 static void ulptx_intr_handler(struct adapter *adapter)
1611 {
1612 	static const struct intr_info ulptx_intr_info[] = {
1613 		{F_PBL_BOUND_ERR_CH0, "ULP TX channel 0 PBL out of bounds",
1614 		 STAT_ULP_CH0_PBL_OOB, 0},
1615 		{F_PBL_BOUND_ERR_CH1, "ULP TX channel 1 PBL out of bounds",
1616 		 STAT_ULP_CH1_PBL_OOB, 0},
1617 		{0xfc, "ULP TX parity error", -1, 1},
1618 		{0}
1619 	};
1620 
1621 	if (t3_handle_intr_status(adapter, A_ULPTX_INT_CAUSE, 0xffffffff,
1622 				  ulptx_intr_info, adapter->irq_stats))
1623 		t3_fatal_err(adapter);
1624 }
1625 
1626 #define ICSPI_FRM_ERR (F_ICSPI0_FIFO2X_RX_FRAMING_ERROR | \
1627 	F_ICSPI1_FIFO2X_RX_FRAMING_ERROR | F_ICSPI0_RX_FRAMING_ERROR | \
1628 	F_ICSPI1_RX_FRAMING_ERROR | F_ICSPI0_TX_FRAMING_ERROR | \
1629 	F_ICSPI1_TX_FRAMING_ERROR)
1630 #define OESPI_FRM_ERR (F_OESPI0_RX_FRAMING_ERROR | \
1631 	F_OESPI1_RX_FRAMING_ERROR | F_OESPI0_TX_FRAMING_ERROR | \
1632 	F_OESPI1_TX_FRAMING_ERROR | F_OESPI0_OFIFO2X_TX_FRAMING_ERROR | \
1633 	F_OESPI1_OFIFO2X_TX_FRAMING_ERROR)
1634 
1635 /*
1636  * PM TX interrupt handler.
1637  */
1638 static void pmtx_intr_handler(struct adapter *adapter)
1639 {
1640 	static const struct intr_info pmtx_intr_info[] = {
1641 		{F_ZERO_C_CMD_ERROR, "PMTX 0-length pcmd", -1, 1},
1642 		{ICSPI_FRM_ERR, "PMTX ispi framing error", -1, 1},
1643 		{OESPI_FRM_ERR, "PMTX ospi framing error", -1, 1},
1644 		{V_ICSPI_PAR_ERROR(M_ICSPI_PAR_ERROR),
1645 		 "PMTX ispi parity error", -1, 1},
1646 		{V_OESPI_PAR_ERROR(M_OESPI_PAR_ERROR),
1647 		 "PMTX ospi parity error", -1, 1},
1648 		{0}
1649 	};
1650 
1651 	if (t3_handle_intr_status(adapter, A_PM1_TX_INT_CAUSE, 0xffffffff,
1652 				  pmtx_intr_info, NULL))
1653 		t3_fatal_err(adapter);
1654 }
1655 
1656 #define IESPI_FRM_ERR (F_IESPI0_FIFO2X_RX_FRAMING_ERROR | \
1657 	F_IESPI1_FIFO2X_RX_FRAMING_ERROR | F_IESPI0_RX_FRAMING_ERROR | \
1658 	F_IESPI1_RX_FRAMING_ERROR | F_IESPI0_TX_FRAMING_ERROR | \
1659 	F_IESPI1_TX_FRAMING_ERROR)
1660 #define OCSPI_FRM_ERR (F_OCSPI0_RX_FRAMING_ERROR | \
1661 	F_OCSPI1_RX_FRAMING_ERROR | F_OCSPI0_TX_FRAMING_ERROR | \
1662 	F_OCSPI1_TX_FRAMING_ERROR | F_OCSPI0_OFIFO2X_TX_FRAMING_ERROR | \
1663 	F_OCSPI1_OFIFO2X_TX_FRAMING_ERROR)
1664 
1665 /*
1666  * PM RX interrupt handler.
1667  */
1668 static void pmrx_intr_handler(struct adapter *adapter)
1669 {
1670 	static const struct intr_info pmrx_intr_info[] = {
1671 		{F_ZERO_E_CMD_ERROR, "PMRX 0-length pcmd", -1, 1},
1672 		{IESPI_FRM_ERR, "PMRX ispi framing error", -1, 1},
1673 		{OCSPI_FRM_ERR, "PMRX ospi framing error", -1, 1},
1674 		{V_IESPI_PAR_ERROR(M_IESPI_PAR_ERROR),
1675 		 "PMRX ispi parity error", -1, 1},
1676 		{V_OCSPI_PAR_ERROR(M_OCSPI_PAR_ERROR),
1677 		 "PMRX ospi parity error", -1, 1},
1678 		{0}
1679 	};
1680 
1681 	if (t3_handle_intr_status(adapter, A_PM1_RX_INT_CAUSE, 0xffffffff,
1682 				  pmrx_intr_info, NULL))
1683 		t3_fatal_err(adapter);
1684 }
1685 
1686 /*
1687  * CPL switch interrupt handler.
1688  */
1689 static void cplsw_intr_handler(struct adapter *adapter)
1690 {
1691 	static const struct intr_info cplsw_intr_info[] = {
1692 		{F_CIM_OP_MAP_PERR, "CPL switch CIM parity error", -1, 1},
1693 		{F_CIM_OVFL_ERROR, "CPL switch CIM overflow", -1, 1},
1694 		{F_TP_FRAMING_ERROR, "CPL switch TP framing error", -1, 1},
1695 		{F_SGE_FRAMING_ERROR, "CPL switch SGE framing error", -1, 1},
1696 		{F_CIM_FRAMING_ERROR, "CPL switch CIM framing error", -1, 1},
1697 		{F_ZERO_SWITCH_ERROR, "CPL switch no-switch error", -1, 1},
1698 		{0}
1699 	};
1700 
1701 	if (t3_handle_intr_status(adapter, A_CPL_INTR_CAUSE, 0xffffffff,
1702 				  cplsw_intr_info, NULL))
1703 		t3_fatal_err(adapter);
1704 }
1705 
1706 /*
1707  * MPS interrupt handler.
1708  */
1709 static void mps_intr_handler(struct adapter *adapter)
1710 {
1711 	static const struct intr_info mps_intr_info[] = {
1712 		{0x1ff, "MPS parity error", -1, 1},
1713 		{0}
1714 	};
1715 
1716 	if (t3_handle_intr_status(adapter, A_MPS_INT_CAUSE, 0xffffffff,
1717 				  mps_intr_info, NULL))
1718 		t3_fatal_err(adapter);
1719 }
1720 
1721 #define MC7_INTR_FATAL (F_UE | V_PE(M_PE) | F_AE)
1722 
1723 /*
1724  * MC7 interrupt handler.
1725  */
1726 static void mc7_intr_handler(struct mc7 *mc7)
1727 {
1728 	struct adapter *adapter = mc7->adapter;
1729 	u32 cause = t3_read_reg(adapter, mc7->offset + A_MC7_INT_CAUSE);
1730 
1731 	if (cause & F_CE) {
1732 		mc7->stats.corr_err++;
1733 		CH_WARN(adapter, "%s MC7 correctable error at addr 0x%x, "
1734 			"data 0x%x 0x%x 0x%x\n", mc7->name,
1735 			t3_read_reg(adapter, mc7->offset + A_MC7_CE_ADDR),
1736 			t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA0),
1737 			t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA1),
1738 			t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA2));
1739 	}
1740 
1741 	if (cause & F_UE) {
1742 		mc7->stats.uncorr_err++;
1743 		CH_ALERT(adapter, "%s MC7 uncorrectable error at addr 0x%x, "
1744 			 "data 0x%x 0x%x 0x%x\n", mc7->name,
1745 			 t3_read_reg(adapter, mc7->offset + A_MC7_UE_ADDR),
1746 			 t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA0),
1747 			 t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA1),
1748 			 t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA2));
1749 	}
1750 
1751 	if (G_PE(cause)) {
1752 		mc7->stats.parity_err++;
1753 		CH_ALERT(adapter, "%s MC7 parity error 0x%x\n",
1754 			 mc7->name, G_PE(cause));
1755 	}
1756 
1757 	if (cause & F_AE) {
1758 		u32 addr = 0;
1759 
1760 		if (adapter->params.rev > 0)
1761 			addr = t3_read_reg(adapter,
1762 					   mc7->offset + A_MC7_ERR_ADDR);
1763 		mc7->stats.addr_err++;
1764 		CH_ALERT(adapter, "%s MC7 address error: 0x%x\n",
1765 			 mc7->name, addr);
1766 	}
1767 
1768 	if (cause & MC7_INTR_FATAL)
1769 		t3_fatal_err(adapter);
1770 
1771 	t3_write_reg(adapter, mc7->offset + A_MC7_INT_CAUSE, cause);
1772 }
1773 
1774 #define XGM_INTR_FATAL (V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR) | \
1775 			V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR))
1776 /*
1777  * XGMAC interrupt handler.
1778  */
1779 static int mac_intr_handler(struct adapter *adap, unsigned int idx)
1780 {
1781 	struct cmac *mac = &adap2pinfo(adap, idx)->mac;
1782 	/*
1783 	 * We mask out interrupt causes for which we're not taking interrupts.
1784 	 * This allows us to use polling logic to monitor some of the other
1785 	 * conditions when taking interrupts would impose too much load on the
1786 	 * system.
1787 	 */
1788 	u32 cause = t3_read_reg(adap, A_XGM_INT_CAUSE + mac->offset) &
1789 		    ~F_RXFIFO_OVERFLOW;
1790 
1791 	if (cause & V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR)) {
1792 		mac->stats.tx_fifo_parity_err++;
1793 		CH_ALERT(adap, "port%d: MAC TX FIFO parity error\n", idx);
1794 	}
1795 	if (cause & V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR)) {
1796 		mac->stats.rx_fifo_parity_err++;
1797 		CH_ALERT(adap, "port%d: MAC RX FIFO parity error\n", idx);
1798 	}
1799 	if (cause & F_TXFIFO_UNDERRUN)
1800 		mac->stats.tx_fifo_urun++;
1801 	if (cause & F_RXFIFO_OVERFLOW)
1802 		mac->stats.rx_fifo_ovfl++;
1803 	if (cause & V_SERDES_LOS(M_SERDES_LOS))
1804 		mac->stats.serdes_signal_loss++;
1805 	if (cause & F_XAUIPCSCTCERR)
1806 		mac->stats.xaui_pcs_ctc_err++;
1807 	if (cause & F_XAUIPCSALIGNCHANGE)
1808 		mac->stats.xaui_pcs_align_change++;
1809 	if (cause & F_XGM_INT) {
1810 		t3_set_reg_field(adap,
1811 				 A_XGM_INT_ENABLE + mac->offset,
1812 				 F_XGM_INT, 0);
1813 		mac->stats.link_faults++;
1814 
1815 		t3_os_link_fault_handler(adap, idx);
1816 	}
1817 
1818 	if (cause & XGM_INTR_FATAL)
1819 		t3_fatal_err(adap);
1820 
1821 	t3_write_reg(adap, A_XGM_INT_CAUSE + mac->offset, cause);
1822 	return cause != 0;
1823 }
1824 
1825 /*
1826  * Interrupt handler for PHY events.
1827  */
1828 int t3_phy_intr_handler(struct adapter *adapter)
1829 {
1830 	u32 i, cause = t3_read_reg(adapter, A_T3DBG_INT_CAUSE);
1831 
1832 	for_each_port(adapter, i) {
1833 		struct port_info *p = adap2pinfo(adapter, i);
1834 
1835 		if (!(p->phy.caps & SUPPORTED_IRQ))
1836 			continue;
1837 
1838 		if (cause & (1 << adapter_info(adapter)->gpio_intr[i])) {
1839 			int phy_cause = p->phy.ops->intr_handler(&p->phy);
1840 
1841 			if (phy_cause & cphy_cause_link_change)
1842 				t3_link_changed(adapter, i);
1843 			if (phy_cause & cphy_cause_fifo_error)
1844 				p->phy.fifo_errors++;
1845 			if (phy_cause & cphy_cause_module_change)
1846 				t3_os_phymod_changed(adapter, i);
1847 		}
1848 	}
1849 
1850 	t3_write_reg(adapter, A_T3DBG_INT_CAUSE, cause);
1851 	return 0;
1852 }
1853 
1854 /*
1855  * T3 slow path (non-data) interrupt handler.
1856  */
1857 int t3_slow_intr_handler(struct adapter *adapter)
1858 {
1859 	u32 cause = t3_read_reg(adapter, A_PL_INT_CAUSE0);
1860 
1861 	cause &= adapter->slow_intr_mask;
1862 	if (!cause)
1863 		return 0;
1864 	if (cause & F_PCIM0) {
1865 		if (is_pcie(adapter))
1866 			pcie_intr_handler(adapter);
1867 		else
1868 			pci_intr_handler(adapter);
1869 	}
1870 	if (cause & F_SGE3)
1871 		t3_sge_err_intr_handler(adapter);
1872 	if (cause & F_MC7_PMRX)
1873 		mc7_intr_handler(&adapter->pmrx);
1874 	if (cause & F_MC7_PMTX)
1875 		mc7_intr_handler(&adapter->pmtx);
1876 	if (cause & F_MC7_CM)
1877 		mc7_intr_handler(&adapter->cm);
1878 	if (cause & F_CIM)
1879 		cim_intr_handler(adapter);
1880 	if (cause & F_TP1)
1881 		tp_intr_handler(adapter);
1882 	if (cause & F_ULP2_RX)
1883 		ulprx_intr_handler(adapter);
1884 	if (cause & F_ULP2_TX)
1885 		ulptx_intr_handler(adapter);
1886 	if (cause & F_PM1_RX)
1887 		pmrx_intr_handler(adapter);
1888 	if (cause & F_PM1_TX)
1889 		pmtx_intr_handler(adapter);
1890 	if (cause & F_CPL_SWITCH)
1891 		cplsw_intr_handler(adapter);
1892 	if (cause & F_MPS0)
1893 		mps_intr_handler(adapter);
1894 	if (cause & F_MC5A)
1895 		t3_mc5_intr_handler(&adapter->mc5);
1896 	if (cause & F_XGMAC0_0)
1897 		mac_intr_handler(adapter, 0);
1898 	if (cause & F_XGMAC0_1)
1899 		mac_intr_handler(adapter, 1);
1900 	if (cause & F_T3DBG)
1901 		t3_os_ext_intr_handler(adapter);
1902 
1903 	/* Clear the interrupts just processed. */
1904 	t3_write_reg(adapter, A_PL_INT_CAUSE0, cause);
1905 	t3_read_reg(adapter, A_PL_INT_CAUSE0);	/* flush */
1906 	return 1;
1907 }
1908 
1909 static unsigned int calc_gpio_intr(struct adapter *adap)
1910 {
1911 	unsigned int i, gpi_intr = 0;
1912 
1913 	for_each_port(adap, i)
1914 		if ((adap2pinfo(adap, i)->phy.caps & SUPPORTED_IRQ) &&
1915 		    adapter_info(adap)->gpio_intr[i])
1916 			gpi_intr |= 1 << adapter_info(adap)->gpio_intr[i];
1917 	return gpi_intr;
1918 }
1919 
1920 /**
1921  *	t3_intr_enable - enable interrupts
1922  *	@adapter: the adapter whose interrupts should be enabled
1923  *
1924  *	Enable interrupts by setting the interrupt enable registers of the
1925  *	various HW modules and then enabling the top-level interrupt
1926  *	concentrator.
1927  */
1928 void t3_intr_enable(struct adapter *adapter)
1929 {
1930 	static const struct addr_val_pair intr_en_avp[] = {
1931 		{A_SG_INT_ENABLE, SGE_INTR_MASK},
1932 		{A_MC7_INT_ENABLE, MC7_INTR_MASK},
1933 		{A_MC7_INT_ENABLE - MC7_PMRX_BASE_ADDR + MC7_PMTX_BASE_ADDR,
1934 		 MC7_INTR_MASK},
1935 		{A_MC7_INT_ENABLE - MC7_PMRX_BASE_ADDR + MC7_CM_BASE_ADDR,
1936 		 MC7_INTR_MASK},
1937 		{A_MC5_DB_INT_ENABLE, MC5_INTR_MASK},
1938 		{A_ULPRX_INT_ENABLE, ULPRX_INTR_MASK},
1939 		{A_PM1_TX_INT_ENABLE, PMTX_INTR_MASK},
1940 		{A_PM1_RX_INT_ENABLE, PMRX_INTR_MASK},
1941 		{A_CIM_HOST_INT_ENABLE, CIM_INTR_MASK},
1942 		{A_MPS_INT_ENABLE, MPS_INTR_MASK},
1943 	};
1944 
1945 	adapter->slow_intr_mask = PL_INTR_MASK;
1946 
1947 	t3_write_regs(adapter, intr_en_avp, ARRAY_SIZE(intr_en_avp), 0);
1948 	t3_write_reg(adapter, A_TP_INT_ENABLE,
1949 		     adapter->params.rev >= T3_REV_C ? 0x2bfffff : 0x3bfffff);
1950 
1951 	if (adapter->params.rev > 0) {
1952 		t3_write_reg(adapter, A_CPL_INTR_ENABLE,
1953 			     CPLSW_INTR_MASK | F_CIM_OVFL_ERROR);
1954 		t3_write_reg(adapter, A_ULPTX_INT_ENABLE,
1955 			     ULPTX_INTR_MASK | F_PBL_BOUND_ERR_CH0 |
1956 			     F_PBL_BOUND_ERR_CH1);
1957 	} else {
1958 		t3_write_reg(adapter, A_CPL_INTR_ENABLE, CPLSW_INTR_MASK);
1959 		t3_write_reg(adapter, A_ULPTX_INT_ENABLE, ULPTX_INTR_MASK);
1960 	}
1961 
1962 	t3_write_reg(adapter, A_T3DBG_INT_ENABLE, calc_gpio_intr(adapter));
1963 
1964 	if (is_pcie(adapter))
1965 		t3_write_reg(adapter, A_PCIE_INT_ENABLE, PCIE_INTR_MASK);
1966 	else
1967 		t3_write_reg(adapter, A_PCIX_INT_ENABLE, PCIX_INTR_MASK);
1968 	t3_write_reg(adapter, A_PL_INT_ENABLE0, adapter->slow_intr_mask);
1969 	t3_read_reg(adapter, A_PL_INT_ENABLE0);	/* flush */
1970 }
1971 
1972 /**
1973  *	t3_intr_disable - disable a card's interrupts
1974  *	@adapter: the adapter whose interrupts should be disabled
1975  *
1976  *	Disable interrupts.  We only disable the top-level interrupt
1977  *	concentrator and the SGE data interrupts.
1978  */
1979 void t3_intr_disable(struct adapter *adapter)
1980 {
1981 	t3_write_reg(adapter, A_PL_INT_ENABLE0, 0);
1982 	t3_read_reg(adapter, A_PL_INT_ENABLE0);	/* flush */
1983 	adapter->slow_intr_mask = 0;
1984 }
1985 
1986 /**
1987  *	t3_intr_clear - clear all interrupts
1988  *	@adapter: the adapter whose interrupts should be cleared
1989  *
1990  *	Clears all interrupts.
1991  */
1992 void t3_intr_clear(struct adapter *adapter)
1993 {
1994 	static const unsigned int cause_reg_addr[] = {
1995 		A_SG_INT_CAUSE,
1996 		A_SG_RSPQ_FL_STATUS,
1997 		A_PCIX_INT_CAUSE,
1998 		A_MC7_INT_CAUSE,
1999 		A_MC7_INT_CAUSE - MC7_PMRX_BASE_ADDR + MC7_PMTX_BASE_ADDR,
2000 		A_MC7_INT_CAUSE - MC7_PMRX_BASE_ADDR + MC7_CM_BASE_ADDR,
2001 		A_CIM_HOST_INT_CAUSE,
2002 		A_TP_INT_CAUSE,
2003 		A_MC5_DB_INT_CAUSE,
2004 		A_ULPRX_INT_CAUSE,
2005 		A_ULPTX_INT_CAUSE,
2006 		A_CPL_INTR_CAUSE,
2007 		A_PM1_TX_INT_CAUSE,
2008 		A_PM1_RX_INT_CAUSE,
2009 		A_MPS_INT_CAUSE,
2010 		A_T3DBG_INT_CAUSE,
2011 	};
2012 	unsigned int i;
2013 
2014 	/* Clear PHY and MAC interrupts for each port. */
2015 	for_each_port(adapter, i)
2016 	    t3_port_intr_clear(adapter, i);
2017 
2018 	for (i = 0; i < ARRAY_SIZE(cause_reg_addr); ++i)
2019 		t3_write_reg(adapter, cause_reg_addr[i], 0xffffffff);
2020 
2021 	if (is_pcie(adapter))
2022 		t3_write_reg(adapter, A_PCIE_PEX_ERR, 0xffffffff);
2023 	t3_write_reg(adapter, A_PL_INT_CAUSE0, 0xffffffff);
2024 	t3_read_reg(adapter, A_PL_INT_CAUSE0);	/* flush */
2025 }
2026 
2027 void t3_xgm_intr_enable(struct adapter *adapter, int idx)
2028 {
2029 	struct port_info *pi = adap2pinfo(adapter, idx);
2030 
2031 	t3_write_reg(adapter, A_XGM_XGM_INT_ENABLE + pi->mac.offset,
2032 		     XGM_EXTRA_INTR_MASK);
2033 }
2034 
2035 void t3_xgm_intr_disable(struct adapter *adapter, int idx)
2036 {
2037 	struct port_info *pi = adap2pinfo(adapter, idx);
2038 
2039 	t3_write_reg(adapter, A_XGM_XGM_INT_DISABLE + pi->mac.offset,
2040 		     0x7ff);
2041 }
2042 
2043 /**
2044  *	t3_port_intr_enable - enable port-specific interrupts
2045  *	@adapter: associated adapter
2046  *	@idx: index of port whose interrupts should be enabled
2047  *
2048  *	Enable port-specific (i.e., MAC and PHY) interrupts for the given
2049  *	adapter port.
2050  */
2051 void t3_port_intr_enable(struct adapter *adapter, int idx)
2052 {
2053 	struct cphy *phy = &adap2pinfo(adapter, idx)->phy;
2054 
2055 	t3_write_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx), XGM_INTR_MASK);
2056 	t3_read_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx)); /* flush */
2057 	phy->ops->intr_enable(phy);
2058 }
2059 
2060 /**
2061  *	t3_port_intr_disable - disable port-specific interrupts
2062  *	@adapter: associated adapter
2063  *	@idx: index of port whose interrupts should be disabled
2064  *
2065  *	Disable port-specific (i.e., MAC and PHY) interrupts for the given
2066  *	adapter port.
2067  */
2068 void t3_port_intr_disable(struct adapter *adapter, int idx)
2069 {
2070 	struct cphy *phy = &adap2pinfo(adapter, idx)->phy;
2071 
2072 	t3_write_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx), 0);
2073 	t3_read_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx)); /* flush */
2074 	phy->ops->intr_disable(phy);
2075 }
2076 
2077 /**
2078  *	t3_port_intr_clear - clear port-specific interrupts
2079  *	@adapter: associated adapter
2080  *	@idx: index of port whose interrupts to clear
2081  *
2082  *	Clear port-specific (i.e., MAC and PHY) interrupts for the given
2083  *	adapter port.
2084  */
2085 static void t3_port_intr_clear(struct adapter *adapter, int idx)
2086 {
2087 	struct cphy *phy = &adap2pinfo(adapter, idx)->phy;
2088 
2089 	t3_write_reg(adapter, XGM_REG(A_XGM_INT_CAUSE, idx), 0xffffffff);
2090 	t3_read_reg(adapter, XGM_REG(A_XGM_INT_CAUSE, idx)); /* flush */
2091 	phy->ops->intr_clear(phy);
2092 }
2093 
2094 #define SG_CONTEXT_CMD_ATTEMPTS 100
2095 
2096 /**
2097  * 	t3_sge_write_context - write an SGE context
2098  * 	@adapter: the adapter
2099  * 	@id: the context id
2100  * 	@type: the context type
2101  *
2102  * 	Program an SGE context with the values already loaded in the
2103  * 	CONTEXT_DATA? registers.
2104  */
2105 static int t3_sge_write_context(struct adapter *adapter, unsigned int id,
2106 				unsigned int type)
2107 {
2108 	if (type == F_RESPONSEQ) {
2109 		/*
2110 		 * Can't write the Response Queue Context bits for
2111 		 * Interrupt Armed or the Reserve bits after the chip
2112 		 * has been initialized out of reset.  Writing to these
2113 		 * bits can confuse the hardware.
2114 		 */
2115 		t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0xffffffff);
2116 		t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0xffffffff);
2117 		t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0x17ffffff);
2118 		t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0xffffffff);
2119 	} else {
2120 		t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0xffffffff);
2121 		t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0xffffffff);
2122 		t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0xffffffff);
2123 		t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0xffffffff);
2124 	}
2125 	t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2126 		     V_CONTEXT_CMD_OPCODE(1) | type | V_CONTEXT(id));
2127 	return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2128 			       0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2129 }
2130 
2131 /**
2132  *	clear_sge_ctxt - completely clear an SGE context
2133  *	@adap: the adapter
2134  *	@id: the context id
2135  *	@type: the context type
2136  *
2137  *	Completely clear an SGE context.  Used predominantly at post-reset
2138  *	initialization.  Note in particular that we don't skip writing to any
2139  *	"sensitive bits" in the contexts the way that t3_sge_write_context()
2140  *	does ...
2141  */
2142 static int clear_sge_ctxt(struct adapter *adap, unsigned int id,
2143 			  unsigned int type)
2144 {
2145 	t3_write_reg(adap, A_SG_CONTEXT_DATA0, 0);
2146 	t3_write_reg(adap, A_SG_CONTEXT_DATA1, 0);
2147 	t3_write_reg(adap, A_SG_CONTEXT_DATA2, 0);
2148 	t3_write_reg(adap, A_SG_CONTEXT_DATA3, 0);
2149 	t3_write_reg(adap, A_SG_CONTEXT_MASK0, 0xffffffff);
2150 	t3_write_reg(adap, A_SG_CONTEXT_MASK1, 0xffffffff);
2151 	t3_write_reg(adap, A_SG_CONTEXT_MASK2, 0xffffffff);
2152 	t3_write_reg(adap, A_SG_CONTEXT_MASK3, 0xffffffff);
2153 	t3_write_reg(adap, A_SG_CONTEXT_CMD,
2154 		     V_CONTEXT_CMD_OPCODE(1) | type | V_CONTEXT(id));
2155 	return t3_wait_op_done(adap, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2156 			       0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2157 }
2158 
2159 /**
2160  *	t3_sge_init_ecntxt - initialize an SGE egress context
2161  *	@adapter: the adapter to configure
2162  *	@id: the context id
2163  *	@gts_enable: whether to enable GTS for the context
2164  *	@type: the egress context type
2165  *	@respq: associated response queue
2166  *	@base_addr: base address of queue
2167  *	@size: number of queue entries
2168  *	@token: uP token
2169  *	@gen: initial generation value for the context
2170  *	@cidx: consumer pointer
2171  *
2172  *	Initialize an SGE egress context and make it ready for use.  If the
2173  *	platform allows concurrent context operations, the caller is
2174  *	responsible for appropriate locking.
2175  */
2176 int t3_sge_init_ecntxt(struct adapter *adapter, unsigned int id, int gts_enable,
2177 		       enum sge_context_type type, int respq, u64 base_addr,
2178 		       unsigned int size, unsigned int token, int gen,
2179 		       unsigned int cidx)
2180 {
2181 	unsigned int credits = type == SGE_CNTXT_OFLD ? 0 : FW_WR_NUM;
2182 
2183 	if (base_addr & 0xfff)	/* must be 4K aligned */
2184 		return -EINVAL;
2185 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2186 		return -EBUSY;
2187 
2188 	base_addr >>= 12;
2189 	t3_write_reg(adapter, A_SG_CONTEXT_DATA0, V_EC_INDEX(cidx) |
2190 		     V_EC_CREDITS(credits) | V_EC_GTS(gts_enable));
2191 	t3_write_reg(adapter, A_SG_CONTEXT_DATA1, V_EC_SIZE(size) |
2192 		     V_EC_BASE_LO(base_addr & 0xffff));
2193 	base_addr >>= 16;
2194 	t3_write_reg(adapter, A_SG_CONTEXT_DATA2, base_addr);
2195 	base_addr >>= 32;
2196 	t3_write_reg(adapter, A_SG_CONTEXT_DATA3,
2197 		     V_EC_BASE_HI(base_addr & 0xf) | V_EC_RESPQ(respq) |
2198 		     V_EC_TYPE(type) | V_EC_GEN(gen) | V_EC_UP_TOKEN(token) |
2199 		     F_EC_VALID);
2200 	return t3_sge_write_context(adapter, id, F_EGRESS);
2201 }
2202 
2203 /**
2204  *	t3_sge_init_flcntxt - initialize an SGE free-buffer list context
2205  *	@adapter: the adapter to configure
2206  *	@id: the context id
2207  *	@gts_enable: whether to enable GTS for the context
2208  *	@base_addr: base address of queue
2209  *	@size: number of queue entries
2210  *	@bsize: size of each buffer for this queue
2211  *	@cong_thres: threshold to signal congestion to upstream producers
2212  *	@gen: initial generation value for the context
2213  *	@cidx: consumer pointer
2214  *
2215  *	Initialize an SGE free list context and make it ready for use.  The
2216  *	caller is responsible for ensuring only one context operation occurs
2217  *	at a time.
2218  */
2219 int t3_sge_init_flcntxt(struct adapter *adapter, unsigned int id,
2220 			int gts_enable, u64 base_addr, unsigned int size,
2221 			unsigned int bsize, unsigned int cong_thres, int gen,
2222 			unsigned int cidx)
2223 {
2224 	if (base_addr & 0xfff)	/* must be 4K aligned */
2225 		return -EINVAL;
2226 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2227 		return -EBUSY;
2228 
2229 	base_addr >>= 12;
2230 	t3_write_reg(adapter, A_SG_CONTEXT_DATA0, base_addr);
2231 	base_addr >>= 32;
2232 	t3_write_reg(adapter, A_SG_CONTEXT_DATA1,
2233 		     V_FL_BASE_HI((u32) base_addr) |
2234 		     V_FL_INDEX_LO(cidx & M_FL_INDEX_LO));
2235 	t3_write_reg(adapter, A_SG_CONTEXT_DATA2, V_FL_SIZE(size) |
2236 		     V_FL_GEN(gen) | V_FL_INDEX_HI(cidx >> 12) |
2237 		     V_FL_ENTRY_SIZE_LO(bsize & M_FL_ENTRY_SIZE_LO));
2238 	t3_write_reg(adapter, A_SG_CONTEXT_DATA3,
2239 		     V_FL_ENTRY_SIZE_HI(bsize >> (32 - S_FL_ENTRY_SIZE_LO)) |
2240 		     V_FL_CONG_THRES(cong_thres) | V_FL_GTS(gts_enable));
2241 	return t3_sge_write_context(adapter, id, F_FREELIST);
2242 }
2243 
2244 /**
2245  *	t3_sge_init_rspcntxt - initialize an SGE response queue context
2246  *	@adapter: the adapter to configure
2247  *	@id: the context id
2248  *	@irq_vec_idx: MSI-X interrupt vector index, 0 if no MSI-X, -1 if no IRQ
2249  *	@base_addr: base address of queue
2250  *	@size: number of queue entries
2251  *	@fl_thres: threshold for selecting the normal or jumbo free list
2252  *	@gen: initial generation value for the context
2253  *	@cidx: consumer pointer
2254  *
2255  *	Initialize an SGE response queue context and make it ready for use.
2256  *	The caller is responsible for ensuring only one context operation
2257  *	occurs at a time.
2258  */
2259 int t3_sge_init_rspcntxt(struct adapter *adapter, unsigned int id,
2260 			 int irq_vec_idx, u64 base_addr, unsigned int size,
2261 			 unsigned int fl_thres, int gen, unsigned int cidx)
2262 {
2263 	unsigned int intr = 0;
2264 
2265 	if (base_addr & 0xfff)	/* must be 4K aligned */
2266 		return -EINVAL;
2267 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2268 		return -EBUSY;
2269 
2270 	base_addr >>= 12;
2271 	t3_write_reg(adapter, A_SG_CONTEXT_DATA0, V_CQ_SIZE(size) |
2272 		     V_CQ_INDEX(cidx));
2273 	t3_write_reg(adapter, A_SG_CONTEXT_DATA1, base_addr);
2274 	base_addr >>= 32;
2275 	if (irq_vec_idx >= 0)
2276 		intr = V_RQ_MSI_VEC(irq_vec_idx) | F_RQ_INTR_EN;
2277 	t3_write_reg(adapter, A_SG_CONTEXT_DATA2,
2278 		     V_CQ_BASE_HI((u32) base_addr) | intr | V_RQ_GEN(gen));
2279 	t3_write_reg(adapter, A_SG_CONTEXT_DATA3, fl_thres);
2280 	return t3_sge_write_context(adapter, id, F_RESPONSEQ);
2281 }
2282 
2283 /**
2284  *	t3_sge_init_cqcntxt - initialize an SGE completion queue context
2285  *	@adapter: the adapter to configure
2286  *	@id: the context id
2287  *	@base_addr: base address of queue
2288  *	@size: number of queue entries
2289  *	@rspq: response queue for async notifications
2290  *	@ovfl_mode: CQ overflow mode
2291  *	@credits: completion queue credits
2292  *	@credit_thres: the credit threshold
2293  *
2294  *	Initialize an SGE completion queue context and make it ready for use.
2295  *	The caller is responsible for ensuring only one context operation
2296  *	occurs at a time.
2297  */
2298 int t3_sge_init_cqcntxt(struct adapter *adapter, unsigned int id, u64 base_addr,
2299 			unsigned int size, int rspq, int ovfl_mode,
2300 			unsigned int credits, unsigned int credit_thres)
2301 {
2302 	if (base_addr & 0xfff)	/* must be 4K aligned */
2303 		return -EINVAL;
2304 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2305 		return -EBUSY;
2306 
2307 	base_addr >>= 12;
2308 	t3_write_reg(adapter, A_SG_CONTEXT_DATA0, V_CQ_SIZE(size));
2309 	t3_write_reg(adapter, A_SG_CONTEXT_DATA1, base_addr);
2310 	base_addr >>= 32;
2311 	t3_write_reg(adapter, A_SG_CONTEXT_DATA2,
2312 		     V_CQ_BASE_HI((u32) base_addr) | V_CQ_RSPQ(rspq) |
2313 		     V_CQ_GEN(1) | V_CQ_OVERFLOW_MODE(ovfl_mode) |
2314 		     V_CQ_ERR(ovfl_mode));
2315 	t3_write_reg(adapter, A_SG_CONTEXT_DATA3, V_CQ_CREDITS(credits) |
2316 		     V_CQ_CREDIT_THRES(credit_thres));
2317 	return t3_sge_write_context(adapter, id, F_CQ);
2318 }
2319 
2320 /**
2321  *	t3_sge_enable_ecntxt - enable/disable an SGE egress context
2322  *	@adapter: the adapter
2323  *	@id: the egress context id
2324  *	@enable: enable (1) or disable (0) the context
2325  *
2326  *	Enable or disable an SGE egress context.  The caller is responsible for
2327  *	ensuring only one context operation occurs at a time.
2328  */
2329 int t3_sge_enable_ecntxt(struct adapter *adapter, unsigned int id, int enable)
2330 {
2331 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2332 		return -EBUSY;
2333 
2334 	t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0);
2335 	t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2336 	t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0);
2337 	t3_write_reg(adapter, A_SG_CONTEXT_MASK3, F_EC_VALID);
2338 	t3_write_reg(adapter, A_SG_CONTEXT_DATA3, V_EC_VALID(enable));
2339 	t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2340 		     V_CONTEXT_CMD_OPCODE(1) | F_EGRESS | V_CONTEXT(id));
2341 	return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2342 			       0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2343 }
2344 
2345 /**
2346  *	t3_sge_disable_fl - disable an SGE free-buffer list
2347  *	@adapter: the adapter
2348  *	@id: the free list context id
2349  *
2350  *	Disable an SGE free-buffer list.  The caller is responsible for
2351  *	ensuring only one context operation occurs at a time.
2352  */
2353 int t3_sge_disable_fl(struct adapter *adapter, unsigned int id)
2354 {
2355 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2356 		return -EBUSY;
2357 
2358 	t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0);
2359 	t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2360 	t3_write_reg(adapter, A_SG_CONTEXT_MASK2, V_FL_SIZE(M_FL_SIZE));
2361 	t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0);
2362 	t3_write_reg(adapter, A_SG_CONTEXT_DATA2, 0);
2363 	t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2364 		     V_CONTEXT_CMD_OPCODE(1) | F_FREELIST | V_CONTEXT(id));
2365 	return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2366 			       0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2367 }
2368 
2369 /**
2370  *	t3_sge_disable_rspcntxt - disable an SGE response queue
2371  *	@adapter: the adapter
2372  *	@id: the response queue context id
2373  *
2374  *	Disable an SGE response queue.  The caller is responsible for
2375  *	ensuring only one context operation occurs at a time.
2376  */
2377 int t3_sge_disable_rspcntxt(struct adapter *adapter, unsigned int id)
2378 {
2379 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2380 		return -EBUSY;
2381 
2382 	t3_write_reg(adapter, A_SG_CONTEXT_MASK0, V_CQ_SIZE(M_CQ_SIZE));
2383 	t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2384 	t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0);
2385 	t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0);
2386 	t3_write_reg(adapter, A_SG_CONTEXT_DATA0, 0);
2387 	t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2388 		     V_CONTEXT_CMD_OPCODE(1) | F_RESPONSEQ | V_CONTEXT(id));
2389 	return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2390 			       0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2391 }
2392 
2393 /**
2394  *	t3_sge_disable_cqcntxt - disable an SGE completion queue
2395  *	@adapter: the adapter
2396  *	@id: the completion queue context id
2397  *
2398  *	Disable an SGE completion queue.  The caller is responsible for
2399  *	ensuring only one context operation occurs at a time.
2400  */
2401 int t3_sge_disable_cqcntxt(struct adapter *adapter, unsigned int id)
2402 {
2403 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2404 		return -EBUSY;
2405 
2406 	t3_write_reg(adapter, A_SG_CONTEXT_MASK0, V_CQ_SIZE(M_CQ_SIZE));
2407 	t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2408 	t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0);
2409 	t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0);
2410 	t3_write_reg(adapter, A_SG_CONTEXT_DATA0, 0);
2411 	t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2412 		     V_CONTEXT_CMD_OPCODE(1) | F_CQ | V_CONTEXT(id));
2413 	return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2414 			       0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2415 }
2416 
2417 /**
2418  *	t3_sge_cqcntxt_op - perform an operation on a completion queue context
2419  *	@adapter: the adapter
2420  *	@id: the context id
2421  *	@op: the operation to perform
2422  *	@credits: credit value to write
2423  *
2424  *	Perform the selected operation on an SGE completion queue context.
2425  *	The caller is responsible for ensuring only one context operation
2426  *	occurs at a time.
2427  */
2428 int t3_sge_cqcntxt_op(struct adapter *adapter, unsigned int id, unsigned int op,
2429 		      unsigned int credits)
2430 {
2431 	u32 val;
2432 
2433 	if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2434 		return -EBUSY;
2435 
2436 	t3_write_reg(adapter, A_SG_CONTEXT_DATA0, credits << 16);
2437 	t3_write_reg(adapter, A_SG_CONTEXT_CMD, V_CONTEXT_CMD_OPCODE(op) |
2438 		     V_CONTEXT(id) | F_CQ);
2439 	if (t3_wait_op_done_val(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2440 				0, SG_CONTEXT_CMD_ATTEMPTS, 1, &val))
2441 		return -EIO;
2442 
2443 	if (op >= 2 && op < 7) {
2444 		if (adapter->params.rev > 0)
2445 			return G_CQ_INDEX(val);
2446 
2447 		t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2448 			     V_CONTEXT_CMD_OPCODE(0) | F_CQ | V_CONTEXT(id));
2449 		if (t3_wait_op_done(adapter, A_SG_CONTEXT_CMD,
2450 				    F_CONTEXT_CMD_BUSY, 0,
2451 				    SG_CONTEXT_CMD_ATTEMPTS, 1))
2452 			return -EIO;
2453 		return G_CQ_INDEX(t3_read_reg(adapter, A_SG_CONTEXT_DATA0));
2454 	}
2455 	return 0;
2456 }
2457 
2458 /**
2459  *	t3_config_rss - configure Rx packet steering
2460  *	@adapter: the adapter
2461  *	@rss_config: RSS settings (written to TP_RSS_CONFIG)
2462  *	@cpus: values for the CPU lookup table (0xff terminated)
2463  *	@rspq: values for the response queue lookup table (0xffff terminated)
2464  *
2465  *	Programs the receive packet steering logic.  @cpus and @rspq provide
2466  *	the values for the CPU and response queue lookup tables.  If they
2467  *	provide fewer values than the size of the tables the supplied values
2468  *	are used repeatedly until the tables are fully populated.
2469  */
2470 void t3_config_rss(struct adapter *adapter, unsigned int rss_config,
2471 		   const u8 * cpus, const u16 *rspq)
2472 {
2473 	int i, j, cpu_idx = 0, q_idx = 0;
2474 
2475 	if (cpus)
2476 		for (i = 0; i < RSS_TABLE_SIZE; ++i) {
2477 			u32 val = i << 16;
2478 
2479 			for (j = 0; j < 2; ++j) {
2480 				val |= (cpus[cpu_idx++] & 0x3f) << (8 * j);
2481 				if (cpus[cpu_idx] == 0xff)
2482 					cpu_idx = 0;
2483 			}
2484 			t3_write_reg(adapter, A_TP_RSS_LKP_TABLE, val);
2485 		}
2486 
2487 	if (rspq)
2488 		for (i = 0; i < RSS_TABLE_SIZE; ++i) {
2489 			t3_write_reg(adapter, A_TP_RSS_MAP_TABLE,
2490 				     (i << 16) | rspq[q_idx++]);
2491 			if (rspq[q_idx] == 0xffff)
2492 				q_idx = 0;
2493 		}
2494 
2495 	t3_write_reg(adapter, A_TP_RSS_CONFIG, rss_config);
2496 }
2497 
2498 /**
2499  *	t3_tp_set_offload_mode - put TP in NIC/offload mode
2500  *	@adap: the adapter
2501  *	@enable: 1 to select offload mode, 0 for regular NIC
2502  *
2503  *	Switches TP to NIC/offload mode.
2504  */
2505 void t3_tp_set_offload_mode(struct adapter *adap, int enable)
2506 {
2507 	if (is_offload(adap) || !enable)
2508 		t3_set_reg_field(adap, A_TP_IN_CONFIG, F_NICMODE,
2509 				 V_NICMODE(!enable));
2510 }
2511 
2512 /**
2513  *	pm_num_pages - calculate the number of pages of the payload memory
2514  *	@mem_size: the size of the payload memory
2515  *	@pg_size: the size of each payload memory page
2516  *
2517  *	Calculate the number of pages, each of the given size, that fit in a
2518  *	memory of the specified size, respecting the HW requirement that the
2519  *	number of pages must be a multiple of 24.
2520  */
2521 static inline unsigned int pm_num_pages(unsigned int mem_size,
2522 					unsigned int pg_size)
2523 {
2524 	unsigned int n = mem_size / pg_size;
2525 
2526 	return n - n % 24;
2527 }
2528 
2529 #define mem_region(adap, start, size, reg) \
2530 	t3_write_reg((adap), A_ ## reg, (start)); \
2531 	start += size
2532 
2533 /**
2534  *	partition_mem - partition memory and configure TP memory settings
2535  *	@adap: the adapter
2536  *	@p: the TP parameters
2537  *
2538  *	Partitions context and payload memory and configures TP's memory
2539  *	registers.
2540  */
2541 static void partition_mem(struct adapter *adap, const struct tp_params *p)
2542 {
2543 	unsigned int m, pstructs, tids = t3_mc5_size(&adap->mc5);
2544 	unsigned int timers = 0, timers_shift = 22;
2545 
2546 	if (adap->params.rev > 0) {
2547 		if (tids <= 16 * 1024) {
2548 			timers = 1;
2549 			timers_shift = 16;
2550 		} else if (tids <= 64 * 1024) {
2551 			timers = 2;
2552 			timers_shift = 18;
2553 		} else if (tids <= 256 * 1024) {
2554 			timers = 3;
2555 			timers_shift = 20;
2556 		}
2557 	}
2558 
2559 	t3_write_reg(adap, A_TP_PMM_SIZE,
2560 		     p->chan_rx_size | (p->chan_tx_size >> 16));
2561 
2562 	t3_write_reg(adap, A_TP_PMM_TX_BASE, 0);
2563 	t3_write_reg(adap, A_TP_PMM_TX_PAGE_SIZE, p->tx_pg_size);
2564 	t3_write_reg(adap, A_TP_PMM_TX_MAX_PAGE, p->tx_num_pgs);
2565 	t3_set_reg_field(adap, A_TP_PARA_REG3, V_TXDATAACKIDX(M_TXDATAACKIDX),
2566 			 V_TXDATAACKIDX(fls(p->tx_pg_size) - 12));
2567 
2568 	t3_write_reg(adap, A_TP_PMM_RX_BASE, 0);
2569 	t3_write_reg(adap, A_TP_PMM_RX_PAGE_SIZE, p->rx_pg_size);
2570 	t3_write_reg(adap, A_TP_PMM_RX_MAX_PAGE, p->rx_num_pgs);
2571 
2572 	pstructs = p->rx_num_pgs + p->tx_num_pgs;
2573 	/* Add a bit of headroom and make multiple of 24 */
2574 	pstructs += 48;
2575 	pstructs -= pstructs % 24;
2576 	t3_write_reg(adap, A_TP_CMM_MM_MAX_PSTRUCT, pstructs);
2577 
2578 	m = tids * TCB_SIZE;
2579 	mem_region(adap, m, (64 << 10) * 64, SG_EGR_CNTX_BADDR);
2580 	mem_region(adap, m, (64 << 10) * 64, SG_CQ_CONTEXT_BADDR);
2581 	t3_write_reg(adap, A_TP_CMM_TIMER_BASE, V_CMTIMERMAXNUM(timers) | m);
2582 	m += ((p->ntimer_qs - 1) << timers_shift) + (1 << 22);
2583 	mem_region(adap, m, pstructs * 64, TP_CMM_MM_BASE);
2584 	mem_region(adap, m, 64 * (pstructs / 24), TP_CMM_MM_PS_FLST_BASE);
2585 	mem_region(adap, m, 64 * (p->rx_num_pgs / 24), TP_CMM_MM_RX_FLST_BASE);
2586 	mem_region(adap, m, 64 * (p->tx_num_pgs / 24), TP_CMM_MM_TX_FLST_BASE);
2587 
2588 	m = (m + 4095) & ~0xfff;
2589 	t3_write_reg(adap, A_CIM_SDRAM_BASE_ADDR, m);
2590 	t3_write_reg(adap, A_CIM_SDRAM_ADDR_SIZE, p->cm_size - m);
2591 
2592 	tids = (p->cm_size - m - (3 << 20)) / 3072 - 32;
2593 	m = t3_mc5_size(&adap->mc5) - adap->params.mc5.nservers -
2594 	    adap->params.mc5.nfilters - adap->params.mc5.nroutes;
2595 	if (tids < m)
2596 		adap->params.mc5.nservers += m - tids;
2597 }
2598 
2599 static inline void tp_wr_indirect(struct adapter *adap, unsigned int addr,
2600 				  u32 val)
2601 {
2602 	t3_write_reg(adap, A_TP_PIO_ADDR, addr);
2603 	t3_write_reg(adap, A_TP_PIO_DATA, val);
2604 }
2605 
2606 static void tp_config(struct adapter *adap, const struct tp_params *p)
2607 {
2608 	t3_write_reg(adap, A_TP_GLOBAL_CONFIG, F_TXPACINGENABLE | F_PATHMTU |
2609 		     F_IPCHECKSUMOFFLOAD | F_UDPCHECKSUMOFFLOAD |
2610 		     F_TCPCHECKSUMOFFLOAD | V_IPTTL(64));
2611 	t3_write_reg(adap, A_TP_TCP_OPTIONS, V_MTUDEFAULT(576) |
2612 		     F_MTUENABLE | V_WINDOWSCALEMODE(1) |
2613 		     V_TIMESTAMPSMODE(1) | V_SACKMODE(1) | V_SACKRX(1));
2614 	t3_write_reg(adap, A_TP_DACK_CONFIG, V_AUTOSTATE3(1) |
2615 		     V_AUTOSTATE2(1) | V_AUTOSTATE1(0) |
2616 		     V_BYTETHRESHOLD(26880) | V_MSSTHRESHOLD(2) |
2617 		     F_AUTOCAREFUL | F_AUTOENABLE | V_DACK_MODE(1));
2618 	t3_set_reg_field(adap, A_TP_IN_CONFIG, F_RXFBARBPRIO | F_TXFBARBPRIO,
2619 			 F_IPV6ENABLE | F_NICMODE);
2620 	t3_write_reg(adap, A_TP_TX_RESOURCE_LIMIT, 0x18141814);
2621 	t3_write_reg(adap, A_TP_PARA_REG4, 0x5050105);
2622 	t3_set_reg_field(adap, A_TP_PARA_REG6, 0,
2623 			 adap->params.rev > 0 ? F_ENABLEESND :
2624 			 F_T3A_ENABLEESND);
2625 
2626 	t3_set_reg_field(adap, A_TP_PC_CONFIG,
2627 			 F_ENABLEEPCMDAFULL,
2628 			 F_ENABLEOCSPIFULL |F_TXDEFERENABLE | F_HEARBEATDACK |
2629 			 F_TXCONGESTIONMODE | F_RXCONGESTIONMODE);
2630 	t3_set_reg_field(adap, A_TP_PC_CONFIG2, F_CHDRAFULL,
2631 			 F_ENABLEIPV6RSS | F_ENABLENONOFDTNLSYN |
2632 			 F_ENABLEARPMISS | F_DISBLEDAPARBIT0);
2633 	t3_write_reg(adap, A_TP_PROXY_FLOW_CNTL, 1080);
2634 	t3_write_reg(adap, A_TP_PROXY_FLOW_CNTL, 1000);
2635 
2636 	if (adap->params.rev > 0) {
2637 		tp_wr_indirect(adap, A_TP_EGRESS_CONFIG, F_REWRITEFORCETOSIZE);
2638 		t3_set_reg_field(adap, A_TP_PARA_REG3, F_TXPACEAUTO,
2639 				 F_TXPACEAUTO);
2640 		t3_set_reg_field(adap, A_TP_PC_CONFIG, F_LOCKTID, F_LOCKTID);
2641 		t3_set_reg_field(adap, A_TP_PARA_REG3, 0, F_TXPACEAUTOSTRICT);
2642 	} else
2643 		t3_set_reg_field(adap, A_TP_PARA_REG3, 0, F_TXPACEFIXED);
2644 
2645 	if (adap->params.rev == T3_REV_C)
2646 		t3_set_reg_field(adap, A_TP_PC_CONFIG,
2647 				 V_TABLELATENCYDELTA(M_TABLELATENCYDELTA),
2648 				 V_TABLELATENCYDELTA(4));
2649 
2650 	t3_write_reg(adap, A_TP_TX_MOD_QUEUE_WEIGHT1, 0);
2651 	t3_write_reg(adap, A_TP_TX_MOD_QUEUE_WEIGHT0, 0);
2652 	t3_write_reg(adap, A_TP_MOD_CHANNEL_WEIGHT, 0);
2653 	t3_write_reg(adap, A_TP_MOD_RATE_LIMIT, 0xf2200000);
2654 }
2655 
2656 /* Desired TP timer resolution in usec */
2657 #define TP_TMR_RES 50
2658 
2659 /* TCP timer values in ms */
2660 #define TP_DACK_TIMER 50
2661 #define TP_RTO_MIN    250
2662 
2663 /**
2664  *	tp_set_timers - set TP timing parameters
2665  *	@adap: the adapter to set
2666  *	@core_clk: the core clock frequency in Hz
2667  *
2668  *	Set TP's timing parameters, such as the various timer resolutions and
2669  *	the TCP timer values.
2670  */
2671 static void tp_set_timers(struct adapter *adap, unsigned int core_clk)
2672 {
2673 	unsigned int tre = fls(core_clk / (1000000 / TP_TMR_RES)) - 1;
2674 	unsigned int dack_re = fls(core_clk / 5000) - 1;	/* 200us */
2675 	unsigned int tstamp_re = fls(core_clk / 1000);	/* 1ms, at least */
2676 	unsigned int tps = core_clk >> tre;
2677 
2678 	t3_write_reg(adap, A_TP_TIMER_RESOLUTION, V_TIMERRESOLUTION(tre) |
2679 		     V_DELAYEDACKRESOLUTION(dack_re) |
2680 		     V_TIMESTAMPRESOLUTION(tstamp_re));
2681 	t3_write_reg(adap, A_TP_DACK_TIMER,
2682 		     (core_clk >> dack_re) / (1000 / TP_DACK_TIMER));
2683 	t3_write_reg(adap, A_TP_TCP_BACKOFF_REG0, 0x3020100);
2684 	t3_write_reg(adap, A_TP_TCP_BACKOFF_REG1, 0x7060504);
2685 	t3_write_reg(adap, A_TP_TCP_BACKOFF_REG2, 0xb0a0908);
2686 	t3_write_reg(adap, A_TP_TCP_BACKOFF_REG3, 0xf0e0d0c);
2687 	t3_write_reg(adap, A_TP_SHIFT_CNT, V_SYNSHIFTMAX(6) |
2688 		     V_RXTSHIFTMAXR1(4) | V_RXTSHIFTMAXR2(15) |
2689 		     V_PERSHIFTBACKOFFMAX(8) | V_PERSHIFTMAX(8) |
2690 		     V_KEEPALIVEMAX(9));
2691 
2692 #define SECONDS * tps
2693 
2694 	t3_write_reg(adap, A_TP_MSL, adap->params.rev > 0 ? 0 : 2 SECONDS);
2695 	t3_write_reg(adap, A_TP_RXT_MIN, tps / (1000 / TP_RTO_MIN));
2696 	t3_write_reg(adap, A_TP_RXT_MAX, 64 SECONDS);
2697 	t3_write_reg(adap, A_TP_PERS_MIN, 5 SECONDS);
2698 	t3_write_reg(adap, A_TP_PERS_MAX, 64 SECONDS);
2699 	t3_write_reg(adap, A_TP_KEEP_IDLE, 7200 SECONDS);
2700 	t3_write_reg(adap, A_TP_KEEP_INTVL, 75 SECONDS);
2701 	t3_write_reg(adap, A_TP_INIT_SRTT, 3 SECONDS);
2702 	t3_write_reg(adap, A_TP_FINWAIT2_TIMER, 600 SECONDS);
2703 
2704 #undef SECONDS
2705 }
2706 
2707 /**
2708  *	t3_tp_set_coalescing_size - set receive coalescing size
2709  *	@adap: the adapter
2710  *	@size: the receive coalescing size
2711  *	@psh: whether a set PSH bit should deliver coalesced data
2712  *
2713  *	Set the receive coalescing size and PSH bit handling.
2714  */
2715 static int t3_tp_set_coalescing_size(struct adapter *adap,
2716 				     unsigned int size, int psh)
2717 {
2718 	u32 val;
2719 
2720 	if (size > MAX_RX_COALESCING_LEN)
2721 		return -EINVAL;
2722 
2723 	val = t3_read_reg(adap, A_TP_PARA_REG3);
2724 	val &= ~(F_RXCOALESCEENABLE | F_RXCOALESCEPSHEN);
2725 
2726 	if (size) {
2727 		val |= F_RXCOALESCEENABLE;
2728 		if (psh)
2729 			val |= F_RXCOALESCEPSHEN;
2730 		size = min(MAX_RX_COALESCING_LEN, size);
2731 		t3_write_reg(adap, A_TP_PARA_REG2, V_RXCOALESCESIZE(size) |
2732 			     V_MAXRXDATA(MAX_RX_COALESCING_LEN));
2733 	}
2734 	t3_write_reg(adap, A_TP_PARA_REG3, val);
2735 	return 0;
2736 }
2737 
2738 /**
2739  *	t3_tp_set_max_rxsize - set the max receive size
2740  *	@adap: the adapter
2741  *	@size: the max receive size
2742  *
2743  *	Set TP's max receive size.  This is the limit that applies when
2744  *	receive coalescing is disabled.
2745  */
2746 static void t3_tp_set_max_rxsize(struct adapter *adap, unsigned int size)
2747 {
2748 	t3_write_reg(adap, A_TP_PARA_REG7,
2749 		     V_PMMAXXFERLEN0(size) | V_PMMAXXFERLEN1(size));
2750 }
2751 
2752 static void init_mtus(unsigned short mtus[])
2753 {
2754 	/*
2755 	 * See draft-mathis-plpmtud-00.txt for the values.  The min is 88 so
2756 	 * it can accommodate max size TCP/IP headers when SACK and timestamps
2757 	 * are enabled and still have at least 8 bytes of payload.
2758 	 */
2759 	mtus[0] = 88;
2760 	mtus[1] = 88;
2761 	mtus[2] = 256;
2762 	mtus[3] = 512;
2763 	mtus[4] = 576;
2764 	mtus[5] = 1024;
2765 	mtus[6] = 1280;
2766 	mtus[7] = 1492;
2767 	mtus[8] = 1500;
2768 	mtus[9] = 2002;
2769 	mtus[10] = 2048;
2770 	mtus[11] = 4096;
2771 	mtus[12] = 4352;
2772 	mtus[13] = 8192;
2773 	mtus[14] = 9000;
2774 	mtus[15] = 9600;
2775 }
2776 
2777 /*
2778  * Initial congestion control parameters.
2779  */
2780 static void init_cong_ctrl(unsigned short *a, unsigned short *b)
2781 {
2782 	a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = a[8] = 1;
2783 	a[9] = 2;
2784 	a[10] = 3;
2785 	a[11] = 4;
2786 	a[12] = 5;
2787 	a[13] = 6;
2788 	a[14] = 7;
2789 	a[15] = 8;
2790 	a[16] = 9;
2791 	a[17] = 10;
2792 	a[18] = 14;
2793 	a[19] = 17;
2794 	a[20] = 21;
2795 	a[21] = 25;
2796 	a[22] = 30;
2797 	a[23] = 35;
2798 	a[24] = 45;
2799 	a[25] = 60;
2800 	a[26] = 80;
2801 	a[27] = 100;
2802 	a[28] = 200;
2803 	a[29] = 300;
2804 	a[30] = 400;
2805 	a[31] = 500;
2806 
2807 	b[0] = b[1] = b[2] = b[3] = b[4] = b[5] = b[6] = b[7] = b[8] = 0;
2808 	b[9] = b[10] = 1;
2809 	b[11] = b[12] = 2;
2810 	b[13] = b[14] = b[15] = b[16] = 3;
2811 	b[17] = b[18] = b[19] = b[20] = b[21] = 4;
2812 	b[22] = b[23] = b[24] = b[25] = b[26] = b[27] = 5;
2813 	b[28] = b[29] = 6;
2814 	b[30] = b[31] = 7;
2815 }
2816 
2817 /* The minimum additive increment value for the congestion control table */
2818 #define CC_MIN_INCR 2U
2819 
2820 /**
2821  *	t3_load_mtus - write the MTU and congestion control HW tables
2822  *	@adap: the adapter
2823  *	@mtus: the unrestricted values for the MTU table
2824  *	@alpha: the values for the congestion control alpha parameter
2825  *	@beta: the values for the congestion control beta parameter
2826  *	@mtu_cap: the maximum permitted effective MTU
2827  *
2828  *	Write the MTU table with the supplied MTUs capping each at &mtu_cap.
2829  *	Update the high-speed congestion control table with the supplied alpha,
2830  * 	beta, and MTUs.
2831  */
2832 void t3_load_mtus(struct adapter *adap, unsigned short mtus[NMTUS],
2833 		  unsigned short alpha[NCCTRL_WIN],
2834 		  unsigned short beta[NCCTRL_WIN], unsigned short mtu_cap)
2835 {
2836 	static const unsigned int avg_pkts[NCCTRL_WIN] = {
2837 		2, 6, 10, 14, 20, 28, 40, 56, 80, 112, 160, 224, 320, 448, 640,
2838 		896, 1281, 1792, 2560, 3584, 5120, 7168, 10240, 14336, 20480,
2839 		28672, 40960, 57344, 81920, 114688, 163840, 229376
2840 	};
2841 
2842 	unsigned int i, w;
2843 
2844 	for (i = 0; i < NMTUS; ++i) {
2845 		unsigned int mtu = min(mtus[i], mtu_cap);
2846 		unsigned int log2 = fls(mtu);
2847 
2848 		if (!(mtu & ((1 << log2) >> 2)))	/* round */
2849 			log2--;
2850 		t3_write_reg(adap, A_TP_MTU_TABLE,
2851 			     (i << 24) | (log2 << 16) | mtu);
2852 
2853 		for (w = 0; w < NCCTRL_WIN; ++w) {
2854 			unsigned int inc;
2855 
2856 			inc = max(((mtu - 40) * alpha[w]) / avg_pkts[w],
2857 				  CC_MIN_INCR);
2858 
2859 			t3_write_reg(adap, A_TP_CCTRL_TABLE, (i << 21) |
2860 				     (w << 16) | (beta[w] << 13) | inc);
2861 		}
2862 	}
2863 }
2864 
2865 /**
2866  *	t3_tp_get_mib_stats - read TP's MIB counters
2867  *	@adap: the adapter
2868  *	@tps: holds the returned counter values
2869  *
2870  *	Returns the values of TP's MIB counters.
2871  */
2872 void t3_tp_get_mib_stats(struct adapter *adap, struct tp_mib_stats *tps)
2873 {
2874 	t3_read_indirect(adap, A_TP_MIB_INDEX, A_TP_MIB_RDATA, (u32 *) tps,
2875 			 sizeof(*tps) / sizeof(u32), 0);
2876 }
2877 
2878 #define ulp_region(adap, name, start, len) \
2879 	t3_write_reg((adap), A_ULPRX_ ## name ## _LLIMIT, (start)); \
2880 	t3_write_reg((adap), A_ULPRX_ ## name ## _ULIMIT, \
2881 		     (start) + (len) - 1); \
2882 	start += len
2883 
2884 #define ulptx_region(adap, name, start, len) \
2885 	t3_write_reg((adap), A_ULPTX_ ## name ## _LLIMIT, (start)); \
2886 	t3_write_reg((adap), A_ULPTX_ ## name ## _ULIMIT, \
2887 		     (start) + (len) - 1)
2888 
2889 static void ulp_config(struct adapter *adap, const struct tp_params *p)
2890 {
2891 	unsigned int m = p->chan_rx_size;
2892 
2893 	ulp_region(adap, ISCSI, m, p->chan_rx_size / 8);
2894 	ulp_region(adap, TDDP, m, p->chan_rx_size / 8);
2895 	ulptx_region(adap, TPT, m, p->chan_rx_size / 4);
2896 	ulp_region(adap, STAG, m, p->chan_rx_size / 4);
2897 	ulp_region(adap, RQ, m, p->chan_rx_size / 4);
2898 	ulptx_region(adap, PBL, m, p->chan_rx_size / 4);
2899 	ulp_region(adap, PBL, m, p->chan_rx_size / 4);
2900 	t3_write_reg(adap, A_ULPRX_TDDP_TAGMASK, 0xffffffff);
2901 }
2902 
2903 /**
2904  *	t3_set_proto_sram - set the contents of the protocol sram
2905  *	@adap: the adapter
2906  *	@data: the protocol image
2907  *
2908  *	Write the contents of the protocol SRAM.
2909  */
2910 int t3_set_proto_sram(struct adapter *adap, const u8 *data)
2911 {
2912 	int i;
2913 	const __be32 *buf = (const __be32 *)data;
2914 
2915 	for (i = 0; i < PROTO_SRAM_LINES; i++) {
2916 		t3_write_reg(adap, A_TP_EMBED_OP_FIELD5, be32_to_cpu(*buf++));
2917 		t3_write_reg(adap, A_TP_EMBED_OP_FIELD4, be32_to_cpu(*buf++));
2918 		t3_write_reg(adap, A_TP_EMBED_OP_FIELD3, be32_to_cpu(*buf++));
2919 		t3_write_reg(adap, A_TP_EMBED_OP_FIELD2, be32_to_cpu(*buf++));
2920 		t3_write_reg(adap, A_TP_EMBED_OP_FIELD1, be32_to_cpu(*buf++));
2921 
2922 		t3_write_reg(adap, A_TP_EMBED_OP_FIELD0, i << 1 | 1 << 31);
2923 		if (t3_wait_op_done(adap, A_TP_EMBED_OP_FIELD0, 1, 1, 5, 1))
2924 			return -EIO;
2925 	}
2926 	t3_write_reg(adap, A_TP_EMBED_OP_FIELD0, 0);
2927 
2928 	return 0;
2929 }
2930 
2931 void t3_config_trace_filter(struct adapter *adapter,
2932 			    const struct trace_params *tp, int filter_index,
2933 			    int invert, int enable)
2934 {
2935 	u32 addr, key[4], mask[4];
2936 
2937 	key[0] = tp->sport | (tp->sip << 16);
2938 	key[1] = (tp->sip >> 16) | (tp->dport << 16);
2939 	key[2] = tp->dip;
2940 	key[3] = tp->proto | (tp->vlan << 8) | (tp->intf << 20);
2941 
2942 	mask[0] = tp->sport_mask | (tp->sip_mask << 16);
2943 	mask[1] = (tp->sip_mask >> 16) | (tp->dport_mask << 16);
2944 	mask[2] = tp->dip_mask;
2945 	mask[3] = tp->proto_mask | (tp->vlan_mask << 8) | (tp->intf_mask << 20);
2946 
2947 	if (invert)
2948 		key[3] |= (1 << 29);
2949 	if (enable)
2950 		key[3] |= (1 << 28);
2951 
2952 	addr = filter_index ? A_TP_RX_TRC_KEY0 : A_TP_TX_TRC_KEY0;
2953 	tp_wr_indirect(adapter, addr++, key[0]);
2954 	tp_wr_indirect(adapter, addr++, mask[0]);
2955 	tp_wr_indirect(adapter, addr++, key[1]);
2956 	tp_wr_indirect(adapter, addr++, mask[1]);
2957 	tp_wr_indirect(adapter, addr++, key[2]);
2958 	tp_wr_indirect(adapter, addr++, mask[2]);
2959 	tp_wr_indirect(adapter, addr++, key[3]);
2960 	tp_wr_indirect(adapter, addr, mask[3]);
2961 	t3_read_reg(adapter, A_TP_PIO_DATA);
2962 }
2963 
2964 /**
2965  *	t3_config_sched - configure a HW traffic scheduler
2966  *	@adap: the adapter
2967  *	@kbps: target rate in Kbps
2968  *	@sched: the scheduler index
2969  *
2970  *	Configure a HW scheduler for the target rate
2971  */
2972 int t3_config_sched(struct adapter *adap, unsigned int kbps, int sched)
2973 {
2974 	unsigned int v, tps, cpt, bpt, delta, mindelta = ~0;
2975 	unsigned int clk = adap->params.vpd.cclk * 1000;
2976 	unsigned int selected_cpt = 0, selected_bpt = 0;
2977 
2978 	if (kbps > 0) {
2979 		kbps *= 125;	/* -> bytes */
2980 		for (cpt = 1; cpt <= 255; cpt++) {
2981 			tps = clk / cpt;
2982 			bpt = (kbps + tps / 2) / tps;
2983 			if (bpt > 0 && bpt <= 255) {
2984 				v = bpt * tps;
2985 				delta = v >= kbps ? v - kbps : kbps - v;
2986 				if (delta <= mindelta) {
2987 					mindelta = delta;
2988 					selected_cpt = cpt;
2989 					selected_bpt = bpt;
2990 				}
2991 			} else if (selected_cpt)
2992 				break;
2993 		}
2994 		if (!selected_cpt)
2995 			return -EINVAL;
2996 	}
2997 	t3_write_reg(adap, A_TP_TM_PIO_ADDR,
2998 		     A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2);
2999 	v = t3_read_reg(adap, A_TP_TM_PIO_DATA);
3000 	if (sched & 1)
3001 		v = (v & 0xffff) | (selected_cpt << 16) | (selected_bpt << 24);
3002 	else
3003 		v = (v & 0xffff0000) | selected_cpt | (selected_bpt << 8);
3004 	t3_write_reg(adap, A_TP_TM_PIO_DATA, v);
3005 	return 0;
3006 }
3007 
3008 static int tp_init(struct adapter *adap, const struct tp_params *p)
3009 {
3010 	int busy = 0;
3011 
3012 	tp_config(adap, p);
3013 	t3_set_vlan_accel(adap, 3, 0);
3014 
3015 	if (is_offload(adap)) {
3016 		tp_set_timers(adap, adap->params.vpd.cclk * 1000);
3017 		t3_write_reg(adap, A_TP_RESET, F_FLSTINITENABLE);
3018 		busy = t3_wait_op_done(adap, A_TP_RESET, F_FLSTINITENABLE,
3019 				       0, 1000, 5);
3020 		if (busy)
3021 			CH_ERR(adap, "TP initialization timed out\n");
3022 	}
3023 
3024 	if (!busy)
3025 		t3_write_reg(adap, A_TP_RESET, F_TPRESET);
3026 	return busy;
3027 }
3028 
3029 /*
3030  * Perform the bits of HW initialization that are dependent on the Tx
3031  * channels being used.
3032  */
3033 static void chan_init_hw(struct adapter *adap, unsigned int chan_map)
3034 {
3035 	int i;
3036 
3037 	if (chan_map != 3) {                                 /* one channel */
3038 		t3_set_reg_field(adap, A_ULPRX_CTL, F_ROUND_ROBIN, 0);
3039 		t3_set_reg_field(adap, A_ULPTX_CONFIG, F_CFG_RR_ARB, 0);
3040 		t3_write_reg(adap, A_MPS_CFG, F_TPRXPORTEN | F_ENFORCEPKT |
3041 			     (chan_map == 1 ? F_TPTXPORT0EN | F_PORT0ACTIVE :
3042 					      F_TPTXPORT1EN | F_PORT1ACTIVE));
3043 		t3_write_reg(adap, A_PM1_TX_CFG,
3044 			     chan_map == 1 ? 0xffffffff : 0);
3045 	} else {                                             /* two channels */
3046 		t3_set_reg_field(adap, A_ULPRX_CTL, 0, F_ROUND_ROBIN);
3047 		t3_set_reg_field(adap, A_ULPTX_CONFIG, 0, F_CFG_RR_ARB);
3048 		t3_write_reg(adap, A_ULPTX_DMA_WEIGHT,
3049 			     V_D1_WEIGHT(16) | V_D0_WEIGHT(16));
3050 		t3_write_reg(adap, A_MPS_CFG, F_TPTXPORT0EN | F_TPTXPORT1EN |
3051 			     F_TPRXPORTEN | F_PORT0ACTIVE | F_PORT1ACTIVE |
3052 			     F_ENFORCEPKT);
3053 		t3_write_reg(adap, A_PM1_TX_CFG, 0x80008000);
3054 		t3_set_reg_field(adap, A_TP_PC_CONFIG, 0, F_TXTOSQUEUEMAPMODE);
3055 		t3_write_reg(adap, A_TP_TX_MOD_QUEUE_REQ_MAP,
3056 			     V_TX_MOD_QUEUE_REQ_MAP(0xaa));
3057 		for (i = 0; i < 16; i++)
3058 			t3_write_reg(adap, A_TP_TX_MOD_QUE_TABLE,
3059 				     (i << 16) | 0x1010);
3060 	}
3061 }
3062 
3063 static int calibrate_xgm(struct adapter *adapter)
3064 {
3065 	if (uses_xaui(adapter)) {
3066 		unsigned int v, i;
3067 
3068 		for (i = 0; i < 5; ++i) {
3069 			t3_write_reg(adapter, A_XGM_XAUI_IMP, 0);
3070 			t3_read_reg(adapter, A_XGM_XAUI_IMP);
3071 			msleep(1);
3072 			v = t3_read_reg(adapter, A_XGM_XAUI_IMP);
3073 			if (!(v & (F_XGM_CALFAULT | F_CALBUSY))) {
3074 				t3_write_reg(adapter, A_XGM_XAUI_IMP,
3075 					     V_XAUIIMP(G_CALIMP(v) >> 2));
3076 				return 0;
3077 			}
3078 		}
3079 		CH_ERR(adapter, "MAC calibration failed\n");
3080 		return -1;
3081 	} else {
3082 		t3_write_reg(adapter, A_XGM_RGMII_IMP,
3083 			     V_RGMIIIMPPD(2) | V_RGMIIIMPPU(3));
3084 		t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_XGM_IMPSETUPDATE,
3085 				 F_XGM_IMPSETUPDATE);
3086 	}
3087 	return 0;
3088 }
3089 
3090 static void calibrate_xgm_t3b(struct adapter *adapter)
3091 {
3092 	if (!uses_xaui(adapter)) {
3093 		t3_write_reg(adapter, A_XGM_RGMII_IMP, F_CALRESET |
3094 			     F_CALUPDATE | V_RGMIIIMPPD(2) | V_RGMIIIMPPU(3));
3095 		t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_CALRESET, 0);
3096 		t3_set_reg_field(adapter, A_XGM_RGMII_IMP, 0,
3097 				 F_XGM_IMPSETUPDATE);
3098 		t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_XGM_IMPSETUPDATE,
3099 				 0);
3100 		t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_CALUPDATE, 0);
3101 		t3_set_reg_field(adapter, A_XGM_RGMII_IMP, 0, F_CALUPDATE);
3102 	}
3103 }
3104 
3105 struct mc7_timing_params {
3106 	unsigned char ActToPreDly;
3107 	unsigned char ActToRdWrDly;
3108 	unsigned char PreCyc;
3109 	unsigned char RefCyc[5];
3110 	unsigned char BkCyc;
3111 	unsigned char WrToRdDly;
3112 	unsigned char RdToWrDly;
3113 };
3114 
3115 /*
3116  * Write a value to a register and check that the write completed.  These
3117  * writes normally complete in a cycle or two, so one read should suffice.
3118  * The very first read exists to flush the posted write to the device.
3119  */
3120 static int wrreg_wait(struct adapter *adapter, unsigned int addr, u32 val)
3121 {
3122 	t3_write_reg(adapter, addr, val);
3123 	t3_read_reg(adapter, addr);	/* flush */
3124 	if (!(t3_read_reg(adapter, addr) & F_BUSY))
3125 		return 0;
3126 	CH_ERR(adapter, "write to MC7 register 0x%x timed out\n", addr);
3127 	return -EIO;
3128 }
3129 
3130 static int mc7_init(struct mc7 *mc7, unsigned int mc7_clock, int mem_type)
3131 {
3132 	static const unsigned int mc7_mode[] = {
3133 		0x632, 0x642, 0x652, 0x432, 0x442
3134 	};
3135 	static const struct mc7_timing_params mc7_timings[] = {
3136 		{12, 3, 4, {20, 28, 34, 52, 0}, 15, 6, 4},
3137 		{12, 4, 5, {20, 28, 34, 52, 0}, 16, 7, 4},
3138 		{12, 5, 6, {20, 28, 34, 52, 0}, 17, 8, 4},
3139 		{9, 3, 4, {15, 21, 26, 39, 0}, 12, 6, 4},
3140 		{9, 4, 5, {15, 21, 26, 39, 0}, 13, 7, 4}
3141 	};
3142 
3143 	u32 val;
3144 	unsigned int width, density, slow, attempts;
3145 	struct adapter *adapter = mc7->adapter;
3146 	const struct mc7_timing_params *p = &mc7_timings[mem_type];
3147 
3148 	if (!mc7->size)
3149 		return 0;
3150 
3151 	val = t3_read_reg(adapter, mc7->offset + A_MC7_CFG);
3152 	slow = val & F_SLOW;
3153 	width = G_WIDTH(val);
3154 	density = G_DEN(val);
3155 
3156 	t3_write_reg(adapter, mc7->offset + A_MC7_CFG, val | F_IFEN);
3157 	val = t3_read_reg(adapter, mc7->offset + A_MC7_CFG);	/* flush */
3158 	msleep(1);
3159 
3160 	if (!slow) {
3161 		t3_write_reg(adapter, mc7->offset + A_MC7_CAL, F_SGL_CAL_EN);
3162 		t3_read_reg(adapter, mc7->offset + A_MC7_CAL);
3163 		msleep(1);
3164 		if (t3_read_reg(adapter, mc7->offset + A_MC7_CAL) &
3165 		    (F_BUSY | F_SGL_CAL_EN | F_CAL_FAULT)) {
3166 			CH_ERR(adapter, "%s MC7 calibration timed out\n",
3167 			       mc7->name);
3168 			goto out_fail;
3169 		}
3170 	}
3171 
3172 	t3_write_reg(adapter, mc7->offset + A_MC7_PARM,
3173 		     V_ACTTOPREDLY(p->ActToPreDly) |
3174 		     V_ACTTORDWRDLY(p->ActToRdWrDly) | V_PRECYC(p->PreCyc) |
3175 		     V_REFCYC(p->RefCyc[density]) | V_BKCYC(p->BkCyc) |
3176 		     V_WRTORDDLY(p->WrToRdDly) | V_RDTOWRDLY(p->RdToWrDly));
3177 
3178 	t3_write_reg(adapter, mc7->offset + A_MC7_CFG,
3179 		     val | F_CLKEN | F_TERM150);
3180 	t3_read_reg(adapter, mc7->offset + A_MC7_CFG);	/* flush */
3181 
3182 	if (!slow)
3183 		t3_set_reg_field(adapter, mc7->offset + A_MC7_DLL, F_DLLENB,
3184 				 F_DLLENB);
3185 	udelay(1);
3186 
3187 	val = slow ? 3 : 6;
3188 	if (wrreg_wait(adapter, mc7->offset + A_MC7_PRE, 0) ||
3189 	    wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE2, 0) ||
3190 	    wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE3, 0) ||
3191 	    wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE1, val))
3192 		goto out_fail;
3193 
3194 	if (!slow) {
3195 		t3_write_reg(adapter, mc7->offset + A_MC7_MODE, 0x100);
3196 		t3_set_reg_field(adapter, mc7->offset + A_MC7_DLL, F_DLLRST, 0);
3197 		udelay(5);
3198 	}
3199 
3200 	if (wrreg_wait(adapter, mc7->offset + A_MC7_PRE, 0) ||
3201 	    wrreg_wait(adapter, mc7->offset + A_MC7_REF, 0) ||
3202 	    wrreg_wait(adapter, mc7->offset + A_MC7_REF, 0) ||
3203 	    wrreg_wait(adapter, mc7->offset + A_MC7_MODE,
3204 		       mc7_mode[mem_type]) ||
3205 	    wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE1, val | 0x380) ||
3206 	    wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE1, val))
3207 		goto out_fail;
3208 
3209 	/* clock value is in KHz */
3210 	mc7_clock = mc7_clock * 7812 + mc7_clock / 2;	/* ns */
3211 	mc7_clock /= 1000000;	/* KHz->MHz, ns->us */
3212 
3213 	t3_write_reg(adapter, mc7->offset + A_MC7_REF,
3214 		     F_PERREFEN | V_PREREFDIV(mc7_clock));
3215 	t3_read_reg(adapter, mc7->offset + A_MC7_REF);	/* flush */
3216 
3217 	t3_write_reg(adapter, mc7->offset + A_MC7_ECC, F_ECCGENEN | F_ECCCHKEN);
3218 	t3_write_reg(adapter, mc7->offset + A_MC7_BIST_DATA, 0);
3219 	t3_write_reg(adapter, mc7->offset + A_MC7_BIST_ADDR_BEG, 0);
3220 	t3_write_reg(adapter, mc7->offset + A_MC7_BIST_ADDR_END,
3221 		     (mc7->size << width) - 1);
3222 	t3_write_reg(adapter, mc7->offset + A_MC7_BIST_OP, V_OP(1));
3223 	t3_read_reg(adapter, mc7->offset + A_MC7_BIST_OP);	/* flush */
3224 
3225 	attempts = 50;
3226 	do {
3227 		msleep(250);
3228 		val = t3_read_reg(adapter, mc7->offset + A_MC7_BIST_OP);
3229 	} while ((val & F_BUSY) && --attempts);
3230 	if (val & F_BUSY) {
3231 		CH_ERR(adapter, "%s MC7 BIST timed out\n", mc7->name);
3232 		goto out_fail;
3233 	}
3234 
3235 	/* Enable normal memory accesses. */
3236 	t3_set_reg_field(adapter, mc7->offset + A_MC7_CFG, 0, F_RDY);
3237 	return 0;
3238 
3239 out_fail:
3240 	return -1;
3241 }
3242 
3243 static void config_pcie(struct adapter *adap)
3244 {
3245 	static const u16 ack_lat[4][6] = {
3246 		{237, 416, 559, 1071, 2095, 4143},
3247 		{128, 217, 289, 545, 1057, 2081},
3248 		{73, 118, 154, 282, 538, 1050},
3249 		{67, 107, 86, 150, 278, 534}
3250 	};
3251 	static const u16 rpl_tmr[4][6] = {
3252 		{711, 1248, 1677, 3213, 6285, 12429},
3253 		{384, 651, 867, 1635, 3171, 6243},
3254 		{219, 354, 462, 846, 1614, 3150},
3255 		{201, 321, 258, 450, 834, 1602}
3256 	};
3257 
3258 	u16 val, devid;
3259 	unsigned int log2_width, pldsize;
3260 	unsigned int fst_trn_rx, fst_trn_tx, acklat, rpllmt;
3261 
3262 	pcie_capability_read_word(adap->pdev, PCI_EXP_DEVCTL, &val);
3263 	pldsize = (val & PCI_EXP_DEVCTL_PAYLOAD) >> 5;
3264 
3265 	pci_read_config_word(adap->pdev, 0x2, &devid);
3266 	if (devid == 0x37) {
3267 		pcie_capability_write_word(adap->pdev, PCI_EXP_DEVCTL,
3268 					   val & ~PCI_EXP_DEVCTL_READRQ &
3269 					   ~PCI_EXP_DEVCTL_PAYLOAD);
3270 		pldsize = 0;
3271 	}
3272 
3273 	pcie_capability_read_word(adap->pdev, PCI_EXP_LNKCTL, &val);
3274 
3275 	fst_trn_tx = G_NUMFSTTRNSEQ(t3_read_reg(adap, A_PCIE_PEX_CTRL0));
3276 	fst_trn_rx = adap->params.rev == 0 ? fst_trn_tx :
3277 	    G_NUMFSTTRNSEQRX(t3_read_reg(adap, A_PCIE_MODE));
3278 	log2_width = fls(adap->params.pci.width) - 1;
3279 	acklat = ack_lat[log2_width][pldsize];
3280 	if (val & PCI_EXP_LNKCTL_ASPM_L0S)	/* check LOsEnable */
3281 		acklat += fst_trn_tx * 4;
3282 	rpllmt = rpl_tmr[log2_width][pldsize] + fst_trn_rx * 4;
3283 
3284 	if (adap->params.rev == 0)
3285 		t3_set_reg_field(adap, A_PCIE_PEX_CTRL1,
3286 				 V_T3A_ACKLAT(M_T3A_ACKLAT),
3287 				 V_T3A_ACKLAT(acklat));
3288 	else
3289 		t3_set_reg_field(adap, A_PCIE_PEX_CTRL1, V_ACKLAT(M_ACKLAT),
3290 				 V_ACKLAT(acklat));
3291 
3292 	t3_set_reg_field(adap, A_PCIE_PEX_CTRL0, V_REPLAYLMT(M_REPLAYLMT),
3293 			 V_REPLAYLMT(rpllmt));
3294 
3295 	t3_write_reg(adap, A_PCIE_PEX_ERR, 0xffffffff);
3296 	t3_set_reg_field(adap, A_PCIE_CFG, 0,
3297 			 F_ENABLELINKDWNDRST | F_ENABLELINKDOWNRST |
3298 			 F_PCIE_DMASTOPEN | F_PCIE_CLIDECEN);
3299 }
3300 
3301 /*
3302  * Initialize and configure T3 HW modules.  This performs the
3303  * initialization steps that need to be done once after a card is reset.
3304  * MAC and PHY initialization is handled separarely whenever a port is enabled.
3305  *
3306  * fw_params are passed to FW and their value is platform dependent.  Only the
3307  * top 8 bits are available for use, the rest must be 0.
3308  */
3309 int t3_init_hw(struct adapter *adapter, u32 fw_params)
3310 {
3311 	int err = -EIO, attempts, i;
3312 	const struct vpd_params *vpd = &adapter->params.vpd;
3313 
3314 	if (adapter->params.rev > 0)
3315 		calibrate_xgm_t3b(adapter);
3316 	else if (calibrate_xgm(adapter))
3317 		goto out_err;
3318 
3319 	if (vpd->mclk) {
3320 		partition_mem(adapter, &adapter->params.tp);
3321 
3322 		if (mc7_init(&adapter->pmrx, vpd->mclk, vpd->mem_timing) ||
3323 		    mc7_init(&adapter->pmtx, vpd->mclk, vpd->mem_timing) ||
3324 		    mc7_init(&adapter->cm, vpd->mclk, vpd->mem_timing) ||
3325 		    t3_mc5_init(&adapter->mc5, adapter->params.mc5.nservers,
3326 				adapter->params.mc5.nfilters,
3327 				adapter->params.mc5.nroutes))
3328 			goto out_err;
3329 
3330 		for (i = 0; i < 32; i++)
3331 			if (clear_sge_ctxt(adapter, i, F_CQ))
3332 				goto out_err;
3333 	}
3334 
3335 	if (tp_init(adapter, &adapter->params.tp))
3336 		goto out_err;
3337 
3338 	t3_tp_set_coalescing_size(adapter,
3339 				  min(adapter->params.sge.max_pkt_size,
3340 				      MAX_RX_COALESCING_LEN), 1);
3341 	t3_tp_set_max_rxsize(adapter,
3342 			     min(adapter->params.sge.max_pkt_size, 16384U));
3343 	ulp_config(adapter, &adapter->params.tp);
3344 
3345 	if (is_pcie(adapter))
3346 		config_pcie(adapter);
3347 	else
3348 		t3_set_reg_field(adapter, A_PCIX_CFG, 0,
3349 				 F_DMASTOPEN | F_CLIDECEN);
3350 
3351 	if (adapter->params.rev == T3_REV_C)
3352 		t3_set_reg_field(adapter, A_ULPTX_CONFIG, 0,
3353 				 F_CFG_CQE_SOP_MASK);
3354 
3355 	t3_write_reg(adapter, A_PM1_RX_CFG, 0xffffffff);
3356 	t3_write_reg(adapter, A_PM1_RX_MODE, 0);
3357 	t3_write_reg(adapter, A_PM1_TX_MODE, 0);
3358 	chan_init_hw(adapter, adapter->params.chan_map);
3359 	t3_sge_init(adapter, &adapter->params.sge);
3360 	t3_set_reg_field(adapter, A_PL_RST, 0, F_FATALPERREN);
3361 
3362 	t3_write_reg(adapter, A_T3DBG_GPIO_ACT_LOW, calc_gpio_intr(adapter));
3363 
3364 	t3_write_reg(adapter, A_CIM_HOST_ACC_DATA, vpd->uclk | fw_params);
3365 	t3_write_reg(adapter, A_CIM_BOOT_CFG,
3366 		     V_BOOTADDR(FW_FLASH_BOOT_ADDR >> 2));
3367 	t3_read_reg(adapter, A_CIM_BOOT_CFG);	/* flush */
3368 
3369 	attempts = 100;
3370 	do {			/* wait for uP to initialize */
3371 		msleep(20);
3372 	} while (t3_read_reg(adapter, A_CIM_HOST_ACC_DATA) && --attempts);
3373 	if (!attempts) {
3374 		CH_ERR(adapter, "uP initialization timed out\n");
3375 		goto out_err;
3376 	}
3377 
3378 	err = 0;
3379 out_err:
3380 	return err;
3381 }
3382 
3383 /**
3384  *	get_pci_mode - determine a card's PCI mode
3385  *	@adapter: the adapter
3386  *	@p: where to store the PCI settings
3387  *
3388  *	Determines a card's PCI mode and associated parameters, such as speed
3389  *	and width.
3390  */
3391 static void get_pci_mode(struct adapter *adapter, struct pci_params *p)
3392 {
3393 	static unsigned short speed_map[] = { 33, 66, 100, 133 };
3394 	u32 pci_mode;
3395 
3396 	if (pci_is_pcie(adapter->pdev)) {
3397 		u16 val;
3398 
3399 		p->variant = PCI_VARIANT_PCIE;
3400 		pcie_capability_read_word(adapter->pdev, PCI_EXP_LNKSTA, &val);
3401 		p->width = (val >> 4) & 0x3f;
3402 		return;
3403 	}
3404 
3405 	pci_mode = t3_read_reg(adapter, A_PCIX_MODE);
3406 	p->speed = speed_map[G_PCLKRANGE(pci_mode)];
3407 	p->width = (pci_mode & F_64BIT) ? 64 : 32;
3408 	pci_mode = G_PCIXINITPAT(pci_mode);
3409 	if (pci_mode == 0)
3410 		p->variant = PCI_VARIANT_PCI;
3411 	else if (pci_mode < 4)
3412 		p->variant = PCI_VARIANT_PCIX_MODE1_PARITY;
3413 	else if (pci_mode < 8)
3414 		p->variant = PCI_VARIANT_PCIX_MODE1_ECC;
3415 	else
3416 		p->variant = PCI_VARIANT_PCIX_266_MODE2;
3417 }
3418 
3419 /**
3420  *	init_link_config - initialize a link's SW state
3421  *	@lc: structure holding the link state
3422  *	@caps: information about the current card
3423  *
3424  *	Initializes the SW state maintained for each link, including the link's
3425  *	capabilities and default speed/duplex/flow-control/autonegotiation
3426  *	settings.
3427  */
3428 static void init_link_config(struct link_config *lc, unsigned int caps)
3429 {
3430 	lc->supported = caps;
3431 	lc->requested_speed = lc->speed = SPEED_INVALID;
3432 	lc->requested_duplex = lc->duplex = DUPLEX_INVALID;
3433 	lc->requested_fc = lc->fc = PAUSE_RX | PAUSE_TX;
3434 	if (lc->supported & SUPPORTED_Autoneg) {
3435 		lc->advertising = lc->supported;
3436 		lc->autoneg = AUTONEG_ENABLE;
3437 		lc->requested_fc |= PAUSE_AUTONEG;
3438 	} else {
3439 		lc->advertising = 0;
3440 		lc->autoneg = AUTONEG_DISABLE;
3441 	}
3442 }
3443 
3444 /**
3445  *	mc7_calc_size - calculate MC7 memory size
3446  *	@cfg: the MC7 configuration
3447  *
3448  *	Calculates the size of an MC7 memory in bytes from the value of its
3449  *	configuration register.
3450  */
3451 static unsigned int mc7_calc_size(u32 cfg)
3452 {
3453 	unsigned int width = G_WIDTH(cfg);
3454 	unsigned int banks = !!(cfg & F_BKS) + 1;
3455 	unsigned int org = !!(cfg & F_ORG) + 1;
3456 	unsigned int density = G_DEN(cfg);
3457 	unsigned int MBs = ((256 << density) * banks) / (org << width);
3458 
3459 	return MBs << 20;
3460 }
3461 
3462 static void mc7_prep(struct adapter *adapter, struct mc7 *mc7,
3463 		     unsigned int base_addr, const char *name)
3464 {
3465 	u32 cfg;
3466 
3467 	mc7->adapter = adapter;
3468 	mc7->name = name;
3469 	mc7->offset = base_addr - MC7_PMRX_BASE_ADDR;
3470 	cfg = t3_read_reg(adapter, mc7->offset + A_MC7_CFG);
3471 	mc7->size = G_DEN(cfg) == M_DEN ? 0 : mc7_calc_size(cfg);
3472 	mc7->width = G_WIDTH(cfg);
3473 }
3474 
3475 static void mac_prep(struct cmac *mac, struct adapter *adapter, int index)
3476 {
3477 	u16 devid;
3478 
3479 	mac->adapter = adapter;
3480 	pci_read_config_word(adapter->pdev, 0x2, &devid);
3481 
3482 	if (devid == 0x37 && !adapter->params.vpd.xauicfg[1])
3483 		index = 0;
3484 	mac->offset = (XGMAC0_1_BASE_ADDR - XGMAC0_0_BASE_ADDR) * index;
3485 	mac->nucast = 1;
3486 
3487 	if (adapter->params.rev == 0 && uses_xaui(adapter)) {
3488 		t3_write_reg(adapter, A_XGM_SERDES_CTRL + mac->offset,
3489 			     is_10G(adapter) ? 0x2901c04 : 0x2301c04);
3490 		t3_set_reg_field(adapter, A_XGM_PORT_CFG + mac->offset,
3491 				 F_ENRGMII, 0);
3492 	}
3493 }
3494 
3495 static void early_hw_init(struct adapter *adapter,
3496 			  const struct adapter_info *ai)
3497 {
3498 	u32 val = V_PORTSPEED(is_10G(adapter) ? 3 : 2);
3499 
3500 	mi1_init(adapter, ai);
3501 	t3_write_reg(adapter, A_I2C_CFG,	/* set for 80KHz */
3502 		     V_I2C_CLKDIV(adapter->params.vpd.cclk / 80 - 1));
3503 	t3_write_reg(adapter, A_T3DBG_GPIO_EN,
3504 		     ai->gpio_out | F_GPIO0_OEN | F_GPIO0_OUT_VAL);
3505 	t3_write_reg(adapter, A_MC5_DB_SERVER_INDEX, 0);
3506 	t3_write_reg(adapter, A_SG_OCO_BASE, V_BASE1(0xfff));
3507 
3508 	if (adapter->params.rev == 0 || !uses_xaui(adapter))
3509 		val |= F_ENRGMII;
3510 
3511 	/* Enable MAC clocks so we can access the registers */
3512 	t3_write_reg(adapter, A_XGM_PORT_CFG, val);
3513 	t3_read_reg(adapter, A_XGM_PORT_CFG);
3514 
3515 	val |= F_CLKDIVRESET_;
3516 	t3_write_reg(adapter, A_XGM_PORT_CFG, val);
3517 	t3_read_reg(adapter, A_XGM_PORT_CFG);
3518 	t3_write_reg(adapter, XGM_REG(A_XGM_PORT_CFG, 1), val);
3519 	t3_read_reg(adapter, A_XGM_PORT_CFG);
3520 }
3521 
3522 /*
3523  * Reset the adapter.
3524  * Older PCIe cards lose their config space during reset, PCI-X
3525  * ones don't.
3526  */
3527 int t3_reset_adapter(struct adapter *adapter)
3528 {
3529 	int i, save_and_restore_pcie =
3530 	    adapter->params.rev < T3_REV_B2 && is_pcie(adapter);
3531 	uint16_t devid = 0;
3532 
3533 	if (save_and_restore_pcie)
3534 		pci_save_state(adapter->pdev);
3535 	t3_write_reg(adapter, A_PL_RST, F_CRSTWRM | F_CRSTWRMMODE);
3536 
3537 	/*
3538 	 * Delay. Give Some time to device to reset fully.
3539 	 * XXX The delay time should be modified.
3540 	 */
3541 	for (i = 0; i < 10; i++) {
3542 		msleep(50);
3543 		pci_read_config_word(adapter->pdev, 0x00, &devid);
3544 		if (devid == 0x1425)
3545 			break;
3546 	}
3547 
3548 	if (devid != 0x1425)
3549 		return -1;
3550 
3551 	if (save_and_restore_pcie)
3552 		pci_restore_state(adapter->pdev);
3553 	return 0;
3554 }
3555 
3556 static int init_parity(struct adapter *adap)
3557 {
3558 	int i, err, addr;
3559 
3560 	if (t3_read_reg(adap, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
3561 		return -EBUSY;
3562 
3563 	for (err = i = 0; !err && i < 16; i++)
3564 		err = clear_sge_ctxt(adap, i, F_EGRESS);
3565 	for (i = 0xfff0; !err && i <= 0xffff; i++)
3566 		err = clear_sge_ctxt(adap, i, F_EGRESS);
3567 	for (i = 0; !err && i < SGE_QSETS; i++)
3568 		err = clear_sge_ctxt(adap, i, F_RESPONSEQ);
3569 	if (err)
3570 		return err;
3571 
3572 	t3_write_reg(adap, A_CIM_IBQ_DBG_DATA, 0);
3573 	for (i = 0; i < 4; i++)
3574 		for (addr = 0; addr <= M_IBQDBGADDR; addr++) {
3575 			t3_write_reg(adap, A_CIM_IBQ_DBG_CFG, F_IBQDBGEN |
3576 				     F_IBQDBGWR | V_IBQDBGQID(i) |
3577 				     V_IBQDBGADDR(addr));
3578 			err = t3_wait_op_done(adap, A_CIM_IBQ_DBG_CFG,
3579 					      F_IBQDBGBUSY, 0, 2, 1);
3580 			if (err)
3581 				return err;
3582 		}
3583 	return 0;
3584 }
3585 
3586 /*
3587  * Initialize adapter SW state for the various HW modules, set initial values
3588  * for some adapter tunables, take PHYs out of reset, and initialize the MDIO
3589  * interface.
3590  */
3591 int t3_prep_adapter(struct adapter *adapter, const struct adapter_info *ai,
3592 		    int reset)
3593 {
3594 	int ret;
3595 	unsigned int i, j = -1;
3596 
3597 	get_pci_mode(adapter, &adapter->params.pci);
3598 
3599 	adapter->params.info = ai;
3600 	adapter->params.nports = ai->nports0 + ai->nports1;
3601 	adapter->params.chan_map = (!!ai->nports0) | (!!ai->nports1 << 1);
3602 	adapter->params.rev = t3_read_reg(adapter, A_PL_REV);
3603 	/*
3604 	 * We used to only run the "adapter check task" once a second if
3605 	 * we had PHYs which didn't support interrupts (we would check
3606 	 * their link status once a second).  Now we check other conditions
3607 	 * in that routine which could potentially impose a very high
3608 	 * interrupt load on the system.  As such, we now always scan the
3609 	 * adapter state once a second ...
3610 	 */
3611 	adapter->params.linkpoll_period = 10;
3612 	adapter->params.stats_update_period = is_10G(adapter) ?
3613 	    MAC_STATS_ACCUM_SECS : (MAC_STATS_ACCUM_SECS * 10);
3614 	adapter->params.pci.vpd_cap_addr =
3615 	    pci_find_capability(adapter->pdev, PCI_CAP_ID_VPD);
3616 	if (!adapter->params.pci.vpd_cap_addr)
3617 		return -ENODEV;
3618 	ret = get_vpd_params(adapter, &adapter->params.vpd);
3619 	if (ret < 0)
3620 		return ret;
3621 
3622 	if (reset && t3_reset_adapter(adapter))
3623 		return -1;
3624 
3625 	t3_sge_prep(adapter, &adapter->params.sge);
3626 
3627 	if (adapter->params.vpd.mclk) {
3628 		struct tp_params *p = &adapter->params.tp;
3629 
3630 		mc7_prep(adapter, &adapter->pmrx, MC7_PMRX_BASE_ADDR, "PMRX");
3631 		mc7_prep(adapter, &adapter->pmtx, MC7_PMTX_BASE_ADDR, "PMTX");
3632 		mc7_prep(adapter, &adapter->cm, MC7_CM_BASE_ADDR, "CM");
3633 
3634 		p->nchan = adapter->params.chan_map == 3 ? 2 : 1;
3635 		p->pmrx_size = t3_mc7_size(&adapter->pmrx);
3636 		p->pmtx_size = t3_mc7_size(&adapter->pmtx);
3637 		p->cm_size = t3_mc7_size(&adapter->cm);
3638 		p->chan_rx_size = p->pmrx_size / 2;	/* only 1 Rx channel */
3639 		p->chan_tx_size = p->pmtx_size / p->nchan;
3640 		p->rx_pg_size = 64 * 1024;
3641 		p->tx_pg_size = is_10G(adapter) ? 64 * 1024 : 16 * 1024;
3642 		p->rx_num_pgs = pm_num_pages(p->chan_rx_size, p->rx_pg_size);
3643 		p->tx_num_pgs = pm_num_pages(p->chan_tx_size, p->tx_pg_size);
3644 		p->ntimer_qs = p->cm_size >= (128 << 20) ||
3645 		    adapter->params.rev > 0 ? 12 : 6;
3646 	}
3647 
3648 	adapter->params.offload = t3_mc7_size(&adapter->pmrx) &&
3649 				  t3_mc7_size(&adapter->pmtx) &&
3650 				  t3_mc7_size(&adapter->cm);
3651 
3652 	if (is_offload(adapter)) {
3653 		adapter->params.mc5.nservers = DEFAULT_NSERVERS;
3654 		adapter->params.mc5.nfilters = adapter->params.rev > 0 ?
3655 		    DEFAULT_NFILTERS : 0;
3656 		adapter->params.mc5.nroutes = 0;
3657 		t3_mc5_prep(adapter, &adapter->mc5, MC5_MODE_144_BIT);
3658 
3659 		init_mtus(adapter->params.mtus);
3660 		init_cong_ctrl(adapter->params.a_wnd, adapter->params.b_wnd);
3661 	}
3662 
3663 	early_hw_init(adapter, ai);
3664 	ret = init_parity(adapter);
3665 	if (ret)
3666 		return ret;
3667 
3668 	for_each_port(adapter, i) {
3669 		u8 hw_addr[6];
3670 		const struct port_type_info *pti;
3671 		struct port_info *p = adap2pinfo(adapter, i);
3672 
3673 		while (!adapter->params.vpd.port_type[++j])
3674 			;
3675 
3676 		pti = &port_types[adapter->params.vpd.port_type[j]];
3677 		if (!pti->phy_prep) {
3678 			CH_ALERT(adapter, "Invalid port type index %d\n",
3679 				 adapter->params.vpd.port_type[j]);
3680 			return -EINVAL;
3681 		}
3682 
3683 		p->phy.mdio.dev = adapter->port[i];
3684 		ret = pti->phy_prep(&p->phy, adapter, ai->phy_base_addr + j,
3685 				    ai->mdio_ops);
3686 		if (ret)
3687 			return ret;
3688 		mac_prep(&p->mac, adapter, j);
3689 
3690 		/*
3691 		 * The VPD EEPROM stores the base Ethernet address for the
3692 		 * card.  A port's address is derived from the base by adding
3693 		 * the port's index to the base's low octet.
3694 		 */
3695 		memcpy(hw_addr, adapter->params.vpd.eth_base, 5);
3696 		hw_addr[5] = adapter->params.vpd.eth_base[5] + i;
3697 
3698 		eth_hw_addr_set(adapter->port[i], hw_addr);
3699 		init_link_config(&p->link_config, p->phy.caps);
3700 		p->phy.ops->power_down(&p->phy, 1);
3701 
3702 		/*
3703 		 * If the PHY doesn't support interrupts for link status
3704 		 * changes, schedule a scan of the adapter links at least
3705 		 * once a second.
3706 		 */
3707 		if (!(p->phy.caps & SUPPORTED_IRQ) &&
3708 		    adapter->params.linkpoll_period > 10)
3709 			adapter->params.linkpoll_period = 10;
3710 	}
3711 
3712 	return 0;
3713 }
3714 
3715 void t3_led_ready(struct adapter *adapter)
3716 {
3717 	t3_set_reg_field(adapter, A_T3DBG_GPIO_EN, F_GPIO0_OUT_VAL,
3718 			 F_GPIO0_OUT_VAL);
3719 }
3720 
3721 int t3_replay_prep_adapter(struct adapter *adapter)
3722 {
3723 	const struct adapter_info *ai = adapter->params.info;
3724 	unsigned int i, j = -1;
3725 	int ret;
3726 
3727 	early_hw_init(adapter, ai);
3728 	ret = init_parity(adapter);
3729 	if (ret)
3730 		return ret;
3731 
3732 	for_each_port(adapter, i) {
3733 		const struct port_type_info *pti;
3734 		struct port_info *p = adap2pinfo(adapter, i);
3735 
3736 		while (!adapter->params.vpd.port_type[++j])
3737 			;
3738 
3739 		pti = &port_types[adapter->params.vpd.port_type[j]];
3740 		ret = pti->phy_prep(&p->phy, adapter, p->phy.mdio.prtad, NULL);
3741 		if (ret)
3742 			return ret;
3743 		p->phy.ops->power_down(&p->phy, 1);
3744 	}
3745 
3746 	return 0;
3747 }
3748 
3749