?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC66 3.0.0.4.374.130 core
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / drivers / net / netxen / netxen_nic_ethtool.c
blob0175f6c353f625d732a1ac08e4e5392346578cfc
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 * ethtool support for netxen nic
31 *
32 */
33
34 #include <linux/types.h>
35 #include <linux/delay.h>
36 #include <asm/uaccess.h>
37 #include <linux/pci.h>
38 #include <asm/io.h>
39 #include <linux/netdevice.h>
40 #include <linux/ethtool.h>
41 #include <linux/version.h>
42
43 #include "netxen_nic.h"
44 #include "netxen_nic_hw.h"
45 #include "netxen_nic_phan_reg.h"
46
47 struct netxen_nic_stats {
48 char stat_string[ETH_GSTRING_LEN];
49 int sizeof_stat;
50 int stat_offset;
51 };
52
53 #define NETXEN_NIC_STAT(m) sizeof(((struct netxen_adapter *)0)->m), \
54 offsetof(struct netxen_adapter, m)
55
56 #define NETXEN_NIC_PORT_WINDOW 0x10000
57 #define NETXEN_NIC_INVALID_DATA 0xDEADBEEF
58
59 static const struct netxen_nic_stats netxen_nic_gstrings_stats[] = {
60 {"rcvd_bad_skb", NETXEN_NIC_STAT(stats.rcvdbadskb)},
61 {"xmit_called", NETXEN_NIC_STAT(stats.xmitcalled)},
62 {"xmited_frames", NETXEN_NIC_STAT(stats.xmitedframes)},
63 {"xmit_finished", NETXEN_NIC_STAT(stats.xmitfinished)},
64 {"bad_skb_len", NETXEN_NIC_STAT(stats.badskblen)},
65 {"no_cmd_desc", NETXEN_NIC_STAT(stats.nocmddescriptor)},
66 {"polled", NETXEN_NIC_STAT(stats.polled)},
67 {"uphappy", NETXEN_NIC_STAT(stats.uphappy)},
68 {"updropped", NETXEN_NIC_STAT(stats.updropped)},
69 {"uplcong", NETXEN_NIC_STAT(stats.uplcong)},
70 {"uphcong", NETXEN_NIC_STAT(stats.uphcong)},
71 {"upmcong", NETXEN_NIC_STAT(stats.upmcong)},
72 {"updunno", NETXEN_NIC_STAT(stats.updunno)},
73 {"skb_freed", NETXEN_NIC_STAT(stats.skbfreed)},
74 {"tx_dropped", NETXEN_NIC_STAT(stats.txdropped)},
75 {"tx_null_skb", NETXEN_NIC_STAT(stats.txnullskb)},
76 {"csummed", NETXEN_NIC_STAT(stats.csummed)},
77 {"no_rcv", NETXEN_NIC_STAT(stats.no_rcv)},
78 {"rx_bytes", NETXEN_NIC_STAT(stats.rxbytes)},
79 {"tx_bytes", NETXEN_NIC_STAT(stats.txbytes)},
80 };
81
82 #define NETXEN_NIC_STATS_LEN ARRAY_SIZE(netxen_nic_gstrings_stats)
83
84 static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
85 "Register_Test_on_offline",
86 "Link_Test_on_offline"
87 };
88
89 #define NETXEN_NIC_TEST_LEN sizeof(netxen_nic_gstrings_test) / ETH_GSTRING_LEN
90
91 #define NETXEN_NIC_REGS_COUNT 42
92 #define NETXEN_NIC_REGS_LEN (NETXEN_NIC_REGS_COUNT * sizeof(__le32))
93 #define NETXEN_MAX_EEPROM_LEN 1024
94
95 static int netxen_nic_get_eeprom_len(struct net_device *dev)
96 {
97 return NETXEN_FLASH_TOTAL_SIZE;
98 }
99
100 static void
101 netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
102 {
103 struct netxen_adapter *adapter = netdev_priv(dev);
104 u32 fw_major = 0;
105 u32 fw_minor = 0;
106 u32 fw_build = 0;
107
108 strncpy(drvinfo->driver, netxen_nic_driver_name, 32);
109 strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32);
110 fw_major = readl(NETXEN_CRB_NORMALIZE(adapter,
111 NETXEN_FW_VERSION_MAJOR));
112 fw_minor = readl(NETXEN_CRB_NORMALIZE(adapter,
113 NETXEN_FW_VERSION_MINOR));
114 fw_build = readl(NETXEN_CRB_NORMALIZE(adapter, NETXEN_FW_VERSION_SUB));
115 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
116
117 strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
118 drvinfo->n_stats = NETXEN_NIC_STATS_LEN;
119 drvinfo->testinfo_len = NETXEN_NIC_TEST_LEN;
120 drvinfo->regdump_len = NETXEN_NIC_REGS_LEN;
121 drvinfo->eedump_len = netxen_nic_get_eeprom_len(dev);
122 }
123
124 static int
125 netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
126 {
127 struct netxen_adapter *adapter = netdev_priv(dev);
128 struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg;
129
130 /* read which mode */
131 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
132 ecmd->supported = (SUPPORTED_10baseT_Half |
133 SUPPORTED_10baseT_Full |
134 SUPPORTED_100baseT_Half |
135 SUPPORTED_100baseT_Full |
136 SUPPORTED_1000baseT_Half |
137 SUPPORTED_1000baseT_Full);
138
139 ecmd->advertising = (ADVERTISED_100baseT_Half |
140 ADVERTISED_100baseT_Full |
141 ADVERTISED_1000baseT_Half |
142 ADVERTISED_1000baseT_Full);
143
144 ecmd->port = PORT_TP;
145
146 if (netif_running(dev)) {
147 ecmd->speed = adapter->link_speed;
148 ecmd->duplex = adapter->link_duplex;
149 } else
150 return -EIO; /* link absent */
151 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
152 ecmd->supported = (SUPPORTED_TP |
153 SUPPORTED_1000baseT_Full |
154 SUPPORTED_10000baseT_Full);
155 ecmd->advertising = (ADVERTISED_TP |
156 ADVERTISED_1000baseT_Full |
157 ADVERTISED_10000baseT_Full);
158 ecmd->port = PORT_TP;
159
160 ecmd->speed = SPEED_10000;
161 ecmd->duplex = DUPLEX_FULL;
162 ecmd->autoneg = AUTONEG_DISABLE;
163 } else
164 return -EIO;
165
166 ecmd->phy_address = adapter->portnum;
167 ecmd->transceiver = XCVR_EXTERNAL;
168
169 switch ((netxen_brdtype_t) boardinfo->board_type) {
170 case NETXEN_BRDTYPE_P2_SB35_4G:
171 case NETXEN_BRDTYPE_P2_SB31_2G:
172 ecmd->supported |= SUPPORTED_Autoneg;
173 ecmd->advertising |= ADVERTISED_Autoneg;
174 case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
175 ecmd->supported |= SUPPORTED_TP;
176 ecmd->advertising |= ADVERTISED_TP;
177 ecmd->port = PORT_TP;
178 ecmd->autoneg = (boardinfo->board_type ==
179 NETXEN_BRDTYPE_P2_SB31_10G_CX4) ?
180 (AUTONEG_DISABLE) : (adapter->link_autoneg);
181 break;
182 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
183 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
184 ecmd->supported |= SUPPORTED_MII;
185 ecmd->advertising |= ADVERTISED_MII;
186 ecmd->port = PORT_FIBRE;
187 ecmd->autoneg = AUTONEG_DISABLE;
188 break;
189 case NETXEN_BRDTYPE_P2_SB31_10G:
190 ecmd->supported |= SUPPORTED_FIBRE;
191 ecmd->advertising |= ADVERTISED_FIBRE;
192 ecmd->port = PORT_FIBRE;
193 ecmd->autoneg = AUTONEG_DISABLE;
194 break;
195 default:
196 printk(KERN_ERR "netxen-nic: Unsupported board model %d\n",
197 (netxen_brdtype_t) boardinfo->board_type);
198 return -EIO;
199 }
200
201 return 0;
202 }
203
204 static int
205 netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
206 {
207 struct netxen_adapter *adapter = netdev_priv(dev);
208 __u32 status;
209
210 /* read which mode */
211 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
212 /* autonegotiation */
213 if (adapter->phy_write
214 && adapter->phy_write(adapter,
215 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
216 ecmd->autoneg) != 0)
217 return -EIO;
218 else
219 adapter->link_autoneg = ecmd->autoneg;
220
221 if (adapter->phy_read
222 && adapter->phy_read(adapter,
223 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
224 &status) != 0)
225 return -EIO;
226
227 /* speed */
228 switch (ecmd->speed) {
229 case SPEED_10:
230 netxen_set_phy_speed(status, 0);
231 break;
232 case SPEED_100:
233 netxen_set_phy_speed(status, 1);
234 break;
235 case SPEED_1000:
236 netxen_set_phy_speed(status, 2);
237 break;
238 }
239 /* set duplex mode */
240 if (ecmd->duplex == DUPLEX_HALF)
241 netxen_clear_phy_duplex(status);
242 if (ecmd->duplex == DUPLEX_FULL)
243 netxen_set_phy_duplex(status);
244 if (adapter->phy_write
245 && adapter->phy_write(adapter,
246 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
247 *((int *)&status)) != 0)
248 return -EIO;
249 else {
250 adapter->link_speed = ecmd->speed;
251 adapter->link_duplex = ecmd->duplex;
252 }
253 } else
254 return -EOPNOTSUPP;
255
256 if (netif_running(dev)) {
257 dev->stop(dev);
258 dev->open(dev);
259 }
260 return 0;
261 }
262
263 static int netxen_nic_get_regs_len(struct net_device *dev)
264 {
265 return NETXEN_NIC_REGS_LEN;
266 }
267
268 struct netxen_niu_regs {
269 __u32 reg[NETXEN_NIC_REGS_COUNT];
270 };
271
272 static struct netxen_niu_regs niu_registers[] = {
273 {
274 /* GB Mode */
275 {
276 NETXEN_NIU_GB_SERDES_RESET,
277 NETXEN_NIU_GB0_MII_MODE,
278 NETXEN_NIU_GB1_MII_MODE,
279 NETXEN_NIU_GB2_MII_MODE,
280 NETXEN_NIU_GB3_MII_MODE,
281 NETXEN_NIU_GB0_GMII_MODE,
282 NETXEN_NIU_GB1_GMII_MODE,
283 NETXEN_NIU_GB2_GMII_MODE,
284 NETXEN_NIU_GB3_GMII_MODE,
285 NETXEN_NIU_REMOTE_LOOPBACK,
286 NETXEN_NIU_GB0_HALF_DUPLEX,
287 NETXEN_NIU_GB1_HALF_DUPLEX,
288 NETXEN_NIU_RESET_SYS_FIFOS,
289 NETXEN_NIU_GB_CRC_DROP,
290 NETXEN_NIU_GB_DROP_WRONGADDR,
291 NETXEN_NIU_TEST_MUX_CTL,
292
293 NETXEN_NIU_GB_MAC_CONFIG_0(0),
294 NETXEN_NIU_GB_MAC_CONFIG_1(0),
295 NETXEN_NIU_GB_HALF_DUPLEX_CTRL(0),
296 NETXEN_NIU_GB_MAX_FRAME_SIZE(0),
297 NETXEN_NIU_GB_TEST_REG(0),
298 NETXEN_NIU_GB_MII_MGMT_CONFIG(0),
299 NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
300 NETXEN_NIU_GB_MII_MGMT_ADDR(0),
301 NETXEN_NIU_GB_MII_MGMT_CTRL(0),
302 NETXEN_NIU_GB_MII_MGMT_STATUS(0),
303 NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
304 NETXEN_NIU_GB_INTERFACE_CTRL(0),
305 NETXEN_NIU_GB_INTERFACE_STATUS(0),
306 NETXEN_NIU_GB_STATION_ADDR_0(0),
307 NETXEN_NIU_GB_STATION_ADDR_1(0),
308 -1,
309 }
310 },
311 {
312 /* XG Mode */
313 {
314 NETXEN_NIU_XG_SINGLE_TERM,
315 NETXEN_NIU_XG_DRIVE_HI,
316 NETXEN_NIU_XG_DRIVE_LO,
317 NETXEN_NIU_XG_DTX,
318 NETXEN_NIU_XG_DEQ,
319 NETXEN_NIU_XG_WORD_ALIGN,
320 NETXEN_NIU_XG_RESET,
321 NETXEN_NIU_XG_POWER_DOWN,
322 NETXEN_NIU_XG_RESET_PLL,
323 NETXEN_NIU_XG_SERDES_LOOPBACK,
324 NETXEN_NIU_XG_DO_BYTE_ALIGN,
325 NETXEN_NIU_XG_TX_ENABLE,
326 NETXEN_NIU_XG_RX_ENABLE,
327 NETXEN_NIU_XG_STATUS,
328 NETXEN_NIU_XG_PAUSE_THRESHOLD,
329 NETXEN_NIU_XGE_CONFIG_0,
330 NETXEN_NIU_XGE_CONFIG_1,
331 NETXEN_NIU_XGE_IPG,
332 NETXEN_NIU_XGE_STATION_ADDR_0_HI,
333 NETXEN_NIU_XGE_STATION_ADDR_0_1,
334 NETXEN_NIU_XGE_STATION_ADDR_1_LO,
335 NETXEN_NIU_XGE_STATUS,
336 NETXEN_NIU_XGE_MAX_FRAME_SIZE,
337 NETXEN_NIU_XGE_PAUSE_FRAME_VALUE,
338 NETXEN_NIU_XGE_TX_BYTE_CNT,
339 NETXEN_NIU_XGE_TX_FRAME_CNT,
340 NETXEN_NIU_XGE_RX_BYTE_CNT,
341 NETXEN_NIU_XGE_RX_FRAME_CNT,
342 NETXEN_NIU_XGE_AGGR_ERROR_CNT,
343 NETXEN_NIU_XGE_MULTICAST_FRAME_CNT,
344 NETXEN_NIU_XGE_UNICAST_FRAME_CNT,
345 NETXEN_NIU_XGE_CRC_ERROR_CNT,
346 NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
347 NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
348 NETXEN_NIU_XGE_LOCAL_ERROR_CNT,
349 NETXEN_NIU_XGE_REMOTE_ERROR_CNT,
350 NETXEN_NIU_XGE_CONTROL_CHAR_CNT,
351 NETXEN_NIU_XGE_PAUSE_FRAME_CNT,
352 -1,
353 }
354 }
355 };
356
357 static void
358 netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
359 {
360 struct netxen_adapter *adapter = netdev_priv(dev);
361 __u32 mode, *regs_buff = p;
362 void __iomem *addr;
363 int i, window;
364
365 memset(p, 0, NETXEN_NIC_REGS_LEN);
366 regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
367 (adapter->pdev)->device;
368 /* which mode */
369 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_MODE, &regs_buff[0]);
370 mode = regs_buff[0];
371
372 /* Common registers to all the modes */
373 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER,
374 &regs_buff[2]);
375 /* GB/XGB Mode */
376 mode = (mode / 2) - 1;
377 window = 0;
378 if (mode <= 1) {
379 for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
380 /* GB: port specific registers */
381 if (mode == 0 && i >= 19)
382 window = physical_port[adapter->portnum] *
383 NETXEN_NIC_PORT_WINDOW;
384
385 NETXEN_NIC_LOCKED_READ_REG(niu_registers[mode].
386 reg[i - 3] + window,
387 &regs_buff[i]);
388 }
389
390 }
391 }
392
393 static u32 netxen_nic_test_link(struct net_device *dev)
394 {
395 struct netxen_adapter *adapter = netdev_priv(dev);
396 __u32 status;
397 int val;
398
399 /* read which mode */
400 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
401 if (adapter->phy_read
402 && adapter->phy_read(adapter,
403 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
404 &status) != 0)
405 return -EIO;
406 else {
407 val = netxen_get_phy_link(status);
408 return !val;
409 }
410 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
411 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
412 return (val == XG_LINK_UP) ? 0 : 1;
413 }
414 return -EIO;
415 }
416
417 static int
418 netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
419 u8 * bytes)
420 {
421 struct netxen_adapter *adapter = netdev_priv(dev);
422 int offset;
423 int ret;
424
425 if (eeprom->len == 0)
426 return -EINVAL;
427
428 eeprom->magic = (adapter->pdev)->vendor |
429 ((adapter->pdev)->device << 16);
430 offset = eeprom->offset;
431
432 ret = netxen_rom_fast_read_words(adapter, offset, bytes,
433 eeprom->len);
434 if (ret < 0)
435 return ret;
436
437 return 0;
438 }
439
440 static int
441 netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
442 u8 * bytes)
443 {
444 struct netxen_adapter *adapter = netdev_priv(dev);
445 int offset = eeprom->offset;
446 static int flash_start;
447 static int ready_to_flash;
448 int ret;
449
450 if (flash_start == 0) {
451 netxen_halt_pegs(adapter);
452 ret = netxen_flash_unlock(adapter);
453 if (ret < 0) {
454 printk(KERN_ERR "%s: Flash unlock failed.\n",
455 netxen_nic_driver_name);
456 return ret;
457 }
458 printk(KERN_INFO "%s: flash unlocked. \n",
459 netxen_nic_driver_name);
460 last_schedule_time = jiffies;
461 ret = netxen_flash_erase_secondary(adapter);
462 if (ret != FLASH_SUCCESS) {
463 printk(KERN_ERR "%s: Flash erase failed.\n",
464 netxen_nic_driver_name);
465 return ret;
466 }
467 printk(KERN_INFO "%s: secondary flash erased successfully.\n",
468 netxen_nic_driver_name);
469 flash_start = 1;
470 return 0;
471 }
472
473 if (offset == NETXEN_BOOTLD_START) {
474 ret = netxen_flash_erase_primary(adapter);
475 if (ret != FLASH_SUCCESS) {
476 printk(KERN_ERR "%s: Flash erase failed.\n",
477 netxen_nic_driver_name);
478 return ret;
479 }
480
481 ret = netxen_rom_se(adapter, NETXEN_USER_START);
482 if (ret != FLASH_SUCCESS)
483 return ret;
484 ret = netxen_rom_se(adapter, NETXEN_FIXED_START);
485 if (ret != FLASH_SUCCESS)
486 return ret;
487
488 printk(KERN_INFO "%s: primary flash erased successfully\n",
489 netxen_nic_driver_name);
490
491 ret = netxen_backup_crbinit(adapter);
492 if (ret != FLASH_SUCCESS) {
493 printk(KERN_ERR "%s: CRBinit backup failed.\n",
494 netxen_nic_driver_name);
495 return ret;
496 }
497 printk(KERN_INFO "%s: CRBinit backup done.\n",
498 netxen_nic_driver_name);
499 ready_to_flash = 1;
500 }
501
502 if (!ready_to_flash) {
503 printk(KERN_ERR "%s: Invalid write sequence, returning...\n",
504 netxen_nic_driver_name);
505 return -EINVAL;
506 }
507
508 return netxen_rom_fast_write_words(adapter, offset, bytes, eeprom->len);
509 }
510
511 static void
512 netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
513 {
514 struct netxen_adapter *adapter = netdev_priv(dev);
515 int i;
516
517 ring->rx_pending = 0;
518 ring->rx_jumbo_pending = 0;
519 for (i = 0; i < MAX_RCV_CTX; ++i) {
520 ring->rx_pending += adapter->recv_ctx[i].
521 rcv_desc[RCV_DESC_NORMAL_CTXID].rcv_pending;
522 ring->rx_jumbo_pending += adapter->recv_ctx[i].
523 rcv_desc[RCV_DESC_JUMBO_CTXID].rcv_pending;
524 }
525
526 ring->rx_max_pending = adapter->max_rx_desc_count;
527 ring->tx_max_pending = adapter->max_tx_desc_count;
528 ring->rx_jumbo_max_pending = adapter->max_jumbo_rx_desc_count;
529 ring->rx_mini_max_pending = 0;
530 ring->rx_mini_pending = 0;
531 ring->rx_jumbo_pending = 0;
532 }
533
534 static void
535 netxen_nic_get_pauseparam(struct net_device *dev,
536 struct ethtool_pauseparam *pause)
537 {
538 struct netxen_adapter *adapter = netdev_priv(dev);
539 __u32 val;
540 int port = physical_port[adapter->portnum];
541
542 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
543 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
544 return;
545 /* get flow control settings */
546 netxen_nic_read_w0(adapter,NETXEN_NIU_GB_MAC_CONFIG_0(port),
547 &val);
548 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
549 netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
550 switch (port) {
551 case 0:
552 pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
553 break;
554 case 1:
555 pause->tx_pause = !(netxen_gb_get_gb1_mask(val));
556 break;
557 case 2:
558 pause->tx_pause = !(netxen_gb_get_gb2_mask(val));
559 break;
560 case 3:
561 default:
562 pause->tx_pause = !(netxen_gb_get_gb3_mask(val));
563 break;
564 }
565 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
566 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
567 return;
568 pause->rx_pause = 1;
569 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
570 if (port == 0)
571 pause->tx_pause = !(netxen_xg_get_xg0_mask(val));
572 else
573 pause->tx_pause = !(netxen_xg_get_xg1_mask(val));
574 } else {
575 printk(KERN_ERR"%s: Unknown board type: %x\n",
576 netxen_nic_driver_name, adapter->ahw.board_type);
577 }
578 }
579
580 static int
581 netxen_nic_set_pauseparam(struct net_device *dev,
582 struct ethtool_pauseparam *pause)
583 {
584 struct netxen_adapter *adapter = netdev_priv(dev);
585 __u32 val;
586 int port = physical_port[adapter->portnum];
587 /* read mode */
588 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
589 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
590 return -EIO;
591 /* set flow control */
592 netxen_nic_read_w0(adapter,
593 NETXEN_NIU_GB_MAC_CONFIG_0(port), &val);
594
595 if (pause->rx_pause)
596 netxen_gb_rx_flowctl(val);
597 else
598 netxen_gb_unset_rx_flowctl(val);
599
600 netxen_nic_write_w0(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
601 val);
602 /* set autoneg */
603 netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
604 switch (port) {
605 case 0:
606 if (pause->tx_pause)
607 netxen_gb_unset_gb0_mask(val);
608 else
609 netxen_gb_set_gb0_mask(val);
610 break;
611 case 1:
612 if (pause->tx_pause)
613 netxen_gb_unset_gb1_mask(val);
614 else
615 netxen_gb_set_gb1_mask(val);
616 break;
617 case 2:
618 if (pause->tx_pause)
619 netxen_gb_unset_gb2_mask(val);
620 else
621 netxen_gb_set_gb2_mask(val);
622 break;
623 case 3:
624 default:
625 if (pause->tx_pause)
626 netxen_gb_unset_gb3_mask(val);
627 else
628 netxen_gb_set_gb3_mask(val);
629 break;
630 }
631 netxen_nic_write_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
632 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
633 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
634 return -EIO;
635 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
636 if (port == 0) {
637 if (pause->tx_pause)
638 netxen_xg_unset_xg0_mask(val);
639 else
640 netxen_xg_set_xg0_mask(val);
641 } else {
642 if (pause->tx_pause)
643 netxen_xg_unset_xg1_mask(val);
644 else
645 netxen_xg_set_xg1_mask(val);
646 }
647 netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);
648 } else {
649 printk(KERN_ERR "%s: Unknown board type: %x\n",
650 netxen_nic_driver_name,
651 adapter->ahw.board_type);
652 }
653 return 0;
654 }
655
656 static int netxen_nic_reg_test(struct net_device *dev)
657 {
658 struct netxen_adapter *adapter = netdev_priv(dev);
659 u32 data_read, data_written;
660
661 netxen_nic_read_w0(adapter, NETXEN_PCIX_PH_REG(0), &data_read);
662 if ((data_read & 0xffff) != PHAN_VENDOR_ID)
663 return 1;
664
665 data_written = (u32)0xa5a5a5a5;
666
667 netxen_nic_reg_write(adapter, CRB_SCRATCHPAD_TEST, data_written);
668 data_read = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_SCRATCHPAD_TEST));
669 if (data_written != data_read)
670 return 1;
671
672 return 0;
673 }
674
675 static int netxen_nic_diag_test_count(struct net_device *dev)
676 {
677 return NETXEN_NIC_TEST_LEN;
678 }
679
680 static void
681 netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
682 u64 * data)
683 {
684 memset(data, 0, sizeof(uint64_t) * NETXEN_NIC_TEST_LEN);
685 if ((data[0] = netxen_nic_reg_test(dev)))
686 eth_test->flags |= ETH_TEST_FL_FAILED;
687 /* link test */
688 if ((data[1] = (u64) netxen_nic_test_link(dev)))
689 eth_test->flags |= ETH_TEST_FL_FAILED;
690 }
691
692 static void
693 netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
694 {
695 int index;
696
697 switch (stringset) {
698 case ETH_SS_TEST:
699 memcpy(data, *netxen_nic_gstrings_test,
700 NETXEN_NIC_TEST_LEN * ETH_GSTRING_LEN);
701 break;
702 case ETH_SS_STATS:
703 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
704 memcpy(data + index * ETH_GSTRING_LEN,
705 netxen_nic_gstrings_stats[index].stat_string,
706 ETH_GSTRING_LEN);
707 }
708 break;
709 }
710 }
711
712 static int netxen_nic_get_stats_count(struct net_device *dev)
713 {
714 return NETXEN_NIC_STATS_LEN;
715 }
716
717 static void
718 netxen_nic_get_ethtool_stats(struct net_device *dev,
719 struct ethtool_stats *stats, u64 * data)
720 {
721 struct netxen_adapter *adapter = netdev_priv(dev);
722 int index;
723
724 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
725 char *p =
726 (char *)adapter +
727 netxen_nic_gstrings_stats[index].stat_offset;
728 data[index] =
729 (netxen_nic_gstrings_stats[index].sizeof_stat ==
730 sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
731 }
732 }
733
734 struct ethtool_ops netxen_nic_ethtool_ops = {
735 .get_settings = netxen_nic_get_settings,
736 .set_settings = netxen_nic_set_settings,
737 .get_drvinfo = netxen_nic_get_drvinfo,
738 .get_regs_len = netxen_nic_get_regs_len,
739 .get_regs = netxen_nic_get_regs,
740 .get_link = ethtool_op_get_link,
741 .get_eeprom_len = netxen_nic_get_eeprom_len,
742 .get_eeprom = netxen_nic_get_eeprom,
743 .set_eeprom = netxen_nic_set_eeprom,
744 .get_ringparam = netxen_nic_get_ringparam,
745 .get_pauseparam = netxen_nic_get_pauseparam,
746 .set_pauseparam = netxen_nic_set_pauseparam,
747 .get_tx_csum = ethtool_op_get_tx_csum,
748 .set_tx_csum = ethtool_op_set_tx_csum,
749 .get_sg = ethtool_op_get_sg,
750 .set_sg = ethtool_op_set_sg,
751 .get_tso = ethtool_op_get_tso,
752 .set_tso = ethtool_op_set_tso,
753 .self_test_count = netxen_nic_diag_test_count,
754 .self_test = netxen_nic_diag_test,
755 .get_strings = netxen_nic_get_strings,
756 .get_stats_count = netxen_nic_get_stats_count,
757 .get_ethtool_stats = netxen_nic_get_ethtool_stats,
758 .get_perm_addr = ethtool_op_get_perm_addr,
759 };
Tomato firmware and modifications.