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