drivers/net/netxen/netxen_nic.h

   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 #ifndef _NETXEN_NIC_H_
  31 #define _NETXEN_NIC_H_
  32
  33 #include <linux/module.h>
  34 #include <linux/kernel.h>
  35 #include <linux/types.h>
  36 #include <linux/compiler.h>
  37 #include <linux/slab.h>
  38 #include <linux/delay.h>
  39 #include <linux/init.h>
  40 #include <linux/ioport.h>
  41 #include <linux/pci.h>
  42 #include <linux/netdevice.h>
  43 #include <linux/etherdevice.h>
  44 #include <linux/ip.h>
  45 #include <linux/in.h>
  46 #include <linux/tcp.h>
  47 #include <linux/skbuff.h>
  48 #include <linux/version.h>
  49
  50 #include <linux/ethtool.h>
  51 #include <linux/mii.h>
  52 #include <linux/interrupt.h>
  53 #include <linux/timer.h>
  54
  55 #include <linux/mm.h>
  56 #include <linux/mman.h>
  57
  58 #include <asm/system.h>
  59 #include <asm/io.h>
  60 #include <asm/byteorder.h>
  61 #include <asm/uaccess.h>
  62 #include <asm/pgtable.h>
  63
  64 #include "netxen_nic_hw.h"
  65
  66 #define NETXEN_NIC_BUILD_NO     "232"
  67 #define _NETXEN_NIC_LINUX_MAJOR 2
  68 #define _NETXEN_NIC_LINUX_MINOR 3
  69 #define _NETXEN_NIC_LINUX_SUBVERSION 57
  70 #define NETXEN_NIC_LINUX_VERSIONID  "2.3.57"
  71 #define NETXEN_NIC_FW_VERSIONID "2.3.57"
  72
  73 #define RCV_DESC_RINGSIZE       \
  74         (sizeof(struct rcv_desc) * adapter->max_rx_desc_count)
  75 #define STATUS_DESC_RINGSIZE    \
  76         (sizeof(struct status_desc)* adapter->max_rx_desc_count)
  77 #define TX_RINGSIZE     \
  78         (sizeof(struct netxen_cmd_buffer) * adapter->max_tx_desc_count)
  79 #define RCV_BUFFSIZE    \
  80         (sizeof(struct netxen_rx_buffer) * rcv_desc->max_rx_desc_count)
  81 #define find_diff_among(a,b,range) ((a)<(b)?((b)-(a)):((b)+(range)-(a)))
  82
  83 #define NETXEN_NETDEV_STATUS 0x1
  84
  85 #define ADDR_IN_WINDOW1(off)    \
  86         ((off > NETXEN_CRB_PCIX_HOST2) && (off < NETXEN_CRB_MAX)) ? 1 : 0
  87
  88 /*
  89  * normalize a 64MB crb address to 32MB PCI window
  90  * To use NETXEN_CRB_NORMALIZE, window _must_ be set to 1
  91  */
  92 #define NETXEN_CRB_NORMALIZE(adapter, reg) \
  93         ((adapter)->ahw.pci_base + (reg)        \
  94         - NETXEN_CRB_PCIX_HOST2 + NETXEN_CRB_PCIX_HOST)
  95
  96 #define MAX_RX_BUFFER_LENGTH            2000
  97 #define MAX_RX_JUMBO_BUFFER_LENGTH      9046
  98 #define RX_DMA_MAP_LEN                  (MAX_RX_BUFFER_LENGTH - NET_IP_ALIGN)
  99 #define RX_JUMBO_DMA_MAP_LEN    \
 100         (MAX_RX_JUMBO_BUFFER_LENGTH - NET_IP_ALIGN)
 101 #define NETXEN_ROM_ROUNDUP              0x80000000ULL
 102
 103 /*
 104  * Maximum number of ring contexts
 105  */
 106 #define MAX_RING_CTX 1
 107
 108 /* Opcodes to be used with the commands */
 109 enum {
 110         TX_ETHER_PKT = 0x01,
 111 /* The following opcodes are for IP checksum    */
 112         TX_TCP_PKT,
 113         TX_UDP_PKT,
 114         TX_IP_PKT,
 115         TX_TCP_LSO,
 116         TX_IPSEC,
 117         TX_IPSEC_CMD
 118 };
 119
 120 /* The following opcodes are for internal consumption. */
 121 #define NETXEN_CONTROL_OP       0x10
 122 #define PEGNET_REQUEST          0x11
 123
 124 #define MAX_NUM_CARDS           4
 125
 126 #define MAX_BUFFERS_PER_CMD     32
 127
 128 /*
 129  * Following are the states of the Phantom. Phantom will set them and
 130  * Host will read to check if the fields are correct.
 131  */
 132 #define PHAN_INITIALIZE_START           0xff00
 133 #define PHAN_INITIALIZE_FAILED          0xffff
 134 #define PHAN_INITIALIZE_COMPLETE        0xff01
 135
 136 /* Host writes the following to notify that it has done the init-handshake */
 137 #define PHAN_INITIALIZE_ACK     0xf00f
 138
 139 #define NUM_RCV_DESC_RINGS      2       /* No of Rcv Descriptor contexts */
 140
 141 /* descriptor types */
 142 #define RCV_DESC_NORMAL         0x01
 143 #define RCV_DESC_JUMBO          0x02
 144 #define RCV_DESC_NORMAL_CTXID   0
 145 #define RCV_DESC_JUMBO_CTXID    1
 146
 147 #define RCV_DESC_TYPE(ID) \
 148         ((ID == RCV_DESC_JUMBO_CTXID) ? RCV_DESC_JUMBO : RCV_DESC_NORMAL)
 149
 150 #define MAX_CMD_DESCRIPTORS             1024
 151 #define MAX_RCV_DESCRIPTORS             32768
 152 #define MAX_JUMBO_RCV_DESCRIPTORS       1024
 153 #define MAX_RCVSTATUS_DESCRIPTORS       MAX_RCV_DESCRIPTORS
 154 #define MAX_JUMBO_RCV_DESC      MAX_JUMBO_RCV_DESCRIPTORS
 155 #define MAX_RCV_DESC            MAX_RCV_DESCRIPTORS
 156 #define MAX_RCVSTATUS_DESC      MAX_RCV_DESCRIPTORS
 157 #define NUM_RCV_DESC            (MAX_RCV_DESC + MAX_JUMBO_RCV_DESCRIPTORS)
 158 #define MAX_EPG_DESCRIPTORS     (MAX_CMD_DESCRIPTORS * 8)
 159
 160 #define MIN_TX_COUNT    4096
 161 #define MIN_RX_COUNT    4096
 162
 163 #define MAX_FRAME_SIZE  0x10000 /* 64K MAX size for LSO */
 164
 165 #define PHAN_PEG_RCV_INITIALIZED        0xff01
 166 #define PHAN_PEG_RCV_START_INITIALIZE   0xff00
 167
 168 #define get_next_index(index, length)   \
 169         (((index) + 1) & ((length) - 1))
 170
 171 #define get_index_range(index,length,count)     \
 172         (((index) + (count)) & ((length) - 1))
 173
 174 /*
 175  * Following data structures describe the descriptors that will be used.
 176  * Added fileds of tcpHdrSize and ipHdrSize, The driver needs to do it only when
 177  * we are doing LSO (above the 1500 size packet) only.
 178  */
 179
 180 /*
 181  * The size of reference handle been changed to 16 bits to pass the MSS fields
 182  * for the LSO packet
 183  */
 184
 185 #define FLAGS_CHECKSUM_ENABLED  0x01
 186 #define FLAGS_LSO_ENABLED       0x02
 187 #define FLAGS_IPSEC_SA_ADD      0x04
 188 #define FLAGS_IPSEC_SA_DELETE   0x08
 189 #define FLAGS_VLAN_TAGGED       0x10
 190
 191 #define CMD_DESC_TOTAL_LENGTH(cmd_desc) \
 192                 ((cmd_desc)->length_tcp_hdr & 0x00FFFFFF)
 193 #define CMD_DESC_TCP_HDR_OFFSET(cmd_desc)       \
 194                 (((cmd_desc)->length_tcp_hdr >> 24) & 0x0FF)
 195 #define CMD_DESC_PORT(cmd_desc)         ((cmd_desc)->port_ctxid & 0x0F)
 196 #define CMD_DESC_CTX_ID(cmd_desc)       (((cmd_desc)->port_ctxid >> 4) & 0x0F)
 197
 198 #define CMD_DESC_TOTAL_LENGTH_WRT(cmd_desc, var)        \
 199                 ((cmd_desc)->length_tcp_hdr |= ((var) & 0x00FFFFFF))
 200 #define CMD_DESC_TCP_HDR_OFFSET_WRT(cmd_desc, var)      \
 201                 ((cmd_desc)->length_tcp_hdr |= (((var) << 24) & 0xFF000000))
 202 #define CMD_DESC_PORT_WRT(cmd_desc, var)        \
 203                 ((cmd_desc)->port_ctxid |= ((var) & 0x0F))
 204
 205 struct cmd_desc_type0 {
 206         u64 netxen_next;        /* for fragments handled by Phantom */
 207         union {
 208                 struct {
 209                         u32 addr_low_part2;
 210                         u32 addr_high_part2;
 211                 };
 212                 u64 addr_buffer2;
 213         };
 214
 215         /* Bit pattern: 0-23 total length, 24-32 tcp header offset */
 216         u32 length_tcp_hdr;
 217         u8 ip_hdr_offset;       /* For LSO only */
 218         u8 num_of_buffers;      /* total number of segments */
 219         u8 flags;               /* as defined above */
 220         u8 opcode;
 221
 222         u16 reference_handle;   /* changed to u16 to add mss */
 223         u16 mss;                /* passed by NDIS_PACKET for LSO */
 224         /* Bit pattern 0-3 port, 0-3 ctx id */
 225         u8 port_ctxid;
 226         u8 total_hdr_length;    /* LSO only : MAC+IP+TCP Hdr size */
 227         u16 conn_id;            /* IPSec offoad only */
 228
 229         union {
 230                 struct {
 231                         u32 addr_low_part3;
 232                         u32 addr_high_part3;
 233                 };
 234                 u64 addr_buffer3;
 235         };
 236
 237         union {
 238                 struct {
 239                         u32 addr_low_part1;
 240                         u32 addr_high_part1;
 241                 };
 242                 u64 addr_buffer1;
 243         };
 244
 245         u16 buffer1_length;
 246         u16 buffer2_length;
 247         u16 buffer3_length;
 248         u16 buffer4_length;
 249
 250         union {
 251                 struct {
 252                         u32 addr_low_part4;
 253                         u32 addr_high_part4;
 254                 };
 255                 u64 addr_buffer4;
 256         };
 257
 258 } __attribute__ ((aligned(64)));
 259
 260 /* Note: sizeof(rcv_desc) should always be a mutliple of 2 */
 261 struct rcv_desc {
 262         u16 reference_handle;
 263         u16 reserved;
 264         u32 buffer_length;      /* allocated buffer length (usually 2K) */
 265         u64 addr_buffer;
 266 };
 267
 268 /* opcode field in status_desc */
 269 #define RCV_NIC_PKT     (0xA)
 270 #define STATUS_NIC_PKT  ((RCV_NIC_PKT) << 12)
 271
 272 /* for status field in status_desc */
 273 #define STATUS_NEED_CKSUM       (1)
 274 #define STATUS_CKSUM_OK         (2)
 275
 276 /* owner bits of status_desc */
 277 #define STATUS_OWNER_HOST       (0x1)
 278 #define STATUS_OWNER_PHANTOM    (0x2)
 279
 280 #define NETXEN_PROT_IP          (1)
 281 #define NETXEN_PROT_UNKNOWN     (0)
 282
 283 /* Note: sizeof(status_desc) should always be a mutliple of 2 */
 284 #define STATUS_DESC_PORT(status_desc)   \
 285                 ((status_desc)->port_status_type_op & 0x0F)
 286 #define STATUS_DESC_STATUS(status_desc) \
 287                 (((status_desc)->port_status_type_op >> 4) & 0x0F)
 288 #define STATUS_DESC_TYPE(status_desc)   \
 289                 (((status_desc)->port_status_type_op >> 8) & 0x0F)
 290 #define STATUS_DESC_OPCODE(status_desc) \
 291                 (((status_desc)->port_status_type_op >> 12) & 0x0F)
 292
 293 struct status_desc {
 294         /* Bit pattern: 0-3 port, 4-7 status, 8-11 type, 12-15 opcode */
 295         u16 port_status_type_op;
 296         u16 total_length;       /* NIC mode */
 297         u16 reference_handle;   /* handle for the associated packet */
 298         /* Bit pattern: 0-1 owner, 2-5 protocol */
 299         u16 owner;              /* Owner of the descriptor */
 300 } __attribute__ ((aligned(8)));
 301
 302 enum {
 303         NETXEN_RCV_PEG_0 = 0,
 304         NETXEN_RCV_PEG_1
 305 };
 306 /* The version of the main data structure */
 307 #define NETXEN_BDINFO_VERSION 1
 308
 309 /* Magic number to let user know flash is programmed */
 310 #define NETXEN_BDINFO_MAGIC 0x12345678
 311
 312 /* Max number of Gig ports on a Phantom board */
 313 #define NETXEN_MAX_PORTS 4
 314
 315 typedef enum {
 316         NETXEN_BRDTYPE_P1_BD = 0x0000,
 317         NETXEN_BRDTYPE_P1_SB = 0x0001,
 318         NETXEN_BRDTYPE_P1_SMAX = 0x0002,
 319         NETXEN_BRDTYPE_P1_SOCK = 0x0003,
 320
 321         NETXEN_BRDTYPE_P2_SOCK_31 = 0x0008,
 322         NETXEN_BRDTYPE_P2_SOCK_35 = 0x0009,
 323         NETXEN_BRDTYPE_P2_SB35_4G = 0x000a,
 324         NETXEN_BRDTYPE_P2_SB31_10G = 0x000b,
 325         NETXEN_BRDTYPE_P2_SB31_2G = 0x000c,
 326
 327         NETXEN_BRDTYPE_P2_SB31_10G_IMEZ = 0x000d,
 328         NETXEN_BRDTYPE_P2_SB31_10G_HMEZ = 0x000e,
 329         NETXEN_BRDTYPE_P2_SB31_10G_CX4 = 0x000f
 330 } netxen_brdtype_t;
 331
 332 typedef enum {
 333         NETXEN_BRDMFG_INVENTEC = 1
 334 } netxen_brdmfg;
 335
 336 typedef enum {
 337         MEM_ORG_128Mbx4 = 0x0,  /* DDR1 only */
 338         MEM_ORG_128Mbx8 = 0x1,  /* DDR1 only */
 339         MEM_ORG_128Mbx16 = 0x2, /* DDR1 only */
 340         MEM_ORG_256Mbx4 = 0x3,
 341         MEM_ORG_256Mbx8 = 0x4,
 342         MEM_ORG_256Mbx16 = 0x5,
 343         MEM_ORG_512Mbx4 = 0x6,
 344         MEM_ORG_512Mbx8 = 0x7,
 345         MEM_ORG_512Mbx16 = 0x8,
 346         MEM_ORG_1Gbx4 = 0x9,
 347         MEM_ORG_1Gbx8 = 0xa,
 348         MEM_ORG_1Gbx16 = 0xb,
 349         MEM_ORG_2Gbx4 = 0xc,
 350         MEM_ORG_2Gbx8 = 0xd,
 351         MEM_ORG_2Gbx16 = 0xe,
 352         MEM_ORG_128Mbx32 = 0x10002,     /* GDDR only */
 353         MEM_ORG_256Mbx32 = 0x10005      /* GDDR only */
 354 } netxen_mn_mem_org_t;
 355
 356 typedef enum {
 357         MEM_ORG_512Kx36 = 0x0,
 358         MEM_ORG_1Mx36 = 0x1,
 359         MEM_ORG_2Mx36 = 0x2
 360 } netxen_sn_mem_org_t;
 361
 362 typedef enum {
 363         MEM_DEPTH_4MB = 0x1,
 364         MEM_DEPTH_8MB = 0x2,
 365         MEM_DEPTH_16MB = 0x3,
 366         MEM_DEPTH_32MB = 0x4,
 367         MEM_DEPTH_64MB = 0x5,
 368         MEM_DEPTH_128MB = 0x6,
 369         MEM_DEPTH_256MB = 0x7,
 370         MEM_DEPTH_512MB = 0x8,
 371         MEM_DEPTH_1GB = 0x9,
 372         MEM_DEPTH_2GB = 0xa,
 373         MEM_DEPTH_4GB = 0xb,
 374         MEM_DEPTH_8GB = 0xc,
 375         MEM_DEPTH_16GB = 0xd,
 376         MEM_DEPTH_32GB = 0xe
 377 } netxen_mem_depth_t;
 378
 379 struct netxen_board_info {
 380         u32 header_version;
 381
 382         u32 board_mfg;
 383         u32 board_type;
 384         u32 board_num;
 385         u32 chip_id;
 386         u32 chip_minor;
 387         u32 chip_major;
 388         u32 chip_pkg;
 389         u32 chip_lot;
 390
 391         u32 port_mask;          /* available niu ports */
 392         u32 peg_mask;           /* available pegs */
 393         u32 icache_ok;          /* can we run with icache? */
 394         u32 dcache_ok;          /* can we run with dcache? */
 395         u32 casper_ok;
 396
 397         u32 mac_addr_lo_0;
 398         u32 mac_addr_lo_1;
 399         u32 mac_addr_lo_2;
 400         u32 mac_addr_lo_3;
 401
 402         /* MN-related config */
 403         u32 mn_sync_mode;       /* enable/ sync shift cclk/ sync shift mclk */
 404         u32 mn_sync_shift_cclk;
 405         u32 mn_sync_shift_mclk;
 406         u32 mn_wb_en;
 407         u32 mn_crystal_freq;    /* in MHz */
 408         u32 mn_speed;           /* in MHz */
 409         u32 mn_org;
 410         u32 mn_depth;
 411         u32 mn_ranks_0;         /* ranks per slot */
 412         u32 mn_ranks_1;         /* ranks per slot */
 413         u32 mn_rd_latency_0;
 414         u32 mn_rd_latency_1;
 415         u32 mn_rd_latency_2;
 416         u32 mn_rd_latency_3;
 417         u32 mn_rd_latency_4;
 418         u32 mn_rd_latency_5;
 419         u32 mn_rd_latency_6;
 420         u32 mn_rd_latency_7;
 421         u32 mn_rd_latency_8;
 422         u32 mn_dll_val[18];
 423         u32 mn_mode_reg;        /* MIU DDR Mode Register */
 424         u32 mn_ext_mode_reg;    /* MIU DDR Extended Mode Register */
 425         u32 mn_timing_0;        /* MIU Memory Control Timing Rgister */
 426         u32 mn_timing_1;        /* MIU Extended Memory Ctrl Timing Register */
 427         u32 mn_timing_2;        /* MIU Extended Memory Ctrl Timing2 Register */
 428
 429         /* SN-related config */
 430         u32 sn_sync_mode;       /* enable/ sync shift cclk / sync shift mclk */
 431         u32 sn_pt_mode;         /* pass through mode */
 432         u32 sn_ecc_en;
 433         u32 sn_wb_en;
 434         u32 sn_crystal_freq;
 435         u32 sn_speed;
 436         u32 sn_org;
 437         u32 sn_depth;
 438         u32 sn_dll_tap;
 439         u32 sn_rd_latency;
 440
 441         u32 mac_addr_hi_0;
 442         u32 mac_addr_hi_1;
 443         u32 mac_addr_hi_2;
 444         u32 mac_addr_hi_3;
 445
 446         u32 magic;              /* indicates flash has been initialized */
 447
 448         u32 mn_rdimm;
 449         u32 mn_dll_override;
 450
 451 };
 452
 453 #define FLASH_NUM_PORTS         (4)
 454
 455 struct netxen_flash_mac_addr {
 456         u32 flash_addr[32];
 457 };
 458
 459 struct netxen_user_old_info {
 460         u8 flash_md5[16];
 461         u8 crbinit_md5[16];
 462         u8 brdcfg_md5[16];
 463         /* bootloader */
 464         u32 bootld_version;
 465         u32 bootld_size;
 466         u8 bootld_md5[16];
 467         /* image */
 468         u32 image_version;
 469         u32 image_size;
 470         u8 image_md5[16];
 471         /* primary image status */
 472         u32 primary_status;
 473         u32 secondary_present;
 474
 475         /* MAC address , 4 ports */
 476         struct netxen_flash_mac_addr mac_addr[FLASH_NUM_PORTS];
 477 };
 478 #define FLASH_NUM_MAC_PER_PORT  32
 479 struct netxen_user_info {
 480         u8 flash_md5[16 * 64];
 481         /* bootloader */
 482         u32 bootld_version;
 483         u32 bootld_size;
 484         /* image */
 485         u32 image_version;
 486         u32 image_size;
 487         /* primary image status */
 488         u32 primary_status;
 489         u32 secondary_present;
 490
 491         /* MAC address , 4 ports, 32 address per port */
 492         u64 mac_addr[FLASH_NUM_PORTS * FLASH_NUM_MAC_PER_PORT];
 493         u32 sub_sys_id;
 494         u8 serial_num[32];
 495
 496         /* Any user defined data */
 497 };
 498
 499 /*
 500  * Flash Layout - new format.
 501  */
 502 struct netxen_new_user_info {
 503         u8 flash_md5[16 * 64];
 504         /* bootloader */
 505         u32 bootld_version;
 506         u32 bootld_size;
 507         /* image */
 508         u32 image_version;
 509         u32 image_size;
 510         /* primary image status */
 511         u32 primary_status;
 512         u32 secondary_present;
 513
 514         /* MAC address , 4 ports, 32 address per port */
 515         u64 mac_addr[FLASH_NUM_PORTS * FLASH_NUM_MAC_PER_PORT];
 516         u32 sub_sys_id;
 517         u8 serial_num[32];
 518
 519         /* Any user defined data */
 520 };
 521
 522 #define SECONDARY_IMAGE_PRESENT 0xb3b4b5b6
 523 #define SECONDARY_IMAGE_ABSENT  0xffffffff
 524 #define PRIMARY_IMAGE_GOOD      0x5a5a5a5a
 525 #define PRIMARY_IMAGE_BAD       0xffffffff
 526
 527 /* Flash memory map */
 528 typedef enum {
 529         CRBINIT_START = 0,      /* Crbinit section */
 530         BRDCFG_START = 0x4000,  /* board config */
 531         INITCODE_START = 0x6000,        /* pegtune code */
 532         BOOTLD_START = 0x10000, /* bootld */
 533         IMAGE_START = 0x43000,  /* compressed image */
 534         SECONDARY_START = 0x200000,     /* backup images */
 535         PXE_START = 0x3E0000,   /* user defined region */
 536         USER_START = 0x3E8000,  /* User defined region for new boards */
 537         FIXED_START = 0x3F0000  /* backup of crbinit */
 538 } netxen_flash_map_t;
 539
 540 #define USER_START_OLD PXE_START        /* for backward compatibility */
 541
 542 #define FLASH_START             (CRBINIT_START)
 543 #define INIT_SECTOR             (0)
 544 #define PRIMARY_START           (BOOTLD_START)
 545 #define FLASH_CRBINIT_SIZE      (0x4000)
 546 #define FLASH_BRDCFG_SIZE       (sizeof(struct netxen_board_info))
 547 #define FLASH_USER_SIZE         (sizeof(netxen_user_info)/sizeof(u32))
 548 #define FLASH_SECONDARY_SIZE    (USER_START-SECONDARY_START)
 549 #define NUM_PRIMARY_SECTORS     (0x20)
 550 #define NUM_CONFIG_SECTORS      (1)
 551 #define PFX "netxen: "
 552
 553 /* Note: Make sure to not call this before adapter->port is valid */
 554 #if !defined(NETXEN_DEBUG)
 555 #define DPRINTK(klevel, fmt, args...)   do { \
 556         } while (0)
 557 #else
 558 #define DPRINTK(klevel, fmt, args...)   do { \
 559         printk(KERN_##klevel PFX "%s: %s: " fmt, __FUNCTION__,\
 560                 (adapter != NULL && adapter->port != NULL && \
 561                 adapter->port[0] != NULL && \
 562                 adapter->port[0]->netdev != NULL) ? \
 563                 adapter->port[0]->netdev->name : NULL, \
 564                 ## args); } while(0)
 565 #endif
 566
 567 /* Number of status descriptors to handle per interrupt */
 568 #define MAX_STATUS_HANDLE       (128)
 569
 570 /*
 571  * netxen_skb_frag{} is to contain mapping info for each SG list. This
 572  * has to be freed when DMA is complete. This is part of netxen_tx_buffer{}.
 573  */
 574 struct netxen_skb_frag {
 575         u64 dma;
 576         u32 length;
 577 };
 578
 579 /*    Following defines are for the state of the buffers    */
 580 #define NETXEN_BUFFER_FREE      0
 581 #define NETXEN_BUFFER_BUSY      1
 582
 583 /*
 584  * There will be one netxen_buffer per skb packet.    These will be
 585  * used to save the dma info for pci_unmap_page()
 586  */
 587 struct netxen_cmd_buffer {
 588         struct sk_buff *skb;
 589         struct netxen_skb_frag frag_array[MAX_BUFFERS_PER_CMD + 1];
 590         u32 total_length;
 591         u32 mss;
 592         u16 port;
 593         u8 cmd;
 594         u8 frag_count;
 595         unsigned long time_stamp;
 596         u32 state;
 597         u32 no_of_descriptors;
 598 };
 599
 600 /* In rx_buffer, we do not need multiple fragments as is a single buffer */
 601 struct netxen_rx_buffer {
 602         struct sk_buff *skb;
 603         u64 dma;
 604         u16 ref_handle;
 605         u16 state;
 606 };
 607
 608 /* Board types */
 609 #define NETXEN_NIC_GBE  0x01
 610 #define NETXEN_NIC_XGBE 0x02
 611
 612 /*
 613  * One hardware_context{} per adapter
 614  * contains interrupt info as well shared hardware info.
 615  */
 616 struct netxen_hardware_context {
 617         struct pci_dev *pdev;
 618         void __iomem *pci_base; /* base of mapped phantom memory */
 619         u8 revision_id;
 620         u16 board_type;
 621         u16 max_ports;
 622         struct netxen_board_info boardcfg;
 623         u32 xg_linkup;
 624         /* Address of cmd ring in Phantom */
 625         struct cmd_desc_type0 *cmd_desc_head;
 626         dma_addr_t cmd_desc_phys_addr;
 627         struct netxen_adapter *adapter;
 628 };
 629
 630 #define MINIMUM_ETHERNET_FRAME_SIZE     64      /* With FCS */
 631 #define ETHERNET_FCS_SIZE               4
 632
 633 struct netxen_adapter_stats {
 634         u64 ints;
 635         u64 hostints;
 636         u64 otherints;
 637         u64 process_rcv;
 638         u64 process_xmit;
 639         u64 noxmitdone;
 640         u64 xmitcsummed;
 641         u64 post_called;
 642         u64 posted;
 643         u64 lastposted;
 644         u64 goodskbposts;
 645 };
 646
 647 /*
 648  * Rcv Descriptor Context. One such per Rcv Descriptor. There may
 649  * be one Rcv Descriptor for normal packets, one for jumbo and may be others.
 650  */
 651 struct netxen_rcv_desc_ctx {
 652         u32 flags;
 653         u32 producer;
 654         u32 rcv_pending;        /* Num of bufs posted in phantom */
 655         u32 rcv_free;           /* Num of bufs in free list */
 656         dma_addr_t phys_addr;
 657         struct rcv_desc *desc_head;     /* address of rx ring in Phantom */
 658         u32 max_rx_desc_count;
 659         u32 dma_size;
 660         u32 skb_size;
 661         struct netxen_rx_buffer *rx_buf_arr;    /* rx buffers for receive   */
 662         int begin_alloc;
 663 };
 664
 665 /*
 666  * Receive context. There is one such structure per instance of the
 667  * receive processing. Any state information that is relevant to
 668  * the receive, and is must be in this structure. The global data may be
 669  * present elsewhere.
 670  */
 671 struct netxen_recv_context {
 672         struct netxen_rcv_desc_ctx rcv_desc[NUM_RCV_DESC_RINGS];
 673         u32 status_rx_producer;
 674         u32 status_rx_consumer;
 675         dma_addr_t rcv_status_desc_phys_addr;
 676         struct status_desc *rcv_status_desc_head;
 677 };
 678
 679 #define NETXEN_NIC_MSI_ENABLED 0x02
 680
 681 struct netxen_drvops;
 682
 683 struct netxen_adapter {
 684         struct netxen_hardware_context ahw;
 685         int port_count;         /* Number of configured ports  */
 686         int active_ports;       /* Number of open ports */
 687         struct netxen_port *port[NETXEN_MAX_PORTS];     /* ptr to each port  */
 688         spinlock_t tx_lock;
 689         spinlock_t lock;
 690         struct work_struct watchdog_task;
 691         struct work_struct tx_timeout_task;
 692         struct timer_list watchdog_timer;
 693
 694         u32 curr_window;
 695
 696         u32 cmd_producer;
 697         u32 cmd_consumer;
 698
 699         u32 last_cmd_consumer;
 700         u32 max_tx_desc_count;
 701         u32 max_rx_desc_count;
 702         u32 max_jumbo_rx_desc_count;
 703         /* Num of instances active on cmd buffer ring */
 704         u32 proc_cmd_buf_counter;
 705
 706         u32 num_threads, total_threads; /*Use to keep track of xmit threads */
 707
 708         u32 flags;
 709         u32 irq;
 710         int driver_mismatch;
 711
 712         struct netxen_adapter_stats stats;
 713
 714         struct netxen_cmd_buffer *cmd_buf_arr;  /* Command buffers for xmit */
 715
 716         /*
 717          * Receive instances. These can be either one per port,
 718          * or one per peg, etc.
 719          */
 720         struct netxen_recv_context recv_ctx[MAX_RCV_CTX];
 721
 722         int is_up;
 723         int work_done;
 724         struct netxen_drvops *ops;
 725 };                              /* netxen_adapter structure */
 726
 727 /* Max number of xmit producer threads that can run simultaneously */
 728 #define MAX_XMIT_PRODUCERS              16
 729
 730 struct netxen_port_stats {
 731         u64 rcvdbadskb;
 732         u64 xmitcalled;
 733         u64 xmitedframes;
 734         u64 xmitfinished;
 735         u64 badskblen;
 736         u64 nocmddescriptor;
 737         u64 polled;
 738         u64 uphappy;
 739         u64 updropped;
 740         u64 uplcong;
 741         u64 uphcong;
 742         u64 upmcong;
 743         u64 updunno;
 744         u64 skbfreed;
 745         u64 txdropped;
 746         u64 txnullskb;
 747         u64 csummed;
 748         u64 no_rcv;
 749         u64 rxbytes;
 750         u64 txbytes;
 751 };
 752
 753 struct netxen_port {
 754         struct netxen_adapter *adapter;
 755
 756         u16 portnum;            /* GBE port number */
 757         u16 link_speed;
 758         u16 link_duplex;
 759         u16 link_autoneg;
 760
 761         int flags;
 762
 763         struct net_device *netdev;
 764         struct pci_dev *pdev;
 765         struct net_device_stats net_stats;
 766         struct netxen_port_stats stats;
 767 };
 768
 769 struct netxen_drvops {
 770         int (*enable_phy_interrupts) (struct netxen_adapter *, int);
 771         int (*disable_phy_interrupts) (struct netxen_adapter *, int);
 772         void (*handle_phy_intr) (struct netxen_adapter *);
 773         int (*macaddr_set) (struct netxen_port *, netxen_ethernet_macaddr_t);
 774         int (*set_mtu) (struct netxen_port *, int);
 775         int (*set_promisc) (struct netxen_adapter *, int,
 776                             netxen_niu_prom_mode_t);
 777         int (*unset_promisc) (struct netxen_adapter *, int,
 778                               netxen_niu_prom_mode_t);
 779         int (*phy_read) (struct netxen_adapter *, long phy, long reg, u32 *);
 780         int (*phy_write) (struct netxen_adapter *, long phy, long reg, u32 val);
 781         int (*init_port) (struct netxen_adapter *, int);
 782         void (*init_niu) (struct netxen_adapter *);
 783         int (*stop_port) (struct netxen_adapter *, int);
 784 };
 785
 786 extern char netxen_nic_driver_name[];
 787
 788 int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter,
 789                                           int port);
 790 int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter,
 791                                          int port);
 792 int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter,
 793                                            int port);
 794 int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter,
 795                                           int port);
 796 int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter,
 797                                          int port);
 798 int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter,
 799                                         int port);
 800 void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter);
 801 void netxen_nic_gbe_handle_phy_intr(struct netxen_adapter *adapter);
 802 void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter, int port,
 803                                  long enable);
 804 void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter, int port,
 805                                   long enable);
 806 int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy, long reg,
 807                             __le32 * readval);
 808 int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long phy,
 809                              long reg, __le32 val);
 810
 811 /* Functions available from netxen_nic_hw.c */
 812 int netxen_niu_xginit(struct netxen_adapter *);
 813 int netxen_nic_set_mtu_xgb(struct netxen_port *port, int new_mtu);
 814 int netxen_nic_set_mtu_gb(struct netxen_port *port, int new_mtu);
 815 void netxen_nic_init_niu_gb(struct netxen_adapter *adapter);
 816 void netxen_nic_pci_change_crbwindow(struct netxen_adapter *adapter, u32 wndw);
 817 void netxen_nic_reg_write(struct netxen_adapter *adapter, u64 off, u32 val);
 818 int netxen_nic_reg_read(struct netxen_adapter *adapter, u64 off);
 819 void netxen_nic_write_w0(struct netxen_adapter *adapter, u32 index, u32 value);
 820 void netxen_nic_read_w0(struct netxen_adapter *adapter, u32 index, u32 * value);
 821
 822 int netxen_nic_get_board_info(struct netxen_adapter *adapter);
 823 int netxen_nic_hw_read_wx(struct netxen_adapter *adapter, u64 off, void *data,
 824                           int len);
 825 int netxen_nic_hw_write_wx(struct netxen_adapter *adapter, u64 off, void *data,
 826                            int len);
 827 void netxen_crb_writelit_adapter(struct netxen_adapter *adapter,
 828                                  unsigned long off, int data);
 829
 830 /* Functions from netxen_nic_init.c */
 831 void netxen_phantom_init(struct netxen_adapter *adapter);
 832 void netxen_load_firmware(struct netxen_adapter *adapter);
 833 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose);
 834 int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp);
 835
 836 /* Functions from netxen_nic_isr.c */
 837 void netxen_nic_isr_other(struct netxen_adapter *adapter);
 838 void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 port,
 839                                  u32 link);
 840 void netxen_handle_port_int(struct netxen_adapter *adapter, u32 port,
 841                             u32 enable);
 842 void netxen_nic_stop_all_ports(struct netxen_adapter *adapter);
 843 void netxen_initialize_adapter_sw(struct netxen_adapter *adapter);
 844 void netxen_initialize_adapter_hw(struct netxen_adapter *adapter);
 845 void netxen_initialize_adapter_ops(struct netxen_adapter *adapter);
 846 int netxen_init_firmware(struct netxen_adapter *adapter);
 847 void netxen_free_hw_resources(struct netxen_adapter *adapter);
 848 void netxen_tso_check(struct netxen_adapter *adapter,
 849                       struct cmd_desc_type0 *desc, struct sk_buff *skb);
 850 int netxen_nic_hw_resources(struct netxen_adapter *adapter);
 851 void netxen_nic_clear_stats(struct netxen_adapter *adapter);
 852 int
 853 netxen_nic_do_ioctl(struct netxen_adapter *adapter, void *u_data,
 854                     struct netxen_port *port);
 855 int netxen_nic_rx_has_work(struct netxen_adapter *adapter);
 856 int netxen_nic_tx_has_work(struct netxen_adapter *adapter);
 857 void netxen_watchdog_task(unsigned long v);
 858 void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx,
 859                             u32 ringid);
 860 void netxen_process_cmd_ring(unsigned long data);
 861 u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctx, int max);
 862 void netxen_nic_set_multi(struct net_device *netdev);
 863 int netxen_nic_change_mtu(struct net_device *netdev, int new_mtu);
 864 int netxen_nic_set_mac(struct net_device *netdev, void *p);
 865 struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev);
 866
 867 static inline void netxen_nic_disable_int(struct netxen_adapter *adapter)
 868 {
 869         /*
 870          * ISR_INT_MASK: Can be read from window 0 or 1.
 871          */
 872         writel(0x7ff, (void __iomem *)(adapter->ahw.pci_base + ISR_INT_MASK));
 873 }
 874
 875 static inline void netxen_nic_enable_int(struct netxen_adapter *adapter)
 876 {
 877         u32 mask;
 878
 879         switch (adapter->ahw.board_type) {
 880         case NETXEN_NIC_GBE:
 881                 mask = 0x77b;
 882                 break;
 883         case NETXEN_NIC_XGBE:
 884                 mask = 0x77f;
 885                 break;
 886         default:
 887                 mask = 0x7ff;
 888                 break;
 889         }
 890
 891         writel(mask, (void __iomem *)(adapter->ahw.pci_base + ISR_INT_MASK));
 892
 893         if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
 894                 mask = 0xbff;
 895                 writel(mask, (void __iomem *)
 896                        (adapter->ahw.pci_base + ISR_INT_TARGET_MASK));
 897         }
 898 }
 899
 900 int netxen_is_flash_supported(struct netxen_adapter *adapter);
 901 int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, u64 mac[]);
 902
 903 extern void netxen_change_ringparam(struct netxen_adapter *adapter);
 904 extern int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr,
 905                                 int *valp);
 906
 907 extern struct ethtool_ops netxen_nic_ethtool_ops;
 908
 909 #endif                          /* __NETXEN_NIC_H_ */