Merge git://git.infradead.org/~dwmw2/battery-2.6

[linux-2.6-omap-h63xx.git] / drivers / net / netxen / netxen_nic_init.c

diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index a36892457761321adaf634daa031d6d7dfd6afa5..1811bcb8c380ad53019033c7e43df01e0ff0912b 100644 (file)
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -139,6 +139,8 @@ int netxen_init_firmware(struct netxen_adapter *adapter)
                return err;
        }
        /* Window 1 call */
+       writel(INTR_SCHEME_PERPORT,
+              NETXEN_CRB_NORMALIZE(adapter, CRB_NIC_CAPABILITIES_HOST));
        writel(MPORT_MULTI_FUNCTION_MODE,
               NETXEN_CRB_NORMALIZE(adapter, CRB_MPORT_MODE));
        writel(PHAN_INITIALIZE_ACK,
@@ -405,10 +407,7 @@ static inline int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
 static inline int
 do_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
 {
-       if (jiffies > (last_schedule_time + (8 * HZ))) {
-               last_schedule_time = jiffies;
-               schedule();
-       }
+       cond_resched();
 
        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
@@ -585,7 +584,7 @@ int netxen_backup_crbinit(struct netxen_adapter *adapter)
 {
        int ret = FLASH_SUCCESS;
        int val;
-       char *buffer = kmalloc(FLASH_SECTOR_SIZE, GFP_KERNEL);
+       char *buffer = kmalloc(NETXEN_FLASH_SECTOR_SIZE, GFP_KERNEL);
 
        if (!buffer)
                return -ENOMEM; 
@@ -601,13 +600,13 @@ int netxen_backup_crbinit(struct netxen_adapter *adapter)
                goto out_kfree;
 
        /* copy  sector 0 to sector 63 */
-       ret = netxen_rom_fast_read_words(adapter, CRBINIT_START, 
-                                               buffer, FLASH_SECTOR_SIZE);
+       ret = netxen_rom_fast_read_words(adapter, NETXEN_CRBINIT_START, 
+                                       buffer, NETXEN_FLASH_SECTOR_SIZE);
        if (ret != FLASH_SUCCESS)
                goto out_kfree;
 
-       ret = netxen_rom_fast_write_words(adapter, FIXED_START, 
-                                               buffer, FLASH_SECTOR_SIZE);
+       ret = netxen_rom_fast_write_words(adapter, NETXEN_FIXED_START, 
+                                       buffer, NETXEN_FLASH_SECTOR_SIZE);
        if (ret != FLASH_SUCCESS)
                goto out_kfree;
 
@@ -654,7 +653,8 @@ void check_erased_flash(struct netxen_adapter *adapter, int addr)
        int count = 0, erased_errors = 0;
        int range;
 
-       range = (addr == USER_START) ? FIXED_START : addr + FLASH_SECTOR_SIZE;
+       range = (addr == NETXEN_USER_START) ? 
+               NETXEN_FIXED_START : addr + NETXEN_FLASH_SECTOR_SIZE;
        
        for (i = addr; i < range; i += 4) {
                netxen_rom_fast_read(adapter, i, &val);
@@ -689,7 +689,7 @@ netxen_flash_erase_sections(struct netxen_adapter *adapter, int start, int end)
        int i;
 
        for (i = start; i < end; i++) {
-               ret = netxen_rom_se(adapter, i * FLASH_SECTOR_SIZE);
+               ret = netxen_rom_se(adapter, i * NETXEN_FLASH_SECTOR_SIZE);
                if (ret)
                        break;
                ret = netxen_rom_wip_poll(adapter);
@@ -706,8 +706,8 @@ netxen_flash_erase_secondary(struct netxen_adapter *adapter)
        int ret = FLASH_SUCCESS;
        int start, end;
 
-       start = SECONDARY_START / FLASH_SECTOR_SIZE;
-       end   = USER_START / FLASH_SECTOR_SIZE;
+       start = NETXEN_SECONDARY_START / NETXEN_FLASH_SECTOR_SIZE;
+       end   = NETXEN_USER_START / NETXEN_FLASH_SECTOR_SIZE;
        ret = netxen_flash_erase_sections(adapter, start, end);
 
        return ret;
@@ -719,8 +719,8 @@ netxen_flash_erase_primary(struct netxen_adapter *adapter)
        int ret = FLASH_SUCCESS;
        int start, end;
 
-       start = PRIMARY_START / FLASH_SECTOR_SIZE;
-       end   = SECONDARY_START / FLASH_SECTOR_SIZE;
+       start = NETXEN_PRIMARY_START / NETXEN_FLASH_SECTOR_SIZE;
+       end   = NETXEN_SECONDARY_START / NETXEN_FLASH_SECTOR_SIZE;
        ret = netxen_flash_erase_sections(adapter, start, end);
 
        return ret;
@@ -853,10 +853,10 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
                                netxen_nic_pci_change_crbwindow(adapter, 1);
                        }
                        if (init_delay == 1) {
-                               ssleep(1);
+                               msleep(2000);
                                init_delay = 0;
                        }
-                       msleep(1);
+                       msleep(20);
                }
                kfree(buf);
 
@@ -932,10 +932,6 @@ int netxen_initialize_adapter_offload(struct netxen_adapter *adapter)
 void netxen_free_adapter_offload(struct netxen_adapter *adapter)
 {
        if (adapter->dummy_dma.addr) {
-               writel(0, NETXEN_CRB_NORMALIZE(adapter,
-                       CRB_HOST_DUMMY_BUF_ADDR_HI));
-               writel(0, NETXEN_CRB_NORMALIZE(adapter,
-                       CRB_HOST_DUMMY_BUF_ADDR_LO));
                pci_free_consistent(adapter->ahw.pdev,
                                    NETXEN_HOST_DUMMY_DMA_SIZE,
                                    adapter->dummy_dma.addr,
@@ -944,25 +940,32 @@ void netxen_free_adapter_offload(struct netxen_adapter *adapter)
        }
 }
 
-void netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
+int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
 {
        u32 val = 0;
-       int loops = 0;
+       int retries = 30;
 
        if (!pegtune_val) {
-               val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
-               while (val != PHAN_INITIALIZE_COMPLETE && 
-                       val != PHAN_INITIALIZE_ACK && loops < 200000) {
-                       udelay(100);
-                       schedule();
-                       val =
-                           readl(NETXEN_CRB_NORMALIZE
+               do {
+                       val = readl(NETXEN_CRB_NORMALIZE
                                  (adapter, CRB_CMDPEG_STATE));
-                       loops++;
+                       pegtune_val = readl(NETXEN_CRB_NORMALIZE
+                                 (adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
+
+                       if (val == PHAN_INITIALIZE_COMPLETE ||
+                               val == PHAN_INITIALIZE_ACK)
+                               return 0;
+
+                       msleep(1000);
+               } while (--retries);
+               if (!retries) {
+                       printk(KERN_WARNING "netxen_phantom_init: init failed, "
+                                       "pegtune_val=%x\n", pegtune_val);
+                       return -1;
                }
-               if (val != PHAN_INITIALIZE_COMPLETE)
-                       printk("WARNING: Initial boot wait loop failed...\n");
        }
+
+       return 0;
 }
 
 int netxen_nic_rx_has_work(struct netxen_adapter *adapter)
@@ -1036,18 +1039,23 @@ void netxen_watchdog_task(struct work_struct *work)
        if ((adapter->portnum  == 0) && netxen_nic_check_temp(adapter))
                return;
 
+       if (adapter->handle_phy_intr)
+               adapter->handle_phy_intr(adapter);
+
        netdev = adapter->netdev;
-       if ((netif_running(netdev)) && !netif_carrier_ok(netdev)) {
-               printk(KERN_INFO "%s port %d, %s carrier is now ok\n",
-                      netxen_nic_driver_name, adapter->portnum, netdev->name);
+       if ((netif_running(netdev)) && !netif_carrier_ok(netdev) &&
+                       netxen_nic_link_ok(adapter) ) {
+               printk(KERN_INFO "%s %s (port %d), Link is up\n",
+                              netxen_nic_driver_name, netdev->name, adapter->portnum);
                netif_carrier_on(netdev);
-       }
-
-       if (netif_queue_stopped(netdev))
                netif_wake_queue(netdev);
+       } else if(!(netif_running(netdev)) && netif_carrier_ok(netdev)) {
+               printk(KERN_ERR "%s %s Link is Down\n",
+                               netxen_nic_driver_name, netdev->name);
+               netif_carrier_off(netdev);
+               netif_stop_queue(netdev);
+       }
 
-       if (adapter->handle_phy_intr)
-               adapter->handle_phy_intr(adapter);
        mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
 }
 
@@ -1114,6 +1122,7 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
                adapter->stats.csummed++;
                skb->ip_summed = CHECKSUM_UNNECESSARY;
        }
+       skb->dev = netdev;
        if (desc_ctx == RCV_DESC_LRO_CTXID) {
                /* True length was only available on the last pkt */
                skb_put(skb, buffer->lro_length);
@@ -1218,6 +1227,7 @@ u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctxid, int max)
                       NETXEN_CRB_NORMALIZE(adapter,
                                            recv_crb_registers[adapter->portnum].
                                            crb_rcv_status_consumer));
+               wmb();
        }
 
        return count;
@@ -1270,11 +1280,13 @@ int netxen_process_cmd_ring(unsigned long data)
                if (skb && (cmpxchg(&buffer->skb, skb, 0) == skb)) {
                        pci_unmap_single(pdev, frag->dma, frag->length,
                                         PCI_DMA_TODEVICE);
+                       frag->dma = 0ULL;
                        for (i = 1; i < buffer->frag_count; i++) {
                                DPRINTK(INFO, "getting fragment no %d\n", i);
                                frag++; /* Get the next frag */
                                pci_unmap_page(pdev, frag->dma, frag->length,
                                               PCI_DMA_TODEVICE);
+                               frag->dma = 0ULL;
                        }
 
                        adapter->stats.skbfreed++;
@@ -1440,6 +1452,7 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
                        writel(msg,
                               DB_NORMALIZE(adapter,
                                            NETXEN_RCV_PRODUCER_OFFSET));
+                       wmb();
                }
        }
 }