?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libertas: convert SNMP_MIB to a direct command
[linux/fpc-iii.git] / drivers / net / netxen / netxen_nic_niu.c
blob27f07f6a45b1229f8a53afd8c4026f59bbcdb055
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 }
Linux with added FPC-III support