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