1 /***************************************************************************** 2 * * 3 * File: cxgb2.c * 4 * $Revision: 1.25 $ * 5 * $Date: 2005/06/22 00:43:25 $ * 6 * Description: * 7 * Chelsio 10Gb Ethernet Driver. * 8 * * 9 * This program is free software; you can redistribute it and/or modify * 10 * it under the terms of the GNU General Public License, version 2, as * 11 * published by the Free Software Foundation. * 12 * * 13 * You should have received a copy of the GNU General Public License along * 14 * with this program; if not, write to the Free Software Foundation, Inc., * 15 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * 16 * * 17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED * 18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * 20 * * 21 * http://www.chelsio.com * 22 * * 23 * Copyright (c) 2003 - 2005 Chelsio Communications, Inc. * 24 * All rights reserved. * 25 * * 26 * Maintainers: maintainers@chelsio.com * 27 * * 28 * Authors: Dimitrios Michailidis <dm@chelsio.com> * 29 * Tina Yang <tainay@chelsio.com> * 30 * Felix Marti <felix@chelsio.com> * 31 * Scott Bardone <sbardone@chelsio.com> * 32 * Kurt Ottaway <kottaway@chelsio.com> * 33 * Frank DiMambro <frank@chelsio.com> * 34 * * 35 * History: * 36 * * 37 ****************************************************************************/ 38 39 #include "common.h" 40 #include <linux/module.h> 41 #include <linux/init.h> 42 #include <linux/pci.h> 43 #include <linux/netdevice.h> 44 #include <linux/etherdevice.h> 45 #include <linux/if_vlan.h> 46 #include <linux/mii.h> 47 #include <linux/sockios.h> 48 #include <linux/dma-mapping.h> 49 #include <asm/uaccess.h> 50 51 #include "cpl5_cmd.h" 52 #include "regs.h" 53 #include "gmac.h" 54 #include "cphy.h" 55 #include "sge.h" 56 #include "tp.h" 57 #include "espi.h" 58 #include "elmer0.h" 59 60 #include <linux/workqueue.h> 61 62 static inline void schedule_mac_stats_update(struct adapter *ap, int secs) 63 { 64 schedule_delayed_work(&ap->stats_update_task, secs * HZ); 65 } 66 67 static inline void cancel_mac_stats_update(struct adapter *ap) 68 { 69 cancel_delayed_work(&ap->stats_update_task); 70 } 71 72 #define MAX_CMDQ_ENTRIES 16384 73 #define MAX_CMDQ1_ENTRIES 1024 74 #define MAX_RX_BUFFERS 16384 75 #define MAX_RX_JUMBO_BUFFERS 16384 76 #define MAX_TX_BUFFERS_HIGH 16384U 77 #define MAX_TX_BUFFERS_LOW 1536U 78 #define MAX_TX_BUFFERS 1460U 79 #define MIN_FL_ENTRIES 32 80 81 #define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \ 82 NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\ 83 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR) 84 85 /* 86 * The EEPROM is actually bigger but only the first few bytes are used so we 87 * only report those. 88 */ 89 #define EEPROM_SIZE 32 90 91 MODULE_DESCRIPTION(DRV_DESCRIPTION); 92 MODULE_AUTHOR("Chelsio Communications"); 93 MODULE_LICENSE("GPL"); 94 95 static int dflt_msg_enable = DFLT_MSG_ENABLE; 96 97 module_param(dflt_msg_enable, int, 0); 98 MODULE_PARM_DESC(dflt_msg_enable, "Chelsio T1 default message enable bitmap"); 99 100 #define HCLOCK 0x0 101 #define LCLOCK 0x1 102 103 /* T1 cards powersave mode */ 104 static int t1_clock(struct adapter *adapter, int mode); 105 static int t1powersave = 1; /* HW default is powersave mode. */ 106 107 module_param(t1powersave, int, 0); 108 MODULE_PARM_DESC(t1powersave, "Enable/Disable T1 powersaving mode"); 109 110 static int disable_msi = 0; 111 module_param(disable_msi, int, 0); 112 MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)"); 113 114 static const char pci_speed[][4] = { 115 "33", "66", "100", "133" 116 }; 117 118 /* 119 * Setup MAC to receive the types of packets we want. 120 */ 121 static void t1_set_rxmode(struct net_device *dev) 122 { 123 struct adapter *adapter = dev->ml_priv; 124 struct cmac *mac = adapter->port[dev->if_port].mac; 125 struct t1_rx_mode rm; 126 127 rm.dev = dev; 128 mac->ops->set_rx_mode(mac, &rm); 129 } 130 131 static void link_report(struct port_info *p) 132 { 133 if (!netif_carrier_ok(p->dev)) 134 printk(KERN_INFO "%s: link down\n", p->dev->name); 135 else { 136 const char *s = "10Mbps"; 137 138 switch (p->link_config.speed) { 139 case SPEED_10000: s = "10Gbps"; break; 140 case SPEED_1000: s = "1000Mbps"; break; 141 case SPEED_100: s = "100Mbps"; break; 142 } 143 144 printk(KERN_INFO "%s: link up, %s, %s-duplex\n", 145 p->dev->name, s, 146 p->link_config.duplex == DUPLEX_FULL ? "full" : "half"); 147 } 148 } 149 150 void t1_link_negotiated(struct adapter *adapter, int port_id, int link_stat, 151 int speed, int duplex, int pause) 152 { 153 struct port_info *p = &adapter->port[port_id]; 154 155 if (link_stat != netif_carrier_ok(p->dev)) { 156 if (link_stat) 157 netif_carrier_on(p->dev); 158 else 159 netif_carrier_off(p->dev); 160 link_report(p); 161 162 /* multi-ports: inform toe */ 163 if ((speed > 0) && (adapter->params.nports > 1)) { 164 unsigned int sched_speed = 10; 165 switch (speed) { 166 case SPEED_1000: 167 sched_speed = 1000; 168 break; 169 case SPEED_100: 170 sched_speed = 100; 171 break; 172 case SPEED_10: 173 sched_speed = 10; 174 break; 175 } 176 t1_sched_update_parms(adapter->sge, port_id, 0, sched_speed); 177 } 178 } 179 } 180 181 static void link_start(struct port_info *p) 182 { 183 struct cmac *mac = p->mac; 184 185 mac->ops->reset(mac); 186 if (mac->ops->macaddress_set) 187 mac->ops->macaddress_set(mac, p->dev->dev_addr); 188 t1_set_rxmode(p->dev); 189 t1_link_start(p->phy, mac, &p->link_config); 190 mac->ops->enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX); 191 } 192 193 static void enable_hw_csum(struct adapter *adapter) 194 { 195 if (adapter->port[0].dev->hw_features & NETIF_F_TSO) 196 t1_tp_set_ip_checksum_offload(adapter->tp, 1); /* for TSO only */ 197 t1_tp_set_tcp_checksum_offload(adapter->tp, 1); 198 } 199 200 /* 201 * Things to do upon first use of a card. 202 * This must run with the rtnl lock held. 203 */ 204 static int cxgb_up(struct adapter *adapter) 205 { 206 int err = 0; 207 208 if (!(adapter->flags & FULL_INIT_DONE)) { 209 err = t1_init_hw_modules(adapter); 210 if (err) 211 goto out_err; 212 213 enable_hw_csum(adapter); 214 adapter->flags |= FULL_INIT_DONE; 215 } 216 217 t1_interrupts_clear(adapter); 218 219 adapter->params.has_msi = !disable_msi && !pci_enable_msi(adapter->pdev); 220 err = request_irq(adapter->pdev->irq, t1_interrupt, 221 adapter->params.has_msi ? 0 : IRQF_SHARED, 222 adapter->name, adapter); 223 if (err) { 224 if (adapter->params.has_msi) 225 pci_disable_msi(adapter->pdev); 226 227 goto out_err; 228 } 229 230 t1_sge_start(adapter->sge); 231 t1_interrupts_enable(adapter); 232 out_err: 233 return err; 234 } 235 236 /* 237 * Release resources when all the ports have been stopped. 238 */ 239 static void cxgb_down(struct adapter *adapter) 240 { 241 t1_sge_stop(adapter->sge); 242 t1_interrupts_disable(adapter); 243 free_irq(adapter->pdev->irq, adapter); 244 if (adapter->params.has_msi) 245 pci_disable_msi(adapter->pdev); 246 } 247 248 static int cxgb_open(struct net_device *dev) 249 { 250 int err; 251 struct adapter *adapter = dev->ml_priv; 252 int other_ports = adapter->open_device_map & PORT_MASK; 253 254 napi_enable(&adapter->napi); 255 if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0) { 256 napi_disable(&adapter->napi); 257 return err; 258 } 259 260 __set_bit(dev->if_port, &adapter->open_device_map); 261 link_start(&adapter->port[dev->if_port]); 262 netif_start_queue(dev); 263 if (!other_ports && adapter->params.stats_update_period) 264 schedule_mac_stats_update(adapter, 265 adapter->params.stats_update_period); 266 267 t1_vlan_mode(adapter, dev->features); 268 return 0; 269 } 270 271 static int cxgb_close(struct net_device *dev) 272 { 273 struct adapter *adapter = dev->ml_priv; 274 struct port_info *p = &adapter->port[dev->if_port]; 275 struct cmac *mac = p->mac; 276 277 netif_stop_queue(dev); 278 napi_disable(&adapter->napi); 279 mac->ops->disable(mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX); 280 netif_carrier_off(dev); 281 282 clear_bit(dev->if_port, &adapter->open_device_map); 283 if (adapter->params.stats_update_period && 284 !(adapter->open_device_map & PORT_MASK)) { 285 /* Stop statistics accumulation. */ 286 smp_mb__after_clear_bit(); 287 spin_lock(&adapter->work_lock); /* sync with update task */ 288 spin_unlock(&adapter->work_lock); 289 cancel_mac_stats_update(adapter); 290 } 291 292 if (!adapter->open_device_map) 293 cxgb_down(adapter); 294 return 0; 295 } 296 297 static struct net_device_stats *t1_get_stats(struct net_device *dev) 298 { 299 struct adapter *adapter = dev->ml_priv; 300 struct port_info *p = &adapter->port[dev->if_port]; 301 struct net_device_stats *ns = &p->netstats; 302 const struct cmac_statistics *pstats; 303 304 /* Do a full update of the MAC stats */ 305 pstats = p->mac->ops->statistics_update(p->mac, 306 MAC_STATS_UPDATE_FULL); 307 308 ns->tx_packets = pstats->TxUnicastFramesOK + 309 pstats->TxMulticastFramesOK + pstats->TxBroadcastFramesOK; 310 311 ns->rx_packets = pstats->RxUnicastFramesOK + 312 pstats->RxMulticastFramesOK + pstats->RxBroadcastFramesOK; 313 314 ns->tx_bytes = pstats->TxOctetsOK; 315 ns->rx_bytes = pstats->RxOctetsOK; 316 317 ns->tx_errors = pstats->TxLateCollisions + pstats->TxLengthErrors + 318 pstats->TxUnderrun + pstats->TxFramesAbortedDueToXSCollisions; 319 ns->rx_errors = pstats->RxDataErrors + pstats->RxJabberErrors + 320 pstats->RxFCSErrors + pstats->RxAlignErrors + 321 pstats->RxSequenceErrors + pstats->RxFrameTooLongErrors + 322 pstats->RxSymbolErrors + pstats->RxRuntErrors; 323 324 ns->multicast = pstats->RxMulticastFramesOK; 325 ns->collisions = pstats->TxTotalCollisions; 326 327 /* detailed rx_errors */ 328 ns->rx_length_errors = pstats->RxFrameTooLongErrors + 329 pstats->RxJabberErrors; 330 ns->rx_over_errors = 0; 331 ns->rx_crc_errors = pstats->RxFCSErrors; 332 ns->rx_frame_errors = pstats->RxAlignErrors; 333 ns->rx_fifo_errors = 0; 334 ns->rx_missed_errors = 0; 335 336 /* detailed tx_errors */ 337 ns->tx_aborted_errors = pstats->TxFramesAbortedDueToXSCollisions; 338 ns->tx_carrier_errors = 0; 339 ns->tx_fifo_errors = pstats->TxUnderrun; 340 ns->tx_heartbeat_errors = 0; 341 ns->tx_window_errors = pstats->TxLateCollisions; 342 return ns; 343 } 344 345 static u32 get_msglevel(struct net_device *dev) 346 { 347 struct adapter *adapter = dev->ml_priv; 348 349 return adapter->msg_enable; 350 } 351 352 static void set_msglevel(struct net_device *dev, u32 val) 353 { 354 struct adapter *adapter = dev->ml_priv; 355 356 adapter->msg_enable = val; 357 } 358 359 static char stats_strings[][ETH_GSTRING_LEN] = { 360 "TxOctetsOK", 361 "TxOctetsBad", 362 "TxUnicastFramesOK", 363 "TxMulticastFramesOK", 364 "TxBroadcastFramesOK", 365 "TxPauseFrames", 366 "TxFramesWithDeferredXmissions", 367 "TxLateCollisions", 368 "TxTotalCollisions", 369 "TxFramesAbortedDueToXSCollisions", 370 "TxUnderrun", 371 "TxLengthErrors", 372 "TxInternalMACXmitError", 373 "TxFramesWithExcessiveDeferral", 374 "TxFCSErrors", 375 "TxJumboFramesOk", 376 "TxJumboOctetsOk", 377 378 "RxOctetsOK", 379 "RxOctetsBad", 380 "RxUnicastFramesOK", 381 "RxMulticastFramesOK", 382 "RxBroadcastFramesOK", 383 "RxPauseFrames", 384 "RxFCSErrors", 385 "RxAlignErrors", 386 "RxSymbolErrors", 387 "RxDataErrors", 388 "RxSequenceErrors", 389 "RxRuntErrors", 390 "RxJabberErrors", 391 "RxInternalMACRcvError", 392 "RxInRangeLengthErrors", 393 "RxOutOfRangeLengthField", 394 "RxFrameTooLongErrors", 395 "RxJumboFramesOk", 396 "RxJumboOctetsOk", 397 398 /* Port stats */ 399 "RxCsumGood", 400 "TxCsumOffload", 401 "TxTso", 402 "RxVlan", 403 "TxVlan", 404 "TxNeedHeadroom", 405 406 /* Interrupt stats */ 407 "rx drops", 408 "pure_rsps", 409 "unhandled irqs", 410 "respQ_empty", 411 "respQ_overflow", 412 "freelistQ_empty", 413 "pkt_too_big", 414 "pkt_mismatch", 415 "cmdQ_full0", 416 "cmdQ_full1", 417 418 "espi_DIP2ParityErr", 419 "espi_DIP4Err", 420 "espi_RxDrops", 421 "espi_TxDrops", 422 "espi_RxOvfl", 423 "espi_ParityErr" 424 }; 425 426 #define T2_REGMAP_SIZE (3 * 1024) 427 428 static int get_regs_len(struct net_device *dev) 429 { 430 return T2_REGMAP_SIZE; 431 } 432 433 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 434 { 435 struct adapter *adapter = dev->ml_priv; 436 437 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 438 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 439 strlcpy(info->bus_info, pci_name(adapter->pdev), 440 sizeof(info->bus_info)); 441 } 442 443 static int get_sset_count(struct net_device *dev, int sset) 444 { 445 switch (sset) { 446 case ETH_SS_STATS: 447 return ARRAY_SIZE(stats_strings); 448 default: 449 return -EOPNOTSUPP; 450 } 451 } 452 453 static void get_strings(struct net_device *dev, u32 stringset, u8 *data) 454 { 455 if (stringset == ETH_SS_STATS) 456 memcpy(data, stats_strings, sizeof(stats_strings)); 457 } 458 459 static void get_stats(struct net_device *dev, struct ethtool_stats *stats, 460 u64 *data) 461 { 462 struct adapter *adapter = dev->ml_priv; 463 struct cmac *mac = adapter->port[dev->if_port].mac; 464 const struct cmac_statistics *s; 465 const struct sge_intr_counts *t; 466 struct sge_port_stats ss; 467 468 s = mac->ops->statistics_update(mac, MAC_STATS_UPDATE_FULL); 469 t = t1_sge_get_intr_counts(adapter->sge); 470 t1_sge_get_port_stats(adapter->sge, dev->if_port, &ss); 471 472 *data++ = s->TxOctetsOK; 473 *data++ = s->TxOctetsBad; 474 *data++ = s->TxUnicastFramesOK; 475 *data++ = s->TxMulticastFramesOK; 476 *data++ = s->TxBroadcastFramesOK; 477 *data++ = s->TxPauseFrames; 478 *data++ = s->TxFramesWithDeferredXmissions; 479 *data++ = s->TxLateCollisions; 480 *data++ = s->TxTotalCollisions; 481 *data++ = s->TxFramesAbortedDueToXSCollisions; 482 *data++ = s->TxUnderrun; 483 *data++ = s->TxLengthErrors; 484 *data++ = s->TxInternalMACXmitError; 485 *data++ = s->TxFramesWithExcessiveDeferral; 486 *data++ = s->TxFCSErrors; 487 *data++ = s->TxJumboFramesOK; 488 *data++ = s->TxJumboOctetsOK; 489 490 *data++ = s->RxOctetsOK; 491 *data++ = s->RxOctetsBad; 492 *data++ = s->RxUnicastFramesOK; 493 *data++ = s->RxMulticastFramesOK; 494 *data++ = s->RxBroadcastFramesOK; 495 *data++ = s->RxPauseFrames; 496 *data++ = s->RxFCSErrors; 497 *data++ = s->RxAlignErrors; 498 *data++ = s->RxSymbolErrors; 499 *data++ = s->RxDataErrors; 500 *data++ = s->RxSequenceErrors; 501 *data++ = s->RxRuntErrors; 502 *data++ = s->RxJabberErrors; 503 *data++ = s->RxInternalMACRcvError; 504 *data++ = s->RxInRangeLengthErrors; 505 *data++ = s->RxOutOfRangeLengthField; 506 *data++ = s->RxFrameTooLongErrors; 507 *data++ = s->RxJumboFramesOK; 508 *data++ = s->RxJumboOctetsOK; 509 510 *data++ = ss.rx_cso_good; 511 *data++ = ss.tx_cso; 512 *data++ = ss.tx_tso; 513 *data++ = ss.vlan_xtract; 514 *data++ = ss.vlan_insert; 515 *data++ = ss.tx_need_hdrroom; 516 517 *data++ = t->rx_drops; 518 *data++ = t->pure_rsps; 519 *data++ = t->unhandled_irqs; 520 *data++ = t->respQ_empty; 521 *data++ = t->respQ_overflow; 522 *data++ = t->freelistQ_empty; 523 *data++ = t->pkt_too_big; 524 *data++ = t->pkt_mismatch; 525 *data++ = t->cmdQ_full[0]; 526 *data++ = t->cmdQ_full[1]; 527 528 if (adapter->espi) { 529 const struct espi_intr_counts *e; 530 531 e = t1_espi_get_intr_counts(adapter->espi); 532 *data++ = e->DIP2_parity_err; 533 *data++ = e->DIP4_err; 534 *data++ = e->rx_drops; 535 *data++ = e->tx_drops; 536 *data++ = e->rx_ovflw; 537 *data++ = e->parity_err; 538 } 539 } 540 541 static inline void reg_block_dump(struct adapter *ap, void *buf, 542 unsigned int start, unsigned int end) 543 { 544 u32 *p = buf + start; 545 546 for ( ; start <= end; start += sizeof(u32)) 547 *p++ = readl(ap->regs + start); 548 } 549 550 static void get_regs(struct net_device *dev, struct ethtool_regs *regs, 551 void *buf) 552 { 553 struct adapter *ap = dev->ml_priv; 554 555 /* 556 * Version scheme: bits 0..9: chip version, bits 10..15: chip revision 557 */ 558 regs->version = 2; 559 560 memset(buf, 0, T2_REGMAP_SIZE); 561 reg_block_dump(ap, buf, 0, A_SG_RESPACCUTIMER); 562 reg_block_dump(ap, buf, A_MC3_CFG, A_MC4_INT_CAUSE); 563 reg_block_dump(ap, buf, A_TPI_ADDR, A_TPI_PAR); 564 reg_block_dump(ap, buf, A_TP_IN_CONFIG, A_TP_TX_DROP_COUNT); 565 reg_block_dump(ap, buf, A_RAT_ROUTE_CONTROL, A_RAT_INTR_CAUSE); 566 reg_block_dump(ap, buf, A_CSPI_RX_AE_WM, A_CSPI_INTR_ENABLE); 567 reg_block_dump(ap, buf, A_ESPI_SCH_TOKEN0, A_ESPI_GOSTAT); 568 reg_block_dump(ap, buf, A_ULP_ULIMIT, A_ULP_PIO_CTRL); 569 reg_block_dump(ap, buf, A_PL_ENABLE, A_PL_CAUSE); 570 reg_block_dump(ap, buf, A_MC5_CONFIG, A_MC5_MASK_WRITE_CMD); 571 } 572 573 static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 574 { 575 struct adapter *adapter = dev->ml_priv; 576 struct port_info *p = &adapter->port[dev->if_port]; 577 578 cmd->supported = p->link_config.supported; 579 cmd->advertising = p->link_config.advertising; 580 581 if (netif_carrier_ok(dev)) { 582 ethtool_cmd_speed_set(cmd, p->link_config.speed); 583 cmd->duplex = p->link_config.duplex; 584 } else { 585 ethtool_cmd_speed_set(cmd, -1); 586 cmd->duplex = -1; 587 } 588 589 cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE; 590 cmd->phy_address = p->phy->mdio.prtad; 591 cmd->transceiver = XCVR_EXTERNAL; 592 cmd->autoneg = p->link_config.autoneg; 593 cmd->maxtxpkt = 0; 594 cmd->maxrxpkt = 0; 595 return 0; 596 } 597 598 static int speed_duplex_to_caps(int speed, int duplex) 599 { 600 int cap = 0; 601 602 switch (speed) { 603 case SPEED_10: 604 if (duplex == DUPLEX_FULL) 605 cap = SUPPORTED_10baseT_Full; 606 else 607 cap = SUPPORTED_10baseT_Half; 608 break; 609 case SPEED_100: 610 if (duplex == DUPLEX_FULL) 611 cap = SUPPORTED_100baseT_Full; 612 else 613 cap = SUPPORTED_100baseT_Half; 614 break; 615 case SPEED_1000: 616 if (duplex == DUPLEX_FULL) 617 cap = SUPPORTED_1000baseT_Full; 618 else 619 cap = SUPPORTED_1000baseT_Half; 620 break; 621 case SPEED_10000: 622 if (duplex == DUPLEX_FULL) 623 cap = SUPPORTED_10000baseT_Full; 624 } 625 return cap; 626 } 627 628 #define ADVERTISED_MASK (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \ 629 ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \ 630 ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full | \ 631 ADVERTISED_10000baseT_Full) 632 633 static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 634 { 635 struct adapter *adapter = dev->ml_priv; 636 struct port_info *p = &adapter->port[dev->if_port]; 637 struct link_config *lc = &p->link_config; 638 639 if (!(lc->supported & SUPPORTED_Autoneg)) 640 return -EOPNOTSUPP; /* can't change speed/duplex */ 641 642 if (cmd->autoneg == AUTONEG_DISABLE) { 643 u32 speed = ethtool_cmd_speed(cmd); 644 int cap = speed_duplex_to_caps(speed, cmd->duplex); 645 646 if (!(lc->supported & cap) || (speed == SPEED_1000)) 647 return -EINVAL; 648 lc->requested_speed = speed; 649 lc->requested_duplex = cmd->duplex; 650 lc->advertising = 0; 651 } else { 652 cmd->advertising &= ADVERTISED_MASK; 653 if (cmd->advertising & (cmd->advertising - 1)) 654 cmd->advertising = lc->supported; 655 cmd->advertising &= lc->supported; 656 if (!cmd->advertising) 657 return -EINVAL; 658 lc->requested_speed = SPEED_INVALID; 659 lc->requested_duplex = DUPLEX_INVALID; 660 lc->advertising = cmd->advertising | ADVERTISED_Autoneg; 661 } 662 lc->autoneg = cmd->autoneg; 663 if (netif_running(dev)) 664 t1_link_start(p->phy, p->mac, lc); 665 return 0; 666 } 667 668 static void get_pauseparam(struct net_device *dev, 669 struct ethtool_pauseparam *epause) 670 { 671 struct adapter *adapter = dev->ml_priv; 672 struct port_info *p = &adapter->port[dev->if_port]; 673 674 epause->autoneg = (p->link_config.requested_fc & PAUSE_AUTONEG) != 0; 675 epause->rx_pause = (p->link_config.fc & PAUSE_RX) != 0; 676 epause->tx_pause = (p->link_config.fc & PAUSE_TX) != 0; 677 } 678 679 static int set_pauseparam(struct net_device *dev, 680 struct ethtool_pauseparam *epause) 681 { 682 struct adapter *adapter = dev->ml_priv; 683 struct port_info *p = &adapter->port[dev->if_port]; 684 struct link_config *lc = &p->link_config; 685 686 if (epause->autoneg == AUTONEG_DISABLE) 687 lc->requested_fc = 0; 688 else if (lc->supported & SUPPORTED_Autoneg) 689 lc->requested_fc = PAUSE_AUTONEG; 690 else 691 return -EINVAL; 692 693 if (epause->rx_pause) 694 lc->requested_fc |= PAUSE_RX; 695 if (epause->tx_pause) 696 lc->requested_fc |= PAUSE_TX; 697 if (lc->autoneg == AUTONEG_ENABLE) { 698 if (netif_running(dev)) 699 t1_link_start(p->phy, p->mac, lc); 700 } else { 701 lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX); 702 if (netif_running(dev)) 703 p->mac->ops->set_speed_duplex_fc(p->mac, -1, -1, 704 lc->fc); 705 } 706 return 0; 707 } 708 709 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e) 710 { 711 struct adapter *adapter = dev->ml_priv; 712 int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0; 713 714 e->rx_max_pending = MAX_RX_BUFFERS; 715 e->rx_jumbo_max_pending = MAX_RX_JUMBO_BUFFERS; 716 e->tx_max_pending = MAX_CMDQ_ENTRIES; 717 718 e->rx_pending = adapter->params.sge.freelQ_size[!jumbo_fl]; 719 e->rx_jumbo_pending = adapter->params.sge.freelQ_size[jumbo_fl]; 720 e->tx_pending = adapter->params.sge.cmdQ_size[0]; 721 } 722 723 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e) 724 { 725 struct adapter *adapter = dev->ml_priv; 726 int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0; 727 728 if (e->rx_pending > MAX_RX_BUFFERS || e->rx_mini_pending || 729 e->rx_jumbo_pending > MAX_RX_JUMBO_BUFFERS || 730 e->tx_pending > MAX_CMDQ_ENTRIES || 731 e->rx_pending < MIN_FL_ENTRIES || 732 e->rx_jumbo_pending < MIN_FL_ENTRIES || 733 e->tx_pending < (adapter->params.nports + 1) * (MAX_SKB_FRAGS + 1)) 734 return -EINVAL; 735 736 if (adapter->flags & FULL_INIT_DONE) 737 return -EBUSY; 738 739 adapter->params.sge.freelQ_size[!jumbo_fl] = e->rx_pending; 740 adapter->params.sge.freelQ_size[jumbo_fl] = e->rx_jumbo_pending; 741 adapter->params.sge.cmdQ_size[0] = e->tx_pending; 742 adapter->params.sge.cmdQ_size[1] = e->tx_pending > MAX_CMDQ1_ENTRIES ? 743 MAX_CMDQ1_ENTRIES : e->tx_pending; 744 return 0; 745 } 746 747 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c) 748 { 749 struct adapter *adapter = dev->ml_priv; 750 751 adapter->params.sge.rx_coalesce_usecs = c->rx_coalesce_usecs; 752 adapter->params.sge.coalesce_enable = c->use_adaptive_rx_coalesce; 753 adapter->params.sge.sample_interval_usecs = c->rate_sample_interval; 754 t1_sge_set_coalesce_params(adapter->sge, &adapter->params.sge); 755 return 0; 756 } 757 758 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c) 759 { 760 struct adapter *adapter = dev->ml_priv; 761 762 c->rx_coalesce_usecs = adapter->params.sge.rx_coalesce_usecs; 763 c->rate_sample_interval = adapter->params.sge.sample_interval_usecs; 764 c->use_adaptive_rx_coalesce = adapter->params.sge.coalesce_enable; 765 return 0; 766 } 767 768 static int get_eeprom_len(struct net_device *dev) 769 { 770 struct adapter *adapter = dev->ml_priv; 771 772 return t1_is_asic(adapter) ? EEPROM_SIZE : 0; 773 } 774 775 #define EEPROM_MAGIC(ap) \ 776 (PCI_VENDOR_ID_CHELSIO | ((ap)->params.chip_version << 16)) 777 778 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e, 779 u8 *data) 780 { 781 int i; 782 u8 buf[EEPROM_SIZE] __attribute__((aligned(4))); 783 struct adapter *adapter = dev->ml_priv; 784 785 e->magic = EEPROM_MAGIC(adapter); 786 for (i = e->offset & ~3; i < e->offset + e->len; i += sizeof(u32)) 787 t1_seeprom_read(adapter, i, (__le32 *)&buf[i]); 788 memcpy(data, buf + e->offset, e->len); 789 return 0; 790 } 791 792 static const struct ethtool_ops t1_ethtool_ops = { 793 .get_settings = get_settings, 794 .set_settings = set_settings, 795 .get_drvinfo = get_drvinfo, 796 .get_msglevel = get_msglevel, 797 .set_msglevel = set_msglevel, 798 .get_ringparam = get_sge_param, 799 .set_ringparam = set_sge_param, 800 .get_coalesce = get_coalesce, 801 .set_coalesce = set_coalesce, 802 .get_eeprom_len = get_eeprom_len, 803 .get_eeprom = get_eeprom, 804 .get_pauseparam = get_pauseparam, 805 .set_pauseparam = set_pauseparam, 806 .get_link = ethtool_op_get_link, 807 .get_strings = get_strings, 808 .get_sset_count = get_sset_count, 809 .get_ethtool_stats = get_stats, 810 .get_regs_len = get_regs_len, 811 .get_regs = get_regs, 812 }; 813 814 static int t1_ioctl(struct net_device *dev, struct ifreq *req, int cmd) 815 { 816 struct adapter *adapter = dev->ml_priv; 817 struct mdio_if_info *mdio = &adapter->port[dev->if_port].phy->mdio; 818 819 return mdio_mii_ioctl(mdio, if_mii(req), cmd); 820 } 821 822 static int t1_change_mtu(struct net_device *dev, int new_mtu) 823 { 824 int ret; 825 struct adapter *adapter = dev->ml_priv; 826 struct cmac *mac = adapter->port[dev->if_port].mac; 827 828 if (!mac->ops->set_mtu) 829 return -EOPNOTSUPP; 830 if (new_mtu < 68) 831 return -EINVAL; 832 if ((ret = mac->ops->set_mtu(mac, new_mtu))) 833 return ret; 834 dev->mtu = new_mtu; 835 return 0; 836 } 837 838 static int t1_set_mac_addr(struct net_device *dev, void *p) 839 { 840 struct adapter *adapter = dev->ml_priv; 841 struct cmac *mac = adapter->port[dev->if_port].mac; 842 struct sockaddr *addr = p; 843 844 if (!mac->ops->macaddress_set) 845 return -EOPNOTSUPP; 846 847 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 848 mac->ops->macaddress_set(mac, dev->dev_addr); 849 return 0; 850 } 851 852 static netdev_features_t t1_fix_features(struct net_device *dev, 853 netdev_features_t features) 854 { 855 /* 856 * Since there is no support for separate rx/tx vlan accel 857 * enable/disable make sure tx flag is always in same state as rx. 858 */ 859 if (features & NETIF_F_HW_VLAN_RX) 860 features |= NETIF_F_HW_VLAN_TX; 861 else 862 features &= ~NETIF_F_HW_VLAN_TX; 863 864 return features; 865 } 866 867 static int t1_set_features(struct net_device *dev, netdev_features_t features) 868 { 869 netdev_features_t changed = dev->features ^ features; 870 struct adapter *adapter = dev->ml_priv; 871 872 if (changed & NETIF_F_HW_VLAN_RX) 873 t1_vlan_mode(adapter, features); 874 875 return 0; 876 } 877 #ifdef CONFIG_NET_POLL_CONTROLLER 878 static void t1_netpoll(struct net_device *dev) 879 { 880 unsigned long flags; 881 struct adapter *adapter = dev->ml_priv; 882 883 local_irq_save(flags); 884 t1_interrupt(adapter->pdev->irq, adapter); 885 local_irq_restore(flags); 886 } 887 #endif 888 889 /* 890 * Periodic accumulation of MAC statistics. This is used only if the MAC 891 * does not have any other way to prevent stats counter overflow. 892 */ 893 static void mac_stats_task(struct work_struct *work) 894 { 895 int i; 896 struct adapter *adapter = 897 container_of(work, struct adapter, stats_update_task.work); 898 899 for_each_port(adapter, i) { 900 struct port_info *p = &adapter->port[i]; 901 902 if (netif_running(p->dev)) 903 p->mac->ops->statistics_update(p->mac, 904 MAC_STATS_UPDATE_FAST); 905 } 906 907 /* Schedule the next statistics update if any port is active. */ 908 spin_lock(&adapter->work_lock); 909 if (adapter->open_device_map & PORT_MASK) 910 schedule_mac_stats_update(adapter, 911 adapter->params.stats_update_period); 912 spin_unlock(&adapter->work_lock); 913 } 914 915 /* 916 * Processes elmer0 external interrupts in process context. 917 */ 918 static void ext_intr_task(struct work_struct *work) 919 { 920 struct adapter *adapter = 921 container_of(work, struct adapter, ext_intr_handler_task); 922 923 t1_elmer0_ext_intr_handler(adapter); 924 925 /* Now reenable external interrupts */ 926 spin_lock_irq(&adapter->async_lock); 927 adapter->slow_intr_mask |= F_PL_INTR_EXT; 928 writel(F_PL_INTR_EXT, adapter->regs + A_PL_CAUSE); 929 writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA, 930 adapter->regs + A_PL_ENABLE); 931 spin_unlock_irq(&adapter->async_lock); 932 } 933 934 /* 935 * Interrupt-context handler for elmer0 external interrupts. 936 */ 937 void t1_elmer0_ext_intr(struct adapter *adapter) 938 { 939 /* 940 * Schedule a task to handle external interrupts as we require 941 * a process context. We disable EXT interrupts in the interim 942 * and let the task reenable them when it's done. 943 */ 944 adapter->slow_intr_mask &= ~F_PL_INTR_EXT; 945 writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA, 946 adapter->regs + A_PL_ENABLE); 947 schedule_work(&adapter->ext_intr_handler_task); 948 } 949 950 void t1_fatal_err(struct adapter *adapter) 951 { 952 if (adapter->flags & FULL_INIT_DONE) { 953 t1_sge_stop(adapter->sge); 954 t1_interrupts_disable(adapter); 955 } 956 pr_alert("%s: encountered fatal error, operation suspended\n", 957 adapter->name); 958 } 959 960 static const struct net_device_ops cxgb_netdev_ops = { 961 .ndo_open = cxgb_open, 962 .ndo_stop = cxgb_close, 963 .ndo_start_xmit = t1_start_xmit, 964 .ndo_get_stats = t1_get_stats, 965 .ndo_validate_addr = eth_validate_addr, 966 .ndo_set_rx_mode = t1_set_rxmode, 967 .ndo_do_ioctl = t1_ioctl, 968 .ndo_change_mtu = t1_change_mtu, 969 .ndo_set_mac_address = t1_set_mac_addr, 970 .ndo_fix_features = t1_fix_features, 971 .ndo_set_features = t1_set_features, 972 #ifdef CONFIG_NET_POLL_CONTROLLER 973 .ndo_poll_controller = t1_netpoll, 974 #endif 975 }; 976 977 static int __devinit init_one(struct pci_dev *pdev, 978 const struct pci_device_id *ent) 979 { 980 static int version_printed; 981 982 int i, err, pci_using_dac = 0; 983 unsigned long mmio_start, mmio_len; 984 const struct board_info *bi; 985 struct adapter *adapter = NULL; 986 struct port_info *pi; 987 988 if (!version_printed) { 989 printk(KERN_INFO "%s - version %s\n", DRV_DESCRIPTION, 990 DRV_VERSION); 991 ++version_printed; 992 } 993 994 err = pci_enable_device(pdev); 995 if (err) 996 return err; 997 998 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { 999 pr_err("%s: cannot find PCI device memory base address\n", 1000 pci_name(pdev)); 1001 err = -ENODEV; 1002 goto out_disable_pdev; 1003 } 1004 1005 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { 1006 pci_using_dac = 1; 1007 1008 if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) { 1009 pr_err("%s: unable to obtain 64-bit DMA for " 1010 "consistent allocations\n", pci_name(pdev)); 1011 err = -ENODEV; 1012 goto out_disable_pdev; 1013 } 1014 1015 } else if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) != 0) { 1016 pr_err("%s: no usable DMA configuration\n", pci_name(pdev)); 1017 goto out_disable_pdev; 1018 } 1019 1020 err = pci_request_regions(pdev, DRV_NAME); 1021 if (err) { 1022 pr_err("%s: cannot obtain PCI resources\n", pci_name(pdev)); 1023 goto out_disable_pdev; 1024 } 1025 1026 pci_set_master(pdev); 1027 1028 mmio_start = pci_resource_start(pdev, 0); 1029 mmio_len = pci_resource_len(pdev, 0); 1030 bi = t1_get_board_info(ent->driver_data); 1031 1032 for (i = 0; i < bi->port_number; ++i) { 1033 struct net_device *netdev; 1034 1035 netdev = alloc_etherdev(adapter ? 0 : sizeof(*adapter)); 1036 if (!netdev) { 1037 err = -ENOMEM; 1038 goto out_free_dev; 1039 } 1040 1041 SET_NETDEV_DEV(netdev, &pdev->dev); 1042 1043 if (!adapter) { 1044 adapter = netdev_priv(netdev); 1045 adapter->pdev = pdev; 1046 adapter->port[0].dev = netdev; /* so we don't leak it */ 1047 1048 adapter->regs = ioremap(mmio_start, mmio_len); 1049 if (!adapter->regs) { 1050 pr_err("%s: cannot map device registers\n", 1051 pci_name(pdev)); 1052 err = -ENOMEM; 1053 goto out_free_dev; 1054 } 1055 1056 if (t1_get_board_rev(adapter, bi, &adapter->params)) { 1057 err = -ENODEV; /* Can't handle this chip rev */ 1058 goto out_free_dev; 1059 } 1060 1061 adapter->name = pci_name(pdev); 1062 adapter->msg_enable = dflt_msg_enable; 1063 adapter->mmio_len = mmio_len; 1064 1065 spin_lock_init(&adapter->tpi_lock); 1066 spin_lock_init(&adapter->work_lock); 1067 spin_lock_init(&adapter->async_lock); 1068 spin_lock_init(&adapter->mac_lock); 1069 1070 INIT_WORK(&adapter->ext_intr_handler_task, 1071 ext_intr_task); 1072 INIT_DELAYED_WORK(&adapter->stats_update_task, 1073 mac_stats_task); 1074 1075 pci_set_drvdata(pdev, netdev); 1076 } 1077 1078 pi = &adapter->port[i]; 1079 pi->dev = netdev; 1080 netif_carrier_off(netdev); 1081 netdev->irq = pdev->irq; 1082 netdev->if_port = i; 1083 netdev->mem_start = mmio_start; 1084 netdev->mem_end = mmio_start + mmio_len - 1; 1085 netdev->ml_priv = adapter; 1086 netdev->hw_features |= NETIF_F_SG | NETIF_F_IP_CSUM | 1087 NETIF_F_RXCSUM; 1088 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM | 1089 NETIF_F_RXCSUM | NETIF_F_LLTX; 1090 1091 if (pci_using_dac) 1092 netdev->features |= NETIF_F_HIGHDMA; 1093 if (vlan_tso_capable(adapter)) { 1094 netdev->features |= 1095 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; 1096 netdev->hw_features |= NETIF_F_HW_VLAN_RX; 1097 1098 /* T204: disable TSO */ 1099 if (!(is_T2(adapter)) || bi->port_number != 4) { 1100 netdev->hw_features |= NETIF_F_TSO; 1101 netdev->features |= NETIF_F_TSO; 1102 } 1103 } 1104 1105 netdev->netdev_ops = &cxgb_netdev_ops; 1106 netdev->hard_header_len += (netdev->hw_features & NETIF_F_TSO) ? 1107 sizeof(struct cpl_tx_pkt_lso) : sizeof(struct cpl_tx_pkt); 1108 1109 netif_napi_add(netdev, &adapter->napi, t1_poll, 64); 1110 1111 SET_ETHTOOL_OPS(netdev, &t1_ethtool_ops); 1112 } 1113 1114 if (t1_init_sw_modules(adapter, bi) < 0) { 1115 err = -ENODEV; 1116 goto out_free_dev; 1117 } 1118 1119 /* 1120 * The card is now ready to go. If any errors occur during device 1121 * registration we do not fail the whole card but rather proceed only 1122 * with the ports we manage to register successfully. However we must 1123 * register at least one net device. 1124 */ 1125 for (i = 0; i < bi->port_number; ++i) { 1126 err = register_netdev(adapter->port[i].dev); 1127 if (err) 1128 pr_warning("%s: cannot register net device %s, skipping\n", 1129 pci_name(pdev), adapter->port[i].dev->name); 1130 else { 1131 /* 1132 * Change the name we use for messages to the name of 1133 * the first successfully registered interface. 1134 */ 1135 if (!adapter->registered_device_map) 1136 adapter->name = adapter->port[i].dev->name; 1137 1138 __set_bit(i, &adapter->registered_device_map); 1139 } 1140 } 1141 if (!adapter->registered_device_map) { 1142 pr_err("%s: could not register any net devices\n", 1143 pci_name(pdev)); 1144 goto out_release_adapter_res; 1145 } 1146 1147 printk(KERN_INFO "%s: %s (rev %d), %s %dMHz/%d-bit\n", adapter->name, 1148 bi->desc, adapter->params.chip_revision, 1149 adapter->params.pci.is_pcix ? "PCIX" : "PCI", 1150 adapter->params.pci.speed, adapter->params.pci.width); 1151 1152 /* 1153 * Set the T1B ASIC and memory clocks. 1154 */ 1155 if (t1powersave) 1156 adapter->t1powersave = LCLOCK; /* HW default is powersave mode. */ 1157 else 1158 adapter->t1powersave = HCLOCK; 1159 if (t1_is_T1B(adapter)) 1160 t1_clock(adapter, t1powersave); 1161 1162 return 0; 1163 1164 out_release_adapter_res: 1165 t1_free_sw_modules(adapter); 1166 out_free_dev: 1167 if (adapter) { 1168 if (adapter->regs) 1169 iounmap(adapter->regs); 1170 for (i = bi->port_number - 1; i >= 0; --i) 1171 if (adapter->port[i].dev) 1172 free_netdev(adapter->port[i].dev); 1173 } 1174 pci_release_regions(pdev); 1175 out_disable_pdev: 1176 pci_disable_device(pdev); 1177 pci_set_drvdata(pdev, NULL); 1178 return err; 1179 } 1180 1181 static void bit_bang(struct adapter *adapter, int bitdata, int nbits) 1182 { 1183 int data; 1184 int i; 1185 u32 val; 1186 1187 enum { 1188 S_CLOCK = 1 << 3, 1189 S_DATA = 1 << 4 1190 }; 1191 1192 for (i = (nbits - 1); i > -1; i--) { 1193 1194 udelay(50); 1195 1196 data = ((bitdata >> i) & 0x1); 1197 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1198 1199 if (data) 1200 val |= S_DATA; 1201 else 1202 val &= ~S_DATA; 1203 1204 udelay(50); 1205 1206 /* Set SCLOCK low */ 1207 val &= ~S_CLOCK; 1208 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1209 1210 udelay(50); 1211 1212 /* Write SCLOCK high */ 1213 val |= S_CLOCK; 1214 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1215 1216 } 1217 } 1218 1219 static int t1_clock(struct adapter *adapter, int mode) 1220 { 1221 u32 val; 1222 int M_CORE_VAL; 1223 int M_MEM_VAL; 1224 1225 enum { 1226 M_CORE_BITS = 9, 1227 T_CORE_VAL = 0, 1228 T_CORE_BITS = 2, 1229 N_CORE_VAL = 0, 1230 N_CORE_BITS = 2, 1231 M_MEM_BITS = 9, 1232 T_MEM_VAL = 0, 1233 T_MEM_BITS = 2, 1234 N_MEM_VAL = 0, 1235 N_MEM_BITS = 2, 1236 NP_LOAD = 1 << 17, 1237 S_LOAD_MEM = 1 << 5, 1238 S_LOAD_CORE = 1 << 6, 1239 S_CLOCK = 1 << 3 1240 }; 1241 1242 if (!t1_is_T1B(adapter)) 1243 return -ENODEV; /* Can't re-clock this chip. */ 1244 1245 if (mode & 2) 1246 return 0; /* show current mode. */ 1247 1248 if ((adapter->t1powersave & 1) == (mode & 1)) 1249 return -EALREADY; /* ASIC already running in mode. */ 1250 1251 if ((mode & 1) == HCLOCK) { 1252 M_CORE_VAL = 0x14; 1253 M_MEM_VAL = 0x18; 1254 adapter->t1powersave = HCLOCK; /* overclock */ 1255 } else { 1256 M_CORE_VAL = 0xe; 1257 M_MEM_VAL = 0x10; 1258 adapter->t1powersave = LCLOCK; /* underclock */ 1259 } 1260 1261 /* Don't interrupt this serial stream! */ 1262 spin_lock(&adapter->tpi_lock); 1263 1264 /* Initialize for ASIC core */ 1265 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1266 val |= NP_LOAD; 1267 udelay(50); 1268 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1269 udelay(50); 1270 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1271 val &= ~S_LOAD_CORE; 1272 val &= ~S_CLOCK; 1273 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1274 udelay(50); 1275 1276 /* Serial program the ASIC clock synthesizer */ 1277 bit_bang(adapter, T_CORE_VAL, T_CORE_BITS); 1278 bit_bang(adapter, N_CORE_VAL, N_CORE_BITS); 1279 bit_bang(adapter, M_CORE_VAL, M_CORE_BITS); 1280 udelay(50); 1281 1282 /* Finish ASIC core */ 1283 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1284 val |= S_LOAD_CORE; 1285 udelay(50); 1286 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1287 udelay(50); 1288 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1289 val &= ~S_LOAD_CORE; 1290 udelay(50); 1291 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1292 udelay(50); 1293 1294 /* Initialize for memory */ 1295 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1296 val |= NP_LOAD; 1297 udelay(50); 1298 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1299 udelay(50); 1300 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1301 val &= ~S_LOAD_MEM; 1302 val &= ~S_CLOCK; 1303 udelay(50); 1304 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1305 udelay(50); 1306 1307 /* Serial program the memory clock synthesizer */ 1308 bit_bang(adapter, T_MEM_VAL, T_MEM_BITS); 1309 bit_bang(adapter, N_MEM_VAL, N_MEM_BITS); 1310 bit_bang(adapter, M_MEM_VAL, M_MEM_BITS); 1311 udelay(50); 1312 1313 /* Finish memory */ 1314 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1315 val |= S_LOAD_MEM; 1316 udelay(50); 1317 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1318 udelay(50); 1319 __t1_tpi_read(adapter, A_ELMER0_GPO, &val); 1320 val &= ~S_LOAD_MEM; 1321 udelay(50); 1322 __t1_tpi_write(adapter, A_ELMER0_GPO, val); 1323 1324 spin_unlock(&adapter->tpi_lock); 1325 1326 return 0; 1327 } 1328 1329 static inline void t1_sw_reset(struct pci_dev *pdev) 1330 { 1331 pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 3); 1332 pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 0); 1333 } 1334 1335 static void __devexit remove_one(struct pci_dev *pdev) 1336 { 1337 struct net_device *dev = pci_get_drvdata(pdev); 1338 struct adapter *adapter = dev->ml_priv; 1339 int i; 1340 1341 for_each_port(adapter, i) { 1342 if (test_bit(i, &adapter->registered_device_map)) 1343 unregister_netdev(adapter->port[i].dev); 1344 } 1345 1346 t1_free_sw_modules(adapter); 1347 iounmap(adapter->regs); 1348 1349 while (--i >= 0) { 1350 if (adapter->port[i].dev) 1351 free_netdev(adapter->port[i].dev); 1352 } 1353 1354 pci_release_regions(pdev); 1355 pci_disable_device(pdev); 1356 pci_set_drvdata(pdev, NULL); 1357 t1_sw_reset(pdev); 1358 } 1359 1360 static struct pci_driver driver = { 1361 .name = DRV_NAME, 1362 .id_table = t1_pci_tbl, 1363 .probe = init_one, 1364 .remove = __devexit_p(remove_one), 1365 }; 1366 1367 static int __init t1_init_module(void) 1368 { 1369 return pci_register_driver(&driver); 1370 } 1371 1372 static void __exit t1_cleanup_module(void) 1373 { 1374 pci_unregister_driver(&driver); 1375 } 1376 1377 module_init(t1_init_module); 1378 module_exit(t1_cleanup_module); 1379