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