netxen patches
[linux-2.6] / drivers / net / netxen / netxen_nic_niu.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  * Provides access to the Network Interface Unit h/w block.
31  *
32  */
33
34 #include "netxen_nic.h"
35
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
40
41 static long phy_lock_timeout = 100000000;
42
43 static inline int phy_lock(struct netxen_adapter *adapter)
44 {
45         int i;
46         int done = 0, timeout = 0;
47
48         while (!done) {
49                 done =
50                     readl(pci_base_offset
51                           (adapter, NETXEN_PCIE_REG(PCIE_SEM3_LOCK)));
52                 if (done == 1)
53                         break;
54                 if (timeout >= phy_lock_timeout) {
55                         return -1;
56                 }
57                 timeout++;
58                 if (!in_atomic())
59                         schedule();
60                 else {
61                         for (i = 0; i < 20; i++)
62                                 cpu_relax();
63                 }
64         }
65
66         writel(PHY_LOCK_DRIVER,
67                NETXEN_CRB_NORMALIZE(adapter, NETXEN_PHY_LOCK_ID));
68         return 0;
69 }
70
71 static inline int phy_unlock(struct netxen_adapter *adapter)
72 {
73         readl(pci_base_offset(adapter, NETXEN_PCIE_REG(PCIE_SEM3_UNLOCK)));
74
75         return 0;
76 }
77
78 /* 
79  * netxen_niu_gbe_phy_read - read a register from the GbE PHY via
80  * mii management interface.
81  *
82  * Note: The MII management interface goes through port 0.
83  *      Individual phys are addressed as follows:
84  * @param phy  [15:8]  phy id
85  * @param reg  [7:0]   register number
86  *
87  * @returns  0 on success
88  *        -1 on error
89  *
90  */
91 int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy,
92                             long reg, __u32 * readval)
93 {
94         long timeout = 0;
95         long result = 0;
96         long restore = 0;
97         __u32 address;
98         __u32 command;
99         __u32 status;
100         __u32 mac_cfg0;
101
102         if (phy_lock(adapter) != 0) {
103                 return -1;
104         }
105
106         /*
107          * MII mgmt all goes through port 0 MAC interface,
108          * so it cannot be in reset
109          */
110
111         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
112                                   &mac_cfg0, 4))
113                 return -EIO;
114         if (netxen_gb_get_soft_reset(mac_cfg0)) {
115                 __u32 temp;
116                 temp = 0;
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 (netxen_nic_hw_write_wx(adapter,
122                                            NETXEN_NIU_GB_MAC_CONFIG_0(0),
123                                            &temp, 4))
124                         return -EIO;
125                 restore = 1;
126         }
127
128         address = 0;
129         netxen_gb_mii_mgmt_reg_addr(address, reg);
130         netxen_gb_mii_mgmt_phy_addr(address, phy);
131         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
132                                    &address, 4))
133                 return -EIO;
134         command = 0;            /* turn off any prior activity */
135         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
136                                    &command, 4))
137                 return -EIO;
138         /* send read command */
139         netxen_gb_mii_mgmt_set_read_cycle(command);
140         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
141                                    &command, 4))
142                 return -EIO;
143
144         status = 0;
145         do {
146                 if (netxen_nic_hw_read_wx(adapter,
147                                           NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
148                                           &status, 4))
149                         return -EIO;
150                 timeout++;
151         } while ((netxen_get_gb_mii_mgmt_busy(status)
152                   || netxen_get_gb_mii_mgmt_notvalid(status))
153                  && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
154
155         if (timeout < NETXEN_NIU_PHY_WAITMAX) {
156                 if (netxen_nic_hw_read_wx(adapter,
157                                           NETXEN_NIU_GB_MII_MGMT_STATUS(0),
158                                           readval, 4))
159                         return -EIO;
160                 result = 0;
161         } else
162                 result = -1;
163
164         if (restore)
165                 if (netxen_nic_hw_write_wx(adapter,
166                                            NETXEN_NIU_GB_MAC_CONFIG_0(0),
167                                            &mac_cfg0, 4))
168                         return -EIO;
169         phy_unlock(adapter);
170         return result;
171 }
172
173 /* 
174  * netxen_niu_gbe_phy_write - write a register to the GbE PHY via
175  * mii management interface.
176  *
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
181  *
182  * @returns  0 on success
183  *        -1 on error
184  *
185  */
186 int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter,
187                              long phy, long reg, __u32 val)
188 {
189         long timeout = 0;
190         long result = 0;
191         long restore = 0;
192         __u32 address;
193         __u32 command;
194         __u32 status;
195         __u32 mac_cfg0;
196
197         /*
198          * MII mgmt all goes through port 0 MAC interface, so it
199          * cannot be in reset
200          */
201
202         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
203                                   &mac_cfg0, 4))
204                 return -EIO;
205         if (netxen_gb_get_soft_reset(mac_cfg0)) {
206                 __u32 temp;
207                 temp = 0;
208                 netxen_gb_tx_reset_pb(temp);
209                 netxen_gb_rx_reset_pb(temp);
210                 netxen_gb_tx_reset_mac(temp);
211                 netxen_gb_rx_reset_mac(temp);
212
213                 if (netxen_nic_hw_write_wx(adapter,
214                                            NETXEN_NIU_GB_MAC_CONFIG_0(0),
215                                            &temp, 4))
216                         return -EIO;
217                 restore = 1;
218         }
219
220         command = 0;            /* turn off any prior activity */
221         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
222                                    &command, 4))
223                 return -EIO;
224
225         address = 0;
226         netxen_gb_mii_mgmt_reg_addr(address, reg);
227         netxen_gb_mii_mgmt_phy_addr(address, phy);
228         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
229                                    &address, 4))
230                 return -EIO;
231
232         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_CTRL(0),
233                                    &val, 4))
234                 return -EIO;
235
236         status = 0;
237         do {
238                 if (netxen_nic_hw_read_wx(adapter,
239                                           NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
240                                           &status, 4))
241                         return -EIO;
242                 timeout++;
243         } while ((netxen_get_gb_mii_mgmt_busy(status))
244                  && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
245
246         if (timeout < NETXEN_NIU_PHY_WAITMAX)
247                 result = 0;
248         else
249                 result = -EIO;
250
251         /* restore the state of port 0 MAC in case we tampered with it */
252         if (restore)
253                 if (netxen_nic_hw_write_wx(adapter,
254                                            NETXEN_NIU_GB_MAC_CONFIG_0(0),
255                                            &mac_cfg0, 4))
256                         return -EIO;
257
258         return result;
259 }
260
261 int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter,
262                                           int port)
263 {
264         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x3f);
265         return 0;
266 }
267
268 int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter,
269                                          int port)
270 {
271         int result = 0;
272         __u32 enable = 0;
273         netxen_set_phy_int_link_status_changed(enable);
274         netxen_set_phy_int_autoneg_completed(enable);
275         netxen_set_phy_int_speed_changed(enable);
276
277         if (0 !=
278             netxen_niu_gbe_phy_write(adapter, port,
279                                      NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE,
280                                      enable))
281                 result = -EIO;
282
283         return result;
284 }
285
286 int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter,
287                                            int port)
288 {
289         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x7f);
290         return 0;
291 }
292
293 int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter,
294                                           int port)
295 {
296         int result = 0;
297         if (0 !=
298             netxen_niu_gbe_phy_write(adapter, port,
299                                      NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE, 0))
300                 result = -EIO;
301
302         return result;
303 }
304
305 int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter,
306                                          int port)
307 {
308         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_ACTIVE_INT, -1);
309         return 0;
310 }
311
312 int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter,
313                                         int port)
314 {
315         int result = 0;
316         if (0 !=
317             netxen_niu_gbe_phy_write(adapter, port,
318                                      NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
319                                      -EIO))
320                 result = -EIO;
321
322         return result;
323 }
324
325 /* 
326  * netxen_niu_gbe_set_mii_mode- Set 10/100 Mbit Mode for GbE MAC
327  *
328  */
329 void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
330                                  int port, long enable)
331 {
332         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
333         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
334                                     0x80000000);
335         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
336                                     0x0000f0025);
337         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
338                                     0xf1ff);
339         netxen_crb_writelit_adapter(adapter,
340                                     NETXEN_NIU_GB0_GMII_MODE + (port << 3), 0);
341         netxen_crb_writelit_adapter(adapter,
342                                     NETXEN_NIU_GB0_MII_MODE + (port << 3), 1);
343         netxen_crb_writelit_adapter(adapter,
344                                     (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
345         netxen_crb_writelit_adapter(adapter,
346                                     NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
347
348         if (enable) {
349                 /* 
350                  * Do NOT enable flow control until a suitable solution for 
351                  *  shutting down pause frames is found. 
352                  */
353                 netxen_crb_writelit_adapter(adapter,
354                                             NETXEN_NIU_GB_MAC_CONFIG_0(port),
355                                             0x5);
356         }
357
358         if (netxen_niu_gbe_enable_phy_interrupts(adapter, port))
359                 printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
360         if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
361                 printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
362 }
363
364 /* 
365  * netxen_niu_gbe_set_gmii_mode- Set GbE Mode for GbE MAC
366  */
367 void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
368                                   int port, long enable)
369 {
370         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
371         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
372                                     0x80000000);
373         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
374                                     0x0000f0025);
375         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
376                                     0xf2ff);
377         netxen_crb_writelit_adapter(adapter,
378                                     NETXEN_NIU_GB0_MII_MODE + (port << 3), 0);
379         netxen_crb_writelit_adapter(adapter,
380                                     NETXEN_NIU_GB0_GMII_MODE + (port << 3), 1);
381         netxen_crb_writelit_adapter(adapter,
382                                     (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
383         netxen_crb_writelit_adapter(adapter,
384                                     NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
385
386         if (enable) {
387                 /* 
388                  * Do NOT enable flow control until a suitable solution for 
389                  *  shutting down pause frames is found. 
390                  */
391                 netxen_crb_writelit_adapter(adapter,
392                                             NETXEN_NIU_GB_MAC_CONFIG_0(port),
393                                             0x5);
394         }
395
396         if (netxen_niu_gbe_enable_phy_interrupts(adapter, port))
397                 printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
398         if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
399                 printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
400 }
401
402 int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
403 {
404         int result = 0;
405         __u32 status;
406         if (adapter->disable_phy_interrupts)
407                 adapter->disable_phy_interrupts(adapter, port);
408         mdelay(2);
409
410         if (0 ==
411             netxen_niu_gbe_phy_read(adapter, port,
412                                     NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
413                                     &status)) {
414                 if (netxen_get_phy_link(status)) {
415                         if (netxen_get_phy_speed(status) == 2) {
416                                 netxen_niu_gbe_set_gmii_mode(adapter, port, 1);
417                         } else if ((netxen_get_phy_speed(status) == 1)
418                                    || (netxen_get_phy_speed(status) == 0)) {
419                                 netxen_niu_gbe_set_mii_mode(adapter, port, 1);
420                         } else {
421                                 result = -1;
422                         }
423
424                 } else {
425                         /*
426                          * We don't have link. Cable  must be unconnected.
427                          * Enable phy interrupts so we take action when
428                          * plugged in.
429                          */
430
431                         netxen_crb_writelit_adapter(adapter,
432                                                     NETXEN_NIU_GB_MAC_CONFIG_0
433                                                     (port),
434                                                     NETXEN_GB_MAC_SOFT_RESET);
435                         netxen_crb_writelit_adapter(adapter,
436                                                     NETXEN_NIU_GB_MAC_CONFIG_0
437                                                     (port),
438                                                     NETXEN_GB_MAC_RESET_PROT_BLK
439                                                     | NETXEN_GB_MAC_ENABLE_TX_RX
440                                                     |
441                                                     NETXEN_GB_MAC_PAUSED_FRMS);
442                         if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
443                                 printk(KERN_ERR PFX
444                                        "ERROR clearing PHY interrupts\n");
445                         if (netxen_niu_gbe_enable_phy_interrupts(adapter, port))
446                                 printk(KERN_ERR PFX
447                                        "ERROR enabling PHY interrupts\n");
448                         if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
449                                 printk(KERN_ERR PFX
450                                        "ERROR clearing PHY interrupts\n");
451                         result = -1;
452                 }
453         } else {
454                 result = -EIO;
455         }
456         return result;
457 }
458
459 int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
460 {
461         long reg = 0, ret = 0;
462
463         if (adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB31_10G_IMEZ) {
464                 netxen_crb_writelit_adapter(adapter,
465                                             NETXEN_NIU_XG1_CONFIG_0, 0x5);
466                 /* XXX hack for Mez cards: both ports in promisc mode */
467                 netxen_nic_hw_read_wx(adapter,
468                                       NETXEN_NIU_XGE_CONFIG_1, &reg, 4);
469                 reg = (reg | 0x2000UL);
470                 netxen_crb_writelit_adapter(adapter,
471                                             NETXEN_NIU_XGE_CONFIG_1, reg);
472                 reg = 0;
473                 netxen_nic_hw_read_wx(adapter,
474                                       NETXEN_NIU_XG1_CONFIG_1, &reg, 4);
475                 reg = (reg | 0x2000UL);
476                 netxen_crb_writelit_adapter(adapter,
477                                             NETXEN_NIU_XG1_CONFIG_1, reg);
478         }
479
480         return ret;
481 }
482
483 /* 
484  * netxen_niu_gbe_handle_phy_interrupt - Handles GbE PHY interrupts
485  * @param enable 0 means don't enable the port
486  *               1 means enable (or re-enable) the port
487  */
488 int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
489                                         int port, long enable)
490 {
491         int result = 0;
492         __u32 int_src;
493
494         printk(KERN_INFO PFX "NETXEN: Handling PHY interrupt on port %d"
495                " (device enable = %d)\n", (int)port, (int)enable);
496
497         /*
498          * The read of the PHY INT status will clear the pending
499          * interrupt status
500          */
501         if (netxen_niu_gbe_phy_read(adapter, port,
502                                     NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
503                                     &int_src) != 0)
504                 result = -EINVAL;
505         else {
506                 printk(KERN_INFO PFX "PHY Interrupt source = 0x%x \n", int_src);
507                 if (netxen_get_phy_int_jabber(int_src))
508                         printk(KERN_INFO PFX "jabber Interrupt ");
509                 if (netxen_get_phy_int_polarity_changed(int_src))
510                         printk(KERN_INFO PFX "polarity changed ");
511                 if (netxen_get_phy_int_energy_detect(int_src))
512                         printk(KERN_INFO PFX "energy detect \n");
513                 if (netxen_get_phy_int_downshift(int_src))
514                         printk(KERN_INFO PFX "downshift \n");
515                 if (netxen_get_phy_int_mdi_xover_changed(int_src))
516                         printk(KERN_INFO PFX "mdi_xover_changed ");
517                 if (netxen_get_phy_int_fifo_over_underflow(int_src))
518                         printk(KERN_INFO PFX "fifo_over_underflow ");
519                 if (netxen_get_phy_int_false_carrier(int_src))
520                         printk(KERN_INFO PFX "false_carrier ");
521                 if (netxen_get_phy_int_symbol_error(int_src))
522                         printk(KERN_INFO PFX "symbol_error ");
523                 if (netxen_get_phy_int_autoneg_completed(int_src))
524                         printk(KERN_INFO PFX "autoneg_completed ");
525                 if (netxen_get_phy_int_page_received(int_src))
526                         printk(KERN_INFO PFX "page_received ");
527                 if (netxen_get_phy_int_duplex_changed(int_src))
528                         printk(KERN_INFO PFX "duplex_changed ");
529                 if (netxen_get_phy_int_autoneg_error(int_src))
530                         printk(KERN_INFO PFX "autoneg_error ");
531                 if ((netxen_get_phy_int_speed_changed(int_src))
532                     || (netxen_get_phy_int_link_status_changed(int_src))) {
533                         __u32 status;
534
535                         printk(KERN_INFO PFX
536                                "speed_changed or link status changed");
537                         if (netxen_niu_gbe_phy_read
538                             (adapter, port,
539                              NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
540                              &status) == 0) {
541                                 if (netxen_get_phy_speed(status) == 2) {
542                                         printk
543                                             (KERN_INFO PFX "Link speed changed"
544                                              " to 1000 Mbps\n");
545                                         netxen_niu_gbe_set_gmii_mode(adapter,
546                                                                      port,
547                                                                      enable);
548                                 } else if (netxen_get_phy_speed(status) == 1) {
549                                         printk
550                                             (KERN_INFO PFX "Link speed changed"
551                                              " to 100 Mbps\n");
552                                         netxen_niu_gbe_set_mii_mode(adapter,
553                                                                     port,
554                                                                     enable);
555                                 } else if (netxen_get_phy_speed(status) == 0) {
556                                         printk
557                                             (KERN_INFO PFX "Link speed changed"
558                                              " to 10 Mbps\n");
559                                         netxen_niu_gbe_set_mii_mode(adapter,
560                                                                     port,
561                                                                     enable);
562                                 } else {
563                                         printk(KERN_ERR PFX "ERROR reading"
564                                                "PHY status. Illegal speed.\n");
565                                         result = -1;
566                                 }
567                         } else {
568                                 printk(KERN_ERR PFX
569                                        "ERROR reading PHY status.\n");
570                                 result = -1;
571                         }
572
573                 }
574                 printk(KERN_INFO "\n");
575         }
576         return result;
577 }
578
579 /*
580  * Return the current station MAC address.
581  * Note that the passed-in value must already be in network byte order.
582  */
583 int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
584                            int phy, netxen_ethernet_macaddr_t * addr)
585 {
586         u32 stationhigh;
587         u32 stationlow;
588         u8 val[8];
589
590         if (addr == NULL)
591                 return -EINVAL;
592         if ((phy < 0) || (phy > 3))
593                 return -EINVAL;
594
595         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy),
596                                   &stationhigh, 4))
597                 return -EIO;
598         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy),
599                                   &stationlow, 4))
600                 return -EIO;
601         ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
602         ((__le32 *)val)[0] = cpu_to_le32(stationlow);
603
604         memcpy(addr, val + 2, 6);
605
606         return 0;
607 }
608
609 /*
610  * Set the station MAC address.
611  * Note that the passed-in value must already be in network byte order.
612  */
613 int netxen_niu_macaddr_set(struct netxen_port *port,
614                            netxen_ethernet_macaddr_t addr)
615 {
616         u8 temp[4];
617         u32 val;
618         struct netxen_adapter *adapter = port->adapter;
619         int phy = port->portnum;
620         unsigned char mac_addr[6];
621         int i;
622
623         for (i = 0; i < 10; i++) {
624                 temp[0] = temp[1] = 0;
625                 memcpy(temp + 2, addr, 2);
626                 val = le32_to_cpu(*(__le32 *)temp);
627                 if (netxen_nic_hw_write_wx
628                     (adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy), &val, 4))
629                         return -EIO;
630
631                 memcpy(temp, ((u8 *) addr) + 2, sizeof(__le32));
632                 val = le32_to_cpu(*(__le32 *)temp);
633                 if (netxen_nic_hw_write_wx
634                     (adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy), &val, 4))
635                         return -2;
636
637                 netxen_niu_macaddr_get(adapter, phy,
638                                        (netxen_ethernet_macaddr_t *) mac_addr);
639                 if (memcmp(mac_addr, addr, 6) == 0)
640                         break;
641         }
642
643         if (i == 10) {
644                 printk(KERN_ERR "%s: cannot set Mac addr for %s\n",
645                        netxen_nic_driver_name, port->netdev->name);
646                 printk(KERN_ERR "MAC address set: "
647                        "%02x:%02x:%02x:%02x:%02x:%02x.\n",
648                        addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
649
650                 printk(KERN_ERR "MAC address get: "
651                        "%02x:%02x:%02x:%02x:%02x:%02x.\n",
652                        mac_addr[0],
653                        mac_addr[1],
654                        mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
655         }
656         return 0;
657 }
658
659 /* Enable a GbE interface */
660 int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
661                                int port, netxen_niu_gbe_ifmode_t mode)
662 {
663         __u32 mac_cfg0;
664         __u32 mac_cfg1;
665         __u32 mii_cfg;
666
667         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
668                 return -EINVAL;
669
670         mac_cfg0 = 0;
671         netxen_gb_soft_reset(mac_cfg0);
672         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
673                                    &mac_cfg0, 4))
674                 return -EIO;
675         mac_cfg0 = 0;
676         netxen_gb_enable_tx(mac_cfg0);
677         netxen_gb_enable_rx(mac_cfg0);
678         netxen_gb_unset_rx_flowctl(mac_cfg0);
679         netxen_gb_tx_reset_pb(mac_cfg0);
680         netxen_gb_rx_reset_pb(mac_cfg0);
681         netxen_gb_tx_reset_mac(mac_cfg0);
682         netxen_gb_rx_reset_mac(mac_cfg0);
683
684         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
685                                    &mac_cfg0, 4))
686                 return -EIO;
687         mac_cfg1 = 0;
688         netxen_gb_set_preamblelen(mac_cfg1, 0xf);
689         netxen_gb_set_duplex(mac_cfg1);
690         netxen_gb_set_crc_enable(mac_cfg1);
691         netxen_gb_set_padshort(mac_cfg1);
692         netxen_gb_set_checklength(mac_cfg1);
693         netxen_gb_set_hugeframes(mac_cfg1);
694
695         if (mode == NETXEN_NIU_10_100_MB) {
696                 netxen_gb_set_intfmode(mac_cfg1, 1);
697                 if (netxen_nic_hw_write_wx(adapter,
698                                            NETXEN_NIU_GB_MAC_CONFIG_1(port),
699                                            &mac_cfg1, 4))
700                         return -EIO;
701
702                 /* set mii mode */
703                 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_GMII_MODE +
704                                             (port << 3), 0);
705                 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_MII_MODE +
706                                             (port << 3), 1);
707
708         } else if (mode == NETXEN_NIU_1000_MB) {
709                 netxen_gb_set_intfmode(mac_cfg1, 2);
710                 if (netxen_nic_hw_write_wx(adapter,
711                                            NETXEN_NIU_GB_MAC_CONFIG_1(port),
712                                            &mac_cfg1, 4))
713                         return -EIO;
714                 /* set gmii mode */
715                 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_MII_MODE +
716                                             (port << 3), 0);
717                 netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_GMII_MODE +
718                                             (port << 3), 1);
719         }
720         mii_cfg = 0;
721         netxen_gb_set_mii_mgmt_clockselect(mii_cfg, 7);
722         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_CONFIG(port),
723                                    &mii_cfg, 4))
724                 return -EIO;
725         mac_cfg0 = 0;
726         netxen_gb_enable_tx(mac_cfg0);
727         netxen_gb_enable_rx(mac_cfg0);
728         netxen_gb_unset_rx_flowctl(mac_cfg0);
729         netxen_gb_unset_tx_flowctl(mac_cfg0);
730
731         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
732                                    &mac_cfg0, 4))
733                 return -EIO;
734         return 0;
735 }
736
737 /* Disable a GbE interface */
738 int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port)
739 {
740         __u32 mac_cfg0;
741
742         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
743                 return -EINVAL;
744
745         mac_cfg0 = 0;
746         netxen_gb_soft_reset(mac_cfg0);
747         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
748                                    &mac_cfg0, 4))
749                 return -EIO;
750         return 0;
751 }
752
753 /* Disable an XG interface */
754 int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port)
755 {
756         __u32 mac_cfg;
757
758         if (port != 0)
759                 return -EINVAL;
760
761         mac_cfg = 0;
762         netxen_xg_soft_reset(mac_cfg);
763         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_CONFIG_0,
764                                    &mac_cfg, 4))
765                 return -EIO;
766         return 0;
767 }
768
769 /* Set promiscuous mode for a GbE interface */
770 int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port,
771                                     netxen_niu_prom_mode_t mode)
772 {
773         __u32 reg;
774
775         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
776                 return -EINVAL;
777
778         /* save previous contents */
779         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
780                                   &reg, 4))
781                 return -EIO;
782         if (mode == NETXEN_NIU_PROMISC_MODE) {
783                 switch (port) {
784                 case 0:
785                         netxen_clear_gb_drop_gb0(reg);
786                         break;
787                 case 1:
788                         netxen_clear_gb_drop_gb1(reg);
789                         break;
790                 case 2:
791                         netxen_clear_gb_drop_gb2(reg);
792                         break;
793                 case 3:
794                         netxen_clear_gb_drop_gb3(reg);
795                         break;
796                 default:
797                         return -EIO;
798                 }
799         } else {
800                 switch (port) {
801                 case 0:
802                         netxen_set_gb_drop_gb0(reg);
803                         break;
804                 case 1:
805                         netxen_set_gb_drop_gb1(reg);
806                         break;
807                 case 2:
808                         netxen_set_gb_drop_gb2(reg);
809                         break;
810                 case 3:
811                         netxen_set_gb_drop_gb3(reg);
812                         break;
813                 default:
814                         return -EIO;
815                 }
816         }
817         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
818                                    &reg, 4))
819                 return -EIO;
820         return 0;
821 }
822
823 /*
824  * Set the MAC address for an XG port
825  * Note that the passed-in value must already be in network byte order.
826  */
827 int netxen_niu_xg_macaddr_set(struct netxen_port *port,
828                               netxen_ethernet_macaddr_t addr)
829 {
830         u8 temp[4];
831         u32 val;
832         struct netxen_adapter *adapter = port->adapter;
833
834         temp[0] = temp[1] = 0;
835         memcpy(temp + 2, addr, 2);
836         val = le32_to_cpu(*(__le32 *)temp);
837         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
838                                    &val, 4))
839                 return -EIO;
840
841         memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
842         val = le32_to_cpu(*(__le32 *)temp);
843         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
844                                    &val, 4))
845                 return -EIO;
846
847         return 0;
848 }
849
850 /*
851  * Return the current station MAC address.
852  * Note that the passed-in value must already be in network byte order.
853  */
854 int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int phy,
855                               netxen_ethernet_macaddr_t * addr)
856 {
857         u32 stationhigh;
858         u32 stationlow;
859         u8 val[8];
860
861         if (addr == NULL)
862                 return -EINVAL;
863         if (phy != 0)
864                 return -EINVAL;
865
866         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
867                                   &stationhigh, 4))
868                 return -EIO;
869         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
870                                   &stationlow, 4))
871                 return -EIO;
872         ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
873         ((__le32 *)val)[0] = cpu_to_le32(stationlow);
874
875         memcpy(addr, val + 2, 6);
876
877         return 0;
878 }
879
880 int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
881                                        int port, netxen_niu_prom_mode_t mode)
882 {
883         __u32 reg;
884
885         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
886                 return -EINVAL;
887
888         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_XGE_CONFIG_1, &reg, 4))
889                 return -EIO;
890         if (mode == NETXEN_NIU_PROMISC_MODE)
891                 reg = (reg | 0x2000UL);
892         else
893                 reg = (reg & ~0x2000UL);
894
895         netxen_crb_writelit_adapter(adapter, NETXEN_NIU_XGE_CONFIG_1, reg);
896
897         return 0;
898 }