2 * Copyright (C) 2003 - 2006 NetXen, Inc.
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.
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.
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,
20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
23 * Contact Information:
26 * 3965 Freedom Circle, Fourth floor,
27 * Santa Clara, CA 95054
30 * Source file for NIC routines to initialize the Phantom Hardware
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"
41 struct crb_addr_pair
{
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 )
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
54 #define NETXEN_NIC_XDMA_RESET 0x8000ff
57 netxen_nic_locked_write_reg(struct netxen_adapter
*adapter
,
58 unsigned long off
, int *data
)
60 void __iomem
*addr
= pci_base_offset(adapter
, off
);
64 static void crb_addr_transform_setup(void)
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
);
116 int netxen_init_firmware(struct netxen_adapter
*adapter
)
118 u32 state
= 0, loops
= 0, err
= 0;
121 state
= readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_CMDPEG_STATE
));
123 if (state
== PHAN_INITIALIZE_ACK
)
126 while (state
!= PHAN_INITIALIZE_COMPLETE
&& loops
< 2000) {
129 state
= readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_CMDPEG_STATE
));
134 printk(KERN_ERR
"Cmd Peg initialization not complete:%x.\n",
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
));
148 #define NETXEN_ADDR_LIMIT 0xffffffffULL
150 void *netxen_alloc(struct pci_dev
*pdev
, size_t sz
, dma_addr_t
* ptr
,
151 struct pci_dev
**used_dev
)
155 addr
= pci_alloc_consistent(pdev
, sz
, ptr
);
156 if ((unsigned long long)(*ptr
) < NETXEN_ADDR_LIMIT
) {
160 pci_free_consistent(pdev
, sz
, addr
, *ptr
);
161 addr
= pci_alloc_consistent(NULL
, sz
, ptr
);
166 void netxen_initialize_adapter_sw(struct netxen_adapter
*adapter
)
171 struct netxen_rcv_desc_ctx
*rcv_desc
;
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
;
183 * Now go through all of them, set reference handles
184 * and put them in the queues.
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
);
197 void netxen_initialize_adapter_hw(struct netxen_adapter
*adapter
)
200 struct netxen_board_info
*board_info
= &(adapter
->ahw
.boardcfg
);
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
);
207 printk(KERN_ERR
"%s: Unknown board type\n",
208 netxen_nic_driver_name
);
209 adapter
->ahw
.max_ports
= ports
;
212 void netxen_initialize_adapter_ops(struct netxen_adapter
*adapter
)
214 switch (adapter
->ahw
.board_type
) {
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
;
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
;
252 * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
253 * address to external PCI CRB address.
255 unsigned long netxen_decode_crb_addr(unsigned long addr
)
258 unsigned long base_addr
, offset
, pci_base
;
260 crb_addr_transform_setup();
262 pci_base
= NETXEN_ADDR_ERROR
;
263 base_addr
= addr
& 0xfff00000;
264 offset
= addr
& 0x000fffff;
266 for (i
= 0; i
< NETXEN_MAX_CRB_XFORM
; i
++) {
267 if (crb_addr_xform
[i
] == base_addr
) {
272 if (pci_base
== NETXEN_ADDR_ERROR
)
275 return (pci_base
+ offset
);
278 static long rom_max_timeout
= 10000;
279 static long rom_lock_timeout
= 1000000;
281 static inline int rom_lock(struct netxen_adapter
*adapter
)
288 /* acquire semaphore2 from PCI HW block */
289 netxen_nic_read_w0(adapter
, NETXEN_PCIE_REG(PCIE_SEM2_LOCK
),
293 if (timeout
>= rom_lock_timeout
)
303 for (iter
= 0; iter
< 20; iter
++)
304 cpu_relax(); /*This a nop instr on i386 */
307 netxen_nic_reg_write(adapter
, NETXEN_ROM_LOCK_ID
, ROM_LOCK_DRIVER
);
311 int netxen_wait_rom_done(struct netxen_adapter
*adapter
)
317 done
= netxen_nic_reg_read(adapter
, NETXEN_ROMUSB_GLB_STATUS
);
320 if (timeout
>= rom_max_timeout
) {
321 printk("Timeout reached waiting for rom done");
328 static inline int netxen_rom_wren(struct netxen_adapter
*adapter
)
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
,
334 if (netxen_wait_rom_done(adapter
)) {
340 static inline unsigned int netxen_rdcrbreg(struct netxen_adapter
*adapter
,
343 unsigned int data
= 0xdeaddead;
344 data
= netxen_nic_reg_read(adapter
, addr
);
348 static inline int netxen_do_rom_rdsr(struct netxen_adapter
*adapter
)
350 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_INSTR_OPCODE
,
352 if (netxen_wait_rom_done(adapter
)) {
355 return netxen_rdcrbreg(adapter
, NETXEN_ROMUSB_ROM_RDATA
);
358 static inline void netxen_rom_unlock(struct netxen_adapter
*adapter
)
362 /* release semaphore2 */
363 netxen_nic_read_w0(adapter
, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK
), &val
);
367 int netxen_rom_wip_poll(struct netxen_adapter
*adapter
)
372 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
374 val
= netxen_do_rom_rdsr(adapter
);
377 if (timeout
> rom_max_timeout
) {
384 static inline int do_rom_fast_write(struct netxen_adapter
*adapter
, int addr
,
387 if (netxen_rom_wren(adapter
)) {
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
,
395 if (netxen_wait_rom_done(adapter
)) {
396 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
400 return netxen_rom_wip_poll(adapter
);
404 do_rom_fast_read(struct netxen_adapter
*adapter
, int addr
, int *valp
)
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");
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);
420 *valp
= netxen_nic_reg_read(adapter
, NETXEN_ROMUSB_ROM_RDATA
);
424 int netxen_rom_fast_read(struct netxen_adapter
*adapter
, int addr
, int *valp
)
428 if (rom_lock(adapter
) != 0)
431 ret
= do_rom_fast_read(adapter
, addr
, valp
);
432 netxen_rom_unlock(adapter
);
436 int netxen_rom_fast_write(struct netxen_adapter
*adapter
, int addr
, int data
)
440 if (rom_lock(adapter
) != 0) {
443 ret
= do_rom_fast_write(adapter
, addr
, data
);
444 netxen_rom_unlock(adapter
);
447 int netxen_do_rom_se(struct netxen_adapter
*adapter
, int addr
)
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
,
454 if (netxen_wait_rom_done(adapter
)) {
455 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
458 return netxen_rom_wip_poll(adapter
);
461 int netxen_rom_se(struct netxen_adapter
*adapter
, int addr
)
464 if (rom_lock(adapter
) != 0) {
467 ret
= netxen_do_rom_se(adapter
, addr
);
468 netxen_rom_unlock(adapter
);
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
479 int netxen_pinit_from_rom(struct netxen_adapter
*adapter
, int verbose
)
481 int addr
, val
, status
;
484 struct crb_addr_pair
*buf
;
488 status
= netxen_nic_get_board_info(adapter
);
490 printk("%s: netxen_pinit_from_rom: Error getting board info\n",
491 netxen_nic_driver_name
);
493 netxen_crb_writelit_adapter(adapter
, NETXEN_ROMUSB_GLB_SW_RESET
,
494 NETXEN_ROMBUS_RESET
);
498 if (netxen_rom_fast_read(adapter
, NETXEN_BOARDTYPE
, &val
) == 0)
499 printk("P2 ROM board type: 0x%08x\n", val
);
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
);
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
);
509 printk("Could not read chip number\n");
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
) {
517 printk("%s: %d CRB init values found"
518 " in ROM.\n", netxen_nic_driver_name
, n
);
520 printk("%s:n=0x%x Error! NetXen card flash not"
521 " initialized.\n", __FUNCTION__
, n
);
524 buf
= kcalloc(n
, sizeof(struct crb_addr_pair
), GFP_KERNEL
);
526 printk("%s: netxen_pinit_from_rom: Unable to calloc "
527 "memory.\n", netxen_nic_driver_name
);
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,
540 printk("%s: PCI: 0x%08x == 0x%08x\n",
541 netxen_nic_driver_name
, (unsigned int)
542 netxen_decode_crb_addr((unsigned long)
545 for (i
= 0; i
< n
; i
++) {
548 netxen_decode_crb_addr((unsigned long)buf
[i
].addr
) +
550 /* skipping cold reboot MAGIC */
551 if (off
== NETXEN_CAM_RAM(0x1fc))
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
) {
558 /* hold xdma in reset also */
559 buf
[i
].data
= NETXEN_NIC_XDMA_RESET
;
562 if (ADDR_IN_WINDOW1(off
)) {
564 NETXEN_CRB_NORMALIZE(adapter
, off
));
566 netxen_nic_pci_change_crbwindow(adapter
, 0);
568 pci_base_offset(adapter
, off
));
570 netxen_nic_pci_change_crbwindow(adapter
, 1);
572 if (init_delay
== 1) {
580 /* disable_peg_cache_all */
582 /* unreset_net_cache */
583 netxen_nic_hw_read_wx(adapter
, NETXEN_ROMUSB_GLB_SW_RESET
, &val
,
585 netxen_crb_writelit_adapter(adapter
, NETXEN_ROMUSB_GLB_SW_RESET
,
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);
600 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_0
+ 0x8,
602 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_0
+ 0xc,
605 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_1
+ 0x8,
607 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_1
+ 0xc,
610 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_2
+ 0x8,
612 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_2
+ 0xc,
615 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_3
+ 0x8,
617 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_3
+ 0xc,
623 int netxen_initialize_adapter_offload(struct netxen_adapter
*adapter
)
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",
639 addr
= (uint64_t) adapter
->dummy_dma
.phys_addr
;
640 hi
= (addr
>> 32) & 0xffffffff;
641 lo
= addr
& 0xffffffff;
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
));
649 void netxen_free_adapter_offload(struct netxen_adapter
*adapter
)
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
;
660 void netxen_phantom_init(struct netxen_adapter
*adapter
, int pegtune_val
)
666 while (val
!= PHAN_INITIALIZE_COMPLETE
&& loops
< 200000) {
670 readl(NETXEN_CRB_NORMALIZE
671 (adapter
, CRB_CMDPEG_STATE
));
674 if (val
!= PHAN_INITIALIZE_COMPLETE
)
675 printk("WARNING: Initial boot wait loop failed...\n");
679 int netxen_nic_rx_has_work(struct netxen_adapter
*adapter
)
683 for (ctx
= 0; ctx
< MAX_RCV_CTX
; ++ctx
) {
684 struct netxen_recv_context
*recv_ctx
=
685 &(adapter
->recv_ctx
[ctx
]);
687 struct status_desc
*desc_head
;
688 struct status_desc
*desc
;
690 consumer
= recv_ctx
->status_rx_consumer
;
691 desc_head
= recv_ctx
->rcv_status_desc_head
;
692 desc
= &desc_head
[consumer
];
694 if (((le16_to_cpu(netxen_get_sts_owner(desc
)))
695 & STATUS_OWNER_HOST
))
702 static inline int netxen_nic_check_temp(struct netxen_adapter
*adapter
)
705 struct netxen_port
*port
;
706 struct net_device
*netdev
;
707 uint32_t temp
, temp_state
, temp_val
;
710 temp
= readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_TEMP_STATE
));
712 temp_state
= nx_get_temp_state(temp
);
713 temp_val
= nx_get_temp_val(temp
);
715 if (temp_state
== NX_TEMP_PANIC
) {
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
;
722 port
= adapter
->port
[port_num
];
723 netdev
= port
->netdev
;
725 netif_carrier_off(netdev
);
726 netif_stop_queue(netdev
);
729 } else if (temp_state
== NX_TEMP_WARN
) {
730 if (adapter
->temp
== NX_TEMP_NORMAL
) {
732 "%s: Device temperature %d degrees C "
733 "exceeds operating range."
734 " Immediate action needed.\n",
735 netxen_nic_driver_name
, temp_val
);
738 if (adapter
->temp
== NX_TEMP_WARN
) {
740 "%s: Device temperature is now %d degrees C"
741 " in normal range.\n", netxen_nic_driver_name
,
745 adapter
->temp
= temp_state
;
749 void netxen_watchdog_task(struct work_struct
*work
)
752 struct netxen_port
*port
;
753 struct net_device
*netdev
;
754 struct netxen_adapter
*adapter
=
755 container_of(work
, struct netxen_adapter
, watchdog_task
);
757 if (netxen_nic_check_temp(adapter
))
760 for (port_num
= 0; port_num
< adapter
->ahw
.max_ports
; port_num
++) {
761 port
= adapter
->port
[port_num
];
762 netdev
= port
->netdev
;
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
);
770 if (netif_queue_stopped(netdev
))
771 netif_wake_queue(netdev
);
774 if (adapter
->handle_phy_intr
)
775 adapter
->handle_phy_intr(adapter
);
776 mod_timer(&adapter
->watchdog_timer
, jiffies
+ 2 * HZ
);
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...
785 netxen_process_rcv(struct netxen_adapter
*adapter
, int ctxid
,
786 struct status_desc
*desc
)
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
;
795 u32 length
= le16_to_cpu(netxen_get_sts_totallength(desc
));
797 struct netxen_rcv_desc_ctx
*rcv_desc
;
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
);
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
);
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
;
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"
826 netxen_get_sts_desc_lro_last_frag(desc
),
827 buffer
->lro_expected_frags
,
828 buffer
->lro_current_frags
);
834 pci_unmap_single(pdev
, buffer
->dma
, rcv_desc
->dma_size
,
837 skb
= (struct sk_buff
*)buffer
->skb
;
839 if (likely(netxen_get_sts_status(desc
) == STATUS_CKSUM_OK
)) {
840 port
->stats
.csummed
++;
841 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
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
);
848 skb_put(skb
, length
);
851 skb
->protocol
= eth_type_trans(skb
, netdev
);
853 ret
= netif_receive_skb(skb
);
856 * RH: Do we need these stats on a regular basis. Can we get it from
861 port
->stats
.uphappy
++;
865 port
->stats
.uplcong
++;
869 port
->stats
.upmcong
++;
873 port
->stats
.uphcong
++;
877 port
->stats
.updropped
++;
881 port
->stats
.updunno
++;
885 netdev
->last_rx
= jiffies
;
887 rcv_desc
->rcv_free
++;
888 rcv_desc
->rcv_pending
--;
891 * We just consumed one buffer so post a buffer.
893 adapter
->stats
.post_called
++;
895 buffer
->state
= NETXEN_BUFFER_FREE
;
896 buffer
->lro_current_frags
= 0;
897 buffer
->lro_expected_frags
= 0;
899 port
->stats
.no_rcv
++;
900 port
->stats
.rxbytes
+= length
;
903 /* Process Receive status ring */
904 u32
netxen_process_rcv_ring(struct netxen_adapter
*adapter
, int ctxid
, int max
)
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
;
913 DPRINTK(INFO
, "procesing receive\n");
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.
920 while (count
< max
) {
921 desc
= &desc_head
[consumer
];
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
));
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);
936 for (ring
= 0; ring
< NUM_RCV_DESC_RINGS
; ring
++) {
937 netxen_post_rx_buffers_nodb(adapter
, ctxid
, ring
);
941 /* update the consumer index in phantom */
943 adapter
->stats
.process_rcv
++;
944 recv_ctx
->status_rx_consumer
= consumer
;
945 recv_ctx
->status_rx_producer
= producer
;
949 NETXEN_CRB_NORMALIZE(adapter
,
950 recv_crb_registers
[ctxid
].
951 crb_rcv_status_consumer
));
957 /* Process Command status ring */
958 int netxen_process_cmd_ring(unsigned long data
)
962 struct netxen_adapter
*adapter
= (struct netxen_adapter
*)data
;
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
;
971 struct sk_buff
*skb
= NULL
;
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.
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
);
992 adapter
->proc_cmd_buf_counter
++;
993 adapter
->stats
.process_xmit
++;
995 * Not needed - does not seem to be used anywhere.
996 * adapter->cmd_consumer = consumer;
998 spin_unlock(&adapter
->tx_lock
);
1000 while ((last_consumer
!= consumer
) && (count1
< MAX_STATUS_HANDLE
)) {
1001 buffer
= &adapter
->cmd_buf_arr
[last_consumer
];
1002 port
= adapter
->port
[buffer
->port
];
1004 frag
= &buffer
->frag_array
[0];
1006 if (skb
&& (cmpxchg(&buffer
->skb
, skb
, 0) == skb
)) {
1007 pci_unmap_single(pdev
, frag
->dma
, frag
->length
,
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
,
1016 port
->stats
.skbfreed
++;
1017 dev_kfree_skb_any(skb
);
1019 } else if (adapter
->proc_cmd_buf_counter
== 1) {
1020 port
->stats
.txnullskb
++;
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
);
1029 last_consumer
= get_next_index(last_consumer
,
1030 adapter
->max_tx_desc_count
);
1033 adapter
->stats
.noxmitdone
+= count1
;
1036 spin_lock(&adapter
->tx_lock
);
1037 if ((--adapter
->proc_cmd_buf_counter
) == 0) {
1038 adapter
->last_cmd_consumer
= last_consumer
;
1039 while ((adapter
->last_cmd_consumer
!= consumer
)
1040 && (count2
< MAX_STATUS_HANDLE
)) {
1042 &adapter
->cmd_buf_arr
[adapter
->last_cmd_consumer
];
1047 adapter
->last_cmd_consumer
=
1048 get_next_index(adapter
->last_cmd_consumer
,
1049 adapter
->max_tx_desc_count
);
1052 if (count1
|| count2
) {
1053 for (p
= 0; p
< adapter
->ahw
.max_ports
; p
++) {
1054 nport
= adapter
->port
[p
];
1055 if (netif_queue_stopped(nport
->netdev
)
1056 && (nport
->flags
& NETXEN_NETDEV_STATUS
)) {
1057 netif_wake_queue(nport
->netdev
);
1058 nport
->flags
&= ~NETXEN_NETDEV_STATUS
;
1063 * If everything is freed up to consumer then check if the ring is full
1064 * If the ring is full then check if more needs to be freed and
1065 * schedule the call back again.
1067 * This happens when there are 2 CPUs. One could be freeing and the
1068 * other filling it. If the ring is full when we get out of here and
1069 * the card has already interrupted the host then the host can miss the
1072 * There is still a possible race condition and the host could miss an
1073 * interrupt. The card has to take care of this.
1075 if (adapter
->last_cmd_consumer
== consumer
&&
1076 (((adapter
->cmd_producer
+ 1) %
1077 adapter
->max_tx_desc_count
) == adapter
->last_cmd_consumer
)) {
1078 consumer
= *(adapter
->cmd_consumer
);
1080 done
= (adapter
->last_cmd_consumer
== consumer
);
1082 spin_unlock(&adapter
->tx_lock
);
1083 DPRINTK(INFO
, "last consumer is %d in %s\n", last_consumer
,
1089 * netxen_post_rx_buffers puts buffer in the Phantom memory
1091 void netxen_post_rx_buffers(struct netxen_adapter
*adapter
, u32 ctx
, u32 ringid
)
1093 struct pci_dev
*pdev
= adapter
->ahw
.pdev
;
1094 struct sk_buff
*skb
;
1095 struct netxen_recv_context
*recv_ctx
= &(adapter
->recv_ctx
[ctx
]);
1096 struct netxen_rcv_desc_ctx
*rcv_desc
= NULL
;
1098 struct rcv_desc
*pdesc
;
1099 struct netxen_rx_buffer
*buffer
;
1102 netxen_ctx_msg msg
= 0;
1105 adapter
->stats
.post_called
++;
1106 rcv_desc
= &recv_ctx
->rcv_desc
[ringid
];
1108 producer
= rcv_desc
->producer
;
1109 index
= rcv_desc
->begin_alloc
;
1110 buffer
= &rcv_desc
->rx_buf_arr
[index
];
1111 /* We can start writing rx descriptors into the phantom memory. */
1112 while (buffer
->state
== NETXEN_BUFFER_FREE
) {
1113 skb
= dev_alloc_skb(rcv_desc
->skb_size
);
1114 if (unlikely(!skb
)) {
1117 * We need to schedule the posting of buffers to the pegs.
1119 rcv_desc
->begin_alloc
= index
;
1120 DPRINTK(ERR
, "netxen_post_rx_buffers: "
1121 " allocated only %d buffers\n", count
);
1125 count
++; /* now there should be no failure */
1126 pdesc
= &rcv_desc
->desc_head
[producer
];
1128 #if defined(XGB_DEBUG)
1129 *(unsigned long *)(skb
->head
) = 0xc0debabe;
1130 if (skb_is_nonlinear(skb
)) {
1131 printk("Allocated SKB @%p is nonlinear\n");
1134 skb_reserve(skb
, 2);
1135 /* This will be setup when we receive the
1136 * buffer after it has been filled FSL TBD TBD
1137 * skb->dev = netdev;
1139 dma
= pci_map_single(pdev
, skb
->data
, rcv_desc
->dma_size
,
1140 PCI_DMA_FROMDEVICE
);
1141 pdesc
->addr_buffer
= dma
;
1143 buffer
->state
= NETXEN_BUFFER_BUSY
;
1145 /* make a rcv descriptor */
1146 pdesc
->reference_handle
= buffer
->ref_handle
;
1147 pdesc
->buffer_length
= rcv_desc
->dma_size
;
1148 DPRINTK(INFO
, "done writing descripter\n");
1150 get_next_index(producer
, rcv_desc
->max_rx_desc_count
);
1151 index
= get_next_index(index
, rcv_desc
->max_rx_desc_count
);
1152 buffer
= &rcv_desc
->rx_buf_arr
[index
];
1154 /* if we did allocate buffers, then write the count to Phantom */
1156 rcv_desc
->begin_alloc
= index
;
1157 rcv_desc
->rcv_pending
+= count
;
1158 adapter
->stats
.lastposted
= count
;
1159 adapter
->stats
.posted
+= count
;
1160 rcv_desc
->producer
= producer
;
1161 if (rcv_desc
->rcv_free
>= 32) {
1162 rcv_desc
->rcv_free
= 0;
1164 writel((producer
- 1) &
1165 (rcv_desc
->max_rx_desc_count
- 1),
1166 NETXEN_CRB_NORMALIZE(adapter
,
1167 recv_crb_registers
[0].
1168 rcv_desc_crb
[ringid
].
1169 crb_rcv_producer_offset
));
1171 * Write a doorbell msg to tell phanmon of change in
1172 * receive ring producer
1174 netxen_set_msg_peg_id(msg
, NETXEN_RCV_PEG_DB_ID
);
1175 netxen_set_msg_privid(msg
);
1176 netxen_set_msg_count(msg
,
1179 max_rx_desc_count
- 1)));
1180 netxen_set_msg_ctxid(msg
, 0);
1181 netxen_set_msg_opcode(msg
, NETXEN_RCV_PRODUCER(ringid
));
1183 DB_NORMALIZE(adapter
,
1184 NETXEN_RCV_PRODUCER_OFFSET
));
1189 void netxen_post_rx_buffers_nodb(struct netxen_adapter
*adapter
, uint32_t ctx
,
1192 struct pci_dev
*pdev
= adapter
->ahw
.pdev
;
1193 struct sk_buff
*skb
;
1194 struct netxen_recv_context
*recv_ctx
= &(adapter
->recv_ctx
[ctx
]);
1195 struct netxen_rcv_desc_ctx
*rcv_desc
= NULL
;
1197 struct rcv_desc
*pdesc
;
1198 struct netxen_rx_buffer
*buffer
;
1202 adapter
->stats
.post_called
++;
1203 rcv_desc
= &recv_ctx
->rcv_desc
[ringid
];
1205 producer
= rcv_desc
->producer
;
1206 index
= rcv_desc
->begin_alloc
;
1207 buffer
= &rcv_desc
->rx_buf_arr
[index
];
1208 /* We can start writing rx descriptors into the phantom memory. */
1209 while (buffer
->state
== NETXEN_BUFFER_FREE
) {
1210 skb
= dev_alloc_skb(rcv_desc
->skb_size
);
1211 if (unlikely(!skb
)) {
1213 * We need to schedule the posting of buffers to the pegs.
1215 rcv_desc
->begin_alloc
= index
;
1216 DPRINTK(ERR
, "netxen_post_rx_buffers_nodb: "
1217 " allocated only %d buffers\n", count
);
1220 count
++; /* now there should be no failure */
1221 pdesc
= &rcv_desc
->desc_head
[producer
];
1222 skb_reserve(skb
, 2);
1224 * This will be setup when we receive the
1225 * buffer after it has been filled
1226 * skb->dev = netdev;
1229 buffer
->state
= NETXEN_BUFFER_BUSY
;
1230 buffer
->dma
= pci_map_single(pdev
, skb
->data
,
1232 PCI_DMA_FROMDEVICE
);
1234 /* make a rcv descriptor */
1235 pdesc
->reference_handle
= le16_to_cpu(buffer
->ref_handle
);
1236 pdesc
->buffer_length
= le16_to_cpu(rcv_desc
->dma_size
);
1237 pdesc
->addr_buffer
= cpu_to_le64(buffer
->dma
);
1238 DPRINTK(INFO
, "done writing descripter\n");
1240 get_next_index(producer
, rcv_desc
->max_rx_desc_count
);
1241 index
= get_next_index(index
, rcv_desc
->max_rx_desc_count
);
1242 buffer
= &rcv_desc
->rx_buf_arr
[index
];
1245 /* if we did allocate buffers, then write the count to Phantom */
1247 rcv_desc
->begin_alloc
= index
;
1248 rcv_desc
->rcv_pending
+= count
;
1249 adapter
->stats
.lastposted
= count
;
1250 adapter
->stats
.posted
+= count
;
1251 rcv_desc
->producer
= producer
;
1252 if (rcv_desc
->rcv_free
>= 32) {
1253 rcv_desc
->rcv_free
= 0;
1255 writel((producer
- 1) &
1256 (rcv_desc
->max_rx_desc_count
- 1),
1257 NETXEN_CRB_NORMALIZE(adapter
,
1258 recv_crb_registers
[0].
1259 rcv_desc_crb
[ringid
].
1260 crb_rcv_producer_offset
));
1266 int netxen_nic_tx_has_work(struct netxen_adapter
*adapter
)
1268 if (find_diff_among(adapter
->last_cmd_consumer
,
1269 adapter
->cmd_producer
,
1270 adapter
->max_tx_desc_count
) > 0)
1277 netxen_nic_fill_statistics(struct netxen_adapter
*adapter
,
1278 struct netxen_port
*port
,
1279 struct netxen_statistics
*netxen_stats
)
1283 if (adapter
->ahw
.board_type
== NETXEN_NIC_XGBE
) {
1284 netxen_nic_pci_change_crbwindow(adapter
, 0);
1285 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_TX_BYTE_CNT
,
1286 &(netxen_stats
->tx_bytes
));
1287 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_TX_FRAME_CNT
,
1288 &(netxen_stats
->tx_packets
));
1289 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_RX_BYTE_CNT
,
1290 &(netxen_stats
->rx_bytes
));
1291 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_RX_FRAME_CNT
,
1292 &(netxen_stats
->rx_packets
));
1293 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_AGGR_ERROR_CNT
,
1294 &(netxen_stats
->rx_errors
));
1295 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_CRC_ERROR_CNT
,
1296 &(netxen_stats
->rx_crc_errors
));
1297 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR
,
1299 rx_long_length_error
));
1300 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR
,
1302 rx_short_length_error
));
1304 netxen_nic_pci_change_crbwindow(adapter
, 1);
1306 spin_lock_bh(&adapter
->tx_lock
);
1307 netxen_stats
->tx_bytes
= port
->stats
.txbytes
;
1308 netxen_stats
->tx_packets
= port
->stats
.xmitedframes
+
1309 port
->stats
.xmitfinished
;
1310 netxen_stats
->rx_bytes
= port
->stats
.rxbytes
;
1311 netxen_stats
->rx_packets
= port
->stats
.no_rcv
;
1312 netxen_stats
->rx_errors
= port
->stats
.rcvdbadskb
;
1313 netxen_stats
->tx_errors
= port
->stats
.nocmddescriptor
;
1314 netxen_stats
->rx_short_length_error
= port
->stats
.uplcong
;
1315 netxen_stats
->rx_long_length_error
= port
->stats
.uphcong
;
1316 netxen_stats
->rx_crc_errors
= 0;
1317 netxen_stats
->rx_mac_errors
= 0;
1318 spin_unlock_bh(&adapter
->tx_lock
);
1323 void netxen_nic_clear_stats(struct netxen_adapter
*adapter
)
1325 struct netxen_port
*port
;
1328 memset(&adapter
->stats
, 0, sizeof(adapter
->stats
));
1329 for (port_num
= 0; port_num
< adapter
->ahw
.max_ports
; port_num
++) {
1330 port
= adapter
->port
[port_num
];
1331 memset(&port
->stats
, 0, sizeof(port
->stats
));
1336 netxen_nic_clear_statistics(struct netxen_adapter
*adapter
,
1337 struct netxen_port
*port
)
1341 netxen_nic_pci_change_crbwindow(adapter
, 0);
1343 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_TX_BYTE_CNT
, &data
);
1344 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_TX_FRAME_CNT
,
1346 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_RX_BYTE_CNT
, &data
);
1347 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_RX_FRAME_CNT
,
1349 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_AGGR_ERROR_CNT
,
1351 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_CRC_ERROR_CNT
,
1353 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR
,
1355 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR
,
1358 netxen_nic_pci_change_crbwindow(adapter
, 1);
1359 netxen_nic_clear_stats(adapter
);
1364 netxen_nic_do_ioctl(struct netxen_adapter
*adapter
, void *u_data
,
1365 struct netxen_port
*port
)
1367 struct netxen_nic_ioctl_data data
;
1368 struct netxen_nic_ioctl_data
*up_data
;
1370 struct netxen_statistics netxen_stats
;
1372 up_data
= (void *)u_data
;
1374 DPRINTK(INFO
, "doing ioctl for %p\n", adapter
);
1375 if (copy_from_user(&data
, (void __user
*)up_data
, sizeof(data
))) {
1376 /* evil user tried to crash the kernel */
1377 DPRINTK(ERR
, "bad copy from userland: %d\n", (int)sizeof(data
));
1382 /* Shouldn't access beyond legal limits of "char u[64];" member */
1383 if (!data
.ptr
&& (data
.size
> sizeof(data
.u
))) {
1384 /* evil user tried to crash the kernel */
1385 DPRINTK(ERR
, "bad size: %d\n", data
.size
);
1391 case netxen_nic_cmd_pci_read
:
1392 if ((retval
= netxen_nic_hw_read_ioctl(adapter
, data
.off
,
1393 &(data
.u
), data
.size
)))
1396 ((void __user
*)&(up_data
->u
), &(data
.u
), data
.size
)) {
1397 DPRINTK(ERR
, "bad copy to userland: %d\n",
1405 case netxen_nic_cmd_pci_write
:
1406 if ((retval
= netxen_nic_hw_write_ioctl(adapter
, data
.off
,
1407 &(data
.u
), data
.size
)))
1412 case netxen_nic_cmd_pci_mem_read
:
1413 if (netxen_nic_pci_mem_read_ioctl(adapter
, data
.off
, &(data
.u
),
1415 DPRINTK(ERR
, "Failed to read the data.\n");
1420 ((void __user
*)&(up_data
->u
), &(data
.u
), data
.size
)) {
1421 DPRINTK(ERR
, "bad copy to userland: %d\n",
1429 case netxen_nic_cmd_pci_mem_write
:
1430 if ((retval
= netxen_nic_pci_mem_write_ioctl(adapter
, data
.off
,
1437 case netxen_nic_cmd_pci_config_read
:
1438 switch (data
.size
) {
1440 data
.rv
= pci_read_config_byte(adapter
->ahw
.pdev
,
1445 data
.rv
= pci_read_config_word(adapter
->ahw
.pdev
,
1447 (short *)&(data
.u
));
1450 data
.rv
= pci_read_config_dword(adapter
->ahw
.pdev
,
1452 (u32
*) & (data
.u
));
1456 ((void __user
*)&(up_data
->u
), &(data
.u
), data
.size
)) {
1457 DPRINTK(ERR
, "bad copy to userland: %d\n",
1464 case netxen_nic_cmd_pci_config_write
:
1465 switch (data
.size
) {
1467 data
.rv
= pci_write_config_byte(adapter
->ahw
.pdev
,
1469 *(char *)&(data
.u
));
1472 data
.rv
= pci_write_config_word(adapter
->ahw
.pdev
,
1474 *(short *)&(data
.u
));
1477 data
.rv
= pci_write_config_dword(adapter
->ahw
.pdev
,
1479 *(u32
*) & (data
.u
));
1484 case netxen_nic_cmd_get_stats
:
1486 netxen_nic_fill_statistics(adapter
, port
, &netxen_stats
);
1488 ((void __user
*)(up_data
->ptr
), (void *)&netxen_stats
,
1489 sizeof(struct netxen_statistics
))) {
1490 DPRINTK(ERR
, "bad copy to userland: %d\n",
1491 (int)sizeof(netxen_stats
));
1495 up_data
->rv
= data
.rv
;
1498 case netxen_nic_cmd_clear_stats
:
1499 data
.rv
= netxen_nic_clear_statistics(adapter
, port
);
1500 up_data
->rv
= data
.rv
;
1503 case netxen_nic_cmd_get_version
:
1505 ((void __user
*)&(up_data
->u
), NETXEN_NIC_LINUX_VERSIONID
,
1506 sizeof(NETXEN_NIC_LINUX_VERSIONID
))) {
1507 DPRINTK(ERR
, "bad copy to userland: %d\n",
1515 DPRINTK(INFO
, "bad command %d for %p\n", data
.cmd
, adapter
);
1516 retval
= -EOPNOTSUPP
;
1519 put_user(data
.rv
, (&(up_data
->rv
)));
1520 DPRINTK(INFO
, "done ioctl for %p well.\n", adapter
);