SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/chelsio/cxgb2.c

   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/proc_fs.h>
  49 #include <linux/dma-mapping.h>
  50 #include <asm/uaccess.h>
  51
  52 #include "cpl5_cmd.h"
  53 #include "regs.h"
  54 #include "gmac.h"
  55 #include "cphy.h"
  56 #include "sge.h"
  57 #include "espi.h"
  58
  59 #ifdef work_struct
  60 #include <linux/tqueue.h>
  61 #define INIT_WORK INIT_TQUEUE
  62 #define schedule_work schedule_task
  63 #define flush_scheduled_work flush_scheduled_tasks
  64
  65 static inline void schedule_mac_stats_update(struct adapter *ap, int secs)
  66 {
  67         mod_timer(&ap->stats_update_timer, jiffies + secs * HZ);
  68 }
  69
  70 static inline void cancel_mac_stats_update(struct adapter *ap)
  71 {
  72         del_timer_sync(&ap->stats_update_timer);
  73         flush_scheduled_tasks();
  74 }
  75
  76 /*
  77  * Stats update timer for 2.4.  It schedules a task to do the actual update as
  78  * we need to access MAC statistics in process context.
  79  */
  80 static void mac_stats_timer(unsigned long data)
  81 {
  82         struct adapter *ap = (struct adapter *)data;
  83
  84         schedule_task(&ap->stats_update_task);
  85 }
  86 #else
  87 #include <linux/workqueue.h>
  88
  89 static inline void schedule_mac_stats_update(struct adapter *ap, int secs)
  90 {
  91         schedule_delayed_work(&ap->stats_update_task, secs * HZ);
  92 }
  93
  94 static inline void cancel_mac_stats_update(struct adapter *ap)
  95 {
  96         cancel_delayed_work(&ap->stats_update_task);
  97 }
  98 #endif
  99
 100 #define MAX_CMDQ_ENTRIES 16384
 101 #define MAX_CMDQ1_ENTRIES 1024
 102 #define MAX_RX_BUFFERS 16384
 103 #define MAX_RX_JUMBO_BUFFERS 16384
 104 #define MAX_TX_BUFFERS_HIGH     16384U
 105 #define MAX_TX_BUFFERS_LOW      1536U
 106 #define MIN_FL_ENTRIES 32
 107
 108 #define PORT_MASK ((1 << MAX_NPORTS) - 1)
 109
 110 #define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \
 111                          NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\
 112                          NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR)
 113
 114 /*
 115  * The EEPROM is actually bigger but only the first few bytes are used so we
 116  * only report those.
 117  */
 118 #define EEPROM_SIZE 32
 119
 120 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 121 MODULE_AUTHOR("Chelsio Communications");
 122 MODULE_LICENSE("GPL");
 123
 124 static int dflt_msg_enable = DFLT_MSG_ENABLE;
 125
 126 module_param(dflt_msg_enable, int, 0);
 127 MODULE_PARM_DESC(dflt_msg_enable, "Chelsio T1 message enable bitmap");
 128
 129
 130 static const char pci_speed[][4] = {
 131         "33", "66", "100", "133"
 132 };
 133
 134 /*
 135  * Setup MAC to receive the types of packets we want.
 136  */
 137 static void t1_set_rxmode(struct net_device *dev)
 138 {
 139         struct adapter *adapter = dev->priv;
 140         struct cmac *mac = adapter->port[dev->if_port].mac;
 141         struct t1_rx_mode rm;
 142
 143         rm.dev = dev;
 144         rm.idx = 0;
 145         rm.list = dev->mc_list;
 146         mac->ops->set_rx_mode(mac, &rm);
 147 }
 148
 149 static void link_report(struct port_info *p)
 150 {
 151         if (!netif_carrier_ok(p->dev))
 152                 printk(KERN_INFO "%s: link down\n", p->dev->name);
 153         else {
 154                 const char *s = "10Mbps";
 155
 156                 switch (p->link_config.speed) {
 157                         case SPEED_10000: s = "10Gbps"; break;
 158                         case SPEED_1000:  s = "1000Mbps"; break;
 159                         case SPEED_100:   s = "100Mbps"; break;
 160                 }
 161
 162         printk(KERN_INFO "%s: link up, %s, %s-duplex\n",
 163                        p->dev->name, s,
 164                        p->link_config.duplex == DUPLEX_FULL ? "full" : "half");
 165         }
 166 }
 167
 168 void t1_link_changed(struct adapter *adapter, int port_id, int link_stat,
 169                         int speed, int duplex, int pause)
 170 {
 171         struct port_info *p = &adapter->port[port_id];
 172
 173         if (link_stat != netif_carrier_ok(p->dev)) {
 174                 if (link_stat)
 175                         netif_carrier_on(p->dev);
 176                 else
 177                         netif_carrier_off(p->dev);
 178                 link_report(p);
 179
 180         }
 181 }
 182
 183 static void link_start(struct port_info *p)
 184 {
 185         struct cmac *mac = p->mac;
 186
 187         mac->ops->reset(mac);
 188         if (mac->ops->macaddress_set)
 189                 mac->ops->macaddress_set(mac, p->dev->dev_addr);
 190         t1_set_rxmode(p->dev);
 191         t1_link_start(p->phy, mac, &p->link_config);
 192         mac->ops->enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX);
 193 }
 194
 195 static void enable_hw_csum(struct adapter *adapter)
 196 {
 197         if (adapter->flags & TSO_CAPABLE)
 198                 t1_tp_set_ip_checksum_offload(adapter, 1); /* for TSO only */
 199         t1_tp_set_tcp_checksum_offload(adapter, 1);
 200 }
 201
 202 /*
 203  * Things to do upon first use of a card.
 204  * This must run with the rtnl lock held.
 205  */
 206 static int cxgb_up(struct adapter *adapter)
 207 {
 208         int err = 0;
 209
 210         if (!(adapter->flags & FULL_INIT_DONE)) {
 211                 err = t1_init_hw_modules(adapter);
 212                 if (err)
 213                         goto out_err;
 214
 215                 enable_hw_csum(adapter);
 216                 adapter->flags |= FULL_INIT_DONE;
 217         }
 218
 219         t1_interrupts_clear(adapter);
 220         if ((err = request_irq(adapter->pdev->irq,
 221                                t1_select_intr_handler(adapter), IRQF_SHARED,
 222                                adapter->name, adapter))) {
 223                 goto out_err;
 224         }
 225         t1_sge_start(adapter->sge);
 226         t1_interrupts_enable(adapter);
 227  out_err:
 228         return err;
 229 }
 230
 231 /*
 232  * Release resources when all the ports have been stopped.
 233  */
 234 static void cxgb_down(struct adapter *adapter)
 235 {
 236         t1_sge_stop(adapter->sge);
 237         t1_interrupts_disable(adapter);
 238         free_irq(adapter->pdev->irq, adapter);
 239 }
 240
 241 static int cxgb_open(struct net_device *dev)
 242 {
 243         int err;
 244         struct adapter *adapter = dev->priv;
 245         int other_ports = adapter->open_device_map & PORT_MASK;
 246
 247         if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0)
 248                 return err;
 249
 250         __set_bit(dev->if_port, &adapter->open_device_map);
 251         link_start(&adapter->port[dev->if_port]);
 252         netif_start_queue(dev);
 253         if (!other_ports && adapter->params.stats_update_period)
 254                 schedule_mac_stats_update(adapter,
 255                                           adapter->params.stats_update_period);
 256         return 0;
 257 }
 258
 259 static int cxgb_close(struct net_device *dev)
 260 {
 261         struct adapter *adapter = dev->priv;
 262         struct port_info *p = &adapter->port[dev->if_port];
 263         struct cmac *mac = p->mac;
 264
 265         netif_stop_queue(dev);
 266         mac->ops->disable(mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX);
 267         netif_carrier_off(dev);
 268
 269         clear_bit(dev->if_port, &adapter->open_device_map);
 270         if (adapter->params.stats_update_period &&
 271             !(adapter->open_device_map & PORT_MASK)) {
 272                 /* Stop statistics accumulation. */
 273                 smp_mb__after_clear_bit();
 274                 spin_lock(&adapter->work_lock);   /* sync with update task */
 275                 spin_unlock(&adapter->work_lock);
 276                 cancel_mac_stats_update(adapter);
 277         }
 278
 279         if (!adapter->open_device_map)
 280                 cxgb_down(adapter);
 281         return 0;
 282 }
 283
 284 static struct net_device_stats *t1_get_stats(struct net_device *dev)
 285 {
 286         struct adapter *adapter = dev->priv;
 287         struct port_info *p = &adapter->port[dev->if_port];
 288         struct net_device_stats *ns = &p->netstats;
 289         const struct cmac_statistics *pstats;
 290
 291         /* Do a full update of the MAC stats */
 292         pstats = p->mac->ops->statistics_update(p->mac,
 293                                                       MAC_STATS_UPDATE_FULL);
 294
 295         ns->tx_packets = pstats->TxUnicastFramesOK +
 296                 pstats->TxMulticastFramesOK + pstats->TxBroadcastFramesOK;
 297
 298         ns->rx_packets = pstats->RxUnicastFramesOK +
 299                 pstats->RxMulticastFramesOK + pstats->RxBroadcastFramesOK;
 300
 301         ns->tx_bytes = pstats->TxOctetsOK;
 302         ns->rx_bytes = pstats->RxOctetsOK;
 303
 304         ns->tx_errors = pstats->TxLateCollisions + pstats->TxLengthErrors +
 305                 pstats->TxUnderrun + pstats->TxFramesAbortedDueToXSCollisions;
 306         ns->rx_errors = pstats->RxDataErrors + pstats->RxJabberErrors +
 307                 pstats->RxFCSErrors + pstats->RxAlignErrors +
 308                 pstats->RxSequenceErrors + pstats->RxFrameTooLongErrors +
 309                 pstats->RxSymbolErrors + pstats->RxRuntErrors;
 310
 311         ns->multicast  = pstats->RxMulticastFramesOK;
 312         ns->collisions = pstats->TxTotalCollisions;
 313
 314         /* detailed rx_errors */
 315         ns->rx_length_errors = pstats->RxFrameTooLongErrors +
 316                 pstats->RxJabberErrors;
 317         ns->rx_over_errors   = 0;
 318         ns->rx_crc_errors    = pstats->RxFCSErrors;
 319         ns->rx_frame_errors  = pstats->RxAlignErrors;
 320         ns->rx_fifo_errors   = 0;
 321         ns->rx_missed_errors = 0;
 322
 323         /* detailed tx_errors */
 324         ns->tx_aborted_errors   = pstats->TxFramesAbortedDueToXSCollisions;
 325         ns->tx_carrier_errors   = 0;
 326         ns->tx_fifo_errors      = pstats->TxUnderrun;
 327         ns->tx_heartbeat_errors = 0;
 328         ns->tx_window_errors    = pstats->TxLateCollisions;
 329         return ns;
 330 }
 331
 332 static u32 get_msglevel(struct net_device *dev)
 333 {
 334         struct adapter *adapter = dev->priv;
 335
 336         return adapter->msg_enable;
 337 }
 338
 339 static void set_msglevel(struct net_device *dev, u32 val)
 340 {
 341         struct adapter *adapter = dev->priv;
 342
 343         adapter->msg_enable = val;
 344 }
 345
 346 static char stats_strings[][ETH_GSTRING_LEN] = {
 347         "TxOctetsOK",
 348         "TxOctetsBad",
 349         "TxUnicastFramesOK",
 350         "TxMulticastFramesOK",
 351         "TxBroadcastFramesOK",
 352         "TxPauseFrames",
 353         "TxFramesWithDeferredXmissions",
 354         "TxLateCollisions",
 355         "TxTotalCollisions",
 356         "TxFramesAbortedDueToXSCollisions",
 357         "TxUnderrun",
 358         "TxLengthErrors",
 359         "TxInternalMACXmitError",
 360         "TxFramesWithExcessiveDeferral",
 361         "TxFCSErrors",
 362
 363         "RxOctetsOK",
 364         "RxOctetsBad",
 365         "RxUnicastFramesOK",
 366         "RxMulticastFramesOK",
 367         "RxBroadcastFramesOK",
 368         "RxPauseFrames",
 369         "RxFCSErrors",
 370         "RxAlignErrors",
 371         "RxSymbolErrors",
 372         "RxDataErrors",
 373         "RxSequenceErrors",
 374         "RxRuntErrors",
 375         "RxJabberErrors",
 376         "RxInternalMACRcvError",
 377         "RxInRangeLengthErrors",
 378         "RxOutOfRangeLengthField",
 379         "RxFrameTooLongErrors",
 380
 381         "TSO",
 382         "VLANextractions",
 383         "VLANinsertions",
 384         "RxCsumGood",
 385         "TxCsumOffload",
 386         "RxDrops"
 387
 388         "respQ_empty",
 389         "respQ_overflow",
 390         "freelistQ_empty",
 391         "pkt_too_big",
 392         "pkt_mismatch",
 393         "cmdQ_full0",
 394         "cmdQ_full1",
 395         "tx_ipfrags",
 396         "tx_reg_pkts",
 397         "tx_lso_pkts",
 398         "tx_do_cksum",
 399
 400         "espi_DIP2ParityErr",
 401         "espi_DIP4Err",
 402         "espi_RxDrops",
 403         "espi_TxDrops",
 404         "espi_RxOvfl",
 405         "espi_ParityErr"
 406 };
 407
 408 #define T2_REGMAP_SIZE (3 * 1024)
 409
 410 static int get_regs_len(struct net_device *dev)
 411 {
 412         return T2_REGMAP_SIZE;
 413 }
 414
 415 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 416 {
 417         struct adapter *adapter = dev->priv;
 418
 419         strcpy(info->driver, DRV_NAME);
 420         strcpy(info->version, DRV_VERSION);
 421         strcpy(info->fw_version, "N/A");
 422         strcpy(info->bus_info, pci_name(adapter->pdev));
 423 }
 424
 425 static int get_stats_count(struct net_device *dev)
 426 {
 427         return ARRAY_SIZE(stats_strings);
 428 }
 429
 430 static void get_strings(struct net_device *dev, u32 stringset, u8 *data)
 431 {
 432         if (stringset == ETH_SS_STATS)
 433                 memcpy(data, stats_strings, sizeof(stats_strings));
 434 }
 435
 436 static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
 437                       u64 *data)
 438 {
 439         struct adapter *adapter = dev->priv;
 440         struct cmac *mac = adapter->port[dev->if_port].mac;
 441         const struct cmac_statistics *s;
 442         const struct sge_port_stats *ss;
 443         const struct sge_intr_counts *t;
 444
 445         s = mac->ops->statistics_update(mac, MAC_STATS_UPDATE_FULL);
 446         ss = t1_sge_get_port_stats(adapter->sge, dev->if_port);
 447         t = t1_sge_get_intr_counts(adapter->sge);
 448
 449         *data++ = s->TxOctetsOK;
 450         *data++ = s->TxOctetsBad;
 451         *data++ = s->TxUnicastFramesOK;
 452         *data++ = s->TxMulticastFramesOK;
 453         *data++ = s->TxBroadcastFramesOK;
 454         *data++ = s->TxPauseFrames;
 455         *data++ = s->TxFramesWithDeferredXmissions;
 456         *data++ = s->TxLateCollisions;
 457         *data++ = s->TxTotalCollisions;
 458         *data++ = s->TxFramesAbortedDueToXSCollisions;
 459         *data++ = s->TxUnderrun;
 460         *data++ = s->TxLengthErrors;
 461         *data++ = s->TxInternalMACXmitError;
 462         *data++ = s->TxFramesWithExcessiveDeferral;
 463         *data++ = s->TxFCSErrors;
 464
 465         *data++ = s->RxOctetsOK;
 466         *data++ = s->RxOctetsBad;
 467         *data++ = s->RxUnicastFramesOK;
 468         *data++ = s->RxMulticastFramesOK;
 469         *data++ = s->RxBroadcastFramesOK;
 470         *data++ = s->RxPauseFrames;
 471         *data++ = s->RxFCSErrors;
 472         *data++ = s->RxAlignErrors;
 473         *data++ = s->RxSymbolErrors;
 474         *data++ = s->RxDataErrors;
 475         *data++ = s->RxSequenceErrors;
 476         *data++ = s->RxRuntErrors;
 477         *data++ = s->RxJabberErrors;
 478         *data++ = s->RxInternalMACRcvError;
 479         *data++ = s->RxInRangeLengthErrors;
 480         *data++ = s->RxOutOfRangeLengthField;
 481         *data++ = s->RxFrameTooLongErrors;
 482
 483         *data++ = ss->tso;
 484         *data++ = ss->vlan_xtract;
 485         *data++ = ss->vlan_insert;
 486         *data++ = ss->rx_cso_good;
 487         *data++ = ss->tx_cso;
 488         *data++ = ss->rx_drops;
 489
 490         *data++ = (u64)t->respQ_empty;
 491         *data++ = (u64)t->respQ_overflow;
 492         *data++ = (u64)t->freelistQ_empty;
 493         *data++ = (u64)t->pkt_too_big;
 494         *data++ = (u64)t->pkt_mismatch;
 495         *data++ = (u64)t->cmdQ_full[0];
 496         *data++ = (u64)t->cmdQ_full[1];
 497         *data++ = (u64)t->tx_ipfrags;
 498         *data++ = (u64)t->tx_reg_pkts;
 499         *data++ = (u64)t->tx_lso_pkts;
 500         *data++ = (u64)t->tx_do_cksum;
 501 }
 502
 503 static inline void reg_block_dump(struct adapter *ap, void *buf,
 504                                   unsigned int start, unsigned int end)
 505 {
 506         u32 *p = buf + start;
 507
 508         for ( ; start <= end; start += sizeof(u32))
 509                 *p++ = readl(ap->regs + start);
 510 }
 511
 512 static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
 513                      void *buf)
 514 {
 515         struct adapter *ap = dev->priv;
 516
 517         /*
 518          * Version scheme: bits 0..9: chip version, bits 10..15: chip revision
 519          */
 520         regs->version = 2;
 521
 522         memset(buf, 0, T2_REGMAP_SIZE);
 523         reg_block_dump(ap, buf, 0, A_SG_RESPACCUTIMER);
 524 }
 525
 526 static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 527 {
 528         struct adapter *adapter = dev->priv;
 529         struct port_info *p = &adapter->port[dev->if_port];
 530
 531         cmd->supported = p->link_config.supported;
 532         cmd->advertising = p->link_config.advertising;
 533
 534         if (netif_carrier_ok(dev)) {
 535                 cmd->speed = p->link_config.speed;
 536                 cmd->duplex = p->link_config.duplex;
 537         } else {
 538                 cmd->speed = -1;
 539                 cmd->duplex = -1;
 540         }
 541
 542         cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
 543         cmd->phy_address = p->phy->addr;
 544         cmd->transceiver = XCVR_EXTERNAL;
 545         cmd->autoneg = p->link_config.autoneg;
 546         cmd->maxtxpkt = 0;
 547         cmd->maxrxpkt = 0;
 548         return 0;
 549 }
 550
 551 static int speed_duplex_to_caps(int speed, int duplex)
 552 {
 553         int cap = 0;
 554
 555         switch (speed) {
 556         case SPEED_10:
 557                 if (duplex == DUPLEX_FULL)
 558                         cap = SUPPORTED_10baseT_Full;
 559                 else
 560                         cap = SUPPORTED_10baseT_Half;
 561                 break;
 562         case SPEED_100:
 563                 if (duplex == DUPLEX_FULL)
 564                         cap = SUPPORTED_100baseT_Full;
 565                 else
 566                         cap = SUPPORTED_100baseT_Half;
 567                 break;
 568         case SPEED_1000:
 569                 if (duplex == DUPLEX_FULL)
 570                         cap = SUPPORTED_1000baseT_Full;
 571                 else
 572                         cap = SUPPORTED_1000baseT_Half;
 573                 break;
 574         case SPEED_10000:
 575                 if (duplex == DUPLEX_FULL)
 576                         cap = SUPPORTED_10000baseT_Full;
 577         }
 578         return cap;
 579 }
 580
 581 #define ADVERTISED_MASK (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \
 582                       ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \
 583                       ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full | \
 584                       ADVERTISED_10000baseT_Full)
 585
 586 static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 587 {
 588         struct adapter *adapter = dev->priv;
 589         struct port_info *p = &adapter->port[dev->if_port];
 590         struct link_config *lc = &p->link_config;
 591
 592         if (!(lc->supported & SUPPORTED_Autoneg))
 593                 return -EOPNOTSUPP;             /* can't change speed/duplex */
 594
 595         if (cmd->autoneg == AUTONEG_DISABLE) {
 596                 int cap = speed_duplex_to_caps(cmd->speed, cmd->duplex);
 597
 598                 if (!(lc->supported & cap) || cmd->speed == SPEED_1000)
 599                         return -EINVAL;
 600                 lc->requested_speed = cmd->speed;
 601                 lc->requested_duplex = cmd->duplex;
 602                 lc->advertising = 0;
 603         } else {
 604                 cmd->advertising &= ADVERTISED_MASK;
 605                 if (cmd->advertising & (cmd->advertising - 1))
 606                         cmd->advertising = lc->supported;
 607                 cmd->advertising &= lc->supported;
 608                 if (!cmd->advertising)
 609                         return -EINVAL;
 610                 lc->requested_speed = SPEED_INVALID;
 611                 lc->requested_duplex = DUPLEX_INVALID;
 612                 lc->advertising = cmd->advertising | ADVERTISED_Autoneg;
 613         }
 614         lc->autoneg = cmd->autoneg;
 615         if (netif_running(dev))
 616                 t1_link_start(p->phy, p->mac, lc);
 617         return 0;
 618 }
 619
 620 static void get_pauseparam(struct net_device *dev,
 621                            struct ethtool_pauseparam *epause)
 622 {
 623         struct adapter *adapter = dev->priv;
 624         struct port_info *p = &adapter->port[dev->if_port];
 625
 626         epause->autoneg = (p->link_config.requested_fc & PAUSE_AUTONEG) != 0;
 627         epause->rx_pause = (p->link_config.fc & PAUSE_RX) != 0;
 628         epause->tx_pause = (p->link_config.fc & PAUSE_TX) != 0;
 629 }
 630
 631 static int set_pauseparam(struct net_device *dev,
 632                           struct ethtool_pauseparam *epause)
 633 {
 634         struct adapter *adapter = dev->priv;
 635         struct port_info *p = &adapter->port[dev->if_port];
 636         struct link_config *lc = &p->link_config;
 637
 638         if (epause->autoneg == AUTONEG_DISABLE)
 639                 lc->requested_fc = 0;
 640         else if (lc->supported & SUPPORTED_Autoneg)
 641                 lc->requested_fc = PAUSE_AUTONEG;
 642         else
 643                 return -EINVAL;
 644
 645         if (epause->rx_pause)
 646                 lc->requested_fc |= PAUSE_RX;
 647         if (epause->tx_pause)
 648                 lc->requested_fc |= PAUSE_TX;
 649         if (lc->autoneg == AUTONEG_ENABLE) {
 650                 if (netif_running(dev))
 651                         t1_link_start(p->phy, p->mac, lc);
 652         } else {
 653                 lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
 654                 if (netif_running(dev))
 655                         p->mac->ops->set_speed_duplex_fc(p->mac, -1, -1,
 656                                                          lc->fc);
 657         }
 658         return 0;
 659 }
 660
 661 static u32 get_rx_csum(struct net_device *dev)
 662 {
 663         struct adapter *adapter = dev->priv;
 664
 665         return (adapter->flags & RX_CSUM_ENABLED) != 0;
 666 }
 667
 668 static int set_rx_csum(struct net_device *dev, u32 data)
 669 {
 670         struct adapter *adapter = dev->priv;
 671
 672         if (data)
 673                 adapter->flags |= RX_CSUM_ENABLED;
 674         else
 675                 adapter->flags &= ~RX_CSUM_ENABLED;
 676         return 0;
 677 }
 678
 679 static int set_tso(struct net_device *dev, u32 value)
 680 {
 681         struct adapter *adapter = dev->priv;
 682
 683         if (!(adapter->flags & TSO_CAPABLE))
 684                 return value ? -EOPNOTSUPP : 0;
 685         return ethtool_op_set_tso(dev, value);
 686 }
 687
 688 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
 689 {
 690         struct adapter *adapter = dev->priv;
 691         int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0;
 692
 693         e->rx_max_pending = MAX_RX_BUFFERS;
 694         e->rx_mini_max_pending = 0;
 695         e->rx_jumbo_max_pending = MAX_RX_JUMBO_BUFFERS;
 696         e->tx_max_pending = MAX_CMDQ_ENTRIES;
 697
 698         e->rx_pending = adapter->params.sge.freelQ_size[!jumbo_fl];
 699         e->rx_mini_pending = 0;
 700         e->rx_jumbo_pending = adapter->params.sge.freelQ_size[jumbo_fl];
 701         e->tx_pending = adapter->params.sge.cmdQ_size[0];
 702 }
 703
 704 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
 705 {
 706         struct adapter *adapter = dev->priv;
 707         int jumbo_fl = t1_is_T1B(adapter) ? 1 : 0;
 708
 709         if (e->rx_pending > MAX_RX_BUFFERS || e->rx_mini_pending ||
 710             e->rx_jumbo_pending > MAX_RX_JUMBO_BUFFERS ||
 711             e->tx_pending > MAX_CMDQ_ENTRIES ||
 712             e->rx_pending < MIN_FL_ENTRIES ||
 713             e->rx_jumbo_pending < MIN_FL_ENTRIES ||
 714             e->tx_pending < (adapter->params.nports + 1) * (MAX_SKB_FRAGS + 1))
 715                 return -EINVAL;
 716
 717         if (adapter->flags & FULL_INIT_DONE)
 718         return -EBUSY;
 719
 720         adapter->params.sge.freelQ_size[!jumbo_fl] = e->rx_pending;
 721         adapter->params.sge.freelQ_size[jumbo_fl] = e->rx_jumbo_pending;
 722         adapter->params.sge.cmdQ_size[0] = e->tx_pending;
 723         adapter->params.sge.cmdQ_size[1] = e->tx_pending > MAX_CMDQ1_ENTRIES ?
 724                 MAX_CMDQ1_ENTRIES : e->tx_pending;
 725         return 0;
 726 }
 727
 728 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
 729 {
 730         struct adapter *adapter = dev->priv;
 731
 732         /*
 733          * If RX coalescing is requested we use NAPI, otherwise interrupts.
 734          * This choice can be made only when all ports and the TOE are off.
 735          */
 736         if (adapter->open_device_map == 0)
 737                 adapter->params.sge.polling = c->use_adaptive_rx_coalesce;
 738
 739         if (adapter->params.sge.polling) {
 740                 adapter->params.sge.rx_coalesce_usecs = 0;
 741         } else {
 742                 adapter->params.sge.rx_coalesce_usecs = c->rx_coalesce_usecs;
 743         }
 744         adapter->params.sge.coalesce_enable = c->use_adaptive_rx_coalesce;
 745         adapter->params.sge.sample_interval_usecs = c->rate_sample_interval;
 746         t1_sge_set_coalesce_params(adapter->sge, &adapter->params.sge);
 747         return 0;
 748 }
 749
 750 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
 751 {
 752         struct adapter *adapter = dev->priv;
 753
 754         c->rx_coalesce_usecs = adapter->params.sge.rx_coalesce_usecs;
 755         c->rate_sample_interval = adapter->params.sge.sample_interval_usecs;
 756         c->use_adaptive_rx_coalesce = adapter->params.sge.coalesce_enable;
 757         return 0;
 758 }
 759
 760 static int get_eeprom_len(struct net_device *dev)
 761 {
 762     return EEPROM_SIZE;
 763 }
 764
 765 #define EEPROM_MAGIC(ap) \
 766         (PCI_VENDOR_ID_CHELSIO | ((ap)->params.chip_version << 16))
 767
 768 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
 769                       u8 *data)
 770 {
 771         int i;
 772         u8 buf[EEPROM_SIZE] __attribute__((aligned(4)));
 773         struct adapter *adapter = dev->priv;
 774
 775         e->magic = EEPROM_MAGIC(adapter);
 776         for (i = e->offset & ~3; i < e->offset + e->len; i += sizeof(u32))
 777                 t1_seeprom_read(adapter, i, (u32 *)&buf[i]);
 778         memcpy(data, buf + e->offset, e->len);
 779         return 0;
 780 }
 781
 782 static const struct ethtool_ops t1_ethtool_ops = {
 783         .get_settings      = get_settings,
 784         .set_settings      = set_settings,
 785         .get_drvinfo       = get_drvinfo,
 786         .get_msglevel      = get_msglevel,
 787         .set_msglevel      = set_msglevel,
 788         .get_ringparam     = get_sge_param,
 789         .set_ringparam     = set_sge_param,
 790         .get_coalesce      = get_coalesce,
 791         .set_coalesce      = set_coalesce,
 792         .get_eeprom_len    = get_eeprom_len,
 793         .get_eeprom        = get_eeprom,
 794         .get_pauseparam    = get_pauseparam,
 795         .set_pauseparam    = set_pauseparam,
 796         .get_rx_csum       = get_rx_csum,
 797         .set_rx_csum       = set_rx_csum,
 798         .get_tx_csum       = ethtool_op_get_tx_csum,
 799         .set_tx_csum       = ethtool_op_set_tx_csum,
 800         .get_sg            = ethtool_op_get_sg,
 801         .set_sg            = ethtool_op_set_sg,
 802         .get_link          = ethtool_op_get_link,
 803         .get_strings       = get_strings,
 804         .get_stats_count   = get_stats_count,
 805         .get_ethtool_stats = get_stats,
 806         .get_regs_len      = get_regs_len,
 807         .get_regs          = get_regs,
 808         .get_tso           = ethtool_op_get_tso,
 809         .set_tso           = set_tso,
 810 };
 811
 812 static void cxgb_proc_cleanup(struct adapter *adapter,
 813                                         struct proc_dir_entry *dir)
 814 {
 815         const char *name;
 816         name = adapter->name;
 817         remove_proc_entry(name, dir);
 818 }
 819 //#define chtoe_setup_toedev(adapter) NULL
 820 #define update_mtu_tab(adapter)
 821 #define write_smt_entry(adapter, idx)
 822
 823 static int t1_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
 824 {
 825         struct adapter *adapter = dev->priv;
 826         struct mii_ioctl_data *data = if_mii(req);
 827
 828         switch (cmd) {
 829         case SIOCGMIIPHY:
 830                 data->phy_id = adapter->port[dev->if_port].phy->addr;
 831                 /* FALLTHRU */
 832         case SIOCGMIIREG: {
 833                 struct cphy *phy = adapter->port[dev->if_port].phy;
 834                 u32 val;
 835
 836                 if (!phy->mdio_read)
 837             return -EOPNOTSUPP;
 838                 phy->mdio_read(adapter, data->phy_id, 0, data->reg_num & 0x1f,
 839                                &val);
 840                 data->val_out = val;
 841                 break;
 842         }
 843         case SIOCSMIIREG: {
 844                 struct cphy *phy = adapter->port[dev->if_port].phy;
 845
 846                 if (!capable(CAP_NET_ADMIN))
 847                     return -EPERM;
 848                 if (!phy->mdio_write)
 849             return -EOPNOTSUPP;
 850                 phy->mdio_write(adapter, data->phy_id, 0, data->reg_num & 0x1f,
 851                                 data->val_in);
 852                 break;
 853         }
 854
 855         default:
 856                 return -EOPNOTSUPP;
 857         }
 858         return 0;
 859 }
 860
 861 static int t1_change_mtu(struct net_device *dev, int new_mtu)
 862 {
 863         int ret;
 864         struct adapter *adapter = dev->priv;
 865         struct cmac *mac = adapter->port[dev->if_port].mac;
 866
 867         if (!mac->ops->set_mtu)
 868         return -EOPNOTSUPP;
 869         if (new_mtu < 68)
 870         return -EINVAL;
 871         if ((ret = mac->ops->set_mtu(mac, new_mtu)))
 872                 return ret;
 873         dev->mtu = new_mtu;
 874         return 0;
 875 }
 876
 877 static int t1_set_mac_addr(struct net_device *dev, void *p)
 878 {
 879         struct adapter *adapter = dev->priv;
 880         struct cmac *mac = adapter->port[dev->if_port].mac;
 881         struct sockaddr *addr = p;
 882
 883         if (!mac->ops->macaddress_set)
 884                 return -EOPNOTSUPP;
 885
 886         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 887         mac->ops->macaddress_set(mac, dev->dev_addr);
 888         return 0;
 889 }
 890
 891 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
 892 static void vlan_rx_register(struct net_device *dev,
 893                                    struct vlan_group *grp)
 894 {
 895         struct adapter *adapter = dev->priv;
 896
 897         spin_lock_irq(&adapter->async_lock);
 898         adapter->vlan_grp = grp;
 899         t1_set_vlan_accel(adapter, grp != NULL);
 900         spin_unlock_irq(&adapter->async_lock);
 901 }
 902
 903 static void vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
 904 {
 905         struct adapter *adapter = dev->priv;
 906
 907         spin_lock_irq(&adapter->async_lock);
 908         if (adapter->vlan_grp)
 909                 adapter->vlan_grp->vlan_devices[vid] = NULL;
 910         spin_unlock_irq(&adapter->async_lock);
 911 }
 912 #endif
 913
 914 #ifdef CONFIG_NET_POLL_CONTROLLER
 915 static void t1_netpoll(struct net_device *dev)
 916 {
 917         unsigned long flags;
 918         struct adapter *adapter = dev->priv;
 919
 920         local_irq_save(flags);
 921         t1_select_intr_handler(adapter)(adapter->pdev->irq, adapter);
 922         local_irq_restore(flags);
 923 }
 924 #endif
 925
 926 /*
 927  * Periodic accumulation of MAC statistics.  This is used only if the MAC
 928  * does not have any other way to prevent stats counter overflow.
 929  */
 930 static void mac_stats_task(struct work_struct *work)
 931 {
 932         int i;
 933         struct adapter *adapter =
 934                 container_of(work, struct adapter, stats_update_task.work);
 935
 936         for_each_port(adapter, i) {
 937                 struct port_info *p = &adapter->port[i];
 938
 939                 if (netif_running(p->dev))
 940                         p->mac->ops->statistics_update(p->mac,
 941                                                        MAC_STATS_UPDATE_FAST);
 942         }
 943
 944         /* Schedule the next statistics update if any port is active. */
 945         spin_lock(&adapter->work_lock);
 946         if (adapter->open_device_map & PORT_MASK)
 947                 schedule_mac_stats_update(adapter,
 948                                           adapter->params.stats_update_period);
 949         spin_unlock(&adapter->work_lock);
 950 }
 951
 952 /*
 953  * Processes elmer0 external interrupts in process context.
 954  */
 955 static void ext_intr_task(struct work_struct *work)
 956 {
 957         struct adapter *adapter =
 958                 container_of(work, struct adapter, ext_intr_handler_task);
 959
 960         elmer0_ext_intr_handler(adapter);
 961
 962         /* Now reenable external interrupts */
 963         spin_lock_irq(&adapter->async_lock);
 964         adapter->slow_intr_mask |= F_PL_INTR_EXT;
 965         writel(F_PL_INTR_EXT, adapter->regs + A_PL_CAUSE);
 966         writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA,
 967                    adapter->regs + A_PL_ENABLE);
 968         spin_unlock_irq(&adapter->async_lock);
 969 }
 970
 971 /*
 972  * Interrupt-context handler for elmer0 external interrupts.
 973  */
 974 void t1_elmer0_ext_intr(struct adapter *adapter)
 975 {
 976         /*
 977          * Schedule a task to handle external interrupts as we require
 978          * a process context.  We disable EXT interrupts in the interim
 979          * and let the task reenable them when it's done.
 980          */
 981         adapter->slow_intr_mask &= ~F_PL_INTR_EXT;
 982         writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA,
 983                    adapter->regs + A_PL_ENABLE);
 984         schedule_work(&adapter->ext_intr_handler_task);
 985 }
 986
 987 void t1_fatal_err(struct adapter *adapter)
 988 {
 989         if (adapter->flags & FULL_INIT_DONE) {
 990                 t1_sge_stop(adapter->sge);
 991                 t1_interrupts_disable(adapter);
 992         }
 993         CH_ALERT("%s: encountered fatal error, operation suspended\n",
 994                  adapter->name);
 995 }
 996
 997 static int __devinit init_one(struct pci_dev *pdev,
 998                               const struct pci_device_id *ent)
 999 {
1000         static int version_printed;
1001
1002         int i, err, pci_using_dac = 0;
1003         unsigned long mmio_start, mmio_len;
1004         const struct board_info *bi;
1005         struct adapter *adapter = NULL;
1006         struct port_info *pi;
1007
1008         if (!version_printed) {
1009                 printk(KERN_INFO "%s - version %s\n", DRV_DESCRIPTION,
1010                        DRV_VERSION);
1011                 ++version_printed;
1012         }
1013
1014         err = pci_enable_device(pdev);
1015         if (err)
1016         return err;
1017
1018         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1019                 CH_ERR("%s: cannot find PCI device memory base address\n",
1020                        pci_name(pdev));
1021                 err = -ENODEV;
1022                 goto out_disable_pdev;
1023         }
1024
1025         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
1026                 pci_using_dac = 1;
1027
1028                 if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
1029                         CH_ERR("%s: unable to obtain 64-bit DMA for"
1030                                "consistent allocations\n", pci_name(pdev));
1031                         err = -ENODEV;
1032                         goto out_disable_pdev;
1033                 }
1034
1035         } else if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
1036                 CH_ERR("%s: no usable DMA configuration\n", pci_name(pdev));
1037                 goto out_disable_pdev;
1038         }
1039
1040         err = pci_request_regions(pdev, DRV_NAME);
1041         if (err) {
1042                 CH_ERR("%s: cannot obtain PCI resources\n", pci_name(pdev));
1043                 goto out_disable_pdev;
1044         }
1045
1046         pci_set_master(pdev);
1047
1048     mmio_start = pci_resource_start(pdev, 0);
1049         mmio_len = pci_resource_len(pdev, 0);
1050         bi = t1_get_board_info(ent->driver_data);
1051
1052         for (i = 0; i < bi->port_number; ++i) {
1053                 struct net_device *netdev;
1054
1055                 netdev = alloc_etherdev(adapter ? 0 : sizeof(*adapter));
1056                 if (!netdev) {
1057                         err = -ENOMEM;
1058                         goto out_free_dev;
1059                 }
1060
1061                 SET_MODULE_OWNER(netdev);
1062                 SET_NETDEV_DEV(netdev, &pdev->dev);
1063
1064                 if (!adapter) {
1065                         adapter = netdev->priv;
1066                         adapter->pdev = pdev;
1067                         adapter->port[0].dev = netdev;  /* so we don't leak it */
1068
1069                         adapter->regs = ioremap(mmio_start, mmio_len);
1070                         if (!adapter->regs) {
1071                                 CH_ERR("%s: cannot map device registers\n",
1072                                        pci_name(pdev));
1073                                 err = -ENOMEM;
1074                                 goto out_free_dev;
1075                         }
1076
1077                         if (t1_get_board_rev(adapter, bi, &adapter->params)) {
1078                                 err = -ENODEV;    /* Can't handle this chip rev */
1079                                 goto out_free_dev;
1080                         }
1081
1082                         adapter->name = pci_name(pdev);
1083                         adapter->msg_enable = dflt_msg_enable;
1084                         adapter->mmio_len = mmio_len;
1085
1086                         init_MUTEX(&adapter->mib_mutex);
1087                         spin_lock_init(&adapter->tpi_lock);
1088                         spin_lock_init(&adapter->work_lock);
1089                         spin_lock_init(&adapter->async_lock);
1090
1091                         INIT_WORK(&adapter->ext_intr_handler_task,
1092                                   ext_intr_task);
1093                         INIT_DELAYED_WORK(&adapter->stats_update_task,
1094                                           mac_stats_task);
1095 #ifdef work_struct
1096                         init_timer(&adapter->stats_update_timer);
1097                         adapter->stats_update_timer.function = mac_stats_timer;
1098                         adapter->stats_update_timer.data =
1099                                 (unsigned long)adapter;
1100 #endif
1101
1102                         pci_set_drvdata(pdev, netdev);
1103                 }
1104
1105                 pi = &adapter->port[i];
1106                 pi->dev = netdev;
1107                 netif_carrier_off(netdev);
1108                 netdev->irq = pdev->irq;
1109                 netdev->if_port = i;
1110                 netdev->mem_start = mmio_start;
1111                 netdev->mem_end = mmio_start + mmio_len - 1;
1112                 netdev->priv = adapter;
1113                 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1114                 netdev->features |= NETIF_F_LLTX;
1115
1116                 adapter->flags |= RX_CSUM_ENABLED | TCP_CSUM_CAPABLE;
1117                 if (pci_using_dac)
1118                         netdev->features |= NETIF_F_HIGHDMA;
1119                 if (vlan_tso_capable(adapter)) {
1120 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
1121                         adapter->flags |= VLAN_ACCEL_CAPABLE;
1122                         netdev->features |=
1123                                 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1124                         netdev->vlan_rx_register = vlan_rx_register;
1125                         netdev->vlan_rx_kill_vid = vlan_rx_kill_vid;
1126 #endif
1127                         adapter->flags |= TSO_CAPABLE;
1128                         netdev->features |= NETIF_F_TSO;
1129                 }
1130
1131                 netdev->open = cxgb_open;
1132                 netdev->stop = cxgb_close;
1133                 netdev->hard_start_xmit = t1_start_xmit;
1134                 netdev->hard_header_len += (adapter->flags & TSO_CAPABLE) ?
1135                         sizeof(struct cpl_tx_pkt_lso) :
1136                         sizeof(struct cpl_tx_pkt);
1137                 netdev->get_stats = t1_get_stats;
1138                 netdev->set_multicast_list = t1_set_rxmode;
1139                 netdev->do_ioctl = t1_ioctl;
1140                 netdev->change_mtu = t1_change_mtu;
1141                 netdev->set_mac_address = t1_set_mac_addr;
1142 #ifdef CONFIG_NET_POLL_CONTROLLER
1143                 netdev->poll_controller = t1_netpoll;
1144 #endif
1145                 netdev->weight = 64;
1146
1147         SET_ETHTOOL_OPS(netdev, &t1_ethtool_ops);
1148         }
1149
1150         if (t1_init_sw_modules(adapter, bi) < 0) {
1151                 err = -ENODEV;
1152                 goto out_free_dev;
1153         }
1154
1155         /*
1156          * The card is now ready to go.  If any errors occur during device
1157          * registration we do not fail the whole card but rather proceed only
1158          * with the ports we manage to register successfully.  However we must
1159          * register at least one net device.
1160          */
1161         for (i = 0; i < bi->port_number; ++i) {
1162                 err = register_netdev(adapter->port[i].dev);
1163                 if (err)
1164                         CH_WARN("%s: cannot register net device %s, skipping\n",
1165                                 pci_name(pdev), adapter->port[i].dev->name);
1166                 else {
1167                         /*
1168                          * Change the name we use for messages to the name of
1169                          * the first successfully registered interface.
1170                          */
1171                         if (!adapter->registered_device_map)
1172                                 adapter->name = adapter->port[i].dev->name;
1173
1174                 __set_bit(i, &adapter->registered_device_map);
1175                 }
1176         }
1177         if (!adapter->registered_device_map) {
1178                 CH_ERR("%s: could not register any net devices\n",
1179                        pci_name(pdev));
1180                 goto out_release_adapter_res;
1181         }
1182
1183         printk(KERN_INFO "%s: %s (rev %d), %s %dMHz/%d-bit\n", adapter->name,
1184                bi->desc, adapter->params.chip_revision,
1185                adapter->params.pci.is_pcix ? "PCIX" : "PCI",
1186                adapter->params.pci.speed, adapter->params.pci.width);
1187         return 0;
1188
1189  out_release_adapter_res:
1190         t1_free_sw_modules(adapter);
1191  out_free_dev:
1192         if (adapter) {
1193                 if (adapter->regs) iounmap(adapter->regs);
1194                 for (i = bi->port_number - 1; i >= 0; --i)
1195                         if (adapter->port[i].dev) {
1196                                 cxgb_proc_cleanup(adapter, proc_root_driver);
1197                                 kfree(adapter->port[i].dev);
1198                         }
1199         }
1200         pci_release_regions(pdev);
1201  out_disable_pdev:
1202         pci_disable_device(pdev);
1203         pci_set_drvdata(pdev, NULL);
1204         return err;
1205 }
1206
1207 static inline void t1_sw_reset(struct pci_dev *pdev)
1208 {
1209         pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 3);
1210         pci_write_config_dword(pdev, A_PCICFG_PM_CSR, 0);
1211 }
1212
1213 static void __devexit remove_one(struct pci_dev *pdev)
1214 {
1215         struct net_device *dev = pci_get_drvdata(pdev);
1216
1217         if (dev) {
1218                 int i;
1219                 struct adapter *adapter = dev->priv;
1220
1221                 for_each_port(adapter, i)
1222                         if (test_bit(i, &adapter->registered_device_map))
1223                                 unregister_netdev(adapter->port[i].dev);
1224
1225                 t1_free_sw_modules(adapter);
1226                 iounmap(adapter->regs);
1227                 while (--i >= 0)
1228                         if (adapter->port[i].dev) {
1229                                 cxgb_proc_cleanup(adapter, proc_root_driver);
1230                                 kfree(adapter->port[i].dev);
1231                         }
1232                 pci_release_regions(pdev);
1233                 pci_disable_device(pdev);
1234                 pci_set_drvdata(pdev, NULL);
1235                 t1_sw_reset(pdev);
1236         }
1237 }
1238
1239 static struct pci_driver driver = {
1240         .name     = DRV_NAME,
1241         .id_table = t1_pci_tbl,
1242         .probe    = init_one,
1243         .remove   = __devexit_p(remove_one),
1244 };
1245
1246 static int __init t1_init_module(void)
1247 {
1248         return pci_register_driver(&driver);
1249 }
1250
1251 static void __exit t1_cleanup_module(void)
1252 {
1253         pci_unregister_driver(&driver);
1254 }
1255
1256 module_init(t1_init_module);
1257 module_exit(t1_cleanup_module);