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(PHAN_INITIALIZE_ACK
,
141 NETXEN_CRB_NORMALIZE(adapter
, CRB_CMDPEG_STATE
));
146 #define NETXEN_ADDR_LIMIT 0xffffffffULL
148 void *netxen_alloc(struct pci_dev
*pdev
, size_t sz
, dma_addr_t
* ptr
,
149 struct pci_dev
**used_dev
)
153 addr
= pci_alloc_consistent(pdev
, sz
, ptr
);
154 if ((unsigned long long)(*ptr
) < NETXEN_ADDR_LIMIT
) {
158 pci_free_consistent(pdev
, sz
, addr
, *ptr
);
159 addr
= pci_alloc_consistent(NULL
, sz
, ptr
);
164 void netxen_initialize_adapter_sw(struct netxen_adapter
*adapter
)
169 struct netxen_rcv_desc_ctx
*rcv_desc
;
171 DPRINTK(INFO
, "initializing some queues: %p\n", adapter
);
172 for (ctxid
= 0; ctxid
< MAX_RCV_CTX
; ++ctxid
) {
173 for (ring
= 0; ring
< NUM_RCV_DESC_RINGS
; ring
++) {
174 struct netxen_rx_buffer
*rx_buf
;
175 rcv_desc
= &adapter
->recv_ctx
[ctxid
].rcv_desc
[ring
];
176 rcv_desc
->rcv_free
= rcv_desc
->max_rx_desc_count
;
177 rcv_desc
->begin_alloc
= 0;
178 rx_buf
= rcv_desc
->rx_buf_arr
;
179 num_rx_bufs
= rcv_desc
->max_rx_desc_count
;
181 * Now go through all of them, set reference handles
182 * and put them in the queues.
184 for (i
= 0; i
< num_rx_bufs
; i
++) {
185 rx_buf
->ref_handle
= i
;
186 rx_buf
->state
= NETXEN_BUFFER_FREE
;
188 DPRINTK(INFO
, "Rx buf:ctx%d i(%d) rx_buf:"
189 "%p\n", ctxid
, i
, rx_buf
);
194 DPRINTK(INFO
, "initialized buffers for %s and %s\n",
195 "adapter->free_cmd_buf_list", "adapter->free_rxbuf");
198 void netxen_initialize_adapter_hw(struct netxen_adapter
*adapter
)
201 struct netxen_board_info
*board_info
= &(adapter
->ahw
.boardcfg
);
203 if (netxen_nic_get_board_info(adapter
) != 0)
204 printk("%s: Error getting board config info.\n",
205 netxen_nic_driver_name
);
206 get_brd_port_by_type(board_info
->board_type
, &ports
);
208 printk(KERN_ERR
"%s: Unknown board type\n",
209 netxen_nic_driver_name
);
210 adapter
->ahw
.max_ports
= ports
;
213 void netxen_initialize_adapter_ops(struct netxen_adapter
*adapter
)
215 switch (adapter
->ahw
.board_type
) {
217 adapter
->enable_phy_interrupts
=
218 netxen_niu_gbe_enable_phy_interrupts
;
219 adapter
->disable_phy_interrupts
=
220 netxen_niu_gbe_disable_phy_interrupts
;
221 adapter
->handle_phy_intr
= netxen_nic_gbe_handle_phy_intr
;
222 adapter
->macaddr_set
= netxen_niu_macaddr_set
;
223 adapter
->set_mtu
= netxen_nic_set_mtu_gb
;
224 adapter
->set_promisc
= netxen_niu_set_promiscuous_mode
;
225 adapter
->unset_promisc
= netxen_niu_set_promiscuous_mode
;
226 adapter
->phy_read
= netxen_niu_gbe_phy_read
;
227 adapter
->phy_write
= netxen_niu_gbe_phy_write
;
228 adapter
->init_port
= netxen_niu_gbe_init_port
;
229 adapter
->init_niu
= netxen_nic_init_niu_gb
;
230 adapter
->stop_port
= netxen_niu_disable_gbe_port
;
233 case NETXEN_NIC_XGBE
:
234 adapter
->enable_phy_interrupts
=
235 netxen_niu_xgbe_enable_phy_interrupts
;
236 adapter
->disable_phy_interrupts
=
237 netxen_niu_xgbe_disable_phy_interrupts
;
238 adapter
->handle_phy_intr
= netxen_nic_xgbe_handle_phy_intr
;
239 adapter
->macaddr_set
= netxen_niu_xg_macaddr_set
;
240 adapter
->set_mtu
= netxen_nic_set_mtu_xgb
;
241 adapter
->init_port
= netxen_niu_xg_init_port
;
242 adapter
->set_promisc
= netxen_niu_xg_set_promiscuous_mode
;
243 adapter
->unset_promisc
= netxen_niu_xg_set_promiscuous_mode
;
244 adapter
->stop_port
= netxen_niu_disable_xg_port
;
253 * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
254 * address to external PCI CRB address.
256 unsigned long netxen_decode_crb_addr(unsigned long addr
)
259 unsigned long base_addr
, offset
, pci_base
;
261 crb_addr_transform_setup();
263 pci_base
= NETXEN_ADDR_ERROR
;
264 base_addr
= addr
& 0xfff00000;
265 offset
= addr
& 0x000fffff;
267 for (i
= 0; i
< NETXEN_MAX_CRB_XFORM
; i
++) {
268 if (crb_addr_xform
[i
] == base_addr
) {
273 if (pci_base
== NETXEN_ADDR_ERROR
)
276 return (pci_base
+ offset
);
279 static long rom_max_timeout
= 10000;
280 static long rom_lock_timeout
= 1000000;
282 static inline int rom_lock(struct netxen_adapter
*adapter
)
289 /* acquire semaphore2 from PCI HW block */
290 netxen_nic_read_w0(adapter
, NETXEN_PCIE_REG(PCIE_SEM2_LOCK
),
294 if (timeout
>= rom_lock_timeout
)
304 for (iter
= 0; iter
< 20; iter
++)
305 cpu_relax(); /*This a nop instr on i386 */
308 netxen_nic_reg_write(adapter
, NETXEN_ROM_LOCK_ID
, ROM_LOCK_DRIVER
);
312 int netxen_wait_rom_done(struct netxen_adapter
*adapter
)
318 done
= netxen_nic_reg_read(adapter
, NETXEN_ROMUSB_GLB_STATUS
);
321 if (timeout
>= rom_max_timeout
) {
322 printk("Timeout reached waiting for rom done");
329 static inline int netxen_rom_wren(struct netxen_adapter
*adapter
)
331 /* Set write enable latch in ROM status register */
332 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
333 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_INSTR_OPCODE
,
335 if (netxen_wait_rom_done(adapter
)) {
341 static inline unsigned int netxen_rdcrbreg(struct netxen_adapter
*adapter
,
344 unsigned int data
= 0xdeaddead;
345 data
= netxen_nic_reg_read(adapter
, addr
);
349 static inline int netxen_do_rom_rdsr(struct netxen_adapter
*adapter
)
351 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_INSTR_OPCODE
,
353 if (netxen_wait_rom_done(adapter
)) {
356 return netxen_rdcrbreg(adapter
, NETXEN_ROMUSB_ROM_RDATA
);
359 static inline void netxen_rom_unlock(struct netxen_adapter
*adapter
)
363 /* release semaphore2 */
364 netxen_nic_read_w0(adapter
, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK
), &val
);
368 int netxen_rom_wip_poll(struct netxen_adapter
*adapter
)
373 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
375 val
= netxen_do_rom_rdsr(adapter
);
378 if (timeout
> rom_max_timeout
) {
385 static inline int do_rom_fast_write(struct netxen_adapter
*adapter
, int addr
,
388 if (netxen_rom_wren(adapter
)) {
391 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_WDATA
, data
);
392 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ADDRESS
, addr
);
393 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 3);
394 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_INSTR_OPCODE
,
396 if (netxen_wait_rom_done(adapter
)) {
397 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
401 return netxen_rom_wip_poll(adapter
);
405 do_rom_fast_read(struct netxen_adapter
*adapter
, int addr
, int *valp
)
407 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ADDRESS
, addr
);
408 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 3);
409 udelay(100); /* prevent bursting on CRB */
410 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT
, 0);
411 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_INSTR_OPCODE
, 0xb);
412 if (netxen_wait_rom_done(adapter
)) {
413 printk("Error waiting for rom done\n");
416 /* reset abyte_cnt and dummy_byte_cnt */
417 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
418 udelay(100); /* prevent bursting on CRB */
419 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT
, 0);
421 *valp
= netxen_nic_reg_read(adapter
, NETXEN_ROMUSB_ROM_RDATA
);
425 int netxen_rom_fast_read(struct netxen_adapter
*adapter
, int addr
, int *valp
)
429 if (rom_lock(adapter
) != 0)
432 ret
= do_rom_fast_read(adapter
, addr
, valp
);
433 netxen_rom_unlock(adapter
);
437 int netxen_rom_fast_write(struct netxen_adapter
*adapter
, int addr
, int data
)
441 if (rom_lock(adapter
) != 0) {
444 ret
= do_rom_fast_write(adapter
, addr
, data
);
445 netxen_rom_unlock(adapter
);
448 int netxen_do_rom_se(struct netxen_adapter
*adapter
, int addr
)
450 netxen_rom_wren(adapter
);
451 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ADDRESS
, addr
);
452 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 3);
453 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_INSTR_OPCODE
,
455 if (netxen_wait_rom_done(adapter
)) {
456 netxen_nic_reg_write(adapter
, NETXEN_ROMUSB_ROM_ABYTE_CNT
, 0);
459 return netxen_rom_wip_poll(adapter
);
462 int netxen_rom_se(struct netxen_adapter
*adapter
, int addr
)
465 if (rom_lock(adapter
) != 0) {
468 ret
= netxen_do_rom_se(adapter
, addr
);
469 netxen_rom_unlock(adapter
);
473 #define NETXEN_BOARDTYPE 0x4008
474 #define NETXEN_BOARDNUM 0x400c
475 #define NETXEN_CHIPNUM 0x4010
476 #define NETXEN_ROMBUS_RESET 0xFFFFFFFF
477 #define NETXEN_ROM_FIRST_BARRIER 0x800000000ULL
478 #define NETXEN_ROM_FOUND_INIT 0x400
480 int netxen_pinit_from_rom(struct netxen_adapter
*adapter
, int verbose
)
482 int addr
, val
, status
;
485 struct crb_addr_pair
*buf
;
489 status
= netxen_nic_get_board_info(adapter
);
491 printk("%s: netxen_pinit_from_rom: Error getting board info\n",
492 netxen_nic_driver_name
);
494 netxen_crb_writelit_adapter(adapter
, NETXEN_ROMUSB_GLB_SW_RESET
,
495 NETXEN_ROMBUS_RESET
);
499 if (netxen_rom_fast_read(adapter
, NETXEN_BOARDTYPE
, &val
) == 0)
500 printk("P2 ROM board type: 0x%08x\n", val
);
502 printk("Could not read board type\n");
503 if (netxen_rom_fast_read(adapter
, NETXEN_BOARDNUM
, &val
) == 0)
504 printk("P2 ROM board num: 0x%08x\n", val
);
506 printk("Could not read board number\n");
507 if (netxen_rom_fast_read(adapter
, NETXEN_CHIPNUM
, &val
) == 0)
508 printk("P2 ROM chip num: 0x%08x\n", val
);
510 printk("Could not read chip number\n");
513 if (netxen_rom_fast_read(adapter
, 0, &n
) == 0
514 && (n
& NETXEN_ROM_FIRST_BARRIER
)) {
515 n
&= ~NETXEN_ROM_ROUNDUP
;
516 if (n
< NETXEN_ROM_FOUND_INIT
) {
518 printk("%s: %d CRB init values found"
519 " in ROM.\n", netxen_nic_driver_name
, n
);
521 printk("%s:n=0x%x Error! NetXen card flash not"
522 " initialized.\n", __FUNCTION__
, n
);
525 buf
= kcalloc(n
, sizeof(struct crb_addr_pair
), GFP_KERNEL
);
527 printk("%s: netxen_pinit_from_rom: Unable to calloc "
528 "memory.\n", netxen_nic_driver_name
);
531 for (i
= 0; i
< n
; i
++) {
532 if (netxen_rom_fast_read(adapter
, 8 * i
+ 4, &val
) != 0
533 || netxen_rom_fast_read(adapter
, 8 * i
+ 8,
541 printk("%s: PCI: 0x%08x == 0x%08x\n",
542 netxen_nic_driver_name
, (unsigned int)
543 netxen_decode_crb_addr((unsigned long)
546 for (i
= 0; i
< n
; i
++) {
549 netxen_decode_crb_addr((unsigned long)buf
[i
].addr
) +
551 /* skipping cold reboot MAGIC */
552 if (off
== NETXEN_CAM_RAM(0x1fc))
555 /* After writing this register, HW needs time for CRB */
556 /* to quiet down (else crb_window returns 0xffffffff) */
557 if (off
== NETXEN_ROMUSB_GLB_SW_RESET
) {
559 /* hold xdma in reset also */
560 buf
[i
].data
= NETXEN_NIC_XDMA_RESET
;
563 if (ADDR_IN_WINDOW1(off
)) {
565 NETXEN_CRB_NORMALIZE(adapter
, off
));
567 netxen_nic_pci_change_crbwindow(adapter
, 0);
569 pci_base_offset(adapter
, off
));
571 netxen_nic_pci_change_crbwindow(adapter
, 1);
573 if (init_delay
== 1) {
581 /* disable_peg_cache_all */
583 /* unreset_net_cache */
584 netxen_nic_hw_read_wx(adapter
, NETXEN_ROMUSB_GLB_SW_RESET
, &val
,
586 netxen_crb_writelit_adapter(adapter
, NETXEN_ROMUSB_GLB_SW_RESET
,
588 /* p2dn replyCount */
589 netxen_crb_writelit_adapter(adapter
,
590 NETXEN_CRB_PEG_NET_D
+ 0xec, 0x1e);
591 /* disable_peg_cache 0 */
592 netxen_crb_writelit_adapter(adapter
,
593 NETXEN_CRB_PEG_NET_D
+ 0x4c, 8);
594 /* disable_peg_cache 1 */
595 netxen_crb_writelit_adapter(adapter
,
596 NETXEN_CRB_PEG_NET_I
+ 0x4c, 8);
601 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_0
+ 0x8,
603 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_0
+ 0xc,
606 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_1
+ 0x8,
608 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_1
+ 0xc,
611 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_2
+ 0x8,
613 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_2
+ 0xc,
616 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_3
+ 0x8,
618 netxen_crb_writelit_adapter(adapter
, NETXEN_CRB_PEG_NET_3
+ 0xc,
624 void netxen_phantom_init(struct netxen_adapter
*adapter
, int pegtune_val
)
630 while (val
!= PHAN_INITIALIZE_COMPLETE
&& loops
< 200000) {
634 readl(NETXEN_CRB_NORMALIZE
635 (adapter
, CRB_CMDPEG_STATE
));
638 if (val
!= PHAN_INITIALIZE_COMPLETE
)
639 printk("WARNING: Initial boot wait loop failed...\n");
643 int netxen_nic_rx_has_work(struct netxen_adapter
*adapter
)
647 for (ctx
= 0; ctx
< MAX_RCV_CTX
; ++ctx
) {
648 struct netxen_recv_context
*recv_ctx
=
649 &(adapter
->recv_ctx
[ctx
]);
651 struct status_desc
*desc_head
;
652 struct status_desc
*desc
;
654 consumer
= recv_ctx
->status_rx_consumer
;
655 desc_head
= recv_ctx
->rcv_status_desc_head
;
656 desc
= &desc_head
[consumer
];
658 if (((le16_to_cpu(desc
->owner
)) & STATUS_OWNER_HOST
))
665 static inline int netxen_nic_check_temp(struct netxen_adapter
*adapter
)
668 struct netxen_port
*port
;
669 struct net_device
*netdev
;
670 uint32_t temp
, temp_state
, temp_val
;
673 temp
= readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_TEMP_STATE
));
675 temp_state
= nx_get_temp_state(temp
);
676 temp_val
= nx_get_temp_val(temp
);
678 if (temp_state
== NX_TEMP_PANIC
) {
680 "%s: Device temperature %d degrees C exceeds"
681 " maximum allowed. Hardware has been shut down.\n",
682 netxen_nic_driver_name
, temp_val
);
683 for (port_num
= 0; port_num
< adapter
->ahw
.max_ports
;
685 port
= adapter
->port
[port_num
];
686 netdev
= port
->netdev
;
688 netif_carrier_off(netdev
);
689 netif_stop_queue(netdev
);
692 } else if (temp_state
== NX_TEMP_WARN
) {
693 if (adapter
->temp
== NX_TEMP_NORMAL
) {
695 "%s: Device temperature %d degrees C "
696 "exceeds operating range."
697 " Immediate action needed.\n",
698 netxen_nic_driver_name
, temp_val
);
701 if (adapter
->temp
== NX_TEMP_WARN
) {
703 "%s: Device temperature is now %d degrees C"
704 " in normal range.\n", netxen_nic_driver_name
,
708 adapter
->temp
= temp_state
;
712 void netxen_watchdog_task(unsigned long v
)
715 struct netxen_port
*port
;
716 struct net_device
*netdev
;
717 struct netxen_adapter
*adapter
= (struct netxen_adapter
*)v
;
719 if (netxen_nic_check_temp(adapter
))
722 for (port_num
= 0; port_num
< adapter
->ahw
.max_ports
; port_num
++) {
723 port
= adapter
->port
[port_num
];
724 netdev
= port
->netdev
;
726 if ((netif_running(netdev
)) && !netif_carrier_ok(netdev
)) {
727 printk(KERN_INFO
"%s port %d, %s carrier is now ok\n",
728 netxen_nic_driver_name
, port_num
, netdev
->name
);
729 netif_carrier_on(netdev
);
732 if (netif_queue_stopped(netdev
))
733 netif_wake_queue(netdev
);
736 if (adapter
->handle_phy_intr
)
737 adapter
->handle_phy_intr(adapter
);
738 mod_timer(&adapter
->watchdog_timer
, jiffies
+ 2 * HZ
);
742 * netxen_process_rcv() send the received packet to the protocol stack.
743 * and if the number of receives exceeds RX_BUFFERS_REFILL, then we
744 * invoke the routine to send more rx buffers to the Phantom...
747 netxen_process_rcv(struct netxen_adapter
*adapter
, int ctxid
,
748 struct status_desc
*desc
)
750 struct netxen_port
*port
= adapter
->port
[STATUS_DESC_PORT(desc
)];
751 struct pci_dev
*pdev
= port
->pdev
;
752 struct net_device
*netdev
= port
->netdev
;
753 int index
= le16_to_cpu(desc
->reference_handle
);
754 struct netxen_recv_context
*recv_ctx
= &(adapter
->recv_ctx
[ctxid
]);
755 struct netxen_rx_buffer
*buffer
;
757 u32 length
= le16_to_cpu(desc
->total_length
);
759 struct netxen_rcv_desc_ctx
*rcv_desc
;
762 desc_ctx
= STATUS_DESC_TYPE(desc
);
763 if (unlikely(desc_ctx
>= NUM_RCV_DESC_RINGS
)) {
764 printk("%s: %s Bad Rcv descriptor ring\n",
765 netxen_nic_driver_name
, netdev
->name
);
769 rcv_desc
= &recv_ctx
->rcv_desc
[desc_ctx
];
770 buffer
= &rcv_desc
->rx_buf_arr
[index
];
772 pci_unmap_single(pdev
, buffer
->dma
, rcv_desc
->dma_size
,
775 skb
= (struct sk_buff
*)buffer
->skb
;
777 if (likely(STATUS_DESC_STATUS(desc
) == STATUS_CKSUM_OK
)) {
778 port
->stats
.csummed
++;
779 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
781 skb
->ip_summed
= CHECKSUM_NONE
;
783 skb_put(skb
, length
);
784 skb
->protocol
= eth_type_trans(skb
, netdev
);
786 ret
= netif_receive_skb(skb
);
789 * RH: Do we need these stats on a regular basis. Can we get it from
794 port
->stats
.uphappy
++;
798 port
->stats
.uplcong
++;
802 port
->stats
.upmcong
++;
806 port
->stats
.uphcong
++;
810 port
->stats
.updropped
++;
814 port
->stats
.updunno
++;
818 netdev
->last_rx
= jiffies
;
820 rcv_desc
->rcv_free
++;
821 rcv_desc
->rcv_pending
--;
824 * We just consumed one buffer so post a buffer.
826 adapter
->stats
.post_called
++;
828 buffer
->state
= NETXEN_BUFFER_FREE
;
830 port
->stats
.no_rcv
++;
831 port
->stats
.rxbytes
+= length
;
834 /* Process Receive status ring */
835 u32
netxen_process_rcv_ring(struct netxen_adapter
*adapter
, int ctxid
, int max
)
837 struct netxen_recv_context
*recv_ctx
= &(adapter
->recv_ctx
[ctxid
]);
838 struct status_desc
*desc_head
= recv_ctx
->rcv_status_desc_head
;
839 struct status_desc
*desc
; /* used to read status desc here */
840 u32 consumer
= recv_ctx
->status_rx_consumer
;
843 DPRINTK(INFO
, "procesing receive\n");
845 * we assume in this case that there is only one port and that is
846 * port #1...changes need to be done in firmware to indicate port
847 * number as part of the descriptor. This way we will be able to get
848 * the netdev which is associated with that device.
850 while (count
< max
) {
851 desc
= &desc_head
[consumer
];
852 if (!((le16_to_cpu(desc
->owner
)) & STATUS_OWNER_HOST
)) {
853 DPRINTK(ERR
, "desc %p ownedby %x\n", desc
, desc
->owner
);
856 netxen_process_rcv(adapter
, ctxid
, desc
);
857 desc
->owner
= STATUS_OWNER_PHANTOM
;
858 consumer
= (consumer
+ 1) & (adapter
->max_rx_desc_count
- 1);
862 for (ring
= 0; ring
< NUM_RCV_DESC_RINGS
; ring
++) {
863 netxen_post_rx_buffers(adapter
, ctxid
, ring
);
867 /* update the consumer index in phantom */
869 adapter
->stats
.process_rcv
++;
870 recv_ctx
->status_rx_consumer
= consumer
;
874 NETXEN_CRB_NORMALIZE(adapter
,
875 recv_crb_registers
[ctxid
].
876 crb_rcv_status_consumer
));
882 /* Process Command status ring */
883 void netxen_process_cmd_ring(unsigned long data
)
887 struct netxen_adapter
*adapter
= (struct netxen_adapter
*)data
;
889 struct netxen_cmd_buffer
*buffer
;
890 struct netxen_port
*port
; /* port #1 */
891 struct netxen_port
*nport
;
892 struct pci_dev
*pdev
;
893 struct netxen_skb_frag
*frag
;
895 struct sk_buff
*skb
= NULL
;
898 spin_lock(&adapter
->tx_lock
);
899 last_consumer
= adapter
->last_cmd_consumer
;
900 DPRINTK(INFO
, "procesing xmit complete\n");
901 /* we assume in this case that there is only one port and that is
902 * port #1...changes need to be done in firmware to indicate port
903 * number as part of the descriptor. This way we will be able to get
904 * the netdev which is associated with that device.
907 readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_CMD_CONSUMER_OFFSET
));
909 if (last_consumer
== consumer
) { /* Ring is empty */
910 DPRINTK(INFO
, "last_consumer %d == consumer %d\n",
911 last_consumer
, consumer
);
912 spin_unlock(&adapter
->tx_lock
);
916 adapter
->proc_cmd_buf_counter
++;
917 adapter
->stats
.process_xmit
++;
919 * Not needed - does not seem to be used anywhere.
920 * adapter->cmd_consumer = consumer;
922 spin_unlock(&adapter
->tx_lock
);
924 while ((last_consumer
!= consumer
) && (count
< MAX_STATUS_HANDLE
)) {
925 buffer
= &adapter
->cmd_buf_arr
[last_consumer
];
926 port
= adapter
->port
[buffer
->port
];
928 frag
= &buffer
->frag_array
[0];
930 if (skb
&& (cmpxchg(&buffer
->skb
, skb
, 0) == skb
)) {
931 pci_unmap_single(pdev
, frag
->dma
, frag
->length
,
933 for (i
= 1; i
< buffer
->frag_count
; i
++) {
934 DPRINTK(INFO
, "getting fragment no %d\n", i
);
935 frag
++; /* Get the next frag */
936 pci_unmap_page(pdev
, frag
->dma
, frag
->length
,
940 port
->stats
.skbfreed
++;
941 dev_kfree_skb_any(skb
);
943 } else if (adapter
->proc_cmd_buf_counter
== 1) {
944 port
->stats
.txnullskb
++;
946 if (unlikely(netif_queue_stopped(port
->netdev
)
947 && netif_carrier_ok(port
->netdev
))
948 && ((jiffies
- port
->netdev
->trans_start
) >
949 port
->netdev
->watchdog_timeo
)) {
950 schedule_work(&port
->adapter
->tx_timeout_task
);
953 last_consumer
= get_next_index(last_consumer
,
954 adapter
->max_tx_desc_count
);
957 adapter
->stats
.noxmitdone
+= count
;
960 spin_lock(&adapter
->tx_lock
);
961 if ((--adapter
->proc_cmd_buf_counter
) == 0) {
962 adapter
->last_cmd_consumer
= last_consumer
;
963 while ((adapter
->last_cmd_consumer
!= consumer
)
964 && (count
< MAX_STATUS_HANDLE
)) {
966 &adapter
->cmd_buf_arr
[adapter
->last_cmd_consumer
];
971 adapter
->last_cmd_consumer
=
972 get_next_index(adapter
->last_cmd_consumer
,
973 adapter
->max_tx_desc_count
);
977 for (p
= 0; p
< adapter
->ahw
.max_ports
; p
++) {
978 nport
= adapter
->port
[p
];
979 if (netif_queue_stopped(nport
->netdev
)
980 && (nport
->flags
& NETXEN_NETDEV_STATUS
)) {
981 netif_wake_queue(nport
->netdev
);
982 nport
->flags
&= ~NETXEN_NETDEV_STATUS
;
987 spin_unlock(&adapter
->tx_lock
);
988 DPRINTK(INFO
, "last consumer is %d in %s\n", last_consumer
,
993 * netxen_post_rx_buffers puts buffer in the Phantom memory
995 void netxen_post_rx_buffers(struct netxen_adapter
*adapter
, u32 ctx
, u32 ringid
)
997 struct pci_dev
*pdev
= adapter
->ahw
.pdev
;
999 struct netxen_recv_context
*recv_ctx
= &(adapter
->recv_ctx
[ctx
]);
1000 struct netxen_rcv_desc_ctx
*rcv_desc
= NULL
;
1001 struct netxen_recv_crb
*crbarea
= &recv_crb_registers
[ctx
];
1002 struct netxen_rcv_desc_crb
*rcv_desc_crb
= NULL
;
1004 struct rcv_desc
*pdesc
;
1005 struct netxen_rx_buffer
*buffer
;
1009 adapter
->stats
.post_called
++;
1010 rcv_desc
= &recv_ctx
->rcv_desc
[ringid
];
1011 rcv_desc_crb
= &crbarea
->rcv_desc_crb
[ringid
];
1013 producer
= rcv_desc
->producer
;
1014 index
= rcv_desc
->begin_alloc
;
1015 buffer
= &rcv_desc
->rx_buf_arr
[index
];
1016 /* We can start writing rx descriptors into the phantom memory. */
1017 while (buffer
->state
== NETXEN_BUFFER_FREE
) {
1018 skb
= dev_alloc_skb(rcv_desc
->skb_size
);
1019 if (unlikely(!skb
)) {
1021 * We need to schedule the posting of buffers to the pegs.
1023 rcv_desc
->begin_alloc
= index
;
1024 DPRINTK(ERR
, "netxen_post_rx_buffers: "
1025 " allocated only %d buffers\n", count
);
1028 count
++; /* now there should be no failure */
1029 pdesc
= &rcv_desc
->desc_head
[producer
];
1030 skb_reserve(skb
, NET_IP_ALIGN
);
1032 * This will be setup when we receive the
1033 * buffer after it has been filled
1034 * skb->dev = netdev;
1037 buffer
->state
= NETXEN_BUFFER_BUSY
;
1038 buffer
->dma
= pci_map_single(pdev
, skb
->data
,
1040 PCI_DMA_FROMDEVICE
);
1041 /* make a rcv descriptor */
1042 pdesc
->reference_handle
= le16_to_cpu(buffer
->ref_handle
);
1043 pdesc
->buffer_length
= le16_to_cpu(rcv_desc
->dma_size
);
1044 pdesc
->addr_buffer
= cpu_to_le64(buffer
->dma
);
1045 DPRINTK(INFO
, "done writing descripter\n");
1047 get_next_index(producer
, rcv_desc
->max_rx_desc_count
);
1048 index
= get_next_index(index
, rcv_desc
->max_rx_desc_count
);
1049 buffer
= &rcv_desc
->rx_buf_arr
[index
];
1052 /* if we did allocate buffers, then write the count to Phantom */
1054 rcv_desc
->begin_alloc
= index
;
1055 rcv_desc
->rcv_pending
+= count
;
1056 adapter
->stats
.lastposted
= count
;
1057 adapter
->stats
.posted
+= count
;
1058 rcv_desc
->producer
= producer
;
1059 if (rcv_desc
->rcv_free
>= 32) {
1060 rcv_desc
->rcv_free
= 0;
1062 writel((producer
- 1) &
1063 (rcv_desc
->max_rx_desc_count
- 1),
1064 NETXEN_CRB_NORMALIZE(adapter
,
1066 crb_rcv_producer_offset
));
1072 int netxen_nic_tx_has_work(struct netxen_adapter
*adapter
)
1074 if (find_diff_among(adapter
->last_cmd_consumer
,
1075 adapter
->cmd_producer
,
1076 adapter
->max_tx_desc_count
) > 0)
1083 netxen_nic_fill_statistics(struct netxen_adapter
*adapter
,
1084 struct netxen_port
*port
,
1085 struct netxen_statistics
*netxen_stats
)
1089 if (adapter
->ahw
.board_type
== NETXEN_NIC_XGBE
) {
1090 netxen_nic_pci_change_crbwindow(adapter
, 0);
1091 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_TX_BYTE_CNT
,
1092 &(netxen_stats
->tx_bytes
));
1093 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_TX_FRAME_CNT
,
1094 &(netxen_stats
->tx_packets
));
1095 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_RX_BYTE_CNT
,
1096 &(netxen_stats
->rx_bytes
));
1097 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_RX_FRAME_CNT
,
1098 &(netxen_stats
->rx_packets
));
1099 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_AGGR_ERROR_CNT
,
1100 &(netxen_stats
->rx_errors
));
1101 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_CRC_ERROR_CNT
,
1102 &(netxen_stats
->rx_crc_errors
));
1103 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR
,
1105 rx_long_length_error
));
1106 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR
,
1108 rx_short_length_error
));
1110 netxen_nic_pci_change_crbwindow(adapter
, 1);
1112 spin_lock_bh(&adapter
->tx_lock
);
1113 netxen_stats
->tx_bytes
= port
->stats
.txbytes
;
1114 netxen_stats
->tx_packets
= port
->stats
.xmitedframes
+
1115 port
->stats
.xmitfinished
;
1116 netxen_stats
->rx_bytes
= port
->stats
.rxbytes
;
1117 netxen_stats
->rx_packets
= port
->stats
.no_rcv
;
1118 netxen_stats
->rx_errors
= port
->stats
.rcvdbadskb
;
1119 netxen_stats
->tx_errors
= port
->stats
.nocmddescriptor
;
1120 netxen_stats
->rx_short_length_error
= port
->stats
.uplcong
;
1121 netxen_stats
->rx_long_length_error
= port
->stats
.uphcong
;
1122 netxen_stats
->rx_crc_errors
= 0;
1123 netxen_stats
->rx_mac_errors
= 0;
1124 spin_unlock_bh(&adapter
->tx_lock
);
1129 void netxen_nic_clear_stats(struct netxen_adapter
*adapter
)
1131 struct netxen_port
*port
;
1134 memset(&adapter
->stats
, 0, sizeof(adapter
->stats
));
1135 for (port_num
= 0; port_num
< adapter
->ahw
.max_ports
; port_num
++) {
1136 port
= adapter
->port
[port_num
];
1137 memset(&port
->stats
, 0, sizeof(port
->stats
));
1142 netxen_nic_clear_statistics(struct netxen_adapter
*adapter
,
1143 struct netxen_port
*port
)
1147 netxen_nic_pci_change_crbwindow(adapter
, 0);
1149 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_TX_BYTE_CNT
, &data
);
1150 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_TX_FRAME_CNT
,
1152 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_RX_BYTE_CNT
, &data
);
1153 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_RX_FRAME_CNT
,
1155 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_AGGR_ERROR_CNT
,
1157 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_CRC_ERROR_CNT
,
1159 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR
,
1161 netxen_nic_locked_write_reg(adapter
, NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR
,
1164 netxen_nic_pci_change_crbwindow(adapter
, 1);
1165 netxen_nic_clear_stats(adapter
);
1170 netxen_nic_do_ioctl(struct netxen_adapter
*adapter
, void *u_data
,
1171 struct netxen_port
*port
)
1173 struct netxen_nic_ioctl_data data
;
1174 struct netxen_nic_ioctl_data
*up_data
;
1176 struct netxen_statistics netxen_stats
;
1178 up_data
= (void *)u_data
;
1180 DPRINTK(INFO
, "doing ioctl for %p\n", adapter
);
1181 if (copy_from_user(&data
, (void __user
*)up_data
, sizeof(data
))) {
1182 /* evil user tried to crash the kernel */
1183 DPRINTK(ERR
, "bad copy from userland: %d\n", (int)sizeof(data
));
1188 /* Shouldn't access beyond legal limits of "char u[64];" member */
1189 if (!data
.ptr
&& (data
.size
> sizeof(data
.u
))) {
1190 /* evil user tried to crash the kernel */
1191 DPRINTK(ERR
, "bad size: %d\n", data
.size
);
1197 case netxen_nic_cmd_pci_read
:
1198 if ((retval
= netxen_nic_hw_read_wx(adapter
, data
.off
,
1199 &(data
.u
), data
.size
)))
1202 ((void __user
*)&(up_data
->u
), &(data
.u
), data
.size
)) {
1203 DPRINTK(ERR
, "bad copy to userland: %d\n",
1211 case netxen_nic_cmd_pci_write
:
1212 data
.rv
= netxen_nic_hw_write_wx(adapter
, data
.off
, &(data
.u
),
1216 case netxen_nic_cmd_pci_config_read
:
1217 switch (data
.size
) {
1219 data
.rv
= pci_read_config_byte(adapter
->ahw
.pdev
,
1224 data
.rv
= pci_read_config_word(adapter
->ahw
.pdev
,
1226 (short *)&(data
.u
));
1229 data
.rv
= pci_read_config_dword(adapter
->ahw
.pdev
,
1231 (u32
*) & (data
.u
));
1235 ((void __user
*)&(up_data
->u
), &(data
.u
), data
.size
)) {
1236 DPRINTK(ERR
, "bad copy to userland: %d\n",
1243 case netxen_nic_cmd_pci_config_write
:
1244 switch (data
.size
) {
1246 data
.rv
= pci_write_config_byte(adapter
->ahw
.pdev
,
1248 *(char *)&(data
.u
));
1251 data
.rv
= pci_write_config_word(adapter
->ahw
.pdev
,
1253 *(short *)&(data
.u
));
1256 data
.rv
= pci_write_config_dword(adapter
->ahw
.pdev
,
1258 *(u32
*) & (data
.u
));
1263 case netxen_nic_cmd_get_stats
:
1265 netxen_nic_fill_statistics(adapter
, port
, &netxen_stats
);
1267 ((void __user
*)(up_data
->ptr
), (void *)&netxen_stats
,
1268 sizeof(struct netxen_statistics
))) {
1269 DPRINTK(ERR
, "bad copy to userland: %d\n",
1270 (int)sizeof(netxen_stats
));
1274 up_data
->rv
= data
.rv
;
1277 case netxen_nic_cmd_clear_stats
:
1278 data
.rv
= netxen_nic_clear_statistics(adapter
, port
);
1279 up_data
->rv
= data
.rv
;
1282 case netxen_nic_cmd_get_version
:
1284 ((void __user
*)&(up_data
->u
), NETXEN_NIC_LINUX_VERSIONID
,
1285 sizeof(NETXEN_NIC_LINUX_VERSIONID
))) {
1286 DPRINTK(ERR
, "bad copy to userland: %d\n",
1294 DPRINTK(INFO
, "bad command %d for %p\n", data
.cmd
, adapter
);
1295 retval
= -EOPNOTSUPP
;
1298 put_user(data
.rv
, (u16 __user
*) (&(up_data
->rv
)));
1299 DPRINTK(INFO
, "done ioctl for %p well.\n", adapter
);