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