package/broadcom-57xx/src/b57um.c

   1 /******************************************************************************/
   2 /*                                                                            */
   3 /* Broadcom BCM5700 Linux Network Driver, Copyright (c) 2000 - 2005 Broadcom  */
   4 /* Corporation.                                                               */
   5 /* All rights reserved.                                                       */
   6 /*                                                                            */
   7 /* This program is free software; you can redistribute it and/or modify       */
   8 /* it under the terms of the GNU General Public License as published by       */
   9 /* the Free Software Foundation, located in the file LICENSE.                 */
  10 /*                                                                            */
  11 /******************************************************************************/
  12
  13
  14 char bcm5700_driver[] = "bcm57xx";
  15 char bcm5700_version[] = "8.3.14";
  16 char bcm5700_date[] = "(11/2/05)";
  17
  18 #define B57UM
  19 #include "mm.h"
  20 #include "linux/mii.h" //@.@jack add it 2006/06/28.
  21 #include "typedefs.h"
  22 #include "osl.h"
  23 #include "bcmdefs.h"
  24 #include "bcmdevs.h"
  25 #include "sbconfig.h"
  26 #include "sbutils.h"
  27 #include "hndgige.h"
  28 #include "bcmrobo.h"
  29 #include "robo_register.c"
  30
  31 #include "bcmendian.h"
  32 #include "bcmnvram.h"
  33 #include "proto/ethernet.h"
  34 #include "proto/vlan.h"
  35 #include "proto/bcmtcp.h"
  36 #include "proto/bcmip.h"
  37 #define PKTDATA(osh, skb)               (((struct sk_buff*)(skb))->data)
  38
  39 /* this is needed to get good and stable performances */
  40 #define EXTRA_HDR BCMEXTRAHDROOM
  41
  42 #define SIOCGREG_STATUS  0x8996          /* Read Switch register (for debug)*/
  43 #define SIOCSREG_STATUS  0x8997          /* Write Switch register(for debug)*/
  44
  45 /* This structure is used in SIOCXREG_STATUS ioctl calls*/
  46 struct reg_ioctl_data {
  47         u16             page_num;
  48         u16             addr_num;
  49         u16             len;
  50         u16             val_in[4];
  51         u16             val_out[4];
  52 };
  53
  54 /* A few user-configurable values. */
  55
  56 #define MAX_UNITS 16
  57 /* Used to pass the full-duplex flag, etc. */
  58 static int line_speed[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  59 static int auto_speed[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  60 static int full_duplex[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  61 static int rx_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  62 static int tx_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  63 static int auto_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  64 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
  65 static int mtu[MAX_UNITS] = {1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500};  /* Jumbo MTU for interfaces. */
  66 #endif
  67 static int tx_checksum[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  68 static int rx_checksum[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  69 static int scatter_gather[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  70 static int activate_gpio = -1;
  71
  72 #define TX_DESC_CNT DEFAULT_TX_PACKET_DESC_COUNT
  73 static unsigned int tx_pkt_desc_cnt[MAX_UNITS] =
  74         {TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
  75         TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
  76         TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
  77         TX_DESC_CNT};
  78
  79 #define RX_DESC_CNT DEFAULT_STD_RCV_DESC_COUNT
  80 static unsigned int rx_std_desc_cnt[MAX_UNITS] =
  81         {RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
  82         RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
  83         RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
  84         RX_DESC_CNT };
  85
  86 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
  87 #define JBO_DESC_CNT DEFAULT_JUMBO_RCV_DESC_COUNT
  88 static unsigned int rx_jumbo_desc_cnt[MAX_UNITS] =
  89         {JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
  90         JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
  91         JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
  92         JBO_DESC_CNT };
  93 #endif
  94
  95 #ifdef BCM_INT_COAL
  96 #ifdef BCM_NAPI_RXPOLL
  97 static unsigned int adaptive_coalesce[MAX_UNITS] =
  98         {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  99 #else
 100 static unsigned int adaptive_coalesce[MAX_UNITS] =
 101         {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
 102 #endif
 103
 104 #define RX_COAL_TK DEFAULT_RX_COALESCING_TICKS
 105 static unsigned int rx_coalesce_ticks[MAX_UNITS] =
 106         {RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
 107         RX_COAL_TK, RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
 108         RX_COAL_TK,RX_COAL_TK, RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
 109         RX_COAL_TK};
 110
 111 #define RX_COAL_FM DEFAULT_RX_MAX_COALESCED_FRAMES
 112 static unsigned int rx_max_coalesce_frames[MAX_UNITS] =
 113         {RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
 114         RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
 115         RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
 116         RX_COAL_FM};
 117
 118 #define TX_COAL_TK DEFAULT_TX_COALESCING_TICKS
 119 static unsigned int tx_coalesce_ticks[MAX_UNITS] =
 120         {TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
 121         TX_COAL_TK, TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
 122         TX_COAL_TK,TX_COAL_TK, TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
 123         TX_COAL_TK};
 124
 125 #define TX_COAL_FM DEFAULT_TX_MAX_COALESCED_FRAMES
 126 static unsigned int tx_max_coalesce_frames[MAX_UNITS] =
 127         {TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
 128         TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
 129         TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
 130         TX_COAL_FM};
 131
 132 #define ST_COAL_TK DEFAULT_STATS_COALESCING_TICKS
 133 static unsigned int stats_coalesce_ticks[MAX_UNITS] =
 134         {ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
 135         ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
 136         ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
 137         ST_COAL_TK,};
 138
 139 #endif
 140 #ifdef BCM_WOL
 141 static int enable_wol[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 142 #endif
 143 #ifdef BCM_TSO
 144 static int enable_tso[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
 145 #endif
 146 #ifdef BCM_NIC_SEND_BD
 147 static int nic_tx_bd[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 148 #endif
 149 #ifdef BCM_ASF
 150 static int vlan_tag_mode[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 151 #endif
 152 static int delay_link[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 153 static int disable_d3hot[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 154
 155 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
 156 static int disable_msi[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 157 static int bcm_msi_chipset_bug = 0;
 158 #endif
 159
 160 #define BCM_TIMER_GRANULARITY  (1000000 / HZ)
 161
 162 /* Hack to hook the data path to the BCM WL dirver */
 163 #ifdef BCM_WL_EMULATOR
 164 #include "bcmnvram.h"
 165 #include "wl_bcm57emu.h"
 166 #ifdef SKB_MANAGER
 167 int skb_old_alloc = 0;
 168 #endif
 169 #endif /* BCM_WL_EMULATOR */
 170
 171 /* Operational parameters that usually are not changed. */
 172 /* Time in jiffies before concluding the transmitter is hung. */
 173 #define TX_TIMEOUT  (2*HZ)
 174
 175 #if (LINUX_VERSION_CODE < 0x02030d)
 176 #define pci_resource_start(dev, bar)    (dev->base_address[bar] & PCI_BASE_ADDRESS_MEM_MASK)
 177 #elif (LINUX_VERSION_CODE < 0x02032b)
 178 #define pci_resource_start(dev, bar)    (dev->resource[bar] & PCI_BASE_ADDRESS_MEM_MASK)
 179 #endif
 180
 181 #if (LINUX_VERSION_CODE < 0x02032b)
 182 #define dev_kfree_skb_irq(skb)  dev_kfree_skb(skb)
 183 #define netif_wake_queue(dev)   clear_bit(0, &dev->tbusy); mark_bh(NET_BH)
 184 #define netif_stop_queue(dev)   set_bit(0, &dev->tbusy)
 185
 186 static inline void netif_start_queue(struct net_device *dev)
 187 {
 188         dev->tbusy = 0;
 189         dev->interrupt = 0;
 190         dev->start = 1;
 191 }
 192
 193 #define netif_queue_stopped(dev)        dev->tbusy
 194 #define netif_running(dev)              dev->start
 195
 196 static inline void tasklet_schedule(struct tasklet_struct *tasklet)
 197 {
 198         queue_task(tasklet, &tq_immediate);
 199         mark_bh(IMMEDIATE_BH);
 200 }
 201
 202 static inline void tasklet_init(struct tasklet_struct *tasklet,
 203                                 void (*func)(unsigned long),
 204                                 unsigned long data)
 205 {
 206                 tasklet->next = NULL;
 207                 tasklet->sync = 0;
 208                 tasklet->routine = (void (*)(void *))func;
 209                 tasklet->data = (void *)data;
 210 }
 211
 212 #define tasklet_kill(tasklet)
 213
 214 #endif
 215
 216 #if (LINUX_VERSION_CODE < 0x020300)
 217 struct pci_device_id {
 218         unsigned int vendor, device;            /* Vendor and device ID or PCI_ANY_ID */
 219         unsigned int subvendor, subdevice;      /* Subsystem ID's or PCI_ANY_ID */
 220         unsigned int class, class_mask;         /* (class,subclass,prog-if) triplet */
 221         unsigned long driver_data;              /* Data private to the driver */
 222 };
 223
 224 #define PCI_ANY_ID              0
 225
 226 #define pci_set_drvdata(pdev, dev)
 227 #define pci_get_drvdata(pdev) 0
 228
 229 #define pci_enable_device(pdev) 0
 230
 231 #define __devinit               __init
 232 #define __devinitdata           __initdata
 233 #define __devexit
 234
 235 #define SET_MODULE_OWNER(dev)
 236 #define MODULE_DEVICE_TABLE(pci, pci_tbl)
 237
 238 #endif
 239
 240 #if (LINUX_VERSION_CODE < 0x020411)
 241 #ifndef __devexit_p
 242 #define __devexit_p(x)  x
 243 #endif
 244 #endif
 245
 246 #ifndef MODULE_LICENSE
 247 #define MODULE_LICENSE(license)
 248 #endif
 249
 250 #ifndef IRQ_RETVAL
 251 typedef void irqreturn_t;
 252 #define IRQ_RETVAL(x)
 253 #endif
 254
 255 #if (LINUX_VERSION_CODE < 0x02032a)
 256 static inline void *pci_alloc_consistent(struct pci_dev *pdev, size_t size,
 257                                          dma_addr_t *dma_handle)
 258 {
 259         void *virt_ptr;
 260
 261         /* Maximum in slab.c */
 262         if (size > 131072)
 263                 return 0;
 264
 265         virt_ptr = kmalloc(size, GFP_KERNEL);
 266         *dma_handle = virt_to_bus(virt_ptr);
 267         return virt_ptr;
 268 }
 269 #define pci_free_consistent(dev, size, ptr, dma_ptr)    kfree(ptr)
 270
 271 #endif /*#if (LINUX_VERSION_CODE < 0x02032a) */
 272
 273
 274 #if (LINUX_VERSION_CODE < 0x02040d)
 275
 276 #if (LINUX_VERSION_CODE >= 0x020409) && defined(RED_HAT_LINUX_KERNEL)
 277
 278 #define BCM_32BIT_DMA_MASK ((u64) 0x00000000ffffffffULL)
 279 #define BCM_64BIT_DMA_MASK ((u64) 0xffffffffffffffffULL)
 280
 281 #else
 282 /* pci_set_dma_mask is using dma_addr_t */
 283
 284 #define BCM_32BIT_DMA_MASK ((dma_addr_t) 0xffffffff)
 285 #define BCM_64BIT_DMA_MASK ((dma_addr_t) 0xffffffff)
 286
 287 #endif
 288
 289 #else /* (LINUX_VERSION_CODE < 0x02040d) */
 290
 291 #define BCM_32BIT_DMA_MASK ((u64) 0x00000000ffffffffULL)
 292 #define BCM_64BIT_DMA_MASK ((u64) 0xffffffffffffffffULL)
 293 #endif
 294
 295 #if (LINUX_VERSION_CODE < 0x020329)
 296 #define pci_set_dma_mask(pdev, mask) (0)
 297 #else
 298 #if (LINUX_VERSION_CODE < 0x020403)
 299 int
 300 pci_set_dma_mask(struct pci_dev *dev, dma_addr_t mask)
 301 {
 302     if(! pci_dma_supported(dev, mask))
 303         return -EIO;
 304
 305     dev->dma_mask = mask;
 306
 307     return 0;
 308 }
 309 #endif
 310 #endif
 311
 312 #if (LINUX_VERSION_CODE < 0x020547)
 313 #define pci_set_consistent_dma_mask(pdev, mask) (0)
 314 #endif
 315
 316 #if (LINUX_VERSION_CODE < 0x020402)
 317 #define pci_request_regions(pdev, name) (0)
 318 #define pci_release_regions(pdev)
 319 #endif
 320
 321 #if !defined(spin_is_locked)
 322 #define spin_is_locked(lock)    (test_bit(0,(lock)))
 323 #endif
 324
 325 #define BCM5700_LOCK(pUmDevice, flags)                                  \
 326         if ((pUmDevice)->do_global_lock) {                              \
 327                 spin_lock_irqsave(&(pUmDevice)->global_lock, flags);    \
 328         }
 329
 330 #define BCM5700_UNLOCK(pUmDevice, flags)                                \
 331         if ((pUmDevice)->do_global_lock) {                              \
 332                 spin_unlock_irqrestore(&(pUmDevice)->global_lock, flags);\
 333         }
 334
 335 inline void
 336 bcm5700_intr_lock(PUM_DEVICE_BLOCK pUmDevice)
 337 {
 338         if (pUmDevice->do_global_lock) {
 339                 spin_lock(&pUmDevice->global_lock);
 340         }
 341 }
 342
 343 inline void
 344 bcm5700_intr_unlock(PUM_DEVICE_BLOCK pUmDevice)
 345 {
 346         if (pUmDevice->do_global_lock) {
 347                 spin_unlock(&pUmDevice->global_lock);
 348         }
 349 }
 350
 351 void
 352 bcm5700_intr_off(PUM_DEVICE_BLOCK pUmDevice)
 353 {
 354         atomic_inc(&pUmDevice->intr_sem);
 355         LM_DisableInterrupt(&pUmDevice->lm_dev);
 356 #if (LINUX_VERSION_CODE >= 0x2051c)
 357         synchronize_irq(pUmDevice->dev->irq);
 358 #else
 359         synchronize_irq();
 360 #endif
 361         LM_DisableInterrupt(&pUmDevice->lm_dev);
 362 }
 363
 364 void
 365 bcm5700_intr_on(PUM_DEVICE_BLOCK pUmDevice)
 366 {
 367         if (atomic_dec_and_test(&pUmDevice->intr_sem)) {
 368                 LM_EnableInterrupt(&pUmDevice->lm_dev);
 369         }
 370 }
 371
 372
 373 int MM_Packet_Desc_Size = sizeof(UM_PACKET);
 374
 375 #if defined(MODULE)
 376 MODULE_AUTHOR("Michael Chan <mchan at broadcom dot com> and Gary Zambrano <zambrano at broadcom dot com>");
 377 MODULE_DESCRIPTION("BCM5700 Driver");
 378 MODULE_LICENSE("GPL");
 379
 380 #if (LINUX_VERSION_CODE < 0x020605)
 381
 382 MODULE_PARM(debug, "i");
 383 MODULE_PARM(msglevel, "i");
 384 MODULE_PARM(activate_gpio, "0-15i");
 385 MODULE_PARM(line_speed, "1-" __MODULE_STRING(MAX_UNITS) "i");
 386 MODULE_PARM(auto_speed, "1-" __MODULE_STRING(MAX_UNITS) "i");
 387 MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
 388 MODULE_PARM(rx_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
 389 MODULE_PARM(tx_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
 390 MODULE_PARM(auto_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
 391 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
 392 MODULE_PARM(mtu, "1-" __MODULE_STRING(MAX_UNITS) "i");
 393 #endif
 394 MODULE_PARM(tx_checksum, "1-" __MODULE_STRING(MAX_UNITS) "i");
 395 MODULE_PARM(rx_checksum, "1-" __MODULE_STRING(MAX_UNITS) "i");
 396 MODULE_PARM(scatter_gather, "1-" __MODULE_STRING(MAX_UNITS) "i");
 397 MODULE_PARM(tx_pkt_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
 398 MODULE_PARM(rx_std_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
 399 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
 400 MODULE_PARM(rx_jumbo_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
 401 #endif
 402 #ifdef BCM_INT_COAL
 403 MODULE_PARM(adaptive_coalesce, "1-" __MODULE_STRING(MAX_UNITS) "i");
 404 MODULE_PARM(rx_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
 405 MODULE_PARM(rx_max_coalesce_frames, "1-" __MODULE_STRING(MAX_UNITS) "i");
 406 MODULE_PARM(tx_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
 407 MODULE_PARM(tx_max_coalesce_frames, "1-" __MODULE_STRING(MAX_UNITS) "i");
 408 MODULE_PARM(stats_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
 409 #endif
 410 #ifdef BCM_WOL
 411 MODULE_PARM(enable_wol, "1-" __MODULE_STRING(MAX_UNITS) "i");
 412 #endif
 413 #ifdef BCM_TSO
 414 MODULE_PARM(enable_tso, "1-" __MODULE_STRING(MAX_UNITS) "i");
 415 #endif
 416 #ifdef BCM_NIC_SEND_BD
 417 MODULE_PARM(nic_tx_bd, "1-" __MODULE_STRING(MAX_UNITS) "i");
 418 #endif
 419 #ifdef BCM_ASF
 420 MODULE_PARM(vlan_tag_mode, "1-" __MODULE_STRING(MAX_UNITS) "i");
 421 #endif
 422 MODULE_PARM(delay_link, "1-" __MODULE_STRING(MAX_UNITS) "i");
 423 MODULE_PARM(disable_d3hot, "1-" __MODULE_STRING(MAX_UNITS) "i");
 424
 425 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
 426 MODULE_PARM(disable_msi, "1-" __MODULE_STRING(MAX_UNITS) "i");
 427 #endif
 428
 429 #else /* parms*/
 430
 431 #if (LINUX_VERSION_CODE >= 0x020605) && (LINUX_VERSION_CODE < 0x02060a)
 432
 433 static int var;
 434
 435 #define numvar var
 436
 437 #endif
 438
 439 #if (LINUX_VERSION_CODE >= 0x2060a)
 440
 441 #define numvar NULL
 442
 443 #endif
 444
 445 module_param_array(line_speed, int, numvar, 0);
 446 module_param_array(auto_speed, int, numvar, 0);
 447 module_param_array(full_duplex, int, numvar, 0);
 448 module_param_array(rx_flow_control, int, numvar, 0);
 449 module_param_array(tx_flow_control, int, numvar, 0);
 450 module_param_array(auto_flow_control, int, numvar, 0);
 451 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
 452 module_param_array(mtu, int, numvar, 0);
 453 #endif
 454 module_param_array(tx_checksum, int, numvar, 0);
 455 module_param_array(rx_checksum, int, numvar, 0);
 456 module_param_array(scatter_gather, int, numvar, 0);
 457 module_param_array(tx_pkt_desc_cnt, int, numvar, 0);
 458 module_param_array(rx_std_desc_cnt, int, numvar, 0);
 459 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
 460 module_param_array(rx_jumbo_desc_cnt, int, numvar, 0);
 461 #endif
 462 #ifdef BCM_INT_COAL
 463 module_param_array(adaptive_coalesce, int, numvar, 0);
 464 module_param_array(rx_coalesce_ticks, int, numvar, 0);
 465 module_param_array(rx_max_coalesce_frames, int, numvar, 0);
 466 module_param_array(tx_coalesce_ticks, int, numvar, 0);
 467 module_param_array(tx_max_coalesce_frames, int, numvar, 0);
 468 module_param_array(stats_coalesce_ticks, int, numvar, 0);
 469 #endif
 470 #ifdef BCM_WOL
 471 module_param_array(enable_wol, int, numvar, 0);
 472 #endif
 473 #ifdef BCM_TSO
 474 module_param_array(enable_tso, int, numvar, 0);
 475 #endif
 476 #ifdef BCM_NIC_SEND_BD
 477 module_param_array(nic_tx_bd, int, numvar, 0);
 478 #endif
 479 #ifdef BCM_ASF
 480 module_param_array(vlan_tag_mode, int, numvar, 0);
 481 #endif
 482 module_param_array(delay_link, int, numvar, 0);
 483 module_param_array(disable_d3hot, int, numvar, 0);
 484
 485 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
 486 module_param_array(disable_msi, int, numvar, 0);
 487 #endif
 488
 489
 490 #endif /* params */
 491
 492
 493 #endif
 494
 495 #define RUN_AT(x) (jiffies + (x))
 496
 497 char kernel_version[] = UTS_RELEASE;
 498
 499 #define PCI_SUPPORT_VER2
 500
 501 #if !defined(CAP_NET_ADMIN)
 502 #define capable(CAP_XXX) (suser())
 503 #endif
 504
 505 #define tigon3_debug debug
 506 #if TIGON3_DEBUG
 507 static int tigon3_debug = TIGON3_DEBUG;
 508 #else
 509 static int tigon3_debug = 0;
 510 #endif
 511 static int msglevel = 0xdeadbeef;
 512 int b57_msg_level;
 513
 514 int bcm5700_open(struct net_device *dev);
 515 STATIC void bcm5700_timer(unsigned long data);
 516 STATIC void bcm5700_stats_timer(unsigned long data);
 517 STATIC void bcm5700_reset(struct net_device *dev);
 518 STATIC int bcm5700_start_xmit(struct sk_buff *skb, struct net_device *dev);
 519 STATIC irqreturn_t bcm5700_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
 520 #ifdef BCM_TASKLET
 521 STATIC void bcm5700_tasklet(unsigned long data);
 522 #endif
 523 STATIC int bcm5700_close(struct net_device *dev);
 524 STATIC struct net_device_stats *bcm5700_get_stats(struct net_device *dev);
 525 STATIC int bcm5700_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 526 STATIC void bcm5700_do_rx_mode(struct net_device *dev);
 527 STATIC void bcm5700_set_rx_mode(struct net_device *dev);
 528 STATIC int bcm5700_set_mac_addr(struct net_device *dev, void *p);
 529 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
 530 STATIC int bcm5700_change_mtu(struct net_device *dev, int new_mtu);
 531 #endif
 532 #ifdef BCM_NAPI_RXPOLL
 533 STATIC int bcm5700_poll(struct net_device *dev, int *budget);
 534 #endif
 535 STATIC int replenish_rx_buffers(PUM_DEVICE_BLOCK pUmDevice, int max);
 536 STATIC int bcm5700_freemem(struct net_device *dev);
 537 #ifdef BCM_INT_COAL
 538 #ifndef BCM_NAPI_RXPOLL
 539 STATIC int bcm5700_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice);
 540 #endif
 541 #endif
 542 STATIC void bcm5700_set_vlan_mode(UM_DEVICE_BLOCK *pUmDevice);
 543 STATIC int bcm5700_init_counters(PUM_DEVICE_BLOCK pUmDevice);
 544 #ifdef BCM_VLAN
 545 STATIC void bcm5700_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp);
 546 STATIC void bcm5700_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid);
 547 #endif
 548 void bcm5700_shutdown(UM_DEVICE_BLOCK *pUmDevice);
 549 void bcm5700_free_remaining_rx_bufs(UM_DEVICE_BLOCK *pUmDevice);
 550 void bcm5700_validate_param_range(UM_DEVICE_BLOCK *pUmDevice, int *param,
 551         char *param_name, int min, int max, int deflt);
 552
 553 static int bcm5700_notify_reboot(struct notifier_block *this, unsigned long event, void *unused);
 554 static struct notifier_block bcm5700_reboot_notifier = {
 555         bcm5700_notify_reboot,
 556         NULL,
 557         0
 558 };
 559
 560 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
 561 STATIC void poll_bcm5700(struct net_device *dev);
 562 #endif
 563
 564 /* A list of all installed bcm5700 devices. */
 565 static struct net_device *root_tigon3_dev = NULL;
 566
 567 #if defined(CONFIG_SPARC64) || defined(CONFIG_X86_64) ||defined(CONFIG_PPC64)
 568
 569 #endif
 570
 571 typedef enum {
 572         BCM5700A6 = 0,
 573         BCM5700T6,
 574         BCM5700A9,
 575         BCM5700T9,
 576         BCM5700,
 577         BCM5701A5,
 578         BCM5701T1,
 579         BCM5701T8,
 580         BCM5701A7,
 581         BCM5701A10,
 582         BCM5701A12,
 583         BCM5701,
 584         BCM5702,
 585         BCM5703,
 586         BCM5703A31,
 587         BCM5703ARBUCKLE,
 588         TC996T,
 589         TC996ST,
 590         TC996SSX,
 591         TC996SX,
 592         TC996BT,
 593         TC997T,
 594         TC997SX,
 595         TC1000T,
 596         TC1000BT,
 597         TC940BR01,
 598         TC942BR01,
 599         TC998T,
 600         TC998SX,
 601         TC999T,
 602         NC6770,
 603         NC1020,
 604         NC150T,
 605         NC7760,
 606         NC7761,
 607         NC7770,
 608         NC7771,
 609         NC7780,
 610         NC7781,
 611         NC7772,
 612         NC7782,
 613         NC7783,
 614         NC320T,
 615         NC320I,
 616         NC325I,
 617         NC324I,
 618         NC326I,
 619         BCM5704CIOBE,
 620         BCM5704,
 621         BCM5704S,
 622         BCM5705,
 623         BCM5705M,
 624         BCM5705F,
 625         BCM5901,
 626         BCM5782,
 627         BCM5788,
 628         BCM5789,
 629         BCM5750,
 630         BCM5750M,
 631         BCM5720,
 632         BCM5751,
 633         BCM5751M,
 634         BCM5751F,
 635         BCM5721,
 636         BCM5753,
 637         BCM5753M,
 638         BCM5753F,
 639         BCM5781,
 640         BCM5752,
 641         BCM5752M,
 642         BCM5714,
 643         BCM5780,
 644         BCM5780S,
 645         BCM5715,
 646         BCM4785,
 647         BCM5903M,
 648         UNK5788
 649 } board_t;
 650
 651
 652 /* indexed by board_t, above */
 653 static struct {
 654         char *name;
 655 } board_info[] __devinitdata = {
 656         { "Broadcom BCM5700 1000Base-T" },
 657         { "Broadcom BCM5700 1000Base-SX" },
 658         { "Broadcom BCM5700 1000Base-SX" },
 659         { "Broadcom BCM5700 1000Base-T" },
 660         { "Broadcom BCM5700" },
 661         { "Broadcom BCM5701 1000Base-T" },
 662         { "Broadcom BCM5701 1000Base-T" },
 663         { "Broadcom BCM5701 1000Base-T" },
 664         { "Broadcom BCM5701 1000Base-SX" },
 665         { "Broadcom BCM5701 1000Base-T" },
 666         { "Broadcom BCM5701 1000Base-T" },
 667         { "Broadcom BCM5701" },
 668         { "Broadcom BCM5702 1000Base-T" },
 669         { "Broadcom BCM5703 1000Base-T" },
 670         { "Broadcom BCM5703 1000Base-SX" },
 671         { "Broadcom B5703 1000Base-SX" },
 672         { "3Com 3C996 10/100/1000 Server NIC" },
 673         { "3Com 3C996 10/100/1000 Server NIC" },
 674         { "3Com 3C996 Gigabit Fiber-SX Server NIC" },
 675         { "3Com 3C996 Gigabit Fiber-SX Server NIC" },
 676         { "3Com 3C996B Gigabit Server NIC" },
 677         { "3Com 3C997 Gigabit Server NIC" },
 678         { "3Com 3C997 Gigabit Fiber-SX Server NIC" },
 679         { "3Com 3C1000 Gigabit NIC" },
 680         { "3Com 3C1000B-T 10/100/1000 PCI" },
 681         { "3Com 3C940 Gigabit LOM (21X21)" },
 682         { "3Com 3C942 Gigabit LOM (31X31)" },
 683         { "3Com 3C998-T Dual Port 10/100/1000 PCI-X Server NIC" },
 684         { "3Com 3C998-SX Dual Port 1000-SX PCI-X Server NIC" },
 685         { "3Com 3C999-T Quad Port 10/100/1000 PCI-X Server NIC" },
 686         { "HP NC6770 Gigabit Server Adapter" },
 687         { "NC1020 HP ProLiant Gigabit Server Adapter 32 PCI" },
 688         { "HP ProLiant NC 150T PCI 4-port Gigabit Combo Switch Adapter" },
 689         { "HP NC7760 Gigabit Server Adapter" },
 690         { "HP NC7761 Gigabit Server Adapter" },
 691         { "HP NC7770 Gigabit Server Adapter" },
 692         { "HP NC7771 Gigabit Server Adapter" },
 693         { "HP NC7780 Gigabit Server Adapter" },
 694         { "HP NC7781 Gigabit Server Adapter" },
 695         { "HP NC7772 Gigabit Server Adapter" },
 696         { "HP NC7782 Gigabit Server Adapter" },
 697         { "HP NC7783 Gigabit Server Adapter" },
 698         { "HP ProLiant NC 320T PCI Express Gigabit Server Adapter" },
 699         { "HP ProLiant NC 320i PCI Express Gigabit Server Adapter" },
 700         { "HP NC325i Integrated Dual Port PCI Express Gigabit Server Adapter" },
 701         { "HP NC324i Integrated Dual Port PCI Express Gigabit Server Adapter" },
 702         { "HP NC326i Integrated Dual Port PCI Express Gigabit Server Adapter" },
 703         { "Broadcom BCM5704 CIOB-E 1000Base-T" },
 704         { "Broadcom BCM5704 1000Base-T" },
 705         { "Broadcom BCM5704 1000Base-SX" },
 706         { "Broadcom BCM5705 1000Base-T" },
 707         { "Broadcom BCM5705M 1000Base-T" },
 708         { "Broadcom 570x 10/100 Integrated Controller" },
 709         { "Broadcom BCM5901 100Base-TX" },
 710         { "Broadcom NetXtreme Gigabit Ethernet for hp" },
 711         { "Broadcom BCM5788 NetLink 1000Base-T" },
 712         { "Broadcom BCM5789 NetLink 1000Base-T PCI Express" },
 713         { "Broadcom BCM5750 1000Base-T PCI" },
 714         { "Broadcom BCM5750M 1000Base-T PCI" },
 715         { "Broadcom BCM5720 1000Base-T PCI" },
 716         { "Broadcom BCM5751 1000Base-T PCI Express" },
 717         { "Broadcom BCM5751M 1000Base-T PCI Express" },
 718         { "Broadcom BCM5751F 100Base-TX PCI Express" },
 719         { "Broadcom BCM5721 1000Base-T PCI Express" },
 720         { "Broadcom BCM5753 1000Base-T PCI Express" },
 721         { "Broadcom BCM5753M 1000Base-T PCI Express" },
 722         { "Broadcom BCM5753F 100Base-TX PCI Express" },
 723         { "Broadcom BCM5781 NetLink 1000Base-T PCI Express" },
 724         { "Broadcom BCM5752 1000Base-T PCI Express" },
 725         { "Broadcom BCM5752M 1000Base-T PCI Express" },
 726         { "Broadcom BCM5714 1000Base-T " },
 727         { "Broadcom BCM5780 1000Base-T" },
 728         { "Broadcom BCM5780S 1000Base-SX" },
 729         { "Broadcom BCM5715 1000Base-T " },
 730         { "Broadcom BCM4785 10/100/1000 Integrated Controller" },
 731         { "Broadcom BCM5903M Gigabit Ethernet " },
 732         { "Unknown BCM5788 Gigabit Ethernet " },
 733         { 0 }
 734         };
 735
 736 static struct pci_device_id bcm5700_pci_tbl[] __devinitdata = {
 737         {0x14e4, 0x1644, 0x14e4, 0x1644, 0, 0, BCM5700A6 },
 738         {0x14e4, 0x1644, 0x14e4, 0x2, 0, 0, BCM5700T6 },
 739         {0x14e4, 0x1644, 0x14e4, 0x3, 0, 0, BCM5700A9 },
 740         {0x14e4, 0x1644, 0x14e4, 0x4, 0, 0, BCM5700T9 },
 741         {0x14e4, 0x1644, 0x1028, 0xd1, 0, 0, BCM5700 },
 742         {0x14e4, 0x1644, 0x1028, 0x0106, 0, 0, BCM5700 },
 743         {0x14e4, 0x1644, 0x1028, 0x0109, 0, 0, BCM5700 },
 744         {0x14e4, 0x1644, 0x1028, 0x010a, 0, 0, BCM5700 },
 745         {0x14e4, 0x1644, 0x10b7, 0x1000, 0, 0, TC996T },
 746         {0x14e4, 0x1644, 0x10b7, 0x1001, 0, 0, TC996ST },
 747         {0x14e4, 0x1644, 0x10b7, 0x1002, 0, 0, TC996SSX },
 748         {0x14e4, 0x1644, 0x10b7, 0x1003, 0, 0, TC997T },
 749         {0x14e4, 0x1644, 0x10b7, 0x1005, 0, 0, TC997SX },
 750         {0x14e4, 0x1644, 0x10b7, 0x1008, 0, 0, TC942BR01 },
 751         {0x14e4, 0x1644, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5700 },
 752         {0x14e4, 0x1645, 0x14e4, 1, 0, 0, BCM5701A5 },
 753         {0x14e4, 0x1645, 0x14e4, 5, 0, 0, BCM5701T1 },
 754         {0x14e4, 0x1645, 0x14e4, 6, 0, 0, BCM5701T8 },
 755         {0x14e4, 0x1645, 0x14e4, 7, 0, 0, BCM5701A7 },
 756         {0x14e4, 0x1645, 0x14e4, 8, 0, 0, BCM5701A10 },
 757         {0x14e4, 0x1645, 0x14e4, 0x8008, 0, 0, BCM5701A12 },
 758         {0x14e4, 0x1645, 0x0e11, 0xc1, 0, 0, NC6770 },
 759         {0x14e4, 0x1645, 0x0e11, 0x7c, 0, 0, NC7770 },
 760         {0x14e4, 0x1645, 0x0e11, 0x85, 0, 0, NC7780 },
 761         {0x14e4, 0x1645, 0x1028, 0x0121, 0, 0, BCM5701 },
 762         {0x14e4, 0x1645, 0x10b7, 0x1004, 0, 0, TC996SX },
 763         {0x14e4, 0x1645, 0x10b7, 0x1006, 0, 0, TC996BT },
 764         {0x14e4, 0x1645, 0x10b7, 0x1007, 0, 0, TC1000T },
 765         {0x14e4, 0x1645, 0x10b7, 0x1008, 0, 0, TC940BR01 },
 766         {0x14e4, 0x1645, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5701 },
 767         {0x14e4, 0x1646, 0x14e4, 0x8009, 0, 0, BCM5702 },
 768         {0x14e4, 0x1646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
 769         {0x14e4, 0x16a6, 0x14e4, 0x8009, 0, 0, BCM5702 },
 770         {0x14e4, 0x16a6, 0x14e4, 0x000c, 0, 0, BCM5702 },
 771         {0x14e4, 0x16a6, 0x0e11, 0xbb, 0, 0, NC7760 },
 772         {0x14e4, 0x16a6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
 773         {0x14e4, 0x16c6, 0x10b7, 0x1100, 0, 0, TC1000BT },
 774         {0x14e4, 0x16c6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
 775         {0x14e4, 0x1647, 0x14e4, 0x0009, 0, 0, BCM5703 },
 776         {0x14e4, 0x1647, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
 777         {0x14e4, 0x1647, 0x14e4, 0x000b, 0, 0, BCM5703 },
 778         {0x14e4, 0x1647, 0x14e4, 0x800a, 0, 0, BCM5703 },
 779         {0x14e4, 0x1647, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
 780         {0x14e4, 0x16a7, 0x14e4, 0x0009, 0, 0, BCM5703 },
 781         {0x14e4, 0x16a7, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
 782         {0x14e4, 0x16a7, 0x14e4, 0x000b, 0, 0, BCM5703 },
 783         {0x14e4, 0x16a7, 0x14e4, 0x800a, 0, 0, BCM5703 },
 784         {0x14e4, 0x16a7, 0x0e11, 0xca, 0, 0, NC7771 },
 785         {0x14e4, 0x16a7, 0x0e11, 0xcb, 0, 0, NC7781 },
 786         {0x14e4, 0x16a7, 0x1014, 0x0281, 0, 0, BCM5703ARBUCKLE },
 787         {0x14e4, 0x16a7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
 788         {0x14e4, 0x16c7, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
 789         {0x14e4, 0x16c7, 0x0e11, 0xca, 0, 0, NC7771 },
 790         {0x14e4, 0x16c7, 0x0e11, 0xcb, 0, 0, NC7781 },
 791         {0x14e4, 0x16c7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
 792         {0x14e4, 0x1648, 0x0e11, 0xcf, 0, 0, NC7772 },
 793         {0x14e4, 0x1648, 0x0e11, 0xd0, 0, 0, NC7782 },
 794         {0x14e4, 0x1648, 0x0e11, 0xd1, 0, 0, NC7783 },
 795         {0x14e4, 0x1648, 0x10b7, 0x2000, 0, 0, TC998T },
 796         {0x14e4, 0x1648, 0x10b7, 0x3000, 0, 0, TC999T },
 797         {0x14e4, 0x1648, 0x1166, 0x1648, 0, 0, BCM5704CIOBE },
 798         {0x14e4, 0x1648, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704 },
 799         {0x14e4, 0x1649, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704S },
 800         {0x14e4, 0x16a8, 0x14e4, 0x16a8, 0, 0, BCM5704S },
 801         {0x14e4, 0x16a8, 0x10b7, 0x2001, 0, 0, TC998SX },
 802         {0x14e4, 0x16a8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704S },
 803         {0x14e4, 0x1653, 0x0e11, 0x00e3, 0, 0, NC7761 },
 804         {0x14e4, 0x1653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705 },
 805         {0x14e4, 0x1654, 0x0e11, 0x00e3, 0, 0, NC7761 },
 806         {0x14e4, 0x1654, 0x103c, 0x3100, 0, 0, NC1020 },
 807         {0x14e4, 0x1654, 0x103c, 0x3226, 0, 0, NC150T },
 808         {0x14e4, 0x1654, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705 },
 809         {0x14e4, 0x165d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705M },
 810         {0x14e4, 0x165e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705M },
 811         {0x14e4, 0x166e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705F },
 812         {0x14e4, 0x1696, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5782 },
 813         {0x14e4, 0x169c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5788 },
 814         {0x14e4, 0x169d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5789 },
 815         {0x14e4, 0x170d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5901 },
 816         {0x14e4, 0x170e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5901 },
 817         {0x14e4, 0x1676, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5750 },
 818         {0x14e4, 0x167c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5750M },
 819         {0x14e4, 0x1677, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751 },
 820         {0x14e4, 0x167d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751M },
 821         {0x14e4, 0x167e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751F },
 822         {0x14e4, 0x1658, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5720 },
 823         {0x14e4, 0x1659, 0x103c, 0x7031, 0, 0, NC320T },
 824         {0x14e4, 0x1659, 0x103c, 0x7032, 0, 0, NC320T },
 825         {0x14e4, 0x166a, 0x103c, 0x7035, 0, 0, NC325I },
 826         {0x14e4, 0x166b, 0x103c, 0x7036, 0, 0, NC325I },
 827         {0x14e4, 0x1668, 0x103c, 0x7039, 0, 0, NC324I },
 828         {0x14e4, 0x1669, 0x103c, 0x703a, 0, 0, NC324I },
 829         {0x14e4, 0x1678, 0x103c, 0x703e, 0, 0, NC326I },
 830         {0x14e4, 0x1679, 0x103c, 0x703c, 0, 0, NC326I },
 831         {0x14e4, 0x1659, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5721 },
 832         {0x14e4, 0x16f7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753 },
 833         {0x14e4, 0x16fd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753M },
 834         {0x14e4, 0x16fe, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753F },
 835         {0x14e4, 0x16dd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5781 },
 836         {0x14e4, 0x1600, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5752 },
 837         {0x14e4, 0x1601, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5752M },
 838         {0x14e4, 0x1668, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5714 },
 839         {0x14e4, 0x166a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5780 },
 840         {0x14e4, 0x166b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5780S },
 841         {0x14e4, 0x1678, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5715 },
 842         {0x14e4, 0x471f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM4785 },
 843         {0x14e4, 0x16ff, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5903M },
 844         {0x173b, 0x03ed, PCI_ANY_ID, PCI_ANY_ID, 0, 0, UNK5788 },
 845         {0,}
 846         };
 847
 848 MODULE_DEVICE_TABLE(pci, bcm5700_pci_tbl);
 849
 850 #if (LINUX_VERSION_CODE >= 0x2060a)
 851         static struct pci_device_id pci_AMD762id[]={
 852                 { PCI_DEVICE(PCI_VENDOR_ID_AMD,
 853                         PCI_DEVICE_ID_AMD_FE_GATE_700C) },
 854                 { }
 855         };
 856 #endif
 857
 858 static int sbgige = -1;
 859
 860 /*******************************************************************************
 861  *******************************************************************************
 862 */
 863
 864 int get_csum_flag(LM_UINT32 ChipRevId)
 865 {
 866         return NETIF_F_IP_CSUM;
 867 }
 868
 869 /*******************************************************************************
 870  *******************************************************************************
 871
 872    This function returns true if the device passed to it is attached to an
 873    ICH-ICH4. If the chip is not attached to an ICH, or is attached to an ICH5
 874    or newer, it returns false.
 875
 876    This function determines which bridge it is attached to by scaning the pci
 877    bus looking for bridge chips (hdr_type=1). When a bridge chip is detected,
 878    the bridge's subordinate's secondary bus number is compared with this
 879    devices bus number. If they match, then the device is attached to this
 880    bridge. The bridge's device id is compared to a list of known device ids for
 881    ICH-ICH4. Since many older ICH's (ICH2-ICH7) share the same device id, the
 882    chip revision must also be checked to determine if the chip is older than an
 883    ICH5.
 884
 885    To scan the bus, one of two functions is used depending on the kernel
 886    version. For 2.4 kernels, the pci_find_device function is used. This
 887    function has been depricated in the 2.6 kernel and replaced with the
 888    fucntion pci_get_device. The macro walk_pci_bus determines which function to
 889    use when the driver is built.
 890 */
 891
 892 #if (LINUX_VERSION_CODE >= 0x2060a)
 893 #define walk_pci_bus(d)         while ((d = pci_get_device( \
 894                                         PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
 895
 896 #define unwalk_pci_bus(d)       pci_dev_put(d)
 897
 898 #else
 899 #define walk_pci_bus(d)         while ((d = pci_find_device( \
 900                                         PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
 901 #define unwalk_pci_bus(d)
 902
 903 #endif
 904
 905 #define ICH5_CHIP_VERSION       0xc0
 906
 907 static struct pci_device_id pci_ICHtable[] = {
 908         {0x8086, 0x2418}, /* PCI_DEVICE_ID_INTEL_82801AA_8  */
 909         {0x8086, 0x2428}, /* PCI_DEVICE_ID_INTEL_82801AB_8  */
 910         {0x8086, 0x244e}, /* PCI_DEVICE_ID_INTEL_82801BA_6  */
 911         {0x8086, 0x2448}, /* PCI_DEVICE_ID_INTEL_82801BA_11 */
 912         {0, 0}
 913 };
 914
 915 int attached_to_ICH4_or_older( struct pci_dev *pdev)
 916 {
 917         struct pci_dev *tmp_pdev = NULL;
 918         struct pci_device_id *ich_table;
 919         u8 chip_rev;
 920
 921         walk_pci_bus (tmp_pdev) {
 922                 if ((tmp_pdev->hdr_type == 1) &&
 923                    (tmp_pdev->subordinate != NULL) &&
 924                    (tmp_pdev->subordinate->secondary == pdev->bus->number)) {
 925
 926                         ich_table = pci_ICHtable;
 927
 928                         while (ich_table->vendor) {
 929                                 if ((ich_table->vendor == tmp_pdev->vendor) &&
 930                                     (ich_table->device == tmp_pdev->device)) {
 931
 932                                         pci_read_config_byte( tmp_pdev,
 933                                                 PCI_REVISION_ID, &chip_rev);
 934
 935                                         if (chip_rev < ICH5_CHIP_VERSION) {
 936                                                 unwalk_pci_bus( tmp_pdev);
 937                                                 return 1;
 938                                         }
 939                                 }
 940                                 ich_table++;
 941                         }
 942                 }
 943         }
 944         return 0;
 945 }
 946
 947 static void robo_set_power_mode(void *h)
 948 {
 949         //int status = 0;
 950         int i;
 951         //uint8 mode8;
 952         //uint16 mode16;
 953         uint32 flags = 0, temp32 = 0,val32 = 0, savephyaddr = 0;
 954         PUM_DEVICE_BLOCK pudev = (PUM_DEVICE_BLOCK)h;
 955         PLM_DEVICE_BLOCK pdev = &pudev->lm_dev;
 956
 957         /*Brcm,Alex,2006.7.20. Adding Phy power mode setting*/
 958         BCM5700_PHY_LOCK(pudev, flags);
 959         savephyaddr = pdev->PhyAddr;
 960
 961         for(i = 0; i < 8; i++)
 962         {
 963                 pdev->PhyAddr = i;
 964                 temp32 = 0x2007;
 965                 LM_WritePhy(pdev, 0x18, temp32);
 966                 LM_ReadPhy(pdev, 0x18, &val32);
 967 //              printk(KERN_DEBUG "Alex: port = %x, read value =%x\n",i, val32);
 968                 temp32 = 0xc042;
 969                 LM_WritePhy(pdev, 0x18, temp32);
 970                 /*Read back*/
 971                 temp32 = 0x2007;
 972                 val32 = 0;
 973                 LM_WritePhy(pdev, 0x18, temp32);
 974                 LM_ReadPhy(pdev, 0x18, &val32);
 975 //              printk(KERN_ERR "Alex: read back value =%x\n",val32);
 976         }
 977
 978         pdev->PhyAddr = savephyaddr;
 979         BCM5700_PHY_UNLOCK(pudev, flags);
 980
 981         /*end of Brcm,Alex,2006.7.20. Adding Phy power mode setting*/
 982
 983 }
 984
 985 static int
 986 __devinit bcm5700_init_board(struct pci_dev *pdev, struct net_device **dev_out, int board_idx)
 987 {
 988         struct net_device *dev;
 989         PUM_DEVICE_BLOCK pUmDevice;
 990         PLM_DEVICE_BLOCK pDevice;
 991         bool rgmii = FALSE;
 992         sb_t *sbh = NULL;
 993         int rc;
 994
 995         *dev_out = NULL;
 996
 997         /* dev zeroed in init_etherdev */
 998 #if (LINUX_VERSION_CODE >= 0x20600)
 999         dev = alloc_etherdev(sizeof(*pUmDevice));
1000 #else
1001         dev = init_etherdev(NULL, sizeof(*pUmDevice));
1002 #endif
1003         if (dev == NULL) {
1004                 printk(KERN_ERR "%s: unable to alloc new ethernet\n", bcm5700_driver);
1005                 return -ENOMEM;
1006         }
1007         SET_MODULE_OWNER(dev);
1008 #if (LINUX_VERSION_CODE >= 0x20600)
1009         SET_NETDEV_DEV(dev, &pdev->dev);
1010 #endif
1011         pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
1012
1013         /* enable device (incl. PCI PM wakeup), and bus-mastering */
1014         rc = pci_enable_device(pdev);
1015         if (rc)
1016                 goto err_out;
1017
1018         /* init core specific stuff */
1019         if (pdev->device == T3_PCI_DEVICE_ID(T3_PCI_ID_BCM471F)) {
1020                 sbh = sb_kattach(SB_OSH);
1021                 sb_gige_init(sbh, ++sbgige, &rgmii);
1022         }
1023
1024         rc = pci_request_regions(pdev, bcm5700_driver);
1025         if (rc) {
1026                 if (!sbh)
1027                         goto err_out;
1028                 printk(KERN_INFO "bcm5700_init_board: pci_request_regions returned error %d\n"
1029                                  "This may be because the region is already requested by"
1030                                  " the SMBus driver. Ignore the PCI error messages.\n", rc);
1031         }
1032
1033         pci_set_master(pdev);
1034
1035         if (pci_set_dma_mask(pdev, BCM_64BIT_DMA_MASK) == 0) {
1036                 pUmDevice->using_dac = 1;
1037                 if (pci_set_consistent_dma_mask(pdev, BCM_64BIT_DMA_MASK) != 0) {
1038                         printk(KERN_ERR "pci_set_consistent_dma_mask failed\n");
1039                         pci_release_regions(pdev);
1040                         goto err_out;
1041                 }
1042         } else if (pci_set_dma_mask(pdev, BCM_32BIT_DMA_MASK) == 0) {
1043                 pUmDevice->using_dac = 0;
1044         } else {
1045                 printk(KERN_ERR "System does not support DMA\n");
1046                 pci_release_regions(pdev);
1047                 goto err_out;
1048         }
1049
1050         pUmDevice->dev = dev;
1051         pUmDevice->pdev = pdev;
1052         pUmDevice->mem_list_num = 0;
1053         pUmDevice->next_module = root_tigon3_dev;
1054         pUmDevice->index = board_idx;
1055         pUmDevice->sbh = (void *)sbh;
1056         root_tigon3_dev = dev;
1057
1058         spin_lock_init(&pUmDevice->global_lock);
1059
1060         spin_lock_init(&pUmDevice->undi_lock);
1061
1062         spin_lock_init(&pUmDevice->phy_lock);
1063
1064         pDevice = &pUmDevice->lm_dev;
1065         pDevice->Flags = 0;
1066         pDevice->FunctNum = PCI_FUNC(pUmDevice->pdev->devfn);
1067         pUmDevice->boardflags = getintvar(NULL, "boardflags");
1068         if (sbh) {
1069                 if (pUmDevice->boardflags & BFL_ENETROBO)
1070                         pDevice->Flags |= ROBO_SWITCH_FLAG;
1071                 pDevice->Flags |= rgmii ? RGMII_MODE_FLAG : 0;
1072                 if (sb_chip(sbh) == BCM4785_CHIP_ID && sb_chiprev(sbh) < 2)
1073                         pDevice->Flags |= ONE_DMA_AT_ONCE_FLAG;
1074                 pDevice->Flags |= SB_CORE_FLAG;
1075                 if (sb_chip(sbh) == BCM4785_CHIP_ID)
1076                         pDevice->Flags |= FLUSH_POSTED_WRITE_FLAG;
1077         }
1078
1079 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
1080         if (board_idx < MAX_UNITS) {
1081                 bcm5700_validate_param_range(pUmDevice, &mtu[board_idx], "mtu", 1500, 9000, 1500);
1082                 dev->mtu = mtu[board_idx];
1083         }
1084 #endif
1085
1086         if (attached_to_ICH4_or_older(pdev)) {
1087                 pDevice->Flags |= UNDI_FIX_FLAG;
1088         }
1089
1090 #if (LINUX_VERSION_CODE >= 0x2060a)
1091         if (pci_dev_present(pci_AMD762id)) {
1092                 pDevice->Flags |= FLUSH_POSTED_WRITE_FLAG;
1093                 pDevice->Flags &= ~NIC_SEND_BD_FLAG;
1094         }
1095 #else
1096         if (pci_find_device(0x1022, 0x700c, NULL)) {
1097                 /* AMD762 writes I/O out of order */
1098                 /* Setting bit 1 in 762's register 0x4C still doesn't work */
1099                 /* in all cases */
1100                 pDevice->Flags |= FLUSH_POSTED_WRITE_FLAG;
1101                 pDevice->Flags &= ~NIC_SEND_BD_FLAG;
1102         }
1103 #endif
1104         if (LM_GetAdapterInfo(pDevice) != LM_STATUS_SUCCESS) {
1105                 rc = -ENODEV;
1106                 goto err_out_unmap;
1107         }
1108
1109         if (pDevice->Flags & ROBO_SWITCH_FLAG) {
1110                 robo_info_t     *robo;
1111
1112                 if ((robo = bcm_robo_attach(sbh, pDevice, dev->name, NULL,
1113                                             robo_miird, robo_miiwr)) == NULL) {
1114                         B57_ERR(("robo_setup: failed to attach robo switch \n"));
1115                         goto robo_fail;
1116                 }
1117
1118                 if (bcm_robo_enable_device(robo)) {
1119                         B57_ERR(("robo_setup: failed to enable robo switch \n"));
1120 robo_fail:
1121                         bcm_robo_detach(robo);
1122                         rc = -ENODEV;
1123                         goto err_out_unmap;
1124                 }
1125
1126                 /* 5397 power mode setting */
1127                 robo_set_power_mode(robo->h);
1128
1129                 pUmDevice->robo = (void *)robo;
1130         }
1131
1132         if ((pDevice->Flags & JUMBO_CAPABLE_FLAG) == 0) {
1133                 if (dev->mtu > 1500) {
1134                         dev->mtu = 1500;
1135                         printk(KERN_WARNING
1136                                "%s-%d: Jumbo mtu sizes not supported, using mtu=1500\n",
1137                                bcm5700_driver, pUmDevice->index);
1138                 }
1139         }
1140
1141         pUmDevice->do_global_lock = 0;
1142         if (T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) {
1143                 /* The 5700 chip works best without interleaved register */
1144                 /* accesses on certain machines. */
1145                 pUmDevice->do_global_lock = 1;
1146         }
1147
1148         if ((T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5701) &&
1149                 ((pDevice->PciState & T3_PCI_STATE_NOT_PCI_X_BUS) == 0)) {
1150
1151                 pUmDevice->rx_buf_align = 0;
1152         } else {
1153                 pUmDevice->rx_buf_align = 2;
1154         }
1155         dev->mem_start = pci_resource_start(pdev, 0);
1156         dev->mem_end = dev->mem_start + sizeof(T3_STD_MEM_MAP);
1157         dev->irq = pdev->irq;
1158
1159         *dev_out = dev;
1160         return 0;
1161
1162 err_out_unmap:
1163         pci_release_regions(pdev);
1164         bcm5700_freemem(dev);
1165
1166 err_out:
1167 #if (LINUX_VERSION_CODE < 0x020600)
1168         unregister_netdev(dev);
1169         kfree(dev);
1170 #else
1171         free_netdev(dev);
1172 #endif
1173         return rc;
1174 }
1175
1176 static int __devinit
1177 bcm5700_print_ver(void)
1178 {
1179         printk(KERN_INFO "Broadcom Gigabit Ethernet Driver %s ",
1180                 bcm5700_driver);
1181         printk("ver. %s %s\n", bcm5700_version, bcm5700_date);
1182         return 0;
1183 }
1184
1185 static int __devinit
1186 bcm5700_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
1187 {
1188         struct net_device *dev = NULL;
1189         PUM_DEVICE_BLOCK pUmDevice;
1190         PLM_DEVICE_BLOCK pDevice;
1191         int i;
1192         static int board_idx = -1;
1193         static int printed_version = 0;
1194         struct pci_dev *pci_dev;
1195
1196         board_idx++;
1197
1198         if (!printed_version) {
1199                 bcm5700_print_ver();
1200                 printed_version = 1;
1201         }
1202
1203         i = bcm5700_init_board(pdev, &dev, board_idx);
1204         if (i < 0) {
1205                 return i;
1206         }
1207
1208         if (dev == NULL)
1209                 return -ENOMEM;
1210
1211 #ifdef BCM_IOCTL32
1212         if (atomic_read(&bcm5700_load_count) == 0) {
1213                 register_ioctl32_conversion(SIOCNICE, bcm5700_ioctl32);
1214         }
1215         atomic_inc(&bcm5700_load_count);
1216 #endif
1217         dev->open = bcm5700_open;
1218         dev->hard_start_xmit = bcm5700_start_xmit;
1219         dev->stop = bcm5700_close;
1220         dev->get_stats = bcm5700_get_stats;
1221         dev->set_multicast_list = bcm5700_set_rx_mode;
1222         dev->do_ioctl = bcm5700_ioctl;
1223         dev->set_mac_address = &bcm5700_set_mac_addr;
1224 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
1225         dev->change_mtu = &bcm5700_change_mtu;
1226 #endif
1227 #if (LINUX_VERSION_CODE >= 0x20400)
1228         dev->tx_timeout = bcm5700_reset;
1229         dev->watchdog_timeo = TX_TIMEOUT;
1230 #endif
1231 #ifdef BCM_VLAN
1232         dev->vlan_rx_register = &bcm5700_vlan_rx_register;
1233         dev->vlan_rx_kill_vid = &bcm5700_vlan_rx_kill_vid;
1234 #endif
1235 #ifdef BCM_NAPI_RXPOLL
1236         dev->poll = bcm5700_poll;
1237         dev->weight = 64;
1238 #endif
1239
1240         pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
1241         pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1242
1243         dev->base_addr = pci_resource_start(pdev, 0);
1244         dev->irq = pdev->irq;
1245 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
1246         dev->poll_controller = poll_bcm5700;
1247 #endif
1248
1249 #if (LINUX_VERSION_CODE >= 0x20600)
1250         if ((i = register_netdev(dev))) {
1251                 printk(KERN_ERR "%s: Cannot register net device\n",
1252                         bcm5700_driver);
1253                 if (pUmDevice->lm_dev.pMappedMemBase)
1254                         iounmap(pUmDevice->lm_dev.pMappedMemBase);
1255                 pci_release_regions(pdev);
1256                 bcm5700_freemem(dev);
1257                 free_netdev(dev);
1258                 return i;
1259         }
1260 #endif
1261
1262
1263         pci_set_drvdata(pdev, dev);
1264
1265         memcpy(dev->dev_addr, pDevice->NodeAddress, 6);
1266         pUmDevice->name = board_info[ent->driver_data].name,
1267         printk(KERN_INFO "%s: %s found at mem %lx, IRQ %d, ",
1268                 dev->name, pUmDevice->name, dev->base_addr,
1269                 dev->irq);
1270         printk("node addr ");
1271         for (i = 0; i < 6; i++) {
1272                 printk("%2.2x", dev->dev_addr[i]);
1273         }
1274         printk("\n");
1275
1276         printk(KERN_INFO "%s: ", dev->name);
1277         if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5400_PHY_ID)
1278                 printk("Broadcom BCM5400 Copper ");
1279         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5401_PHY_ID)
1280                 printk("Broadcom BCM5401 Copper ");
1281         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5411_PHY_ID)
1282                 printk("Broadcom BCM5411 Copper ");
1283         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5461_PHY_ID)
1284                 printk("Broadcom BCM5461 Copper ");
1285         else if (((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5701_PHY_ID) &&
1286                 !(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
1287                 printk("Broadcom BCM5701 Integrated Copper ");
1288         }
1289         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5703_PHY_ID) {
1290                 printk("Broadcom BCM5703 Integrated ");
1291                 if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
1292                         printk("SerDes ");
1293                 else
1294                         printk("Copper ");
1295         }
1296         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5704_PHY_ID) {
1297                 printk("Broadcom BCM5704 Integrated ");
1298                 if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
1299                         printk("SerDes ");
1300                 else
1301                         printk("Copper ");
1302         }
1303         else if (pDevice->PhyFlags & PHY_IS_FIBER){
1304             if(( pDevice->PhyId & PHY_ID_MASK ) == PHY_BCM5780_PHY_ID)
1305                 printk("Broadcom BCM5780S Integrated Serdes ");
1306
1307         }
1308         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5705_PHY_ID)
1309                 printk("Broadcom BCM5705 Integrated Copper ");
1310         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5750_PHY_ID)
1311                 printk("Broadcom BCM5750 Integrated Copper ");
1312
1313         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5714_PHY_ID)
1314                 printk("Broadcom BCM5714 Integrated Copper ");
1315         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5780_PHY_ID)
1316                 printk("Broadcom BCM5780 Integrated Copper ");
1317
1318         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5752_PHY_ID)
1319                 printk("Broadcom BCM5752 Integrated Copper ");
1320         else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM8002_PHY_ID)
1321                 printk("Broadcom BCM8002 SerDes ");
1322         else if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
1323                 if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) {
1324                         printk("Broadcom BCM5703 Integrated SerDes ");
1325                 }
1326                 else if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
1327                         printk("Broadcom BCM5704 Integrated SerDes ");
1328                 }
1329                 else {
1330                         printk("Agilent HDMP-1636 SerDes ");
1331                 }
1332         }
1333         else {
1334                 printk("Unknown ");
1335         }
1336         printk("transceiver found\n");
1337
1338 #if (LINUX_VERSION_CODE >= 0x20400)
1339         if (scatter_gather[board_idx]) {
1340                 dev->features |= NETIF_F_SG;
1341                 if (pUmDevice->using_dac && !(pDevice->Flags & BCM5788_FLAG))
1342                         dev->features |= NETIF_F_HIGHDMA;
1343         }
1344         if ((pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TX_TCP_CHECKSUM) &&
1345                 tx_checksum[board_idx]) {
1346
1347                 dev->features |= get_csum_flag( pDevice->ChipRevId);
1348         }
1349 #ifdef BCM_VLAN
1350         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1351 #endif
1352 #ifdef BCM_TSO
1353         /* On 5714/15/80 chips, Jumbo Frames and TSO cannot both be enabled at
1354            the same time. Since only one of these features can be enable at a
1355            time, we'll enable only Jumbo Frames and disable TSO when the user
1356            tries to enable both.
1357         */
1358         dev->features &= ~NETIF_F_TSO;
1359
1360         if ((pDevice->TaskToOffload & LM_TASK_OFFLOAD_TCP_SEGMENTATION) &&
1361             (enable_tso[board_idx])) {
1362                 if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
1363                    (dev->mtu > 1500)) {
1364                         printk(KERN_ALERT "%s: Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
1365                 } else {
1366                         dev->features |= NETIF_F_TSO;
1367                 }
1368         }
1369 #endif
1370         printk(KERN_INFO "%s: Scatter-gather %s, 64-bit DMA %s, Tx Checksum %s, ",
1371                         dev->name,
1372                         (char *) ((dev->features & NETIF_F_SG) ? "ON" : "OFF"),
1373                         (char *) ((dev->features & NETIF_F_HIGHDMA) ? "ON" : "OFF"),
1374                         (char *) ((dev->features & get_csum_flag( pDevice->ChipRevId)) ? "ON" : "OFF"));
1375 #endif
1376         if ((pDevice->ChipRevId != T3_CHIP_ID_5700_B0) &&
1377                 rx_checksum[board_idx])
1378                 printk("Rx Checksum ON");
1379         else
1380                 printk("Rx Checksum OFF");
1381 #ifdef BCM_VLAN
1382         printk(", 802.1Q VLAN ON");
1383 #endif
1384 #ifdef BCM_TSO
1385         if (dev->features & NETIF_F_TSO) {
1386                 printk(", TSO ON");
1387         }
1388         else
1389 #endif
1390 #ifdef BCM_NAPI_RXPOLL
1391         printk(", NAPI ON");
1392 #endif
1393         printk("\n");
1394
1395         register_reboot_notifier(&bcm5700_reboot_notifier);
1396 #ifdef BCM_TASKLET
1397         tasklet_init(&pUmDevice->tasklet, bcm5700_tasklet,
1398                 (unsigned long) pUmDevice);
1399 #endif
1400         if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
1401                 if ((REG_RD(pDevice, PciCfg.DualMacCtrl) &
1402                         T3_DUAL_MAC_CH_CTRL_MASK) == 3) {
1403
1404 printk(KERN_WARNING "%s: Device is configured for Hardware Based Teaming which is not supported with this operating system. Please consult the user diagnostic guide to disable Turbo Teaming.\n", dev->name);
1405                 }
1406         }
1407
1408 #if (LINUX_VERSION_CODE > 0x20605)
1409
1410         if ((pci_dev = pci_get_device(0x1022, 0x700c, NULL)))
1411 #else
1412         if ((pci_dev = pci_find_device(0x1022, 0x700c, NULL)))
1413 #endif
1414         {
1415                 u32 val;
1416
1417                 /* Found AMD 762 North bridge */
1418                 pci_read_config_dword(pci_dev, 0x4c, &val);
1419                 if ((val & 0x02) == 0) {
1420                         pci_write_config_dword(pci_dev, 0x4c, val | 0x02);
1421                         printk(KERN_INFO "%s: Setting AMD762 Northbridge to enable PCI ordering compliance\n", bcm5700_driver);
1422                 }
1423         }
1424
1425 #if (LINUX_VERSION_CODE > 0x20605)
1426
1427         pci_dev_put(pci_dev);
1428
1429 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
1430
1431         if ((pci_dev = pci_get_device(0x1066, 0x0017, NULL))) {
1432                 bcm_msi_chipset_bug = 1;
1433         }
1434         pci_dev_put(pci_dev);
1435 #endif
1436 #endif
1437
1438         return 0;
1439 }
1440
1441
1442 static void __devexit
1443 bcm5700_remove_one (struct pci_dev *pdev)
1444 {
1445         struct net_device *dev = pci_get_drvdata (pdev);
1446         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1447
1448 #ifdef BCM_IOCTL32
1449         atomic_dec(&bcm5700_load_count);
1450         if (atomic_read(&bcm5700_load_count) == 0)
1451                 unregister_ioctl32_conversion(SIOCNICE);
1452 #endif
1453         unregister_netdev(dev);
1454
1455         if (pUmDevice->lm_dev.pMappedMemBase)
1456                 iounmap(pUmDevice->lm_dev.pMappedMemBase);
1457
1458         pci_release_regions(pdev);
1459
1460 #if (LINUX_VERSION_CODE < 0x020600)
1461         kfree(dev);
1462 #else
1463         free_netdev(dev);
1464 #endif
1465
1466         pci_set_drvdata(pdev, NULL);
1467
1468 }
1469
1470 int b57_test_intr(UM_DEVICE_BLOCK *pUmDevice);
1471
1472 #ifdef BCM_WL_EMULATOR
1473 /* new transmit callback  */
1474 static int bcm5700emu_start_xmit(struct sk_buff *skb, struct net_device *dev);
1475 /* keep track of the 2 gige devices */
1476 static PLM_DEVICE_BLOCK pDev1;
1477 static PLM_DEVICE_BLOCK pDev2;
1478
1479 static void
1480 bcm5700emu_open(struct net_device *dev)
1481 {
1482         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1483         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1484         static int instance = 0;
1485         static char *wlemu_if = NULL;
1486         char *wlemu_mode = NULL;
1487         //int wlemu_idx = 0;
1488         static int rx_enable = 0;
1489         static int tx_enable = 0;
1490
1491         /* which interface is the emulator ? */
1492         if(instance == 0) {
1493                 wlemu_if = nvram_get("wlemu_if");
1494                 /* do we emulate rx, tx or both  */
1495                 wlemu_mode = nvram_get("wlemu_mode");
1496                 if(wlemu_mode) {
1497                         if (!strcmp(wlemu_mode,"rx"))
1498                         {
1499                                 rx_enable = 1;
1500                         }
1501                         else if (!strcmp(wlemu_mode,"tx"))
1502                         {
1503
1504                                 tx_enable = 1;
1505
1506                         }
1507                         else if (!strcmp(wlemu_mode,"rx_tx"))
1508                         {
1509
1510                                 rx_enable = 1;
1511                                 tx_enable = 1;
1512                         }
1513                 }
1514         }
1515
1516         instance++;
1517
1518         /* The context is used for accessing the OSL for emulating devices */
1519         pDevice->wlc = NULL;
1520
1521         /* determines if this device is an emulator */
1522         pDevice->wl_emulate_rx = 0;
1523         pDevice->wl_emulate_tx = 0;
1524
1525         if(wlemu_if && !strcmp(dev->name,wlemu_if))
1526         {
1527                 /* create an emulator context. */
1528                 pDevice->wlc = (void *)wlcemu_wlccreate((void *)dev);
1529                 B57_INFO(("Using %s for wl emulation \n", dev->name));
1530                 if(rx_enable)
1531                 {
1532                         B57_INFO(("Enabling wl RX emulation \n"));
1533                         pDevice->wl_emulate_rx = 1;
1534                 }
1535                 /* re-direct transmit callback to emulator */
1536                 if(tx_enable)
1537                 {
1538                         pDevice->wl_emulate_tx = 1;
1539                         dev->hard_start_xmit = bcm5700emu_start_xmit;
1540                         B57_INFO(("Enabling wl TX emulation \n"));
1541                 }
1542         }
1543         /* for debug access to configured devices only */
1544         if(instance == 1)
1545                 pDev1 = pDevice;
1546         else if (instance == 2)
1547                 pDev2 = pDevice;
1548 }
1549
1550 /* Public API to get current emulation info */
1551 int bcm5700emu_get_info(char *buf)
1552 {
1553         int len = 0;
1554         PLM_DEVICE_BLOCK p;
1555
1556         /* look for an emulating device */
1557         if(pDev1->wlc) {
1558                 p = pDev1;
1559                 len += sprintf(buf+len,"emulation device : eth0\n");
1560         }
1561         else if (pDev2->wlc) {
1562                 p = pDev2;
1563                 len += sprintf(buf+len,"emulation device : eth1\n");
1564         }
1565         else {
1566                 len += sprintf(buf+len,"emulation not activated\n");
1567                 return len;
1568         }
1569         if(p->wl_emulate_rx)
1570                 len += sprintf(buf+len,"RX emulation enabled\n");
1571         else
1572                 len += sprintf(buf+len,"RX emulation disabled\n");
1573         if(p->wl_emulate_tx)
1574                 len += sprintf(buf+len,"TX emulation enabled\n");
1575         else
1576                 len += sprintf(buf+len,"TX emulation disabled\n");
1577         return len;
1578
1579 }
1580
1581
1582 /* Public API to access the bcm5700_start_xmit callback */
1583
1584 int
1585 bcm5700emu_forward_xmit(struct sk_buff *skb, struct net_device *dev)
1586 {
1587   return bcm5700_start_xmit(skb, dev);
1588 }
1589
1590
1591 /* hook to kernel txmit callback */
1592 STATIC int
1593 bcm5700emu_start_xmit(struct sk_buff *skb, struct net_device *dev)
1594 {
1595
1596   PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1597   PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1598   return wlcemu_start_xmit(skb,pDevice->wlc);
1599 }
1600
1601 #endif /* BCM_WL_EMULATOR */
1602
1603 int
1604 bcm5700_open(struct net_device *dev)
1605 {
1606         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1607         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1608         int rc;
1609
1610         if (pUmDevice->suspended){
1611             return -EAGAIN;
1612         }
1613
1614 #ifdef BCM_WL_EMULATOR
1615         bcm5700emu_open(dev);
1616 #endif
1617
1618         /* delay for 6 seconds */
1619         pUmDevice->delayed_link_ind = (6 * HZ) / pUmDevice->timer_interval;
1620
1621 #ifdef BCM_INT_COAL
1622 #ifndef BCM_NAPI_RXPOLL
1623         pUmDevice->adaptive_expiry = HZ / pUmDevice->timer_interval;
1624 #endif
1625 #endif
1626
1627 #ifdef INCLUDE_TBI_SUPPORT
1628         if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
1629                 (pDevice->TbiFlags & TBI_POLLING_FLAGS)) {
1630                 pUmDevice->poll_tbi_interval = HZ / pUmDevice->timer_interval;
1631                 if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) {
1632                         pUmDevice->poll_tbi_interval /= 4;
1633                 }
1634                 pUmDevice->poll_tbi_expiry = pUmDevice->poll_tbi_interval;
1635         }
1636 #endif
1637         /* set this timer for 2 seconds */
1638         pUmDevice->asf_heartbeat = (2 * HZ) / pUmDevice->timer_interval;
1639
1640 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
1641
1642
1643         if ( (  (T3_ASIC_IS_575X_PLUS(pDevice->ChipRevId) ) &&
1644                 (T3_ASIC_REV(pDevice->ChipRevId) != T3_ASIC_REV_5714_A0 ) &&
1645                 (T3_CHIP_REV(pDevice->ChipRevId) != T3_CHIP_REV_5750_AX ) &&
1646                 (T3_CHIP_REV(pDevice->ChipRevId) != T3_CHIP_REV_5750_BX ) ) &&
1647                 !bcm_msi_chipset_bug    ){
1648
1649                 if (disable_msi[pUmDevice->index]==1){
1650                         /* do nothing-it's not turned on */
1651                 }else{
1652                         pDevice->Flags |= USING_MSI_FLAG;
1653
1654                         REG_WR(pDevice, Msi.Mode,  2 );
1655
1656                         rc = pci_enable_msi(pUmDevice->pdev);
1657
1658                         if(rc!=0){
1659                                 pDevice->Flags &= ~ USING_MSI_FLAG;
1660                                 REG_WR(pDevice, Msi.Mode,  1 );
1661                         }
1662                 }
1663         }
1664
1665
1666 #endif
1667
1668         if ((rc= request_irq(pUmDevice->pdev->irq, &bcm5700_interrupt, SA_SHIRQ, dev->name, dev)))
1669         {
1670
1671 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
1672
1673                 if(pDevice->Flags & USING_MSI_FLAG)  {
1674
1675                         pci_disable_msi(pUmDevice->pdev);
1676                         pDevice->Flags &= ~USING_MSI_FLAG;
1677                         REG_WR(pDevice, Msi.Mode,  1 );
1678
1679                 }
1680 #endif
1681                 return rc;
1682         }
1683
1684         pUmDevice->opened = 1;
1685         if (LM_InitializeAdapter(pDevice) != LM_STATUS_SUCCESS) {
1686                 pUmDevice->opened = 0;
1687                 free_irq(dev->irq, dev);
1688                 bcm5700_freemem(dev);
1689                 return -EAGAIN;
1690         }
1691
1692         bcm5700_set_vlan_mode(pUmDevice);
1693         bcm5700_init_counters(pUmDevice);
1694
1695         if (pDevice->Flags & UNDI_FIX_FLAG) {
1696                 printk(KERN_INFO "%s: Using indirect register access\n", dev->name);
1697         }
1698
1699         if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6))
1700         {
1701                 /* Do not use invalid eth addrs: any multicast & all zeros */
1702                 if( is_valid_ether_addr(dev->dev_addr) ){
1703                         LM_SetMacAddress(pDevice, dev->dev_addr);
1704                 }
1705                 else
1706                 {
1707                         printk(KERN_INFO "%s: Invalid administered node address\n",dev->name);
1708                         memcpy(dev->dev_addr, pDevice->NodeAddress, 6);
1709                 }
1710         }
1711
1712         if (tigon3_debug > 1)
1713                 printk(KERN_DEBUG "%s: tigon3_open() irq %d.\n", dev->name, dev->irq);
1714
1715         QQ_InitQueue(&pUmDevice->rx_out_of_buf_q.Container,
1716         MAX_RX_PACKET_DESC_COUNT);
1717
1718
1719 #if (LINUX_VERSION_CODE < 0x020300)
1720         MOD_INC_USE_COUNT;
1721 #endif
1722
1723         atomic_set(&pUmDevice->intr_sem, 0);
1724
1725         LM_EnableInterrupt(pDevice);
1726
1727 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
1728
1729         if (pDevice->Flags & USING_MSI_FLAG){
1730
1731                 /* int test to check support on older machines */
1732                 if (b57_test_intr(pUmDevice) != 1) {
1733
1734                         LM_DisableInterrupt(pDevice);
1735                         free_irq(pUmDevice->pdev->irq, dev);
1736                         pci_disable_msi(pUmDevice->pdev);
1737                         REG_WR(pDevice, Msi.Mode,  1 );
1738                         pDevice->Flags &= ~USING_MSI_FLAG;
1739
1740                         rc = LM_ResetAdapter(pDevice);
1741 printk(KERN_ALERT " The MSI support in this system is not functional.\n");
1742
1743                         if (rc == LM_STATUS_SUCCESS)
1744                                 rc = 0;
1745                         else
1746                                 rc = -ENODEV;
1747
1748                         if(rc == 0){
1749                                 rc = request_irq(pUmDevice->pdev->irq, &bcm5700_interrupt,
1750                                             SA_SHIRQ, dev->name, dev);
1751                         }
1752
1753                         if(rc){
1754                                 LM_Halt(pDevice);
1755                                 bcm5700_freemem(dev);
1756                                 pUmDevice->opened = 0;
1757                                 return rc;
1758                         }
1759
1760
1761                         pDevice->InitDone = TRUE;
1762                         atomic_set(&pUmDevice->intr_sem, 0);
1763                         LM_EnableInterrupt(pDevice);
1764                 }
1765         }
1766 #endif
1767
1768         init_timer(&pUmDevice->timer);
1769         pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
1770         pUmDevice->timer.data = (unsigned long)dev;
1771         pUmDevice->timer.function = &bcm5700_timer;
1772         add_timer(&pUmDevice->timer);
1773
1774         if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
1775                 init_timer(&pUmDevice->statstimer);
1776                 pUmDevice->statstimer.expires = RUN_AT(pUmDevice->statstimer_interval);
1777                 pUmDevice->statstimer.data = (unsigned long)dev;
1778                 pUmDevice->statstimer.function = &bcm5700_stats_timer;
1779                 add_timer(&pUmDevice->statstimer);
1780         }
1781
1782         if(pDevice->Flags & USING_MSI_FLAG)
1783                 printk(KERN_INFO "%s: Using Message Signaled Interrupt (MSI)  \n", dev->name);
1784         else
1785                 printk(KERN_INFO "%s: Using PCI INTX interrupt \n", dev->name);
1786
1787         netif_start_queue(dev);
1788
1789         return 0;
1790 }
1791
1792
1793 STATIC void
1794 bcm5700_stats_timer(unsigned long data)
1795 {
1796         struct net_device *dev = (struct net_device *)data;
1797         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1798         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1799         unsigned long flags = 0;
1800
1801         if (!pUmDevice->opened)
1802                 return;
1803
1804         if (!atomic_read(&pUmDevice->intr_sem) &&
1805             !pUmDevice->suspended              &&
1806            (pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE)) {
1807                 BCM5700_LOCK(pUmDevice, flags);
1808                 LM_GetStats(pDevice);
1809                 BCM5700_UNLOCK(pUmDevice, flags);
1810         }
1811
1812         pUmDevice->statstimer.expires = RUN_AT(pUmDevice->statstimer_interval);
1813
1814         add_timer(&pUmDevice->statstimer);
1815 }
1816
1817
1818 STATIC void
1819 bcm5700_timer(unsigned long data)
1820 {
1821         struct net_device *dev = (struct net_device *)data;
1822         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1823         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1824         unsigned long flags = 0;
1825         LM_UINT32 value32;
1826
1827         if (!pUmDevice->opened)
1828                 return;
1829
1830         /* BCM4785: Flush posted writes from GbE to host memory. */
1831         if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
1832                 REG_RD(pDevice, HostCoalesce.Mode);
1833
1834         if (atomic_read(&pUmDevice->intr_sem) || pUmDevice->suspended) {
1835                 pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
1836                 add_timer(&pUmDevice->timer);
1837                 return;
1838         }
1839
1840 #ifdef INCLUDE_TBI_SUPPORT
1841         if ((pDevice->TbiFlags & TBI_POLLING_FLAGS) &&
1842                 (--pUmDevice->poll_tbi_expiry <= 0)) {
1843
1844                 BCM5700_PHY_LOCK(pUmDevice, flags);
1845                 value32 = REG_RD(pDevice, MacCtrl.Status);
1846                 if (((pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE) &&
1847                         ((value32 & (MAC_STATUS_LINK_STATE_CHANGED |
1848                                 MAC_STATUS_CFG_CHANGED)) ||
1849                         !(value32 & MAC_STATUS_PCS_SYNCED)))
1850                         ||
1851                         ((pDevice->LinkStatus != LM_STATUS_LINK_ACTIVE) &&
1852                         (value32 & (MAC_STATUS_PCS_SYNCED |
1853                                 MAC_STATUS_SIGNAL_DETECTED))))
1854                 {
1855                         LM_SetupPhy(pDevice);
1856                 }
1857                 BCM5700_PHY_UNLOCK(pUmDevice, flags);
1858                 pUmDevice->poll_tbi_expiry = pUmDevice->poll_tbi_interval;
1859
1860         }
1861 #endif
1862
1863         if (pUmDevice->delayed_link_ind > 0) {
1864                 if (pUmDevice->delayed_link_ind == 1)
1865                         MM_IndicateStatus(pDevice, pDevice->LinkStatus);
1866                 else
1867                         pUmDevice->delayed_link_ind--;
1868         }
1869
1870         if (pUmDevice->crc_counter_expiry > 0)
1871                 pUmDevice->crc_counter_expiry--;
1872
1873         if (!pUmDevice->interrupt) {
1874                 if (!(pDevice->Flags & USE_TAGGED_STATUS_FLAG)) {
1875                         BCM5700_LOCK(pUmDevice, flags);
1876                         if (pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) {
1877                                 /* This will generate an interrupt */
1878                                 REG_WR(pDevice, Grc.LocalCtrl,
1879                                         pDevice->GrcLocalCtrl |
1880                                         GRC_MISC_LOCAL_CTRL_SET_INT);
1881                         }
1882                         else {
1883                                 REG_WR(pDevice, HostCoalesce.Mode,
1884                                         pDevice->CoalesceMode |
1885                                         HOST_COALESCE_ENABLE |
1886                                         HOST_COALESCE_NOW);
1887                         }
1888                         if (!(REG_RD(pDevice, DmaWrite.Mode) &
1889                                 DMA_WRITE_MODE_ENABLE)) {
1890                                 BCM5700_UNLOCK(pUmDevice, flags);
1891                                 bcm5700_reset(dev);
1892                         }
1893                         else {
1894                                 BCM5700_UNLOCK(pUmDevice, flags);
1895                         }
1896                         if (pUmDevice->tx_queued) {
1897                                 pUmDevice->tx_queued = 0;
1898                                 netif_wake_queue(dev);
1899                         }
1900                 }
1901 #if (LINUX_VERSION_CODE < 0x02032b)
1902                 if ((QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) !=
1903                         pDevice->TxPacketDescCnt) &&
1904                         ((jiffies - dev->trans_start) > TX_TIMEOUT)) {
1905
1906                         printk(KERN_WARNING "%s: Tx hung\n", dev->name);
1907                         bcm5700_reset(dev);
1908                 }
1909 #endif
1910         }
1911 #ifdef BCM_INT_COAL
1912 #ifndef BCM_NAPI_RXPOLL
1913         if (pUmDevice->adaptive_coalesce) {
1914                 pUmDevice->adaptive_expiry--;
1915                 if (pUmDevice->adaptive_expiry == 0) {
1916                         pUmDevice->adaptive_expiry = HZ /
1917                                 pUmDevice->timer_interval;
1918                         bcm5700_adapt_coalesce(pUmDevice);
1919                 }
1920         }
1921 #endif
1922 #endif
1923         if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container) >
1924                 (unsigned int) pUmDevice->rx_buf_repl_panic_thresh) {
1925                 /* Generate interrupt and let isr allocate buffers */
1926                 REG_WR(pDevice, HostCoalesce.Mode, pDevice->CoalesceMode |
1927                         HOST_COALESCE_ENABLE | HOST_COALESCE_NOW);
1928         }
1929
1930 #ifdef BCM_ASF
1931         if (pDevice->AsfFlags & ASF_ENABLED) {
1932                 pUmDevice->asf_heartbeat--;
1933                 if (pUmDevice->asf_heartbeat == 0) {
1934                         if( (pDevice->Flags & UNDI_FIX_FLAG) ||
1935                             (pDevice->Flags & ENABLE_PCIX_FIX_FLAG)) {
1936                                 MEM_WR_OFFSET(pDevice, T3_CMD_MAILBOX,
1937                                         T3_CMD_NICDRV_ALIVE2);
1938                                 MEM_WR_OFFSET(pDevice, T3_CMD_LENGTH_MAILBOX,
1939                                         4);
1940                                 MEM_WR_OFFSET(pDevice, T3_CMD_DATA_MAILBOX, 5);
1941                         } else {
1942                                 LM_RegWr(pDevice,
1943                                          (T3_NIC_MBUF_POOL_ADDR +
1944                                           T3_CMD_MAILBOX),
1945                                          T3_CMD_NICDRV_ALIVE2, 1);
1946                                 LM_RegWr(pDevice,
1947                                          (T3_NIC_MBUF_POOL_ADDR +
1948                                           T3_CMD_LENGTH_MAILBOX),4,1);
1949                                 LM_RegWr(pDevice,
1950                                          (T3_NIC_MBUF_POOL_ADDR +
1951                                           T3_CMD_DATA_MAILBOX),5,1);
1952                         }
1953
1954                         value32 = REG_RD(pDevice, Grc.RxCpuEvent);
1955                         REG_WR(pDevice, Grc.RxCpuEvent, value32 | BIT_14);
1956                         pUmDevice->asf_heartbeat = (2 * HZ) /
1957                                 pUmDevice->timer_interval;
1958                 }
1959         }
1960 #endif
1961
1962         if (pDevice->PhyFlags & PHY_IS_FIBER){
1963                 BCM5700_PHY_LOCK(pUmDevice, flags);
1964                 LM_5714_FamFiberCheckLink(pDevice);
1965                 BCM5700_PHY_UNLOCK(pUmDevice, flags);
1966         }
1967
1968         pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
1969         add_timer(&pUmDevice->timer);
1970 }
1971
1972 STATIC int
1973 bcm5700_init_counters(PUM_DEVICE_BLOCK pUmDevice)
1974 {
1975 #ifdef BCM_INT_COAL
1976 #ifndef BCM_NAPI_RXPOLL
1977         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
1978
1979         pUmDevice->rx_curr_coalesce_frames = pDevice->RxMaxCoalescedFrames;
1980         pUmDevice->rx_curr_coalesce_ticks = pDevice->RxCoalescingTicks;
1981         pUmDevice->tx_curr_coalesce_frames = pDevice->TxMaxCoalescedFrames;
1982         pUmDevice->rx_last_cnt = 0;
1983         pUmDevice->tx_last_cnt = 0;
1984 #endif
1985 #endif
1986         pUmDevice->phy_crc_count = 0;
1987 #if TIGON3_DEBUG
1988         pUmDevice->tx_zc_count = 0;
1989         pUmDevice->tx_chksum_count = 0;
1990         pUmDevice->tx_himem_count = 0;
1991         pUmDevice->rx_good_chksum_count = 0;
1992         pUmDevice->rx_bad_chksum_count = 0;
1993 #endif
1994 #ifdef BCM_TSO
1995         pUmDevice->tso_pkt_count = 0;
1996 #endif
1997         return 0;
1998 }
1999
2000 #ifdef BCM_INT_COAL
2001 #ifndef BCM_NAPI_RXPOLL
2002 STATIC int
2003 bcm5700_do_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice,
2004         int rx_frames, int rx_ticks, int tx_frames, int rx_frames_intr)
2005 {
2006         unsigned long flags = 0;
2007         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2008
2009         if (pUmDevice->do_global_lock) {
2010                 if (spin_is_locked(&pUmDevice->global_lock))
2011                         return 0;
2012                 spin_lock_irqsave(&pUmDevice->global_lock, flags);
2013         }
2014         pUmDevice->rx_curr_coalesce_frames = rx_frames;
2015         pUmDevice->rx_curr_coalesce_ticks = rx_ticks;
2016         pUmDevice->tx_curr_coalesce_frames = tx_frames;
2017         pUmDevice->rx_curr_coalesce_frames_intr = rx_frames_intr;
2018         REG_WR(pDevice, HostCoalesce.RxMaxCoalescedFrames, rx_frames);
2019
2020         REG_WR(pDevice, HostCoalesce.RxCoalescingTicks, rx_ticks);
2021
2022         REG_WR(pDevice, HostCoalesce.TxMaxCoalescedFrames, tx_frames);
2023
2024         REG_WR(pDevice, HostCoalesce.RxMaxCoalescedFramesDuringInt,
2025                 rx_frames_intr);
2026
2027         BCM5700_UNLOCK(pUmDevice, flags);
2028         return 0;
2029 }
2030
2031 STATIC int
2032 bcm5700_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice)
2033 {
2034         PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
2035         uint rx_curr_cnt, tx_curr_cnt, rx_delta, tx_delta, total_delta;
2036
2037         rx_curr_cnt = pDevice->pStatsBlkVirt->ifHCInUcastPkts.Low;
2038         tx_curr_cnt = pDevice->pStatsBlkVirt->ifHCOutUcastPkts.Low;
2039         if ((rx_curr_cnt <= pUmDevice->rx_last_cnt) ||
2040                 (tx_curr_cnt < pUmDevice->tx_last_cnt)) {
2041
2042                 /* skip if there is counter rollover */
2043                 pUmDevice->rx_last_cnt = rx_curr_cnt;
2044                 pUmDevice->tx_last_cnt = tx_curr_cnt;
2045                 return 0;
2046         }
2047
2048         rx_delta = rx_curr_cnt - pUmDevice->rx_last_cnt;
2049         tx_delta = tx_curr_cnt - pUmDevice->tx_last_cnt;
2050         total_delta = (((rx_delta + rx_delta) + tx_delta) / 3) << 1;
2051
2052         pUmDevice->rx_last_cnt = rx_curr_cnt;
2053         pUmDevice->tx_last_cnt = tx_curr_cnt;
2054
2055         if (total_delta < ADAPTIVE_LO_PKT_THRESH) {
2056                 if (pUmDevice->rx_curr_coalesce_frames !=
2057                         ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES) {
2058
2059                         bcm5700_do_adapt_coalesce(pUmDevice,
2060                                 ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES,
2061                                 ADAPTIVE_LO_RX_COALESCING_TICKS,
2062                                 ADAPTIVE_LO_TX_MAX_COALESCED_FRAMES,
2063                                 ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES_DURING_INT);
2064                 }
2065         }
2066         else if (total_delta < ADAPTIVE_HI_PKT_THRESH) {
2067                 if (pUmDevice->rx_curr_coalesce_frames !=
2068                         DEFAULT_RX_MAX_COALESCED_FRAMES) {
2069
2070                         bcm5700_do_adapt_coalesce(pUmDevice,
2071                                 DEFAULT_RX_MAX_COALESCED_FRAMES,
2072                                 DEFAULT_RX_COALESCING_TICKS,
2073                                 DEFAULT_TX_MAX_COALESCED_FRAMES,
2074                                 DEFAULT_RX_MAX_COALESCED_FRAMES_DURING_INT);
2075                 }
2076         }
2077         else {
2078                 if (pUmDevice->rx_curr_coalesce_frames !=
2079                         ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES) {
2080
2081                         bcm5700_do_adapt_coalesce(pUmDevice,
2082                                 ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES,
2083                                 ADAPTIVE_HI_RX_COALESCING_TICKS,
2084                                 ADAPTIVE_HI_TX_MAX_COALESCED_FRAMES,
2085                                 ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES_DURING_INT);
2086                 }
2087         }
2088         return 0;
2089 }
2090 #endif
2091 #endif
2092
2093 STATIC void
2094 bcm5700_reset(struct net_device *dev)
2095 {
2096         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2097         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2098         unsigned long flags;
2099
2100 #ifdef BCM_TSO
2101
2102         if( (dev->features & NETIF_F_TSO) &&
2103                 (pUmDevice->tx_full) )     {
2104
2105                 dev->features &= ~NETIF_F_TSO;
2106         }
2107 #endif
2108
2109         netif_stop_queue(dev);
2110         bcm5700_intr_off(pUmDevice);
2111         BCM5700_PHY_LOCK(pUmDevice, flags);
2112         LM_ResetAdapter(pDevice);
2113         pDevice->InitDone = TRUE;
2114         bcm5700_do_rx_mode(dev);
2115         bcm5700_set_vlan_mode(pUmDevice);
2116         bcm5700_init_counters(pUmDevice);
2117         if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6)) {
2118                 LM_SetMacAddress(pDevice, dev->dev_addr);
2119         }
2120         BCM5700_PHY_UNLOCK(pUmDevice, flags);
2121         atomic_set(&pUmDevice->intr_sem, 1);
2122         bcm5700_intr_on(pUmDevice);
2123         netif_wake_queue(dev);
2124 }
2125
2126 STATIC void
2127 bcm5700_set_vlan_mode(UM_DEVICE_BLOCK *pUmDevice)
2128 {
2129         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2130         LM_UINT32 ReceiveMask = pDevice->ReceiveMask;
2131         int vlan_tag_mode = pUmDevice->vlan_tag_mode;
2132
2133         if (vlan_tag_mode == VLAN_TAG_MODE_AUTO_STRIP) {
2134                 if (pDevice->AsfFlags & ASF_ENABLED) {
2135                         vlan_tag_mode = VLAN_TAG_MODE_FORCED_STRIP;
2136                 }
2137                 else {
2138                         vlan_tag_mode = VLAN_TAG_MODE_NORMAL_STRIP;
2139                 }
2140         }
2141         if (vlan_tag_mode == VLAN_TAG_MODE_NORMAL_STRIP) {
2142                 ReceiveMask |= LM_KEEP_VLAN_TAG;
2143 #ifdef BCM_VLAN
2144                 if (pUmDevice->vlgrp)
2145                         ReceiveMask &= ~LM_KEEP_VLAN_TAG;
2146 #endif
2147         }
2148         else if (vlan_tag_mode == VLAN_TAG_MODE_FORCED_STRIP) {
2149                 ReceiveMask &= ~LM_KEEP_VLAN_TAG;
2150         }
2151         if (ReceiveMask != pDevice->ReceiveMask)
2152         {
2153                 LM_SetReceiveMask(pDevice, ReceiveMask);
2154         }
2155 }
2156
2157 static void
2158 bcm5700_poll_wait(UM_DEVICE_BLOCK *pUmDevice)
2159 {
2160 #ifdef BCM_NAPI_RXPOLL
2161         while (pUmDevice->lm_dev.RxPoll) {
2162                 current->state = TASK_INTERRUPTIBLE;
2163                 schedule_timeout(1);
2164         }
2165 #endif
2166 }
2167
2168
2169 #ifdef BCM_VLAN
2170 STATIC void
2171 bcm5700_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp)
2172 {
2173         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
2174
2175         bcm5700_intr_off(pUmDevice);
2176         bcm5700_poll_wait(pUmDevice);
2177         pUmDevice->vlgrp = vlgrp;
2178         bcm5700_set_vlan_mode(pUmDevice);
2179         bcm5700_intr_on(pUmDevice);
2180 }
2181
2182 STATIC void
2183 bcm5700_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
2184 {
2185         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
2186
2187         bcm5700_intr_off(pUmDevice);
2188         bcm5700_poll_wait(pUmDevice);
2189         if (pUmDevice->vlgrp) {
2190                 pUmDevice->vlgrp->vlan_devices[vid] = NULL;
2191         }
2192         bcm5700_intr_on(pUmDevice);
2193 }
2194 #endif
2195
2196 STATIC int
2197 bcm5700_start_xmit(struct sk_buff *skb, struct net_device *dev)
2198 {
2199         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2200         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2201         PLM_PACKET pPacket;
2202         PUM_PACKET pUmPacket;
2203         unsigned long flags = 0;
2204         int frag_no;
2205 #ifdef BCM_TSO
2206         LM_UINT32 mss = 0 ;
2207         uint16_t ip_tcp_len, tcp_opt_len, tcp_seg_flags;
2208 #endif
2209
2210         if ((pDevice->LinkStatus == LM_STATUS_LINK_DOWN) ||
2211                 !pDevice->InitDone || pUmDevice->suspended)
2212         {
2213                 dev_kfree_skb(skb);
2214                 return 0;
2215         }
2216
2217 #if (LINUX_VERSION_CODE < 0x02032b)
2218         if (test_and_set_bit(0, &dev->tbusy)) {
2219             return 1;
2220         }
2221 #endif
2222
2223         if (pUmDevice->do_global_lock && pUmDevice->interrupt) {
2224                 netif_stop_queue(dev);
2225                 pUmDevice->tx_queued = 1;
2226                 if (!pUmDevice->interrupt) {
2227                         netif_wake_queue(dev);
2228                         pUmDevice->tx_queued = 0;
2229                 }
2230             return 1;
2231         }
2232
2233         pPacket = (PLM_PACKET)
2234                 QQ_PopHead(&pDevice->TxPacketFreeQ.Container);
2235         if (pPacket == 0) {
2236                 netif_stop_queue(dev);
2237                 pUmDevice->tx_full = 1;
2238                 if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container)) {
2239                         netif_wake_queue(dev);
2240                         pUmDevice->tx_full = 0;
2241                 }
2242             return 1;
2243         }
2244         pUmPacket = (PUM_PACKET) pPacket;
2245         pUmPacket->skbuff = skb;
2246         pUmDevice->stats.tx_bytes += skb->len;
2247
2248         if (skb->ip_summed == CHECKSUM_HW) {
2249                 pPacket->Flags = SND_BD_FLAG_TCP_UDP_CKSUM;
2250 #if TIGON3_DEBUG
2251                 pUmDevice->tx_chksum_count++;
2252 #endif
2253         }
2254         else {
2255                 pPacket->Flags = 0;
2256         }
2257 #if MAX_SKB_FRAGS
2258         frag_no = skb_shinfo(skb)->nr_frags;
2259 #else
2260         frag_no = 0;
2261 #endif
2262         if (atomic_read(&pDevice->SendBdLeft) < (frag_no + 1)) {
2263                 netif_stop_queue(dev);
2264                 pUmDevice->tx_full = 1;
2265                 QQ_PushHead(&pDevice->TxPacketFreeQ.Container, pPacket);
2266                 if (atomic_read(&pDevice->SendBdLeft) >= (frag_no + 1)) {
2267                         netif_wake_queue(dev);
2268                         pUmDevice->tx_full = 0;
2269                 }
2270                 return 1;
2271         }
2272
2273         pPacket->u.Tx.FragCount = frag_no + 1;
2274 #if TIGON3_DEBUG
2275         if (pPacket->u.Tx.FragCount > 1)
2276                 pUmDevice->tx_zc_count++;
2277 #endif
2278
2279 #ifdef BCM_VLAN
2280         if (pUmDevice->vlgrp && vlan_tx_tag_present(skb)) {
2281                 pPacket->VlanTag = vlan_tx_tag_get(skb);
2282                 pPacket->Flags |= SND_BD_FLAG_VLAN_TAG;
2283         }
2284 #endif
2285
2286 #ifdef BCM_TSO
2287         if ((mss = (LM_UINT32) skb_shinfo(skb)->tso_size) &&
2288                 (skb->len > pDevice->TxMtu)) {
2289
2290 #if (LINUX_VERSION_CODE >= 0x02060c)
2291
2292                 if (skb_header_cloned(skb) &&
2293                         pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
2294
2295                         dev_kfree_skb(skb);
2296                         return 0;
2297                 }
2298 #endif
2299                 pUmDevice->tso_pkt_count++;
2300
2301                 pPacket->Flags |= SND_BD_FLAG_CPU_PRE_DMA |
2302                         SND_BD_FLAG_CPU_POST_DMA;
2303
2304                 tcp_opt_len = 0;
2305                 if (skb->h.th->doff > 5) {
2306                         tcp_opt_len = (skb->h.th->doff - 5) << 2;
2307                 }
2308                 ip_tcp_len = (skb->nh.iph->ihl << 2) + sizeof(struct tcphdr);
2309                 skb->nh.iph->check = 0;
2310
2311                 if ( T3_ASIC_IS_575X_PLUS(pDevice->ChipRevId) ){
2312                         skb->h.th->check = 0;
2313                         pPacket->Flags &= ~SND_BD_FLAG_TCP_UDP_CKSUM;
2314                 }
2315                 else {
2316                         skb->h.th->check = ~csum_tcpudp_magic(
2317                                 skb->nh.iph->saddr, skb->nh.iph->daddr,
2318                                 0, IPPROTO_TCP, 0);
2319                 }
2320
2321                 skb->nh.iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
2322                 tcp_seg_flags = 0;
2323
2324                 if (tcp_opt_len || (skb->nh.iph->ihl > 5)) {
2325                         if ( T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId) ){
2326                                 tcp_seg_flags =
2327                                         ((skb->nh.iph->ihl - 5) +
2328                                         (tcp_opt_len >> 2)) << 11;
2329                         }
2330                         else {
2331                                 pPacket->Flags |=
2332                                         ((skb->nh.iph->ihl - 5) +
2333                                         (tcp_opt_len >> 2)) << 12;
2334                         }
2335                 }
2336                 pPacket->u.Tx.MaxSegmentSize = mss | tcp_seg_flags;
2337         }
2338         else
2339         {
2340                 pPacket->u.Tx.MaxSegmentSize = 0;
2341         }
2342 #endif
2343         BCM5700_LOCK(pUmDevice, flags);
2344         LM_SendPacket(pDevice, pPacket);
2345         BCM5700_UNLOCK(pUmDevice, flags);
2346
2347 #if (LINUX_VERSION_CODE < 0x02032b)
2348         netif_wake_queue(dev);
2349 #endif
2350         dev->trans_start = jiffies;
2351
2352
2353         return 0;
2354 }
2355
2356 #ifdef BCM_NAPI_RXPOLL
2357 STATIC int
2358 bcm5700_poll(struct net_device *dev, int *budget)
2359 {
2360         int orig_budget = *budget;
2361         int work_done;
2362         UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) dev->priv;
2363         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2364         unsigned long flags = 0;
2365         LM_UINT32 tag;
2366
2367         if (orig_budget > dev->quota)
2368                 orig_budget = dev->quota;
2369
2370         BCM5700_LOCK(pUmDevice, flags);
2371         /* BCM4785: Flush posted writes from GbE to host memory. */
2372         if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
2373                 REG_RD(pDevice, HostCoalesce.Mode);
2374         work_done = LM_ServiceRxPoll(pDevice, orig_budget);
2375         *budget -= work_done;
2376         dev->quota -= work_done;
2377
2378         if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
2379                 replenish_rx_buffers(pUmDevice, 0);
2380         }
2381         BCM5700_UNLOCK(pUmDevice, flags);
2382         if (work_done) {
2383                 MM_IndicateRxPackets(pDevice);
2384                 BCM5700_LOCK(pUmDevice, flags);
2385                 LM_QueueRxPackets(pDevice);
2386                 BCM5700_UNLOCK(pUmDevice, flags);
2387         }
2388         if ((work_done < orig_budget) || atomic_read(&pUmDevice->intr_sem) ||
2389                 pUmDevice->suspended) {
2390
2391                 netif_rx_complete(dev);
2392                 BCM5700_LOCK(pUmDevice, flags);
2393                 REG_WR(pDevice, Grc.Mode, pDevice->GrcMode);
2394                 pDevice->RxPoll = FALSE;
2395                 if (pDevice->RxPoll) {
2396                         BCM5700_UNLOCK(pUmDevice, flags);
2397                         return 0;
2398                 }
2399                 /* Take care of possible missed rx interrupts */
2400                 REG_RD_BACK(pDevice, Grc.Mode); /* flush the register write */
2401                 tag = pDevice->pStatusBlkVirt->StatusTag;
2402                 if ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) ||
2403                         (pDevice->pStatusBlkVirt->Idx[0].RcvProdIdx !=
2404                         pDevice->RcvRetConIdx)) {
2405
2406                         REG_WR(pDevice, HostCoalesce.Mode,
2407                                 pDevice->CoalesceMode | HOST_COALESCE_ENABLE |
2408                                 HOST_COALESCE_NOW);
2409                 }
2410                 /* If a new status block is pending in the WDMA state machine */
2411                 /* before the register write to enable the rx interrupt,      */
2412                 /* the new status block may DMA with no interrupt. In this    */
2413                 /* scenario, the tag read above will be older than the tag in */
2414                 /* the pending status block and writing the older tag will    */
2415                 /* cause interrupt to be generated.                           */
2416                 else if (pDevice->Flags & USE_TAGGED_STATUS_FLAG) {
2417                         MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low,
2418                                 tag << 24);
2419                         /* Make sure we service tx in case some tx interrupts */
2420                         /* are cleared */
2421                         if (atomic_read(&pDevice->SendBdLeft) <
2422                                 (T3_SEND_RCB_ENTRY_COUNT / 2)) {
2423                                 REG_WR(pDevice, HostCoalesce.Mode,
2424                                         pDevice->CoalesceMode |
2425                                         HOST_COALESCE_ENABLE |
2426                                         HOST_COALESCE_NOW);
2427                         }
2428                 }
2429                 BCM5700_UNLOCK(pUmDevice, flags);
2430                 return 0;
2431         }
2432         return 1;
2433 }
2434 #endif /* BCM_NAPI_RXPOLL */
2435
2436 STATIC irqreturn_t
2437 bcm5700_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
2438 {
2439         struct net_device *dev = (struct net_device *)dev_instance;
2440         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2441         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2442         LM_UINT32 oldtag, newtag;
2443         int i, max_intr_loop;
2444 #ifdef BCM_TASKLET
2445         int repl_buf_count;
2446 #endif
2447         unsigned int handled = 1;
2448
2449         if (!pDevice->InitDone) {
2450                 handled = 0;
2451                 return IRQ_RETVAL(handled);
2452         }
2453
2454         bcm5700_intr_lock(pUmDevice);
2455         if (atomic_read(&pUmDevice->intr_sem)) {
2456                 MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
2457                 bcm5700_intr_unlock(pUmDevice);
2458                 handled = 0;
2459                 return IRQ_RETVAL(handled);
2460         }
2461
2462         if (test_and_set_bit(0, (void*)&pUmDevice->interrupt)) {
2463                 printk(KERN_ERR "%s: Duplicate entry of the interrupt handler\n",
2464                         dev->name);
2465                 bcm5700_intr_unlock(pUmDevice);
2466                 handled = 0;
2467                 return IRQ_RETVAL(handled);
2468         }
2469
2470         /* BCM4785: Flush posted writes from GbE to host memory. */
2471         if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
2472                 REG_RD(pDevice, HostCoalesce.Mode);
2473
2474         if ((pDevice->Flags & USING_MSI_FLAG) ||
2475                 (pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) ||
2476                 !(REG_RD(pDevice,PciCfg.PciState) & T3_PCI_STATE_INTERRUPT_NOT_ACTIVE) )
2477         {
2478
2479                 if (pUmDevice->intr_test) {
2480                         if (!(REG_RD(pDevice, PciCfg.PciState) &
2481                                         T3_PCI_STATE_INTERRUPT_NOT_ACTIVE) ||
2482                                                 pDevice->Flags & USING_MSI_FLAG ) {
2483                                 pUmDevice->intr_test_result = 1;
2484                         }
2485                         pUmDevice->intr_test = 0;
2486                 }
2487
2488 #ifdef BCM_NAPI_RXPOLL
2489                 max_intr_loop = 1;
2490 #else
2491                 max_intr_loop = 50;
2492 #endif
2493                 if (pDevice->Flags & USE_TAGGED_STATUS_FLAG) {
2494                         MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
2495                         oldtag = pDevice->pStatusBlkVirt->StatusTag;
2496
2497                         for (i = 0; ; i++) {
2498                                 pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED;
2499
2500                                 LM_ServiceInterrupts(pDevice);
2501                                 /* BCM4785: Flush GbE posted writes to host memory. */
2502                                 if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
2503                                         MB_REG_RD(pDevice, Mailbox.Interrupt[0].Low);
2504                                 newtag = pDevice->pStatusBlkVirt->StatusTag;
2505                                 if ((newtag == oldtag) || (i > max_intr_loop)) {
2506                                         MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, oldtag << 24);
2507                                         pDevice->LastTag = oldtag;
2508                                         if (pDevice->Flags & UNDI_FIX_FLAG) {
2509                                                 REG_WR(pDevice, Grc.LocalCtrl,
2510                                                 pDevice->GrcLocalCtrl | 0x2);
2511                                         }
2512                                         break;
2513                                 }
2514                                 oldtag = newtag;
2515                         }
2516                 }
2517                 else
2518                 {
2519                         i = 0;
2520                         do {
2521                                 uint dummy;
2522
2523                                 MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
2524                                 pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED;
2525                                 LM_ServiceInterrupts(pDevice);
2526                                 MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 0);
2527                                 dummy = MB_REG_RD(pDevice, Mailbox.Interrupt[0].Low);
2528                                 i++;
2529                         }
2530                         while ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) &&
2531                                 (i < max_intr_loop));
2532
2533                         if (pDevice->Flags & UNDI_FIX_FLAG) {
2534                                 REG_WR(pDevice, Grc.LocalCtrl,
2535                                 pDevice->GrcLocalCtrl | 0x2);
2536                         }
2537                 }
2538         }
2539         else
2540         {
2541                 /* not my interrupt */
2542                 handled = 0;
2543         }
2544
2545 #ifdef BCM_TASKLET
2546         repl_buf_count = QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container);
2547         if (((repl_buf_count > pUmDevice->rx_buf_repl_panic_thresh) ||
2548                 pDevice->QueueAgain) &&
2549                 (!test_and_set_bit(0, &pUmDevice->tasklet_busy))) {
2550
2551                 replenish_rx_buffers(pUmDevice, pUmDevice->rx_buf_repl_isr_limit);
2552                 clear_bit(0, (void*)&pUmDevice->tasklet_busy);
2553         }
2554         else if ((repl_buf_count > pUmDevice->rx_buf_repl_thresh) &&
2555                 !pUmDevice->tasklet_pending) {
2556
2557                 pUmDevice->tasklet_pending = 1;
2558                 tasklet_schedule(&pUmDevice->tasklet);
2559         }
2560 #else
2561 #ifdef BCM_NAPI_RXPOLL
2562         if (!pDevice->RxPoll &&
2563                 QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
2564                 pDevice->RxPoll = 1;
2565                 MM_ScheduleRxPoll(pDevice);
2566         }
2567 #else
2568         if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
2569                 replenish_rx_buffers(pUmDevice, 0);
2570         }
2571
2572         if (QQ_GetEntryCnt(&pDevice->RxPacketFreeQ.Container) ||
2573                 pDevice->QueueAgain) {
2574
2575                 LM_QueueRxPackets(pDevice);
2576         }
2577 #endif
2578 #endif
2579
2580         clear_bit(0, (void*)&pUmDevice->interrupt);
2581         bcm5700_intr_unlock(pUmDevice);
2582         if (pUmDevice->tx_queued) {
2583                 pUmDevice->tx_queued = 0;
2584                 netif_wake_queue(dev);
2585         }
2586         return IRQ_RETVAL(handled);
2587 }
2588
2589
2590 #ifdef BCM_TASKLET
2591 STATIC void
2592 bcm5700_tasklet(unsigned long data)
2593 {
2594         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)data;
2595         unsigned long flags = 0;
2596
2597         /* RH 7.2 Beta 3 tasklets are reentrant */
2598         if (test_and_set_bit(0, &pUmDevice->tasklet_busy)) {
2599                 pUmDevice->tasklet_pending = 0;
2600                 return;
2601         }
2602
2603         pUmDevice->tasklet_pending = 0;
2604         if (pUmDevice->opened && !pUmDevice->suspended) {
2605                 BCM5700_LOCK(pUmDevice, flags);
2606                 replenish_rx_buffers(pUmDevice, 0);
2607                 BCM5700_UNLOCK(pUmDevice, flags);
2608         }
2609
2610         clear_bit(0, &pUmDevice->tasklet_busy);
2611 }
2612 #endif
2613
2614 STATIC int
2615 bcm5700_close(struct net_device *dev)
2616 {
2617
2618         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2619         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2620
2621 #if (LINUX_VERSION_CODE < 0x02032b)
2622         dev->start = 0;
2623 #endif
2624         netif_stop_queue(dev);
2625         pUmDevice->opened = 0;
2626
2627 #ifdef BCM_ASF
2628         if( !(pDevice->AsfFlags & ASF_ENABLED) )
2629 #endif
2630 #ifdef BCM_WOL
2631                 if( enable_wol[pUmDevice->index] == 0 )
2632 #endif
2633                         B57_INFO(("%s: %s NIC Link is DOWN\n", bcm5700_driver, dev->name));
2634
2635         if (tigon3_debug > 1)
2636                 printk(KERN_DEBUG "%s: Shutting down Tigon3\n",
2637                            dev->name);
2638
2639         LM_MulticastClear(pDevice);
2640         bcm5700_shutdown(pUmDevice);
2641
2642         if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
2643                 del_timer_sync(&pUmDevice->statstimer);
2644         }
2645
2646         del_timer_sync(&pUmDevice->timer);
2647
2648         free_irq(pUmDevice->pdev->irq, dev);
2649
2650 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
2651
2652         if(pDevice->Flags & USING_MSI_FLAG) {
2653                 pci_disable_msi(pUmDevice->pdev);
2654                 REG_WR(pDevice, Msi.Mode,  1 );
2655                 pDevice->Flags &= ~USING_MSI_FLAG;
2656         }
2657
2658 #endif
2659
2660
2661 #if (LINUX_VERSION_CODE < 0x020300)
2662         MOD_DEC_USE_COUNT;
2663 #endif
2664         {
2665         /* BCM4785: Don't go to low-power state because it will power down the smbus block. */
2666         if (!(pDevice->Flags & SB_CORE_FLAG))
2667                 LM_SetPowerState(pDevice, LM_POWER_STATE_D3);
2668         }
2669
2670         bcm5700_freemem(dev);
2671
2672         QQ_InitQueue(&pDevice->RxPacketFreeQ.Container,
2673                         MAX_RX_PACKET_DESC_COUNT);
2674
2675         return 0;
2676 }
2677
2678 STATIC int
2679 bcm5700_freemem(struct net_device *dev)
2680 {
2681         int i;
2682         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2683         LM_DEVICE_BLOCK  *pDevice = &pUmDevice->lm_dev;
2684
2685         for (i = 0; i < pUmDevice->mem_list_num; i++) {
2686                 if (pUmDevice->mem_size_list[i] == 0) {
2687                         kfree(pUmDevice->mem_list[i]);
2688                 }
2689                 else {
2690                         pci_free_consistent(pUmDevice->pdev,
2691                                 (size_t) pUmDevice->mem_size_list[i],
2692                                 pUmDevice->mem_list[i],
2693                                 pUmDevice->dma_list[i]);
2694                 }
2695         }
2696
2697         pDevice->pStatusBlkVirt = 0;
2698         pDevice->pStatsBlkVirt  = 0;
2699         pUmDevice->mem_list_num = 0;
2700
2701         return 0;
2702 }
2703
2704 uint64_t
2705 bcm5700_crc_count(PUM_DEVICE_BLOCK pUmDevice)
2706 {
2707         PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
2708         LM_UINT32 Value32;
2709         PT3_STATS_BLOCK pStats = (PT3_STATS_BLOCK) pDevice->pStatsBlkVirt;
2710         unsigned long flags;
2711
2712         if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5700 ||
2713                 T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5701) &&
2714                 !(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
2715
2716                 if (!pUmDevice->opened || !pDevice->InitDone)
2717                 {
2718
2719                         return 0;
2720                 }
2721
2722                 /* regulate MDIO access during run time */
2723                 if (pUmDevice->crc_counter_expiry > 0)
2724                         return pUmDevice->phy_crc_count;
2725
2726                 pUmDevice->crc_counter_expiry = (5 * HZ) /
2727                         pUmDevice->timer_interval;
2728
2729                 BCM5700_PHY_LOCK(pUmDevice, flags);
2730                 LM_ReadPhy(pDevice, 0x1e, &Value32);
2731                 if ((Value32 & 0x8000) == 0)
2732                         LM_WritePhy(pDevice, 0x1e, Value32 | 0x8000);
2733                 LM_ReadPhy(pDevice, 0x14, &Value32);
2734                 BCM5700_PHY_UNLOCK(pUmDevice, flags);
2735                 /* Sometimes data on the MDIO bus can be corrupted */
2736                 if (Value32 != 0xffff)
2737                         pUmDevice->phy_crc_count += Value32;
2738                 return pUmDevice->phy_crc_count;
2739         }
2740         else if (pStats == 0) {
2741                 return 0;
2742         }
2743         else {
2744                 return (MM_GETSTATS64(pStats->dot3StatsFCSErrors));
2745         }
2746 }
2747
2748 uint64_t
2749 bcm5700_rx_err_count(UM_DEVICE_BLOCK *pUmDevice)
2750 {
2751         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2752         T3_STATS_BLOCK *pStats = (T3_STATS_BLOCK *) pDevice->pStatsBlkVirt;
2753
2754         if (pStats == 0)
2755                 return 0;
2756         return (bcm5700_crc_count(pUmDevice) +
2757                 MM_GETSTATS64(pStats->dot3StatsAlignmentErrors) +
2758                 MM_GETSTATS64(pStats->etherStatsUndersizePkts) +
2759                 MM_GETSTATS64(pStats->etherStatsFragments) +
2760                 MM_GETSTATS64(pStats->dot3StatsFramesTooLong) +
2761                 MM_GETSTATS64(pStats->etherStatsJabbers));
2762 }
2763
2764 STATIC struct net_device_stats *
2765 bcm5700_get_stats(struct net_device *dev)
2766 {
2767         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2768         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2769         PT3_STATS_BLOCK pStats = (PT3_STATS_BLOCK) pDevice->pStatsBlkVirt;
2770         struct net_device_stats *p_netstats = &pUmDevice->stats;
2771
2772         if (pStats == 0)
2773                 return p_netstats;
2774
2775         /* Get stats from LM */
2776         p_netstats->rx_packets =
2777                 MM_GETSTATS(pStats->ifHCInUcastPkts) +
2778                 MM_GETSTATS(pStats->ifHCInMulticastPkts) +
2779                 MM_GETSTATS(pStats->ifHCInBroadcastPkts);
2780         p_netstats->tx_packets =
2781                 MM_GETSTATS(pStats->ifHCOutUcastPkts) +
2782                 MM_GETSTATS(pStats->ifHCOutMulticastPkts) +
2783                 MM_GETSTATS(pStats->ifHCOutBroadcastPkts);
2784         /* There counters seem to be innacurate. Use byte number accumulation
2785            instead.
2786            p_netstats->rx_bytes = MM_GETSTATS(pStats->ifHCInOctets);
2787            p_netstats->tx_bytes = MM_GETSTATS(pStats->ifHCOutOctets);
2788         */
2789         p_netstats->tx_errors =
2790                 MM_GETSTATS(pStats->dot3StatsInternalMacTransmitErrors) +
2791                 MM_GETSTATS(pStats->dot3StatsCarrierSenseErrors) +
2792                 MM_GETSTATS(pStats->ifOutDiscards) +
2793                 MM_GETSTATS(pStats->ifOutErrors);
2794         p_netstats->multicast = MM_GETSTATS(pStats->ifHCInMulticastPkts);
2795         p_netstats->collisions = MM_GETSTATS(pStats->etherStatsCollisions);
2796         p_netstats->rx_length_errors =
2797                 MM_GETSTATS(pStats->dot3StatsFramesTooLong) +
2798                 MM_GETSTATS(pStats->etherStatsUndersizePkts);
2799         p_netstats->rx_over_errors = MM_GETSTATS(pStats->nicNoMoreRxBDs);
2800         p_netstats->rx_frame_errors =
2801                 MM_GETSTATS(pStats->dot3StatsAlignmentErrors);
2802         p_netstats->rx_crc_errors = (unsigned long)
2803                 bcm5700_crc_count(pUmDevice);
2804         p_netstats->rx_errors = (unsigned long)
2805                 bcm5700_rx_err_count(pUmDevice);
2806
2807         p_netstats->tx_aborted_errors = MM_GETSTATS(pStats->ifOutDiscards);
2808         p_netstats->tx_carrier_errors =
2809                 MM_GETSTATS(pStats->dot3StatsCarrierSenseErrors);
2810
2811         return p_netstats;
2812 }
2813
2814 void
2815 b57_suspend_chip(UM_DEVICE_BLOCK *pUmDevice)
2816 {
2817         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2818
2819         if (pUmDevice->opened) {
2820                 bcm5700_intr_off(pUmDevice);
2821                 netif_carrier_off(pUmDevice->dev);
2822                 netif_stop_queue(pUmDevice->dev);
2823 #ifdef BCM_TASKLET
2824                 tasklet_kill(&pUmDevice->tasklet);
2825 #endif
2826                 bcm5700_poll_wait(pUmDevice);
2827         }
2828         pUmDevice->suspended = 1;
2829         LM_ShutdownChip(pDevice, LM_SUSPEND_RESET);
2830 }
2831
2832 void
2833 b57_resume_chip(UM_DEVICE_BLOCK *pUmDevice)
2834 {
2835         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2836
2837         if (pUmDevice->suspended) {
2838                 pUmDevice->suspended = 0;
2839                 if (pUmDevice->opened) {
2840                         bcm5700_reset(pUmDevice->dev);
2841                 }
2842                 else {
2843                         LM_ShutdownChip(pDevice, LM_SHUTDOWN_RESET);
2844                 }
2845         }
2846 }
2847
2848 /* Returns 0 on failure, 1 on success */
2849 int
2850 b57_test_intr(UM_DEVICE_BLOCK *pUmDevice)
2851 {
2852         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2853         int j;
2854
2855         if (!pUmDevice->opened)
2856                 return 0;
2857         pUmDevice->intr_test_result = 0;
2858         pUmDevice->intr_test = 1;
2859
2860         REG_WR(pDevice, HostCoalesce.Mode,
2861                 pDevice->CoalesceMode | HOST_COALESCE_ENABLE |
2862                 HOST_COALESCE_NOW);
2863
2864         for (j = 0; j < 10; j++) {
2865                 if (pUmDevice->intr_test_result){
2866                         break;
2867                 }
2868
2869                 REG_WR(pDevice, HostCoalesce.Mode,
2870                 pDevice->CoalesceMode | HOST_COALESCE_ENABLE |
2871                 HOST_COALESCE_NOW);
2872
2873                 MM_Sleep(pDevice, 1);
2874         }
2875
2876         return pUmDevice->intr_test_result;
2877
2878 }
2879
2880 #ifdef SIOCETHTOOL
2881
2882 #ifdef ETHTOOL_GSTRINGS
2883
2884 #define ETH_NUM_STATS 30
2885 #define RX_CRC_IDX 5
2886 #define RX_MAC_ERR_IDX 14
2887
2888 struct {
2889         char string[ETH_GSTRING_LEN];
2890 } bcm5700_stats_str_arr[ETH_NUM_STATS] = {
2891         { "rx_unicast_packets" },
2892         { "rx_multicast_packets" },
2893         { "rx_broadcast_packets" },
2894         { "rx_bytes" },
2895         { "rx_fragments" },
2896         { "rx_crc_errors" },    /* this needs to be calculated */
2897         { "rx_align_errors" },
2898         { "rx_xon_frames" },
2899         { "rx_xoff_frames" },
2900         { "rx_long_frames" },
2901         { "rx_short_frames" },
2902         { "rx_jabber" },
2903         { "rx_discards" },
2904         { "rx_errors" },
2905         { "rx_mac_errors" },    /* this needs to be calculated */
2906         { "tx_unicast_packets" },
2907         { "tx_multicast_packets" },
2908         { "tx_broadcast_packets" },
2909         { "tx_bytes" },
2910         { "tx_deferred" },
2911         { "tx_single_collisions" },
2912         { "tx_multi_collisions" },
2913         { "tx_total_collisions" },
2914         { "tx_excess_collisions" },
2915         { "tx_late_collisions" },
2916         { "tx_xon_frames" },
2917         { "tx_xoff_frames" },
2918         { "tx_internal_mac_errors" },
2919         { "tx_carrier_errors" },
2920         { "tx_errors" },
2921 };
2922
2923 #define STATS_OFFSET(offset_name) ((OFFSETOF(T3_STATS_BLOCK, offset_name)) / sizeof(uint64_t))
2924
2925 #ifdef __BIG_ENDIAN
2926 #define SWAP_DWORD_64(x) (x)
2927 #else
2928 #define SWAP_DWORD_64(x) ((x << 32) | (x >> 32))
2929 #endif
2930
2931 unsigned long bcm5700_stats_offset_arr[ETH_NUM_STATS] = {
2932         STATS_OFFSET(ifHCInUcastPkts),
2933         STATS_OFFSET(ifHCInMulticastPkts),
2934         STATS_OFFSET(ifHCInBroadcastPkts),
2935         STATS_OFFSET(ifHCInOctets),
2936         STATS_OFFSET(etherStatsFragments),
2937         0,
2938         STATS_OFFSET(dot3StatsAlignmentErrors),
2939         STATS_OFFSET(xonPauseFramesReceived),
2940         STATS_OFFSET(xoffPauseFramesReceived),
2941         STATS_OFFSET(dot3StatsFramesTooLong),
2942         STATS_OFFSET(etherStatsUndersizePkts),
2943         STATS_OFFSET(etherStatsJabbers),
2944         STATS_OFFSET(ifInDiscards),
2945         STATS_OFFSET(ifInErrors),
2946         0,
2947         STATS_OFFSET(ifHCOutUcastPkts),
2948         STATS_OFFSET(ifHCOutMulticastPkts),
2949         STATS_OFFSET(ifHCOutBroadcastPkts),
2950         STATS_OFFSET(ifHCOutOctets),
2951         STATS_OFFSET(dot3StatsDeferredTransmissions),
2952         STATS_OFFSET(dot3StatsSingleCollisionFrames),
2953         STATS_OFFSET(dot3StatsMultipleCollisionFrames),
2954         STATS_OFFSET(etherStatsCollisions),
2955         STATS_OFFSET(dot3StatsExcessiveCollisions),
2956         STATS_OFFSET(dot3StatsLateCollisions),
2957         STATS_OFFSET(outXonSent),
2958         STATS_OFFSET(outXoffSent),
2959         STATS_OFFSET(dot3StatsInternalMacTransmitErrors),
2960         STATS_OFFSET(dot3StatsCarrierSenseErrors),
2961         STATS_OFFSET(ifOutErrors),
2962 };
2963
2964 #endif /* ETHTOOL_GSTRINGS */
2965
2966
2967 #ifdef ETHTOOL_GREGS
2968 #if (LINUX_VERSION_CODE >= 0x02040f)
2969 static void
2970 bcm5700_get_reg_blk(UM_DEVICE_BLOCK *pUmDevice, u32 **buf, u32 start, u32 end,
2971                 int reserved)
2972 {
2973         u32 offset;
2974         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2975
2976         if (reserved) {
2977                 memset(*buf, 0, end - start);
2978                 *buf = *buf + (end - start)/4;
2979                 return;
2980         }
2981         for (offset = start; offset < end; offset+=4, *buf = *buf + 1) {
2982                 if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)){
2983                         if (((offset >= 0x3400) && (offset < 0x3c00)) ||
2984                                 ((offset >= 0x5400) && (offset < 0x5800)) ||
2985                                 ((offset >= 0x6400) && (offset < 0x6800))) {
2986                                 **buf = 0;
2987                                 continue;
2988                         }
2989                 }
2990                 **buf = REG_RD_OFFSET(pDevice, offset);
2991         }
2992 }
2993 #endif
2994 #endif
2995
2996 static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
2997 {
2998         struct ethtool_cmd ethcmd;
2999         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
3000         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
3001
3002         if (mm_copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
3003                 return -EFAULT;
3004
3005         switch (ethcmd.cmd) {
3006 #ifdef ETHTOOL_GDRVINFO
3007         case ETHTOOL_GDRVINFO: {
3008                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3009
3010                 strcpy(info.driver,  bcm5700_driver);
3011 #ifdef INCLUDE_5701_AX_FIX
3012                 if(pDevice->ChipRevId == T3_CHIP_ID_5701_A0) {
3013                         extern int t3FwReleaseMajor;
3014                         extern int t3FwReleaseMinor;
3015                         extern int t3FwReleaseFix;
3016
3017                         sprintf(info.fw_version, "%i.%i.%i",
3018                                 t3FwReleaseMajor, t3FwReleaseMinor,
3019                                 t3FwReleaseFix);
3020                 }
3021 #endif
3022                 strcpy(info.fw_version, pDevice->BootCodeVer);
3023                 strcpy(info.version, bcm5700_version);
3024 #if (LINUX_VERSION_CODE <= 0x020422)
3025                 strcpy(info.bus_info, pUmDevice->pdev->slot_name);
3026 #else
3027                 strcpy(info.bus_info, pci_name(pUmDevice->pdev));
3028 #endif
3029
3030
3031
3032 #ifdef ETHTOOL_GEEPROM
3033                 BCM_EEDUMP_LEN(&info, pDevice->NvramSize);
3034 #endif
3035 #ifdef ETHTOOL_GREGS
3036                 /* dump everything, including holes in the register space */
3037                 info.regdump_len = 0x6c00;
3038 #endif
3039 #ifdef ETHTOOL_GSTATS
3040                 info.n_stats = ETH_NUM_STATS;
3041 #endif
3042                 if (mm_copy_to_user(useraddr, &info, sizeof(info)))
3043                         return -EFAULT;
3044                 return 0;
3045         }
3046 #endif
3047         case ETHTOOL_GSET: {
3048                 if ((pDevice->TbiFlags & ENABLE_TBI_FLAG)||
3049                         (pDevice->PhyFlags & PHY_IS_FIBER)) {
3050                         ethcmd.supported =
3051                                 (SUPPORTED_1000baseT_Full |
3052                                 SUPPORTED_Autoneg);
3053                         ethcmd.supported |= SUPPORTED_FIBRE;
3054                         ethcmd.port = PORT_FIBRE;
3055                 } else {
3056                         ethcmd.supported =
3057                                 (SUPPORTED_10baseT_Half |
3058                                 SUPPORTED_10baseT_Full |
3059                                 SUPPORTED_100baseT_Half |
3060                                 SUPPORTED_100baseT_Full |
3061                                 SUPPORTED_1000baseT_Half |
3062                                 SUPPORTED_1000baseT_Full |
3063                                 SUPPORTED_Autoneg);
3064                         ethcmd.supported |= SUPPORTED_TP;
3065                         ethcmd.port = PORT_TP;
3066                 }
3067
3068                 ethcmd.transceiver = XCVR_INTERNAL;
3069                 ethcmd.phy_address = 0;
3070
3071                 if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS)
3072                         ethcmd.speed = SPEED_1000;
3073                 else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS)
3074                         ethcmd.speed = SPEED_100;
3075                 else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS)
3076                         ethcmd.speed = SPEED_10;
3077                 else
3078                         ethcmd.speed = 0;
3079
3080                 if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL)
3081                         ethcmd.duplex = DUPLEX_FULL;
3082                 else
3083                         ethcmd.duplex = DUPLEX_HALF;
3084
3085                 if (pDevice->DisableAutoNeg == FALSE) {
3086                         ethcmd.autoneg = AUTONEG_ENABLE;
3087                         ethcmd.advertising = ADVERTISED_Autoneg;
3088                         if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) ||
3089                                 (pDevice->PhyFlags & PHY_IS_FIBER)) {
3090                                 ethcmd.advertising |=
3091                                         ADVERTISED_1000baseT_Full |
3092                                         ADVERTISED_FIBRE;
3093                         }
3094                         else {
3095                                 ethcmd.advertising |=
3096                                         ADVERTISED_TP;
3097                                 if (pDevice->advertising &
3098                                         PHY_AN_AD_10BASET_HALF) {
3099
3100                                         ethcmd.advertising |=
3101                                                 ADVERTISED_10baseT_Half;
3102                                 }
3103                                 if (pDevice->advertising &
3104                                         PHY_AN_AD_10BASET_FULL) {
3105
3106                                         ethcmd.advertising |=
3107                                                 ADVERTISED_10baseT_Full;
3108                                 }
3109                                 if (pDevice->advertising &
3110                                         PHY_AN_AD_100BASETX_HALF) {
3111
3112                                         ethcmd.advertising |=
3113                                                 ADVERTISED_100baseT_Half;
3114                                 }
3115                                 if (pDevice->advertising &
3116                                         PHY_AN_AD_100BASETX_FULL) {
3117
3118                                         ethcmd.advertising |=
3119                                                 ADVERTISED_100baseT_Full;
3120                                 }
3121                                 if (pDevice->advertising1000 &
3122                                         BCM540X_AN_AD_1000BASET_HALF) {
3123
3124                                         ethcmd.advertising |=
3125                                                 ADVERTISED_1000baseT_Half;
3126                                 }
3127                                 if (pDevice->advertising1000 &
3128                                         BCM540X_AN_AD_1000BASET_FULL) {
3129
3130                                         ethcmd.advertising |=
3131                                                 ADVERTISED_1000baseT_Full;
3132                                 }
3133                         }
3134                 }
3135                 else {
3136                         ethcmd.autoneg = AUTONEG_DISABLE;
3137                         ethcmd.advertising = 0;
3138                 }
3139
3140                 ethcmd.maxtxpkt = pDevice->TxMaxCoalescedFrames;
3141                 ethcmd.maxrxpkt = pDevice->RxMaxCoalescedFrames;
3142
3143                 if(mm_copy_to_user(useraddr, &ethcmd, sizeof(ethcmd)))
3144                         return -EFAULT;
3145                 return 0;
3146         }
3147         case ETHTOOL_SSET: {
3148                 unsigned long flags;
3149
3150                 if(!capable(CAP_NET_ADMIN))
3151                         return -EPERM;
3152                 if (ethcmd.autoneg == AUTONEG_ENABLE) {
3153                         pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
3154                         pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_UNKNOWN;
3155                         pDevice->DisableAutoNeg = FALSE;
3156                 }
3157                 else {
3158                         if (ethcmd.speed == SPEED_1000 &&
3159                                 pDevice->PhyFlags & PHY_NO_GIGABIT)
3160                                         return -EINVAL;
3161
3162                         if (ethcmd.speed == SPEED_1000 &&
3163                             (pDevice->TbiFlags & ENABLE_TBI_FLAG ||
3164                              pDevice->PhyFlags & PHY_IS_FIBER ) ) {
3165
3166                                 pDevice->RequestedLineSpeed =
3167                                         LM_LINE_SPEED_1000MBPS;
3168
3169                                 pDevice->RequestedDuplexMode =
3170                                         LM_DUPLEX_MODE_FULL;
3171                         }
3172                         else if (ethcmd.speed == SPEED_100 &&
3173                                 !(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3174                                 !(pDevice->PhyFlags & PHY_IS_FIBER)) {
3175
3176                                 pDevice->RequestedLineSpeed =
3177                                         LM_LINE_SPEED_100MBPS;
3178                         }
3179                         else if (ethcmd.speed == SPEED_10  &&
3180                                 !(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3181                                 !(pDevice->PhyFlags & PHY_IS_FIBER)) {
3182
3183                                 pDevice->RequestedLineSpeed =
3184                                         LM_LINE_SPEED_10MBPS;
3185                         }
3186                         else {
3187                                 return -EINVAL;
3188                         }
3189
3190                         pDevice->DisableAutoNeg = TRUE;
3191                         if (ethcmd.duplex == DUPLEX_FULL) {
3192                                 pDevice->RequestedDuplexMode =
3193                                         LM_DUPLEX_MODE_FULL;
3194                         }
3195                         else {
3196                                 if (!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3197                                     !(pDevice->PhyFlags & PHY_IS_FIBER)  ) {
3198
3199                                         pDevice->RequestedDuplexMode =
3200                                                         LM_DUPLEX_MODE_HALF;
3201                                 }
3202                         }
3203                 }
3204                 if (netif_running(dev)) {
3205                         BCM5700_PHY_LOCK(pUmDevice, flags);
3206                         LM_SetupPhy(pDevice);
3207                         BCM5700_PHY_UNLOCK(pUmDevice, flags);
3208                 }
3209                 return 0;
3210         }
3211 #ifdef ETHTOOL_GWOL
3212 #ifdef BCM_WOL
3213         case ETHTOOL_GWOL: {
3214                 struct ethtool_wolinfo wol = {ETHTOOL_GWOL};
3215
3216                 if (((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3217                         !(pDevice->Flags & FIBER_WOL_CAPABLE_FLAG)) ||
3218                         (pDevice->Flags & DISABLE_D3HOT_FLAG)) {
3219                         wol.supported = 0;
3220                         wol.wolopts = 0;
3221                 }
3222                 else {
3223                         wol.supported = WAKE_MAGIC;
3224                         if (pDevice->WakeUpMode == LM_WAKE_UP_MODE_MAGIC_PACKET)
3225                         {
3226                                 wol.wolopts = WAKE_MAGIC;
3227                         }
3228                         else {
3229                                 wol.wolopts = 0;
3230                         }
3231                 }
3232                 if (mm_copy_to_user(useraddr, &wol, sizeof(wol)))
3233                         return -EFAULT;
3234                 return 0;
3235         }
3236         case ETHTOOL_SWOL: {
3237                 struct ethtool_wolinfo wol;
3238
3239                 if(!capable(CAP_NET_ADMIN))
3240                         return -EPERM;
3241                 if (mm_copy_from_user(&wol, useraddr, sizeof(wol)))
3242                         return -EFAULT;
3243                 if ((((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3244                         !(pDevice->Flags & FIBER_WOL_CAPABLE_FLAG)) ||
3245                         (pDevice->Flags & DISABLE_D3HOT_FLAG)) &&
3246                         wol.wolopts) {
3247                         return -EINVAL;
3248                 }
3249
3250                 if ((wol.wolopts & ~WAKE_MAGIC) != 0) {
3251                         return -EINVAL;
3252                 }
3253                 if (wol.wolopts & WAKE_MAGIC) {
3254                         pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET;
3255                         pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET;
3256                 }
3257                 else {
3258                         pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_NONE;
3259                         pDevice->WakeUpMode = LM_WAKE_UP_MODE_NONE;
3260                 }
3261                 return 0;
3262         }
3263 #endif
3264 #endif
3265 #ifdef ETHTOOL_GLINK
3266         case ETHTOOL_GLINK: {
3267                 struct ethtool_value edata = {ETHTOOL_GLINK};
3268
3269                 /* ifup only waits for 5 seconds for link up */
3270                 /* NIC may take more than 5 seconds to establish link */
3271                 if ((pUmDevice->delayed_link_ind > 0) &&
3272                         delay_link[pUmDevice->index])
3273                         return -EOPNOTSUPP;
3274
3275                 if (pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE) {
3276                         edata.data =  1;
3277                 }
3278                 else {
3279                         edata.data =  0;
3280                 }
3281                 if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3282                         return -EFAULT;
3283                 return 0;
3284         }
3285 #endif
3286 #ifdef ETHTOOL_NWAY_RST
3287         case ETHTOOL_NWAY_RST: {
3288                 LM_UINT32 phyctrl;
3289                 unsigned long flags;
3290
3291                 if(!capable(CAP_NET_ADMIN))
3292                         return -EPERM;
3293                 if (pDevice->DisableAutoNeg) {
3294                         return -EINVAL;
3295                 }
3296                 if (!netif_running(dev))
3297                         return -EAGAIN;
3298                 BCM5700_PHY_LOCK(pUmDevice, flags);
3299                 if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
3300                         pDevice->RequestedLineSpeed = LM_LINE_SPEED_1000MBPS;
3301                         pDevice->DisableAutoNeg = TRUE;
3302                         LM_SetupPhy(pDevice);
3303
3304                         pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
3305                         pDevice->DisableAutoNeg = FALSE;
3306                         LM_SetupPhy(pDevice);
3307                 }
3308                 else {
3309                         if ((T3_ASIC_REV(pDevice->ChipRevId) ==
3310                                         T3_ASIC_REV_5703) ||
3311                                 (T3_ASIC_REV(pDevice->ChipRevId) ==
3312                                         T3_ASIC_REV_5704) ||
3313                                 (T3_ASIC_REV(pDevice->ChipRevId) ==
3314                                         T3_ASIC_REV_5705))
3315                         {
3316                                 LM_ResetPhy(pDevice);
3317                                 LM_SetupPhy(pDevice);
3318                         }
3319                         pDevice->PhyFlags &= ~PHY_FIBER_FALLBACK;
3320                         LM_ReadPhy(pDevice, PHY_CTRL_REG, &phyctrl);
3321                         LM_WritePhy(pDevice, PHY_CTRL_REG, phyctrl |
3322                                 PHY_CTRL_AUTO_NEG_ENABLE |
3323                                 PHY_CTRL_RESTART_AUTO_NEG);
3324                 }
3325                 BCM5700_PHY_UNLOCK(pUmDevice, flags);
3326                 return 0;
3327         }
3328 #endif
3329 #ifdef ETHTOOL_GEEPROM
3330         case ETHTOOL_GEEPROM: {
3331                 struct ethtool_eeprom eeprom;
3332                 LM_UINT32 *buf = 0;
3333                 LM_UINT32 buf1[64/4];
3334                 int i, j, offset, len;
3335
3336                 if (mm_copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
3337                         return -EFAULT;
3338
3339                 if (eeprom.offset >= pDevice->NvramSize)
3340                         return -EFAULT;
3341
3342                 /* maximum data limited */
3343                 /* to read more, call again with a different offset */
3344                 if (eeprom.len > 0x800) {
3345                         eeprom.len = 0x800;
3346                         if (mm_copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
3347                                 return -EFAULT;
3348                 }
3349
3350                 if (eeprom.len > 64) {
3351                         buf = kmalloc(eeprom.len, GFP_KERNEL);
3352                         if (!buf)
3353                                 return -ENOMEM;
3354                 }
3355                 else {
3356                         buf = buf1;
3357                 }
3358                 useraddr += offsetof(struct ethtool_eeprom, data);
3359
3360                 offset = eeprom.offset;
3361                 len = eeprom.len;
3362                 if (offset & 3) {
3363                         offset &= 0xfffffffc;
3364                         len += (offset & 3);
3365                 }
3366                 len = (len + 3) & 0xfffffffc;
3367                 for (i = 0, j = 0; j < len; i++, j += 4) {
3368                         if (LM_NvramRead(pDevice, offset + j, buf + i) !=
3369                                 LM_STATUS_SUCCESS) {
3370                                 break;
3371                         }
3372                 }
3373                 if (j >= len) {
3374                         buf += (eeprom.offset & 3);
3375                         i = mm_copy_to_user(useraddr, buf, eeprom.len);
3376                 }
3377                 if (eeprom.len > 64) {
3378                         kfree(buf);
3379                 }
3380                 if ((j < len) || i)
3381                         return -EFAULT;
3382                 return 0;
3383         }
3384         case ETHTOOL_SEEPROM: {
3385                 struct ethtool_eeprom eeprom;
3386                 LM_UINT32 buf[64/4];
3387                 int i, offset, len;
3388
3389                 if(!capable(CAP_NET_ADMIN))
3390                         return -EPERM;
3391                 if (mm_copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
3392                         return -EFAULT;
3393
3394                 if ((eeprom.offset & 3) || (eeprom.len & 3) ||
3395                         (eeprom.offset >= pDevice->NvramSize)) {
3396                         return -EFAULT;
3397                 }
3398
3399                 if ((eeprom.offset + eeprom.len) >= pDevice->NvramSize) {
3400                         eeprom.len = pDevice->NvramSize - eeprom.offset;
3401                 }
3402
3403                 useraddr += offsetof(struct ethtool_eeprom, data);
3404
3405                 len = eeprom.len;
3406                 offset = eeprom.offset;
3407                 for (; len > 0; ) {
3408                         if (len < 64)
3409                                 i = len;
3410                         else
3411                                 i = 64;
3412                         if (mm_copy_from_user(&buf, useraddr, i))
3413                                 return -EFAULT;
3414
3415                         bcm5700_intr_off(pUmDevice);
3416                         /* Prevent race condition on Grc.Mode register */
3417                         bcm5700_poll_wait(pUmDevice);
3418
3419                         if (LM_NvramWriteBlock(pDevice, offset, buf, i/4) !=
3420                                 LM_STATUS_SUCCESS) {
3421                                 bcm5700_intr_on(pUmDevice);
3422                                 return -EFAULT;
3423                         }
3424                         bcm5700_intr_on(pUmDevice);
3425                         len -= i;
3426                         offset += i;
3427                         useraddr += i;
3428                 }
3429                 return 0;
3430         }
3431 #endif
3432 #ifdef ETHTOOL_GREGS
3433 #if (LINUX_VERSION_CODE >= 0x02040f)
3434         case ETHTOOL_GREGS: {
3435                 struct ethtool_regs eregs;
3436                 LM_UINT32 *buf, *buf1;
3437                 unsigned int i;
3438
3439                 if(!capable(CAP_NET_ADMIN))
3440                         return -EPERM;
3441                 if (pDevice->Flags & UNDI_FIX_FLAG)
3442                         return -EOPNOTSUPP;
3443                 if (mm_copy_from_user(&eregs, useraddr, sizeof(eregs)))
3444                         return -EFAULT;
3445                 if (eregs.len > 0x6c00)
3446                         eregs.len = 0x6c00;
3447                 eregs.version = 0x0;
3448                 if (mm_copy_to_user(useraddr, &eregs, sizeof(eregs)))
3449                         return -EFAULT;
3450                 buf = buf1 = kmalloc(eregs.len, GFP_KERNEL);
3451                 if (!buf)
3452                         return -ENOMEM;
3453                 bcm5700_get_reg_blk(pUmDevice, &buf, 0,      0xb0,   0);
3454                 bcm5700_get_reg_blk(pUmDevice, &buf, 0xb0,   0x200,  1);
3455                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x200,  0x8f0,  0);
3456                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x8f0,  0xc00,  1);
3457                 bcm5700_get_reg_blk(pUmDevice, &buf, 0xc00,  0xce0,  0);
3458                 bcm5700_get_reg_blk(pUmDevice, &buf, 0xce0,  0x1000, 1);
3459                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1000, 0x1004, 0);
3460                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1004, 0x1400, 1);
3461                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1400, 0x1480, 0);
3462                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1480, 0x1800, 1);
3463                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1800, 0x1848, 0);
3464                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1848, 0x1c00, 1);
3465                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1c00, 0x1c04, 0);
3466                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x1c04, 0x2000, 1);
3467                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x2000, 0x225c, 0);
3468                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x225c, 0x2400, 1);
3469                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x2400, 0x24c4, 0);
3470                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x24c4, 0x2800, 1);
3471                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x2800, 0x2804, 0);
3472                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x2804, 0x2c00, 1);
3473                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x2c00, 0x2c20, 0);
3474                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x2c20, 0x3000, 1);
3475                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3000, 0x3014, 0);
3476                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3014, 0x3400, 1);
3477                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3400, 0x3408, 0);
3478                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3408, 0x3800, 1);
3479                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3800, 0x3808, 0);
3480                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3808, 0x3c00, 1);
3481                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3c00, 0x3d00, 0);
3482                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x3d00, 0x4000, 1);
3483                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4000, 0x4010, 0);
3484                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4010, 0x4400, 1);
3485                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4400, 0x4458, 0);
3486                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4458, 0x4800, 1);
3487                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4800, 0x4808, 0);
3488                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4808, 0x4c00, 1);
3489                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4c00, 0x4c08, 0);
3490                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x4c08, 0x5000, 1);
3491                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x5000, 0x5050, 0);
3492                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x5050, 0x5400, 1);
3493                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x5400, 0x5450, 0);
3494                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x5450, 0x5800, 1);
3495                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x5800, 0x5a10, 0);
3496                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x5a10, 0x6000, 1);
3497                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x6000, 0x600c, 0);
3498                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x600c, 0x6400, 1);
3499                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x6400, 0x6404, 0);
3500                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x6404, 0x6800, 1);
3501                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x6800, 0x6848, 0);
3502                 bcm5700_get_reg_blk(pUmDevice, &buf, 0x6848, 0x6c00, 1);
3503
3504                 i = mm_copy_to_user(useraddr + sizeof(eregs), buf1, eregs.len);
3505                 kfree(buf1);
3506                 if (i)
3507                         return -EFAULT;
3508                 return 0;
3509         }
3510 #endif
3511 #endif
3512 #ifdef ETHTOOL_GPAUSEPARAM
3513         case ETHTOOL_GPAUSEPARAM: {
3514                 struct ethtool_pauseparam epause = { ETHTOOL_GPAUSEPARAM };
3515
3516                 if (!pDevice->DisableAutoNeg) {
3517                         epause.autoneg = (pDevice->FlowControlCap &
3518                                 LM_FLOW_CONTROL_AUTO_PAUSE) != 0;
3519                 }
3520                 else {
3521                         epause.autoneg = 0;
3522                 }
3523                 epause.rx_pause =
3524                         (pDevice->FlowControl &
3525                         LM_FLOW_CONTROL_RECEIVE_PAUSE) != 0;
3526                 epause.tx_pause =
3527                         (pDevice->FlowControl &
3528                         LM_FLOW_CONTROL_TRANSMIT_PAUSE) != 0;
3529                 if (mm_copy_to_user(useraddr, &epause, sizeof(epause)))
3530                         return -EFAULT;
3531
3532                 return 0;
3533         }
3534         case ETHTOOL_SPAUSEPARAM: {
3535                 struct ethtool_pauseparam epause;
3536                 unsigned long flags;
3537
3538                 if(!capable(CAP_NET_ADMIN))
3539                         return -EPERM;
3540                 if (mm_copy_from_user(&epause, useraddr, sizeof(epause)))
3541                         return -EFAULT;
3542                 pDevice->FlowControlCap = 0;
3543                 if (epause.autoneg && !pDevice->DisableAutoNeg) {
3544                         pDevice->FlowControlCap |= LM_FLOW_CONTROL_AUTO_PAUSE;
3545                 }
3546                 if (epause.rx_pause)  {
3547                         pDevice->FlowControlCap |=
3548                                 LM_FLOW_CONTROL_RECEIVE_PAUSE;
3549                 }
3550                 if (epause.tx_pause)  {
3551                         pDevice->FlowControlCap |=
3552                                 LM_FLOW_CONTROL_TRANSMIT_PAUSE;
3553                 }
3554                 if (netif_running(dev)) {
3555                         BCM5700_PHY_LOCK(pUmDevice, flags);
3556                         LM_SetupPhy(pDevice);
3557                         BCM5700_PHY_UNLOCK(pUmDevice, flags);
3558                 }
3559
3560                 return 0;
3561         }
3562 #endif
3563 #ifdef ETHTOOL_GRXCSUM
3564         case ETHTOOL_GRXCSUM: {
3565                 struct ethtool_value edata = { ETHTOOL_GRXCSUM };
3566
3567                 edata.data =
3568                         (pDevice->TaskToOffload &
3569                         LM_TASK_OFFLOAD_RX_TCP_CHECKSUM) != 0;
3570                 if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3571                         return -EFAULT;
3572
3573                 return 0;
3574         }
3575         case ETHTOOL_SRXCSUM: {
3576                 struct ethtool_value edata;
3577
3578                 if(!capable(CAP_NET_ADMIN))
3579                         return -EPERM;
3580                 if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3581                         return -EFAULT;
3582                 if (edata.data) {
3583                         if (!(pDevice->TaskOffloadCap &
3584                                 LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
3585
3586                                 return -EINVAL;
3587                         }
3588                         pDevice->TaskToOffload |=
3589                                 LM_TASK_OFFLOAD_RX_TCP_CHECKSUM |
3590                                 LM_TASK_OFFLOAD_RX_UDP_CHECKSUM;
3591                 }
3592                 else {
3593                         pDevice->TaskToOffload &=
3594                                 ~(LM_TASK_OFFLOAD_RX_TCP_CHECKSUM |
3595                                 LM_TASK_OFFLOAD_RX_UDP_CHECKSUM);
3596                 }
3597                 return 0;
3598         }
3599         case ETHTOOL_GTXCSUM: {
3600                 struct ethtool_value edata = { ETHTOOL_GTXCSUM };
3601
3602                 edata.data =
3603                         (dev->features & get_csum_flag( pDevice->ChipRevId)) != 0;
3604                 if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3605                         return -EFAULT;
3606
3607                 return 0;
3608         }
3609         case ETHTOOL_STXCSUM: {
3610                 struct ethtool_value edata;
3611
3612                 if(!capable(CAP_NET_ADMIN))
3613                         return -EPERM;
3614                 if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3615                         return -EFAULT;
3616                 if (edata.data) {
3617                         if (!(pDevice->TaskOffloadCap &
3618                                 LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
3619
3620                                 return -EINVAL;
3621                         }
3622                         dev->features |= get_csum_flag( pDevice->ChipRevId);
3623                         pDevice->TaskToOffload |=
3624                                 LM_TASK_OFFLOAD_TX_TCP_CHECKSUM |
3625                                 LM_TASK_OFFLOAD_TX_UDP_CHECKSUM;
3626                 }
3627                 else {
3628                         dev->features &= ~get_csum_flag( pDevice->ChipRevId);
3629                         pDevice->TaskToOffload &=
3630                                 ~(LM_TASK_OFFLOAD_TX_TCP_CHECKSUM |
3631                                 LM_TASK_OFFLOAD_TX_UDP_CHECKSUM);
3632                 }
3633                 return 0;
3634         }
3635         case ETHTOOL_GSG: {
3636                 struct ethtool_value edata = { ETHTOOL_GSG };
3637
3638                 edata.data =
3639                         (dev->features & NETIF_F_SG) != 0;
3640                 if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3641                         return -EFAULT;
3642                 return 0;
3643         }
3644         case ETHTOOL_SSG: {
3645                 struct ethtool_value edata;
3646
3647                 if(!capable(CAP_NET_ADMIN))
3648                         return -EPERM;
3649                 if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3650                         return -EFAULT;
3651                 if (edata.data) {
3652                         dev->features |= NETIF_F_SG;
3653                 }
3654                 else {
3655                         dev->features &= ~NETIF_F_SG;
3656                 }
3657                 return 0;
3658         }
3659 #endif
3660 #ifdef ETHTOOL_GRINGPARAM
3661         case ETHTOOL_GRINGPARAM: {
3662                 struct ethtool_ringparam ering = { ETHTOOL_GRINGPARAM };
3663
3664                 ering.rx_max_pending = T3_STD_RCV_RCB_ENTRY_COUNT - 1;
3665                 ering.rx_pending = pDevice->RxStdDescCnt;
3666                 ering.rx_mini_max_pending = 0;
3667                 ering.rx_mini_pending = 0;
3668 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
3669                 ering.rx_jumbo_max_pending = T3_JUMBO_RCV_RCB_ENTRY_COUNT - 1;
3670                 ering.rx_jumbo_pending = pDevice->RxJumboDescCnt;
3671 #else
3672                 ering.rx_jumbo_max_pending = 0;
3673                 ering.rx_jumbo_pending = 0;
3674 #endif
3675                 ering.tx_max_pending = MAX_TX_PACKET_DESC_COUNT - 1;
3676                 ering.tx_pending = pDevice->TxPacketDescCnt;
3677                 if (mm_copy_to_user(useraddr, &ering, sizeof(ering)))
3678                         return -EFAULT;
3679                 return 0;
3680         }
3681 #endif
3682 #ifdef ETHTOOL_PHYS_ID
3683         case ETHTOOL_PHYS_ID: {
3684                 struct ethtool_value edata;
3685
3686                 if(!capable(CAP_NET_ADMIN))
3687                         return -EPERM;
3688                 if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3689                         return -EFAULT;
3690                 if (LM_BlinkLED(pDevice, edata.data) == LM_STATUS_SUCCESS)
3691                         return 0;
3692                 return -EINTR;
3693         }
3694 #endif
3695 #ifdef ETHTOOL_GSTRINGS
3696         case ETHTOOL_GSTRINGS: {
3697                 struct ethtool_gstrings egstr = { ETHTOOL_GSTRINGS };
3698
3699                 if (mm_copy_from_user(&egstr, useraddr, sizeof(egstr)))
3700                         return -EFAULT;
3701                 switch(egstr.string_set) {
3702 #ifdef ETHTOOL_GSTATS
3703                 case ETH_SS_STATS:
3704                         egstr.len = ETH_NUM_STATS;
3705                         if (mm_copy_to_user(useraddr, &egstr, sizeof(egstr)))
3706                                 return -EFAULT;
3707                         if (mm_copy_to_user(useraddr + sizeof(egstr),
3708                                 bcm5700_stats_str_arr,
3709                                 sizeof(bcm5700_stats_str_arr)))
3710                                 return -EFAULT;
3711                         return 0;
3712 #endif
3713                 default:
3714                         return -EOPNOTSUPP;
3715                 }
3716                 }
3717 #endif
3718 #ifdef ETHTOOL_GSTATS
3719         case ETHTOOL_GSTATS: {
3720                 struct ethtool_stats estats = { ETHTOOL_GSTATS };
3721                 uint64_t stats[ETH_NUM_STATS];
3722                 int i;
3723                 uint64_t *pStats =
3724                         (uint64_t *) pDevice->pStatsBlkVirt;
3725
3726                 estats.n_stats = ETH_NUM_STATS;
3727                 if (pStats == 0) {
3728                         memset(stats, 0, sizeof(stats));
3729                 }
3730                 else {
3731
3732                         for (i = 0; i < ETH_NUM_STATS; i++) {
3733                                 if (bcm5700_stats_offset_arr[i] != 0) {
3734                                         stats[i] = SWAP_DWORD_64(*(pStats +
3735                                                 bcm5700_stats_offset_arr[i]));
3736                                 }
3737                                 else if (i == RX_CRC_IDX) {
3738                                         stats[i] =
3739                                                 bcm5700_crc_count(pUmDevice);
3740                                 }
3741                                 else if (i == RX_MAC_ERR_IDX) {
3742                                         stats[i] =
3743                                                 bcm5700_rx_err_count(pUmDevice);
3744                                 }
3745                         }
3746                 }
3747                 if (mm_copy_to_user(useraddr, &estats, sizeof(estats))) {
3748                         return -EFAULT;
3749                 }
3750                 if (mm_copy_to_user(useraddr + sizeof(estats), &stats,
3751                         sizeof(stats))) {
3752                         return -EFAULT;
3753                 }
3754                 return 0;
3755         }
3756 #endif
3757 #ifdef ETHTOOL_GTSO
3758         case ETHTOOL_GTSO: {
3759                 struct ethtool_value edata = { ETHTOOL_GTSO };
3760
3761 #ifdef BCM_TSO
3762                 edata.data =
3763                         (dev->features & NETIF_F_TSO) != 0;
3764 #else
3765                 edata.data = 0;
3766 #endif
3767                 if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3768                         return -EFAULT;
3769                 return 0;
3770         }
3771 #endif
3772 #ifdef ETHTOOL_STSO
3773         case ETHTOOL_STSO: {
3774 #ifdef BCM_TSO
3775                 struct ethtool_value edata;
3776
3777                 if (!capable(CAP_NET_ADMIN))
3778                         return -EPERM;
3779
3780                 if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3781                         return -EFAULT;
3782
3783                 if (!(pDevice->TaskToOffload &
3784                         LM_TASK_OFFLOAD_TCP_SEGMENTATION)) {
3785                         return -EINVAL;
3786                 }
3787
3788                 dev->features &= ~NETIF_F_TSO;
3789
3790                 if (edata.data) {
3791                         if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
3792                            (dev->mtu > 1500)) {
3793                                 printk(KERN_ALERT "%s: Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
3794                         return -EINVAL;
3795                         } else {
3796                                 dev->features |= NETIF_F_TSO;
3797                         }
3798                 }
3799                 return 0;
3800 #else
3801                 return -EINVAL;
3802 #endif
3803         }
3804 #endif
3805         }
3806
3807         return -EOPNOTSUPP;
3808 }
3809 #endif /* #ifdef SIOCETHTOOL */
3810
3811 #if (LINUX_VERSION_CODE >= 0x20400) && (LINUX_VERSION_CODE < 0x20600)
3812 #include <linux/iobuf.h>
3813 #endif
3814
3815 /* Provide ioctl() calls to examine the MII xcvr state. */
3816 STATIC int bcm5700_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3817 {
3818         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
3819         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
3820         u16 *data = (u16 *)&rq->ifr_data;
3821         u32 value = 0;
3822         u16 page_num =0, addr_num =0, len =0;
3823         unsigned long flags;
3824
3825         switch(cmd) {
3826         case SIOCGREG_STATUS: //Get register
3827         {
3828                 struct reg_ioctl_data *rdata =(struct reg_ioctl_data *)rq->ifr_data;
3829                 robo_info_t *robo = (robo_info_t *)pUmDevice->robo;
3830                 page_num = rdata->page_num;
3831                 addr_num = rdata->addr_num;
3832                 len = rdata->len;
3833                 printk("b57um SIOCGREG_STATUS cmd page[0x%x]addr[0x%x]len[%d].\n",page_num,addr_num,len);
3834                 if (len == 6)
3835                 {
3836                         ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3837                         printk("val[0x%04x-0x%04x-0x%04x].\n",rdata->val_out[0],rdata->val_out[1],rdata->val_out[2]);
3838                 }
3839                 else if (len == 8)
3840                 {
3841                         ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3842                         printk("val[0x%04x%04x-0x%04x%04x].\n",rdata->val_out[0],rdata->val_out[1],
3843                                 rdata->val_out[2],rdata->val_out[3]);
3844                 }
3845                 else if (len == 4)
3846                 {
3847                         ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3848                         printk("val[0x%04x%04x].\n",rdata->val_out[0],rdata->val_out[1]);
3849                 }
3850                 else
3851                 {
3852                         ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3853                         printk("val[0x%04x].\n",rdata->val_out[0]);
3854
3855                 }
3856                 if (mm_copy_to_user(rq->ifr_data, rdata, sizeof(struct reg_ioctl_data)))
3857                 {
3858                         printk("Fail mm_copy_to_user.\n");
3859                         return -EFAULT;
3860                 }
3861                 return 0;
3862         }
3863         break;
3864         case SIOCSREG_STATUS://Set register
3865         {
3866                 struct reg_ioctl_data * wdata =(struct reg_ioctl_data *)rq->ifr_data;
3867                 len = wdata->len;
3868                 page_num = wdata->page_num;
3869                 addr_num = wdata->addr_num;
3870                 robo_info_t *robo = (robo_info_t *)pUmDevice->robo;
3871                 if (len == 6)
3872                 {
3873                         WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3874                         //printk("val[0x%04x-0x%04x-0x%04x].\n",val48[0],val48[1],val48[2]);
3875                 }
3876                 else if (len == 8)
3877                 {
3878                         WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3879                         //printk("val[0x%04x-0x%04x-0x%04x-0x%04x].\n",val64[0],val64[1],val64[2],val64[3]);
3880                 }
3881                 else if (len == 4)
3882                 {
3883                         WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3884                         //printk("val[0x%08x].\n",value);
3885                 }
3886                 else
3887                 {
3888                         WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3889                         //printk("len[%d] val[0x%04x].\n",len,val16);
3890                 }
3891
3892                 return 0;
3893         }
3894         break;
3895 #ifdef SIOCGMIIPHY
3896         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
3897
3898                 data[0] = pDevice->PhyAddr;
3899                 return 0;
3900 #endif
3901
3902 #ifdef SIOCGMIIREG
3903         case SIOCGMIIREG:               /* Read the specified MII register. */
3904         {
3905                 uint32 savephyaddr = 0;
3906
3907                 if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
3908                         return -EOPNOTSUPP;
3909
3910                 /* ifup only waits for 5 seconds for link up */
3911                 /* NIC may take more than 5 seconds to establish link */
3912                 if ((pUmDevice->delayed_link_ind > 0) &&
3913                         delay_link[pUmDevice->index]) {
3914                         return -EAGAIN;
3915                 }
3916
3917                 BCM5700_PHY_LOCK(pUmDevice, flags);
3918                 if (data[0] != 0xffff) {
3919                         savephyaddr = pDevice->PhyAddr;
3920                         pDevice->PhyAddr = data[0];
3921                 }
3922                 LM_ReadPhy(pDevice, data[1] & 0x1f, (LM_UINT32 *)&value);
3923                 if (data[0] != 0xffff)
3924                         pDevice->PhyAddr = savephyaddr;
3925                 BCM5700_PHY_UNLOCK(pUmDevice, flags);
3926                 data[3] = value & 0xffff;
3927                 return 0;
3928         }
3929 #endif
3930
3931 #ifdef SIOCSMIIREG
3932         case SIOCSMIIREG:               /* Write the specified MII register */
3933         {
3934                 uint32 savephyaddr = 0;
3935
3936                 if (!capable(CAP_NET_ADMIN))
3937                         return -EPERM;
3938
3939                 if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
3940                         return -EOPNOTSUPP;
3941
3942                 BCM5700_PHY_LOCK(pUmDevice, flags);
3943                 if (data[0] != 0xffff) {
3944                         savephyaddr = pDevice->PhyAddr;
3945                         pDevice->PhyAddr = data[0];
3946                 }
3947                 LM_WritePhy(pDevice, data[1] & 0x1f, data[2]);
3948                 if (data[0] != 0xffff)
3949                         pDevice->PhyAddr = savephyaddr;
3950                 BCM5700_PHY_UNLOCK(pUmDevice, flags);
3951                 data[3] = 0;
3952                 return 0;
3953         }
3954 #endif
3955
3956 #ifdef SIOCETHTOOL
3957         case SIOCETHTOOL:
3958                 return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
3959 #endif
3960         default:
3961                 return -EOPNOTSUPP;
3962         }
3963         return -EOPNOTSUPP;
3964 }
3965
3966 STATIC void bcm5700_do_rx_mode(struct net_device *dev)
3967 {
3968         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
3969         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
3970         int i;
3971         struct dev_mc_list *mclist;
3972
3973         LM_MulticastClear(pDevice);
3974         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
3975                          i++, mclist = mclist->next) {
3976                 LM_MulticastAdd(pDevice, (PLM_UINT8) &mclist->dmi_addr);
3977         }
3978         if (dev->flags & IFF_ALLMULTI) {
3979                 if (!(pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST)) {
3980                         LM_SetReceiveMask(pDevice,
3981                                 pDevice->ReceiveMask | LM_ACCEPT_ALL_MULTICAST);
3982                 }
3983         }
3984         else if (pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST) {
3985                 LM_SetReceiveMask(pDevice,
3986                         pDevice->ReceiveMask & ~LM_ACCEPT_ALL_MULTICAST);
3987         }
3988         if (dev->flags & IFF_PROMISC) {
3989                 if (!(pDevice->ReceiveMask & LM_PROMISCUOUS_MODE)) {
3990                         LM_SetReceiveMask(pDevice,
3991                                 pDevice->ReceiveMask | LM_PROMISCUOUS_MODE);
3992                 }
3993         }
3994         else if (pDevice->ReceiveMask & LM_PROMISCUOUS_MODE) {
3995                 LM_SetReceiveMask(pDevice,
3996                         pDevice->ReceiveMask & ~LM_PROMISCUOUS_MODE);
3997         }
3998
3999 }
4000
4001 STATIC void bcm5700_set_rx_mode(struct net_device *dev)
4002 {
4003         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
4004         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
4005         int i;
4006         struct dev_mc_list *mclist;
4007         unsigned long flags;
4008
4009         BCM5700_PHY_LOCK(pUmDevice, flags);
4010
4011         LM_MulticastClear(pDevice);
4012         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
4013                          i++, mclist = mclist->next) {
4014                 LM_MulticastAdd(pDevice, (PLM_UINT8) &mclist->dmi_addr);
4015         }
4016         if (dev->flags & IFF_ALLMULTI) {
4017                 if (!(pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST)) {
4018                         LM_SetReceiveMask(pDevice,
4019                                 pDevice->ReceiveMask | LM_ACCEPT_ALL_MULTICAST);
4020                 }
4021         }
4022         else if (pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST) {
4023                 LM_SetReceiveMask(pDevice,
4024                         pDevice->ReceiveMask & ~LM_ACCEPT_ALL_MULTICAST);
4025         }
4026         if (dev->flags & IFF_PROMISC) {
4027                 if (!(pDevice->ReceiveMask & LM_PROMISCUOUS_MODE)) {
4028                         LM_SetReceiveMask(pDevice,
4029                                 pDevice->ReceiveMask | LM_PROMISCUOUS_MODE);
4030                 }
4031         }
4032         else if (pDevice->ReceiveMask & LM_PROMISCUOUS_MODE) {
4033                 LM_SetReceiveMask(pDevice,
4034                         pDevice->ReceiveMask & ~LM_PROMISCUOUS_MODE);
4035         }
4036
4037         BCM5700_PHY_UNLOCK(pUmDevice, flags);
4038 }
4039
4040 /*
4041  * Set the hardware MAC address.
4042  */
4043 STATIC int bcm5700_set_mac_addr(struct net_device *dev, void *p)
4044 {
4045         struct sockaddr *addr=p;
4046         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) dev->priv;
4047         UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4048
4049         if(is_valid_ether_addr(addr->sa_data)){
4050
4051             memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
4052             if (pUmDevice->opened)
4053                 LM_SetMacAddress(pDevice, dev->dev_addr);
4054                         bcm_robo_set_macaddr(pUmDevice->robo, dev->dev_addr);
4055             return 0;
4056         }
4057         return -EINVAL;
4058 }
4059
4060 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
4061 STATIC int bcm5700_change_mtu(struct net_device *dev, int new_mtu)
4062 {
4063         int pkt_size = new_mtu + ETHERNET_PACKET_HEADER_SIZE;
4064         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
4065         PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
4066         unsigned long flags;
4067         int reinit = 0;
4068
4069         if ((pkt_size < MIN_ETHERNET_PACKET_SIZE_NO_CRC) ||
4070                 (pkt_size > MAX_ETHERNET_JUMBO_PACKET_SIZE_NO_CRC)) {
4071
4072                 return -EINVAL;
4073         }
4074         if ( !(pDevice->Flags & JUMBO_CAPABLE_FLAG)    &&
4075                 (pkt_size > MAX_ETHERNET_PACKET_SIZE_NO_CRC) ) {
4076
4077                 return -EINVAL;
4078         }
4079         if (pUmDevice->suspended)
4080                 return -EAGAIN;
4081
4082         if (pUmDevice->opened && (new_mtu != dev->mtu) &&
4083                 (pDevice->Flags & JUMBO_CAPABLE_FLAG)) {
4084                 reinit = 1;
4085         }
4086
4087         BCM5700_PHY_LOCK(pUmDevice, flags);
4088         if (reinit) {
4089                 netif_stop_queue(dev);
4090                 bcm5700_shutdown(pUmDevice);
4091                 bcm5700_freemem(dev);
4092         }
4093
4094         dev->mtu = new_mtu;
4095         if (pkt_size < MAX_ETHERNET_PACKET_SIZE_NO_CRC) {
4096                 pDevice->RxMtu = pDevice->TxMtu =
4097                         MAX_ETHERNET_PACKET_SIZE_NO_CRC;
4098         }
4099         else {
4100                 pDevice->RxMtu = pDevice->TxMtu = pkt_size;
4101         }
4102
4103         if (dev->mtu <= 1514)  {
4104                 pDevice->RxJumboDescCnt = 0;
4105         }
4106         else if (pDevice->Flags & JUMBO_CAPABLE_FLAG){
4107                 pDevice->RxJumboDescCnt =
4108                         rx_jumbo_desc_cnt[pUmDevice->index];
4109         }
4110         pDevice->RxPacketDescCnt = pDevice->RxJumboDescCnt +
4111                 pDevice->RxStdDescCnt;
4112
4113         pDevice->RxJumboBufferSize = (pDevice->RxMtu + 8 /* CRC + VLAN */ +
4114                 COMMON_CACHE_LINE_SIZE-1) & ~COMMON_CACHE_LINE_MASK;
4115
4116 #ifdef BCM_TSO
4117         if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
4118            (dev->mtu > 1514) ) {
4119                 if (dev->features & NETIF_F_TSO) {
4120                         dev->features &= ~NETIF_F_TSO;
4121                         printk(KERN_ALERT "%s: TSO previously enabled. Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
4122                 }
4123         }
4124 #endif
4125
4126         if (reinit) {
4127                 LM_InitializeAdapter(pDevice);
4128                 bcm5700_do_rx_mode(dev);
4129                 bcm5700_set_vlan_mode(pUmDevice);
4130                 bcm5700_init_counters(pUmDevice);
4131                 if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6)) {
4132                         LM_SetMacAddress(pDevice, dev->dev_addr);
4133                 }
4134                 netif_start_queue(dev);
4135                 bcm5700_intr_on(pUmDevice);
4136         }
4137         BCM5700_PHY_UNLOCK(pUmDevice, flags);
4138
4139         return 0;
4140 }
4141 #endif
4142
4143
4144 #if (LINUX_VERSION_CODE < 0x020300)
4145 int
4146 bcm5700_probe(struct net_device *dev)
4147 {
4148         int cards_found = 0;
4149         struct pci_dev *pdev = NULL;
4150         struct pci_device_id *pci_tbl;
4151         u16 ssvid, ssid;
4152
4153         if ( ! pci_present())
4154                 return -ENODEV;
4155
4156         pci_tbl = bcm5700_pci_tbl;
4157         while ((pdev = pci_find_class(PCI_CLASS_NETWORK_ETHERNET << 8, pdev))) {
4158                 int idx;
4159
4160                 pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &ssvid);
4161                 pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &ssid);
4162                 for (idx = 0; pci_tbl[idx].vendor; idx++) {
4163                         if ((pci_tbl[idx].vendor == PCI_ANY_ID ||
4164                                 pci_tbl[idx].vendor == pdev->vendor) &&
4165                                 (pci_tbl[idx].device == PCI_ANY_ID ||
4166                                 pci_tbl[idx].device == pdev->device) &&
4167                                 (pci_tbl[idx].subvendor == PCI_ANY_ID ||
4168                                 pci_tbl[idx].subvendor == ssvid) &&
4169                                 (pci_tbl[idx].subdevice == PCI_ANY_ID ||
4170                                 pci_tbl[idx].subdevice == ssid))
4171                         {
4172
4173                                 break;
4174                         }
4175                 }
4176                 if (pci_tbl[idx].vendor == 0)
4177                         continue;
4178
4179
4180                 if (bcm5700_init_one(pdev, &pci_tbl[idx]) == 0)
4181                         cards_found++;
4182         }
4183
4184         return cards_found ? 0 : -ENODEV;
4185 }
4186
4187 #ifdef MODULE
4188 int init_module(void)
4189 {
4190         return bcm5700_probe(NULL);
4191 }
4192
4193 void cleanup_module(void)
4194 {
4195         struct net_device *next_dev;
4196         PUM_DEVICE_BLOCK pUmDevice;
4197
4198         /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
4199         while (root_tigon3_dev) {
4200                 pUmDevice = (PUM_DEVICE_BLOCK)root_tigon3_dev->priv;
4201                 next_dev = pUmDevice->next_module;
4202                 unregister_netdev(root_tigon3_dev);
4203                 if (pUmDevice->lm_dev.pMappedMemBase)
4204                         iounmap(pUmDevice->lm_dev.pMappedMemBase);
4205 #if (LINUX_VERSION_CODE < 0x020600)
4206                 kfree(root_tigon3_dev);
4207 #else
4208                 free_netdev(root_tigon3_dev);
4209 #endif
4210                 root_tigon3_dev = next_dev;
4211         }
4212 #ifdef BCM_IOCTL32
4213         unregister_ioctl32_conversion(SIOCNICE);
4214 #endif
4215 }
4216
4217 #endif  /* MODULE */
4218 #else   /* LINUX_VERSION_CODE < 0x020300 */
4219
4220 #if (LINUX_VERSION_CODE >= 0x020406)
4221 static int bcm5700_suspend (struct pci_dev *pdev, u32 state)
4222 #else
4223 static void bcm5700_suspend (struct pci_dev *pdev)
4224 #endif
4225 {
4226         struct net_device *dev = (struct net_device *) pci_get_drvdata(pdev);
4227         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
4228         PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
4229
4230         if (!netif_running(dev))
4231 #if (LINUX_VERSION_CODE >= 0x020406)
4232                 return 0;
4233 #else
4234                 return;
4235 #endif
4236
4237         netif_device_detach (dev);
4238         bcm5700_shutdown(pUmDevice);
4239
4240         LM_SetPowerState(pDevice, LM_POWER_STATE_D3);
4241
4242 /*      pci_power_off(pdev, -1);*/
4243 #if (LINUX_VERSION_CODE >= 0x020406)
4244         return 0;
4245 #endif
4246 }
4247
4248
4249 #if (LINUX_VERSION_CODE >= 0x020406)
4250 static int bcm5700_resume(struct pci_dev *pdev)
4251 #else
4252 static void bcm5700_resume(struct pci_dev *pdev)
4253 #endif
4254 {
4255         struct net_device *dev = (struct net_device *) pci_get_drvdata(pdev);
4256         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
4257         PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
4258
4259         if (!netif_running(dev))
4260 #if (LINUX_VERSION_CODE >= 0x020406)
4261                 return 0;
4262 #else
4263                 return;
4264 #endif
4265 /*      pci_power_on(pdev);*/
4266         netif_device_attach(dev);
4267         LM_SetPowerState(pDevice, LM_POWER_STATE_D0);
4268         MM_InitializeUmPackets(pDevice);
4269         bcm5700_reset(dev);
4270 #if (LINUX_VERSION_CODE >= 0x020406)
4271         return 0;
4272 #endif
4273 }
4274
4275
4276 static struct pci_driver bcm5700_pci_driver = {
4277         name:           bcm5700_driver,
4278         id_table:       bcm5700_pci_tbl,
4279         probe:          bcm5700_init_one,
4280         remove:         __devexit_p(bcm5700_remove_one),
4281         suspend:        bcm5700_suspend,
4282         resume:         bcm5700_resume,
4283 };
4284
4285 static int
4286 bcm5700_notify_reboot(struct notifier_block *this, unsigned long event, void *unused)
4287 {
4288         switch (event) {
4289         case SYS_HALT:
4290         case SYS_POWER_OFF:
4291         case SYS_RESTART:
4292                 break;
4293         default:
4294                 return NOTIFY_DONE;
4295         }
4296
4297         B57_INFO(("bcm5700 reboot notification\n"));
4298         pci_unregister_driver(&bcm5700_pci_driver);
4299         return NOTIFY_DONE;
4300 }
4301
4302 static int __init bcm5700_init_module (void)
4303 {
4304         int pin = 1 << 2;
4305
4306         if (nvram_match("disabled_5397", "1") || (activate_gpio != -1)) {
4307                 if ( activate_gpio != -1 ) pin = activate_gpio;
4308                 printk("5397 switch GPIO-Reset (pin %d)\n", pin);
4309                 sb_t *gpio_sbh;
4310                 if (!(gpio_sbh = sb_kattach(SB_OSH))) return -ENODEV;
4311                 sb_gpiosetcore(gpio_sbh);
4312 //              sb_gpioreserve(gpio_sbh, 0x4, GPIO_HI_PRIORITY);
4313                 sb_gpioouten(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
4314                 sb_gpioout(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
4315                 sb_detach(gpio_sbh);
4316         }
4317
4318         if (msglevel != 0xdeadbeef) {
4319                 b57_msg_level = msglevel;
4320                 printf("%s: msglevel set to 0x%x\n", __FUNCTION__, b57_msg_level);
4321         } else
4322                 b57_msg_level = B57_ERR_VAL;
4323
4324         return pci_module_init(&bcm5700_pci_driver);
4325 }
4326
4327 static void __exit bcm5700_cleanup_module (void)
4328 {
4329         unregister_reboot_notifier(&bcm5700_reboot_notifier);
4330         pci_unregister_driver(&bcm5700_pci_driver);
4331 }
4332
4333 module_init(bcm5700_init_module);
4334 module_exit(bcm5700_cleanup_module);
4335 #endif
4336
4337 /*
4338  * Middle Module
4339  *
4340  */
4341
4342
4343 #ifdef BCM_NAPI_RXPOLL
4344 LM_STATUS
4345 MM_ScheduleRxPoll(LM_DEVICE_BLOCK *pDevice)
4346 {
4347         struct net_device *dev = ((UM_DEVICE_BLOCK *) pDevice)->dev;
4348
4349         if (netif_rx_schedule_prep(dev)) {
4350                 __netif_rx_schedule(dev);
4351                 return LM_STATUS_SUCCESS;
4352         }
4353         return LM_STATUS_FAILURE;
4354 }
4355 #endif
4356
4357 LM_STATUS
4358 MM_ReadConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4359         LM_UINT16 *pValue16)
4360 {
4361         UM_DEVICE_BLOCK *pUmDevice;
4362
4363         pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4364         pci_read_config_word(pUmDevice->pdev, Offset, (u16 *) pValue16);
4365         return LM_STATUS_SUCCESS;
4366 }
4367
4368 LM_STATUS
4369 MM_ReadConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4370         LM_UINT32 *pValue32)
4371 {
4372         UM_DEVICE_BLOCK *pUmDevice;
4373
4374         pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4375         pci_read_config_dword(pUmDevice->pdev, Offset, (u32 *) pValue32);
4376         return LM_STATUS_SUCCESS;
4377 }
4378
4379 LM_STATUS
4380 MM_WriteConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4381         LM_UINT16 Value16)
4382 {
4383         UM_DEVICE_BLOCK *pUmDevice;
4384
4385         pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4386         pci_write_config_word(pUmDevice->pdev, Offset, Value16);
4387         return LM_STATUS_SUCCESS;
4388 }
4389
4390 LM_STATUS
4391 MM_WriteConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4392         LM_UINT32 Value32)
4393 {
4394         UM_DEVICE_BLOCK *pUmDevice;
4395
4396         pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4397         pci_write_config_dword(pUmDevice->pdev, Offset, Value32);
4398         return LM_STATUS_SUCCESS;
4399 }
4400
4401 LM_STATUS
4402 MM_AllocateSharedMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
4403         PLM_VOID *pMemoryBlockVirt, PLM_PHYSICAL_ADDRESS pMemoryBlockPhy,
4404         LM_BOOL Cached)
4405 {
4406         PLM_VOID pvirt;
4407         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4408         dma_addr_t mapping;
4409
4410         pvirt = pci_alloc_consistent(pUmDevice->pdev, BlockSize,
4411                                                &mapping);
4412         if (!pvirt) {
4413                 return LM_STATUS_FAILURE;
4414         }
4415         pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
4416         pUmDevice->dma_list[pUmDevice->mem_list_num] = mapping;
4417         pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = BlockSize;
4418         memset(pvirt, 0, BlockSize);
4419         *pMemoryBlockVirt = (PLM_VOID) pvirt;
4420         MM_SetAddr(pMemoryBlockPhy, mapping);
4421         return LM_STATUS_SUCCESS;
4422 }
4423
4424 LM_STATUS
4425 MM_AllocateMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
4426         PLM_VOID *pMemoryBlockVirt)
4427 {
4428         PLM_VOID pvirt;
4429         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4430
4431
4432         /* Maximum in slab.c */
4433         if (BlockSize > 131072) {
4434                 goto MM_Alloc_error;
4435         }
4436
4437         pvirt = kmalloc(BlockSize, GFP_ATOMIC);
4438         if (!pvirt) {
4439                 goto MM_Alloc_error;
4440         }
4441         pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
4442         pUmDevice->dma_list[pUmDevice->mem_list_num] = 0;
4443         pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = 0;
4444         /* mem_size_list[i] == 0 indicates that the memory should be freed */
4445         /* using kfree */
4446         memset(pvirt, 0, BlockSize);
4447         *pMemoryBlockVirt = pvirt;
4448         return LM_STATUS_SUCCESS;
4449
4450 MM_Alloc_error:
4451         printk(KERN_WARNING "%s: Memory allocation failed - buffer parameters may be set too high\n", pUmDevice->dev->name);
4452         return LM_STATUS_FAILURE;
4453 }
4454
4455 LM_STATUS
4456 MM_MapMemBase(PLM_DEVICE_BLOCK pDevice)
4457 {
4458         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4459
4460         pDevice->pMappedMemBase = ioremap_nocache(
4461                 pci_resource_start(pUmDevice->pdev, 0), sizeof(T3_STD_MEM_MAP));
4462         if (pDevice->pMappedMemBase == 0)
4463                 return LM_STATUS_FAILURE;
4464
4465         return LM_STATUS_SUCCESS;
4466 }
4467
4468 LM_STATUS
4469 MM_InitializeUmPackets(PLM_DEVICE_BLOCK pDevice)
4470 {
4471         unsigned int i;
4472         struct sk_buff *skb;
4473         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4474         PUM_PACKET pUmPacket;
4475         PLM_PACKET pPacket;
4476
4477         for (i = 0; i < pDevice->RxPacketDescCnt; i++) {
4478                 pPacket = QQ_PopHead(&pDevice->RxPacketFreeQ.Container);
4479                 pUmPacket = (PUM_PACKET) pPacket;
4480                 if (pPacket == 0) {
4481                         printk(KERN_DEBUG "Bad RxPacketFreeQ\n");
4482                 }
4483                 if (pUmPacket->skbuff == 0) {
4484 #ifdef BCM_WL_EMULATOR
4485                         skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2);
4486 #else
4487                         skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR);
4488 #endif
4489                         if (skb == 0) {
4490                                 pUmPacket->skbuff = 0;
4491                                 QQ_PushTail(
4492                                         &pUmDevice->rx_out_of_buf_q.Container,
4493                                         pPacket);
4494                                 continue;
4495                         }
4496                         pUmPacket->skbuff = skb;
4497                         skb->dev = pUmDevice->dev;
4498 #ifndef BCM_WL_EMULATOR
4499                         skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
4500 #endif
4501                 }
4502                 QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
4503         }
4504         if (T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) {
4505                 /* reallocate buffers in the ISR */
4506                 pUmDevice->rx_buf_repl_thresh = 0;
4507                 pUmDevice->rx_buf_repl_panic_thresh = 0;
4508                 pUmDevice->rx_buf_repl_isr_limit = 0;
4509         }
4510         else {
4511                 pUmDevice->rx_buf_repl_thresh = pDevice->RxPacketDescCnt / 8;
4512                 pUmDevice->rx_buf_repl_panic_thresh =
4513                         pDevice->RxPacketDescCnt  * 7 / 8;
4514
4515                 /* This limits the time spent in the ISR when the receiver */
4516                 /* is in a steady state of being overrun. */
4517                 pUmDevice->rx_buf_repl_isr_limit = pDevice->RxPacketDescCnt / 8;
4518
4519 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
4520                 if (pDevice->RxJumboDescCnt != 0) {
4521                         if (pUmDevice->rx_buf_repl_thresh >=
4522                                 pDevice->RxJumboDescCnt) {
4523
4524                                 pUmDevice->rx_buf_repl_thresh =
4525                                 pUmDevice->rx_buf_repl_panic_thresh =
4526                                         pDevice->RxJumboDescCnt - 1;
4527                         }
4528                         if (pUmDevice->rx_buf_repl_thresh >=
4529                                 pDevice->RxStdDescCnt) {
4530
4531                                 pUmDevice->rx_buf_repl_thresh =
4532                                 pUmDevice->rx_buf_repl_panic_thresh =
4533                                         pDevice->RxStdDescCnt - 1;
4534                         }
4535                 }
4536 #endif
4537         }
4538         return LM_STATUS_SUCCESS;
4539 }
4540
4541 LM_STATUS
4542 MM_GetConfig(PLM_DEVICE_BLOCK pDevice)
4543 {
4544         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4545         int index = pUmDevice->index;
4546         struct net_device *dev = pUmDevice->dev;
4547
4548         if (index >= MAX_UNITS)
4549                 return LM_STATUS_SUCCESS;
4550
4551 #if LINUX_KERNEL_VERSION < 0x0020609
4552
4553         bcm5700_validate_param_range(pUmDevice, &auto_speed[index], "auto_speed",
4554                 0, 1, 1);
4555         if (auto_speed[index] == 0)
4556                 pDevice->DisableAutoNeg = TRUE;
4557         else
4558                 pDevice->DisableAutoNeg = FALSE;
4559
4560         if (line_speed[index] == 0) {
4561                 pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4562                 pDevice->DisableAutoNeg = FALSE;
4563         }
4564         else {
4565                 bcm5700_validate_param_range(pUmDevice, &full_duplex[index],
4566                         "full_duplex", 0, 1, 1);
4567                 if (full_duplex[index]) {
4568                         pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_FULL;
4569                 }
4570                 else {
4571                         pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_HALF;
4572                 }
4573
4574                 if (line_speed[index] == 1000) {
4575                         pDevice->RequestedLineSpeed = LM_LINE_SPEED_1000MBPS;
4576                         if (pDevice->PhyFlags & PHY_NO_GIGABIT) {
4577                                 pDevice->RequestedLineSpeed =
4578                                         LM_LINE_SPEED_100MBPS;
4579                                 printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (1000), using 100\n", bcm5700_driver, index);
4580                         }
4581                         else {
4582                                 if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
4583                                         !full_duplex[index]) {
4584                                         printk(KERN_WARNING "%s-%d: Invalid full_duplex parameter (0) for fiber, using 1\n", bcm5700_driver, index);
4585                                         pDevice->RequestedDuplexMode =
4586                                                 LM_DUPLEX_MODE_FULL;
4587                                 }
4588
4589                                 if (!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
4590                                         !auto_speed[index] && !(pDevice->PhyFlags & PHY_IS_FIBER) ) {
4591                                         printk(KERN_WARNING "%s-%d: Invalid auto_speed parameter (0) for copper, using 1\n", bcm5700_driver, index);
4592                                         pDevice->DisableAutoNeg = FALSE;
4593                                 }
4594                         }
4595                 }
4596                 else if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) ||
4597                          (pDevice->PhyFlags & PHY_IS_FIBER)){
4598                          pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4599                          pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_FULL;
4600                          pDevice->DisableAutoNeg = FALSE;
4601                          printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using auto\n", bcm5700_driver, index, line_speed[index]);
4602                 }
4603                 else if (line_speed[index] == 100) {
4604
4605                         pDevice->RequestedLineSpeed = LM_LINE_SPEED_100MBPS;
4606                 }
4607                 else if (line_speed[index] == 10) {
4608
4609                         pDevice->RequestedLineSpeed = LM_LINE_SPEED_10MBPS;
4610                 }
4611                 else {
4612                         pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4613                         pDevice->DisableAutoNeg = FALSE;
4614                         printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using 0\n", bcm5700_driver, index, line_speed[index]);
4615                 }
4616
4617         }
4618
4619 #endif /* LINUX_KERNEL_VERSION */
4620
4621         /* This is an unmanageable switch nic and will have link problems if
4622            not set to auto
4623         */
4624         if(pDevice->SubsystemVendorId==0x103c && pDevice->SubsystemId==0x3226)
4625         {
4626             if(pDevice->RequestedLineSpeed != LM_LINE_SPEED_AUTO)
4627             {
4628                 printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using 0\n",
4629                         bcm5700_driver, index, line_speed[index]);
4630             }
4631             pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4632             pDevice->DisableAutoNeg = FALSE;
4633         }
4634
4635 #if LINUX_KERNEL_VERSION < 0x0020609
4636
4637         pDevice->FlowControlCap = 0;
4638         bcm5700_validate_param_range(pUmDevice, &rx_flow_control[index],
4639                 "rx_flow_control", 0, 1, 0);
4640         if (rx_flow_control[index] != 0) {
4641                 pDevice->FlowControlCap |= LM_FLOW_CONTROL_RECEIVE_PAUSE;
4642         }
4643         bcm5700_validate_param_range(pUmDevice, &tx_flow_control[index],
4644                 "tx_flow_control", 0, 1, 0);
4645         if (tx_flow_control[index] != 0) {
4646                 pDevice->FlowControlCap |= LM_FLOW_CONTROL_TRANSMIT_PAUSE;
4647         }
4648         bcm5700_validate_param_range(pUmDevice, &auto_flow_control[index],
4649                 "auto_flow_control", 0, 1, 0);
4650         if (auto_flow_control[index] != 0) {
4651                 if (pDevice->DisableAutoNeg == FALSE) {
4652
4653                         pDevice->FlowControlCap |= LM_FLOW_CONTROL_AUTO_PAUSE;
4654                         if ((tx_flow_control[index] == 0) &&
4655                                 (rx_flow_control[index] == 0)) {
4656
4657                                 pDevice->FlowControlCap |=
4658                                         LM_FLOW_CONTROL_TRANSMIT_PAUSE |
4659                                         LM_FLOW_CONTROL_RECEIVE_PAUSE;
4660                         }
4661                 }
4662         }
4663
4664         if (dev->mtu > 1500) {
4665 #ifdef BCM_TSO
4666                 if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
4667                    (dev->features & NETIF_F_TSO)) {
4668                                 dev->features &= ~NETIF_F_TSO;
4669                                 printk(KERN_ALERT "%s: TSO previously enabled. Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
4670                 }
4671 #endif
4672                 pDevice->RxMtu = dev->mtu + 14;
4673         }
4674
4675         if ((T3_ASIC_REV(pDevice->ChipRevId) != T3_ASIC_REV_5700) &&
4676                 !(pDevice->Flags & BCM5788_FLAG)) {
4677                 pDevice->Flags |= USE_TAGGED_STATUS_FLAG;
4678                 pUmDevice->timer_interval = HZ;
4679                 if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) &&
4680                         (pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
4681                         pUmDevice->timer_interval = HZ/4;
4682                 }
4683         }
4684         else {
4685                 pUmDevice->timer_interval = HZ/10;
4686         }
4687
4688         bcm5700_validate_param_range(pUmDevice, &tx_pkt_desc_cnt[index],
4689                 "tx_pkt_desc_cnt", 1, MAX_TX_PACKET_DESC_COUNT-1, TX_DESC_CNT);
4690         pDevice->TxPacketDescCnt = tx_pkt_desc_cnt[index];
4691         bcm5700_validate_param_range(pUmDevice, &rx_std_desc_cnt[index],
4692                 "rx_std_desc_cnt", 1, T3_STD_RCV_RCB_ENTRY_COUNT-1,
4693                 RX_DESC_CNT);
4694         pDevice->RxStdDescCnt = rx_std_desc_cnt[index];
4695
4696 #if T3_JUMBO_RCV_RCB_ENTRY_COUNT
4697         bcm5700_validate_param_range(pUmDevice, &rx_jumbo_desc_cnt[index],
4698                 "rx_jumbo_desc_cnt", 1, T3_JUMBO_RCV_RCB_ENTRY_COUNT-1,
4699                 JBO_DESC_CNT);
4700
4701         if (mtu[index] <= 1514)
4702                 pDevice->RxJumboDescCnt = 0;
4703         else if(!T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)){
4704                 pDevice->RxJumboDescCnt = rx_jumbo_desc_cnt[index];
4705         }
4706 #endif
4707
4708 #ifdef BCM_INT_COAL
4709         bcm5700_validate_param_range(pUmDevice, &adaptive_coalesce[index],
4710                 "adaptive_coalesce", 0, 1, 1);
4711 #ifdef BCM_NAPI_RXPOLL
4712         if (adaptive_coalesce[index]) {
4713                 printk(KERN_WARNING "%s-%d: adaptive_coalesce not used in NAPI mode\n", bcm5700_driver, index);
4714                 adaptive_coalesce[index] = 0;
4715
4716         }
4717 #endif
4718         pUmDevice->adaptive_coalesce = adaptive_coalesce[index];
4719         if (!pUmDevice->adaptive_coalesce) {
4720                 bcm5700_validate_param_range(pUmDevice,
4721                         &rx_coalesce_ticks[index], "rx_coalesce_ticks", 0,
4722                         MAX_RX_COALESCING_TICKS, RX_COAL_TK);
4723                 if ((rx_coalesce_ticks[index] == 0) &&
4724                         (rx_max_coalesce_frames[index] == 0)) {
4725
4726                         printk(KERN_WARNING "%s-%d: Conflicting rx_coalesce_ticks (0) and rx_max_coalesce_frames (0) parameters, using %d and %d respectively\n",
4727                                 bcm5700_driver, index, RX_COAL_TK, RX_COAL_FM);
4728
4729                         rx_coalesce_ticks[index] = RX_COAL_TK;
4730                         rx_max_coalesce_frames[index] = RX_COAL_FM;
4731                 }
4732                 pDevice->RxCoalescingTicks = pUmDevice->rx_curr_coalesce_ticks =
4733                         rx_coalesce_ticks[index];
4734 #ifdef BCM_NAPI_RXPOLL
4735                 pDevice->RxCoalescingTicksDuringInt = rx_coalesce_ticks[index];
4736 #endif
4737
4738                 bcm5700_validate_param_range(pUmDevice,
4739                         &rx_max_coalesce_frames[index],
4740                         "rx_max_coalesce_frames", 0,
4741                         MAX_RX_MAX_COALESCED_FRAMES, RX_COAL_FM);
4742
4743                 pDevice->RxMaxCoalescedFrames =
4744                         pUmDevice->rx_curr_coalesce_frames =
4745                         rx_max_coalesce_frames[index];
4746 #ifdef BCM_NAPI_RXPOLL
4747                 pDevice->RxMaxCoalescedFramesDuringInt =
4748                         rx_max_coalesce_frames[index];
4749 #endif
4750
4751                 bcm5700_validate_param_range(pUmDevice,
4752                         &tx_coalesce_ticks[index], "tx_coalesce_ticks", 0,
4753                         MAX_TX_COALESCING_TICKS, TX_COAL_TK);
4754                 if ((tx_coalesce_ticks[index] == 0) &&
4755                         (tx_max_coalesce_frames[index] == 0)) {
4756
4757                         printk(KERN_WARNING "%s-%d: Conflicting tx_coalesce_ticks (0) and tx_max_coalesce_frames (0) parameters, using %d and %d respectively\n",
4758                                 bcm5700_driver, index, TX_COAL_TK, TX_COAL_FM);
4759
4760                         tx_coalesce_ticks[index] = TX_COAL_TK;
4761                         tx_max_coalesce_frames[index] = TX_COAL_FM;
4762                 }
4763                 pDevice->TxCoalescingTicks = tx_coalesce_ticks[index];
4764                 bcm5700_validate_param_range(pUmDevice,
4765                         &tx_max_coalesce_frames[index],
4766                         "tx_max_coalesce_frames", 0,
4767                         MAX_TX_MAX_COALESCED_FRAMES, TX_COAL_FM);
4768                 pDevice->TxMaxCoalescedFrames = tx_max_coalesce_frames[index];
4769                 pUmDevice->tx_curr_coalesce_frames =
4770                         pDevice->TxMaxCoalescedFrames;
4771
4772                 bcm5700_validate_param_range(pUmDevice,
4773                         &stats_coalesce_ticks[index], "stats_coalesce_ticks",
4774                         0, MAX_STATS_COALESCING_TICKS, ST_COAL_TK);
4775                 if (adaptive_coalesce[index]) {
4776                         printk(KERN_WARNING "%s-%d: Invalid stats_coalesce_ticks parameter set with with adaptive_coalesce parameter. Using adaptive_coalesce.\n", bcm5700_driver, index);
4777                 }else{
4778                         if ((stats_coalesce_ticks[index] > 0) &&
4779                                 (stats_coalesce_ticks[index] < 100)) {
4780                                 printk(KERN_WARNING "%s-%d: Invalid stats_coalesce_ticks parameter (%u), using 100\n", bcm5700_driver, index, (unsigned int) stats_coalesce_ticks[index]);
4781                                 stats_coalesce_ticks[index] = 100;
4782                                 pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index];
4783                                 pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index];
4784                         }
4785                 }
4786         }
4787         else {
4788                 pUmDevice->rx_curr_coalesce_frames = RX_COAL_FM;
4789                 pUmDevice->rx_curr_coalesce_ticks = RX_COAL_TK;
4790                 pUmDevice->tx_curr_coalesce_frames = TX_COAL_FM;
4791         }
4792 #endif
4793
4794         if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
4795                 unsigned int tmpvar;
4796
4797                 tmpvar = pDevice->StatsCoalescingTicks / BCM_TIMER_GRANULARITY;
4798
4799                 /*
4800                  * If the result is zero, the request is too demanding.
4801                  */
4802                 if (tmpvar == 0) {
4803                         tmpvar = 1;
4804                 }
4805
4806                 pDevice->StatsCoalescingTicks = tmpvar * BCM_TIMER_GRANULARITY;
4807
4808                 pUmDevice->statstimer_interval = tmpvar;
4809         }
4810
4811 #ifdef BCM_WOL
4812         bcm5700_validate_param_range(pUmDevice, &enable_wol[index],
4813                 "enable_wol", 0, 1, 0);
4814         if (enable_wol[index]) {
4815                 pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET;
4816                 pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET;
4817         }
4818 #endif
4819 #ifdef INCLUDE_TBI_SUPPORT
4820         if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
4821                 if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) ||
4822                         (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703)) {
4823                         /* just poll since we have hardware autoneg. in 5704 */
4824                         pDevice->TbiFlags |= TBI_PURE_POLLING_FLAG;
4825                 }
4826                 else {
4827                         pDevice->TbiFlags |= TBI_POLLING_INTR_FLAG;
4828                 }
4829         }
4830 #endif
4831         bcm5700_validate_param_range(pUmDevice, &scatter_gather[index],
4832                 "scatter_gather", 0, 1, 1);
4833         bcm5700_validate_param_range(pUmDevice, &tx_checksum[index],
4834                 "tx_checksum", 0, 1, 1);
4835         bcm5700_validate_param_range(pUmDevice, &rx_checksum[index],
4836                 "rx_checksum", 0, 1, 1);
4837         if (!(pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
4838                 if (tx_checksum[index] || rx_checksum[index]) {
4839
4840                         pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE;
4841                         printk(KERN_WARNING "%s-%d: Checksum offload not available on this NIC\n", bcm5700_driver, index);
4842                 }
4843         }
4844         else {
4845                 if (rx_checksum[index]) {
4846                         pDevice->TaskToOffload |=
4847                                 LM_TASK_OFFLOAD_RX_TCP_CHECKSUM |
4848                                 LM_TASK_OFFLOAD_RX_UDP_CHECKSUM;
4849                 }
4850                 if (tx_checksum[index]) {
4851                         pDevice->TaskToOffload |=
4852                                 LM_TASK_OFFLOAD_TX_TCP_CHECKSUM |
4853                                 LM_TASK_OFFLOAD_TX_UDP_CHECKSUM;
4854                         pDevice->Flags |= NO_TX_PSEUDO_HDR_CSUM_FLAG;
4855                 }
4856         }
4857 #ifdef BCM_TSO
4858         bcm5700_validate_param_range(pUmDevice, &enable_tso[index],
4859                 "enable_tso", 0, 1, 1);
4860
4861         /* Always enable TSO firmware if supported */
4862         /* This way we can turn it on or off on the fly */
4863         if (pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TCP_SEGMENTATION)
4864         {
4865                 pDevice->TaskToOffload |=
4866                         LM_TASK_OFFLOAD_TCP_SEGMENTATION;
4867         }
4868         if (enable_tso[index] &&
4869                 !(pDevice->TaskToOffload & LM_TASK_OFFLOAD_TCP_SEGMENTATION))
4870         {
4871                 printk(KERN_WARNING "%s-%d: TSO not available on this NIC\n", bcm5700_driver, index);
4872         }
4873 #endif
4874 #ifdef BCM_ASF
4875         bcm5700_validate_param_range(pUmDevice, &vlan_tag_mode[index],
4876                 "vlan_strip_mode", 0, 2, 0);
4877         pUmDevice->vlan_tag_mode = vlan_tag_mode[index];
4878 #else
4879         pUmDevice->vlan_tag_mode = VLAN_TAG_MODE_NORMAL_STRIP;
4880 #endif
4881
4882 #endif /* LINUX_KERNEL_VERSION */
4883
4884 #ifdef BCM_NIC_SEND_BD
4885         bcm5700_validate_param_range(pUmDevice, &nic_tx_bd[index], "nic_tx_bd",
4886                 0, 1, 0);
4887         if (nic_tx_bd[index])
4888                 pDevice->Flags |= NIC_SEND_BD_FLAG;
4889         if ((pDevice->Flags & ENABLE_PCIX_FIX_FLAG) ||
4890                 (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5705)) {
4891                 if (pDevice->Flags & NIC_SEND_BD_FLAG) {
4892                         pDevice->Flags &= ~NIC_SEND_BD_FLAG;
4893                         printk(KERN_WARNING "%s-%d: Nic Send BDs not available on this NIC or not possible on this system\n", bcm5700_driver, index);
4894                 }
4895         }
4896 #endif
4897 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
4898         bcm5700_validate_param_range(pUmDevice, &disable_msi[pUmDevice->index],
4899                 "disable_msi", 0, 1, 0);
4900 #endif
4901
4902         bcm5700_validate_param_range(pUmDevice, &delay_link[index],
4903                 "delay_link", 0, 1, 0);
4904
4905         bcm5700_validate_param_range(pUmDevice, &disable_d3hot[index],
4906                 "disable_d3hot", 0, 1, 0);
4907         if (disable_d3hot[index]) {
4908
4909 #ifdef BCM_WOL
4910                 if (enable_wol[index]) {
4911                         pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_NONE;
4912                         pDevice->WakeUpMode = LM_WAKE_UP_MODE_NONE;
4913                         printk(KERN_WARNING "%s-%d: Wake-On-Lan disabled because D3Hot is disabled\n", bcm5700_driver, index);
4914                 }
4915 #endif
4916                 pDevice->Flags |= DISABLE_D3HOT_FLAG;
4917         }
4918
4919     return LM_STATUS_SUCCESS;
4920 }
4921
4922 /* From include/proto/ethernet.h */
4923 #define ETHER_TYPE_8021Q        0x8100          /* 802.1Q */
4924
4925 /* From include/proto/vlan.h */
4926 #define VLAN_PRI_MASK           7       /* 3 bits of priority */
4927 #define VLAN_PRI_SHIFT          13
4928
4929 /* Replace the priority in a vlan tag */
4930 #define UPD_VLANTAG_PRIO(tag, prio) do { \
4931         tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT); \
4932         tag |= prio << VLAN_PRI_SHIFT; \
4933 } while (0)
4934
4935 /* Takes an Ethernet frame and sets out-of-bound PKTPRIO.
4936  * Also updates the inplace vlan tag if requested.
4937  * For debugging, it returns an indication of what it did.
4938  */
4939 #define PKTPRIO_VDSCP   0x100           /* DSCP prio found after VLAN tag */
4940 #define PKTPRIO_VLAN    0x200           /* VLAN prio found */
4941 #define PKTPRIO_UPD     0x400           /* DSCP used to update VLAN prio */
4942 #define PKTPRIO_DSCP    0x800           /* DSCP prio found */
4943 #define PKTSETPRIO(skb, x)              (((struct sk_buff*)(skb))->priority = (x))
4944 static uint
4945 pktsetprio(void *pkt, bool update_vtag)
4946 {
4947         struct ether_header *eh;
4948         struct ethervlan_header *evh;
4949         uint8 *pktdata;
4950         int priority = 0;
4951         int rc = 0;
4952
4953         pktdata = (uint8 *) PKTDATA(NULL, pkt);
4954         ASSERT(ISALIGNED((uintptr)pktdata, sizeof(uint16)));
4955
4956         eh = (struct ether_header *) pktdata;
4957
4958         if (ntoh16(eh->ether_type) == ETHER_TYPE_8021Q) {
4959                 uint16 vlan_tag;
4960                 int vlan_prio, dscp_prio = 0;
4961
4962                 evh = (struct ethervlan_header *)eh;
4963
4964                 vlan_tag = ntoh16(evh->vlan_tag);
4965                 vlan_prio = (int) (vlan_tag >> VLAN_PRI_SHIFT) & VLAN_PRI_MASK;
4966
4967                 if (ntoh16(evh->ether_type) == ETHER_TYPE_IP) {
4968                         uint8 *ip_body = pktdata + sizeof(struct ethervlan_header);
4969                         uint8 tos_tc = IP_TOS(ip_body);
4970                         dscp_prio = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
4971                         if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
4972                                 int ip_len;
4973                                 int src_port;
4974                                 bool src_port_exc;
4975                                 uint8 *tcp_hdr;
4976
4977                                 ip_len = IPV4_PAYLOAD_LEN(ip_body);
4978                                 tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
4979                                 src_port = TCP_SRC_PORT(tcp_hdr);
4980                                 src_port_exc = (src_port == 10110) || (src_port == 10120) ||
4981                                         (src_port == 10130) || (src_port == 10140);
4982
4983                                 if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
4984                                         dscp_prio = 7;
4985                                 }
4986                         }
4987                 }
4988
4989                 /* DSCP priority gets precedence over 802.1P (vlan tag) */
4990                 if (dscp_prio != 0) {
4991                         priority = dscp_prio;
4992                         rc |= PKTPRIO_VDSCP;
4993                 } else {
4994                         priority = vlan_prio;
4995                         rc |= PKTPRIO_VLAN;
4996                 }
4997                 /*
4998                  * If the DSCP priority is not the same as the VLAN priority,
4999                  * then overwrite the priority field in the vlan tag, with the
5000                  * DSCP priority value. This is required for Linux APs because
5001                  * the VLAN driver on Linux, overwrites the skb->priority field
5002                  * with the priority value in the vlan tag
5003                  */
5004                 if (update_vtag && (priority != vlan_prio)) {
5005                         vlan_tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT);
5006                         vlan_tag |= (uint16)priority << VLAN_PRI_SHIFT;
5007                         evh->vlan_tag = hton16(vlan_tag);
5008                         rc |= PKTPRIO_UPD;
5009                 }
5010         } else if (ntoh16(eh->ether_type) == ETHER_TYPE_IP) {
5011                 uint8 *ip_body = pktdata + sizeof(struct ether_header);
5012                 uint8 tos_tc = IP_TOS(ip_body);
5013                 priority = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
5014                 rc |= PKTPRIO_DSCP;
5015                 if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
5016                         int ip_len;
5017                         int src_port;
5018                         bool src_port_exc;
5019                         uint8 *tcp_hdr;
5020
5021                         ip_len = IPV4_PAYLOAD_LEN(ip_body);
5022                         tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
5023                         src_port = TCP_SRC_PORT(tcp_hdr);
5024                         src_port_exc = (src_port == 10110) || (src_port == 10120) ||
5025                                 (src_port == 10130) || (src_port == 10140);
5026
5027                         if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
5028                                 priority = 7;
5029                         }
5030                 }
5031         }
5032
5033         ASSERT(priority >= 0 && priority <= MAXPRIO);
5034         PKTSETPRIO(pkt, priority);
5035         return (rc | priority);
5036 }
5037
5038 LM_STATUS
5039 MM_IndicateRxPackets(PLM_DEVICE_BLOCK pDevice)
5040 {
5041         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5042         PLM_PACKET pPacket;
5043         PUM_PACKET pUmPacket;
5044         struct sk_buff *skb;
5045         int size;
5046         int vlan_tag_size = 0;
5047         uint16 dscp_prio;
5048
5049         if (pDevice->ReceiveMask & LM_KEEP_VLAN_TAG)
5050                 vlan_tag_size = 4;
5051
5052         while (1) {
5053                 pPacket = (PLM_PACKET)
5054                         QQ_PopHead(&pDevice->RxPacketReceivedQ.Container);
5055                 if (pPacket == 0)
5056                         break;
5057                 pUmPacket = (PUM_PACKET) pPacket;
5058 #if !defined(NO_PCI_UNMAP)
5059                 pci_unmap_single(pUmDevice->pdev,
5060                                 pci_unmap_addr(pUmPacket, map[0]),
5061                                 pPacket->u.Rx.RxBufferSize,
5062                                 PCI_DMA_FROMDEVICE);
5063 #endif
5064                 if ((pPacket->PacketStatus != LM_STATUS_SUCCESS) ||
5065                         ((size = pPacket->PacketSize) >
5066                         (pDevice->RxMtu + vlan_tag_size))) {
5067
5068                         /* reuse skb */
5069 #ifdef BCM_TASKLET
5070                         QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
5071 #else
5072                         QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5073 #endif
5074                         pUmDevice->rx_misc_errors++;
5075                         continue;
5076                 }
5077                 skb = pUmPacket->skbuff;
5078                 skb_put(skb, size);
5079                 skb->pkt_type = 0;
5080                 /* Extract priority from payload and put it in skb->priority */
5081                 dscp_prio = 0;
5082                 if (pUmDevice->qos) {
5083                         uint rc;
5084
5085                         rc = pktsetprio(skb, TRUE);
5086                         if (rc & (PKTPRIO_VDSCP | PKTPRIO_DSCP))
5087                                 dscp_prio = rc & VLAN_PRI_MASK;
5088                         if (rc != 0)
5089                                 B57_INFO(("pktsetprio returned 0x%x, skb->priority: %d\n",
5090                                           rc, skb->priority));
5091                 }
5092                 skb->protocol = eth_type_trans(skb, skb->dev);
5093                 if (size > pDevice->RxMtu) {
5094                         /* Make sure we have a valid VLAN tag */
5095                         if (htons(skb->protocol) != ETHER_TYPE_8021Q) {
5096                                 dev_kfree_skb_irq(skb);
5097                                 pUmDevice->rx_misc_errors++;
5098                                 goto drop_rx;
5099                         }
5100                 }
5101
5102                 pUmDevice->stats.rx_bytes += skb->len;
5103
5104                 if ((pPacket->Flags & RCV_BD_FLAG_TCP_UDP_CHKSUM_FIELD) &&
5105                         (pDevice->TaskToOffload &
5106                                 LM_TASK_OFFLOAD_RX_TCP_CHECKSUM)) {
5107                         if (pPacket->u.Rx.TcpUdpChecksum == 0xffff) {
5108
5109                                 skb->ip_summed = CHECKSUM_UNNECESSARY;
5110 #if TIGON3_DEBUG
5111                                 pUmDevice->rx_good_chksum_count++;
5112 #endif
5113                         }
5114                         else {
5115                                 skb->ip_summed = CHECKSUM_NONE;
5116                                 pUmDevice->rx_bad_chksum_count++;
5117                         }
5118                 }
5119                 else {
5120                         skb->ip_summed = CHECKSUM_NONE;
5121                 }
5122                 {
5123 #ifdef BCM_VLAN
5124                         if (pUmDevice->vlgrp &&
5125                                 (pPacket->Flags & RCV_BD_FLAG_VLAN_TAG)) {
5126                                 /* Override vlan priority with dscp priority */
5127                                 if (dscp_prio)
5128                                         UPD_VLANTAG_PRIO(pPacket->VlanTag, dscp_prio);
5129 #ifdef BCM_NAPI_RXPOLL
5130                                 vlan_hwaccel_receive_skb(skb, pUmDevice->vlgrp,
5131                                         pPacket->VlanTag);
5132 #else
5133                                 vlan_hwaccel_rx(skb, pUmDevice->vlgrp,
5134                                         pPacket->VlanTag);
5135 #endif
5136                         } else
5137 #endif
5138                         {
5139 #ifdef BCM_WL_EMULATOR
5140                                 if(pDevice->wl_emulate_rx) {
5141                                         /* bcmstats("emu recv %d %d"); */
5142                                         wlcemu_receive_skb(pDevice->wlc, skb);
5143                                         /* bcmstats("emu recv end %d %d"); */
5144                                 }
5145                                 else
5146 #endif /* BCM_WL_EMULATOR  */
5147                                 {
5148 #ifdef BCM_NAPI_RXPOLL
5149                                 netif_receive_skb(skb);
5150 #else
5151                                 netif_rx(skb);
5152 #endif
5153                                 }
5154                         }
5155                 }
5156                 pUmDevice->dev->last_rx = jiffies;
5157
5158 drop_rx:
5159 #ifdef BCM_TASKLET
5160                 pUmPacket->skbuff = 0;
5161                 QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
5162 #else
5163 #ifdef BCM_WL_EMULATOR
5164                 skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2);
5165 #else
5166                 skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR);
5167 #endif /* BCM_WL_EMULATOR  */
5168                 if (skb == 0) {
5169                         pUmPacket->skbuff = 0;
5170                         QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
5171                 }
5172                 else {
5173                         pUmPacket->skbuff = skb;
5174                         skb->dev = pUmDevice->dev;
5175 #ifndef BCM_WL_EMULATOR
5176                         skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
5177 #endif
5178                         QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5179                 }
5180 #endif
5181         }
5182         return LM_STATUS_SUCCESS;
5183 }
5184
5185 LM_STATUS
5186 MM_CoalesceTxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
5187 {
5188         PUM_PACKET pUmPacket = (PUM_PACKET) pPacket;
5189         struct sk_buff *skb = pUmPacket->skbuff;
5190         struct sk_buff *nskb;
5191 #if !defined(NO_PCI_UNMAP)
5192         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5193
5194         pci_unmap_single(pUmDevice->pdev,
5195                         pci_unmap_addr(pUmPacket, map[0]),
5196                         pci_unmap_len(pUmPacket, map_len[0]),
5197                         PCI_DMA_TODEVICE);
5198 #if MAX_SKB_FRAGS
5199         {
5200                 int i;
5201
5202                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
5203                         pci_unmap_page(pUmDevice->pdev,
5204                                 pci_unmap_addr(pUmPacket, map[i + 1]),
5205                                 pci_unmap_len(pUmPacket, map_len[i + 1]),
5206                                 PCI_DMA_TODEVICE);
5207                 }
5208         }
5209 #endif
5210 #endif
5211         if ((nskb = skb_copy(skb, GFP_ATOMIC))) {
5212                 pUmPacket->lm_packet.u.Tx.FragCount = 1;
5213                 dev_kfree_skb(skb);
5214                 pUmPacket->skbuff = nskb;
5215                 return LM_STATUS_SUCCESS;
5216         }
5217         dev_kfree_skb(skb);
5218         pUmPacket->skbuff = 0;
5219         return LM_STATUS_FAILURE;
5220 }
5221
5222 /* Returns 1 if not all buffers are allocated */
5223 STATIC int
5224 replenish_rx_buffers(PUM_DEVICE_BLOCK pUmDevice, int max)
5225 {
5226         PLM_PACKET pPacket;
5227         PUM_PACKET pUmPacket;
5228         PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
5229         struct sk_buff *skb;
5230         int queue_rx = 0;
5231         int alloc_cnt = 0;
5232         int ret = 0;
5233
5234         while ((pUmPacket = (PUM_PACKET)
5235                 QQ_PopHead(&pUmDevice->rx_out_of_buf_q.Container)) != 0) {
5236                 pPacket = (PLM_PACKET) pUmPacket;
5237                 if (pUmPacket->skbuff) {
5238                         /* reuse an old skb */
5239                         QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5240                         queue_rx = 1;
5241                         continue;
5242                 }
5243 #ifdef BCM_WL_EMULATOR
5244                 if ((skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2)) == 0)
5245 #else
5246                if ((skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR)) == 0)
5247 #endif /* BCM_WL_EMULATOR  */
5248                {
5249                        QQ_PushHead(&pUmDevice->rx_out_of_buf_q.Container,
5250                                    pPacket);
5251                        ret = 1;
5252                        break;
5253                }
5254                 pUmPacket->skbuff = skb;
5255                 skb->dev = pUmDevice->dev;
5256 #ifndef BCM_WL_EMULATOR
5257                         skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
5258 #endif
5259                 QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5260                 queue_rx = 1;
5261                 if (max > 0) {
5262                         alloc_cnt++;
5263                         if (alloc_cnt >= max)
5264                                 break;
5265                 }
5266         }
5267         if (queue_rx || pDevice->QueueAgain) {
5268                 LM_QueueRxPackets(pDevice);
5269         }
5270         return ret;
5271 }
5272
5273 LM_STATUS
5274 MM_IndicateTxPackets(PLM_DEVICE_BLOCK pDevice)
5275 {
5276         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5277         PLM_PACKET pPacket;
5278         PUM_PACKET pUmPacket;
5279         struct sk_buff *skb;
5280 #if !defined(NO_PCI_UNMAP) && MAX_SKB_FRAGS
5281         int i;
5282 #endif
5283
5284         while (1) {
5285                 pPacket = (PLM_PACKET)
5286                         QQ_PopHead(&pDevice->TxPacketXmittedQ.Container);
5287                 if (pPacket == 0)
5288                         break;
5289                 pUmPacket = (PUM_PACKET) pPacket;
5290                 skb = pUmPacket->skbuff;
5291 #if !defined(NO_PCI_UNMAP)
5292                 pci_unmap_single(pUmDevice->pdev,
5293                                 pci_unmap_addr(pUmPacket, map[0]),
5294                                 pci_unmap_len(pUmPacket, map_len[0]),
5295                                 PCI_DMA_TODEVICE);
5296 #if MAX_SKB_FRAGS
5297                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
5298                         pci_unmap_page(pUmDevice->pdev,
5299                                 pci_unmap_addr(pUmPacket, map[i + 1]),
5300                                 pci_unmap_len(pUmPacket, map_len[i + 1]),
5301                                 PCI_DMA_TODEVICE);
5302                 }
5303 #endif
5304 #endif
5305                 dev_kfree_skb_irq(skb);
5306                 pUmPacket->skbuff = 0;
5307                 QQ_PushTail(&pDevice->TxPacketFreeQ.Container, pPacket);
5308         }
5309         if (pUmDevice->tx_full) {
5310                 if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) >=
5311                         (pDevice->TxPacketDescCnt >> 1)) {
5312
5313                         pUmDevice->tx_full = 0;
5314                         netif_wake_queue(pUmDevice->dev);
5315                 }
5316         }
5317         return LM_STATUS_SUCCESS;
5318 }
5319
5320 LM_STATUS
5321 MM_IndicateStatus(PLM_DEVICE_BLOCK pDevice, LM_STATUS Status)
5322 {
5323         PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5324         struct net_device *dev = pUmDevice->dev;
5325         LM_FLOW_CONTROL flow_control;
5326         int speed = 0;
5327
5328         if (!pUmDevice->opened)
5329                 return LM_STATUS_SUCCESS;
5330
5331         if (!pUmDevice->suspended) {
5332                 if (Status == LM_STATUS_LINK_DOWN) {
5333                         netif_carrier_off(dev);
5334                 }
5335                 else if (Status == LM_STATUS_LINK_ACTIVE) {
5336                         netif_carrier_on(dev);
5337                 }
5338         }
5339
5340         if (pUmDevice->delayed_link_ind > 0) {
5341                 pUmDevice->delayed_link_ind = 0;
5342                 if (Status == LM_STATUS_LINK_DOWN) {
5343                         B57_INFO(("%s: %s NIC Link is DOWN\n", bcm5700_driver, dev->name));
5344                 }
5345                 else if (Status == LM_STATUS_LINK_ACTIVE) {
5346                         B57_INFO(("%s: %s NIC Link is UP, ", bcm5700_driver, dev->name));
5347                 }
5348         }
5349         else {
5350                 if (Status == LM_STATUS_LINK_DOWN) {
5351                         B57_INFO(("%s: %s NIC Link is Down\n", bcm5700_driver, dev->name));
5352                 }
5353                 else if (Status == LM_STATUS_LINK_ACTIVE) {
5354                         B57_INFO(("%s: %s NIC Link is Up, ", bcm5700_driver, dev->name));
5355                 }
5356         }
5357
5358         if (Status == LM_STATUS_LINK_ACTIVE) {
5359                 if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS)
5360                         speed = 1000;
5361                 else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS)
5362                         speed = 100;
5363                 else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS)
5364                         speed = 10;
5365
5366                 B57_INFO(("%d Mbps ", speed));
5367
5368                 if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL)
5369                         B57_INFO(("full duplex"));
5370                 else
5371                         B57_INFO(("half duplex"));
5372
5373                 flow_control = pDevice->FlowControl &
5374                         (LM_FLOW_CONTROL_RECEIVE_PAUSE |
5375                         LM_FLOW_CONTROL_TRANSMIT_PAUSE);
5376                 if (flow_control) {
5377                         if (flow_control & LM_FLOW_CONTROL_RECEIVE_PAUSE) {
5378                                 B57_INFO((", receive "));
5379                                 if (flow_control & LM_FLOW_CONTROL_TRANSMIT_PAUSE)
5380                                         B57_INFO(("& transmit "));
5381                         }
5382                         else {
5383                                 B57_INFO((", transmit "));
5384                         }
5385                         B57_INFO(("flow control ON"));
5386                 }
5387                 B57_INFO(("\n"));
5388         }
5389         return LM_STATUS_SUCCESS;
5390 }
5391
5392 void
5393 MM_UnmapRxDma(LM_DEVICE_BLOCK *pDevice, LM_PACKET *pPacket)
5394 {
5395 #if !defined(NO_PCI_UNMAP)
5396         UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
5397         UM_PACKET *pUmPacket = (UM_PACKET *) pPacket;
5398
5399         if (!pUmPacket->skbuff)
5400                 return;
5401
5402         pci_unmap_single(pUmDevice->pdev,
5403                         pci_unmap_addr(pUmPacket, map[0]),
5404                         pPacket->u.Rx.RxBufferSize,
5405                         PCI_DMA_FROMDEVICE);
5406 #endif
5407 }
5408
5409 LM_STATUS
5410 MM_FreeRxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
5411 {
5412         PUM_PACKET pUmPacket;
5413         struct sk_buff *skb;
5414
5415         if (pPacket == 0)
5416                 return LM_STATUS_SUCCESS;
5417         pUmPacket = (PUM_PACKET) pPacket;
5418         if ((skb = pUmPacket->skbuff)) {
5419                 /* DMA address already unmapped */
5420                 dev_kfree_skb(skb);
5421         }
5422         pUmPacket->skbuff = 0;
5423         return LM_STATUS_SUCCESS;
5424 }
5425
5426 LM_STATUS
5427 MM_Sleep(LM_DEVICE_BLOCK *pDevice, LM_UINT32 msec)
5428 {
5429         current->state = TASK_INTERRUPTIBLE;
5430         if (schedule_timeout(HZ * msec / 1000) != 0) {
5431                 return LM_STATUS_FAILURE;
5432         }
5433         if (signal_pending(current))
5434                 return LM_STATUS_FAILURE;
5435
5436         return LM_STATUS_SUCCESS;
5437 }
5438
5439 void
5440 bcm5700_shutdown(UM_DEVICE_BLOCK *pUmDevice)
5441 {
5442         LM_DEVICE_BLOCK *pDevice = (LM_DEVICE_BLOCK *) pUmDevice;
5443
5444         bcm5700_intr_off(pUmDevice);
5445         netif_carrier_off(pUmDevice->dev);
5446 #ifdef BCM_TASKLET
5447         tasklet_kill(&pUmDevice->tasklet);
5448 #endif
5449         bcm5700_poll_wait(pUmDevice);
5450
5451         LM_Halt(pDevice);
5452
5453         pDevice->InitDone = 0;
5454         bcm5700_free_remaining_rx_bufs(pUmDevice);
5455 }
5456
5457 void
5458 bcm5700_free_remaining_rx_bufs(UM_DEVICE_BLOCK *pUmDevice)
5459 {
5460         LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
5461         UM_PACKET *pUmPacket;
5462         int cnt, i;
5463
5464         cnt = QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container);
5465         for (i = 0; i < cnt; i++) {
5466                 if ((pUmPacket =
5467                         QQ_PopHead(&pUmDevice->rx_out_of_buf_q.Container))
5468                         != 0) {
5469
5470                         MM_UnmapRxDma(pDevice, (LM_PACKET *) pUmPacket);
5471                         MM_FreeRxBuffer(pDevice, &pUmPacket->lm_packet);
5472                         QQ_PushTail(&pDevice->RxPacketFreeQ.Container,
5473                                 pUmPacket);
5474                 }
5475         }
5476 }
5477
5478 void
5479 bcm5700_validate_param_range(UM_DEVICE_BLOCK *pUmDevice, int *param,
5480         char *param_name, int min, int max, int deflt)
5481 {
5482         if (((unsigned int) *param < (unsigned int) min) ||
5483                 ((unsigned int) *param > (unsigned int) max)) {
5484
5485                 printk(KERN_WARNING "%s-%d: Invalid %s parameter (%u), using %u\n", bcm5700_driver, pUmDevice->index, param_name, (unsigned int) *param, (unsigned int) deflt);
5486                 *param = deflt;
5487         }
5488 }
5489
5490 struct net_device *
5491 bcm5700_find_peer(struct net_device *dev)
5492 {
5493         struct net_device *tmp_dev;
5494         UM_DEVICE_BLOCK *pUmDevice, *pUmTmp;
5495         LM_DEVICE_BLOCK *pDevice;
5496
5497         tmp_dev = 0;
5498         pUmDevice = (UM_DEVICE_BLOCK *) dev->priv;
5499         pDevice = &pUmDevice->lm_dev;
5500         if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
5501                 tmp_dev = root_tigon3_dev;
5502                 while (tmp_dev) {
5503                         pUmTmp = (PUM_DEVICE_BLOCK) tmp_dev->priv;
5504                         if ((tmp_dev != dev) &&
5505                                 (pUmDevice->pdev->bus->number ==
5506                                 pUmTmp->pdev->bus->number) &&
5507                                 PCI_SLOT(pUmDevice->pdev->devfn) ==
5508                                 PCI_SLOT(pUmTmp->pdev->devfn)) {
5509
5510                                 break;
5511                         }
5512                         tmp_dev = pUmTmp->next_module;
5513                 }
5514         }
5515         return tmp_dev;
5516 }
5517
5518 LM_DEVICE_BLOCK *
5519 MM_FindPeerDev(LM_DEVICE_BLOCK *pDevice)
5520 {
5521         UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
5522         struct net_device *dev = pUmDevice->dev;
5523         struct net_device *peer_dev;
5524
5525         peer_dev = bcm5700_find_peer(dev);
5526         if (!peer_dev)
5527                 return 0;
5528         return ((LM_DEVICE_BLOCK *) peer_dev->priv);
5529 }
5530
5531 int MM_FindCapability(LM_DEVICE_BLOCK *pDevice, int capability)
5532 {
5533         UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
5534         return (pci_find_capability(pUmDevice->pdev, capability));
5535 }
5536
5537 #if defined(HAVE_POLL_CONTROLLER)||defined(CONFIG_NET_POLL_CONTROLLER)
5538 STATIC void
5539 poll_bcm5700(struct net_device *dev)
5540 {
5541         UM_DEVICE_BLOCK *pUmDevice = dev->priv;
5542
5543 #if defined(RED_HAT_LINUX_KERNEL) && (LINUX_VERSION_CODE < 0x020605)
5544         if (netdump_mode) {
5545                 bcm5700_interrupt(pUmDevice->pdev->irq, dev, NULL);
5546 #ifdef BCM_NAPI_RXPOLL
5547                 if (dev->poll_list.prev) {
5548                         int budget = 64;
5549
5550                         bcm5700_poll(dev, &budget);
5551                 }
5552 #endif
5553         }
5554         else
5555 #endif
5556         {
5557                 disable_irq(pUmDevice->pdev->irq);
5558                 bcm5700_interrupt(pUmDevice->pdev->irq, dev, NULL);
5559                 enable_irq(pUmDevice->pdev->irq);
5560         }
5561 }
5562 #endif