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