drivers/net/netxen/netxen_nic_init.c

   1 /*
   2  * Copyright (C) 2003 - 2006 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,
  26  * 3965 Freedom Circle, Fourth floor,
  27  * Santa Clara, CA 95054
  28  *
  29  *
  30  * Source file for NIC routines to initialize the Phantom Hardware
  31  *
  32  */
  33
  34 #include <linux/netdevice.h>
  35 #include <linux/delay.h>
  36 #include "netxen_nic.h"
  37 #include "netxen_nic_hw.h"
  38 #include "netxen_nic_ioctl.h"
  39 #include "netxen_nic_phan_reg.h"
  40
  41 struct crb_addr_pair {
  42         long addr;
  43         long data;
  44 };
  45
  46 #define NETXEN_MAX_CRB_XFORM 60
  47 static unsigned int crb_addr_xform[NETXEN_MAX_CRB_XFORM];
  48 #define NETXEN_ADDR_ERROR ((unsigned long ) 0xffffffff )
  49
  50 #define crb_addr_transform(name) \
  51         crb_addr_xform[NETXEN_HW_PX_MAP_CRB_##name] = \
  52         NETXEN_HW_CRB_HUB_AGT_ADR_##name << 20
  53
  54 #define NETXEN_NIC_XDMA_RESET 0x8000ff
  55
  56 static inline void
  57 netxen_nic_locked_write_reg(struct netxen_adapter *adapter,
  58                             unsigned long off, int *data)
  59 {
  60         void __iomem *addr = pci_base_offset(adapter, off);
  61         writel(*data, addr);
  62 }
  63
  64 static void crb_addr_transform_setup(void)
  65 {
  66         crb_addr_transform(XDMA);
  67         crb_addr_transform(TIMR);
  68         crb_addr_transform(SRE);
  69         crb_addr_transform(SQN3);
  70         crb_addr_transform(SQN2);
  71         crb_addr_transform(SQN1);
  72         crb_addr_transform(SQN0);
  73         crb_addr_transform(SQS3);
  74         crb_addr_transform(SQS2);
  75         crb_addr_transform(SQS1);
  76         crb_addr_transform(SQS0);
  77         crb_addr_transform(RPMX7);
  78         crb_addr_transform(RPMX6);
  79         crb_addr_transform(RPMX5);
  80         crb_addr_transform(RPMX4);
  81         crb_addr_transform(RPMX3);
  82         crb_addr_transform(RPMX2);
  83         crb_addr_transform(RPMX1);
  84         crb_addr_transform(RPMX0);
  85         crb_addr_transform(ROMUSB);
  86         crb_addr_transform(SN);
  87         crb_addr_transform(QMN);
  88         crb_addr_transform(QMS);
  89         crb_addr_transform(PGNI);
  90         crb_addr_transform(PGND);
  91         crb_addr_transform(PGN3);
  92         crb_addr_transform(PGN2);
  93         crb_addr_transform(PGN1);
  94         crb_addr_transform(PGN0);
  95         crb_addr_transform(PGSI);
  96         crb_addr_transform(PGSD);
  97         crb_addr_transform(PGS3);
  98         crb_addr_transform(PGS2);
  99         crb_addr_transform(PGS1);
 100         crb_addr_transform(PGS0);
 101         crb_addr_transform(PS);
 102         crb_addr_transform(PH);
 103         crb_addr_transform(NIU);
 104         crb_addr_transform(I2Q);
 105         crb_addr_transform(EG);
 106         crb_addr_transform(MN);
 107         crb_addr_transform(MS);
 108         crb_addr_transform(CAS2);
 109         crb_addr_transform(CAS1);
 110         crb_addr_transform(CAS0);
 111         crb_addr_transform(CAM);
 112         crb_addr_transform(C2C1);
 113         crb_addr_transform(C2C0);
 114 }
 115
 116 int netxen_init_firmware(struct netxen_adapter *adapter)
 117 {
 118         u32 state = 0, loops = 0, err = 0;
 119
 120         /* Window 1 call */
 121         state = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
 122
 123         if (state == PHAN_INITIALIZE_ACK)
 124                 return 0;
 125
 126         while (state != PHAN_INITIALIZE_COMPLETE && loops < 2000) {
 127                 udelay(100);
 128                 /* Window 1 call */
 129                 state = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
 130
 131                 loops++;
 132         }
 133         if (loops >= 2000) {
 134                 printk(KERN_ERR "Cmd Peg initialization not complete:%x.\n",
 135                        state);
 136                 err = -EIO;
 137                 return err;
 138         }
 139         /* Window 1 call */
 140         writel(MPORT_SINGLE_FUNCTION_MODE,
 141                NETXEN_CRB_NORMALIZE(adapter, CRB_MPORT_MODE));
 142         writel(PHAN_INITIALIZE_ACK,
 143                NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
 144
 145         return err;
 146 }
 147
 148 #define NETXEN_ADDR_LIMIT 0xffffffffULL
 149
 150 void *netxen_alloc(struct pci_dev *pdev, size_t sz, dma_addr_t * ptr,
 151                    struct pci_dev **used_dev)
 152 {
 153         void *addr;
 154
 155         addr = pci_alloc_consistent(pdev, sz, ptr);
 156         if ((unsigned long long)(*ptr) < NETXEN_ADDR_LIMIT) {
 157                 *used_dev = pdev;
 158                 return addr;
 159         }
 160         pci_free_consistent(pdev, sz, addr, *ptr);
 161         addr = pci_alloc_consistent(NULL, sz, ptr);
 162         *used_dev = NULL;
 163         return addr;
 164 }
 165
 166 void netxen_initialize_adapter_sw(struct netxen_adapter *adapter)
 167 {
 168         int ctxid, ring;
 169         u32 i;
 170         u32 num_rx_bufs = 0;
 171         struct netxen_rcv_desc_ctx *rcv_desc;
 172
 173         DPRINTK(INFO, "initializing some queues: %p\n", adapter);
 174         for (ctxid = 0; ctxid < MAX_RCV_CTX; ++ctxid) {
 175                 for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
 176                         struct netxen_rx_buffer *rx_buf;
 177                         rcv_desc = &adapter->recv_ctx[ctxid].rcv_desc[ring];
 178                         rcv_desc->rcv_free = rcv_desc->max_rx_desc_count;
 179                         rcv_desc->begin_alloc = 0;
 180                         rx_buf = rcv_desc->rx_buf_arr;
 181                         num_rx_bufs = rcv_desc->max_rx_desc_count;
 182                         /*
 183                          * Now go through all of them, set reference handles
 184                          * and put them in the queues.
 185                          */
 186                         for (i = 0; i < num_rx_bufs; i++) {
 187                                 rx_buf->ref_handle = i;
 188                                 rx_buf->state = NETXEN_BUFFER_FREE;
 189                                 DPRINTK(INFO, "Rx buf:ctx%d i(%d) rx_buf:"
 190                                         "%p\n", ctxid, i, rx_buf);
 191                                 rx_buf++;
 192                         }
 193                 }
 194         }
 195 }
 196
 197 void netxen_initialize_adapter_hw(struct netxen_adapter *adapter)
 198 {
 199         int ports = 0;
 200         struct netxen_board_info *board_info = &(adapter->ahw.boardcfg);
 201
 202         if (netxen_nic_get_board_info(adapter) != 0)
 203                 printk("%s: Error getting board config info.\n",
 204                        netxen_nic_driver_name);
 205         get_brd_port_by_type(board_info->board_type, &ports);
 206         if (ports == 0)
 207                 printk(KERN_ERR "%s: Unknown board type\n",
 208                        netxen_nic_driver_name);
 209         adapter->ahw.max_ports = ports;
 210 }
 211
 212 void netxen_initialize_adapter_ops(struct netxen_adapter *adapter)
 213 {
 214         switch (adapter->ahw.board_type) {
 215         case NETXEN_NIC_GBE:
 216                 adapter->enable_phy_interrupts =
 217                     netxen_niu_gbe_enable_phy_interrupts;
 218                 adapter->disable_phy_interrupts =
 219                     netxen_niu_gbe_disable_phy_interrupts;
 220                 adapter->handle_phy_intr = netxen_nic_gbe_handle_phy_intr;
 221                 adapter->macaddr_set = netxen_niu_macaddr_set;
 222                 adapter->set_mtu = netxen_nic_set_mtu_gb;
 223                 adapter->set_promisc = netxen_niu_set_promiscuous_mode;
 224                 adapter->unset_promisc = netxen_niu_set_promiscuous_mode;
 225                 adapter->phy_read = netxen_niu_gbe_phy_read;
 226                 adapter->phy_write = netxen_niu_gbe_phy_write;
 227                 adapter->init_port = netxen_niu_gbe_init_port;
 228                 adapter->init_niu = netxen_nic_init_niu_gb;
 229                 adapter->stop_port = netxen_niu_disable_gbe_port;
 230                 break;
 231
 232         case NETXEN_NIC_XGBE:
 233                 adapter->enable_phy_interrupts =
 234                     netxen_niu_xgbe_enable_phy_interrupts;
 235                 adapter->disable_phy_interrupts =
 236                     netxen_niu_xgbe_disable_phy_interrupts;
 237                 adapter->handle_phy_intr = netxen_nic_xgbe_handle_phy_intr;
 238                 adapter->macaddr_set = netxen_niu_xg_macaddr_set;
 239                 adapter->set_mtu = netxen_nic_set_mtu_xgb;
 240                 adapter->init_port = netxen_niu_xg_init_port;
 241                 adapter->set_promisc = netxen_niu_xg_set_promiscuous_mode;
 242                 adapter->unset_promisc = netxen_niu_xg_set_promiscuous_mode;
 243                 adapter->stop_port = netxen_niu_disable_xg_port;
 244                 break;
 245
 246         default:
 247                 break;
 248         }
 249 }
 250
 251 /*
 252  * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
 253  * address to external PCI CRB address.
 254  */
 255 unsigned long netxen_decode_crb_addr(unsigned long addr)
 256 {
 257         int i;
 258         unsigned long base_addr, offset, pci_base;
 259
 260         crb_addr_transform_setup();
 261
 262         pci_base = NETXEN_ADDR_ERROR;
 263         base_addr = addr & 0xfff00000;
 264         offset = addr & 0x000fffff;
 265
 266         for (i = 0; i < NETXEN_MAX_CRB_XFORM; i++) {
 267                 if (crb_addr_xform[i] == base_addr) {
 268                         pci_base = i << 20;
 269                         break;
 270                 }
 271         }
 272         if (pci_base == NETXEN_ADDR_ERROR)
 273                 return pci_base;
 274         else
 275                 return (pci_base + offset);
 276 }
 277
 278 static long rom_max_timeout = 10000;
 279 static long rom_lock_timeout = 1000000;
 280
 281 static inline int rom_lock(struct netxen_adapter *adapter)
 282 {
 283         int iter;
 284         u32 done = 0;
 285         int timeout = 0;
 286
 287         while (!done) {
 288                 /* acquire semaphore2 from PCI HW block */
 289                 netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(PCIE_SEM2_LOCK),
 290                                    &done);
 291                 if (done == 1)
 292                         break;
 293                 if (timeout >= rom_lock_timeout)
 294                         return -EIO;
 295
 296                 timeout++;
 297                 /*
 298                  * Yield CPU
 299                  */
 300                 if (!in_atomic())
 301                         schedule();
 302                 else {
 303                         for (iter = 0; iter < 20; iter++)
 304                                 cpu_relax();    /*This a nop instr on i386 */
 305                 }
 306         }
 307         netxen_nic_reg_write(adapter, NETXEN_ROM_LOCK_ID, ROM_LOCK_DRIVER);
 308         return 0;
 309 }
 310
 311 int netxen_wait_rom_done(struct netxen_adapter *adapter)
 312 {
 313         long timeout = 0;
 314         long done = 0;
 315
 316         while (done == 0) {
 317                 done = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_GLB_STATUS);
 318                 done &= 2;
 319                 timeout++;
 320                 if (timeout >= rom_max_timeout) {
 321                         printk("Timeout reached  waiting for rom done");
 322                         return -EIO;
 323                 }
 324         }
 325         return 0;
 326 }
 327
 328 static inline int netxen_rom_wren(struct netxen_adapter *adapter)
 329 {
 330         /* Set write enable latch in ROM status register */
 331         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
 332         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
 333                              M25P_INSTR_WREN);
 334         if (netxen_wait_rom_done(adapter)) {
 335                 return -1;
 336         }
 337         return 0;
 338 }
 339
 340 static inline unsigned int netxen_rdcrbreg(struct netxen_adapter *adapter,
 341                                            unsigned int addr)
 342 {
 343         unsigned int data = 0xdeaddead;
 344         data = netxen_nic_reg_read(adapter, addr);
 345         return data;
 346 }
 347
 348 static inline int netxen_do_rom_rdsr(struct netxen_adapter *adapter)
 349 {
 350         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
 351                              M25P_INSTR_RDSR);
 352         if (netxen_wait_rom_done(adapter)) {
 353                 return -1;
 354         }
 355         return netxen_rdcrbreg(adapter, NETXEN_ROMUSB_ROM_RDATA);
 356 }
 357
 358 static inline void netxen_rom_unlock(struct netxen_adapter *adapter)
 359 {
 360         u32 val;
 361
 362         /* release semaphore2 */
 363         netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK), &val);
 364
 365 }
 366
 367 int netxen_rom_wip_poll(struct netxen_adapter *adapter)
 368 {
 369         long timeout = 0;
 370         long wip = 1;
 371         int val;
 372         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
 373         while (wip != 0) {
 374                 val = netxen_do_rom_rdsr(adapter);
 375                 wip = val & 1;
 376                 timeout++;
 377                 if (timeout > rom_max_timeout) {
 378                         return -1;
 379                 }
 380         }
 381         return 0;
 382 }
 383
 384 static inline int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
 385                                     int data)
 386 {
 387         if (netxen_rom_wren(adapter)) {
 388                 return -1;
 389         }
 390         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_WDATA, data);
 391         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
 392         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
 393         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
 394                              M25P_INSTR_PP);
 395         if (netxen_wait_rom_done(adapter)) {
 396                 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
 397                 return -1;
 398         }
 399
 400         return netxen_rom_wip_poll(adapter);
 401 }
 402
 403 static inline int
 404 do_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
 405 {
 406         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
 407         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
 408         udelay(100);            /* prevent bursting on CRB */
 409         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
 410         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
 411         if (netxen_wait_rom_done(adapter)) {
 412                 printk("Error waiting for rom done\n");
 413                 return -EIO;
 414         }
 415         /* reset abyte_cnt and dummy_byte_cnt */
 416         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
 417         udelay(100);            /* prevent bursting on CRB */
 418         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
 419
 420         *valp = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_ROM_RDATA);
 421         return 0;
 422 }
 423
 424 int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
 425 {
 426         int ret;
 427
 428         if (rom_lock(adapter) != 0)
 429                 return -EIO;
 430
 431         ret = do_rom_fast_read(adapter, addr, valp);
 432         netxen_rom_unlock(adapter);
 433         return ret;
 434 }
 435
 436 int netxen_rom_fast_write(struct netxen_adapter *adapter, int addr, int data)
 437 {
 438         int ret = 0;
 439
 440         if (rom_lock(adapter) != 0) {
 441                 return -1;
 442         }
 443         ret = do_rom_fast_write(adapter, addr, data);
 444         netxen_rom_unlock(adapter);
 445         return ret;
 446 }
 447 int netxen_do_rom_se(struct netxen_adapter *adapter, int addr)
 448 {
 449         netxen_rom_wren(adapter);
 450         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
 451         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
 452         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
 453                              M25P_INSTR_SE);
 454         if (netxen_wait_rom_done(adapter)) {
 455                 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
 456                 return -1;
 457         }
 458         return netxen_rom_wip_poll(adapter);
 459 }
 460
 461 int netxen_rom_se(struct netxen_adapter *adapter, int addr)
 462 {
 463         int ret = 0;
 464         if (rom_lock(adapter) != 0) {
 465                 return -1;
 466         }
 467         ret = netxen_do_rom_se(adapter, addr);
 468         netxen_rom_unlock(adapter);
 469         return ret;
 470 }
 471
 472 #define NETXEN_BOARDTYPE                0x4008
 473 #define NETXEN_BOARDNUM                 0x400c
 474 #define NETXEN_CHIPNUM                  0x4010
 475 #define NETXEN_ROMBUS_RESET             0xFFFFFFFF
 476 #define NETXEN_ROM_FIRST_BARRIER        0x800000000ULL
 477 #define NETXEN_ROM_FOUND_INIT           0x400
 478
 479 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 480 {
 481         int addr, val, status;
 482         int n, i;
 483         int init_delay = 0;
 484         struct crb_addr_pair *buf;
 485         unsigned long off;
 486
 487         /* resetall */
 488         status = netxen_nic_get_board_info(adapter);
 489         if (status)
 490                 printk("%s: netxen_pinit_from_rom: Error getting board info\n",
 491                        netxen_nic_driver_name);
 492
 493         netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_GLB_SW_RESET,
 494                                     NETXEN_ROMBUS_RESET);
 495
 496         if (verbose) {
 497                 int val;
 498                 if (netxen_rom_fast_read(adapter, NETXEN_BOARDTYPE, &val) == 0)
 499                         printk("P2 ROM board type: 0x%08x\n", val);
 500                 else
 501                         printk("Could not read board type\n");
 502                 if (netxen_rom_fast_read(adapter, NETXEN_BOARDNUM, &val) == 0)
 503                         printk("P2 ROM board  num: 0x%08x\n", val);
 504                 else
 505                         printk("Could not read board number\n");
 506                 if (netxen_rom_fast_read(adapter, NETXEN_CHIPNUM, &val) == 0)
 507                         printk("P2 ROM chip   num: 0x%08x\n", val);
 508                 else
 509                         printk("Could not read chip number\n");
 510         }
 511
 512         if (netxen_rom_fast_read(adapter, 0, &n) == 0
 513             && (n & NETXEN_ROM_FIRST_BARRIER)) {
 514                 n &= ~NETXEN_ROM_ROUNDUP;
 515                 if (n < NETXEN_ROM_FOUND_INIT) {
 516                         if (verbose)
 517                                 printk("%s: %d CRB init values found"
 518                                        " in ROM.\n", netxen_nic_driver_name, n);
 519                 } else {
 520                         printk("%s:n=0x%x Error! NetXen card flash not"
 521                                " initialized.\n", __FUNCTION__, n);
 522                         return -EIO;
 523                 }
 524                 buf = kcalloc(n, sizeof(struct crb_addr_pair), GFP_KERNEL);
 525                 if (buf == NULL) {
 526                         printk("%s: netxen_pinit_from_rom: Unable to calloc "
 527                                "memory.\n", netxen_nic_driver_name);
 528                         return -ENOMEM;
 529                 }
 530                 for (i = 0; i < n; i++) {
 531                         if (netxen_rom_fast_read(adapter, 8 * i + 4, &val) != 0
 532                             || netxen_rom_fast_read(adapter, 8 * i + 8,
 533                                                     &addr) != 0)
 534                                 return -EIO;
 535
 536                         buf[i].addr = addr;
 537                         buf[i].data = val;
 538
 539                         if (verbose)
 540                                 printk("%s: PCI:     0x%08x == 0x%08x\n",
 541                                        netxen_nic_driver_name, (unsigned int)
 542                                        netxen_decode_crb_addr((unsigned long)
 543                                                               addr), val);
 544                 }
 545                 for (i = 0; i < n; i++) {
 546
 547                         off =
 548                             netxen_decode_crb_addr((unsigned long)buf[i].addr) +
 549                             NETXEN_PCI_CRBSPACE;
 550                         /* skipping cold reboot MAGIC */
 551                         if (off == NETXEN_CAM_RAM(0x1fc))
 552                                 continue;
 553
 554                         /* After writing this register, HW needs time for CRB */
 555                         /* to quiet down (else crb_window returns 0xffffffff) */
 556                         if (off == NETXEN_ROMUSB_GLB_SW_RESET) {
 557                                 init_delay = 1;
 558                                 /* hold xdma in reset also */
 559                                 buf[i].data = NETXEN_NIC_XDMA_RESET;
 560                         }
 561
 562                         if (ADDR_IN_WINDOW1(off)) {
 563                                 writel(buf[i].data,
 564                                        NETXEN_CRB_NORMALIZE(adapter, off));
 565                         } else {
 566                                 netxen_nic_pci_change_crbwindow(adapter, 0);
 567                                 writel(buf[i].data,
 568                                        pci_base_offset(adapter, off));
 569
 570                                 netxen_nic_pci_change_crbwindow(adapter, 1);
 571                         }
 572                         if (init_delay == 1) {
 573                                 ssleep(1);
 574                                 init_delay = 0;
 575                         }
 576                         msleep(1);
 577                 }
 578                 kfree(buf);
 579
 580                 /* disable_peg_cache_all */
 581
 582                 /* unreset_net_cache */
 583                 netxen_nic_hw_read_wx(adapter, NETXEN_ROMUSB_GLB_SW_RESET, &val,
 584                                       4);
 585                 netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_GLB_SW_RESET,
 586                                             (val & 0xffffff0f));
 587                 /* p2dn replyCount */
 588                 netxen_crb_writelit_adapter(adapter,
 589                                             NETXEN_CRB_PEG_NET_D + 0xec, 0x1e);
 590                 /* disable_peg_cache 0 */
 591                 netxen_crb_writelit_adapter(adapter,
 592                                             NETXEN_CRB_PEG_NET_D + 0x4c, 8);
 593                 /* disable_peg_cache 1 */
 594                 netxen_crb_writelit_adapter(adapter,
 595                                             NETXEN_CRB_PEG_NET_I + 0x4c, 8);
 596
 597                 /* peg_clr_all */
 598
 599                 /* peg_clr 0 */
 600                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_0 + 0x8,
 601                                             0);
 602                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_0 + 0xc,
 603                                             0);
 604                 /* peg_clr 1 */
 605                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_1 + 0x8,
 606                                             0);
 607                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_1 + 0xc,
 608                                             0);
 609                 /* peg_clr 2 */
 610                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_2 + 0x8,
 611                                             0);
 612                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_2 + 0xc,
 613                                             0);
 614                 /* peg_clr 3 */
 615                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_3 + 0x8,
 616                                             0);
 617                 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_3 + 0xc,
 618                                             0);
 619         }
 620         return 0;
 621 }
 622
 623 int netxen_initialize_adapter_offload(struct netxen_adapter *adapter)
 624 {
 625         uint64_t addr;
 626         uint32_t hi;
 627         uint32_t lo;
 628
 629         adapter->dummy_dma.addr =
 630             pci_alloc_consistent(adapter->ahw.pdev,
 631                                  NETXEN_HOST_DUMMY_DMA_SIZE,
 632                                  &adapter->dummy_dma.phys_addr);
 633         if (adapter->dummy_dma.addr == NULL) {
 634                 printk("%s: ERROR: Could not allocate dummy DMA memory\n",
 635                        __FUNCTION__);
 636                 return -ENOMEM;
 637         }
 638
 639         addr = (uint64_t) adapter->dummy_dma.phys_addr;
 640         hi = (addr >> 32) & 0xffffffff;
 641         lo = addr & 0xffffffff;
 642
 643         writel(hi, NETXEN_CRB_NORMALIZE(adapter, CRB_HOST_DUMMY_BUF_ADDR_HI));
 644         writel(lo, NETXEN_CRB_NORMALIZE(adapter, CRB_HOST_DUMMY_BUF_ADDR_LO));
 645
 646         return 0;
 647 }
 648
 649 void netxen_free_adapter_offload(struct netxen_adapter *adapter)
 650 {
 651         if (adapter->dummy_dma.addr) {
 652                 pci_free_consistent(adapter->ahw.pdev,
 653                                     NETXEN_HOST_DUMMY_DMA_SIZE,
 654                                     adapter->dummy_dma.addr,
 655                                     adapter->dummy_dma.phys_addr);
 656                 adapter->dummy_dma.addr = NULL;
 657         }
 658 }
 659
 660 void netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
 661 {
 662         u32 val = 0;
 663         int loops = 0;
 664
 665         if (!pegtune_val) {
 666                 while (val != PHAN_INITIALIZE_COMPLETE && loops < 200000) {
 667                         udelay(100);
 668                         schedule();
 669                         val =
 670                             readl(NETXEN_CRB_NORMALIZE
 671                                   (adapter, CRB_CMDPEG_STATE));
 672                         loops++;
 673                 }
 674                 if (val != PHAN_INITIALIZE_COMPLETE)
 675                         printk("WARNING: Initial boot wait loop failed...\n");
 676         }
 677 }
 678
 679 int netxen_nic_rx_has_work(struct netxen_adapter *adapter)
 680 {
 681         int ctx;
 682
 683         for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
 684                 struct netxen_recv_context *recv_ctx =
 685                     &(adapter->recv_ctx[ctx]);
 686                 u32 consumer;
 687                 struct status_desc *desc_head;
 688                 struct status_desc *desc;
 689
 690                 consumer = recv_ctx->status_rx_consumer;
 691                 desc_head = recv_ctx->rcv_status_desc_head;
 692                 desc = &desc_head[consumer];
 693
 694                 if (((le16_to_cpu(netxen_get_sts_owner(desc)))
 695                      & STATUS_OWNER_HOST))
 696                         return 1;
 697         }
 698
 699         return 0;
 700 }
 701
 702 static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
 703 {
 704         int port_num;
 705         struct netxen_port *port;
 706         struct net_device *netdev;
 707         uint32_t temp, temp_state, temp_val;
 708         int rv = 0;
 709
 710         temp = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_TEMP_STATE));
 711
 712         temp_state = nx_get_temp_state(temp);
 713         temp_val = nx_get_temp_val(temp);
 714
 715         if (temp_state == NX_TEMP_PANIC) {
 716                 printk(KERN_ALERT
 717                        "%s: Device temperature %d degrees C exceeds"
 718                        " maximum allowed. Hardware has been shut down.\n",
 719                        netxen_nic_driver_name, temp_val);
 720                 for (port_num = 0; port_num < adapter->ahw.max_ports;
 721                      port_num++) {
 722                         port = adapter->port[port_num];
 723                         netdev = port->netdev;
 724
 725                         netif_carrier_off(netdev);
 726                         netif_stop_queue(netdev);
 727                 }
 728                 rv = 1;
 729         } else if (temp_state == NX_TEMP_WARN) {
 730                 if (adapter->temp == NX_TEMP_NORMAL) {
 731                         printk(KERN_ALERT
 732                                "%s: Device temperature %d degrees C "
 733                                "exceeds operating range."
 734                                " Immediate action needed.\n",
 735                                netxen_nic_driver_name, temp_val);
 736                 }
 737         } else {
 738                 if (adapter->temp == NX_TEMP_WARN) {
 739                         printk(KERN_INFO
 740                                "%s: Device temperature is now %d degrees C"
 741                                " in normal range.\n", netxen_nic_driver_name,
 742                                temp_val);
 743                 }
 744         }
 745         adapter->temp = temp_state;
 746         return rv;
 747 }
 748
 749 void netxen_watchdog_task(struct work_struct *work)
 750 {
 751         int port_num;
 752         struct netxen_port *port;
 753         struct net_device *netdev;
 754         struct netxen_adapter *adapter =
 755                 container_of(work, struct netxen_adapter, watchdog_task);
 756
 757         if (netxen_nic_check_temp(adapter))
 758                 return;
 759
 760         for (port_num = 0; port_num < adapter->ahw.max_ports; port_num++) {
 761                 port = adapter->port[port_num];
 762                 netdev = port->netdev;
 763
 764                 if ((netif_running(netdev)) && !netif_carrier_ok(netdev)) {
 765                         printk(KERN_INFO "%s port %d, %s carrier is now ok\n",
 766                                netxen_nic_driver_name, port_num, netdev->name);
 767                         netif_carrier_on(netdev);
 768                 }
 769
 770                 if (netif_queue_stopped(netdev))
 771                         netif_wake_queue(netdev);
 772         }
 773
 774         if (adapter->handle_phy_intr)
 775                 adapter->handle_phy_intr(adapter);
 776         mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
 777 }
 778
 779 /*
 780  * netxen_process_rcv() send the received packet to the protocol stack.
 781  * and if the number of receives exceeds RX_BUFFERS_REFILL, then we
 782  * invoke the routine to send more rx buffers to the Phantom...
 783  */
 784 void
 785 netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
 786                    struct status_desc *desc)
 787 {
 788         struct netxen_port *port = adapter->port[netxen_get_sts_port(desc)];
 789         struct pci_dev *pdev = port->pdev;
 790         struct net_device *netdev = port->netdev;
 791         int index = le16_to_cpu(netxen_get_sts_refhandle(desc));
 792         struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctxid]);
 793         struct netxen_rx_buffer *buffer;
 794         struct sk_buff *skb;
 795         u32 length = le16_to_cpu(netxen_get_sts_totallength(desc));
 796         u32 desc_ctx;
 797         struct netxen_rcv_desc_ctx *rcv_desc;
 798         int ret;
 799
 800         desc_ctx = netxen_get_sts_type(desc);
 801         if (unlikely(desc_ctx >= NUM_RCV_DESC_RINGS)) {
 802                 printk("%s: %s Bad Rcv descriptor ring\n",
 803                        netxen_nic_driver_name, netdev->name);
 804                 return;
 805         }
 806
 807         rcv_desc = &recv_ctx->rcv_desc[desc_ctx];
 808         if (unlikely(index > rcv_desc->max_rx_desc_count)) {
 809                 DPRINTK(ERR, "Got a buffer index:%x Max is %x\n",
 810                         index, rcv_desc->max_rx_desc_count);
 811                 return;
 812         }
 813         buffer = &rcv_desc->rx_buf_arr[index];
 814         if (desc_ctx == RCV_DESC_LRO_CTXID) {
 815                 buffer->lro_current_frags++;
 816                 if (netxen_get_sts_desc_lro_last_frag(desc)) {
 817                         buffer->lro_expected_frags =
 818                             netxen_get_sts_desc_lro_cnt(desc);
 819                         buffer->lro_length = length;
 820                 }
 821                 if (buffer->lro_current_frags != buffer->lro_expected_frags) {
 822                         if (buffer->lro_expected_frags != 0) {
 823                                 printk("LRO: (refhandle:%x) recv frag."
 824                                        "wait for last. flags: %x expected:%d"
 825                                        "have:%d\n", index,
 826                                        netxen_get_sts_desc_lro_last_frag(desc),
 827                                        buffer->lro_expected_frags,
 828                                        buffer->lro_current_frags);
 829                         }
 830                         return;
 831                 }
 832         }
 833
 834         pci_unmap_single(pdev, buffer->dma, rcv_desc->dma_size,
 835                          PCI_DMA_FROMDEVICE);
 836
 837         skb = (struct sk_buff *)buffer->skb;
 838
 839         if (likely(netxen_get_sts_status(desc) == STATUS_CKSUM_OK)) {
 840                 port->stats.csummed++;
 841                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 842         }
 843         skb->dev = netdev;
 844         if (desc_ctx == RCV_DESC_LRO_CTXID) {
 845                 /* True length was only available on the last pkt */
 846                 skb_put(skb, buffer->lro_length);
 847         } else {
 848                 skb_put(skb, length);
 849         }
 850
 851         skb->protocol = eth_type_trans(skb, netdev);
 852
 853         ret = netif_receive_skb(skb);
 854
 855         /*
 856          * RH: Do we need these stats on a regular basis. Can we get it from
 857          * Linux stats.
 858          */
 859         switch (ret) {
 860         case NET_RX_SUCCESS:
 861                 port->stats.uphappy++;
 862                 break;
 863
 864         case NET_RX_CN_LOW:
 865                 port->stats.uplcong++;
 866                 break;
 867
 868         case NET_RX_CN_MOD:
 869                 port->stats.upmcong++;
 870                 break;
 871
 872         case NET_RX_CN_HIGH:
 873                 port->stats.uphcong++;
 874                 break;
 875
 876         case NET_RX_DROP:
 877                 port->stats.updropped++;
 878                 break;
 879
 880         default:
 881                 port->stats.updunno++;
 882                 break;
 883         }
 884
 885         netdev->last_rx = jiffies;
 886
 887         rcv_desc->rcv_free++;
 888         rcv_desc->rcv_pending--;
 889
 890         /*
 891          * We just consumed one buffer so post a buffer.
 892          */
 893         adapter->stats.post_called++;
 894         buffer->skb = NULL;
 895         buffer->state = NETXEN_BUFFER_FREE;
 896         buffer->lro_current_frags = 0;
 897         buffer->lro_expected_frags = 0;
 898
 899         port->stats.no_rcv++;
 900         port->stats.rxbytes += length;
 901 }
 902
 903 /* Process Receive status ring */
 904 u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctxid, int max)
 905 {
 906         struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctxid]);
 907         struct status_desc *desc_head = recv_ctx->rcv_status_desc_head;
 908         struct status_desc *desc;       /* used to read status desc here */
 909         u32 consumer = recv_ctx->status_rx_consumer;
 910         u32 producer = 0;
 911         int count = 0, ring;
 912
 913         DPRINTK(INFO, "procesing receive\n");
 914         /*
 915          * we assume in this case that there is only one port and that is
 916          * port #1...changes need to be done in firmware to indicate port
 917          * number as part of the descriptor. This way we will be able to get
 918          * the netdev which is associated with that device.
 919          */
 920         while (count < max) {
 921                 desc = &desc_head[consumer];
 922                 if (!
 923                     (le16_to_cpu(netxen_get_sts_owner(desc)) &
 924                      STATUS_OWNER_HOST)) {
 925                         DPRINTK(ERR, "desc %p ownedby %x\n", desc,
 926                                 netxen_get_sts_owner(desc));
 927                         break;
 928                 }
 929                 netxen_process_rcv(adapter, ctxid, desc);
 930                 netxen_clear_sts_owner(desc);
 931                 netxen_set_sts_owner(desc, STATUS_OWNER_PHANTOM);
 932                 consumer = (consumer + 1) & (adapter->max_rx_desc_count - 1);
 933                 count++;
 934         }
 935         if (count) {
 936                 for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
 937                         netxen_post_rx_buffers_nodb(adapter, ctxid, ring);
 938                 }
 939         }
 940
 941         /* update the consumer index in phantom */
 942         if (count) {
 943                 adapter->stats.process_rcv++;
 944                 recv_ctx->status_rx_consumer = consumer;
 945                 recv_ctx->status_rx_producer = producer;
 946
 947                 /* Window = 1 */
 948                 writel(consumer,
 949                        NETXEN_CRB_NORMALIZE(adapter,
 950                                             recv_crb_registers[ctxid].
 951                                             crb_rcv_status_consumer));
 952         }
 953
 954         return count;
 955 }
 956
 957 /* Process Command status ring */
 958 int netxen_process_cmd_ring(unsigned long data)
 959 {
 960         u32 last_consumer;
 961         u32 consumer;
 962         struct netxen_adapter *adapter = (struct netxen_adapter *)data;
 963         int count1 = 0;
 964         int count2 = 0;
 965         struct netxen_cmd_buffer *buffer;
 966         struct netxen_port *port;       /* port #1 */
 967         struct netxen_port *nport;
 968         struct pci_dev *pdev;
 969         struct netxen_skb_frag *frag;
 970         u32 i;
 971         struct sk_buff *skb = NULL;
 972         int p;
 973         int done;
 974
 975         spin_lock(&adapter->tx_lock);
 976         last_consumer = adapter->last_cmd_consumer;
 977         DPRINTK(INFO, "procesing xmit complete\n");
 978         /* we assume in this case that there is only one port and that is
 979          * port #1...changes need to be done in firmware to indicate port
 980          * number as part of the descriptor. This way we will be able to get
 981          * the netdev which is associated with that device.
 982          */
 983
 984         consumer = *(adapter->cmd_consumer);
 985         if (last_consumer == consumer) {        /* Ring is empty    */
 986                 DPRINTK(INFO, "last_consumer %d == consumer %d\n",
 987                         last_consumer, consumer);
 988                 spin_unlock(&adapter->tx_lock);
 989                 return 1;
 990         }
 991
 992         adapter->proc_cmd_buf_counter++;
 993         adapter->stats.process_xmit++;
 994         /*
 995          * Not needed - does not seem to be used anywhere.
 996          * adapter->cmd_consumer = consumer;
 997          */
 998         spin_unlock(&adapter->tx_lock);
 999
1000         while ((last_consumer != consumer) && (count1 < MAX_STATUS_HANDLE)) {
1001                 buffer = &adapter->cmd_buf_arr[last_consumer];
1002                 port = adapter->port[buffer->port];
1003                 pdev = port->pdev;
1004                 frag = &buffer->frag_array[0];
1005                 skb = buffer->skb;
1006                 if (skb && (cmpxchg(&buffer->skb, skb, 0) == skb)) {
1007                         pci_unmap_single(pdev, frag->dma, frag->length,
1008                                          PCI_DMA_TODEVICE);
1009                         for (i = 1; i < buffer->frag_count; i++) {
1010                                 DPRINTK(INFO, "getting fragment no %d\n", i);
1011                                 frag++; /* Get the next frag */
1012                                 pci_unmap_page(pdev, frag->dma, frag->length,
1013                                                PCI_DMA_TODEVICE);
1014                         }
1015
1016                         port->stats.skbfreed++;
1017                         dev_kfree_skb_any(skb);
1018                         skb = NULL;
1019                 } else if (adapter->proc_cmd_buf_counter == 1) {
1020                         port->stats.txnullskb++;
1021                 }
1022                 if (unlikely(netif_queue_stopped(port->netdev)
1023                              && netif_carrier_ok(port->netdev))
1024                     && ((jiffies - port->netdev->trans_start) >
1025                         port->netdev->watchdog_timeo)) {
1026                         SCHEDULE_WORK(port->adapter->tx_timeout_task
1027                                       + port->portnum);
1028                 }
1029
1030                 last_consumer = get_next_index(last_consumer,
1031                                                adapter->max_tx_desc_count);
1032                 count1++;
1033         }
1034         adapter->stats.noxmitdone += count1;
1035
1036         count2 = 0;
1037         spin_lock(&adapter->tx_lock);
1038         if ((--adapter->proc_cmd_buf_counter) == 0) {
1039                 adapter->last_cmd_consumer = last_consumer;
1040                 while ((adapter->last_cmd_consumer != consumer)
1041                        && (count2 < MAX_STATUS_HANDLE)) {
1042                         buffer =
1043                             &adapter->cmd_buf_arr[adapter->last_cmd_consumer];
1044                         count2++;
1045                         if (buffer->skb)
1046                                 break;
1047                         else
1048                                 adapter->last_cmd_consumer =
1049                                     get_next_index(adapter->last_cmd_consumer,
1050                                                    adapter->max_tx_desc_count);
1051                 }
1052         }
1053         if (count1 || count2) {
1054                 for (p = 0; p < adapter->ahw.max_ports; p++) {
1055                         nport = adapter->port[p];
1056                         if (netif_queue_stopped(nport->netdev)
1057                             && (nport->flags & NETXEN_NETDEV_STATUS)) {
1058                                 netif_wake_queue(nport->netdev);
1059                                 nport->flags &= ~NETXEN_NETDEV_STATUS;
1060                         }
1061                 }
1062         }
1063         /*
1064          * If everything is freed up to consumer then check if the ring is full
1065          * If the ring is full then check if more needs to be freed and
1066          * schedule the call back again.
1067          *
1068          * This happens when there are 2 CPUs. One could be freeing and the
1069          * other filling it. If the ring is full when we get out of here and
1070          * the card has already interrupted the host then the host can miss the
1071          * interrupt.
1072          *
1073          * There is still a possible race condition and the host could miss an
1074          * interrupt. The card has to take care of this.
1075          */
1076         if (adapter->last_cmd_consumer == consumer &&
1077             (((adapter->cmd_producer + 1) %
1078               adapter->max_tx_desc_count) == adapter->last_cmd_consumer)) {
1079                 consumer = *(adapter->cmd_consumer);
1080         }
1081         done = (adapter->last_cmd_consumer == consumer);
1082
1083         spin_unlock(&adapter->tx_lock);
1084         DPRINTK(INFO, "last consumer is %d in %s\n", last_consumer,
1085                 __FUNCTION__);
1086         return (done);
1087 }
1088
1089 /*
1090  * netxen_post_rx_buffers puts buffer in the Phantom memory
1091  */
1092 void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
1093 {
1094         struct pci_dev *pdev = adapter->ahw.pdev;
1095         struct sk_buff *skb;
1096         struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctx]);
1097         struct netxen_rcv_desc_ctx *rcv_desc = NULL;
1098         uint producer;
1099         struct rcv_desc *pdesc;
1100         struct netxen_rx_buffer *buffer;
1101         int count = 0;
1102         int index = 0;
1103         netxen_ctx_msg msg = 0;
1104         dma_addr_t dma;
1105
1106         adapter->stats.post_called++;
1107         rcv_desc = &recv_ctx->rcv_desc[ringid];
1108
1109         producer = rcv_desc->producer;
1110         index = rcv_desc->begin_alloc;
1111         buffer = &rcv_desc->rx_buf_arr[index];
1112         /* We can start writing rx descriptors into the phantom memory. */
1113         while (buffer->state == NETXEN_BUFFER_FREE) {
1114                 skb = dev_alloc_skb(rcv_desc->skb_size);
1115                 if (unlikely(!skb)) {
1116                         /*
1117                          * TODO
1118                          * We need to schedule the posting of buffers to the pegs.
1119                          */
1120                         rcv_desc->begin_alloc = index;
1121                         DPRINTK(ERR, "netxen_post_rx_buffers: "
1122                                 " allocated only %d buffers\n", count);
1123                         break;
1124                 }
1125
1126                 count++;        /* now there should be no failure */
1127                 pdesc = &rcv_desc->desc_head[producer];
1128
1129 #if defined(XGB_DEBUG)
1130                 *(unsigned long *)(skb->head) = 0xc0debabe;
1131                 if (skb_is_nonlinear(skb)) {
1132                         printk("Allocated SKB @%p is nonlinear\n");
1133                 }
1134 #endif
1135                 skb_reserve(skb, 2);
1136                 /* This will be setup when we receive the
1137                  * buffer after it has been filled  FSL  TBD TBD
1138                  * skb->dev = netdev;
1139                  */
1140                 dma = pci_map_single(pdev, skb->data, rcv_desc->dma_size,
1141                                      PCI_DMA_FROMDEVICE);
1142                 pdesc->addr_buffer = dma;
1143                 buffer->skb = skb;
1144                 buffer->state = NETXEN_BUFFER_BUSY;
1145                 buffer->dma = dma;
1146                 /* make a rcv descriptor  */
1147                 pdesc->reference_handle = buffer->ref_handle;
1148                 pdesc->buffer_length = rcv_desc->dma_size;
1149                 DPRINTK(INFO, "done writing descripter\n");
1150                 producer =
1151                     get_next_index(producer, rcv_desc->max_rx_desc_count);
1152                 index = get_next_index(index, rcv_desc->max_rx_desc_count);
1153                 buffer = &rcv_desc->rx_buf_arr[index];
1154         }
1155         /* if we did allocate buffers, then write the count to Phantom */
1156         if (count) {
1157                 rcv_desc->begin_alloc = index;
1158                 rcv_desc->rcv_pending += count;
1159                 adapter->stats.lastposted = count;
1160                 adapter->stats.posted += count;
1161                 rcv_desc->producer = producer;
1162                 if (rcv_desc->rcv_free >= 32) {
1163                         rcv_desc->rcv_free = 0;
1164                         /* Window = 1 */
1165                         writel((producer - 1) &
1166                                (rcv_desc->max_rx_desc_count - 1),
1167                                NETXEN_CRB_NORMALIZE(adapter,
1168                                                     recv_crb_registers[0].
1169                                                     rcv_desc_crb[ringid].
1170                                                     crb_rcv_producer_offset));
1171                         /*
1172                          * Write a doorbell msg to tell phanmon of change in
1173                          * receive ring producer
1174                          */
1175                         netxen_set_msg_peg_id(msg, NETXEN_RCV_PEG_DB_ID);
1176                         netxen_set_msg_privid(msg);
1177                         netxen_set_msg_count(msg,
1178                                              ((producer -
1179                                                1) & (rcv_desc->
1180                                                      max_rx_desc_count - 1)));
1181                         netxen_set_msg_ctxid(msg, 0);
1182                         netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
1183                         writel(msg,
1184                                DB_NORMALIZE(adapter,
1185                                             NETXEN_RCV_PRODUCER_OFFSET));
1186                 }
1187         }
1188 }
1189
1190 void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
1191                                  uint32_t ringid)
1192 {
1193         struct pci_dev *pdev = adapter->ahw.pdev;
1194         struct sk_buff *skb;
1195         struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctx]);
1196         struct netxen_rcv_desc_ctx *rcv_desc = NULL;
1197         u32 producer;
1198         struct rcv_desc *pdesc;
1199         struct netxen_rx_buffer *buffer;
1200         int count = 0;
1201         int index = 0;
1202
1203         adapter->stats.post_called++;
1204         rcv_desc = &recv_ctx->rcv_desc[ringid];
1205
1206         producer = rcv_desc->producer;
1207         index = rcv_desc->begin_alloc;
1208         buffer = &rcv_desc->rx_buf_arr[index];
1209         /* We can start writing rx descriptors into the phantom memory. */
1210         while (buffer->state == NETXEN_BUFFER_FREE) {
1211                 skb = dev_alloc_skb(rcv_desc->skb_size);
1212                 if (unlikely(!skb)) {
1213                         /*
1214                          * We need to schedule the posting of buffers to the pegs.
1215                          */
1216                         rcv_desc->begin_alloc = index;
1217                         DPRINTK(ERR, "netxen_post_rx_buffers_nodb: "
1218                                 " allocated only %d buffers\n", count);
1219                         break;
1220                 }
1221                 count++;        /* now there should be no failure */
1222                 pdesc = &rcv_desc->desc_head[producer];
1223                 skb_reserve(skb, 2);
1224                 /*
1225                  * This will be setup when we receive the
1226                  * buffer after it has been filled
1227                  * skb->dev = netdev;
1228                  */
1229                 buffer->skb = skb;
1230                 buffer->state = NETXEN_BUFFER_BUSY;
1231                 buffer->dma = pci_map_single(pdev, skb->data,
1232                                              rcv_desc->dma_size,
1233                                              PCI_DMA_FROMDEVICE);
1234
1235                 /* make a rcv descriptor  */
1236                 pdesc->reference_handle = le16_to_cpu(buffer->ref_handle);
1237                 pdesc->buffer_length = le16_to_cpu(rcv_desc->dma_size);
1238                 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1239                 DPRINTK(INFO, "done writing descripter\n");
1240                 producer =
1241                     get_next_index(producer, rcv_desc->max_rx_desc_count);
1242                 index = get_next_index(index, rcv_desc->max_rx_desc_count);
1243                 buffer = &rcv_desc->rx_buf_arr[index];
1244         }
1245
1246         /* if we did allocate buffers, then write the count to Phantom */
1247         if (count) {
1248                 rcv_desc->begin_alloc = index;
1249                 rcv_desc->rcv_pending += count;
1250                 adapter->stats.lastposted = count;
1251                 adapter->stats.posted += count;
1252                 rcv_desc->producer = producer;
1253                 if (rcv_desc->rcv_free >= 32) {
1254                         rcv_desc->rcv_free = 0;
1255                         /* Window = 1 */
1256                         writel((producer - 1) &
1257                                (rcv_desc->max_rx_desc_count - 1),
1258                                NETXEN_CRB_NORMALIZE(adapter,
1259                                                     recv_crb_registers[0].
1260                                                     rcv_desc_crb[ringid].
1261                                                     crb_rcv_producer_offset));
1262                         wmb();
1263                 }
1264         }
1265 }
1266
1267 int netxen_nic_tx_has_work(struct netxen_adapter *adapter)
1268 {
1269         if (find_diff_among(adapter->last_cmd_consumer,
1270                             adapter->cmd_producer,
1271                             adapter->max_tx_desc_count) > 0)
1272                 return 1;
1273
1274         return 0;
1275 }
1276
1277 int
1278 netxen_nic_fill_statistics(struct netxen_adapter *adapter,
1279                            struct netxen_port *port,
1280                            struct netxen_statistics *netxen_stats)
1281 {
1282         void __iomem *addr;
1283
1284         if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
1285                 netxen_nic_pci_change_crbwindow(adapter, 0);
1286                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_TX_BYTE_CNT,
1287                                            &(netxen_stats->tx_bytes));
1288                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_TX_FRAME_CNT,
1289                                            &(netxen_stats->tx_packets));
1290                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_RX_BYTE_CNT,
1291                                            &(netxen_stats->rx_bytes));
1292                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_RX_FRAME_CNT,
1293                                            &(netxen_stats->rx_packets));
1294                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_AGGR_ERROR_CNT,
1295                                            &(netxen_stats->rx_errors));
1296                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_CRC_ERROR_CNT,
1297                                            &(netxen_stats->rx_crc_errors));
1298                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
1299                                            &(netxen_stats->
1300                                              rx_long_length_error));
1301                 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
1302                                            &(netxen_stats->
1303                                              rx_short_length_error));
1304
1305                 netxen_nic_pci_change_crbwindow(adapter, 1);
1306         } else {
1307                 spin_lock_bh(&adapter->tx_lock);
1308                 netxen_stats->tx_bytes = port->stats.txbytes;
1309                 netxen_stats->tx_packets = port->stats.xmitedframes +
1310                     port->stats.xmitfinished;
1311                 netxen_stats->rx_bytes = port->stats.rxbytes;
1312                 netxen_stats->rx_packets = port->stats.no_rcv;
1313                 netxen_stats->rx_errors = port->stats.rcvdbadskb;
1314                 netxen_stats->tx_errors = port->stats.nocmddescriptor;
1315                 netxen_stats->rx_short_length_error = port->stats.uplcong;
1316                 netxen_stats->rx_long_length_error = port->stats.uphcong;
1317                 netxen_stats->rx_crc_errors = 0;
1318                 netxen_stats->rx_mac_errors = 0;
1319                 spin_unlock_bh(&adapter->tx_lock);
1320         }
1321         return 0;
1322 }
1323
1324 void netxen_nic_clear_stats(struct netxen_adapter *adapter)
1325 {
1326         struct netxen_port *port;
1327         int port_num;
1328
1329         memset(&adapter->stats, 0, sizeof(adapter->stats));
1330         for (port_num = 0; port_num < adapter->ahw.max_ports; port_num++) {
1331                 port = adapter->port[port_num];
1332                 memset(&port->stats, 0, sizeof(port->stats));
1333         }
1334 }
1335
1336 int
1337 netxen_nic_clear_statistics(struct netxen_adapter *adapter,
1338                             struct netxen_port *port)
1339 {
1340         int data = 0;
1341
1342         netxen_nic_pci_change_crbwindow(adapter, 0);
1343
1344         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_TX_BYTE_CNT, &data);
1345         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_TX_FRAME_CNT,
1346                                     &data);
1347         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_RX_BYTE_CNT, &data);
1348         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_RX_FRAME_CNT,
1349                                     &data);
1350         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_AGGR_ERROR_CNT,
1351                                     &data);
1352         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_CRC_ERROR_CNT,
1353                                     &data);
1354         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
1355                                     &data);
1356         netxen_nic_locked_write_reg(adapter, NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
1357                                     &data);
1358
1359         netxen_nic_pci_change_crbwindow(adapter, 1);
1360         netxen_nic_clear_stats(adapter);
1361         return 0;
1362 }
1363
1364 int
1365 netxen_nic_do_ioctl(struct netxen_adapter *adapter, void *u_data,
1366                     struct netxen_port *port)
1367 {
1368         struct netxen_nic_ioctl_data data;
1369         struct netxen_nic_ioctl_data *up_data;
1370         int retval = 0;
1371         struct netxen_statistics netxen_stats;
1372
1373         up_data = (void *)u_data;
1374
1375         DPRINTK(INFO, "doing ioctl for %p\n", adapter);
1376         if (copy_from_user(&data, (void __user *)up_data, sizeof(data))) {
1377                 /* evil user tried to crash the kernel */
1378                 DPRINTK(ERR, "bad copy from userland: %d\n", (int)sizeof(data));
1379                 retval = -EFAULT;
1380                 goto error_out;
1381         }
1382
1383         /* Shouldn't access beyond legal limits of  "char u[64];" member */
1384         if (!data.ptr && (data.size > sizeof(data.u))) {
1385                 /* evil user tried to crash the kernel */
1386                 DPRINTK(ERR, "bad size: %d\n", data.size);
1387                 retval = -EFAULT;
1388                 goto error_out;
1389         }
1390
1391         switch (data.cmd) {
1392         case netxen_nic_cmd_pci_read:
1393                 if ((retval = netxen_nic_hw_read_ioctl(adapter, data.off,
1394                                                        &(data.u), data.size)))
1395                         goto error_out;
1396                 if (copy_to_user
1397                     ((void __user *)&(up_data->u), &(data.u), data.size)) {
1398                         DPRINTK(ERR, "bad copy to userland: %d\n",
1399                                 (int)sizeof(data));
1400                         retval = -EFAULT;
1401                         goto error_out;
1402                 }
1403                 data.rv = 0;
1404                 break;
1405
1406         case netxen_nic_cmd_pci_write:
1407                 if ((retval = netxen_nic_hw_write_ioctl(adapter, data.off,
1408                                                         &(data.u), data.size)))
1409                         goto error_out;
1410                 data.rv = 0;
1411                 break;
1412
1413         case netxen_nic_cmd_pci_mem_read:
1414                 if (netxen_nic_pci_mem_read_ioctl(adapter, data.off, &(data.u),
1415                                                   data.size)) {
1416                         DPRINTK(ERR, "Failed to read the data.\n");
1417                         retval = -EFAULT;
1418                         goto error_out;
1419                 }
1420                 if (copy_to_user
1421                     ((void __user *)&(up_data->u), &(data.u), data.size)) {
1422                         DPRINTK(ERR, "bad copy to userland: %d\n",
1423                                 (int)sizeof(data));
1424                         retval = -EFAULT;
1425                         goto error_out;
1426                 }
1427                 data.rv = 0;
1428                 break;
1429
1430         case netxen_nic_cmd_pci_mem_write:
1431                 if ((retval = netxen_nic_pci_mem_write_ioctl(adapter, data.off,
1432                                                              &(data.u),
1433                                                              data.size)))
1434                         goto error_out;
1435                 data.rv = 0;
1436                 break;
1437
1438         case netxen_nic_cmd_pci_config_read:
1439                 switch (data.size) {
1440                 case 1:
1441                         data.rv = pci_read_config_byte(adapter->ahw.pdev,
1442                                                        data.off,
1443                                                        (char *)&(data.u));
1444                         break;
1445                 case 2:
1446                         data.rv = pci_read_config_word(adapter->ahw.pdev,
1447                                                        data.off,
1448                                                        (short *)&(data.u));
1449                         break;
1450                 case 4:
1451                         data.rv = pci_read_config_dword(adapter->ahw.pdev,
1452                                                         data.off,
1453                                                         (u32 *) & (data.u));
1454                         break;
1455                 }
1456                 if (copy_to_user
1457                     ((void __user *)&(up_data->u), &(data.u), data.size)) {
1458                         DPRINTK(ERR, "bad copy to userland: %d\n",
1459                                 (int)sizeof(data));
1460                         retval = -EFAULT;
1461                         goto error_out;
1462                 }
1463                 break;
1464
1465         case netxen_nic_cmd_pci_config_write:
1466                 switch (data.size) {
1467                 case 1:
1468                         data.rv = pci_write_config_byte(adapter->ahw.pdev,
1469                                                         data.off,
1470                                                         *(char *)&(data.u));
1471                         break;
1472                 case 2:
1473                         data.rv = pci_write_config_word(adapter->ahw.pdev,
1474                                                         data.off,
1475                                                         *(short *)&(data.u));
1476                         break;
1477                 case 4:
1478                         data.rv = pci_write_config_dword(adapter->ahw.pdev,
1479                                                          data.off,
1480                                                          *(u32 *) & (data.u));
1481                         break;
1482                 }
1483                 break;
1484
1485         case netxen_nic_cmd_get_stats:
1486                 data.rv =
1487                     netxen_nic_fill_statistics(adapter, port, &netxen_stats);
1488                 if (copy_to_user
1489                     ((void __user *)(up_data->ptr), (void *)&netxen_stats,
1490                      sizeof(struct netxen_statistics))) {
1491                         DPRINTK(ERR, "bad copy to userland: %d\n",
1492                                 (int)sizeof(netxen_stats));
1493                         retval = -EFAULT;
1494                         goto error_out;
1495                 }
1496                 up_data->rv = data.rv;
1497                 break;
1498
1499         case netxen_nic_cmd_clear_stats:
1500                 data.rv = netxen_nic_clear_statistics(adapter, port);
1501                 up_data->rv = data.rv;
1502                 break;
1503
1504         case netxen_nic_cmd_get_version:
1505                 if (copy_to_user
1506                     ((void __user *)&(up_data->u), NETXEN_NIC_LINUX_VERSIONID,
1507                      sizeof(NETXEN_NIC_LINUX_VERSIONID))) {
1508                         DPRINTK(ERR, "bad copy to userland: %d\n",
1509                                 (int)sizeof(data));
1510                         retval = -EFAULT;
1511                         goto error_out;
1512                 }
1513                 break;
1514
1515         default:
1516                 DPRINTK(INFO, "bad command %d for %p\n", data.cmd, adapter);
1517                 retval = -EOPNOTSUPP;
1518                 goto error_out;
1519         }
1520         put_user(data.rv, (&(up_data->rv)));
1521         DPRINTK(INFO, "done ioctl for %p well.\n", adapter);
1522
1523       error_out:
1524         return retval;
1525 }