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