1 /************************************************************************** 2 3 Copyright (c) 2007-2009 Chelsio Inc. 4 All rights reserved. 5 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions are met: 8 9 1. Redistributions of source code must retain the above copyright notice, 10 this list of conditions and the following disclaimer. 11 12 2. Neither the name of the Chelsio Corporation nor the names of its 13 contributors may be used to endorse or promote products derived from 14 this software without specific prior written permission. 15 16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 20 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 POSSIBILITY OF SUCH DAMAGE. 27 28 ***************************************************************************/ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <cxgb_include.h> 34 35 #undef msleep 36 #define msleep t3_os_sleep 37 38 39 static inline int macidx(const struct cmac *mac) 40 { 41 return mac->offset / (XGMAC0_1_BASE_ADDR - XGMAC0_0_BASE_ADDR); 42 } 43 44 /* 45 * Returns a reasonable A_XGM_RESET_CTRL value for the mac specified. 46 */ 47 static inline int xgm_reset_ctrl(const struct cmac *mac) 48 { 49 adapter_t *adap = mac->adapter; 50 int val = F_MAC_RESET_ | F_XGMAC_STOP_EN; 51 52 if (is_10G(adap)) { 53 int cfg = t3_read_reg(adap, A_XGM_PORT_CFG + mac->offset); 54 55 val |= F_PCS_RESET_; 56 if (G_PORTSPEED(cfg) != 3) /* not running at 10G */ 57 val |= F_XG2G_RESET_; 58 } else if (uses_xaui(adap)) 59 val |= F_PCS_RESET_ | F_XG2G_RESET_; 60 else 61 val |= F_RGMII_RESET_ | F_XG2G_RESET_; 62 63 return (val); 64 } 65 66 static void xaui_serdes_reset(struct cmac *mac) 67 { 68 static const unsigned int clear[] = { 69 F_PWRDN0 | F_PWRDN1, F_RESETPLL01, F_RESET0 | F_RESET1, 70 F_PWRDN2 | F_PWRDN3, F_RESETPLL23, F_RESET2 | F_RESET3 71 }; 72 73 int i; 74 adapter_t *adap = mac->adapter; 75 u32 ctrl = A_XGM_SERDES_CTRL0 + mac->offset; 76 77 t3_write_reg(adap, ctrl, adap->params.vpd.xauicfg[macidx(mac)] | 78 F_RESET3 | F_RESET2 | F_RESET1 | F_RESET0 | 79 F_PWRDN3 | F_PWRDN2 | F_PWRDN1 | F_PWRDN0 | 80 F_RESETPLL23 | F_RESETPLL01); 81 (void)t3_read_reg(adap, ctrl); 82 udelay(15); 83 84 for (i = 0; i < ARRAY_SIZE(clear); i++) { 85 t3_set_reg_field(adap, ctrl, clear[i], 0); 86 udelay(15); 87 } 88 } 89 90 /** 91 * t3b_pcs_reset - reset the PCS on T3B+ adapters 92 * @mac: the XGMAC handle 93 * 94 * Reset the XGMAC PCS block on T3B+ adapters. 95 */ 96 void t3b_pcs_reset(struct cmac *mac) 97 { 98 t3_set_reg_field(mac->adapter, A_XGM_RESET_CTRL + mac->offset, 99 F_PCS_RESET_, 0); 100 udelay(20); 101 t3_set_reg_field(mac->adapter, A_XGM_RESET_CTRL + mac->offset, 0, 102 F_PCS_RESET_); 103 } 104 105 /** 106 * t3_mac_init - initialize a MAC 107 * @mac: the MAC to initialize 108 * 109 * Initialize the given MAC. 110 */ 111 int t3_mac_init(struct cmac *mac) 112 { 113 static struct addr_val_pair mac_reset_avp[] = { 114 { A_XGM_TX_CTRL, 0 }, 115 { A_XGM_RX_CTRL, 0 }, 116 { A_XGM_RX_CFG, F_DISPAUSEFRAMES | F_EN1536BFRAMES | 117 F_RMFCS | F_ENJUMBO | F_ENHASHMCAST }, 118 { A_XGM_RX_HASH_LOW, 0 }, 119 { A_XGM_RX_HASH_HIGH, 0 }, 120 { A_XGM_RX_EXACT_MATCH_LOW_1, 0 }, 121 { A_XGM_RX_EXACT_MATCH_LOW_2, 0 }, 122 { A_XGM_RX_EXACT_MATCH_LOW_3, 0 }, 123 { A_XGM_RX_EXACT_MATCH_LOW_4, 0 }, 124 { A_XGM_RX_EXACT_MATCH_LOW_5, 0 }, 125 { A_XGM_RX_EXACT_MATCH_LOW_6, 0 }, 126 { A_XGM_RX_EXACT_MATCH_LOW_7, 0 }, 127 { A_XGM_RX_EXACT_MATCH_LOW_8, 0 }, 128 { A_XGM_STAT_CTRL, F_CLRSTATS } 129 }; 130 u32 val; 131 adapter_t *adap = mac->adapter; 132 unsigned int oft = mac->offset; 133 134 t3_write_reg(adap, A_XGM_RESET_CTRL + oft, F_MAC_RESET_); 135 (void) t3_read_reg(adap, A_XGM_RESET_CTRL + oft); /* flush */ 136 137 t3_write_regs(adap, mac_reset_avp, ARRAY_SIZE(mac_reset_avp), oft); 138 t3_set_reg_field(adap, A_XGM_RXFIFO_CFG + oft, 139 F_RXSTRFRWRD | F_DISERRFRAMES, 140 uses_xaui(adap) ? 0 : F_RXSTRFRWRD); 141 t3_set_reg_field(adap, A_XGM_TXFIFO_CFG + oft, 0, F_UNDERUNFIX); 142 143 if (uses_xaui(adap)) { 144 if (adap->params.rev == 0) { 145 t3_set_reg_field(adap, A_XGM_SERDES_CTRL + oft, 0, 146 F_RXENABLE | F_TXENABLE); 147 if (t3_wait_op_done(adap, A_XGM_SERDES_STATUS1 + oft, 148 F_CMULOCK, 1, 5, 2)) { 149 CH_ERR(adap, 150 "MAC %d XAUI SERDES CMU lock failed\n", 151 macidx(mac)); 152 return -1; 153 } 154 t3_set_reg_field(adap, A_XGM_SERDES_CTRL + oft, 0, 155 F_SERDESRESET_); 156 } else 157 xaui_serdes_reset(mac); 158 } 159 160 161 if (mac->multiport) { 162 t3_write_reg(adap, A_XGM_RX_MAX_PKT_SIZE + oft, 163 V_RXMAXPKTSIZE(MAX_FRAME_SIZE - 4)); 164 t3_set_reg_field(adap, A_XGM_TXFIFO_CFG + oft, 0, 165 F_DISPREAMBLE); 166 t3_set_reg_field(adap, A_XGM_RX_CFG + oft, 0, F_COPYPREAMBLE | 167 F_ENNON802_3PREAMBLE); 168 t3_set_reg_field(adap, A_XGM_TXFIFO_CFG + oft, 169 V_TXFIFOTHRESH(M_TXFIFOTHRESH), 170 V_TXFIFOTHRESH(64)); 171 t3_write_reg(adap, A_XGM_TX_CTRL + oft, F_TXEN); 172 t3_write_reg(adap, A_XGM_RX_CTRL + oft, F_RXEN); 173 } 174 175 t3_set_reg_field(adap, A_XGM_RX_MAX_PKT_SIZE + oft, 176 V_RXMAXFRAMERSIZE(M_RXMAXFRAMERSIZE), 177 V_RXMAXFRAMERSIZE(MAX_FRAME_SIZE) | F_RXENFRAMER); 178 179 val = xgm_reset_ctrl(mac); 180 t3_write_reg(adap, A_XGM_RESET_CTRL + oft, val); 181 (void) t3_read_reg(adap, A_XGM_RESET_CTRL + oft); /* flush */ 182 if ((val & F_PCS_RESET_) && adap->params.rev) { 183 msleep(1); 184 t3b_pcs_reset(mac); 185 } 186 187 memset(&mac->stats, 0, sizeof(mac->stats)); 188 return 0; 189 } 190 191 static int t3_mac_reset(struct cmac *mac, int portspeed) 192 { 193 u32 val, store_mps; 194 adapter_t *adap = mac->adapter; 195 unsigned int oft = mac->offset; 196 int idx = macidx(mac); 197 unsigned int store; 198 199 /* Stop egress traffic to xgm*/ 200 store_mps = t3_read_reg(adap, A_MPS_CFG); 201 if (!idx) 202 t3_set_reg_field(adap, A_MPS_CFG, F_PORT0ACTIVE, 0); 203 else 204 t3_set_reg_field(adap, A_MPS_CFG, F_PORT1ACTIVE, 0); 205 206 /* This will reduce the number of TXTOGGLES */ 207 /* Clear: to stop the NIC traffic */ 208 t3_set_reg_field(adap, A_MPS_CFG, F_ENFORCEPKT, 0); 209 /* Ensure TX drains */ 210 t3_set_reg_field(adap, A_XGM_TX_CFG + oft, F_TXPAUSEEN, 0); 211 212 /* PCS in reset */ 213 t3_write_reg(adap, A_XGM_RESET_CTRL + oft, F_MAC_RESET_); 214 (void) t3_read_reg(adap, A_XGM_RESET_CTRL + oft); /* flush */ 215 216 /* Store A_TP_TX_DROP_CFG_CH0 */ 217 t3_write_reg(adap, A_TP_PIO_ADDR, A_TP_TX_DROP_CFG_CH0 + idx); 218 store = t3_read_reg(adap, A_TP_PIO_DATA); 219 220 msleep(10); 221 222 /* Change DROP_CFG to 0xc0000011 */ 223 t3_write_reg(adap, A_TP_PIO_ADDR, A_TP_TX_DROP_CFG_CH0 + idx); 224 t3_write_reg(adap, A_TP_PIO_DATA, 0xc0000011); 225 226 /* Check for xgm Rx fifo empty */ 227 /* Increased loop count to 1000 from 5 cover 1G and 100Mbps case */ 228 if (t3_wait_op_done(adap, A_XGM_RX_MAX_PKT_SIZE_ERR_CNT + oft, 229 0x80000000, 1, 1000, 2) && portspeed < 0) { 230 CH_ERR(adap, "MAC %d Rx fifo drain failed\n", idx); 231 return -1; 232 } 233 234 if (portspeed >= 0) { 235 u32 intr = t3_read_reg(adap, A_XGM_INT_ENABLE + oft); 236 237 /* 238 * safespeedchange: wipes out pretty much all XGMAC registers. 239 */ 240 241 t3_set_reg_field(adap, A_XGM_PORT_CFG + oft, 242 V_PORTSPEED(M_PORTSPEED) | F_SAFESPEEDCHANGE, 243 portspeed | F_SAFESPEEDCHANGE); 244 (void) t3_read_reg(adap, A_XGM_PORT_CFG + oft); 245 t3_set_reg_field(adap, A_XGM_PORT_CFG + oft, 246 F_SAFESPEEDCHANGE, 0); 247 (void) t3_read_reg(adap, A_XGM_PORT_CFG + oft); 248 t3_mac_init(mac); 249 250 t3_write_reg(adap, A_XGM_INT_ENABLE + oft, intr); 251 } else { 252 253 t3_write_reg(adap, A_XGM_RESET_CTRL + oft, 0); /*MAC in reset*/ 254 (void) t3_read_reg(adap, A_XGM_RESET_CTRL + oft); /* flush */ 255 256 val = xgm_reset_ctrl(mac); 257 t3_write_reg(adap, A_XGM_RESET_CTRL + oft, val); 258 (void) t3_read_reg(adap, A_XGM_RESET_CTRL + oft); /* flush */ 259 if ((val & F_PCS_RESET_) && adap->params.rev) { 260 msleep(1); 261 t3b_pcs_reset(mac); 262 } 263 t3_write_reg(adap, A_XGM_RX_CFG + oft, 264 F_DISPAUSEFRAMES | F_EN1536BFRAMES | 265 F_RMFCS | F_ENJUMBO | F_ENHASHMCAST ); 266 } 267 268 /* Restore the DROP_CFG */ 269 t3_write_reg(adap, A_TP_PIO_ADDR, A_TP_TX_DROP_CFG_CH0 + idx); 270 t3_write_reg(adap, A_TP_PIO_DATA, store); 271 272 /* Resume egress traffic to xgm */ 273 t3_set_reg_field(adap, A_MPS_CFG, F_PORT1ACTIVE | F_PORT0ACTIVE, 274 store_mps); 275 276 /* Set: re-enable NIC traffic */ 277 t3_set_reg_field(adap, A_MPS_CFG, F_ENFORCEPKT, F_ENFORCEPKT); 278 279 return 0; 280 } 281 282 /* 283 * Set the exact match register 'idx' to recognize the given Ethernet address. 284 */ 285 static void set_addr_filter(struct cmac *mac, int idx, const u8 *addr) 286 { 287 u32 addr_lo, addr_hi; 288 unsigned int oft = mac->offset + idx * 8; 289 290 addr_lo = (addr[3] << 24) | (addr[2] << 16) | (addr[1] << 8) | addr[0]; 291 addr_hi = (addr[5] << 8) | addr[4]; 292 293 t3_write_reg(mac->adapter, A_XGM_RX_EXACT_MATCH_LOW_1 + oft, addr_lo); 294 t3_write_reg(mac->adapter, A_XGM_RX_EXACT_MATCH_HIGH_1 + oft, addr_hi); 295 } 296 297 /** 298 * t3_mac_set_address - set one of the station's unicast MAC addresses 299 * @mac: the MAC handle 300 * @idx: index of the exact address match filter to use 301 * @addr: the Ethernet address 302 * 303 * Set one of the station's unicast MAC addresses. 304 */ 305 int t3_mac_set_address(struct cmac *mac, unsigned int idx, u8 addr[6]) 306 { 307 if (mac->multiport) 308 idx = mac->ext_port + idx * mac->adapter->params.nports; 309 if (idx >= mac->nucast) 310 return -EINVAL; 311 set_addr_filter(mac, idx, addr); 312 if (mac->multiport && idx < mac->adapter->params.nports) 313 t3_vsc7323_set_addr(mac->adapter, addr, idx); 314 return 0; 315 } 316 317 /** 318 * t3_mac_set_num_ucast - set the number of unicast addresses needed 319 * @mac: the MAC handle 320 * @n: number of unicast addresses needed 321 * 322 * Specify the number of exact address filters that should be reserved for 323 * unicast addresses. Caller should reload the unicast and multicast 324 * addresses after calling this. 325 * 326 * Generally, this is 1 with the first one used for the station address, 327 * and the rest are available for multicast addresses. 328 */ 329 int t3_mac_set_num_ucast(struct cmac *mac, unsigned char n) 330 { 331 if (n > EXACT_ADDR_FILTERS) 332 return -EINVAL; 333 mac->nucast = n; 334 return 0; 335 } 336 337 void t3_mac_disable_exact_filters(struct cmac *mac) 338 { 339 unsigned int i, reg = mac->offset + A_XGM_RX_EXACT_MATCH_LOW_1; 340 341 for (i = 0; i < EXACT_ADDR_FILTERS; i++, reg += 8) { 342 u32 v = t3_read_reg(mac->adapter, reg); 343 t3_write_reg(mac->adapter, reg, v); 344 } 345 t3_read_reg(mac->adapter, A_XGM_RX_EXACT_MATCH_LOW_1); /* flush */ 346 } 347 348 void t3_mac_enable_exact_filters(struct cmac *mac) 349 { 350 unsigned int i, reg = mac->offset + A_XGM_RX_EXACT_MATCH_HIGH_1; 351 352 for (i = 0; i < EXACT_ADDR_FILTERS; i++, reg += 8) { 353 u32 v = t3_read_reg(mac->adapter, reg); 354 t3_write_reg(mac->adapter, reg, v); 355 } 356 t3_read_reg(mac->adapter, A_XGM_RX_EXACT_MATCH_LOW_1); /* flush */ 357 } 358 359 /* Calculate the RX hash filter index of an Ethernet address */ 360 static int hash_hw_addr(const u8 *addr) 361 { 362 int hash = 0, octet, bit, i = 0, c; 363 364 for (octet = 0; octet < 6; ++octet) 365 for (c = addr[octet], bit = 0; bit < 8; c >>= 1, ++bit) { 366 hash ^= (c & 1) << i; 367 if (++i == 6) 368 i = 0; 369 } 370 return hash; 371 } 372 373 /** 374 * t3_mac_set_rx_mode - set the Rx mode and address filters 375 * @mac: the MAC to configure 376 * @rm: structure containing the Rx mode and MAC addresses needed 377 * 378 * Configures the MAC Rx mode (promiscuity, etc) and exact and hash 379 * address filters. 380 */ 381 int t3_mac_set_rx_mode(struct cmac *mac, struct t3_rx_mode *rm) 382 { 383 u32 hash_lo, hash_hi; 384 adapter_t *adap = mac->adapter; 385 unsigned int oft = mac->offset; 386 387 if (promisc_rx_mode(rm)) 388 mac->promisc_map |= 1 << mac->ext_port; 389 else 390 mac->promisc_map &= ~(1 << mac->ext_port); 391 t3_set_reg_field(adap, A_XGM_RX_CFG + oft, F_COPYALLFRAMES, 392 mac->promisc_map ? F_COPYALLFRAMES : 0); 393 394 if (allmulti_rx_mode(rm) || mac->multiport) 395 hash_lo = hash_hi = 0xffffffff; 396 else { 397 u8 *addr; 398 int exact_addr_idx = mac->nucast; 399 400 hash_lo = hash_hi = 0; 401 while ((addr = t3_get_next_mcaddr(rm))) 402 if (exact_addr_idx < EXACT_ADDR_FILTERS) 403 set_addr_filter(mac, exact_addr_idx++, addr); 404 else { 405 int hash = hash_hw_addr(addr); 406 407 if (hash < 32) 408 hash_lo |= (1 << hash); 409 else 410 hash_hi |= (1 << (hash - 32)); 411 } 412 } 413 414 t3_write_reg(adap, A_XGM_RX_HASH_LOW + oft, hash_lo); 415 t3_write_reg(adap, A_XGM_RX_HASH_HIGH + oft, hash_hi); 416 return 0; 417 } 418 419 static int rx_fifo_hwm(int mtu) 420 { 421 int hwm; 422 423 hwm = max(MAC_RXFIFO_SIZE - 3 * mtu, (MAC_RXFIFO_SIZE * 38) / 100); 424 return min(hwm, MAC_RXFIFO_SIZE - 8192); 425 } 426 427 /** 428 * t3_mac_set_mtu - set the MAC MTU 429 * @mac: the MAC to configure 430 * @mtu: the MTU 431 * 432 * Sets the MAC MTU and adjusts the FIFO PAUSE watermarks accordingly. 433 */ 434 int t3_mac_set_mtu(struct cmac *mac, unsigned int mtu) 435 { 436 int hwm, lwm, divisor; 437 int ipg; 438 unsigned int thres, v, reg; 439 adapter_t *adap = mac->adapter; 440 unsigned port_type = adap->params.vpd.port_type[macidx(mac)]; 441 unsigned int orig_mtu=mtu; 442 443 /* 444 * MAX_FRAME_SIZE inludes header + FCS, mtu doesn't. The HW max 445 * packet size register includes header, but not FCS. 446 */ 447 mtu += 14; 448 if (mac->multiport) 449 mtu += 8; /* for preamble */ 450 if (mtu > MAX_FRAME_SIZE - 4) 451 return -EINVAL; 452 if (mac->multiport) 453 return t3_vsc7323_set_mtu(adap, mtu - 4, mac->ext_port); 454 455 /* Modify the TX and RX fifo depth only if the card has a vsc8211 phy */ 456 if (port_type == 2) { 457 int err = t3_vsc8211_fifo_depth(adap,orig_mtu,macidx(mac)); 458 459 if (err) 460 return err; 461 } 462 463 if (adap->params.rev >= T3_REV_B2 && 464 (t3_read_reg(adap, A_XGM_RX_CTRL + mac->offset) & F_RXEN)) { 465 t3_mac_disable_exact_filters(mac); 466 v = t3_read_reg(adap, A_XGM_RX_CFG + mac->offset); 467 t3_set_reg_field(adap, A_XGM_RX_CFG + mac->offset, 468 F_ENHASHMCAST | F_COPYALLFRAMES, F_DISBCAST); 469 470 reg = adap->params.rev == T3_REV_B2 ? 471 A_XGM_RX_MAX_PKT_SIZE_ERR_CNT : A_XGM_RXFIFO_CFG; 472 473 /* drain RX FIFO */ 474 if (t3_wait_op_done(adap, reg + mac->offset, 475 F_RXFIFO_EMPTY, 1, 20, 5)) { 476 t3_write_reg(adap, A_XGM_RX_CFG + mac->offset, v); 477 t3_mac_enable_exact_filters(mac); 478 return -EIO; 479 } 480 t3_set_reg_field(adap, A_XGM_RX_MAX_PKT_SIZE + mac->offset, 481 V_RXMAXPKTSIZE(M_RXMAXPKTSIZE), 482 V_RXMAXPKTSIZE(mtu)); 483 t3_write_reg(adap, A_XGM_RX_CFG + mac->offset, v); 484 t3_mac_enable_exact_filters(mac); 485 } else 486 t3_set_reg_field(adap, A_XGM_RX_MAX_PKT_SIZE + mac->offset, 487 V_RXMAXPKTSIZE(M_RXMAXPKTSIZE), 488 V_RXMAXPKTSIZE(mtu)); 489 /* 490 * Adjust the PAUSE frame watermarks. We always set the LWM, and the 491 * HWM only if flow-control is enabled. 492 */ 493 hwm = rx_fifo_hwm(mtu); 494 lwm = min(3 * (int) mtu, MAC_RXFIFO_SIZE /4); 495 v = t3_read_reg(adap, A_XGM_RXFIFO_CFG + mac->offset); 496 v &= ~V_RXFIFOPAUSELWM(M_RXFIFOPAUSELWM); 497 v |= V_RXFIFOPAUSELWM(lwm / 8); 498 if (G_RXFIFOPAUSEHWM(v)) 499 v = (v & ~V_RXFIFOPAUSEHWM(M_RXFIFOPAUSEHWM)) | 500 V_RXFIFOPAUSEHWM(hwm / 8); 501 502 t3_write_reg(adap, A_XGM_RXFIFO_CFG + mac->offset, v); 503 504 /* Adjust the TX FIFO threshold based on the MTU */ 505 thres = (adap->params.vpd.cclk * 1000) / 15625; 506 thres = (thres * mtu) / 1000; 507 if (is_10G(adap)) 508 thres /= 10; 509 thres = mtu > thres ? (mtu - thres + 7) / 8 : 0; 510 thres = max(thres, 8U); /* need at least 8 */ 511 ipg = (port_type == 9 || adap->params.rev != T3_REV_C) ? 1 : 0; 512 t3_set_reg_field(adap, A_XGM_TXFIFO_CFG + mac->offset, 513 V_TXFIFOTHRESH(M_TXFIFOTHRESH) | V_TXIPG(M_TXIPG), 514 V_TXFIFOTHRESH(thres) | V_TXIPG(ipg)); 515 516 /* Assuming a minimum drain rate of 2.5Gbps... 517 */ 518 if (adap->params.rev > 0) { 519 divisor = (adap->params.rev == T3_REV_C) ? 64 : 8; 520 t3_write_reg(adap, A_XGM_PAUSE_TIMER + mac->offset, 521 (hwm - lwm) * 4 / divisor); 522 } 523 t3_write_reg(adap, A_XGM_TX_PAUSE_QUANTA + mac->offset, 524 MAC_RXFIFO_SIZE * 4 * 8 / 512); 525 return 0; 526 } 527 528 /** 529 * t3_mac_set_speed_duplex_fc - set MAC speed, duplex and flow control 530 * @mac: the MAC to configure 531 * @speed: the desired speed (10/100/1000/10000) 532 * @duplex: the desired duplex 533 * @fc: desired Tx/Rx PAUSE configuration 534 * 535 * Set the MAC speed, duplex (actually only full-duplex is supported), and 536 * flow control. If a parameter value is negative the corresponding 537 * MAC setting is left at its current value. 538 */ 539 int t3_mac_set_speed_duplex_fc(struct cmac *mac, int speed, int duplex, int fc) 540 { 541 u32 val; 542 adapter_t *adap = mac->adapter; 543 unsigned int oft = mac->offset; 544 545 if (duplex >= 0 && duplex != DUPLEX_FULL) 546 return -EINVAL; 547 if (mac->multiport) { 548 u32 rx_max_pkt_size = 549 G_RXMAXPKTSIZE(t3_read_reg(adap, 550 A_XGM_RX_MAX_PKT_SIZE + oft)); 551 val = t3_read_reg(adap, A_XGM_RXFIFO_CFG + oft); 552 val &= ~V_RXFIFOPAUSEHWM(M_RXFIFOPAUSEHWM); 553 val |= V_RXFIFOPAUSEHWM(rx_fifo_hwm(rx_max_pkt_size) / 8); 554 t3_write_reg(adap, A_XGM_RXFIFO_CFG + oft, val); 555 556 t3_set_reg_field(adap, A_XGM_TX_CFG + oft, F_TXPAUSEEN, 557 F_TXPAUSEEN); 558 return t3_vsc7323_set_speed_fc(adap, speed, fc, mac->ext_port); 559 } 560 if (speed >= 0) { 561 if (speed == SPEED_10) 562 val = V_PORTSPEED(0); 563 else if (speed == SPEED_100) 564 val = V_PORTSPEED(1); 565 else if (speed == SPEED_1000) 566 val = V_PORTSPEED(2); 567 else if (speed == SPEED_10000) 568 val = V_PORTSPEED(3); 569 else 570 return -EINVAL; 571 572 if (!uses_xaui(adap)) /* T302 */ 573 t3_set_reg_field(adap, A_XGM_PORT_CFG + oft, 574 V_PORTSPEED(M_PORTSPEED), val); 575 else { 576 u32 old = t3_read_reg(adap, A_XGM_PORT_CFG + oft); 577 578 if ((old & V_PORTSPEED(M_PORTSPEED)) != val) { 579 t3_mac_reset(mac, val); 580 mac->was_reset = 1; 581 } 582 } 583 } 584 585 val = t3_read_reg(adap, A_XGM_RXFIFO_CFG + oft); 586 val &= ~V_RXFIFOPAUSEHWM(M_RXFIFOPAUSEHWM); 587 if (fc & PAUSE_TX) { 588 u32 rx_max_pkt_size = 589 G_RXMAXPKTSIZE(t3_read_reg(adap, 590 A_XGM_RX_MAX_PKT_SIZE + oft)); 591 val |= V_RXFIFOPAUSEHWM(rx_fifo_hwm(rx_max_pkt_size) / 8); 592 } 593 t3_write_reg(adap, A_XGM_RXFIFO_CFG + oft, val); 594 595 t3_set_reg_field(adap, A_XGM_TX_CFG + oft, F_TXPAUSEEN, 596 (fc & PAUSE_RX) ? F_TXPAUSEEN : 0); 597 return 0; 598 } 599 600 /** 601 * t3_mac_enable - enable the MAC in the given directions 602 * @mac: the MAC to configure 603 * @which: bitmap indicating which directions to enable 604 * 605 * Enables the MAC for operation in the given directions. 606 * %MAC_DIRECTION_TX enables the Tx direction, and %MAC_DIRECTION_RX 607 * enables the Rx one. 608 */ 609 int t3_mac_enable(struct cmac *mac, int which) 610 { 611 int idx = macidx(mac); 612 adapter_t *adap = mac->adapter; 613 unsigned int oft = mac->offset; 614 struct mac_stats *s = &mac->stats; 615 616 if (mac->multiport) 617 return t3_vsc7323_enable(adap, mac->ext_port, which); 618 619 if (which & MAC_DIRECTION_TX) { 620 t3_write_reg(adap, A_TP_PIO_ADDR, A_TP_TX_DROP_CFG_CH0 + idx); 621 t3_write_reg(adap, A_TP_PIO_DATA, 622 adap->params.rev == T3_REV_C ? 623 0xc4ffff01 : 0xc0ede401); 624 t3_write_reg(adap, A_TP_PIO_ADDR, A_TP_TX_DROP_MODE); 625 t3_set_reg_field(adap, A_TP_PIO_DATA, 1 << idx, 626 adap->params.rev == T3_REV_C ? 627 0 : 1 << idx); 628 629 t3_write_reg(adap, A_XGM_TX_CTRL + oft, F_TXEN); 630 631 t3_write_reg(adap, A_TP_PIO_ADDR, A_TP_TX_DROP_CNT_CH0 + idx); 632 mac->tx_mcnt = s->tx_frames; 633 mac->tx_tcnt = (G_TXDROPCNTCH0RCVD(t3_read_reg(adap, 634 A_TP_PIO_DATA))); 635 mac->tx_xcnt = (G_TXSPI4SOPCNT(t3_read_reg(adap, 636 A_XGM_TX_SPI4_SOP_EOP_CNT + 637 oft))); 638 mac->rx_mcnt = s->rx_frames; 639 mac->rx_pause = s->rx_pause; 640 mac->rx_xcnt = (G_TXSPI4SOPCNT(t3_read_reg(adap, 641 A_XGM_RX_SPI4_SOP_EOP_CNT + 642 oft))); 643 mac->rx_ocnt = s->rx_fifo_ovfl; 644 mac->txen = F_TXEN; 645 mac->toggle_cnt = 0; 646 } 647 if (which & MAC_DIRECTION_RX) 648 t3_write_reg(adap, A_XGM_RX_CTRL + oft, F_RXEN); 649 return 0; 650 } 651 652 /** 653 * t3_mac_disable - disable the MAC in the given directions 654 * @mac: the MAC to configure 655 * @which: bitmap indicating which directions to disable 656 * 657 * Disables the MAC in the given directions. 658 * %MAC_DIRECTION_TX disables the Tx direction, and %MAC_DIRECTION_RX 659 * disables the Rx one. 660 */ 661 int t3_mac_disable(struct cmac *mac, int which) 662 { 663 adapter_t *adap = mac->adapter; 664 665 if (mac->multiport) 666 return t3_vsc7323_disable(adap, mac->ext_port, which); 667 668 if (which & MAC_DIRECTION_TX) { 669 t3_write_reg(adap, A_XGM_TX_CTRL + mac->offset, 0); 670 mac->txen = 0; 671 } 672 if (which & MAC_DIRECTION_RX) { 673 int val = xgm_reset_ctrl(mac); 674 675 t3_set_reg_field(mac->adapter, A_XGM_RESET_CTRL + mac->offset, 676 F_PCS_RESET_, 0); 677 msleep(100); 678 t3_write_reg(adap, A_XGM_RX_CTRL + mac->offset, 0); 679 t3_write_reg(mac->adapter, A_XGM_RESET_CTRL + mac->offset, val); 680 } 681 return 0; 682 } 683 684 int t3b2_mac_watchdog_task(struct cmac *mac) 685 { 686 int status; 687 unsigned int tx_tcnt, tx_xcnt; 688 adapter_t *adap = mac->adapter; 689 struct mac_stats *s = &mac->stats; 690 u64 tx_mcnt = s->tx_frames; 691 692 if (mac->multiport) 693 tx_mcnt = t3_read_reg(adap, A_XGM_STAT_TX_FRAME_LOW); 694 695 status = 0; 696 tx_xcnt = 1; /* By default tx_xcnt is making progress*/ 697 tx_tcnt = mac->tx_tcnt; /* If tx_mcnt is progressing ignore tx_tcnt*/ 698 if (tx_mcnt == mac->tx_mcnt && mac->rx_pause == s->rx_pause) { 699 u32 cfg, active, enforcepkt; 700 701 tx_xcnt = (G_TXSPI4SOPCNT(t3_read_reg(adap, 702 A_XGM_TX_SPI4_SOP_EOP_CNT + 703 mac->offset))); 704 cfg = t3_read_reg(adap, A_MPS_CFG); 705 active = macidx(mac) ? cfg & F_PORT1ACTIVE : cfg & F_PORT0ACTIVE; 706 enforcepkt = cfg & F_ENFORCEPKT; 707 if (active && enforcepkt && (tx_xcnt == 0)) { 708 t3_write_reg(adap, A_TP_PIO_ADDR, 709 A_TP_TX_DROP_CNT_CH0 + macidx(mac)); 710 tx_tcnt = (G_TXDROPCNTCH0RCVD(t3_read_reg(adap, 711 A_TP_PIO_DATA))); 712 } else 713 goto out; 714 715 } else { 716 mac->toggle_cnt = 0; 717 goto out; 718 } 719 720 if ((tx_tcnt != mac->tx_tcnt) && (mac->tx_xcnt == 0)) { 721 if (mac->toggle_cnt > 4) { 722 status = 2; 723 goto out; 724 } else { 725 status = 1; 726 goto out; 727 } 728 } else { 729 mac->toggle_cnt = 0; 730 goto out; 731 } 732 733 out: 734 mac->tx_tcnt = tx_tcnt; 735 mac->tx_xcnt = tx_xcnt; 736 mac->tx_mcnt = s->tx_frames; 737 mac->rx_pause = s->rx_pause; 738 if (status == 1) { 739 t3_write_reg(adap, A_XGM_TX_CTRL + mac->offset, 0); 740 t3_read_reg(adap, A_XGM_TX_CTRL + mac->offset); /* flush */ 741 t3_write_reg(adap, A_XGM_TX_CTRL + mac->offset, mac->txen); 742 t3_read_reg(adap, A_XGM_TX_CTRL + mac->offset); /* flush */ 743 mac->toggle_cnt++; 744 } else if (status == 2) { 745 t3_mac_reset(mac, -1); 746 mac->toggle_cnt = 0; 747 } 748 return status; 749 } 750 751 /** 752 * t3_mac_update_stats - accumulate MAC statistics 753 * @mac: the MAC handle 754 * 755 * This function is called periodically to accumulate the current values 756 * of the RMON counters into the port statistics. Since the packet 757 * counters are only 32 bits they can overflow in ~286 secs at 10G, so the 758 * function should be called more frequently than that. The byte counters 759 * are 45-bit wide, they would overflow in ~7.8 hours. 760 */ 761 const struct mac_stats *t3_mac_update_stats(struct cmac *mac) 762 { 763 #define RMON_READ(mac, addr) t3_read_reg(mac->adapter, addr + mac->offset) 764 #define RMON_UPDATE(mac, name, reg) \ 765 (mac)->stats.name += (u64)RMON_READ(mac, A_XGM_STAT_##reg) 766 #define RMON_UPDATE64(mac, name, reg_lo, reg_hi) \ 767 (mac)->stats.name += RMON_READ(mac, A_XGM_STAT_##reg_lo) + \ 768 ((u64)RMON_READ(mac, A_XGM_STAT_##reg_hi) << 32) 769 770 u32 v, lo; 771 772 if (mac->multiport) 773 return t3_vsc7323_update_stats(mac); 774 775 RMON_UPDATE64(mac, rx_octets, RX_BYTES_LOW, RX_BYTES_HIGH); 776 RMON_UPDATE64(mac, rx_frames, RX_FRAMES_LOW, RX_FRAMES_HIGH); 777 RMON_UPDATE(mac, rx_mcast_frames, RX_MCAST_FRAMES); 778 RMON_UPDATE(mac, rx_bcast_frames, RX_BCAST_FRAMES); 779 RMON_UPDATE(mac, rx_fcs_errs, RX_CRC_ERR_FRAMES); 780 RMON_UPDATE(mac, rx_pause, RX_PAUSE_FRAMES); 781 RMON_UPDATE(mac, rx_jabber, RX_JABBER_FRAMES); 782 RMON_UPDATE(mac, rx_short, RX_SHORT_FRAMES); 783 RMON_UPDATE(mac, rx_symbol_errs, RX_SYM_CODE_ERR_FRAMES); 784 785 RMON_UPDATE(mac, rx_too_long, RX_OVERSIZE_FRAMES); 786 787 v = RMON_READ(mac, A_XGM_RX_MAX_PKT_SIZE_ERR_CNT); 788 if (mac->adapter->params.rev == T3_REV_B2) 789 v &= 0x7fffffff; 790 mac->stats.rx_too_long += v; 791 792 RMON_UPDATE(mac, rx_frames_64, RX_64B_FRAMES); 793 RMON_UPDATE(mac, rx_frames_65_127, RX_65_127B_FRAMES); 794 RMON_UPDATE(mac, rx_frames_128_255, RX_128_255B_FRAMES); 795 RMON_UPDATE(mac, rx_frames_256_511, RX_256_511B_FRAMES); 796 RMON_UPDATE(mac, rx_frames_512_1023, RX_512_1023B_FRAMES); 797 RMON_UPDATE(mac, rx_frames_1024_1518, RX_1024_1518B_FRAMES); 798 RMON_UPDATE(mac, rx_frames_1519_max, RX_1519_MAXB_FRAMES); 799 800 RMON_UPDATE64(mac, tx_octets, TX_BYTE_LOW, TX_BYTE_HIGH); 801 RMON_UPDATE64(mac, tx_frames, TX_FRAME_LOW, TX_FRAME_HIGH); 802 RMON_UPDATE(mac, tx_mcast_frames, TX_MCAST); 803 RMON_UPDATE(mac, tx_bcast_frames, TX_BCAST); 804 RMON_UPDATE(mac, tx_pause, TX_PAUSE); 805 /* This counts error frames in general (bad FCS, underrun, etc). */ 806 RMON_UPDATE(mac, tx_underrun, TX_ERR_FRAMES); 807 808 RMON_UPDATE(mac, tx_frames_64, TX_64B_FRAMES); 809 RMON_UPDATE(mac, tx_frames_65_127, TX_65_127B_FRAMES); 810 RMON_UPDATE(mac, tx_frames_128_255, TX_128_255B_FRAMES); 811 RMON_UPDATE(mac, tx_frames_256_511, TX_256_511B_FRAMES); 812 RMON_UPDATE(mac, tx_frames_512_1023, TX_512_1023B_FRAMES); 813 RMON_UPDATE(mac, tx_frames_1024_1518, TX_1024_1518B_FRAMES); 814 RMON_UPDATE(mac, tx_frames_1519_max, TX_1519_MAXB_FRAMES); 815 816 /* The next stat isn't clear-on-read. */ 817 t3_write_reg(mac->adapter, A_TP_MIB_INDEX, mac->offset ? 51 : 50); 818 v = t3_read_reg(mac->adapter, A_TP_MIB_RDATA); 819 lo = (u32)mac->stats.rx_cong_drops; 820 mac->stats.rx_cong_drops += (u64)(v - lo); 821 822 return &mac->stats; 823 } 824