drivers/net/netxen/netxen_nic_init.c

   1 /*
   2  * Copyright (C) 2003 - 2009 NetXen, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18  * MA  02111-1307, USA.
  19  *
  20  * The full GNU General Public License is included in this distribution
  21  * in the file called LICENSE.
  22  *
  23  * Contact Information:
  24  *    info@netxen.com
  25  * NetXen Inc,
  26  * 18922 Forge Drive
  27  * Cupertino, CA 95014-0701
  28  *
  29  */
  30
  31 #include <linux/netdevice.h>
  32 #include <linux/delay.h>
  33 #include "netxen_nic.h"
  34 #include "netxen_nic_hw.h"
  35 #include "netxen_nic_phan_reg.h"
  36
  37 struct crb_addr_pair {
  38         u32 addr;
  39         u32 data;
  40 };
  41
  42 #define NETXEN_MAX_CRB_XFORM 60
  43 static unsigned int crb_addr_xform[NETXEN_MAX_CRB_XFORM];
  44 #define NETXEN_ADDR_ERROR (0xffffffff)
  45
  46 #define crb_addr_transform(name) \
  47         crb_addr_xform[NETXEN_HW_PX_MAP_CRB_##name] = \
  48         NETXEN_HW_CRB_HUB_AGT_ADR_##name << 20
  49
  50 #define NETXEN_NIC_XDMA_RESET 0x8000ff
  51
  52 static void
  53 netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
  54                 struct nx_host_rds_ring *rds_ring);
  55
  56 static void crb_addr_transform_setup(void)
  57 {
  58         crb_addr_transform(XDMA);
  59         crb_addr_transform(TIMR);
  60         crb_addr_transform(SRE);
  61         crb_addr_transform(SQN3);
  62         crb_addr_transform(SQN2);
  63         crb_addr_transform(SQN1);
  64         crb_addr_transform(SQN0);
  65         crb_addr_transform(SQS3);
  66         crb_addr_transform(SQS2);
  67         crb_addr_transform(SQS1);
  68         crb_addr_transform(SQS0);
  69         crb_addr_transform(RPMX7);
  70         crb_addr_transform(RPMX6);
  71         crb_addr_transform(RPMX5);
  72         crb_addr_transform(RPMX4);
  73         crb_addr_transform(RPMX3);
  74         crb_addr_transform(RPMX2);
  75         crb_addr_transform(RPMX1);
  76         crb_addr_transform(RPMX0);
  77         crb_addr_transform(ROMUSB);
  78         crb_addr_transform(SN);
  79         crb_addr_transform(QMN);
  80         crb_addr_transform(QMS);
  81         crb_addr_transform(PGNI);
  82         crb_addr_transform(PGND);
  83         crb_addr_transform(PGN3);
  84         crb_addr_transform(PGN2);
  85         crb_addr_transform(PGN1);
  86         crb_addr_transform(PGN0);
  87         crb_addr_transform(PGSI);
  88         crb_addr_transform(PGSD);
  89         crb_addr_transform(PGS3);
  90         crb_addr_transform(PGS2);
  91         crb_addr_transform(PGS1);
  92         crb_addr_transform(PGS0);
  93         crb_addr_transform(PS);
  94         crb_addr_transform(PH);
  95         crb_addr_transform(NIU);
  96         crb_addr_transform(I2Q);
  97         crb_addr_transform(EG);
  98         crb_addr_transform(MN);
  99         crb_addr_transform(MS);
 100         crb_addr_transform(CAS2);
 101         crb_addr_transform(CAS1);
 102         crb_addr_transform(CAS0);
 103         crb_addr_transform(CAM);
 104         crb_addr_transform(C2C1);
 105         crb_addr_transform(C2C0);
 106         crb_addr_transform(SMB);
 107         crb_addr_transform(OCM0);
 108         crb_addr_transform(I2C0);
 109 }
 110
 111 void netxen_release_rx_buffers(struct netxen_adapter *adapter)
 112 {
 113         struct netxen_recv_context *recv_ctx;
 114         struct nx_host_rds_ring *rds_ring;
 115         struct netxen_rx_buffer *rx_buf;
 116         int i, ring;
 117
 118         recv_ctx = &adapter->recv_ctx;
 119         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
 120                 rds_ring = &recv_ctx->rds_rings[ring];
 121                 for (i = 0; i < rds_ring->num_desc; ++i) {
 122                         rx_buf = &(rds_ring->rx_buf_arr[i]);
 123                         if (rx_buf->state == NETXEN_BUFFER_FREE)
 124                                 continue;
 125                         pci_unmap_single(adapter->pdev,
 126                                         rx_buf->dma,
 127                                         rds_ring->dma_size,
 128                                         PCI_DMA_FROMDEVICE);
 129                         if (rx_buf->skb != NULL)
 130                                 dev_kfree_skb_any(rx_buf->skb);
 131                 }
 132         }
 133 }
 134
 135 void netxen_release_tx_buffers(struct netxen_adapter *adapter)
 136 {
 137         struct netxen_cmd_buffer *cmd_buf;
 138         struct netxen_skb_frag *buffrag;
 139         int i, j;
 140         struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
 141
 142         cmd_buf = tx_ring->cmd_buf_arr;
 143         for (i = 0; i < tx_ring->num_desc; i++) {
 144                 buffrag = cmd_buf->frag_array;
 145                 if (buffrag->dma) {
 146                         pci_unmap_single(adapter->pdev, buffrag->dma,
 147                                          buffrag->length, PCI_DMA_TODEVICE);
 148                         buffrag->dma = 0ULL;
 149                 }
 150                 for (j = 0; j < cmd_buf->frag_count; j++) {
 151                         buffrag++;
 152                         if (buffrag->dma) {
 153                                 pci_unmap_page(adapter->pdev, buffrag->dma,
 154                                                buffrag->length,
 155                                                PCI_DMA_TODEVICE);
 156                                 buffrag->dma = 0ULL;
 157                         }
 158                 }
 159                 if (cmd_buf->skb) {
 160                         dev_kfree_skb_any(cmd_buf->skb);
 161                         cmd_buf->skb = NULL;
 162                 }
 163                 cmd_buf++;
 164         }
 165 }
 166
 167 void netxen_free_sw_resources(struct netxen_adapter *adapter)
 168 {
 169         struct netxen_recv_context *recv_ctx;
 170         struct nx_host_rds_ring *rds_ring;
 171         struct nx_host_tx_ring *tx_ring;
 172         int ring;
 173
 174         recv_ctx = &adapter->recv_ctx;
 175
 176         if (recv_ctx->rds_rings == NULL)
 177                 goto skip_rds;
 178
 179         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
 180                 rds_ring = &recv_ctx->rds_rings[ring];
 181                 vfree(rds_ring->rx_buf_arr);
 182                 rds_ring->rx_buf_arr = NULL;
 183         }
 184         kfree(recv_ctx->rds_rings);
 185
 186 skip_rds:
 187         if (adapter->tx_ring == NULL)
 188                 return;
 189
 190         tx_ring = adapter->tx_ring;
 191         vfree(tx_ring->cmd_buf_arr);
 192 }
 193
 194 int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
 195 {
 196         struct netxen_recv_context *recv_ctx;
 197         struct nx_host_rds_ring *rds_ring;
 198         struct nx_host_sds_ring *sds_ring;
 199         struct nx_host_tx_ring *tx_ring;
 200         struct netxen_rx_buffer *rx_buf;
 201         int ring, i, size;
 202
 203         struct netxen_cmd_buffer *cmd_buf_arr;
 204         struct net_device *netdev = adapter->netdev;
 205         struct pci_dev *pdev = adapter->pdev;
 206
 207         size = sizeof(struct nx_host_tx_ring);
 208         tx_ring = kzalloc(size, GFP_KERNEL);
 209         if (tx_ring == NULL) {
 210                 dev_err(&pdev->dev, "%s: failed to allocate tx ring struct\n",
 211                        netdev->name);
 212                 return -ENOMEM;
 213         }
 214         adapter->tx_ring = tx_ring;
 215
 216         tx_ring->num_desc = adapter->num_txd;
 217         tx_ring->txq = netdev_get_tx_queue(netdev, 0);
 218
 219         cmd_buf_arr = vmalloc(TX_BUFF_RINGSIZE(tx_ring));
 220         if (cmd_buf_arr == NULL) {
 221                 dev_err(&pdev->dev, "%s: failed to allocate cmd buffer ring\n",
 222                        netdev->name);
 223                 return -ENOMEM;
 224         }
 225         memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring));
 226         tx_ring->cmd_buf_arr = cmd_buf_arr;
 227
 228         recv_ctx = &adapter->recv_ctx;
 229
 230         size = adapter->max_rds_rings * sizeof (struct nx_host_rds_ring);
 231         rds_ring = kzalloc(size, GFP_KERNEL);
 232         if (rds_ring == NULL) {
 233                 dev_err(&pdev->dev, "%s: failed to allocate rds ring struct\n",
 234                        netdev->name);
 235                 return -ENOMEM;
 236         }
 237         recv_ctx->rds_rings = rds_ring;
 238
 239         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
 240                 rds_ring = &recv_ctx->rds_rings[ring];
 241                 switch (ring) {
 242                 case RCV_RING_NORMAL:
 243                         rds_ring->num_desc = adapter->num_rxd;
 244                         if (adapter->ahw.cut_through) {
 245                                 rds_ring->dma_size =
 246                                         NX_CT_DEFAULT_RX_BUF_LEN;
 247                                 rds_ring->skb_size =
 248                                         NX_CT_DEFAULT_RX_BUF_LEN;
 249                         } else {
 250                                 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 251                                         rds_ring->dma_size =
 252                                                 NX_P3_RX_BUF_MAX_LEN;
 253                                 else
 254                                         rds_ring->dma_size =
 255                                                 NX_P2_RX_BUF_MAX_LEN;
 256                                 rds_ring->skb_size =
 257                                         rds_ring->dma_size + NET_IP_ALIGN;
 258                         }
 259                         break;
 260
 261                 case RCV_RING_JUMBO:
 262                         rds_ring->num_desc = adapter->num_jumbo_rxd;
 263                         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 264                                 rds_ring->dma_size =
 265                                         NX_P3_RX_JUMBO_BUF_MAX_LEN;
 266                         else
 267                                 rds_ring->dma_size =
 268                                         NX_P2_RX_JUMBO_BUF_MAX_LEN;
 269                         rds_ring->skb_size =
 270                                 rds_ring->dma_size + NET_IP_ALIGN;
 271                         break;
 272
 273                 case RCV_RING_LRO:
 274                         rds_ring->num_desc = adapter->num_lro_rxd;
 275                         rds_ring->dma_size = NX_RX_LRO_BUFFER_LENGTH;
 276                         rds_ring->skb_size = rds_ring->dma_size + NET_IP_ALIGN;
 277                         break;
 278
 279                 }
 280                 rds_ring->rx_buf_arr = (struct netxen_rx_buffer *)
 281                         vmalloc(RCV_BUFF_RINGSIZE(rds_ring));
 282                 if (rds_ring->rx_buf_arr == NULL) {
 283                         printk(KERN_ERR "%s: Failed to allocate "
 284                                 "rx buffer ring %d\n",
 285                                 netdev->name, ring);
 286                         /* free whatever was already allocated */
 287                         goto err_out;
 288                 }
 289                 memset(rds_ring->rx_buf_arr, 0, RCV_BUFF_RINGSIZE(rds_ring));
 290                 INIT_LIST_HEAD(&rds_ring->free_list);
 291                 /*
 292                  * Now go through all of them, set reference handles
 293                  * and put them in the queues.
 294                  */
 295                 rx_buf = rds_ring->rx_buf_arr;
 296                 for (i = 0; i < rds_ring->num_desc; i++) {
 297                         list_add_tail(&rx_buf->list,
 298                                         &rds_ring->free_list);
 299                         rx_buf->ref_handle = i;
 300                         rx_buf->state = NETXEN_BUFFER_FREE;
 301                         rx_buf++;
 302                 }
 303                 spin_lock_init(&rds_ring->lock);
 304         }
 305
 306         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 307                 sds_ring = &recv_ctx->sds_rings[ring];
 308                 sds_ring->irq = adapter->msix_entries[ring].vector;
 309                 sds_ring->adapter = adapter;
 310                 sds_ring->num_desc = adapter->num_rxd;
 311
 312                 for (i = 0; i < NUM_RCV_DESC_RINGS; i++)
 313                         INIT_LIST_HEAD(&sds_ring->free_list[i]);
 314         }
 315
 316         return 0;
 317
 318 err_out:
 319         netxen_free_sw_resources(adapter);
 320         return -ENOMEM;
 321 }
 322
 323 void netxen_initialize_adapter_ops(struct netxen_adapter *adapter)
 324 {
 325         adapter->macaddr_set = netxen_p2_nic_set_mac_addr;
 326         adapter->set_multi = netxen_p2_nic_set_multi;
 327
 328         switch (adapter->ahw.port_type) {
 329         case NETXEN_NIC_GBE:
 330                 adapter->enable_phy_interrupts =
 331                     netxen_niu_gbe_enable_phy_interrupts;
 332                 adapter->disable_phy_interrupts =
 333                     netxen_niu_gbe_disable_phy_interrupts;
 334                 adapter->set_mtu = netxen_nic_set_mtu_gb;
 335                 adapter->set_promisc = netxen_niu_set_promiscuous_mode;
 336                 adapter->phy_read = netxen_niu_gbe_phy_read;
 337                 adapter->phy_write = netxen_niu_gbe_phy_write;
 338                 adapter->init_port = netxen_niu_gbe_init_port;
 339                 adapter->stop_port = netxen_niu_disable_gbe_port;
 340                 break;
 341
 342         case NETXEN_NIC_XGBE:
 343                 adapter->enable_phy_interrupts =
 344                     netxen_niu_xgbe_enable_phy_interrupts;
 345                 adapter->disable_phy_interrupts =
 346                     netxen_niu_xgbe_disable_phy_interrupts;
 347                 adapter->set_mtu = netxen_nic_set_mtu_xgb;
 348                 adapter->init_port = netxen_niu_xg_init_port;
 349                 adapter->set_promisc = netxen_niu_xg_set_promiscuous_mode;
 350                 adapter->stop_port = netxen_niu_disable_xg_port;
 351                 break;
 352
 353         default:
 354                 break;
 355         }
 356
 357         if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 358                 adapter->set_mtu = nx_fw_cmd_set_mtu;
 359                 adapter->set_promisc = netxen_p3_nic_set_promisc;
 360                 adapter->macaddr_set = netxen_p3_nic_set_mac_addr;
 361                 adapter->set_multi = netxen_p3_nic_set_multi;
 362         }
 363 }
 364
 365 /*
 366  * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
 367  * address to external PCI CRB address.
 368  */
 369 static u32 netxen_decode_crb_addr(u32 addr)
 370 {
 371         int i;
 372         u32 base_addr, offset, pci_base;
 373
 374         crb_addr_transform_setup();
 375
 376         pci_base = NETXEN_ADDR_ERROR;
 377         base_addr = addr & 0xfff00000;
 378         offset = addr & 0x000fffff;
 379
 380         for (i = 0; i < NETXEN_MAX_CRB_XFORM; i++) {
 381                 if (crb_addr_xform[i] == base_addr) {
 382                         pci_base = i << 20;
 383                         break;
 384                 }
 385         }
 386         if (pci_base == NETXEN_ADDR_ERROR)
 387                 return pci_base;
 388         else
 389                 return (pci_base + offset);
 390 }
 391
 392 static long rom_max_timeout = 100;
 393 static long rom_lock_timeout = 10000;
 394
 395 static int rom_lock(struct netxen_adapter *adapter)
 396 {
 397         int iter;
 398         u32 done = 0;
 399         int timeout = 0;
 400
 401         while (!done) {
 402                 /* acquire semaphore2 from PCI HW block */
 403                 done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM2_LOCK));
 404                 if (done == 1)
 405                         break;
 406                 if (timeout >= rom_lock_timeout)
 407                         return -EIO;
 408
 409                 timeout++;
 410                 /*
 411                  * Yield CPU
 412                  */
 413                 if (!in_atomic())
 414                         schedule();
 415                 else {
 416                         for (iter = 0; iter < 20; iter++)
 417                                 cpu_relax();    /*This a nop instr on i386 */
 418                 }
 419         }
 420         NXWR32(adapter, NETXEN_ROM_LOCK_ID, ROM_LOCK_DRIVER);
 421         return 0;
 422 }
 423
 424 static int netxen_wait_rom_done(struct netxen_adapter *adapter)
 425 {
 426         long timeout = 0;
 427         long done = 0;
 428
 429         cond_resched();
 430
 431         while (done == 0) {
 432                 done = NXRD32(adapter, NETXEN_ROMUSB_GLB_STATUS);
 433                 done &= 2;
 434                 timeout++;
 435                 if (timeout >= rom_max_timeout) {
 436                         printk("Timeout reached  waiting for rom done");
 437                         return -EIO;
 438                 }
 439         }
 440         return 0;
 441 }
 442
 443 static void netxen_rom_unlock(struct netxen_adapter *adapter)
 444 {
 445         /* release semaphore2 */
 446         NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK));
 447
 448 }
 449
 450 static int do_rom_fast_read(struct netxen_adapter *adapter,
 451                             int addr, int *valp)
 452 {
 453         NXWR32(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
 454         NXWR32(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
 455         NXWR32(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
 456         NXWR32(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
 457         if (netxen_wait_rom_done(adapter)) {
 458                 printk("Error waiting for rom done\n");
 459                 return -EIO;
 460         }
 461         /* reset abyte_cnt and dummy_byte_cnt */
 462         NXWR32(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
 463         udelay(10);
 464         NXWR32(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
 465
 466         *valp = NXRD32(adapter, NETXEN_ROMUSB_ROM_RDATA);
 467         return 0;
 468 }
 469
 470 static int do_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
 471                                   u8 *bytes, size_t size)
 472 {
 473         int addridx;
 474         int ret = 0;
 475
 476         for (addridx = addr; addridx < (addr + size); addridx += 4) {
 477                 int v;
 478                 ret = do_rom_fast_read(adapter, addridx, &v);
 479                 if (ret != 0)
 480                         break;
 481                 *(__le32 *)bytes = cpu_to_le32(v);
 482                 bytes += 4;
 483         }
 484
 485         return ret;
 486 }
 487
 488 int
 489 netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
 490                                 u8 *bytes, size_t size)
 491 {
 492         int ret;
 493
 494         ret = rom_lock(adapter);
 495         if (ret < 0)
 496                 return ret;
 497
 498         ret = do_rom_fast_read_words(adapter, addr, bytes, size);
 499
 500         netxen_rom_unlock(adapter);
 501         return ret;
 502 }
 503
 504 int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
 505 {
 506         int ret;
 507
 508         if (rom_lock(adapter) != 0)
 509                 return -EIO;
 510
 511         ret = do_rom_fast_read(adapter, addr, valp);
 512         netxen_rom_unlock(adapter);
 513         return ret;
 514 }
 515
 516 #define NETXEN_BOARDTYPE                0x4008
 517 #define NETXEN_BOARDNUM                 0x400c
 518 #define NETXEN_CHIPNUM                  0x4010
 519
 520 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 521 {
 522         int addr, val;
 523         int i, n, init_delay = 0;
 524         struct crb_addr_pair *buf;
 525         unsigned offset;
 526         u32 off;
 527
 528         /* resetall */
 529         rom_lock(adapter);
 530         NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0xffffffff);
 531         netxen_rom_unlock(adapter);
 532
 533         if (verbose) {
 534                 if (netxen_rom_fast_read(adapter, NETXEN_BOARDTYPE, &val) == 0)
 535                         printk("P2 ROM board type: 0x%08x\n", val);
 536                 else
 537                         printk("Could not read board type\n");
 538                 if (netxen_rom_fast_read(adapter, NETXEN_BOARDNUM, &val) == 0)
 539                         printk("P2 ROM board  num: 0x%08x\n", val);
 540                 else
 541                         printk("Could not read board number\n");
 542                 if (netxen_rom_fast_read(adapter, NETXEN_CHIPNUM, &val) == 0)
 543                         printk("P2 ROM chip   num: 0x%08x\n", val);
 544                 else
 545                         printk("Could not read chip number\n");
 546         }
 547
 548         if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 549                 if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
 550                         (n != 0xcafecafe) ||
 551                         netxen_rom_fast_read(adapter, 4, &n) != 0) {
 552                         printk(KERN_ERR "%s: ERROR Reading crb_init area: "
 553                                         "n: %08x\n", netxen_nic_driver_name, n);
 554                         return -EIO;
 555                 }
 556                 offset = n & 0xffffU;
 557                 n = (n >> 16) & 0xffffU;
 558         } else {
 559                 if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
 560                         !(n & 0x80000000)) {
 561                         printk(KERN_ERR "%s: ERROR Reading crb_init area: "
 562                                         "n: %08x\n", netxen_nic_driver_name, n);
 563                         return -EIO;
 564                 }
 565                 offset = 1;
 566                 n &= ~0x80000000;
 567         }
 568
 569         if (n < 1024) {
 570                 if (verbose)
 571                         printk(KERN_DEBUG "%s: %d CRB init values found"
 572                                " in ROM.\n", netxen_nic_driver_name, n);
 573         } else {
 574                 printk(KERN_ERR "%s:n=0x%x Error! NetXen card flash not"
 575                        " initialized.\n", __func__, n);
 576                 return -EIO;
 577         }
 578
 579         buf = kcalloc(n, sizeof(struct crb_addr_pair), GFP_KERNEL);
 580         if (buf == NULL) {
 581                 printk("%s: netxen_pinit_from_rom: Unable to calloc memory.\n",
 582                                 netxen_nic_driver_name);
 583                 return -ENOMEM;
 584         }
 585         for (i = 0; i < n; i++) {
 586                 if (netxen_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
 587                 netxen_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0) {
 588                         kfree(buf);
 589                         return -EIO;
 590                 }
 591
 592                 buf[i].addr = addr;
 593                 buf[i].data = val;
 594
 595                 if (verbose)
 596                         printk(KERN_DEBUG "%s: PCI:     0x%08x == 0x%08x\n",
 597                                 netxen_nic_driver_name,
 598                                 (u32)netxen_decode_crb_addr(addr), val);
 599         }
 600         for (i = 0; i < n; i++) {
 601
 602                 off = netxen_decode_crb_addr(buf[i].addr);
 603                 if (off == NETXEN_ADDR_ERROR) {
 604                         printk(KERN_ERR"CRB init value out of range %x\n",
 605                                         buf[i].addr);
 606                         continue;
 607                 }
 608                 off += NETXEN_PCI_CRBSPACE;
 609                 /* skipping cold reboot MAGIC */
 610                 if (off == NETXEN_CAM_RAM(0x1fc))
 611                         continue;
 612
 613                 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 614                         /* do not reset PCI */
 615                         if (off == (ROMUSB_GLB + 0xbc))
 616                                 continue;
 617                         if (off == (ROMUSB_GLB + 0xa8))
 618                                 continue;
 619                         if (off == (ROMUSB_GLB + 0xc8)) /* core clock */
 620                                 continue;
 621                         if (off == (ROMUSB_GLB + 0x24)) /* MN clock */
 622                                 continue;
 623                         if (off == (ROMUSB_GLB + 0x1c)) /* MS clock */
 624                                 continue;
 625                         if (off == (NETXEN_CRB_PEG_NET_1 + 0x18))
 626                                 buf[i].data = 0x1020;
 627                         /* skip the function enable register */
 628                         if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION))
 629                                 continue;
 630                         if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION2))
 631                                 continue;
 632                         if ((off & 0x0ff00000) == NETXEN_CRB_SMB)
 633                                 continue;
 634                 }
 635
 636                 if (off == NETXEN_ADDR_ERROR) {
 637                         printk(KERN_ERR "%s: Err: Unknown addr: 0x%08x\n",
 638                                         netxen_nic_driver_name, buf[i].addr);
 639                         continue;
 640                 }
 641
 642                 init_delay = 1;
 643                 /* After writing this register, HW needs time for CRB */
 644                 /* to quiet down (else crb_window returns 0xffffffff) */
 645                 if (off == NETXEN_ROMUSB_GLB_SW_RESET) {
 646                         init_delay = 1000;
 647                         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 648                                 /* hold xdma in reset also */
 649                                 buf[i].data = NETXEN_NIC_XDMA_RESET;
 650                                 buf[i].data = 0x8000ff;
 651                         }
 652                 }
 653
 654                 NXWR32(adapter, off, buf[i].data);
 655
 656                 msleep(init_delay);
 657         }
 658         kfree(buf);
 659
 660         /* disable_peg_cache_all */
 661
 662         /* unreset_net_cache */
 663         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 664                 val = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
 665                 NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, (val & 0xffffff0f));
 666         }
 667
 668         /* p2dn replyCount */
 669         NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0xec, 0x1e);
 670         /* disable_peg_cache 0 */
 671         NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0x4c, 8);
 672         /* disable_peg_cache 1 */
 673         NXWR32(adapter, NETXEN_CRB_PEG_NET_I + 0x4c, 8);
 674
 675         /* peg_clr_all */
 676
 677         /* peg_clr 0 */
 678         NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0x8, 0);
 679         NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0xc, 0);
 680         /* peg_clr 1 */
 681         NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0x8, 0);
 682         NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0xc, 0);
 683         /* peg_clr 2 */
 684         NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0x8, 0);
 685         NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0xc, 0);
 686         /* peg_clr 3 */
 687         NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0x8, 0);
 688         NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0xc, 0);
 689         return 0;
 690 }
 691
 692 int
 693 netxen_need_fw_reset(struct netxen_adapter *adapter)
 694 {
 695         u32 count, old_count;
 696         u32 val, version, major, minor, build;
 697         int i, timeout;
 698         u8 fw_type;
 699
 700         /* NX2031 firmware doesn't support heartbit */
 701         if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
 702                 return 1;
 703
 704         /* last attempt had failed */
 705         if (NXRD32(adapter, CRB_CMDPEG_STATE) == PHAN_INITIALIZE_FAILED)
 706                 return 1;
 707
 708         old_count = count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
 709
 710         for (i = 0; i < 10; i++) {
 711
 712                 timeout = msleep_interruptible(200);
 713                 if (timeout) {
 714                         NXWR32(adapter, CRB_CMDPEG_STATE,
 715                                         PHAN_INITIALIZE_FAILED);
 716                         return -EINTR;
 717                 }
 718
 719                 count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
 720                 if (count != old_count)
 721                         break;
 722         }
 723
 724         /* firmware is dead */
 725         if (count == old_count)
 726                 return 1;
 727
 728         /* check if we have got newer or different file firmware */
 729         if (adapter->fw) {
 730
 731                 const struct firmware *fw = adapter->fw;
 732
 733                 val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_VERSION_OFFSET]);
 734                 version = NETXEN_DECODE_VERSION(val);
 735
 736                 major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
 737                 minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
 738                 build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
 739
 740                 if (version > NETXEN_VERSION_CODE(major, minor, build))
 741                         return 1;
 742
 743                 if (version == NETXEN_VERSION_CODE(major, minor, build)) {
 744
 745                         val = NXRD32(adapter, NETXEN_MIU_MN_CONTROL);
 746                         fw_type = (val & 0x4) ?
 747                                 NX_P3_CT_ROMIMAGE : NX_P3_MN_ROMIMAGE;
 748
 749                         if (adapter->fw_type != fw_type)
 750                                 return 1;
 751                 }
 752         }
 753
 754         return 0;
 755 }
 756
 757 static char *fw_name[] = {
 758         "nxromimg.bin", "nx3fwct.bin", "nx3fwmn.bin", "flash",
 759 };
 760
 761 int
 762 netxen_load_firmware(struct netxen_adapter *adapter)
 763 {
 764         u64 *ptr64;
 765         u32 i, flashaddr, size;
 766         const struct firmware *fw = adapter->fw;
 767         struct pci_dev *pdev = adapter->pdev;
 768
 769         dev_info(&pdev->dev, "loading firmware from %s\n",
 770                         fw_name[adapter->fw_type]);
 771
 772         if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
 773                 NXWR32(adapter, NETXEN_ROMUSB_GLB_CAS_RST, 1);
 774
 775         if (fw) {
 776                 __le64 data;
 777
 778                 size = (NETXEN_IMAGE_START - NETXEN_BOOTLD_START) / 8;
 779
 780                 ptr64 = (u64 *)&fw->data[NETXEN_BOOTLD_START];
 781                 flashaddr = NETXEN_BOOTLD_START;
 782
 783                 for (i = 0; i < size; i++) {
 784                         data = cpu_to_le64(ptr64[i]);
 785                         adapter->pci_mem_write(adapter, flashaddr, &data, 8);
 786                         flashaddr += 8;
 787                 }
 788
 789                 size = *(u32 *)&fw->data[NX_FW_SIZE_OFFSET];
 790                 size = (__force u32)cpu_to_le32(size) / 8;
 791
 792                 ptr64 = (u64 *)&fw->data[NETXEN_IMAGE_START];
 793                 flashaddr = NETXEN_IMAGE_START;
 794
 795                 for (i = 0; i < size; i++) {
 796                         data = cpu_to_le64(ptr64[i]);
 797
 798                         if (adapter->pci_mem_write(adapter,
 799                                                 flashaddr, &data, 8))
 800                                 return -EIO;
 801
 802                         flashaddr += 8;
 803                 }
 804         } else {
 805                 u32 data;
 806
 807                 size = (NETXEN_IMAGE_START - NETXEN_BOOTLD_START) / 4;
 808                 flashaddr = NETXEN_BOOTLD_START;
 809
 810                 for (i = 0; i < size; i++) {
 811                         if (netxen_rom_fast_read(adapter,
 812                                         flashaddr, (int *)&data) != 0)
 813                                 return -EIO;
 814
 815                         if (adapter->pci_mem_write(adapter,
 816                                                 flashaddr, &data, 4))
 817                                 return -EIO;
 818
 819                         flashaddr += 4;
 820                 }
 821         }
 822         msleep(1);
 823
 824         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 825                 NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0x80001d);
 826         else {
 827                 NXWR32(adapter, NETXEN_ROMUSB_GLB_CHIP_CLK_CTRL, 0x3fff);
 828                 NXWR32(adapter, NETXEN_ROMUSB_GLB_CAS_RST, 0);
 829         }
 830
 831         return 0;
 832 }
 833
 834 static int
 835 netxen_validate_firmware(struct netxen_adapter *adapter, const char *fwname)
 836 {
 837         __le32 val;
 838         u32 ver, min_ver, bios;
 839         struct pci_dev *pdev = adapter->pdev;
 840         const struct firmware *fw = adapter->fw;
 841
 842         if (fw->size < NX_FW_MIN_SIZE)
 843                 return -EINVAL;
 844
 845         val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_MAGIC_OFFSET]);
 846         if ((__force u32)val != NETXEN_BDINFO_MAGIC)
 847                 return -EINVAL;
 848
 849         val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_VERSION_OFFSET]);
 850
 851         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 852                 min_ver = NETXEN_VERSION_CODE(4, 0, 216);
 853         else
 854                 min_ver = NETXEN_VERSION_CODE(3, 4, 216);
 855
 856         ver = NETXEN_DECODE_VERSION(val);
 857
 858         if ((_major(ver) > _NETXEN_NIC_LINUX_MAJOR) || (ver < min_ver)) {
 859                 dev_err(&pdev->dev,
 860                                 "%s: firmware version %d.%d.%d unsupported\n",
 861                                 fwname, _major(ver), _minor(ver), _build(ver));
 862                 return -EINVAL;
 863         }
 864
 865         val = cpu_to_le32(*(u32 *)&fw->data[NX_BIOS_VERSION_OFFSET]);
 866         netxen_rom_fast_read(adapter, NX_BIOS_VERSION_OFFSET, (int *)&bios);
 867         if ((__force u32)val != bios) {
 868                 dev_err(&pdev->dev, "%s: firmware bios is incompatible\n",
 869                                 fwname);
 870                 return -EINVAL;
 871         }
 872
 873         /* check if flashed firmware is newer */
 874         if (netxen_rom_fast_read(adapter,
 875                         NX_FW_VERSION_OFFSET, (int *)&val))
 876                 return -EIO;
 877         val = NETXEN_DECODE_VERSION(val);
 878         if (val > ver) {
 879                 dev_info(&pdev->dev, "%s: firmware is older than flash\n",
 880                                 fwname);
 881                 return -EINVAL;
 882         }
 883
 884         NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
 885         return 0;
 886 }
 887
 888 static int
 889 netxen_p3_has_mn(struct netxen_adapter *adapter)
 890 {
 891         u32 capability, flashed_ver;
 892         capability = 0;
 893
 894         netxen_rom_fast_read(adapter,
 895                         NX_FW_VERSION_OFFSET, (int *)&flashed_ver);
 896         flashed_ver = NETXEN_DECODE_VERSION(flashed_ver);
 897
 898         if (flashed_ver >= NETXEN_VERSION_CODE(4, 0, 220)) {
 899
 900                 capability = NXRD32(adapter, NX_PEG_TUNE_CAPABILITY);
 901                 if (capability & NX_PEG_TUNE_MN_PRESENT)
 902                         return 1;
 903         }
 904         return 0;
 905 }
 906
 907 void netxen_request_firmware(struct netxen_adapter *adapter)
 908 {
 909         u8 fw_type;
 910         struct pci_dev *pdev = adapter->pdev;
 911         int rc = 0;
 912
 913         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 914                 fw_type = NX_P2_MN_ROMIMAGE;
 915                 goto request_fw;
 916         }
 917
 918         fw_type = netxen_p3_has_mn(adapter) ?
 919                 NX_P3_MN_ROMIMAGE : NX_P3_CT_ROMIMAGE;
 920
 921 request_fw:
 922         rc = request_firmware(&adapter->fw, fw_name[fw_type], &pdev->dev);
 923         if (rc != 0) {
 924                 if (fw_type == NX_P3_MN_ROMIMAGE) {
 925                         msleep(1);
 926                         fw_type = NX_P3_CT_ROMIMAGE;
 927                         goto request_fw;
 928                 }
 929
 930                 fw_type = NX_FLASH_ROMIMAGE;
 931                 adapter->fw = NULL;
 932                 goto done;
 933         }
 934
 935         rc = netxen_validate_firmware(adapter, fw_name[fw_type]);
 936         if (rc != 0) {
 937                 release_firmware(adapter->fw);
 938
 939                 if (fw_type == NX_P3_MN_ROMIMAGE) {
 940                         msleep(1);
 941                         fw_type = NX_P3_CT_ROMIMAGE;
 942                         goto request_fw;
 943                 }
 944
 945                 fw_type = NX_FLASH_ROMIMAGE;
 946                 adapter->fw = NULL;
 947                 goto done;
 948         }
 949
 950 done:
 951         adapter->fw_type = fw_type;
 952 }
 953
 954
 955 void
 956 netxen_release_firmware(struct netxen_adapter *adapter)
 957 {
 958         if (adapter->fw)
 959                 release_firmware(adapter->fw);
 960 }
 961
 962 int netxen_init_dummy_dma(struct netxen_adapter *adapter)
 963 {
 964         u64 addr;
 965         u32 hi, lo;
 966
 967         if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
 968                 return 0;
 969
 970         adapter->dummy_dma.addr = pci_alloc_consistent(adapter->pdev,
 971                                  NETXEN_HOST_DUMMY_DMA_SIZE,
 972                                  &adapter->dummy_dma.phys_addr);
 973         if (adapter->dummy_dma.addr == NULL) {
 974                 dev_err(&adapter->pdev->dev,
 975                         "ERROR: Could not allocate dummy DMA memory\n");
 976                 return -ENOMEM;
 977         }
 978
 979         addr = (uint64_t) adapter->dummy_dma.phys_addr;
 980         hi = (addr >> 32) & 0xffffffff;
 981         lo = addr & 0xffffffff;
 982
 983         NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_HI, hi);
 984         NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_LO, lo);
 985
 986         return 0;
 987 }
 988
 989 /*
 990  * NetXen DMA watchdog control:
 991  *
 992  *      Bit 0           : enabled => R/O: 1 watchdog active, 0 inactive
 993  *      Bit 1           : disable_request => 1 req disable dma watchdog
 994  *      Bit 2           : enable_request =>  1 req enable dma watchdog
 995  *      Bit 3-31        : unused
 996  */
 997 void netxen_free_dummy_dma(struct netxen_adapter *adapter)
 998 {
 999         int i = 100;
1000         u32 ctrl;
1001
1002         if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
1003                 return;
1004
1005         if (!adapter->dummy_dma.addr)
1006                 return;
1007
1008         ctrl = NXRD32(adapter, NETXEN_DMA_WATCHDOG_CTRL);
1009         if ((ctrl & 0x1) != 0) {
1010                 NXWR32(adapter, NETXEN_DMA_WATCHDOG_CTRL, (ctrl | 0x2));
1011
1012                 while ((ctrl & 0x1) != 0) {
1013
1014                         msleep(50);
1015
1016                         ctrl = NXRD32(adapter, NETXEN_DMA_WATCHDOG_CTRL);
1017
1018                         if (--i == 0)
1019                                 break;
1020                 };
1021         }
1022
1023         if (i) {
1024                 pci_free_consistent(adapter->pdev,
1025                             NETXEN_HOST_DUMMY_DMA_SIZE,
1026                             adapter->dummy_dma.addr,
1027                             adapter->dummy_dma.phys_addr);
1028                 adapter->dummy_dma.addr = NULL;
1029         } else
1030                 dev_err(&adapter->pdev->dev, "dma_watchdog_shutdown failed\n");
1031 }
1032
1033 int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
1034 {
1035         u32 val = 0;
1036         int retries = 60;
1037
1038         if (pegtune_val)
1039                 return 0;
1040
1041         do {
1042                 val = NXRD32(adapter, CRB_CMDPEG_STATE);
1043
1044                 switch (val) {
1045                 case PHAN_INITIALIZE_COMPLETE:
1046                 case PHAN_INITIALIZE_ACK:
1047                         return 0;
1048                 case PHAN_INITIALIZE_FAILED:
1049                         goto out_err;
1050                 default:
1051                         break;
1052                 }
1053
1054                 msleep(500);
1055
1056         } while (--retries);
1057
1058         NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_FAILED);
1059
1060 out_err:
1061         dev_warn(&adapter->pdev->dev, "firmware init failed\n");
1062         return -EIO;
1063 }
1064
1065 static int
1066 netxen_receive_peg_ready(struct netxen_adapter *adapter)
1067 {
1068         u32 val = 0;
1069         int retries = 2000;
1070
1071         do {
1072                 val = NXRD32(adapter, CRB_RCVPEG_STATE);
1073
1074                 if (val == PHAN_PEG_RCV_INITIALIZED)
1075                         return 0;
1076
1077                 msleep(10);
1078
1079         } while (--retries);
1080
1081         if (!retries) {
1082                 printk(KERN_ERR "Receive Peg initialization not "
1083                               "complete, state: 0x%x.\n", val);
1084                 return -EIO;
1085         }
1086
1087         return 0;
1088 }
1089
1090 int netxen_init_firmware(struct netxen_adapter *adapter)
1091 {
1092         int err;
1093
1094         err = netxen_receive_peg_ready(adapter);
1095         if (err)
1096                 return err;
1097
1098         NXWR32(adapter, CRB_NIC_CAPABILITIES_HOST, INTR_SCHEME_PERPORT);
1099         NXWR32(adapter, CRB_NIC_MSI_MODE_HOST, MSI_MODE_MULTIFUNC);
1100         NXWR32(adapter, CRB_MPORT_MODE, MPORT_MULTI_FUNCTION_MODE);
1101         NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
1102
1103         return err;
1104 }
1105
1106 static void
1107 netxen_handle_linkevent(struct netxen_adapter *adapter, nx_fw_msg_t *msg)
1108 {
1109         u32 cable_OUI;
1110         u16 cable_len;
1111         u16 link_speed;
1112         u8  link_status, module, duplex, autoneg;
1113         struct net_device *netdev = adapter->netdev;
1114
1115         adapter->has_link_events = 1;
1116
1117         cable_OUI = msg->body[1] & 0xffffffff;
1118         cable_len = (msg->body[1] >> 32) & 0xffff;
1119         link_speed = (msg->body[1] >> 48) & 0xffff;
1120
1121         link_status = msg->body[2] & 0xff;
1122         duplex = (msg->body[2] >> 16) & 0xff;
1123         autoneg = (msg->body[2] >> 24) & 0xff;
1124
1125         module = (msg->body[2] >> 8) & 0xff;
1126         if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE) {
1127                 printk(KERN_INFO "%s: unsupported cable: OUI 0x%x, length %d\n",
1128                                 netdev->name, cable_OUI, cable_len);
1129         } else if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN) {
1130                 printk(KERN_INFO "%s: unsupported cable length %d\n",
1131                                 netdev->name, cable_len);
1132         }
1133
1134         netxen_advert_link_change(adapter, link_status);
1135
1136         /* update link parameters */
1137         if (duplex == LINKEVENT_FULL_DUPLEX)
1138                 adapter->link_duplex = DUPLEX_FULL;
1139         else
1140                 adapter->link_duplex = DUPLEX_HALF;
1141         adapter->module_type = module;
1142         adapter->link_autoneg = autoneg;
1143         adapter->link_speed = link_speed;
1144 }
1145
1146 static void
1147 netxen_handle_fw_message(int desc_cnt, int index,
1148                 struct nx_host_sds_ring *sds_ring)
1149 {
1150         nx_fw_msg_t msg;
1151         struct status_desc *desc;
1152         int i = 0, opcode;
1153
1154         while (desc_cnt > 0 && i < 8) {
1155                 desc = &sds_ring->desc_head[index];
1156                 msg.words[i++] = le64_to_cpu(desc->status_desc_data[0]);
1157                 msg.words[i++] = le64_to_cpu(desc->status_desc_data[1]);
1158
1159                 index = get_next_index(index, sds_ring->num_desc);
1160                 desc_cnt--;
1161         }
1162
1163         opcode = netxen_get_nic_msg_opcode(msg.body[0]);
1164         switch (opcode) {
1165         case NX_NIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE:
1166                 netxen_handle_linkevent(sds_ring->adapter, &msg);
1167                 break;
1168         default:
1169                 break;
1170         }
1171 }
1172
1173 static int
1174 netxen_alloc_rx_skb(struct netxen_adapter *adapter,
1175                 struct nx_host_rds_ring *rds_ring,
1176                 struct netxen_rx_buffer *buffer)
1177 {
1178         struct sk_buff *skb;
1179         dma_addr_t dma;
1180         struct pci_dev *pdev = adapter->pdev;
1181
1182         buffer->skb = dev_alloc_skb(rds_ring->skb_size);
1183         if (!buffer->skb)
1184                 return 1;
1185
1186         skb = buffer->skb;
1187
1188         if (!adapter->ahw.cut_through)
1189                 skb_reserve(skb, 2);
1190
1191         dma = pci_map_single(pdev, skb->data,
1192                         rds_ring->dma_size, PCI_DMA_FROMDEVICE);
1193
1194         if (pci_dma_mapping_error(pdev, dma)) {
1195                 dev_kfree_skb_any(skb);
1196                 buffer->skb = NULL;
1197                 return 1;
1198         }
1199
1200         buffer->skb = skb;
1201         buffer->dma = dma;
1202         buffer->state = NETXEN_BUFFER_BUSY;
1203
1204         return 0;
1205 }
1206
1207 static struct sk_buff *netxen_process_rxbuf(struct netxen_adapter *adapter,
1208                 struct nx_host_rds_ring *rds_ring, u16 index, u16 cksum)
1209 {
1210         struct netxen_rx_buffer *buffer;
1211         struct sk_buff *skb;
1212
1213         buffer = &rds_ring->rx_buf_arr[index];
1214
1215         pci_unmap_single(adapter->pdev, buffer->dma, rds_ring->dma_size,
1216                         PCI_DMA_FROMDEVICE);
1217
1218         skb = buffer->skb;
1219         if (!skb)
1220                 goto no_skb;
1221
1222         if (likely(adapter->rx_csum && cksum == STATUS_CKSUM_OK)) {
1223                 adapter->stats.csummed++;
1224                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1225         } else
1226                 skb->ip_summed = CHECKSUM_NONE;
1227
1228         skb->dev = adapter->netdev;
1229
1230         buffer->skb = NULL;
1231 no_skb:
1232         buffer->state = NETXEN_BUFFER_FREE;
1233         return skb;
1234 }
1235
1236 static struct netxen_rx_buffer *
1237 netxen_process_rcv(struct netxen_adapter *adapter,
1238                 struct nx_host_sds_ring *sds_ring,
1239                 int ring, u64 sts_data0)
1240 {
1241         struct net_device *netdev = adapter->netdev;
1242         struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
1243         struct netxen_rx_buffer *buffer;
1244         struct sk_buff *skb;
1245         struct nx_host_rds_ring *rds_ring;
1246         int index, length, cksum, pkt_offset;
1247
1248         if (unlikely(ring >= adapter->max_rds_rings))
1249                 return NULL;
1250
1251         rds_ring = &recv_ctx->rds_rings[ring];
1252
1253         index = netxen_get_sts_refhandle(sts_data0);
1254         if (unlikely(index >= rds_ring->num_desc))
1255                 return NULL;
1256
1257         buffer = &rds_ring->rx_buf_arr[index];
1258
1259         length = netxen_get_sts_totallength(sts_data0);
1260         cksum  = netxen_get_sts_status(sts_data0);
1261         pkt_offset = netxen_get_sts_pkt_offset(sts_data0);
1262
1263         skb = netxen_process_rxbuf(adapter, rds_ring, index, cksum);
1264         if (!skb)
1265                 return buffer;
1266
1267         if (length > rds_ring->skb_size)
1268                 skb_put(skb, rds_ring->skb_size);
1269         else
1270                 skb_put(skb, length);
1271
1272
1273         if (pkt_offset)
1274                 skb_pull(skb, pkt_offset);
1275
1276         skb->protocol = eth_type_trans(skb, netdev);
1277
1278         napi_gro_receive(&sds_ring->napi, skb);
1279
1280         adapter->stats.no_rcv++;
1281         adapter->stats.rxbytes += length;
1282
1283         return buffer;
1284 }
1285
1286 #define TCP_HDR_SIZE            20
1287 #define TCP_TS_OPTION_SIZE      12
1288 #define TCP_TS_HDR_SIZE         (TCP_HDR_SIZE + TCP_TS_OPTION_SIZE)
1289
1290 static struct netxen_rx_buffer *
1291 netxen_process_lro(struct netxen_adapter *adapter,
1292                 struct nx_host_sds_ring *sds_ring,
1293                 int ring, u64 sts_data0, u64 sts_data1)
1294 {
1295         struct net_device *netdev = adapter->netdev;
1296         struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
1297         struct netxen_rx_buffer *buffer;
1298         struct sk_buff *skb;
1299         struct nx_host_rds_ring *rds_ring;
1300         struct iphdr *iph;
1301         struct tcphdr *th;
1302         bool push, timestamp;
1303         int l2_hdr_offset, l4_hdr_offset;
1304         int index;
1305         u16 lro_length, length, data_offset;
1306         u32 seq_number;
1307
1308         if (unlikely(ring > adapter->max_rds_rings))
1309                 return NULL;
1310
1311         rds_ring = &recv_ctx->rds_rings[ring];
1312
1313         index = netxen_get_lro_sts_refhandle(sts_data0);
1314         if (unlikely(index > rds_ring->num_desc))
1315                 return NULL;
1316
1317         buffer = &rds_ring->rx_buf_arr[index];
1318
1319         timestamp = netxen_get_lro_sts_timestamp(sts_data0);
1320         lro_length = netxen_get_lro_sts_length(sts_data0);
1321         l2_hdr_offset = netxen_get_lro_sts_l2_hdr_offset(sts_data0);
1322         l4_hdr_offset = netxen_get_lro_sts_l4_hdr_offset(sts_data0);
1323         push = netxen_get_lro_sts_push_flag(sts_data0);
1324         seq_number = netxen_get_lro_sts_seq_number(sts_data1);
1325
1326         skb = netxen_process_rxbuf(adapter, rds_ring, index, STATUS_CKSUM_OK);
1327         if (!skb)
1328                 return buffer;
1329
1330         if (timestamp)
1331                 data_offset = l4_hdr_offset + TCP_TS_HDR_SIZE;
1332         else
1333                 data_offset = l4_hdr_offset + TCP_HDR_SIZE;
1334
1335         skb_put(skb, lro_length + data_offset);
1336
1337         skb->truesize = (skb->len + sizeof(struct sk_buff) +
1338                         ((unsigned long)skb->data - (unsigned long)skb->head));
1339
1340         skb_pull(skb, l2_hdr_offset);
1341         skb->protocol = eth_type_trans(skb, netdev);
1342
1343         iph = (struct iphdr *)skb->data;
1344         th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
1345
1346         length = (iph->ihl << 2) + (th->doff << 2) + lro_length;
1347         iph->tot_len = htons(length);
1348         iph->check = 0;
1349         iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
1350         th->psh = push;
1351         th->seq = htonl(seq_number);
1352
1353         netif_receive_skb(skb);
1354
1355         return buffer;
1356 }
1357
1358 #define netxen_merge_rx_buffers(list, head) \
1359         do { list_splice_tail_init(list, head); } while (0);
1360
1361 int
1362 netxen_process_rcv_ring(struct nx_host_sds_ring *sds_ring, int max)
1363 {
1364         struct netxen_adapter *adapter = sds_ring->adapter;
1365
1366         struct list_head *cur;
1367
1368         struct status_desc *desc;
1369         struct netxen_rx_buffer *rxbuf;
1370
1371         u32 consumer = sds_ring->consumer;
1372
1373         int count = 0;
1374         u64 sts_data0, sts_data1;
1375         int opcode, ring = 0, desc_cnt;
1376
1377         while (count < max) {
1378                 desc = &sds_ring->desc_head[consumer];
1379                 sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
1380
1381                 if (!(sts_data0 & STATUS_OWNER_HOST))
1382                         break;
1383
1384                 desc_cnt = netxen_get_sts_desc_cnt(sts_data0);
1385
1386                 opcode = netxen_get_sts_opcode(sts_data0);
1387
1388                 switch (opcode) {
1389                 case NETXEN_NIC_RXPKT_DESC:
1390                 case NETXEN_OLD_RXPKT_DESC:
1391                 case NETXEN_NIC_SYN_OFFLOAD:
1392                         ring = netxen_get_sts_type(sts_data0);
1393                         rxbuf = netxen_process_rcv(adapter, sds_ring,
1394                                         ring, sts_data0);
1395                         break;
1396                 case NETXEN_NIC_LRO_DESC:
1397                         ring = netxen_get_lro_sts_type(sts_data0);
1398                         sts_data1 = le64_to_cpu(desc->status_desc_data[1]);
1399                         rxbuf = netxen_process_lro(adapter, sds_ring,
1400                                         ring, sts_data0, sts_data1);
1401                         break;
1402                 case NETXEN_NIC_RESPONSE_DESC:
1403                         netxen_handle_fw_message(desc_cnt, consumer, sds_ring);
1404                 default:
1405                         goto skip;
1406                 }
1407
1408                 WARN_ON(desc_cnt > 1);
1409
1410                 if (rxbuf)
1411                         list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
1412
1413 skip:
1414                 for (; desc_cnt > 0; desc_cnt--) {
1415                         desc = &sds_ring->desc_head[consumer];
1416                         desc->status_desc_data[0] =
1417                                 cpu_to_le64(STATUS_OWNER_PHANTOM);
1418                         consumer = get_next_index(consumer, sds_ring->num_desc);
1419                 }
1420                 count++;
1421         }
1422
1423         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1424                 struct nx_host_rds_ring *rds_ring =
1425                         &adapter->recv_ctx.rds_rings[ring];
1426
1427                 if (!list_empty(&sds_ring->free_list[ring])) {
1428                         list_for_each(cur, &sds_ring->free_list[ring]) {
1429                                 rxbuf = list_entry(cur,
1430                                                 struct netxen_rx_buffer, list);
1431                                 netxen_alloc_rx_skb(adapter, rds_ring, rxbuf);
1432                         }
1433                         spin_lock(&rds_ring->lock);
1434                         netxen_merge_rx_buffers(&sds_ring->free_list[ring],
1435                                                 &rds_ring->free_list);
1436                         spin_unlock(&rds_ring->lock);
1437                 }
1438
1439                 netxen_post_rx_buffers_nodb(adapter, rds_ring);
1440         }
1441
1442         if (count) {
1443                 sds_ring->consumer = consumer;
1444                 NXWR32(adapter, sds_ring->crb_sts_consumer, consumer);
1445         }
1446
1447         return count;
1448 }
1449
1450 /* Process Command status ring */
1451 int netxen_process_cmd_ring(struct netxen_adapter *adapter)
1452 {
1453         u32 sw_consumer, hw_consumer;
1454         int count = 0, i;
1455         struct netxen_cmd_buffer *buffer;
1456         struct pci_dev *pdev = adapter->pdev;
1457         struct net_device *netdev = adapter->netdev;
1458         struct netxen_skb_frag *frag;
1459         int done = 0;
1460         struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
1461
1462         if (!spin_trylock(&adapter->tx_clean_lock))
1463                 return 1;
1464
1465         sw_consumer = tx_ring->sw_consumer;
1466         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
1467
1468         while (sw_consumer != hw_consumer) {
1469                 buffer = &tx_ring->cmd_buf_arr[sw_consumer];
1470                 if (buffer->skb) {
1471                         frag = &buffer->frag_array[0];
1472                         pci_unmap_single(pdev, frag->dma, frag->length,
1473                                          PCI_DMA_TODEVICE);
1474                         frag->dma = 0ULL;
1475                         for (i = 1; i < buffer->frag_count; i++) {
1476                                 frag++; /* Get the next frag */
1477                                 pci_unmap_page(pdev, frag->dma, frag->length,
1478                                                PCI_DMA_TODEVICE);
1479                                 frag->dma = 0ULL;
1480                         }
1481
1482                         adapter->stats.xmitfinished++;
1483                         dev_kfree_skb_any(buffer->skb);
1484                         buffer->skb = NULL;
1485                 }
1486
1487                 sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
1488                 if (++count >= MAX_STATUS_HANDLE)
1489                         break;
1490         }
1491
1492         if (count && netif_running(netdev)) {
1493                 tx_ring->sw_consumer = sw_consumer;
1494
1495                 smp_mb();
1496
1497                 if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
1498                         __netif_tx_lock(tx_ring->txq, smp_processor_id());
1499                         if (netxen_tx_avail(tx_ring) > TX_STOP_THRESH)
1500                                 netif_wake_queue(netdev);
1501                         __netif_tx_unlock(tx_ring->txq);
1502                 }
1503         }
1504         /*
1505          * If everything is freed up to consumer then check if the ring is full
1506          * If the ring is full then check if more needs to be freed and
1507          * schedule the call back again.
1508          *
1509          * This happens when there are 2 CPUs. One could be freeing and the
1510          * other filling it. If the ring is full when we get out of here and
1511          * the card has already interrupted the host then the host can miss the
1512          * interrupt.
1513          *
1514          * There is still a possible race condition and the host could miss an
1515          * interrupt. The card has to take care of this.
1516          */
1517         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
1518         done = (sw_consumer == hw_consumer);
1519         spin_unlock(&adapter->tx_clean_lock);
1520
1521         return (done);
1522 }
1523
1524 void
1525 netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
1526         struct nx_host_rds_ring *rds_ring)
1527 {
1528         struct rcv_desc *pdesc;
1529         struct netxen_rx_buffer *buffer;
1530         int producer, count = 0;
1531         netxen_ctx_msg msg = 0;
1532         struct list_head *head;
1533
1534         producer = rds_ring->producer;
1535
1536         spin_lock(&rds_ring->lock);
1537         head = &rds_ring->free_list;
1538         while (!list_empty(head)) {
1539
1540                 buffer = list_entry(head->next, struct netxen_rx_buffer, list);
1541
1542                 if (!buffer->skb) {
1543                         if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
1544                                 break;
1545                 }
1546
1547                 count++;
1548                 list_del(&buffer->list);
1549
1550                 /* make a rcv descriptor  */
1551                 pdesc = &rds_ring->desc_head[producer];
1552                 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1553                 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
1554                 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1555
1556                 producer = get_next_index(producer, rds_ring->num_desc);
1557         }
1558         spin_unlock(&rds_ring->lock);
1559
1560         if (count) {
1561                 rds_ring->producer = producer;
1562                 NXWR32(adapter, rds_ring->crb_rcv_producer,
1563                                 (producer-1) & (rds_ring->num_desc-1));
1564
1565                 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1566                         /*
1567                          * Write a doorbell msg to tell phanmon of change in
1568                          * receive ring producer
1569                          * Only for firmware version < 4.0.0
1570                          */
1571                         netxen_set_msg_peg_id(msg, NETXEN_RCV_PEG_DB_ID);
1572                         netxen_set_msg_privid(msg);
1573                         netxen_set_msg_count(msg,
1574                                              ((producer - 1) &
1575                                               (rds_ring->num_desc - 1)));
1576                         netxen_set_msg_ctxid(msg, adapter->portnum);
1577                         netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
1578                         writel(msg,
1579                                DB_NORMALIZE(adapter,
1580                                             NETXEN_RCV_PRODUCER_OFFSET));
1581                 }
1582         }
1583 }
1584
1585 static void
1586 netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
1587                 struct nx_host_rds_ring *rds_ring)
1588 {
1589         struct rcv_desc *pdesc;
1590         struct netxen_rx_buffer *buffer;
1591         int producer, count = 0;
1592         struct list_head *head;
1593
1594         producer = rds_ring->producer;
1595         if (!spin_trylock(&rds_ring->lock))
1596                 return;
1597
1598         head = &rds_ring->free_list;
1599         while (!list_empty(head)) {
1600
1601                 buffer = list_entry(head->next, struct netxen_rx_buffer, list);
1602
1603                 if (!buffer->skb) {
1604                         if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
1605                                 break;
1606                 }
1607
1608                 count++;
1609                 list_del(&buffer->list);
1610
1611                 /* make a rcv descriptor  */
1612                 pdesc = &rds_ring->desc_head[producer];
1613                 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
1614                 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1615                 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1616
1617                 producer = get_next_index(producer, rds_ring->num_desc);
1618         }
1619
1620         if (count) {
1621                 rds_ring->producer = producer;
1622                 NXWR32(adapter, rds_ring->crb_rcv_producer,
1623                                 (producer - 1) & (rds_ring->num_desc - 1));
1624         }
1625         spin_unlock(&rds_ring->lock);
1626 }
1627
1628 void netxen_nic_clear_stats(struct netxen_adapter *adapter)
1629 {
1630         memset(&adapter->stats, 0, sizeof(adapter->stats));
1631         return;
1632 }
1633