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 * Provides access to the Network Interface Unit h/w block.
34 #include "netxen_nic.h"
36 #define NETXEN_GB_MAC_SOFT_RESET 0x80000000
37 #define NETXEN_GB_MAC_RESET_PROT_BLK 0x000F0000
38 #define NETXEN_GB_MAC_ENABLE_TX_RX 0x00000005
39 #define NETXEN_GB_MAC_PAUSED_FRMS 0x00000020
41 static long phy_lock_timeout = 100000000;
43 static int phy_lock(struct netxen_adapter *adapter)
46 int done = 0, timeout = 0;
49 done = netxen_nic_reg_read(adapter,
50 NETXEN_PCIE_REG(PCIE_SEM3_LOCK));
53 if (timeout >= phy_lock_timeout) {
60 for (i = 0; i < 20; i++)
65 netxen_crb_writelit_adapter(adapter,
66 NETXEN_PHY_LOCK_ID, PHY_LOCK_DRIVER);
70 static int phy_unlock(struct netxen_adapter *adapter)
72 adapter->pci_read_immediate(adapter, NETXEN_PCIE_REG(PCIE_SEM3_UNLOCK));
78 * netxen_niu_gbe_phy_read - read a register from the GbE PHY via
79 * mii management interface.
81 * Note: The MII management interface goes through port 0.
82 * Individual phys are addressed as follows:
83 * @param phy [15:8] phy id
84 * @param reg [7:0] register number
86 * @returns 0 on success
90 int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
96 long phy = adapter->physical_port;
102 if (phy_lock(adapter) != 0) {
107 * MII mgmt all goes through port 0 MAC interface,
108 * so it cannot be in reset
111 if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
114 if (netxen_gb_get_soft_reset(mac_cfg0)) {
117 netxen_gb_tx_reset_pb(temp);
118 netxen_gb_rx_reset_pb(temp);
119 netxen_gb_tx_reset_mac(temp);
120 netxen_gb_rx_reset_mac(temp);
121 if (adapter->hw_write_wx(adapter,
122 NETXEN_NIU_GB_MAC_CONFIG_0(0),
129 netxen_gb_mii_mgmt_reg_addr(address, reg);
130 netxen_gb_mii_mgmt_phy_addr(address, phy);
131 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
134 command = 0; /* turn off any prior activity */
135 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
138 /* send read command */
139 netxen_gb_mii_mgmt_set_read_cycle(command);
140 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
146 if (adapter->hw_read_wx(adapter,
147 NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
151 } while ((netxen_get_gb_mii_mgmt_busy(status)
152 || netxen_get_gb_mii_mgmt_notvalid(status))
153 && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
155 if (timeout < NETXEN_NIU_PHY_WAITMAX) {
156 if (adapter->hw_read_wx(adapter,
157 NETXEN_NIU_GB_MII_MGMT_STATUS(0),
165 if (adapter->hw_write_wx(adapter,
166 NETXEN_NIU_GB_MAC_CONFIG_0(0),
174 * netxen_niu_gbe_phy_write - write a register to the GbE PHY via
175 * mii management interface.
177 * Note: The MII management interface goes through port 0.
178 * Individual phys are addressed as follows:
179 * @param phy [15:8] phy id
180 * @param reg [7:0] register number
182 * @returns 0 on success
186 int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
192 long phy = adapter->physical_port;
199 * MII mgmt all goes through port 0 MAC interface, so it
203 if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
206 if (netxen_gb_get_soft_reset(mac_cfg0)) {
209 netxen_gb_tx_reset_pb(temp);
210 netxen_gb_rx_reset_pb(temp);
211 netxen_gb_tx_reset_mac(temp);
212 netxen_gb_rx_reset_mac(temp);
214 if (adapter->hw_write_wx(adapter,
215 NETXEN_NIU_GB_MAC_CONFIG_0(0),
221 command = 0; /* turn off any prior activity */
222 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
227 netxen_gb_mii_mgmt_reg_addr(address, reg);
228 netxen_gb_mii_mgmt_phy_addr(address, phy);
229 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
233 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_CTRL(0),
239 if (adapter->hw_read_wx(adapter,
240 NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
244 } while ((netxen_get_gb_mii_mgmt_busy(status))
245 && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
247 if (timeout < NETXEN_NIU_PHY_WAITMAX)
252 /* restore the state of port 0 MAC in case we tampered with it */
254 if (adapter->hw_write_wx(adapter,
255 NETXEN_NIU_GB_MAC_CONFIG_0(0),
262 int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter)
264 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x3f);
268 int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter)
272 netxen_set_phy_int_link_status_changed(enable);
273 netxen_set_phy_int_autoneg_completed(enable);
274 netxen_set_phy_int_speed_changed(enable);
277 netxen_niu_gbe_phy_write(adapter,
278 NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE,
285 int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter)
287 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x7f);
291 int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter)
295 netxen_niu_gbe_phy_write(adapter,
296 NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE, 0))
303 int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter)
305 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_ACTIVE_INT, -1);
310 static int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
314 netxen_niu_gbe_phy_write(adapter,
315 NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
323 * netxen_niu_gbe_set_mii_mode- Set 10/100 Mbit Mode for GbE MAC
326 static void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
327 int port, long enable)
329 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
330 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
332 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
334 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
336 netxen_crb_writelit_adapter(adapter,
337 NETXEN_NIU_GB0_GMII_MODE + (port << 3), 0);
338 netxen_crb_writelit_adapter(adapter,
339 NETXEN_NIU_GB0_MII_MODE + (port << 3), 1);
340 netxen_crb_writelit_adapter(adapter,
341 (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
342 netxen_crb_writelit_adapter(adapter,
343 NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
347 * Do NOT enable flow control until a suitable solution for
348 * shutting down pause frames is found.
350 netxen_crb_writelit_adapter(adapter,
351 NETXEN_NIU_GB_MAC_CONFIG_0(port),
355 if (netxen_niu_gbe_enable_phy_interrupts(adapter))
356 printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
357 if (netxen_niu_gbe_clear_phy_interrupts(adapter))
358 printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
362 * netxen_niu_gbe_set_gmii_mode- Set GbE Mode for GbE MAC
364 static void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
365 int port, long enable)
367 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
368 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
370 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
372 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
374 netxen_crb_writelit_adapter(adapter,
375 NETXEN_NIU_GB0_MII_MODE + (port << 3), 0);
376 netxen_crb_writelit_adapter(adapter,
377 NETXEN_NIU_GB0_GMII_MODE + (port << 3), 1);
378 netxen_crb_writelit_adapter(adapter,
379 (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
380 netxen_crb_writelit_adapter(adapter,
381 NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
385 * Do NOT enable flow control until a suitable solution for
386 * shutting down pause frames is found.
388 netxen_crb_writelit_adapter(adapter,
389 NETXEN_NIU_GB_MAC_CONFIG_0(port),
393 if (netxen_niu_gbe_enable_phy_interrupts(adapter))
394 printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
395 if (netxen_niu_gbe_clear_phy_interrupts(adapter))
396 printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
399 int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
403 if (adapter->disable_phy_interrupts)
404 adapter->disable_phy_interrupts(adapter);
408 netxen_niu_gbe_phy_read(adapter,
409 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
411 if (netxen_get_phy_link(status)) {
412 if (netxen_get_phy_speed(status) == 2) {
413 netxen_niu_gbe_set_gmii_mode(adapter, port, 1);
414 } else if ((netxen_get_phy_speed(status) == 1)
415 || (netxen_get_phy_speed(status) == 0)) {
416 netxen_niu_gbe_set_mii_mode(adapter, port, 1);
423 * We don't have link. Cable must be unconnected.
424 * Enable phy interrupts so we take action when
428 netxen_crb_writelit_adapter(adapter,
429 NETXEN_NIU_GB_MAC_CONFIG_0
431 NETXEN_GB_MAC_SOFT_RESET);
432 netxen_crb_writelit_adapter(adapter,
433 NETXEN_NIU_GB_MAC_CONFIG_0
435 NETXEN_GB_MAC_RESET_PROT_BLK
436 | NETXEN_GB_MAC_ENABLE_TX_RX
438 NETXEN_GB_MAC_PAUSED_FRMS);
439 if (netxen_niu_gbe_clear_phy_interrupts(adapter))
441 "ERROR clearing PHY interrupts\n");
442 if (netxen_niu_gbe_enable_phy_interrupts(adapter))
444 "ERROR enabling PHY interrupts\n");
445 if (netxen_niu_gbe_clear_phy_interrupts(adapter))
447 "ERROR clearing PHY interrupts\n");
456 int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
458 u32 portnum = adapter->physical_port;
460 netxen_crb_writelit_adapter(adapter,
461 NETXEN_NIU_XGE_CONFIG_1+(0x10000*portnum), 0x1447);
462 netxen_crb_writelit_adapter(adapter,
463 NETXEN_NIU_XGE_CONFIG_0+(0x10000*portnum), 0x5);
470 * netxen_niu_gbe_handle_phy_interrupt - Handles GbE PHY interrupts
471 * @param enable 0 means don't enable the port
472 * 1 means enable (or re-enable) the port
474 int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
475 int port, long enable)
480 printk(KERN_INFO PFX "NETXEN: Handling PHY interrupt on port %d"
481 " (device enable = %d)\n", (int)port, (int)enable);
484 * The read of the PHY INT status will clear the pending
487 if (netxen_niu_gbe_phy_read(adapter,
488 NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
492 printk(KERN_INFO PFX "PHY Interrupt source = 0x%x \n", int_src);
493 if (netxen_get_phy_int_jabber(int_src))
494 printk(KERN_INFO PFX "jabber Interrupt ");
495 if (netxen_get_phy_int_polarity_changed(int_src))
496 printk(KERN_INFO PFX "polarity changed ");
497 if (netxen_get_phy_int_energy_detect(int_src))
498 printk(KERN_INFO PFX "energy detect \n");
499 if (netxen_get_phy_int_downshift(int_src))
500 printk(KERN_INFO PFX "downshift \n");
501 if (netxen_get_phy_int_mdi_xover_changed(int_src))
502 printk(KERN_INFO PFX "mdi_xover_changed ");
503 if (netxen_get_phy_int_fifo_over_underflow(int_src))
504 printk(KERN_INFO PFX "fifo_over_underflow ");
505 if (netxen_get_phy_int_false_carrier(int_src))
506 printk(KERN_INFO PFX "false_carrier ");
507 if (netxen_get_phy_int_symbol_error(int_src))
508 printk(KERN_INFO PFX "symbol_error ");
509 if (netxen_get_phy_int_autoneg_completed(int_src))
510 printk(KERN_INFO PFX "autoneg_completed ");
511 if (netxen_get_phy_int_page_received(int_src))
512 printk(KERN_INFO PFX "page_received ");
513 if (netxen_get_phy_int_duplex_changed(int_src))
514 printk(KERN_INFO PFX "duplex_changed ");
515 if (netxen_get_phy_int_autoneg_error(int_src))
516 printk(KERN_INFO PFX "autoneg_error ");
517 if ((netxen_get_phy_int_speed_changed(int_src))
518 || (netxen_get_phy_int_link_status_changed(int_src))) {
522 "speed_changed or link status changed");
523 if (netxen_niu_gbe_phy_read
525 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
527 if (netxen_get_phy_speed(status) == 2) {
529 (KERN_INFO PFX "Link speed changed"
531 netxen_niu_gbe_set_gmii_mode(adapter,
534 } else if (netxen_get_phy_speed(status) == 1) {
536 (KERN_INFO PFX "Link speed changed"
538 netxen_niu_gbe_set_mii_mode(adapter,
541 } else if (netxen_get_phy_speed(status) == 0) {
543 (KERN_INFO PFX "Link speed changed"
545 netxen_niu_gbe_set_mii_mode(adapter,
549 printk(KERN_ERR PFX "ERROR reading "
550 "PHY status. Invalid speed.\n");
555 "ERROR reading PHY status.\n");
560 printk(KERN_INFO "\n");
567 * Return the current station MAC address.
568 * Note that the passed-in value must already be in network byte order.
570 static int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
571 netxen_ethernet_macaddr_t * addr)
575 int phy = adapter->physical_port;
580 if ((phy < 0) || (phy > 3))
583 if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy),
586 if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy),
589 ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
590 ((__le32 *)val)[0] = cpu_to_le32(stationlow);
592 memcpy(addr, val + 2, 6);
598 * Set the station MAC address.
599 * Note that the passed-in value must already be in network byte order.
601 int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
602 netxen_ethernet_macaddr_t addr)
606 int phy = adapter->physical_port;
607 unsigned char mac_addr[6];
609 DECLARE_MAC_BUF(mac);
611 for (i = 0; i < 10; i++) {
612 temp[0] = temp[1] = 0;
613 memcpy(temp + 2, addr, 2);
614 val = le32_to_cpu(*(__le32 *)temp);
615 if (adapter->hw_write_wx(adapter,
616 NETXEN_NIU_GB_STATION_ADDR_1(phy), &val, 4))
619 memcpy(temp, ((u8 *) addr) + 2, sizeof(__le32));
620 val = le32_to_cpu(*(__le32 *)temp);
621 if (adapter->hw_write_wx(adapter,
622 NETXEN_NIU_GB_STATION_ADDR_0(phy), &val, 4))
625 netxen_niu_macaddr_get(adapter,
626 (netxen_ethernet_macaddr_t *) mac_addr);
627 if (memcmp(mac_addr, addr, 6) == 0)
632 printk(KERN_ERR "%s: cannot set Mac addr for %s\n",
633 netxen_nic_driver_name, adapter->netdev->name);
634 printk(KERN_ERR "MAC address set: %s.\n",
635 print_mac(mac, addr));
636 printk(KERN_ERR "MAC address get: %s.\n",
637 print_mac(mac, mac_addr));
643 /* Enable a GbE interface */
644 int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
645 int port, netxen_niu_gbe_ifmode_t mode)
651 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
655 netxen_gb_soft_reset(mac_cfg0);
656 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
660 netxen_gb_enable_tx(mac_cfg0);
661 netxen_gb_enable_rx(mac_cfg0);
662 netxen_gb_unset_rx_flowctl(mac_cfg0);
663 netxen_gb_tx_reset_pb(mac_cfg0);
664 netxen_gb_rx_reset_pb(mac_cfg0);
665 netxen_gb_tx_reset_mac(mac_cfg0);
666 netxen_gb_rx_reset_mac(mac_cfg0);
668 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
672 netxen_gb_set_preamblelen(mac_cfg1, 0xf);
673 netxen_gb_set_duplex(mac_cfg1);
674 netxen_gb_set_crc_enable(mac_cfg1);
675 netxen_gb_set_padshort(mac_cfg1);
676 netxen_gb_set_checklength(mac_cfg1);
677 netxen_gb_set_hugeframes(mac_cfg1);
679 if (mode == NETXEN_NIU_10_100_MB) {
680 netxen_gb_set_intfmode(mac_cfg1, 1);
681 if (adapter->hw_write_wx(adapter,
682 NETXEN_NIU_GB_MAC_CONFIG_1(port),
687 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_GMII_MODE +
689 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_MII_MODE +
692 } else if (mode == NETXEN_NIU_1000_MB) {
693 netxen_gb_set_intfmode(mac_cfg1, 2);
694 if (adapter->hw_write_wx(adapter,
695 NETXEN_NIU_GB_MAC_CONFIG_1(port),
699 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_MII_MODE +
701 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_GMII_MODE +
705 netxen_gb_set_mii_mgmt_clockselect(mii_cfg, 7);
706 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_CONFIG(port),
710 netxen_gb_enable_tx(mac_cfg0);
711 netxen_gb_enable_rx(mac_cfg0);
712 netxen_gb_unset_rx_flowctl(mac_cfg0);
713 netxen_gb_unset_tx_flowctl(mac_cfg0);
715 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
722 /* Disable a GbE interface */
723 int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter)
726 u32 port = adapter->physical_port;
728 if (port > NETXEN_NIU_MAX_GBE_PORTS)
731 netxen_gb_soft_reset(mac_cfg0);
732 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
738 /* Disable an XG interface */
739 int netxen_niu_disable_xg_port(struct netxen_adapter *adapter)
742 u32 port = adapter->physical_port;
744 if (port > NETXEN_NIU_MAX_XG_PORTS)
748 if (adapter->hw_write_wx(adapter,
749 NETXEN_NIU_XGE_CONFIG_0 + (0x10000 * port), &mac_cfg, 4))
754 /* Set promiscuous mode for a GbE interface */
755 int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
756 netxen_niu_prom_mode_t mode)
759 u32 port = adapter->physical_port;
761 if (port > NETXEN_NIU_MAX_GBE_PORTS)
764 /* save previous contents */
765 if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
768 if (mode == NETXEN_NIU_PROMISC_MODE) {
771 netxen_clear_gb_drop_gb0(reg);
774 netxen_clear_gb_drop_gb1(reg);
777 netxen_clear_gb_drop_gb2(reg);
780 netxen_clear_gb_drop_gb3(reg);
788 netxen_set_gb_drop_gb0(reg);
791 netxen_set_gb_drop_gb1(reg);
794 netxen_set_gb_drop_gb2(reg);
797 netxen_set_gb_drop_gb3(reg);
803 if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
810 * Set the MAC address for an XG port
811 * Note that the passed-in value must already be in network byte order.
813 int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
814 netxen_ethernet_macaddr_t addr)
816 int phy = adapter->physical_port;
820 if ((phy < 0) || (phy > NETXEN_NIU_MAX_XG_PORTS))
823 temp[0] = temp[1] = 0;
826 memcpy(temp + 2, addr, 2);
827 val = le32_to_cpu(*(__le32 *)temp);
828 if (adapter->hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
832 memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
833 val = le32_to_cpu(*(__le32 *)temp);
834 if (adapter->hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
840 memcpy(temp + 2, addr, 2);
841 val = le32_to_cpu(*(__le32 *)temp);
842 if (adapter->hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_1,
846 memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
847 val = le32_to_cpu(*(__le32 *)temp);
848 if (adapter->hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_HI,
854 printk(KERN_ERR "Unknown port %d\n", phy);
863 * Return the current station MAC address.
864 * Note that the passed-in value must already be in network byte order.
866 int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter,
867 netxen_ethernet_macaddr_t * addr)
869 int phy = adapter->physical_port;
879 if (adapter->hw_read_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
882 if (adapter->hw_read_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
885 ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
886 ((__le32 *)val)[0] = cpu_to_le32(stationlow);
888 memcpy(addr, val + 2, 6);
894 int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
895 netxen_niu_prom_mode_t mode)
898 u32 port = adapter->physical_port;
900 if (port > NETXEN_NIU_MAX_XG_PORTS)
903 if (adapter->hw_read_wx(adapter,
904 NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), ®, 4))
906 if (mode == NETXEN_NIU_PROMISC_MODE)
907 reg = (reg | 0x2000UL);
909 reg = (reg & ~0x2000UL);
911 if (mode == NETXEN_NIU_ALLMULTI_MODE)
912 reg = (reg | 0x1000UL);
914 reg = (reg & ~0x1000UL);
916 netxen_crb_writelit_adapter(adapter,
917 NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), reg);